แอปพลิเคชั่น Hibernate แรกของคุณ

ในบทความนี้ คุณจะทำความคุ้นเคยกับหนึ่งในเฟรมเวิร์กองค์กรยอดนิยมสำหรับ Java และสร้างแอปพลิเคชัน Hibernate แรกของคุณ ไม่เคยได้ยินเกี่ยวกับไฮเบอร์เนต? หรือบางทีคุณอาจเคยได้ยินแต่ยังไม่เคยใช้? หรือบางทีคุณอาจพยายามใช้แต่ล้มเหลว? ในทั้งสามกรณี - ยินดีต้อนรับสู่ด้านล่างของการตัด :) สวัสดีทุกคน! ในบทความนี้ ฉันจะพูดถึงคุณสมบัติหลักของเฟรมเวิร์ก Hibernate และช่วยคุณเขียนแอปพลิเคชันขนาดเล็กตัวแรกของคุณ สำหรับสิ่งนี้ เราต้องการ:

1. 
   ดาวน์โหลดIntelliJ IDEA Ultimate Edition จาก เว็บไซต์อย่างเป็นทางการและเปิดใช้งานรุ่นทดลองใช้ 30 วัน
2. PostgreSQL - หนึ่งในระบบจัดการฐานข้อมูลสมัยใหม่ที่ได้รับความนิยมสูงสุด (DBMS)
3. Maven (เชื่อมต่อกับ IDEA แล้ว)
4. อดทนอีกนิด

ในกรณีที่ฉันโพสต์รหัสแอปพลิเคชันบนGitHub (สาขา codegym) บทความนี้มุ่งเป้าไปที่ผู้ที่ไม่เคยใช้เทคโนโลยีนี้มาก่อน ดังนั้นฉันจึงลดจำนวนโค้ดให้เหลือน้อยที่สุด มาเริ่มกันเลย!

ไฮเบอร์เนตคืออะไร?

เป็นหนึ่งในการใช้งานการทำแผนที่เชิงวัตถุ (ORM) ที่ได้รับความนิยมมากที่สุด การทำแผนที่เชิงวัตถุกำหนดความสัมพันธ์ระหว่างวัตถุซอฟต์แวร์และบันทึกฐานข้อมูล แน่นอนว่า Hibernate มีฟังก์ชันการทำงานที่หลากหลายมาก แต่เราจะเน้นไปที่ฟังก์ชันที่ง่ายที่สุด เป้าหมายของเราคือการสร้างแอปพลิเคชัน CRUD (สร้าง อ่าน อัปเดต ลบ) ที่จะสามารถ:

1. สร้างผู้ใช้ (User) ค้นหาในฐานข้อมูลด้วย ID อัปเดตข้อมูลในฐานข้อมูล และลบออกจากฐานข้อมูล
2. กำหนดวัตถุรถยนต์ (อัตโนมัติ) ให้กับผู้ใช้ สร้าง อัปเดต ค้นหา และลบรถยนต์ออกจากฐานข้อมูล
3. นอกจากนี้ แอปพลิเคชันควรลบรถยนต์ที่ "ไม่มีเจ้าของ" ออกจากฐานข้อมูลโดยอัตโนมัติ กล่าวอีกนัยหนึ่ง เมื่อผู้ใช้ถูกลบ รถยนต์ทั้งหมดที่เป็นของผู้ใช้นั้นจะต้องถูกลบออกจากฐานข้อมูลด้วย

โครงการของเราจะมีโครงสร้างดังนี้ อย่างที่คุณเห็น ไม่มีอะไรซับซ้อน 6 คลาส + 1 ไฟล์พร้อมการกำหนดค่า ขั้นแรก สร้างโครงการ Maven ใหม่ใน IntelliJ IDEA ไฟล์ -> โครงการใหม่ เลือก Maven จากประเภทโครงการที่เสนอและย้ายไปยังขั้นตอนถัดไป Apache Maven เป็นเฟรมเวิร์กสำหรับสร้างโปรเจ็กต์โดยอัตโนมัติตามคำอธิบายของโครงสร้างในไฟล์ POM โครงสร้างทั้งหมดของโครงการของคุณจะอธิบายไว้ใน pom.xml ซึ่งเป็นไฟล์ที่ IDEA สร้างขึ้นเองในรูทของโครงการของคุณ ในการตั้งค่าโครงการ คุณต้องระบุการตั้งค่า Maven ต่อไปนี้: groupId และ artifactId ในโครงการ groupId มักจะเป็นรายละเอียดของบริษัทหรือหน่วยธุรกิจ ชื่อโดเมนของบริษัทหรือเว็บไซต์สามารถไปที่นี่ ในทางกลับกัน artifactId คือชื่อของโครงการ สำหรับ groupdId คุณสามารถcom.yourNickname.codegymป้อน การดำเนินการนี้จะไม่มีผลใดๆ ต่อแอปพลิเคชัน สำหรับ artifactId ให้เลือกชื่อโปรเจ็กต์ที่คุณต้องการ เวอร์ชันไม่สามารถเปลี่ยนแปลงได้ ในหน้าจอสุดท้าย เพียงยืนยันข้อมูลที่ป้อนก่อนหน้านี้ดังนั้นเราจึงสร้างโครงการ ตอนนี้สิ่งที่ต้องทำคือเขียนโค้ดและทำให้มันใช้งานได้ :) สิ่งแรกอย่างแรก: หากเราต้องการสร้างแอปพลิเคชันที่ทำงานร่วมกับฐานข้อมูล เราไม่สามารถทำได้หากไม่มีฐานข้อมูล! ดาวน์โหลด PostgreSQL จากที่นี่ (ฉันใช้เวอร์ชัน 9) PostgreSQL มีผู้ใช้เริ่มต้นคือ 'postgres' คุณจะต้องคิดรหัสผ่านเมื่อทำการติดตั้ง อย่าลืมรหัสผ่าน เราต้องการมันในภายหลัง! (โดยทั่วไป การใช้ฐานข้อมูลเริ่มต้นในแอปพลิเคชันถือเป็นแนวทางปฏิบัติที่ไม่ดี แต่เราจะทำเพื่อลดจำนวนแผลที่เกิดจากการสร้างฐานข้อมูลของคุณเอง) หากคุณไม่ได้เป็นเพื่อนกับบรรทัดคำสั่งและคำสั่ง SQL มีข่าวดี IntelliJ IDEA มีส่วนติดต่อผู้ใช้ที่เหมาะสมอย่างยิ่งสำหรับการทำงานกับฐานข้อมูล (อยู่ในบานหน้าต่างด้านขวาของ IDEA แท็บฐานข้อมูล) หากต้องการสร้างการเชื่อมต่อ ให้คลิก "+" แล้วเลือกแหล่งข้อมูลของเรา (PostgeSQL) กรอกข้อมูลในช่องสำหรับผู้ใช้และฐานข้อมูล ("postgres" สำหรับทั้งสองช่อง) และป้อนรหัสผ่านที่ตั้งไว้ระหว่างการติดตั้ง PostgreSQL หากจำเป็น ให้ดาวน์โหลดไดรเวอร์ Postgres คุณสามารถทำได้ในหน้าเดียวกัน คลิก "ทดสอบการเชื่อมต่อ" เพื่อยืนยันว่าสร้างการเชื่อมต่อฐานข้อมูลแล้ว หากคุณเห็น "สำเร็จ" ให้ดำเนินการต่อ ตอนนี้เราจะสร้างตารางที่เราต้องการ จะมีทั้งหมดสอง: ผู้ใช้และอัตโนมัติ พารามิเตอร์สำหรับตารางผู้ใช้: โปรดทราบว่า id เป็นคีย์หลัก หากคุณไม่รู้ว่าคีย์หลักคืออะไรใน SQL ให้ Google ค้นหา นี้เป็นสิ่งสำคัญ. การตั้งค่าสำหรับตารางรถยนต์: สำหรับตาราง autos คุณต้องกำหนดค่าคีย์นอก มันจะทำหน้าที่เชื่อมโยงตารางของเรา ฉันขอแนะนำให้คุณอ่านเพิ่มเติมเกี่ยวกับเรื่องนี้ พูดง่ายๆ คืออ้างอิงตารางภายนอก ในกรณีของเราคือผู้ใช้ หากรถยนต์เป็นของผู้ใช้ที่มี id = 1 ช่อง user_id ของรถยนต์จะเท่ากับ 1 นี่คือวิธีที่เราเชื่อมโยงผู้ใช้กับรถยนต์ของพวกเขาในแอปพลิเคชันของเรา ในตาราง autos ฟิลด์ user_id จะทำหน้าที่เป็นคีย์นอก มันจะอ้างถึงฟิลด์ id ของตารางผู้ใช้ ดังนั้นเราจึงสร้างฐานข้อมูลที่มีสองตาราง สิ่งที่เหลืออยู่คือการเข้าใจวิธีจัดการจากโค้ด Java เราจะเริ่มต้นด้วยไฟล์ pom.xml ซึ่งเราจำเป็นต้องรวมไลบรารีที่จำเป็น (ใน Maven เรียกว่าการพึ่งพา) ไลบรารีทั้งหมดถูกจัดเก็บไว้ในที่เก็บ Maven ส่วนกลาง ไลบรารีที่คุณระบุใน pom.xml มีให้คุณใช้ในโครงการ pom.xml ของคุณควรมีลักษณะดังนี้: ไม่มีอะไรซับซ้อนอย่างที่คุณเห็น เราเพิ่มการอ้างอิงเพียง 2 รายการ — สำหรับการใช้ PostgreSQL และ Hibernate ตอนนี้เรามาที่โค้ด Java กัน สร้างแพ็คเกจและคลาสที่จำเป็นทั้งหมดในโครงการ ในการเริ่มต้น เราจำเป็นต้องมีโมเดลข้อมูล: the UserและAutoคลาส

 package models;
 
 import javax.persistence.*;
 import java.util.ArrayList;
 import java.util.List;
 
 @Entity
 @Table (name = "users")
 public class User {
 
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private int id;
     @Column(name = "name")
     private String name;
     // You can omit the Column attribute if the name property matches the column name in the table
     private int age;
 
     @OneToMany(mappedBy = "user", cascade = CascadeType.ALL, orphanRemoval = true)
     private List<Auto> autos;
 
     public User() {
     }
 
     public User(String name, int age) {
         this.name = name;
         this.age = age;
         autos = new ArrayList<>();
     }
 
     public void addAuto(Auto auto) {
         auto.setUser(this);
         autos.add(auto);
     }
 
     public void removeAuto(Auto auto) {
         autos.remove(auto);
     }
 
     public int getId() {
         return id;
     }
 
     public String getName() {
         return name;
     }
 
     public void setName(String name) {
         this.name = name;
     }
 
     public int getAge() {
         return age;
     }
 
     public void setAge(int age) {
         this.age = age;
     }
 
     public List<Auto> getAutos() {
         return autos;
     }
 
     public void setAutos(List<Auto> autos) {
         this.autos = autos;
     }
 
     @Override
     public String toString() {
         return "models.User{" +
                 "id=" + id +
                 ", name='" + name + '\'' +
                 ", age=" + age +
                 '}';
     }
 }
 
 

 package models;
 
 import javax.persistence.*;
 
 @Entity
 @Table(name = "autos")
 public class Auto {
 
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private int id;
 
     @Column (name = "model")
     private String model;
 
     // You can omit the Column attribute if the name property matches the column name in the table
     private String color;
 
 
     @ManyToOne(fetch = FetchType.LAZY)
     @JoinColumn(name = "user_id")
     private User user;
 
     public Auto() {
     }
 
     public Auto(String model, String color) {
         this.model = model;
         this.color = color;
     }
 
     public int getId() {
         return id;
     }
 
     public String getModel() {
         return model;
     }
 
     public void setModel(String model) {
         this.model = model;
     }
 
     public String getColor() {
         return color;
     }
 
     public void setColor(String color) {
         this.color = color;
     }
 
     public User getUser() {
         return user;
     }
 
     public void setUser(User user) {
         this.user = user;
     }
 
     @Override
     public String toString() {
         return color + " " + model;
     }
 }
 
 

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

• ต้องมีตัวสร้างว่าง ( publicหรือprotected)
• ไม่สามารถซ้อนอินเทอร์เฟซหรือenum
• ไม่สามารถfinalและไม่มีfinalเขตข้อมูล/คุณสมบัติ
• ต้องมีฟิลด์ @Id อย่างน้อยหนึ่งฟิลด์

ตรวจสอบชั้นเรียนเอนทิตีของคุณ: เป็นสถานที่ยอดนิยมในการยิงตัวเองด้วยเท้า มันง่ายมากที่จะลืมบางสิ่ง นอกจากนี้ กิจการยังสามารถดำเนินการดังต่อไปนี้:

• สามารถมีตัวสร้างที่ไม่ว่างเปล่า
• สามารถสืบทอดและสืบทอดได้
• สามารถมีวิธีการอื่นและใช้อินเทอร์เฟซ

อย่างที่คุณเห็นUserคลาสนั้นคล้ายกับตารางผู้ใช้มาก มีid, name, และageเขตข้อมูล คำอธิบายประกอบที่อยู่ด้านบนไม่ต้องการคำอธิบายใด ๆ เป็นที่ชัดเจนว่า @Id ระบุว่าฟิลด์เป็นตัวระบุของออบเจ็กต์ของคลาสนี้ คำอธิบายประกอบ @Table เหนือคลาสระบุชื่อของตารางที่มีการเขียนวัตถุ หมายเหตุความคิดเห็นเหนือฟิลด์อายุ: ถ้าชื่อของฟิลด์ในคลาสเหมือนกับชื่อของตาราง คุณสามารถละเว้น @Column คำอธิบายประกอบและจะใช้ได้ สำหรับส่วนที่ระบุไว้ในเครื่องหมายปีกกา ("กลยุทธ์ = GenerationType.IDENTITY"): มีหลายกลยุทธ์ในการสร้าง ID คุณสามารถ Google ได้ แต่สำหรับแอปพลิเคชันของเรา ไม่ต้องกังวล สิ่งสำคัญคือสำหรับวัตถุของเรา ค่าของ id จะถูกสร้างขึ้นโดยอัตโนมัติ ดังนั้นจึงไม่มีตัวตั้งค่าสำหรับ id และเราไม่ได้ตั้งค่าในตัวสร้างเช่นกัน อย่างไรก็ตาม,Userชั้นไม่โดดเด่น มีรายชื่อรถแล้ว! คำอธิบายประกอบ @OneToMany แขวนอยู่เหนือรายการ หมายความว่ารถยนต์หลายคันสามารถสอดคล้องกับวัตถุเดียวกันของคลาสผู้ใช้ องค์ประกอบ "mappedBy" อ้างถึงฟิลด์ผู้ใช้ของAutoคลาส รถยนต์และผู้ใช้จึงมีความเกี่ยวข้องกัน องค์ประกอบ orphanRemoval ระบุว่าจะใช้การดำเนินการลบกับเอนทิตีที่ไม่มีความสัมพันธ์อีกต่อไปหรือไม่ หากเราลบผู้ใช้ออกจากฐานข้อมูล รถยนต์ทั้งหมดที่เกี่ยวข้องกับผู้ใช้นั้นจะถูกลบด้วย ในทางกลับกัน ในAutoคุณจะเห็นฟิลด์ผู้ใช้พร้อมคำอธิบายประกอบ @ManyToOne (ผู้ใช้หนึ่งคนสามารถสอดคล้องกับหลายอัตโนมัติ) และคำอธิบายประกอบ @JoinColumn ระบุว่าคอลัมน์ใดในตาราง autos ใช้เพื่ออ้างอิงตารางผู้ใช้ (เช่น foreign key ที่เราพูดถึงก่อนหน้านี้) หลังจากสร้างโมเดลข้อมูลแล้ว ก็ถึงเวลาสอนโปรแกรมของเราให้ดำเนินการกับข้อมูลในฐานข้อมูล เริ่มต้นด้วยคลาสยูทิลิตี้ HibernateSessionFactoryUtil มีเพียงงานเดียวเท่านั้น — เพื่อสร้างโรงงานเซสชั่นสำหรับแอปพลิเคชันของเราเพื่อทำงานกับฐานข้อมูล (ทักทายกับรูปแบบการออกแบบโรงงาน!) มันไม่รู้ว่าจะต้องทำอย่างไรอีก

 package utils;
 
 import models.Auto;
 import models.User;
 import org.hibernate.SessionFactory;
 import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
 import org.hibernate.cfg.Configuration;
 
 public class HibernateSessionFactoryUtil {
     private static SessionFactory sessionFactory;
 
     private HibernateSessionFactoryUtil() {}
 
     public static SessionFactory getSessionFactory() {
         if (sessionFactory == null) {
             try {
                 Configuration configuration = new Configuration().configure();
                 configuration.addAnnotatedClass(User.class);
                 configuration.addAnnotatedClass(Auto.class);
                 StandardServiceRegistryBuilder builder = new StandardServiceRegistryBuilder().applySettings(configuration.getProperties());
                 sessionFactory = configuration.buildSessionFactory(builder.build());
 
             } catch (Exception e) {
                 System.out.println("Исключение!" + e);
             }
         }
         return sessionFactory;
     }
 }
 

ในคลาสนี้ เราสร้าง Configuration object ใหม่ และส่งไปยังคลาสที่ควรถือว่าเป็นเอนทิตี: Userและ Autoให้ความสนใจกับconfiguration.getProperties()วิธีการ มีคุณสมบัติอะไรอีกบ้าง? พวกเขามาจากที่ไหน? คุณสมบัติคือการตั้งค่าไฮเบอร์เนตที่ระบุในไฟล์ hibernate.cfg.xml พิเศษ อ่าน Hibernate.cfg.xml ที่นี่: new Configuration().configure(); อย่างที่คุณเห็น ไม่มีอะไรพิเศษเกี่ยวกับมัน: มันมีพารามิเตอร์สำหรับการเชื่อมต่อกับฐานข้อมูล เช่นเดียวกับพารามิเตอร์ show_sql สิ่งนี้จำเป็นเพื่อให้การสืบค้น sql ทั้งหมดที่ดำเนินการโดย Hibernate แสดงบนคอนโซล ด้วยวิธีนี้คุณจะเห็นได้อย่างชัดเจนว่า Hibernate กำลังทำอะไรในช่วงเวลาใดเวลาหนึ่ง โดยขจัดความรู้สึกของ "เวทมนตร์" ออกไป ต่อไปเราต้องการUserDAOระดับ. แนวทางปฏิบัติที่ดีที่สุดคือการเขียนโปรแกรมผ่านอินเทอร์เฟซ — สร้างUserDAOอินเทอร์เฟซแยกต่างหากและUserDAOImplการใช้งาน แต่ฉันจะข้ามขั้นตอนนี้ไปเพื่อลดจำนวนโค้ด อย่าทำสิ่งนี้ในโครงการจริง! รูปแบบการออกแบบ DAO (วัตถุเข้าถึงข้อมูล) เป็นหนึ่งในรูปแบบที่พบได้บ่อยที่สุด แนวคิดนั้นเรียบง่าย — สร้างเลเยอร์แอปพลิเคชันที่มีหน้าที่เข้าถึงข้อมูลเท่านั้น ไม่มีอะไรเพิ่มเติม ดึงข้อมูลจากฐานข้อมูล อัปเดตข้อมูล ลบข้อมูล แค่นั้น ศึกษาเพิ่มเติมเกี่ยวกับ DAO คุณจะใช้วัตถุเข้าถึงข้อมูลอย่างต่อเนื่องในการทำงานของคุณ UserDaoชั้นเรียนของเราทำอะไรได้บ้าง เช่นเดียวกับ DAO ทั้งหมด สามารถทำงานกับข้อมูลเท่านั้น ค้นหาผู้ใช้ด้วย id อัปเดตข้อมูล ลบออก รับรายชื่อผู้ใช้ทั้งหมดจากฐานข้อมูล หรือบันทึกผู้ใช้ใหม่ในฐานข้อมูล นั่นคือฟังก์ชันการทำงานทั้งหมด

 package dao;
 
 import models.Auto;
 import models.User;
 import org.hibernate.Session;
 import org.hibernate.Transaction;
 import utils.HibernateSessionFactoryUtil;
 import java.util.List;
 
 public class UserDao {
 
     public User findById(int id) {
         return HibernateSessionFactoryUtil.getSessionFactory().openSession().get(User.class, id);
     }
 
     public void save(User user) {
         Session session = HibernateSessionFactoryUtil.getSessionFactory().openSession();
         Transaction tx1 = session.beginTransaction();
         session.save(user);
         tx1.commit();
         session.close();
     }
 
     public void update(User user) {
         Session session = HibernateSessionFactoryUtil.getSessionFactory().openSession();
         Transaction tx1 = session.beginTransaction();
         session.update(user);
         tx1.commit();
         session.close();
     }
 
     public void delete(User user) {
         Session session = HibernateSessionFactoryUtil.getSessionFactory().openSession();
         Transaction tx1 = session.beginTransaction();
         session.delete(user);
         tx1.commit();
         session.close();
     }
 
     public Auto findAutoById(int id) {
         return HibernateSessionFactoryUtil.getSessionFactory().openSession().get(Auto.class, id);
     }
 
     public List<User> findAll() {
         List<User> users = (List<User>) HibernateSessionFactoryUtil.getSessionFactory().openSession().createQuery("From User").list();
         return users;
     }
 }
 

UserDaoวิธีการของมันก็คล้ายๆกัน โดยส่วนใหญ่แล้ว เราได้รับSession object (เซสชันการเชื่อมต่อฐานข้อมูล) โดยใช้ Session Factory ของเรา สร้างธุรกรรมเดียวภายในเซสชันนี้ ดำเนินการจัดการข้อมูลที่จำเป็น บันทึกผลลัพธ์ของธุรกรรมในฐานข้อมูล แล้วปิดเซสชัน อย่างที่คุณเห็นวิธีการนั้นค่อนข้างง่าย DAO คือ "หัวใจ" ของแอปพลิเคชันของเรา อย่างไรก็ตาม เราจะไม่สร้าง DAO โดยตรงและเรียกเมธอดของมันในmain()เมธอด ของเรา ตรรกะทั้งหมดจะถูกย้ายไปยังUserServiceชั้นเรียน

 package services;
 
 import dao.UserDao;
 import models.Auto;
 import models.User;
 
 import java.util.List;
 
 public class UserService {
 
     private UserDao usersDao = new UserDao();
 
     public UserService() {
     }
 
     public User findUser(int id) {
         return usersDao.findById(id);
     }
 
     public void saveUser(User user) {
         usersDao.save(user);
     }
 
     public void deleteUser(User user) {
         usersDao.delete(user);
     }
 
     public void updateUser(User user) {
         usersDao.update(user);
     }
 
     public List<User> findAllUsers() {
         return usersDao.findAll();
     }
 
     public Auto findAutoById(int id) {
         return usersDao.findAutoById(id);
     }
 
 
 }
 
 

บริการเป็นชั้นข้อมูลแอปพลิเคชันที่รับผิดชอบในการดำเนินการตรรกะทางธุรกิจ หากโปรแกรมของคุณต้องดำเนินการตามตรรกะทางธุรกิจบางประเภท จะดำเนินการผ่านบริการต่างๆ บริการประกอบด้วย a UserDaoและเรียกใช้เมธอด DAO ในเมธอด อาจดูเหมือนว่าเรากำลังทำซ้ำฟังก์ชันที่นี่ (ทำไมไม่เรียกเมธอดจากวัตถุ DAO ล่ะ) แต่ด้วยออบเจกต์จำนวนมากและตรรกะที่ซับซ้อน การแบ่งชั้นของแอปพลิเคชันให้ประโยชน์อย่างมาก (การทำเช่นนี้ถือเป็นแนวทางปฏิบัติที่ดี — จำสิ่งนี้ไว้ในอนาคต และอ่านเกี่ยวกับ "ชั้นแอปพลิเคชัน") บริการของเรามีตรรกะง่ายๆ แต่วิธีการบริการในโครงการในโลกแห่งความจริงมีโค้ดมากกว่าหนึ่งบรรทัด :) ตอนนี้เรามีทุกสิ่งที่คุณต้องการเพื่อเรียกใช้แอปพลิเคชัน! ในmain()วิธีการนี้ เรามาสร้างผู้ใช้และรถของผู้ใช้ เชื่อมโยงกัน และบันทึกไว้ในฐานข้อมูล

 import models.Auto;
 import models.User;
 import services.UserService;
 
 import java.sql.SQLException;
 
 public class Main {
     public static void main(String[] args) throws SQLException {
 
         UserService userService = new UserService();
         User user = new User ("Jenny", 26);
         userService.saveUser(user);
         Auto ferrari = new Auto("Ferrari", "red");
         ferrari.setUser(user);
         user.addAuto(ferrari);
         Auto ford = new Auto("Ford", "black");
         ford.setUser(user);
         user.addAuto(ford);
         userService.updateUser(user);
     }
 }
 
 

อย่างที่คุณเห็น ตารางผู้ใช้มีบันทึกของตัวเอง และตารางรถยนต์มีบันทึกของตัวเอง ลองเปลี่ยนชื่อผู้ใช้ของเรา ล้างตารางผู้ใช้และรันโค้ด

 import models.Auto;
 import models.User;
 import services.UserService;
 
 import java.sql.SQLException;
 
 public class Main {
     public static void main(String[] args) throws SQLException {
 
         UserService userService = new UserService();
         User user = new User ("Jenny", 26);
         userService.saveUser(user);
         Auto ferrari = new Auto("Ferrari", "red");
         user.addAuto(ferrari);
         Auto ford = new Auto("Ford", "black");
         ford.setUser(user);
         user.addAuto(ford);
         userService.updateUser(user);
         user.setName ("Benny");
         userService.updateUser(user);
     }
 }
 
 

มันได้ผล! จะเกิดอะไรขึ้นถ้าคุณลบผู้ใช้ ล้างตารางผู้ใช้ (อัตโนมัติจะล้างตัวเอง) และดำเนินการรหัส

 import models.Auto;
 import models.User;
 import services.UserService;
 
 import java.sql.SQLException;
 
 public class Main {
     public static void main(String[] args) throws SQLException {
 
         UserService userService = new UserService();
         User user = new User ("Jenny", 26);
         userService.saveUser(user);
         Auto ferrari = new Auto("Ferrari", "red");
         user.addAuto(ferrari);
         Auto ford = new Auto("Ford", "black");
         ford.setUser(user);
         user.addAuto(ford);
         userService.updateUser(user);
         user.setName ("Benny");
         userService.updateUser(user);
         userService.deleteUser(user);
     }
 }
 
 

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