แอปพลิเคชั่น 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" ฉันได้ตรวจสอบในบทความก่อนหน้านี้ ฉันหวังว่าบทความนี้จะเป็นประโยชน์กับผู้อ่าน หากคุณมีคำถามให้ถามพวกเขาในความคิดเห็น ฉันยินดีที่จะตอบ :) นอกจากนี้อย่าลืมสนับสนุนผู้เขียนในการแข่งขันด้วยการโพสต์ "ถูกใจ" หรือดีกว่านั้น — "รักเลย" :) ขอให้โชคดีในการเรียน!