ניתוח שאלות ותשובות מראיונות למפתח Java. חלק 6

שלום עולם! המשך הפיתוח חשוב מאוד לכל מפתח. אחרי הכל, אם תפסיק, יש סיכון להפוך ללא דרישה ולעוף לחלוטין מהשוק: עולם ה-IT מתפתח כל הזמן ומתקדם, ואתה צריך להתקדם איתו. אבל גם יחד עם זאת, אי אפשר להתמקד רק בטכנולוגיות חדשות ורעננות, כדי לא לשכוח, כביכול, את הקלאסיקה (נושאים קלאסיים). היום אני רוצה להמשיך בניתוח השאלות שלי בנושאים "קלאסיים" עבור מפתח Java. אני מציין שהתשובות שלי אינן הסמכות הסופית - רק כך אני רואה את התשובות הנכונות לשאלות אלו, וייתכן שאינך מסכים עם חלק מהן. זה יהיה די נורמלי, אז אל תהסס לשתף את דעתך בתגובות. קישורים לחלקים מהניתוח נמצאים בסוף המאמר.

ספריות ותקנים

52. מה זה Hibernate? מה ההבדל בין JPA לבין Hibernate?

אני חושב שכדי לענות על השאלה הזו, ראשית עלינו להבין מהי JPA . JPA הוא מפרט שמתאר את מיפוי האובייקטים-יחסי אובייקטים של אובייקטים פשוטים של Java ומספק API לאחסון, אחזור ומניפולציה של אובייקטים כאלה. כלומר, כזכור, מסדי נתונים יחסיים (DBs) מוצגים בצורה של טבלאות רבות הקשורות זו לזו. ו- JPA הוא תקן מקובל שמתאר כיצד אובייקטים יכולים לקיים אינטראקציה עם מסדי נתונים יחסיים. כפי שאתה יכול לראות, JPA הוא משהו מופשט ובלתי מוחשי. זה כמו הרעיון עצמו, הגישה. יחד עם זאת, Hibernate היא ספרייה ספציפית המיישמת את הפרדיגמות של JPA . כלומר, בעזרת ספרייה זו ניתן לעבוד עם מסד נתונים יחסי באמצעות אובייקטים המייצגים נתונים ממסד הנתונים (Entity). כמו שאומרים, הספרייה הזו קרובה מאוד לאידיאלים של JPA ואולי בגלל זה היא הפכה פופולרית. וכפי שאתה מבין, הפופולריות של השימוש היא טיעון טוב להמשך פיתוח ושיפורים. בנוסף, מאחורי השימוש התכוף בו ישנה קהילה ענקית שכבר מיינה את כל השאלות האפשריות והבלתי אפשריות הקשורות לכלי הזה. הנה דוגמה לספר שבוחן בפירוט את כל הפינות האפלות של הטכנולוגיה הזו. כלומר, Hibernate נחקר ככל האפשר, ומסתבר שהוא אמין. למעשה, לא בכדי אפילו היישום האידיאלי של JPA בצד האביב משתמש בדרך כלל ב-Hibernate מתחת למכסה המנוע.

53. מה זה מדורג? איך משתמשים בו במצב Hibernate?

כפי שאמרתי קודם, במצב Hibernate התקשורת מתבצעת באמצעות אובייקטי נתונים הנקראים ישויות . ישויות אלה מייצגות כמה טבלאות ספציפיות במסד הנתונים, וכפי שאתה זוכר, ב-Java מחלקות יכולות להכיל הפניות למחלקות אחרות. קשרים אלו באים לידי ביטוי במסד הנתונים. במסד נתונים, ככלל, אלו הם מפתחות זרים (עבור OneToOne, OneToMany, ManyToOne) או טבלאות ביניים (עבור ManyToMany). ניתן לקרוא עוד על הקשר בין ישויות במאמר זה . כאשר לישות שלך יש קישורים לישויות קשורות אחרות, הערות ממוקמות מעל קישורים אלה כדי לציין את סוג החיבור: @OneToOne, @OneToMany, @ManyToOne, @ManyToMane, שבפרמטרים שלהם ניתן לציין את ערך המאפיין - מפל - ה- סוג מפל עבור חיבור זה. ל-JPA יש שיטות ספציפיות לאינטראקציה עם ישויות (להתמיד, לשמור, להתמזג...) . סוגים מדורגים משמשים בדיוק כדי להראות כיצד הנתונים המשויכים צריכים להתנהג כאשר משתמשים בשיטות אלו על ישות היעד. אז, מהן אסטרטגיות המדורגות (סוגי מדורגים)? תקן JPA מרמז על שימוש בשישה סוגים של מדורגים:

• PERSIST - פעולות השמירה יתרחשו במדורג (עבור המתודות save() ו- persist() ). כלומר, אם אנו שומרים ישות הקשורה לישויות אחרות, הן נשמרות גם במסד הנתונים (אם הן עדיין לא שם)

• MERGE - פעולות עדכון יתרחשו במפל (עבור שיטת המיזוג() )

• REMOVE - פעולות ההסרה מתרחשות במפל ( שיטת remove() )

• ALL - מכיל שלוש פעולות מפל בבת אחת - PERSIST - מיזוג - הסר

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

• ישויות הקשורות ל- DETACH לא ינוהלו על ידי ההפעלה ( שיטת detach() ). כלומר, כאשר הם משתנים, לא יהיה שינוי אוטומטי בנתונים שלהם במסד הנתונים - הם מועברים ממצב התמדה למנותק (ישות שאינה מנוהלת על ידי JPA)

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

Hibernate תומך בכל פעולות המדורגות הסטנדרטיות הללו, אך גם מציג שלוש משלה:

• REPLICATE - משמש כאשר יש לנו יותר ממקור נתונים אחד ואנו רוצים שהנתונים יסונכרנו (שיטת Hibernate - שכפול). לכל הישויות חייבות להיות מזהים (מזהה) כדי שלא יהיו בעיות ביצירתן (כדי שלאותה ישות אין מזהים שונים עבור מסדי נתונים שונים)

• SAVE_UPDATE - שמירה/מחיקה מדורגת (עבור שיטת Hibernate - saveOrUpdate )

• LOCK היא הפעולה ההפוכה ל- DETACHED : היא מעבירה את הישות המנותקת חזרה למצב ההתמדה , כלומר. הישות תחזור למעקב על ידי ההפעלה הנוכחית

אם הסוג המדורג לא נבחר, לאף פעולה על ישות לא תהיה השפעה כלשהי על ישויות אחרות המשויכות אליה.

54. האם מחלקה של Entity יכולה להיות מופשטת?

במפרט JPA בסעיף 2.1 מחלקת הישות יש שורה: " מחלקות מופשטות וקונקרטיות יכולות להיות ישויות ." אז התשובה היא כן, מחלקה מופשטת יכולה להיות ישות וניתנת להערה עם @Entity.

55. מהו מנהל ישות? על מה הוא אחראי?

ראשית, ברצוני לציין כי EntityManager הוא אחד המרכיבים המרכזיים של JPA , המשמש ליצירת אינטראקציה בין ישויות עם מסד הנתונים. באופן כללי, זה קורא לשיטות האינטראקציה בין הישות למסד הנתונים (התמיד, מיזוג, הסר, ניתוק)... אבל אציין גם שרכיב זה, ככלל, אינו אחד עבור האפליקציה כולה: לרוב הוא קל משקל ולעתים קרובות מוסר וחדש נוצר באמצעות EntityManagerFactory . אם נצייר הקבלה ל- JDBC , שבו EntityManagerFactory יהיה אנלוגי של DataSource , אז EntityManager, בתורו, יהיה אנלוגי של Connection . קודם לכן הזכרתי ישות התמדה , כישות שנשלטת על ידי החיבור הנוכחי. אז: ישות זו מנוהלת במדויק על ידי EntityManager , אשר קשור קשר הדוק לחיבור הנוכחי ו- TransactionManager , אשר אחראי על פתיחת/סגירת עסקאות. בהמשך האיור למטה ניתן לראות את מחזור החיים של ישות: EntityManager מנהל את הישות כשהיא בשלב המנוהל (בשלב זה היא מתמשכת, כי יש לה קשר עם EntityManager). כלומר, הוא כבר לא חדש וטרם הוסר. אנו יכולים לומר שכאשר ישות חדשה או מוסרת, היא גם מנותקת, כי הוא אינו מנוהל על ידי ה-EntityManager. ישנן אסטרטגיות שונות עבור EntityManager. כלומר, יכול להיות EntityManager יחיד אחד עבור האפליקציה כולה, או שניתן ליצור אחד חדש בכל פעם, עבור כל חיבור. אם אתה משתמש ב-Spring, אז היצירה/מחיקה של EntityManager נשלטת אוטומטית מתחת למכסה המנוע (אבל זה לא אומר שאתה לא יכול להתאים אותו ^^). כדאי לומר שמנהל EntityManager אחד או יותר יוצרים את הקשר ההתמדה . Context persistence היא סביבה שבה מופעים של ישויות מסונכרנים עם ישויות דומות במסד הנתונים (כפי שאמרתי, זה עובד רק עבור ישויות מתמשכות). אם תעמיקו ב- JPA (שאני ממליץ בחום), תתקלו במושגים האלה לעיתים קרובות מאוד.

56. מהי מחלקת אסר? למה להשתמש בו?

לא שמעתי על מחלקה כזו ב- JPA , אז אניח שהכוונה היא למחלקה JUnit של הספרייה, המשמשת לבדיקת יחידות של קוד. המחלקה של ספרייה זו, Assert , משמשת לבדיקת תוצאות ביצוע הקוד ( assert היא הצהרה שיש לך מצב/נתונים מסוימים במקום מסוים). לדוגמה, אתה בודק שיטה שאמורה ליצור חתול. אתה מפעיל שיטה ומקבל תוצאה כלשהי:

Cat resultOfTest = createCat();

אבל אתה צריך לוודא שהוא נוצר בצורה נכונה, נכון? לכן, יצרת בעבר cat מסויים - expectcat - באופן ידני עם בדיוק הפרמטרים שאתה מצפה מהחתול המתקבל מהשיטה createCat() . לאחר מכן, אתה משתמש במחלקה Assert כדי לאמת את התוצאות:

Assert.assertEquals(resultOfTest, expectedCat);

אם החתולים שונים, ייזרק חריג AssertionError , שאומר לנו שהתוצאות הצפויות אינן מתכנסות. למחלקה Assert יש שיטות רבות ושונות המכסות רבות מהמשימות של אימות התוצאות הצפויות. הנה כמה מהם:

• assertTrue(<boolean>) - הערך הצפוי שהתקבל כארגומנט חייב להיות נכון

• assertFalse(<boolean>) - הערך הצפוי שהתקבל כארגומנט צריך להיות false

• assertNotEquals(<object1>, <object2>) - אובייקטים המתקבלים כארגומנטים חייבים להיות שונים בהשוואה באמצעות שווים ( false )

• assertThrows(<ClassNameOfException>.class, <exceptionObject>) - הארגומנט השני צפוי להיות חריג מהמחלקה שצוינה על ידי הארגומנט הראשון (כלומר, ככלל, במקום הארגומנט השני, נקראת מתודה שאמורה להיות לזרוק חריג מהסוג הנדרש)

חוּט

57. אפיון מחרוזת ב-Java

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

58. מהן הדרכים השונות ליצור אובייקט מחרוזת? איפה זה נוצר?

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

String str = "Hello World!";

אתה יכול גם לעשות זאת ישירות דרך חדש :

String str = new String("Hello World!");

אתה יכול ליצור מחרוזת החל ממערך של תווים:

char[] charArr = {'H','e','l','l','o',' ', 'W','o','r','l','d','!'};
String str = new String(charArr);

כתוצאה משיטת toString שפועלת על אובייקט כלשהו:

String str = someObject.toString();

כמו התוצאה של כל שיטה אחרת, היא מחזירה ייצוג מחרוזת. לדוגמה:

BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
String str =  reader.readLine();

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

59. איך להשוות בין שתי מחרוזות ב-Java ואיך למיין אותן?

Java משתמשת בסימן השווה הכפול == כדי להשוות ערכים . אם היינו צריכים להשוות כמה ערכים פשוטים כמו int , היינו משתמשים בזה. אבל שיטה זו אינה ישימה להשוואת אובייקטים מן המניין. במקרה זה, זו תהיה רק ​​השוואה של הפניות - בין אם הן מצביעות על אותו אובייקט או לא. כלומר, כאשר משווים בין שני אובייקטים בעלי אותם ערכים של שדות פנימיים בדיוק, השוואה דרך == תיתן את התוצאה False : למרות השדות הזהים של האובייקטים, האובייקטים עצמם תופסים תאי זיכרון שונים. ואובייקטים של מחלקת String , למרות הפשטות המתעתעת שלהם, הם עדיין אובייקטים. והשוואה דרך == גם לא ישימה עבורם (אפילו למרות נוכחות של בריכת מיתר). כאן נכנסת לתמונה השיטה הסטנדרטית של מחלקת Object - equals , אותה יש לעקוף במחלקה כדי שהיא תעבוד נכון (אחרת, כברירת מחדל היא משווה באמצעות == ). זה מוחלף במחלקה String , אז אנחנו פשוט לוקחים אותו ומשתמשים בו:

String firstStr = "Hello World!";
String secondStr = "Hello World!";
boolean isEquals = firstStr.equals(secondStr);

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

TreeSet<String> sortedSet = new TreeSet<>();
sortedSet.add("B");
sortedSet.add("C");
sortedSet.add("A");
sortedSet.forEach(System.out::println);

פלט מסוף:

60. תן אלגוריתם להמרת מחרוזת לתו. כתוב את הקוד המתאים

כפי שאמרתי קודם, לאובייקטים של המחלקה String יש הרבה שיטות שימושיות שונות. אחד מהם הוא toCharArray . שיטה זו ממירה מחרוזת למערך תווים:

String str = "Hello world";
char[] charArr = str.toCharArray();

לאחר מכן יש לנו מערך של תווים שאנו יכולים לקרוא לפי אינדקס:

char firstChar = charArr[0]; // H

61. כיצד להמיר מחרוזת למערך בתים ובחזרה? כתוב את הקוד המתאים

בדומה לשיטת toCharArray , למחלקה String יש מתודה getBytes שמחזירה מערך בתים של המחרוזת:

String str = "Hello world";
byte[] byteArr = str.getBytes();
byte firstChar = byteArr[6]; // 119

החלק של היום בניתוח הגיע לסיומו ההגיוני. תודה לך על תשומת הלב!