שאלות ראיון ותשובות לראיונות בפריץ

I have posted a lot of Spring Tutorials recently. This post will help you get through Spring interview Questions explaining the core concepts in detail.

הגיבוי של האביב הוא אחד מהפריימוורקים הפופולריים ביותר ב-Java EE עבור אפליקציות אינטרנט. הזרמפות תלויות ותכנות ממוקד ברזולוציה נמצאים בלב הפריימוורק של Spring. אם אתה טוב בפריימוורק של האביב, הסיכויים להתקבל ממש גבוהים בראיונות ב-Java.

טיפ מקצועי: ג'אווה קור הוא בסיס הפריימוורקים המבוססים על ג'אווה, אז אם אתה מתכונן לראיונות, אני ממליץ לעבור על שאלות הראיון בג'אווה הבסיסיות ועל מאמרי שאלות הראיון בג'אווה.שאלות הראיון ב-Java

שאלות ראיון ותשובות בנושא האביב

כאן אני מספק כמעט 50 שאלות ראיון על האביב ותשובותיהן. המידע עודכן עד Spring 5, כך שהוא מכסה את כל התכונות העדכניות כגון האביב WebFlux לתכנות ריאקטיבי.

1. מהו Spring Framework?

Spring הוא אחד מסגנונות Java EE הנפוצים ביותר. העקרונות היסודיים של מסגנון העבודה של Spring הם "הזרמת תלות" ו"תכנות מונחה לאספקטים".

ניתן להשתמש ב Spring גם ביישומים רגילים של Java כדי להשיג פתיחות קטנה בין רכיבים שונים על ידי הטמעת הזרמת תלות. ניתן לבצע משימות חוצות כגון תיעוד ואימות באמצעות תמיכת Spring בתכנות מונחה לאספקטים.

I like spring because it provides a lot of features and different modules for specific tasks such as Spring MVC and Spring JDBC. Since it’s an open-source framework with a lot of online resources and active community members, working with the Spring framework is easy and fun at the same time.

קרא נוסף: Spring Framework

2. מהם כמה מהתכונות החשובות של Spring Framework?

Spring Framework מבוסס על שני עקרונות עיצוב – הזרמת תלות ותכנות מונחה לאספקטים.

כמה מהתכונות של Spring Framework הם:

• קל משקל ומעט הערכה מול שימוש במסגנון לפיתוח שלנו.
• הזרמת תלות או הפוך של בקרה לכתיבת רכיבים שאינם תלויים זה בזה, מחזיק Spring בתיקון מהם להשיג את העבודה שלנו.
• מנהל ה- Spring IoC מנהל את מחזור החיים של סוגי ה- Spring Bean והגדרות התצורה של פרויקט כמו חיפוש JNDI.
• מסגרת Spring MVC ניתן להשתמש בה ליצירת אפליקציות ווב וגם שירותי רשת Restful המסוגלים להחזיר תגובת XML ותגובת JSON.
• תמיכה בניהול עסקאות, פעולות JDBC, העלאת קבצים, טיפול בשגיאות וכו' עם מספר קונפיגורציות פשוטות, באמצעות הוספת הערות או קובץ תצורת Bean של Spring.

3. מהי היתרון בשימוש ב- Spring Framework?

כמה מהיתרונות בשימוש ב- Spring Framework הם:

• ירידה בתלות ישירה בין רכיבים שונים של היישום. מנהל ה- Spring IoC אחראי לאתחול משאבים או רכיבים ולהחדרתם כתלות.
• כתיבת בדיקות יחידה פשוטה במסגרת Spring מכיוון שהלוגיקה העסקית שלנו אין לה תלות ישירה עם מחלקות המימוש של המשאבים האמיתיים. באפשרותנו לכתוב בקונפיגורציה לבדיקות ולהחדיר את הרכיבים המוקים שלנו לצורך בדיקות.
• ירידה בכמות הקוד המיותר, כמו אתחול אובייקטים ופתיחה / סגירה של משאבים. אני אוהב מחלקה כמו JdbcTemplate מאוד מאחר והיא עוזרת לנו להעיר את כל הקוד המיותר שמגיע עם תכנות JDBC.
• פריימוורק של Spring מתחלק למספר מודולים שונים, וזה עוזר לנו לשמור על יישום היישום שלנו קל משקל. לדוגמה, אם אנחנו לא זקוקים לתכונות ניהול העברות של Spring, אנחנו לא צריכים להוסיף את התלות הזו לפרויקט שלנו.
• פריימוורק של Spring תומך ברוב התכונות של Java EE ואפילו יותר. הוא תמיד מוביל בטכנולוגיות החדשות, לדוגמה, יש פרויקט של Spring עבור אנדרואיד שעוזר לנו לכתוב קוד טוב יותר ליישומים טבעיים של אנדרואיד. זה מפקח על הפריימוורק של Spring חבילה מלאה ואנחנו לא צריכים לחפש אחר פריימוורקים שונים עבור דרישות שונות.

4. מהם התכונות החשובות של Spring 5?

Spring 5 הוא שדרוג עיקרי מ-Spring 4. כמה מהתכונות החשובות הן:

• תמיכה ב-Java 8 וגרסאות גבוהות יותר, כך שאנחנו יכולים להשתמש בביטויים למבדר.
• תמיכה ב-Java EE7 ובמפרט Servlet 4.0.
• פעולות קובץ מבוצעות כעת דרך נפחי NIO 2, שיפור ענק אם היישום שלך עושה הרבה טיפולי קבצים.
• הכנת פרויקט של spring-jcl לסדר את הלוגים, עד כה זה היה כאוב מאחר ואין נקודה יחידה לצורך לוגים.
• תמיכה ב-Kotlin, Lombok, Reactor 3.1 Flux, ו-Mono, וגם ב-RxJava.
• Spring WebFlux שמביא תכנות ריאקטיבי ל-Spring.
• תמיכה ב-JUnit 5
• תמיכה בספק מידע על רכיבי Spring דרך קובץ אינדקס "META-INF/spring.components" במקום סריקה ב-Classpath.

אנא עבור על תכונות Spring 5 כדי לקבל סקירה מפורטת של הגרסה הזו.

5. מהו Spring WebFlux?

Spring WebFlux הוא המודול החדש שהוצג ב-Spring 5. Spring WebFlux הוא הצעד הראשון לעבר דגם התכנות הריאקטיבי במסגרת ה-Spring.

Spring WebFlux הוא אלטרנטיבה למודול Spring MVC. Spring WebFlux משמש ליצירת אפליקציה לגמרי אסינכרונית ובלתי חוסמת הנבנית על דגם הביצועים של לולאת האירועים.

ניתן לקרוא עוד על זה ב-מדריך Spring WebFlux.

6. מהו הבנת הזרם (Dependency Injection)?

דפוס העיצוב של הזרם (Dependency Injection) מאפשר לנו להסיר את התלות הקשה בקוד ולהפוך את האפליקציה שלנו לחיבור פחות צמוד, מרחיב וניתנת לתחזוקה. ניתן ליישם את דפוס ההזרם על מנת להעביר את ההתלות מזמן הקומפילציה לזמן הריצה.

כמה מהיתרונות של שימוש בהזנת תלות הם הפרדת דאגות, הפחתת קוד Boilerplate, רכיבים הניתנים להגדרה ובדיקות יחידה קלות.

קרא עוד ב- מדריך להזנת תלות. ניתן גם להשתמש ב- Google Guice להזנת תלות כדי לאוטומטизיר את תהליך ההזנת תלות. אך ברוב המקרים, אנו מחפשים יותר מהזנת תלות בלבד וזה המקום שבו Spring עולה לראש.

7. איך אנו מיישמים הזנת תלות בסביבת העבודה של Spring?

ניתן להשתמש בהגדרות מבוססות XML של Spring וגם בהגדרות באמצעות הערות כדי לממש הזנת תלות ביישומי Spring. להבנה טובה יותר, אנא קרא את דוגמת הזנת התלות של Spring בה אפשר ללמוד שתי הדרכים יחד עם מבחן JUnit. הפוסט מכיל גם קובץ פרויקט לדוגמה שאפשר להוריד ולשחק כדי ללמוד עוד.

8. מהם היתרונות של שימוש ב-Spring Tool Suite?

ניתן להתקין תוספים ל-Eclipse כדי לקבל את כל התכונות של Spring Tool Suite. אך, STS מגיע עם Eclipse עם מספר פריטים חשובים אחרים כמו תמיכה ב-Maven, תבניות ליצירת סוגים שונים של פרויקטי Spring, ושרת tc לביצועים טובים יותר עם יישומי Spring.

I like STS because it highlights the Spring components and if you are using AOP pointcuts and advice, then it clearly shows which methods will come under the specific pointcut. So rather than installing everything on our own, I prefer using STS when developing Spring-based applications.

9. ציין חלק מהמודולים החשובים של Spring?

חלק מהמודולים החשובים של מסגרת ה- Spring הם:

• Spring Context – להזנת תלות.
• Spring AOP – לתכנות המונחה לדברים.
• Spring DAO – לפעולות מסד נתונים באמצעות דפוס DAO.
• Spring JDBC – לתמיכה ב-JDBC וב-DataSource.
• Spring ORM – לתמיכה בכלי ORM כמו Hibernate
• מודול האינטרנט של Spring – ליצירת יישומי אינטרנט.
• Spring MVC – יישום של מודל-תצוגה-בקר עבור יצירת יישומי אינטרנט, שירותי רשת, וכו '.

מה אתה מבין על ידי תכנות מונה נגד רגע?

יישומי מערכת עסקיים מכילים מספר דאגות משותפות שניתן ליישם על אובייקטים שונים ומודוליי יישום, כגון רישום, ניהול עסקאות, אימות נתונים, אימות ועוד. המודולריות של היישום מושגת על ידי כיתות בתכנות עצמים. ב-AOP, המודולריות של היישום מושגת על ידי תכנונים והם מוגדרים כדי לחתוך דרך שונה של שיטות מחלקות.

ה-AOP מסירה את התלות הישירה של משימות חותכות מחודש ממחלקות שאינן אפשריות בתכנות עצמים רגיל. לדוגמה, ניתן להגדיר מחלקה נפרדת לרישום אך המחלקות האחרות יצטרכו לקרוא אלה שיטות. אך, ב-AOP אנו מגדירים את התכנונים והרצת השיטות מתרחשת באופן אוטומטי. קרא עוד על תמיכת Spring AOP ב-דוגמת Spring AOP.

11. מהו תכנון, ייעוץ, נקודת חיתוך, נקודת הצטרפות ופרמטרי ייעוץ ב-AOP?

נקודת מבט: נקודת מבט היא מחלקה שמיישמת תחומים חותכים, כמו ניהול עסקאות. נקודות מבט יכולות להיות מחלקה רגילה המוגדרת ואז מוגדרת בקובץ תצורת Spring Bean, או שניתן להשתמש בתמיכת Spring AspectJ להצהרת מחלקה כנקודת מבט באמצעות ההוספה של האונוטציה @Aspect.

עצה: עצה היא הפעולה שנעשית עבור נקודת ההצטרפות המסוימת. מבחינת תכנות, אלו הם שיטות שמתבצעות כאשר נקודת ההצטרפות מסוימת עם pointcut תואם מושגת באפליקציה. ניתן לראות בעצה כאינטרספטורים של Spring או פילטרים של Servlet.

Pointcut: Pointcuts הם ביטויים רגילים המתאימים לנקודות הצטרפות כדי לקבוע האם יש צורך לבצע עצה או לא. Pointcut משתמש בסוגים שונים של ביטויים המתאימים לנקודות הצטרפות. המסגרת של Spring משתמשת בשפת ביטויי AspectJ עבור קביעת נקודות הצטרפות שבהן יחולו שיטות עצה.

JoinPoint: נקודת הצטרפות היא נקודה מסוימת באפליקציה כמו ביצוע של שיטה, טיפול בחריגה, שינוי של ערך משתנה באובייקט, וכדומה. ב- Spring AOP, נקודת הצטרפות היא תמיד ביצוע של שיטה.

ארגומנטים לייעוץ: אנו יכולים להעביר ארגומנטים בשיטות הייעוץ. ניתן להשתמש בביטוי args() ב-npointcut להיממש בכל שיטה שתואמת את דפוס הארגומנטים. אם נעשה שימוש בזה, אז עלינו להשתמש באותו שם בשיטת הייעוץ ממנה נקבע סוג הארגומנט.

המושגים הללו נראים מבלבלים בתחילה, אך אם תעבר דרך Spring Aspect, Advice Example אז יהיה קל לקשר אליהם.

12. מה ההבדל בין Spring AOP ל-ApectJ AOP?

ApectJ היא המימוש התקני לתכנות מונחי, בעוד ש-Spring מיישם AOP למקרים מסוימים. ההבדלים העיקריים בין Spring AOP ו-ApectJ הם:

• Spring AOP פשוט יותר לשימוש מ-ApectJ מכיוון שאין צורך לדאוג לתהליך הסריגה.
• Spring AOP תומך באנוטציות של ApectJ, כך שאם אתה מוכר עם ApectJ אז העבודה עם Spring AOP היא יותר פשוטה.
• Spring AOP תומך רק ב-AOP המבוסס על פרוקסי, ולכן יכול להיממש רק בנקודות הצטרפות לביצוע של שיטות. ApectJ תומך בכל סוגי ה-pointcuts.
• אחת מחסרונות Spring AOP הוא שהוא יכול להיממש רק על הבונים שנוצרו דרך מצב ההקשר של Spring.

13. מהו Spring IoC Container?

ההיפוך של שליטה (IoC) הוא המנגנון להשיג קישור רפוי בין תלותי עצמים. כדי להשיג קישור רפוי וקישור דינמי של העצמים בזמן ריצה, העצמים מגדירים את תלותיהם שמיוחסות על ידי אובייקטי המכרכרים אחרים. מעצם ה- Spring IoC הוא התוכנה שמזריקה תלותים לתוך אובייקט ומכינה אותו לשימוש שלנו.

כיתות מנוע ה-IoC של מסגרת ה-Spring הן חלק מתיקיית org.springframework.beans ומתיקיית org.springframework.context ומספקות לנו דרכים שונות לפרידת התלותות בין העצמים.

חלק ממימושי המבנה של ApplicationContext שימושיים שאנו משתמשים בהם הם;

• AnnotationConfigApplicationContext: ליישומי Java עצמאיים בשימוש בהגדרות המבוססות על אנוטציות.
• ClassPathXmlApplicationContext: ליישומי Java עצמאיים בשימוש בהגדרות מבוססות על XML.
• FileSystemXmlApplicationContext: דומה ל-ClassPathXmlApplicationContext רק שניתן לטעון את קובץ התצורה XML מכל מקום במערכת הקבצים.
• AnnotationConfigWebApplicationContext ו-XmlWebApplicationContext ליישומי אינטרנט.

14. מהו Spring Bean?

כל קלאס ג'אווה רגיל שמאתחל על ידי מנוהל ה-Inversion of Control של Spring נקרא Spring Bean. אנו משתמשים ב־ApplicationContext של Spring כדי לקבל את מופע Spring Bean.

מנהל תפריט ה-Inversion of Control של Spring טופל במחזור חיי ה-Spring Bean, בין לבין הקפאת ה-bean, וכן הזרמת תלות נדרשות ל-dimensions שונות ב-bean.

15. מהו חשיבות קובץ התצורה של Spring Bean?

אנו משתמשים בקובץ התצורה של Spring Bean כדי להגדיר את כל ה-beans שיתחילו על ידי ה-Spring Context. כאשר אנו יוצרים את המופע של ה-ApplicationContext של Spring, הוא קורא את קובץ ה-XML של ה-Spring Bean ומאתחל את כולם. לאחר שההקשר אותחל, אנו יכולים להשתמש בו כדי לקבל מופעים שונים של beans.

בנוסף להגדרת Spring Bean, קובץ זה גם מכיל interceptors של spring MVC, מפרטי פתרון תצוגה, ואלמנטים נוספים לתמיכה בהגדרות הבתים המבוססות על אנוטציות.

16. מהם הדרכים השונות להגדיר קבוצה כ- Spring Bean?

יש שלוש דרכים שונות להגדיר Spring Bean.

תצורת XML: זו ההגדרה הכי פופולרית וניתן להשתמש באלמנט ה-bean בקובץ ה-context כדי להגדיר Spring Bean. לדוגמה:

<bean name="myBean" class="com.journaldev.spring.beans.MyBean"></bean>

תצורה באמצעות קוד Java: אם אתה משתמש רק באנוטציות, תוכל להגדיר Spring Bean באמצעות אנוטציה @Bean. האנוטציה הזו משתמשת עם קבוצות האנוטציות @Configuration כדי להגדיר קבוצת Spring. הגדרה לדוגמה היא:

@Configuration
@ComponentScan(value="com.journaldev.spring.main")
public class MyConfiguration {

	@Bean
	public MyService getService(){
		return new MyService();
	}
}

כדי לקבל את ה-bean הזה מה-context של Spring, עלינו להשתמש בקטע הקוד הבא:

AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(
		MyConfiguration.class);
MyService service = ctx.getBean(MyService.class);

תצורה באמצעות אנוטציות: ניתן גם להשתמש באנוטציות @Component, @Service, @Repository ו־@Controller עם קבוצות כדי להגדיר אותן כ- Spring Bean. במקרה זה, יהיה עלינו לספק את מיקום תיקיית הבסיס לסריקה של קבוצות אלו. לדוגמה:

<context:component-scan base-package="com.journaldev.spring" />

17. מהם הטווחים השונים של Spring Bean?

יש חמישה טווחים שהוגדרו עבור Spring Beans.

1. singleton: יתווצר רק מופע אחד של הבין עבור כל מיכל. זהו הטווח המוגדר כברירת מחדל עבור הבינים של Spring. בעת השימוש בטווח זה, וודא שהבין של Spring אינו מכיל משתני מופע משותפים, אחרת עשויים להתגלגל בעיות עם עקביות הנתונים מאחר והוא לא thread-safe.
2. prototype: יווצר מופע חדש בכל פעם שהבין נדרש.
3. request: זהה לטווח ה-prototype, אך הוא מיועד לשימוש ביישומי אינטרנט. מופע חדש של הבין יופעל לכל בקשת HTTP חדשה.
4. session: מופע חדש ייווצר עבור כל הפעלת HTTP על ידי המיכל.
5. global-session: משמש ליצירת בינים של סשן גלובליים עבור יישומי Portlet.

הסביבה של Spring היא נרחבת ואפשר ליצור טווחים משלנו גם. אך ברוב הזמן אנו עובדים עם הטווחים המסופקים על ידי המסגרת. כדי להגדיר טווחי בין של Spring ניתן להשתמש במאפיין "טווח" באלמנט הבין או באנוטציה @Scope להגדרות מבוססות אנוטציות.

18. מהו מחזור חיי ה־Spring Bean?

ה־Spring Beans מאותחלים על ידי מיכל ה־Spring וכל התלויות מוזנות גם. כאשר ההקשר נהרס, הוא גם מושמד את כל החסומים שאותחלו. זה עובד טוב ברוב המקרים, אך לפעמים יש רצון לאתחל משאבים אחרים או לבצע אימות לפני שהחסומים שלנו מוכנים לשימוש. הספרייה של Spring תומכת במתודולוגיות לאחר האתחול ולפני ההרס בחסומים של Spring.

ניתן לעשות זאת בשני דרכים – על ידי הממשקים InitializingBean ו־DisposableBean, או באמצעות שימוש במאפיינים init-method ו־destroy-method בהגדרות חסומי Spring. לפרטים נוספים, יש לקרוא את שיטות מחזור החיים של Spring Bean.

19. איך לקבל את אובייקטי ServletContext ו־ServletConfig בחסום של Spring?

ישנן שתי דרכים לקבל אובייקטים ספציפיים של הקונטיינר בחסום של Spring.

• מיישם את ממשקי ה- *Aware של Spring, לדוג, ממשקי ServletContextAware ו-ServletConfigAware. לדוג, קוד של ממשקי Aware נמצא ב- ממשקי Aware של Spring.
• שימוש בהסמכה @Autowired עם משתנה מסוג ServletContext ו- ServletConfig. הם יעבדו רק בסביבות של מיכל Servlet בלבד.

@Autowired
ServletContext servletContext;

20. מהו Bean Wiring והסמכה @Autowired?

תהליך ההזרקת תלותי Bean של Spring בעת התחלת הרצת האפליקציה נקרא Bean Wiring של Spring.

בדרך כלל, הטוב ביותר הוא לבצע את ההזרקה המפורטת של כל תלותי ה-Bean, אך פריימוורק של Spring תומך גם באוטומטיזציה של ההזרקה. ניתן להשתמש בהסמכה @Autowired עם שדות או פעולות עבור הזרקה אוטומטית לפי סוג. כדי שההסמכה תעבוד, יש צורך גם להפעיל תצורת הסמכות מבוססות הסמכות בקובץ התצורה של Bean של Spring. ניתן לעשות זאת על ידי השגת הרשאות ה- context:annotation-config.

למידע נוסף אודות ההסמכה @Autowired, יש לקרוא דוגמה לאוטואיר ב-Spring.

21. מהם סוגי התקנות של התקנות האוטומטיות של Spring Bean?

יש ארבעה סוגי התקנות אוטומטיות בסביבת ה-Spring.

1. autowire byName
2. autowire byType
3. autowire by constructor
4. אוטומטיות על ידי @Autowired ועל ידי @Qualifier הערות

לפני Spring 3.1, autowire by autodetect נתמך גם והיה דומה לאוטומטיות על ידי constructor או על ידי byType. לפרטים נוספים על אפשרויות אלו, נא לקרוא Spring Bean Autowiring.

22. האם Spring Bean מספק thread safety?

ההיקף הברירת מחדל של Spring bean הוא singleton, כך שיהיה רק אינסטנס אחד לכל קונטקסט. זה אומר שכל הבעיה שיש לה משתנה ברמת המחלקה שכל תהליך יכול לעדכן יוביל לנתונים בלתי עקביים. לכן, במצב ברירת המחדל, מחלקות ה- Spring אינן thread-safe.

אובייקט: אתה יכול לשנות את ההגדרה של spring bean ל־request, prototype או session כדי להשיג thread-safety על חשבון הביצועים. זו החלטת עיצוב המבוססת על דרישות הפרויקט.

23. מהו Controller ב־Spring MVC?

כמו בתבנית העיצוב MVC, ה־Controller הוא המחלקה שמטפלת בכל בקשה מהלקוח ושולחת אותן למשאבים המוגדרים לטיפול בהן. ב־Spring MVC, DispatcherServlet הוא המחלקה של ה־front controller שאחראית לאתחול ההקשר על פי התצורה של ה־spring beans.

A Controller class is responsible to handle a different kind of client requests based on the request mappings. We can create a controller class by using @Controller annotation. Usually, it’s used with @RequestMapping annotation to define handler methods for specific URI mapping.

24. מה ההבחנה בין @Component, @Controller, @Repository ו־@Service ב־Spring?

@Component משמש לציון כי קלאס הוא רכיב. קלאסים אלו משמשים לזיהוי אוטומטי ומוגדרים כבינים כאשר משתמשים בהגדרות מבוססות הערות.

@Controller הוא סוג מסוים של רכיב, המשמש ביישומי MVC ונהוג בעיקר עם ההערה RequestMapping.

@Repository הערת השימוש כדי לציין כי הרכיב משמש כמחסן וכמנגנון לאחסון/אחזור/חיפוש של נתונים. אנו יכולים להחיל את ההערה הזו עם קלאסים ליישום של דפוס DAO.

@Service משמש לציון כי הקלאס הוא שירות. לרוב, קלאסי הממשק העסקי שמספקים שירותים מסוימים מסומנים עם זה.

ניתן להשתמש בכל אחת מההערות לעמודת לזיהוי אוטומטי אך סופקו סוגים שונים כדי שתוכל להבחין בקלות במטרת הקלאסים שנסמנו.

25. מהו DispatcherServlet ו־ContextLoaderListener?

DispatcherServlet הוא הפנה-שרת ביישום Spring MVC והוא טוען את קובץ התצורה של ה-Bean של Spring ומאתחל את כל ה-Beanים שמוגדרים. אם האופציה של הערות מופעלת, הוא סורק גם את החבילות ומגדיר כל Bean שמסומן בעזרת הערות @Component, @Controller, @Repository, או @Service.

ContextLoaderListener הוא הקולט להתחלה וסגירה של WebApplicationContext השורש של Spring. תפקודיו החשובים הם לקשר את מחזור החיים של ApplicationContext למחזור החיים של ServletContext וליצור באופן אוטומטי את ApplicationContext. אנו יכולים להשתמש בו כדי להגדיר Beanים משותפים שניתן להשתמש בהם במגוון הקשור לקשורים של Spring.

26. מהו ViewResolver ב-Spring?

מימושים של ViewResolver משמשים לפתור את עמודי התצוגה לפי שמם. אנו מגדירים את זה בקובץ התצורה של ה-Bean של Spring. לדוגמה:

<!-- מפתח תצוגה שנבחרים לצורך הצגה על ידי @Controllers למשאבים .jsp בתיקיית /WEB-INF/views -->
<beans:bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
	<beans:property name="prefix" value="/WEB-INF/views/" />
	<beans:property name="suffix" value=".jsp" />
</beans:bean>

InternalResourceViewResolver הוא אחד מהמימושים של ממשק ViewResolver ואנו מספקים לו את ספריית דפי התצוגה ומיקום הסיומת דרך תכונות החפוש. אז אם שיטת טיפול בבקשות של בקר מחזירה "home", מסדר תצוגה ישתמש בדף התצוגה שממוקם ב- /WEB-INF/views/home.jsp.

27. מהו MultipartResolver ומתי הוא משמש?

ממשק MultipartResolver משמש להעלאת קבצים – CommonsMultipartResolver ו-StandardServletMultipartResolver הם שני מימושים של Spring Framework הזמינים להעלאת קבצים. כברירת מחדל, אין מגרשים מרוכזים מוגדרים, אך כדי להשתמש בהם להעלאת קבצים, עלינו להגדיר פסולת בשם "multipartResolver" עם סוג MultipartResolver בתצורות פול חומר Spring.

לאחר הגדרה, כל בקשת מרטפארט תתבצע על ידי MultipartResolver שהוגדר ותעבור על HttpServletRequest מעוטר. אז הוא משמש במחלקת הבקר כדי לקבל את הקובץ ולעבד אותו. לדוגמה מלאה, יש לקרוא את דוגמא להעלאת קבצים ב-Spring MVC.

28. איך לטפל בחריגות במסגרת Spring MVC?

מסגרת Spring MVC מספקת את הדרכים הבאות לעזור לנו להשיג טיפול חזק בחריגות.

על ידי בקרת הבקר – נוכל להגדיר שיטות מטפלות בחריגות במחלקות הבקרה שלנו. כל מה שנצטרך הוא לסמן את השיטות הללו עם ההערה @ExceptionHandler.

מטפל חריגה גלובאלי – טיפול בחריגות הוא עניין חוצה-חותם ו-Spring מספק את ההערה @ControllerAdvice שאנו יכולים להשתמש בה עם כל מחלקה כדי להגדיר את מטפל החריגה הגלובאלי שלנו.

מימוש HandlerExceptionResolver – לחריגות גנריות, לרוב אנו מספקים דפים סטטיים. מסגרת Spring מספקת ממשק HandlerExceptionResolver שאנו יכולים לממש כדי ליצור מטפל חריגה גלובאלי. הסיבה למאחורי הדרך הנוספת להגדיר את מטפל החריגה הגלובאלי היא שמסגרת הספרינג גם מספקת מחלקות מימוש ברירת המחדל שאנו יכולים להגדיר בקובץ התצורה של חריגת שישה בובות הקפוא שלנו כדי לקבל יתרונות בטיפול בחריגה של מסגרת הספרינג.

מעבר לדיי דוגמה של טיפול בחריגות בספרינג.

29. כיצד ליצור ApplicationContext בתוך תוכנית Java?

ישנם דרכים הבאות ליצירת הקשר של ספרינג בתוך תוכנית Java עצמאית.

1. AnnotationConfigApplicationContext: אם אנו משתמשים בספרינג ביישומים סטנדלוניים של Java ומשתמשים בהערות להגדרת התצורה, אז נוכל להשתמש בזה כדי לאתחל את המיכל ולקבל את אובייקטי הפול.
2. ClassPathXmlApplicationContext: אם יש לנו קובץ הגדרת פול של ספרינג ביישום סטנדלוני, אז נוכל להשתמש במחלקה זו כדי לטעון את הקובץ ולקבל את אובייקט המיכל.
3. FileSystemXmlApplicationContext: דומה ל- ClassPathXmlApplicationContext רק שניתן לטעון את קובץ ההגדרות XML מכל מקום במערכת הקבצים.

30. האם אפשר להגדיר יותר מקובץ הגדרות ספרינג אחד?

ליישומי Spring MVC, אנו יכולים להגדיר מספר קבצי תצורת קונטקסט של Spring דרך contextConfigLocation. מחרוזת המיקום הזו יכולה להכיל מספר מיקומים מופרדים באמצעות כל מספר של פסיקים ורווחים. לדוגמה;

<servlet>
	<servlet-name>appServlet</servlet-name>
	<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
	<init-param>
            <param-name>contextConfigLocation</param-name>
	    <param-value>/WEB-INF/spring/appServlet/servlet-context.xml,/WEB-INF/spring/appServlet/servlet-jdbc.xml</param-value>
	</init-param>
	<load-on-startup>1</load-on-startup>
</servlet>

אנו יכולים גם להגדיר מספר תצורות שורש של Spring ולטעון אותם דרך context-param. לדוגמה;

<context-param>
	<param-name>contextConfigLocation</param-name>
	<param-value>/WEB-INF/spring/root-context.xml /WEB-INF/spring/root-security.xml</param-value>
</context-param>

אפשרות נוספת היא להשתמש באלמנט הייבוא בקובץ תצורת הקונטקסט כדי לייבא תצורות אחרות, לדוגמה:

<beans:import resource="spring-jdbc.xml"/>

31. מהו ContextLoaderListener?

ContextLoaderListener הוא מחלקת המאזינה שמשמשת לטעינת הקונטקסט השורש ולהגדרת תצורות הבונים של Spring שיהיו גלויים לכל הקונטקסטים האחרים. הוא מוגדר בקובץ web.xml כך:

<context-param>
	<param-name>contextConfigLocation</param-name>
	<param-value>/WEB-INF/spring/root-context.xml</param-value>
</context-param>
	
<listener>
	<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

32. מהן ההגדרות המינימליות הנדרשות ליצירת אפליקציית Spring MVC?

ליצירת אפליקציית Spring MVC פשוטה, יהיה עלינו לבצע את המשימות הבאות.

• הוספת התלות spring-context ו-spring-webmvc לפרויקט.
• הגדר את DispatcherServlet בקובץ web.xml כדי לטפל בבקשות דרך ה Spring container.
• קובץ התצורה של ה- Spring bean יש להגדיר בו את ה-beans, אם משתמשים באנוטציות אז עליכם להגדיר אותן כאן. כמו כן, עלינו להגדיר את מסמך פתרונות התצורה עבור דפי התצוגה.
• מחלקת הבקרה עם מיפויי בקשות מוגדרים לטיפול בבקשות הלקוח.

שלבים אלו צריכים להיות מספיקים כדי ליצור אפליקציית Spring MVC Hello World פשוטה.

33. איך תקשרו את מסגרת Spring MVC לארכיטקטורת MVC?

כפי ששמו מרמז, Spring MVC בנויה על גבי ארכיטקטורת Model-View-Controller. DispatcherServlet היא הבקר הראשי באפליקציית Spring MVC שמטפל בכל הבקשות הנכנסות ומפנה אותן לשיטות טיפול של בקרי השונים.

המודל יכול להיות כל Java Bean ב- Spring Framework, בדיוק כמו כל מסגרת MVC אחרת, Spring מספקת קשר אוטומטי של נתוני הטופס ל-Java beans. אנו יכולים להגדיר את המודלים כמאפיינים לשימוש בדפי התצוגה.

דפי התצוגה יכולים להיות JSP, HTML סטטי וכדומה, ומפתחי הפתרונות לתצוגה אחראים למציאת הדף התצוגה הנכון. לאחר שהדף התצוגה מזוהה, השליטה מוחזרת לבקר ה-DispatcherServlet. DispatcherServlet אחראית לעיבוד התצוגה ולהחזרת התגובה הסופית ללקוח.

34. כיצד להשיג לוקליזציה ביישומי Spring MVC?

Spring מספק תמיכה מצוינת בלוקליזציה או i18n דרך חבילות משאבים. השלבים הבסיסיים הנדרשים להפוך את היישום שלנו ללוקלייזציה הם:

• יצירת חבילות משאבים להודעות עבור שפות שונות, כמו messages_en.properties, messages_fr.properties, וכו'
• הגדרת משאב של messageSource בקובץ התצורה של Spring beans של סוג ResourceBundleMessageSource או ReloadableResourceBundleMessageSource.
• עבור תמיכה בשינוי של לוקל, הגדר את משאב ה־localeResolver בסוג CookieLocaleResolver וקבע אינטרספטור של LocaleChangeInterceptor. דוגמת הגדרה מוצגת כך:

<beans:bean id="messageSource"
class="org.springframework.context.support.ReloadableResourceBundleMessageSource">
<beans:property name="basename" value="classpath:messages" />
<beans:property name="defaultEncoding" value="UTF-8" />
</beans:bean>
 
<beans:bean id="localeResolver"
    class="org.springframework.web.servlet.i18n.CookieLocaleResolver">
    <beans:property name="defaultLocale" value="en" />
    <beans:property name="cookieName" value="myAppLocaleCookie"></beans:property>
    <beans:property name="cookieMaxAge" value="3600"></beans:property>
</beans:bean>
 
<interceptors>
    <beans:bean class="org.springframework.web.servlet.i18n.LocaleChangeInterceptor">
        <beans:property name="paramName" value="locale" />
    </beans:bean>
</interceptors>

• השתמש באלמנט spring:message בדפי התצוגה עם שמות מפתח, DispatcherServlet יבחר את הערך התואם ויצייר את הדף בלוקלייזציה התואמת ויחזיר כתגובה.

לדוגמה מלאה, אנא קרא דוגמת לוקליזציה ב־Spring.

35. איך אפשר להשתמש ב-Spring כדי ליצור שירות אינטרנטי רסטפול המחזיר תגובת JSON?

ניתן להשתמש במסגרת Spring כדי ליצור שירותים אינטרנטיים רסטפול המחזירים נתוני JSON. Spring מספקת אינטגרציה עם חבילת Jackson JSON API שאנו יכולים להשתמש בה כדי לשלוח תגובות JSON בשירות אינטרנטי רסטפול.

יש לבצע את השלבים הבאים כדי להגדיר את היישום שלנו של Spring MVC כך שישלח תגובת JSON.

1. הוספת תלותי Jackson JSON, אם אתה משתמש ב-Maven זה ניתן לבצע עם הקוד הבא:

<!-- Jackson -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>${jackson.databind-version}</version>
</dependency>

2. הגדרת RequestMappingHandlerAdapter bean בקובץ התצורה של ה-Bean של Spring והגדרת המאפשרים הודעה ל-MappingJackson2HttpMessageConverter bean. הגדרה דוגמתית תהיה:

<!-- הגדר כדי להוסיף JSON כבקשה וכתגובה במטפל בשיטה -->
<beans:bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
    <beans:property name="messageConverters">
        <beans:list>
            <beans:ref bean="jsonMessageConverter"/>
        </beans:list>
    </beans:property>
</beans:bean>
     
<!-- הגדרת Bean כדי להמיר JSON ל-POJO ולהפוך -->
<beans:bean id="jsonMessageConverter" class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
</beans:bean>

3. בשיטות המטפלות בפונקציות המטפלות, החזרת ה-Object כתגובה באמצעות האונוטציה @ResponseBody. קוד דוגמה:

@RequestMapping(value = EmpRestURIConstants.GET_EMP, method = RequestMethod.GET)
public @ResponseBody Employee getEmployee(@PathVariable("id") int empId) {
    logger.info("Start getEmployee. ID="+empId);
     
    return empData.get(empId);
}

4. ניתן לקרוא לשירות ה-REST דרך כל API, אך אם ברצונך להשתמש ב-Spring אז תוכל בקלות לעשות זאת באמצעות ה-Class RestTemplate.

עבור משלם, בבקשה קרא את דוגמה מלאה של שירות רוחב נתינה ב־Spring.

36. אילו הן האננוטציות החשובות ביותר של Spring שהשתמשת?

חלק מהאננוטציות של Spring שהשתמשתי בפרויקט שלי הן:

• @Controller – לקבוע קבוצות בבקרת תצוגה בפרויקט Spring MVC.
• @RequestMapping – להגדיר דיוגי URI בשיטות טיפול בבקר.דוגמאות לשימוש באננוטציית RequestMapping ב־Spring MVC
• @ResponseBody – לשלוח אובייקט כתגובה, בדרך כלל לשליחת נתוני XML או JSON כתגובה.
• @PathVariable – למפות ערכים דינמיים מה-URI לארגומנטים של שיטת טיפול.
• @Autowired – להפעיל אוטומטית התלמידויות בין התלמידויות בפעילות הפרצוף של Spring.
• @Qualifier – יחד עם הסימון @Autowired כדי למנוע תחושת תבל בעת שקיימות מספר מופעים של סוג הפעילות.
• @Service – לקבוע שירותות.
• @Scope – להגדיר את היקף הפעילות של פעילות הפרצוף של Spring.
• @Configuration, @ComponentScan, ו־@Bean – לתצורת הפעילות המבוססת על Java.
• אספקטים של AspectJ להגדרת אספקטים וייעוץ, @Aspect, @Before, @After, @Around, @Pointcut, וכו'.

37. ?אפשר לשלוח אובייקט כתשובה מסוג Controller handler method

כן, אנו יכולים לעשות זאת באמצעות הערה @ResponseBody. כך אנו שולחים תגובה מבוססת JSON או XML בשירותי רשת RESTful.

38. ?איך להעלות קבצים ביישום Spring MVC

Spring מספק תמיכה מובנית להעלאת קבצים דרך ממשק MultipartResolver. זה קל לשימוש ודורש שינויים בהגדרה כדי להפעיל אותו. יהיה עלינו לכתוב את מתגם הטיפול בקובץ הנכנס ולעבד אותו. לדוגמה מלאה, יש להסתכל על דוגמה להעלאת קבצי Spring.

39. איך לאמת נתוני טופס ב-Framework של Spring Web MVC?

Spring תומך באימותים באמצעות אנוטציות המבוססות על JSR-303, ומספק ממשק Validator שאנו יכולים לממש כדי ליצור את האמות המותאמת שלנו. עבור שימוש באימות מבוססת על JSR-303, אנו צריכים להוסיף אנוטציות למשתני ה-Bean עם האמות הנדרשות.

לממש יצירת אמות מותאמות אישית, עלינו להגדיר אותן במחלקת הקונטרולר. לדוגמה מלאה, אנא ראה את דוגמת אימות טופס ב-Spring MVC.

40. מהו Interceptor של Spring MVC ואיך להשתמש בו?

ה-Interceptors של Spring MVC דומים ל-Servlet Filters ומאפשרים לנו להפריד בין בקשות הלקוח ולעבד אותן. אנו יכולים להפריד בין בקשות הלקוח בשלושה נקודות – preHandle, postHandle, ו־afterCompletion.

ניתן ליצור Interceptor של Spring על ידי מימוש ממשק ה-HandlerInterceptor או על ידי הרחבה של המחלקה המופשטת HandlerInterceptorAdapter.

אנו צריכים להגדיר אינטרספטורים בקובץ התצורה של ה- spring bean. אנו יכולים להגדיר אינטרספטור כדי להפריד את כל בקשות הלקוח או להגדיר אותו עבור מיפוי URI ספציפי גם. לדוגמה מפורטת, נא להסתכל דוגמת אינטרספטור Spring MVC.

41. מהו מחלקת ה- Spring JdbcTemplate וכיצד להשתמש בה?

המסגרת של Spring מספקת אינטגרציה מצוינת עם ממשק ה- JDBC ומספקת מחלקת יוליטי JdbcTemplate שאנו יכולים להשתמש בה כדי למנוע קוד מיותר מלוגיקת פעולות בסיס הנתונים שלנו כגון פתיחת/סגירת חיבור, ResultSet, PreparedStatement וכו '.

לדוגמה של JdbcTemplate, נא להסתכל דוגמת JDBC של Spring.

42. כיצד להשתמש במקור נתונים JNDI של Tomcat ביישום האינטרנט של Spring?

עבור שימוש ב- servlet container המוגדר עם JNDI DataSource, אנו צריכים להגדיר אותו בקובץ התצורה של ה- spring bean ולאחר מכן להזרים אותו ל- spring beans כתלות. לאחר מכן, נוכל להשתמש בו עם JdbcTemplate כדי לבצע פעולות במסד הנתונים.

<beans:bean id="dbDataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
    <beans:property name="jndiName" value="java:comp/env/jdbc/MyLocalDB"/>
</beans:bean>

לדוגמה מלאה, אנא ראה את דוגמה על Spring Tomcat JNDI.

43. איך תגיע לניהול עסקאות ב-Spring?

הספרייה של Spring מספקת תמיכה בניהול עסקאות דרך ניהול עסקאות הז׳קלרטיבי וכן דרך ניהול עסקאות פרוגרמטי. ניהול עסקאות דרך הז׳קלרטיבי הוא הפופולרי ביותר מכיוון שהוא פשוט לשימוש ועובד ברוב המקרים.

אנו משתמשים בהסמכה של שיטה עם האנוטציה @Transactional לניהול עסקאות דרך הזקלרטיבי. עלינו להגדיר את מנהל העסקאות עבור מקור הנתונים בקובץ התצורה של ה- spring bean.

<bean id="transactionManager"
    class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource" />
</bean>

44. מהו DAO של Spring?

תמיכה ב־Spring DAO ניתנת כדי לעבוד עם טכנולוגיות גישה לנתונים כמו JDBC, Hibernate בדרך עקבית וקלה. לדוגמה, יש לנו JdbcDaoSupport, HibernateDaoSupport, JdoDaoSupport ו־JpaDaoSupport לטכנולוגיות המתאימות.

Spring DAO מספקת גם עקביות במורכבות החריגים ולא עלינו לתפוס חריגים ספציפיים.

45. איך לאינטגרציה בין Spring ו־Hibernate Frameworks?

ניתן להשתמש במודול Spring ORM כדי לאינטגרציה בין Spring ו־Hibernate frameworks אם אתה משתמש ב־Hibernate 3+ שבו SessionFactory מספק סשן נוכחי, אז עליך להימנע משימוש בקבוצות HibernateTemplate או HibernateDaoSupport ונכון יותר להשתמש בתבנית DAO עם הזרמת תלות עבור האינטגרציה.

Spring ORM מספקת תמיכה בשימוש בניהול עסקאות דקלרטיבי של Spring, לכן עליך להשתמש בכך במקום ללכת על קוד כור ה־Hibernate לניהול עסקאות.

להבנה טובה יותר עליך לעבור דרך המדריכים הבאים:

• דוגמא לאינטגרציה של Spring Hibernate
• דוגמא לאינטגרציה של Spring MVC Hibernate

46. מהו הסגירות של Spring Security?

פריסת הביטחון של Spring מתמקדת בספק האימות וההרשאה ביישומי Java. היא גם טופלת את רוב החולשות האבטחה הנפוצות כמו התקפת CSRF.

זה מאוד מועיל וקל להשתמש בביטחון של Spring ביישומי האינטרנט, דרך השימוש באנוטציות כמו @EnableWebSecurity. כדאי לעבור על הפוסטים הבאים כדי ללמוד כיצד להשתמש בפריימוורק של Spring Security.

• ביטחון של Spring ביישום רשת Servlet
• דוגמה לאינטגרציה בין Spring MVC ו-Spring Security

47. כיצד להכניס סט java.util.Properties לתוך Spring Bean?

עלינו להגדיר את הבונה propertyConfigurer שיטען את המאפיינים מקובץ המאפיינים הנתון. לאחר מכן נוכל להשתמש בתמיכת EL של Spring כדי להכניס מאפיינים לתוך תלותי פול.
לדוגמה:

<bean id="propertyConfigurer" 
  class="org.springframework.context.support.PropertySourcesPlaceholderConfigurer">
    <property name="location" value="/WEB-INF/application.properties" />
</bean> 

<bean class="com.journaldev.spring.EmployeeDaoImpl">
    <property name="maxReadResults" value="${results.read.max}"/>
</bean>

אם אתה משתמש בהערכה להגדרת הפרוץ של Spring, אז תוכל להזין מאפיינים כמו שמוצג למטה.

@Value("${maxReadResults}") 
private int maxReadResults;

48. תן שמות לכמה מתבניות העיצוב שמשמשות ב-Spring Framework?

Spring Framework משתמש במגוון רחב של מתבניות עיצוב, כמה מהן הן:

1. מתבנית ה-Singleton: יצירת חומרות עם טווח ברירת המחדל.
2. מתבנית ה-Factory: מחלקות מפעילות של Bean
3. מתבנית ה-Prototype: טווחי Bean
4. מתבנית ה-Adapter: Spring Web ו-Spring MVC
5. מתבנית ה-Proxy: תמיכה בתכנות נוגעת להופעה ב-Spring AOP
6. מתבנית ה-Template Method: JdbcTemplate, HibernateTemplate וכו'
7. Front Controller: Spring MVC DispatcherServlet
8. אובייקט גישה לנתונים: תמיכה ב- Spring DAO
9. הפקת תלות ותכנות ממוקד פרספקטיבה

49. מהן כמה מתוך שיטות העבודה הטובות למסגרת ה- Spring?

כמה מתוך שיטות העבודה הטובות למסגרת ה- Spring הן:

• להימנע משימוש במספרי גרסאות בהפניית הסכמת הסכמה, כדי לוודא שיש לנו את התצורות האחרונות.
• לחלק את ההגדרות של הבונים של Spring לפי התחומים שלהם כמו spring-jdbc.xml, spring-security.xml.
• עבור בונים של Spring המשמשים במספר הקשרים ב- Spring MVC, יש ליצור אותם בהקשר הבסיסי ולאתחל אותם עם המאזין.
• להגדיר תלות בין הבונים ככל הניתן, ולנסות להימנע מהופעת תלות אוטומטית ככל הניתן.
• עבור מאפייני רמה של היישום, הגישה הטובה ביותר היא ליצור קובץ מאפיינים ולקרוא אותו בקובץ ההגדרות של בון ה-Spring.
• עבור אפליקציות קטנות יותר, האנוטציות שימושיות אך עבור אפליקציות גדולות יותר, האנוטציות עשויות להפוך לקושי. אם נחזיק את כל ההגדרות בקבצי XML, התחזוקה תהיה קלה יותר.
• @Service ועבור DAO beans השתמש ב־@Repository.
• הקורס Spring מציע מגוון רחב של מודולים, השתמש באלו שאתה זקוק להם. הסר את כל התלויות הנוספות שנוספות בדרך כלל כאשר אתה יוצר פרויקטים דרך תבניות Spring Tool Suite.
• אם אתה משתמש ב-Aspects, ודא שאתה שומר על נקודת ההתמקדות כמה שיותר צרה כדי למנוע ייעוץ על שיטות שאין לך צורך בהן. שקול בשימוש באנוטציות מותאמות אישית שהן יותר נוחות לשימוש ומתרחקות מבעיות אפשריות.
• השתמש בהזנת תלויות כאשר יש תועלת ממנה, אל תשתמש בהן רק בשביל ליצור קשר ירוד, השתמש בהן כי יש תועלת אמית ממנה.

50. מהו Spring Boot?

ספרינג בוט הופך את הספרינג פריימוורק לייחודי. הוא מספק לנו דרך פשוטה ליצירת סוגים שונים של יישומים ב-Java ולקשר אותם עם סביבת הרץ של מכולת הסרבלט. לכן אנו מקבלים קובץ JAR יחיד שאפשר להריץ כדי להריץ את הפרויקט. זה חוסך לנו המון זמן ביצירת פרויקט רקע שהוא מוכן לפרסום מהיר מאוד. בכך אנו יכולים להתמקד יותר בלוגיקת העסקים במקום לעבור דרך התהליך הנפוץ של בניית הקוד ואז הפצתו על מכולת סרבלט. מאחר וזו נושא נרחב מאוד, אני ממליץ לך לעבור על שאלות ראיון על Spring Boot.

זהו כל השאלות של ראיון על פריימוורק ספרינג. אני מקווה ששאלות אלו יסייעו לך בראיון עבודה ב-Java EE הקרוב. אני אמשיך להוסיף שאלות נוספות לרשימה בהתאם למציאתם. אם יש לך עוד שאלות שצריך להיות חלק מהרשימה, הוסף תגובה ואני אכליל אותן.