1.1 การแม็พคลาสกับตาราง
หลังจากเรียนรู้ JDBC แล้ว คุณมักจะรู้สึกว่าการทำงานกับฐานข้อมูลจากแอปพลิเคชัน Java ยังคงเป็นเรื่องน่ายินดี ถ้าฉันบอกคุณว่างานทั้งหมดนี้สามารถทำได้ง่ายขึ้น 10 เท่า
ประโยชน์หลักของภาษา SQL คืออะไร? นี่เป็นภาษาที่เปิดเผย - มันอธิบายถึงสิ่งที่เราต้องการและไม่พูดอะไรเลยเกี่ยวกับวิธีการทำ อย่างไร - นี่เป็นข้อกังวลของเซิร์ฟเวอร์ SQL
สามารถใช้วิธีการเดียวกันนี้เมื่อทำงานกับฐานข้อมูล
ในโลกอุดมคติ เราสามารถเขียนแบบสอบถาม SQL ลงในฐานข้อมูล และตอบสนองเราจะได้รับวัตถุ Java สำเร็จรูปหรือคอลเลกชันของวัตถุ Java ถ้าเราขอหลายชิ้น
ฉันจะพูดอะไรได้ นี่คือสิ่งที่ผู้ชายหลายคนคิดในปี 2000 และตัดสินใจที่จะเขียนกรอบ ORM ของตัวเอง
ORMย่อมาจากObject-Relational Mappingและโดยพื้นฐานแล้วเป็นการแมปของ Java Object กับ SQL Query
พวกเขาคิดสิ่งง่ายๆ ขึ้นมาได้แต่ละตารางในฐานข้อมูลต้องสอดคล้องกับบางคลาสในแอปพลิเคชัน Java ในแอปพลิเคชัน Java เราดำเนินการกับออบเจกต์ และออบเจ็กต์เหล่านี้รู้วิธีบันทึกตัวเองลงในฐานข้อมูลอยู่แล้ว
มีสามวิธีในการแก้ปัญหานี้ และมีลักษณะดังนี้:
- วัตถุจะบันทึกตัวเองลงในฐานข้อมูลและอัปเดตฟิลด์ตามข้อมูลจากฐานข้อมูล
- วัตถุสามารถบันทึกตัวเองไปยังฐานข้อมูล แต่ไม่เคยเริ่มต้นกรณีนี้
- วัตถุประกอบด้วยข้อมูลเท่านั้น และมีคนบันทึกไว้ในฐานข้อมูลและโหลดจากฐานข้อมูล
ในขั้นต้น แนวทางแรกครอบงำ จากนั้นเซิร์ฟเวอร์แอปพลิเคชันและ 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 มาก ฉันจึงคิดว่าถึงเวลาแล้วที่จะต้องทำงานกับมันให้หนักขึ้นอีกนิด
ประการแรก มีเว็บไซต์อย่างเป็นทางการที่มีเอกสารภาษาอังกฤษจำนวนมาก แน่นอนว่าเธอมีอคติในข้อมูลอ้างอิงและไม่ได้อยู่ในการฝึกอบรม แต่ก็ยังดีกว่าการดีบั๊กแหล่งที่มาใช่ไหม :)
คำแนะนำ:
- คุณเปิดลิงค์
- คุณมองเธอเป็นเวลานาน
- กลับมาที่ CodeGym
- คุณอ่านการบรรยายเพิ่มเติมของฉัน
งานของฉันคือทำให้เรื่องที่ซับซ้อนง่ายขึ้นและอธิบายด้วยคำง่ายๆ และถ้าคุณมาถึงระดับนี้แล้ว ฉันก็ทำได้
ในการเริ่มต้นใช้งาน 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>