การทำแผนที่เชิงสัมพันธ์ของวัตถุ

1.1 การแม็พคลาสกับตาราง

หลังจากเรียนรู้ JDBC แล้ว คุณมักจะรู้สึกว่าการทำงานกับฐานข้อมูลจากแอปพลิเคชัน Java ยังคงเป็นเรื่องน่ายินดี ถ้าฉันบอกคุณว่างานทั้งหมดนี้สามารถทำได้ง่ายขึ้น 10 เท่า

ประโยชน์หลักของภาษา SQL คืออะไร? นี่เป็นภาษาที่เปิดเผย - มันอธิบายถึงสิ่งที่เราต้องการและไม่พูดอะไรเลยเกี่ยวกับวิธีการทำ อย่างไร - นี่เป็นข้อกังวลของเซิร์ฟเวอร์ SQL

สามารถใช้วิธีการเดียวกันนี้เมื่อทำงานกับฐานข้อมูล

ในโลกอุดมคติ เราสามารถเขียนแบบสอบถาม SQL ลงในฐานข้อมูล และตอบสนองเราจะได้รับวัตถุ Java สำเร็จรูปหรือคอลเลกชันของวัตถุ Java ถ้าเราขอหลายชิ้น

ฉันจะพูดอะไรได้ นี่คือสิ่งที่ผู้ชายหลายคนคิดในปี 2000 และตัดสินใจที่จะเขียนกรอบ ORM ของตัวเอง

ORMย่อมาจากObject-Relational Mappingและโดยพื้นฐานแล้วเป็นการแมปของ Java Object กับ SQL Query

พวกเขาคิดสิ่งง่ายๆ ขึ้นมาได้แต่ละตารางในฐานข้อมูลต้องสอดคล้องกับบางคลาสในแอปพลิเคชัน Java ในแอปพลิเคชัน Java เราดำเนินการกับออบเจกต์ และออบเจ็กต์เหล่านี้รู้วิธีบันทึกตัวเองลงในฐานข้อมูลอยู่แล้ว

มีสามวิธีในการแก้ปัญหานี้ และมีลักษณะดังนี้:

1. วัตถุจะบันทึกตัวเองลงในฐานข้อมูลและอัปเดตฟิลด์ตามข้อมูลจากฐานข้อมูล
2. วัตถุสามารถบันทึกตัวเองไปยังฐานข้อมูล แต่ไม่เคยเริ่มต้นกรณีนี้
3. วัตถุประกอบด้วยข้อมูลเท่านั้น และมีคนบันทึกไว้ในฐานข้อมูลและโหลดจากฐานข้อมูล

ในขั้นต้น แนวทางแรกครอบงำ จากนั้นเซิร์ฟเวอร์แอปพลิเคชันและ Enterprise Java Beans ได้รับความนิยม มีแม้แต่ถั่วทั้งคลาสที่เรียกว่า Persistence EJB ที่สามารถบันทึกตัวเองลงในฐานข้อมูลได้

แต่วันหนึ่งทุกอย่างเปลี่ยนไป...

1.2 การเกิดขึ้นของไฮเบอร์เนต

ในปี 2544 เวอร์ชันแรกของ Hibernate framework ได้รับการเผยแพร่ เป็นเฟรมเวิร์กที่เรียบง่ายมาก แต่อนุญาตให้ใช้ "วัตถุโง่ๆ" ทั่วไปที่ไม่รู้อะไรเลยว่าควรจัดเก็บไว้ในฐานข้อมูลหรือโหลดจากที่นั่นอย่างไร

การแม็พฟิลด์ของคลาส Java และคอลัมน์ในตารางในฐานข้อมูลถูกตั้งค่าโดยใช้ไฟล์ XML และบางครั้งก็ค่อนข้างเทอะทะ ตกลงฉันล้อเล่นใคร พวกมันเป็นผืนผ้าใบขนาดใหญ่ของรหัส XML และสถานการณ์ได้รับการช่วยเหลือโดยข้อเท็จจริงที่ว่าเมื่อ 20 ปีที่แล้วไม่มีฐานข้อมูลขนาดมหึมาเช่นนี้

แต่ในความเป็นจริง การตัดสินใจที่ทรงพลังที่สุดคือการแยกวัตถุที่ต้องการบันทึกลงในฐานข้อมูลออกจากรหัสที่บันทึกไว้ที่นั่น วิธีแก้ปัญหานี้ไม่ชัดเจนจริงๆ เนื่องจากหลักการของการห่อหุ้มระบุว่าวัตถุนั้นรู้ดีที่สุดว่าต้องจัดเก็บและโหลดอย่างไร

และแนวทางของ ORM ก็ทำลายแนวคิดนั้นจริงๆ คลาสข้อมูลเปิดเผยโครงสร้างภายใน แต่การทำงานกับกลุ่มของวัตถุประเภทต่างๆ นั้นง่ายกว่ามาก

ความก้าวหน้าครั้งสำคัญเกิดขึ้นหลังจากการเปิดตัว Java 5เมื่อมีสองสิ่งที่ปรากฏใน JDK:

• คำอธิบายประกอบ
• หนังสือมอบฉันทะ

คำอธิบายประกอบXML ถูกแทนที่อย่างรวดเร็ว และตอนนี้การระบุการตั้งค่าที่จำเป็นทั้งหมดสำหรับการแม็พคลาส Java กับตารางในฐานข้อมูลในคลาส Java นั้นเป็นเรื่องง่าย

หนังสือมอบฉันทะผู้ใช้ Hibernate ไม่สังเกตเห็นได้ชัดเจนนัก แต่การมีส่วนร่วมของพวกเขานั้นร้ายแรงยิ่งกว่า เมื่อคุณขออ็อบเจกต์เฉพาะหรืออ็อบเจ็กต์จาก Hibernate มันจะส่งคืน Stub (พร็อกซี) ให้คุณ และสกัดกั้นการเรียกใช้เมธอดทั้งหมด

สิ่งนี้ทำให้สามารถใช้กลไก Lazy Loading ต่างๆ และเพิ่มความเร็วและประสิทธิภาพของ Hibernate ไปสู่ระดับสูงสุดบนท้องฟ้าในช่วงเวลานั้น ไฮเบอร์เนตไม่ได้เป็นเพียงมาตรฐานอุตสาหกรรมโดยพฤตินัยเท่านั้น แต่ยังเริ่มมีการแปลเป็นภาษาอื่นด้วย ตัวอย่างเช่น Framework NHibernate ปรากฏขึ้นสำหรับ C#

1.3 การเกิดขึ้นของ JPA

โดยพฤตินัยตามด้วยการยอมรับโดยนิตินัย นักพัฒนา JDK ตัดสินใจสร้างข้อกำหนดเกี่ยวกับการแมปวัตถุกับตารางในฐานข้อมูลอย่างถูกต้อง ข้อกำหนดนี้เรียกว่าจป- Java Persistence API

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

ดูเหมือนว่าพวกเขาเพิ่งใช้ไฮเบอร์เนตเป็นพื้นฐานและเปลี่ยนชื่อแพ็คเกจจากมัน เนื่องจากคำอธิบายประกอบทั้งหมดที่อยู่ใน Hibernate ย้ายไปที่ JPA แทบจะทีละรายการ

วันนี้ Hibernate ใช้ข้อกำหนด JPA ทั้งหมดอย่างสมบูรณ์ รวมถึงคุณสมบัติเพิ่มเติมบางอย่างที่ทำให้การทำงานสะดวกสบายยิ่งขึ้น ดังนั้นในแง่ของมาตรฐาน เราสามารถพูดได้ว่า Hibernate มีคุณสมบัติสองชุด:

• มาตรฐาน JPA
• Hibernate Native API (ฟังก์ชันเพิ่มเติม)

เอกสารไฮเบอร์เนตอย่างเป็นทางการอธิบายไว้ดังนี้:

แต่จากประสบการณ์ของฉันและหลังจากอ่านเอกสาร Hibernate อีกครั้ง ฉันสามารถพูดได้ว่า JPA และ Hibernate API นั้นเหมือนกันถึง 95% พวกเขาเป็นเพียงแนวคิดที่เหมือนกัน

1.4 Maven สำหรับไฮเบอร์เนต

เนื่องจากฉันชื่นชม Hibernate มาก ฉันจึงคิดว่าถึงเวลาแล้วที่จะต้องทำงานกับมันให้หนักขึ้นอีกนิด

ประการแรก มีเว็บไซต์อย่างเป็นทางการที่มีเอกสารภาษาอังกฤษจำนวนมาก แน่นอนว่าเธอมีอคติในข้อมูลอ้างอิงและไม่ได้อยู่ในการฝึกอบรม แต่ก็ยังดีกว่าการดีบั๊กแหล่งที่มาใช่ไหม :)

คำแนะนำ:

1. คุณเปิดลิงค์
2. คุณมองเธอเป็นเวลานาน
3. กลับมาที่ CodeGym
4. คุณอ่านการบรรยายเพิ่มเติมของฉัน

งานของฉันคือทำให้เรื่องที่ซับซ้อนง่ายขึ้นและอธิบายด้วยคำง่ายๆ และถ้าคุณมาถึงระดับนี้แล้ว ฉันก็ทำได้

ในการเริ่มต้นใช้งาน Hibernate คุณต้องเพิ่มลงใน pom.xml ของคุณ จนถึงปัจจุบัน Hibernate เวอร์ชันที่ 6 มีให้บริการแล้วหรือมากกว่า 6.1.1 ดังนั้นเราจะเรียนรู้วิธีทำงานกับเวอร์ชันล่าสุด

เพียงเพิ่มบรรทัดเหล่านี้ใน pom.xml ของคุณ:

<dependency>
	<groupId>org.hibernate</groupId>
    <artifactId>hibernate-core</artifactId>
	<version>6.1.1.Final</version>
</dependency>

หากคุณกำลังอ่านการบรรยายนี้นอกกรอบปี 2023+ คุณสามารถดาวน์โหลด เวอร์ชันใหม่ได้ที่ นี่

สำคัญ! ไลบรารีบางตัวที่ Hibernate ใช้เลิกใช้แล้วใน JDK 11 และ JDK 17 ดังนั้นหากคุณมีปัญหาในการเริ่มต้นและรันโปรเจ็กต์ ให้เพิ่มการขึ้นต่อกันเหล่านี้:

  	<dependency>
        <groupId>jakarta.xml.bind</groupId>
        <artifactId>jakarta.xml.bind-api</artifactId>
      	<version>4.0.0</version>
  	</dependency>
 
  	<dependency>
        <groupId>org.glassfish.jaxb</groupId>
        <artifactId>jaxb-runtime</artifactId>
      	<version>4.0.0</version>
  	</dependency>
 
  	<dependency>
        <groupId>org.javassist</groupId>
        <artifactId>javassist</artifactId>
        <version>3.29.0-GA</version>
  	</dependency>