
ห้องสมุดและมาตรฐาน
52. ไฮเบอร์เนตคืออะไร? JPA และไฮเบอร์เนตแตกต่างกันอย่างไร?
ฉันคิดว่าจะตอบคำถามนี้ ก่อนอื่นเราต้องเข้าใจว่าJPA คือ อะไร JPAเป็นข้อกำหนดที่อธิบายการแมปเชิงวัตถุสัมพันธ์ของวัตถุ Java แบบธรรมดา และจัดเตรียม API สำหรับการจัดเก็บ เรียกค้น และจัดการวัตถุดังกล่าว นั่นคืออย่างที่เราจำได้ว่าฐานข้อมูล เชิงสัมพันธ์ (DB) จะถูกนำเสนอในรูปแบบของตารางที่เชื่อมต่อถึงกันจำนวนมาก และJPAก็เป็นมาตรฐานที่ได้รับการยอมรับอย่างกว้างขวาง ซึ่งอธิบายว่าอ็อบเจ็กต์สามารถโต้ตอบกับฐานข้อมูลเชิงสัมพันธ์ได้อย่างไร อย่างที่คุณเห็นJPAเป็นสิ่งที่เป็นนามธรรมและไม่มีตัวตน มันเหมือนกับความคิด วิธีการ
53. การเรียงซ้อนคืออะไร? มันถูกใช้อย่างไรในไฮเบอร์เนต?
ดังที่ฉันได้กล่าวไว้ก่อนหน้านี้ในการสื่อสารแบบไฮเบอร์เนตจะดำเนินการผ่านวัตถุข้อมูลที่เรียกว่าเอนทิตี . เอนทิตีเหล่านี้เป็นตัวแทนของตารางเฉพาะบางตารางในฐานข้อมูล และอย่างที่คุณจำได้ ในคลาส Java สามารถมีการอ้างอิงถึงคลาสอื่นได้ ความสัมพันธ์เหล่านี้สะท้อนให้เห็นในฐานข้อมูล ตามกฎแล้วในฐานข้อมูลสิ่งเหล่านี้อาจเป็นคีย์นอก (สำหรับ OneToOne, OneToMany, ManyToOne) หรือตารางระดับกลาง (สำหรับ ManyToMany) คุณสามารถอ่าน เพิ่มเติมเกี่ยวกับความสัมพันธ์ระหว่างเอนทิตีได้ในบทความนี้ เมื่อเอนทิตีของคุณมีลิงก์ไปยังเอนทิตีที่เกี่ยวข้องอื่นๆ คำอธิบายประกอบจะถูกวางไว้เหนือลิงก์เหล่านี้เพื่อระบุประเภทของการเชื่อมต่อ: @OneToOne, @OneToMany, @ManyToOne, @ManyToMane ซึ่งคุณสามารถระบุค่าของคุณสมบัติได้ - cascade - the ประเภทของคาสเคดสำหรับการเชื่อมต่อนี้ JPA มีวิธีการเฉพาะสำหรับการโต้ตอบกับเอนทิตี (คงอยู่ บันทึก ผสาน... ) ประเภทการเรียงซ้อนถูกนำมาใช้อย่างแม่นยำเพื่อแสดงให้เห็นว่าข้อมูลที่เกี่ยวข้องควรทำงานอย่างไรเมื่อใช้วิธีการเหล่านี้กับเอนทิตีเป้าหมาย ดังนั้นกลยุทธ์การเรียงซ้อน (ประเภทของการเรียงซ้อน) คืออะไร? มาตรฐาน JPA แสดงถึงการใช้การเรียงซ้อนหกประเภท:-
PERSIST - การดำเนินการบันทึกจะเกิดขึ้นแบบเรียงซ้อน (สำหรับ วิธี การบันทึก()และคงอยู่() ) นั่นคือถ้าเราบันทึกเอนทิตีที่เกี่ยวข้องกับเอนทิตีอื่น พวกเขาจะถูกบันทึกในฐานข้อมูลด้วย (หากยังไม่มี)
-
MERGE - การดำเนินการอัปเดตจะเกิดขึ้นแบบเรียงซ้อน (สำหรับ เมธอด Merge() )
-
ลบ - การดำเนินการลบเกิดขึ้นในแบบเรียงซ้อน ( วิธี ลบ () )
-
ทั้งหมด - มีการดำเนินการเรียงซ้อนสามครั้งพร้อมกัน - PERSIST - MERGE - REMOVE
-
DETACH - เอนทิตีที่เกี่ยวข้องจะไม่ได้รับการจัดการโดยเซสชัน ( detach() method ) นั่นคือเมื่อมีการเปลี่ยนแปลง จะไม่มีการเปลี่ยนแปลงข้อมูลในฐานข้อมูลโดยอัตโนมัติ - จะถูกถ่ายโอนจากสถานะคงอยู่เป็นแยกออก (เอนทิตีที่ไม่ได้รับการจัดการโดย JPA)
-
รีเฟรช - ทุกครั้งที่อัปเดตเอนทิตีด้วยข้อมูลจากฐานข้อมูล ( รีเฟรช() - อัปเดตออบเจ็กต์ที่แยกออก) เอนทิตีที่เกี่ยวข้องจะได้รับการอัปเดตในลักษณะเดียวกัน ตัวอย่างเช่น คุณเปลี่ยนแปลงข้อมูลที่นำมาจากฐานข้อมูลและต้องการส่งกลับค่าดั้งเดิม ในกรณีนี้ การดำเนินการนี้จะเป็นประโยชน์สำหรับคุณ

-
จำลอง - ใช้เมื่อเรามีแหล่งข้อมูลมากกว่าหนึ่งแหล่งและเราต้องการให้ข้อมูลซิงโครไนซ์ (วิธีไฮเบอร์เนต - ทำซ้ำ) เอนทิตีทั้งหมดต้องมีตัวระบุ (id) เพื่อไม่ให้เกิดปัญหากับการสร้าง (เพื่อให้เอนทิตีเดียวกันไม่มีรหัสที่แตกต่างกันสำหรับฐานข้อมูลที่แตกต่างกัน)
-
SAVE_UPDATE - บันทึก/ลบแบบเรียงซ้อน (สำหรับวิธี Hibernate - saveOrUpdate )
-
LOCKเป็นการดำเนินการผกผันกับDETACHEDโดยจะถ่าย โอนเอนทิ ตีที่ แยก ออกกลับไปยัง สถานะ คงอยู่เช่น เอนทิตีจะถูกติดตามอีกครั้งในเซสชันปัจจุบัน
54. คลาส Entity สามารถเป็นนามธรรมได้หรือไม่?
ในข้อกำหนด JPAในย่อหน้า2.1 คลาสเอนทิตีมีบรรทัด: “ ทั้งคลาสนามธรรมและคอนกรีตสามารถเป็นเอนทิตีได้ ” ดังนั้นคำตอบคือใช่ คลาสนามธรรมสามารถเป็นเอนทิตีและสามารถใส่คำอธิบายประกอบด้วย @Entity55. ผู้จัดการกิจการคืออะไร? เขารับผิดชอบอะไร?
ก่อนอื่น ฉันอยากจะทราบว่าEntityManagerเป็นหนึ่งในองค์ประกอบสำคัญของ JPAซึ่งใช้ในการโต้ตอบเอนทิตีกับฐานข้อมูล โดยทั่วไปจะเรียกวิธีการโต้ตอบระหว่างเอนทิตีและฐานข้อมูล (คงอยู่ ผสาน ลบ แยกออก)... แต่ฉันก็ทราบด้วยว่าตามกฎแล้วองค์ประกอบนี้ไม่ใช่องค์ประกอบเดียวสำหรับแอปพลิเคชันทั้งหมด: บ่อยที่สุด มันมีน้ำหนักเบาและมักจะถูกลบออกและสร้างอันใหม่โดยใช้EntityManagerFactory หากเราวาดเส้นขนานกับJDBCโดยที่EntityManagerFactoryจะเป็นอะนาล็อกของ DataSourceจากนั้นEntityManagerจะเป็นอะนาล็อกของConnection ในทางกลับ กัน ก่อนหน้านี้ฉันได้กล่าวถึงการคงอยู่เอนทิตีเป็นเอนทิตีที่ถูกควบคุมโดยการเชื่อมต่อปัจจุบัน ดังนั้น: เอนทิตีนี้ได้รับการจัดการอย่างแม่นยำโดย EntityManagerซึ่งเกี่ยวข้องอย่างใกล้ชิดกับการเชื่อมต่อปัจจุบันและTransactionManagerซึ่งรับผิดชอบในการเปิด/ปิดธุรกรรม นอกจากนี้ ในรูปด้านล่าง คุณสามารถดูวงจรชีวิตของเอนทิตีได้:
56. คลาส Assert คืออะไร? ทำไมต้องใช้มัน?
ฉันไม่เคยได้ยินเกี่ยวกับคลาสดังกล่าว ในJPAดังนั้นฉันจะถือว่าสิ่งนี้หมายถึง คลาส JUnitของไลบรารี ซึ่งใช้สำหรับการทดสอบโค้ดหน่วย คลาสของไลบรารีนี้Assertใช้เพื่อตรวจสอบผลลัพธ์ของการเรียกใช้โค้ด ( assertคือคำสั่งที่คุณมีสถานะ/ข้อมูลที่แน่นอนในที่ใดที่หนึ่ง) ตัวอย่างเช่น คุณกำลังทดสอบวิธีที่ควรสร้างแมวขึ้นมา คุณเรียกใช้เมธอดและรับผลลัพธ์:Cat resultOfTest = createCat();
แต่คุณต้องแน่ใจว่ามันถูกสร้างขึ้นอย่างถูกต้องใช่ไหม? ดังนั้น ก่อนหน้านี้คุณได้สร้าง cat - ExpectedCat - บางตัวด้วย ตนเอง โดยมีพารามิเตอร์ที่คุณคาดหวังจาก cat ที่ได้รับจาก เมธอด createCat() จากนั้นคุณใช้ คลาส Assertเพื่อตรวจสอบผลลัพธ์:
Assert.assertEquals(resultOfTest, expectedCat);
หากแมวแตกต่างกัน ข้อยกเว้น AssertionError จะถูกส่งออกไป ซึ่งบอกเราว่าผลลัพธ์ที่คาดหวังไม่มาบรรจบกัน คลาสAssertมีวิธีการที่แตกต่างกันมากมายซึ่งครอบคลุมงานหลายอย่างในการตรวจสอบผลลัพธ์ที่คาดหวัง นี่คือบางส่วนของพวกเขา:
-
assertTrue(<boolean>) - ค่าที่คาดหวังที่ได้รับเป็นอาร์กิวเมนต์จะต้องเป็นจริง
-
assertFalse(<boolean>) - ค่าที่คาดหวังที่ได้รับเป็นอาร์กิวเมนต์ควรเป็นเท็จ
-
assertNotEquals(<object1>, <object2>) - อ็อบเจ็กต์ที่ได้รับเป็นอาร์กิวเมนต์จะต้องแตกต่างกันเมื่อเปรียบเทียบโดยใช้เท่ากับ ( false )
-
assertThrows(<ClassNameOfException>.class, <ExceptionObject>) - อาร์กิวเมนต์ที่สองคาดว่าจะเป็นข้อยกเว้นของคลาสที่ระบุโดยอาร์กิวเมนต์แรก (เช่น ตามกฎแล้ว แทนที่อาร์กิวเมนต์ที่สอง วิธีการจะถูกเรียกที่ควร โยนข้อยกเว้นประเภทที่ต้องการ)
สตริง
57. กำหนดลักษณะสตริงใน Java
Stringเป็นคลาสมาตรฐานใน Java ซึ่งรับผิดชอบในการจัดเก็บและจัดการค่าสตริง (ลำดับของอักขระ) เป็น คลาส ที่ไม่เปลี่ยนรูป ( ฉันเขียนเกี่ยวกับไม่เปลี่ยนรูปก่อนหน้านี้ ) เช่น ข้อมูลของออบเจ็กต์ของคลาสนี้ไม่สามารถเปลี่ยนแปลงได้หลังจากการสร้าง ฉันต้องการทราบทันทีว่าคลาส StringBuilderและStringBufferเป็นคลาสสองคลาสที่แทบจะเหมือนกัน โดยมีข้อแตกต่างเพียงอย่างเดียวคือคลาสใดคลาสหนึ่งมีไว้สำหรับใช้ในสภาพแวดล้อมแบบมัลติเธรด (StringBuffer) คลาสเหล่านี้คล้ายคลึงกับStringแต่ต่างกันตรงที่คลาสเหล่านี้ไม่แน่นอน กล่าวคือ เมื่อสร้างออบเจ็กต์แล้ว อนุญาตให้แก้ไขสตริงที่แสดงได้โดยไม่ต้องสร้างออบเจ็กต์ใหม่ จริงๆ แล้ว วิธีการเหล่านี้แตกต่างจาก วิธี String มาตรฐาน และมีจุดมุ่งหมายเพื่อตอบสนองความต้องการในการเปลี่ยนสตริง (ไม่ใช่เพื่ออะไรที่พวกเขาเรียกว่าตัวสร้าง) อ่านเพิ่มเติมเกี่ยวกับString , StringBufferและStringBuilder ในบทความนี้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เราก็จะใช้มัน แต่วิธีนี้ใช้ไม่ได้กับการเปรียบเทียบวัตถุที่มีคุณสมบัติครบถ้วน ในกรณีนี้ จะเป็นการเปรียบเทียบการอ้างอิงเท่านั้น ไม่ว่าจะชี้ไปที่วัตถุเดียวกันหรือไม่ก็ตาม นั่นคือเมื่อเปรียบเทียบวัตถุสองชิ้นที่มีค่าเหมือนกันทุกประการของฟิลด์ภายในการเปรียบเทียบผ่าน==จะให้ผลลัพธ์เป็นเท็จ : แม้จะมีฟิลด์ที่เหมือนกันของวัตถุ แต่วัตถุนั้นก็ครอบครองเซลล์หน่วยความจำที่แตกต่างกัน และอ็อบเจ็กต์ของ คลาส Stringแม้จะมีความเรียบง่ายที่หลอกลวง แต่ก็ยังเป็นวัตถุ และการเปรียบเทียบผ่าน==ก็ไม่สามารถใช้ได้กับพวกเขาเช่นกัน (แม้ว่าจะมีพูลสตริงอยู่ก็ตาม) ที่นี่วิธีการมาตรฐานของคลาส Objectเข้ามามี บทบาท - เท่ากับซึ่งจะต้องถูกแทนที่ในคลาสเพื่อให้ทำงานได้อย่างถูกต้อง (มิฉะนั้น โดยค่าเริ่มต้นจะเปรียบเทียบโดยใช้== ) มันถูกแทนที่ ใน คลาส Stringดังนั้นเราจึงรับมันและใช้งาน:String firstStr = "Hello World!";
String secondStr = "Hello World!";
boolean isEquals = firstStr.equals(secondStr);

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
การวิเคราะห์ส่วนหนึ่งของวันนี้ได้สิ้นสุดลงแล้ว ขอขอบคุณสำหรับความสนใจของคุณ!
GO TO FULL VERSION