สำรวจคำถามและคำตอบจากการสัมภาษณ์งานสำหรับตำแหน่ง Java Developer ตอนที่ 6

สวัสดีชาวโลก! มันเป็นสิ่งสำคัญสำหรับนักพัฒนาทุกคนที่จะไม่หยุดเติบโต ท้ายที่สุด หากคุณหยุด คุณเสี่ยงที่จะขาดความต้องการและหลุดออกจากตลาดงานโดยสิ้นเชิง โลกไอทีมีการพัฒนาและก้าวไปข้างหน้าอย่างต่อเนื่อง - คุณต้องก้าวไปพร้อมกับมัน แต่ในขณะเดียวกัน คุณไม่สามารถใช้เทคโนโลยีล่าสุดได้เสมอไป เกรงว่าคุณจะลืม "คลาสสิก" (หัวข้อการพัฒนาซอฟต์แวร์แบบคลาสสิก) วันนี้ฉันต้องการที่จะอภิปราย "หัวข้อคลาสสิก" สำหรับนักพัฒนา Java ต่อไป ฉันจะชี้ให้เห็นว่าคำตอบของฉันไม่ใช่คำพูดสุดท้าย นี่เป็นเพียงมุมมองของฉันเกี่ยวกับคำตอบที่ถูกต้อง - คุณอาจไม่เห็นด้วยกับบางข้อ ไม่เป็นไร ดังนั้นอย่าลังเลที่จะแบ่งปันความคิดเห็นของคุณในความคิดเห็น คุณสามารถดูลิงก์ไปยังส่วนก่อนหน้าของบทวิจารณ์ได้ในตอนท้ายของบทความ

ห้องสมุดและมาตรฐาน

52. ไฮเบอร์เนตคืออะไร? JPA และไฮเบอร์เนตแตกต่างกันอย่างไร

เพื่อตอบคำถามนี้ ฉันคิดว่าเราต้องเข้าใจก่อนว่า JPA คืออะไร เป็นข้อกำหนดที่อธิบายการแมปเชิงวัตถุสัมพันธ์ของอ็อบเจ็กต์ Java แบบธรรมดา และจัดเตรียม API สำหรับการจัดเก็บ การดึงข้อมูล และการจัดการอ็อบเจ็กต์ดังกล่าว นั่นคือฐานข้อมูลเชิงสัมพันธ์ (DB) จะแสดงเป็นชุดของตารางที่เชื่อมต่อถึงกัน และ JPA เป็นมาตรฐานที่นำมาใช้กันอย่างแพร่หลายซึ่งอธิบายว่าวัตถุสามารถโต้ตอบกับฐานข้อมูลเชิงสัมพันธ์ได้อย่างไร อย่างที่คุณเห็น JPA เป็นสิ่งที่เป็นนามธรรมและไม่มีตัวตน มันเหมือนกับความคิด แนวทาง แต่Hibernate เป็นไลบรารีเฉพาะที่ใช้กระบวนทัศน์ JPA ในการจัดลำดับคำ คุณสามารถใช้ไลบรารีนี้เพื่อทำงานกับฐานข้อมูลเชิงสัมพันธ์ผ่านอ็อบเจ็กต์ที่แสดงถึงข้อมูลในฐานข้อมูล (เอนทิตี) ห้องสมุดแห่งนี้ว่ากันว่าใกล้เคียงกับอุดมคติของ JPA มาก นั่นอาจเป็นเหตุผลว่าทำไมมันถึงได้รับความนิยม อย่างที่คุณสามารถจินตนาการได้ ความนิยมของมันทำให้มีการพัฒนาและปรับปรุงต่อไป นอกจากนี้ การใช้งานอย่างแพร่หลายยังเกิดจากชุมชนขนาดใหญ่ที่ได้สำรวจทุกคำถามที่เป็นไปได้และเป็นไปไม่ได้ที่เกี่ยวข้องกับเครื่องมือนี้แล้ว ไฮเบอร์เนตได้รับการศึกษาอย่างละเอียดและน่าเชื่อถือ มีเหตุผลที่ดีว่าทำไมแม้แต่การนำ JPA ในอุดมคติไปใช้ใน Spring ก็ยังใช้ Hibernate ภายใต้ประทุน

53. การเรียงซ้อนคืออะไร? มันถูกใช้อย่างไรในไฮเบอร์เนต?

อย่างที่ฉันบอกไปก่อนหน้านี้ การสื่อสารใน Hibernate เกิดขึ้นผ่านออบเจ็กต์ข้อมูลที่เรียกว่าเอนทิตี เอนทิตีเหล่านี้แสดงถึงตารางเฉพาะในฐานข้อมูล และอย่างที่คุณจำได้ คลาส Java สามารถมีการอ้างอิงถึงคลาสอื่นได้ ความสัมพันธ์เหล่านี้ยังสะท้อนให้เห็นในฐานข้อมูลด้วย ตามกฎแล้ว คีย์เหล่านี้เป็นคีย์นอก (สำหรับความสัมพันธ์ OneToOne, OneToMany, ManyToOne) หรือตารางระดับกลาง (สำหรับความสัมพันธ์ ManyToMany) เมื่อเอนทิตีของคุณมีการอ้างอิงถึงเอนทิตีที่เกี่ยวข้องอื่นๆ คำอธิบายประกอบจะถูกวางไว้เหนือการอ้างอิงเหล่านี้เพื่อระบุประเภทของความสัมพันธ์: @OneToOne, @OneToMany, @ManyToOne, @ManyToMany คุณสามารถระบุประเภทของการเรียงซ้อนสำหรับความสัมพันธ์นี้ได้ในคุณสมบัติการเรียงซ้อนของคำอธิบายประกอบ JPA มีวิธีการเฉพาะสำหรับการโต้ตอบกับเอนทิตี (คงอยู่ บันทึก ผสาน ...) ประเภท Cascade ใช้เพื่อแสดงว่าข้อมูลที่เกี่ยวข้องควรทำงานอย่างไร วิธีการเหล่านี้ใช้กับเอนทิตีเป้าหมาย ดังนั้นกลยุทธ์การเรียงซ้อน (ประเภทการเรียงซ้อน) คืออะไร? มาตรฐาน JPA กำหนดให้มีการใช้คาสเคดหกประเภท:

• PERSIST - การดำเนินการบันทึกเกิดขึ้นในแบบเรียงซ้อน (สำหรับ วิธี การบันทึก ()และคงอยู่ () ) กล่าวอีกนัยหนึ่ง ถ้าเราบันทึกเอนทิตีที่เกี่ยวข้องกับเอนทิตีอื่น เอนทิตีเหล่านั้นก็จะถูกบันทึกในฐานข้อมูลด้วย (หากยังไม่มีอยู่)

• MERGE - การดำเนินการอัปเดตเกิดขึ้นในแบบเรียงซ้อน (สำหรับ วิธี การผสาน () )

• ลบ - การดำเนินการลบเกิดขึ้นในน้ำตก ( วิธี ลบ () )

• ALL — มีการดำเนินการเรียงซ้อนสามรายการพร้อมกัน — PERSIST — MERGE — REMOVE

JPA มีแนวคิดเกี่ยวกับเอนทิตีถาวร — เอนทิตีที่เกี่ยวข้องกับข้อมูลในฐานข้อมูลและควบคุมโดยเซสชันปัจจุบัน (การเชื่อมต่อ) หากคุณเปลี่ยนแปลงโดยไม่บันทึกการเปลี่ยนแปลงในฐานข้อมูล ข้อมูลของเอนทิตีในฐานข้อมูลจะยังคงมีการเปลี่ยนแปลง

• DETACH - เอนทิตีที่เกี่ยวข้องไม่ได้รับการจัดการโดยเซสชัน ( วิธีdetach() ) นั่นคือ เมื่อข้อมูลของเอนทิตีที่เกี่ยวข้องมีการเปลี่ยนแปลง ข้อมูลในฐานข้อมูลจะไม่ได้รับการอัปเดตโดยอัตโนมัติ ข้อมูลเหล่านั้นจะถูกแปลงจากถาวรเป็นแยกออก (กล่าวคือ เอนทิตีไม่ได้รับการจัดการโดย JPA)

• รีเฟรช — ทุกครั้งที่รีเฟรชเอนทิตีด้วยข้อมูลจากฐานข้อมูล ( รีเฟรช() — รีเฟรชออบเจ็กต์ที่แยกออกมา) เอนทิตีที่เกี่ยวข้องก็จะถูกรีเฟรชด้วย ตัวอย่างเช่น คุณเปลี่ยนแปลงข้อมูลที่นำมาจากฐานข้อมูล และคุณต้องการคืนค่าค่าดั้งเดิม ในกรณีนี้ คุณจะพบว่าการดำเนินการนี้มีประโยชน์

Hibernate รองรับการดำเนินการต่อเรียงมาตรฐานทั้งหมดเหล่านี้ และยังแนะนำสามการดำเนินการของตนเอง:

• REPLICATE — ใช้เมื่อเรามีแหล่งข้อมูลมากกว่าหนึ่งแหล่งและเราต้องการให้ข้อมูลซิงโครไนซ์ (วิธีการทำซ้ำของ Hibernate) เอนทิตีทั้งหมดต้องมีตัวระบุ (id) เพื่อให้แน่ใจว่าสามารถสร้างได้โดยไม่มีปัญหา (เพื่อให้แน่ใจว่าเอนทิตีเดียวกันไม่มีรหัสที่แตกต่างกันสำหรับฐานข้อมูลที่แตกต่างกัน)

• SAVE_UPDATE - บันทึก/ลบแบบเรียงซ้อน (สำหรับวิธีsaveOrUpdate ของ Hibernate)

• LOCK — ตรงกันข้ามกับ การดำเนินการ DETACHED : แปลงเอนทิตีที่แยกออกมากลับเป็นสถานะถาวร กล่าวคือ เซสชันปัจจุบันจะติดตามเอนทิตีอีกครั้ง

ถ้าไม่ได้เลือกชนิดการเรียงซ้อน การดำเนินการในเอนทิตีจะไม่ส่งผลกระทบต่อเอนทิตีอื่น ๆ ที่เกี่ยวข้อง

54. คลาส Entity สามารถเป็นนามธรรมได้หรือไม่?

ตาม2.1 The Entity Classของข้อกำหนด JPA " ทั้งคลาสนามธรรมและคลาสคอนกรีตสามารถเป็นเอนทิตีได้ " ดังนั้น คำตอบคือใช่ คลาสนามธรรมสามารถเป็นเอนทิตีและสามารถทำเครื่องหมายด้วยคำอธิบายประกอบ @Entity

55. ผู้จัดการกิจการคืออะไร? มันรับผิดชอบอะไร?

ก่อนอื่น ฉันอยากจะทราบว่าEntityManager เป็นองค์ประกอบสำคัญของJPA ใช้สำหรับการโต้ตอบระหว่างเอนทิตีกับฐานข้อมูล โดยทั่วไป วิธีการโต้ตอบของเอนทิตีกับฐานข้อมูลจะถูกเรียกใช้บนเอนทิตี (คงอยู่ ผสาน ลบ ลบออก)... แต่ฉันก็ทราบด้วยว่าส่วนประกอบนี้มักจะไม่ใช่ซิงเกิลตันสำหรับแอปพลิเคชันทั้งหมด มันมักจะมี น้ำหนักเบา หนึ่งถูกลบ และสร้างใหม่โดยใช้EntityManagerFactory หากเราวาดเส้นขนานกับJDBCโดยที่EntityManagerFactoryคล้ายคลึงกับDataSourceดังนั้นEntityManagerก็คล้ายคลึงกับConnection ก่อนหน้านี้ ฉันกล่าวไว้ว่าเอนทิตีถาวรคือเอนทิตีที่ได้รับการจัดการโดยการเชื่อมต่อปัจจุบัน เอนทิตีนี้ได้รับการจัดการโดยEntityManagerซึ่งเกี่ยวข้องอย่างใกล้ชิดกับการเชื่อมต่อปัจจุบัน และTransactionManagerซึ่งรับผิดชอบในการเปิด/ปิดธุรกรรม ในรูปด้านล่าง คุณสามารถดูวงจรชีวิตของเอนทิตีได้: EntityManager จัดการเอนทิตีเมื่ออยู่ในขั้นตอนที่ได้รับการจัดการ (เมื่อยังคงอยู่ เนื่องจากมีการเชื่อมต่อกับEntityManager ) นั่นคือไม่ใช่เรื่องใหม่และไม่ได้ถูกลบออกด้วย เมื่อเอนทิตีใหม่หรือถูกลบออก เราสามารถพูดได้ว่าเอนทิตีนั้นถูกแยกออกเช่นกัน เนื่องจาก EntityManager ไม่ได้จัดการเอนทิตีนั้น มีกลยุทธ์ที่แตกต่างกันสำหรับEntityManager คุณสามารถมี EntityManager singleton สำหรับทั้งแอปพลิเคชันหรือสร้างใหม่ได้ในแต่ละครั้งสำหรับการเชื่อมต่อแต่ละครั้ง หากคุณใช้ Spring การสร้าง/การลบ EntityManager จะได้รับการจัดการโดยอัตโนมัติภายใต้ประทุน (แต่นั่นไม่ได้หมายความว่าคุณไม่สามารถปรับแต่งมันเองได้ ^^) ฉันต้องพูดถึงว่า EntityManagers อย่างน้อยหนึ่งรายการสร้างบริบทการคงอยู่ บริบทการคงอยู่คือสภาพแวดล้อมที่อินสแตนซ์ของเอนทิตีซิงโครไนซ์กับเอนทิตีที่คล้ายกันในฐานข้อมูล (อย่างที่ฉันบอกไป สิ่งนี้ใช้ได้กับเอนทิตีที่คงอยู่เท่านั้น) หากคุณเจาะลึกเข้าไปในJPA (ซึ่งฉันขอแนะนำอย่างยิ่ง) คุณจะพบกับแนวคิดนี้บ่อยมาก

56. คลาส Assert คืออะไร? ทำไมมันถึงใช้?

ฉันไม่เคยได้ยินเกี่ยวกับคลาสดังกล่าวในJPAดังนั้นฉันจะถือว่าคำถามนี้หมายถึงคลาสที่พบในไลบรารี JUnit ที่ใช้สำหรับการทดสอบหน่วย ในไลบรารีนี้ คลาส Assertใช้เพื่อตรวจสอบผลลัพธ์ของการเรียกใช้โค้ด (ในที่นี้assertหมายถึงการยืนยันว่าคุณมีสถานะ/ข้อมูลเฉพาะในตำแหน่งเฉพาะในโค้ด) ตัวอย่างเช่น สมมติว่าคุณกำลังทดสอบวิธีการที่ควรจะสร้างแมว คุณเรียกใช้วิธีการและคุณได้รับผลลัพธ์:

Cat resultOfTest = createCat();

แต่คุณต้องแน่ใจว่ามันถูกสร้างขึ้นอย่างถูกต้องใช่ไหม? ดังนั้นคุณจึงสร้าง cat เฉพาะ ( ExpectCat ) ด้วยตนเองด้วยพารามิเตอร์ที่คุณคาดหวังที่จะเห็นใน cat ที่ได้รับจากเมธอดcreateCat() จากนั้นคุณใช้ คลาส Assertเพื่อตรวจสอบผลลัพธ์:

Assert.assertEquals(resultOfTest, expectedCat);

หากแมวไม่เหมือนกัน ก็จะเกิดAssertionError ซึ่งบอกเราว่าเราไม่ได้รับผลลัพธ์ตามที่คาดหวัง คลาสAssertมีวิธีการที่แตกต่างกันมากมายซึ่งครอบคลุมการดำเนินการต่างๆ ที่เป็นประโยชน์ในการตรวจสอบผลลัพธ์ที่คาดหวัง นี่คือบางส่วนของพวกเขา:

• assertTrue(<boolean>) — ค่าที่ส่งผ่านเป็นอาร์กิวเมนต์คาดว่าจะเป็นจริง

• assertFalse(<boolean>) — ค่าที่ส่งผ่านเป็นอาร์กิวเมนต์คาดว่าจะเป็นเท็จ

• assertNotEquals(<object1>, <object2>) — วัตถุที่ส่งผ่านเป็นอาร์กิวเมนต์จะต้องแตกต่างกันเมื่อเปรียบเทียบโดยใช้เท่ากับ ( false )

• assertThrows(<ClassNameOfException>.class, <ExceptionObject>) — อาร์กิวเมนต์ที่สองคาดว่าจะเป็นข้อยกเว้นที่เกิดจากอาร์กิวเมนต์แรก (เช่น อาร์กิวเมนต์ที่สองมักจะเป็นการเรียกเมธอดที่ควรส่งข้อยกเว้นประเภทที่ต้องการ)

สตริง

57. อธิบายคลาส String ของ Java

Stringเป็นคลาส Java มาตรฐานที่รับผิดชอบในการจัดเก็บและจัดการค่าสตริง (ลำดับของอักขระ) มันเป็น คลาส ที่ไม่เปลี่ยนรูป (ฉันเขียนเกี่ยวกับไม่เปลี่ยนรูปก่อนหน้านี้ที่นี่ ) กล่าวคือข้อมูลของวัตถุในคลาสนี้ไม่สามารถเปลี่ยนแปลงได้หลังจากที่ถูกสร้างขึ้น ฉันต้องการทราบทันทีว่า คลาส StringBuilderและStringBufferนั้นเหมือนกันโดยพื้นฐานแล้ว ข้อแตกต่างเพียงอย่างเดียวคือหนึ่งในนั้นมีไว้สำหรับใช้ในสภาพแวดล้อมแบบมัลติเธรด ( StringBuffer ) คลาสเหล่านี้เหมือนกับStringแต่แตกต่างกันตรงที่คลาสเหล่านี้ไม่แน่นอน แม้ว่าจะสร้างแล้วก็ตาม ก็ยังให้คุณแก้ไขสตริงที่เป็นตัวแทนได้โดยไม่ต้องสร้างอ็อบเจ็กต์ใหม่ วิธีการของพวกเขาแตกต่างจาก วิธี String มาตรฐาน และได้รับการออกแบบสำหรับการจัดการสตริง (มีเหตุผลที่พวกเขาเรียกมันว่าตัวสร้าง)

58. วิธีสร้างวัตถุ String มีอะไรบ้าง? มันถูกสร้างขึ้นที่ไหน?

วิธีทั่วไปในการสร้างสตริงคือการระบุค่าที่เราต้องการในเครื่องหมายคำพูดคู่ง่ายๆ:

String str = "Hello World!";

คุณสามารถทำได้อย่างชัดเจนโดยใช้new :

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 มันจะถูกจัดเก็บไว้ใน string poolซึ่งเราจะหารือในรายละเอียดเพิ่มเติมในคำถามข้อใดข้อหนึ่งด้านล่าง

59. คุณจะเปรียบเทียบสตริง Java สองสตริงได้อย่างไร และคุณจะเรียงลำดับสตริงเหล่านั้นอย่างไร?

Java ใช้เครื่องหมายเท่ากับสองเท่า ( == ) เพื่อทำการเปรียบเทียบ หากเราต้องเปรียบเทียบค่าง่ายๆ เช่น int เราจะใช้มัน แต่วิธีนี้ไม่เหมาะสำหรับการเปรียบเทียบวัตถุที่เต็มเปี่ยม โดยจะเปรียบเทียบเฉพาะข้อมูลอ้างอิง กล่าวคือ ข้อมูลอ้างอิงชี้ไปที่วัตถุเดียวกันหรือไม่ ซึ่งหมายความว่าหากเราเปรียบเทียบสองวัตถุที่มีค่าฟิลด์เดียวกันโดยใช้==เราจะได้false ฟิลด์ต่างๆ มีค่าเหมือนกัน แต่ออบเจ็กต์เองก็ใช้ตำแหน่งต่างกันในหน่วยความจำ วัตถุสตริง แม้จะมีความเรียบง่ายที่หลอกลวง แต่ก็ยังเป็นวัตถุ การเปรียบเทียบโดยใช้==ก็ไม่เหมาะสมเช่นกัน (แม้ว่าจะมีพูลสตริงอยู่ก็ตาม) วิธีแก้ไขที่เหมาะสมคือ วิธีมาตรฐาน เท่ากับของคลาสObjectซึ่งจำเป็นต้องถูกแทนที่เพื่อให้ทำงานได้อย่างถูกต้อง (โดยค่าเริ่มต้นจะใช้==สำหรับการเปรียบเทียบ) คลาสStringจะแทนที่มัน ดังนั้นเราจึงใช้งานมัน:

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

เราได้พูดคุยเกี่ยวกับการเปรียบเทียบเพื่อความเท่าเทียมกัน ตอนนี้เราจะหาการเปรียบเทียบสำหรับการเรียงลำดับ เพราะถ้าเราจะเรียงลำดับอะไรสักอย่าง เราก็ต้องรู้ว่าจะใช้หลักการอะไรในการเรียงลำดับ เมื่อต้องการทำเช่นนี้ คุณสามารถใช้TreeSetซึ่งเป็นชุดการเรียงลำดับมาตรฐาน โครงสร้างข้อมูลนี้อาศัยอัลกอริทึมต้นไม้สีแดง-ดำ และเรียงลำดับชุดตามหลักการเรียงลำดับที่ระบุ ดังที่ได้กล่าวไปแล้ว คุณต้องเข้าใจวิธีจัดเรียงวัตถุบางประเภท หากต้องการกำหนดวิธีการเปรียบเทียบสำหรับการเรียงลำดับ ให้ใช้ตัวเปรียบเทียบ โดยทั่วไปคุณจะต้องนำไปใช้กับคลาสที่คุณต้องการเรียงลำดับ แต่ในกรณีของString คลาสเหล่านั้นจะถูกนำไปใช้แล้ว ดังนั้น เราเพียงแค่เพิ่มสตริงของเราไปที่TreeSetและมันจะจัดเรียงสตริงให้เรา:

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

เอาต์พุตคอนโซล:

60. จัดเตรียมอัลกอริทึมสำหรับการแปลงสตริงเป็นอักขระ เขียนรหัสที่เกี่ยวข้อง

ดังที่ได้กล่าวไปแล้วString object มีวิธีการที่เป็นประโยชน์มากมาย toCharArrayหนึ่งในนั้นคือ วิธีการนี้แปลงสตริงเป็นอาร์เรย์อักขระ:

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

ต่อไป เรามีอาร์เรย์ของอักขระที่เราสามารถอ้างอิงตามดัชนี:

char firstChar = charArr[0]; // H

61. คุณจะแปลงสตริงเป็นอาร์เรย์ไบต์และย้อนกลับได้อย่างไร? เขียนรหัสที่เกี่ยวข้อง

คลาสStringมี เมธอด getBytesซึ่งคล้ายกับ เมธอด toCharArrayและส่งกลับสตริงเป็นอาร์เรย์ไบต์:

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

เราได้มาถึงข้อสรุปเชิงตรรกะของการตรวจสอบของเราในวันนี้ ขอบคุณที่อ่าน!