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

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

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

บทความนี้มุ่งเป้าไปที่ผู้ที่ไม่เคยใช้เทคโนโลยีนี้มาก่อน ดังนั้นจำนวนโค้ดจึงลดลงให้มากที่สุด มาเริ่มกันเลย!

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

นี่เป็นหนึ่งในการใช้งานโมเดล 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.вашНикнейм.javarushซึ่งจะไม่ส่งผลต่อการทำงานของแอปพลิเคชันแต่อย่างใด สำหรับ artifactId ให้เลือกชื่อโปรเจ็กต์ที่คุณต้องการ คุณสามารถปล่อยให้เวอร์ชันไม่เปลี่ยนแปลงได้ ในหน้าจอสุดท้าย เพียงยืนยันข้อมูลที่ป้อนไว้ก่อนหน้านี้ ดังนั้นเราจึงสร้างโปรเจ็กต์ขึ้นมา สิ่งที่เหลืออยู่คือการเขียนโค้ดและทำให้มันใช้งานได้ :) ก่อนอื่นเลย หากเราต้องการสร้างแอปพลิเคชันที่ทำงานร่วมกับฐานข้อมูล เราจะไม่สามารถทำได้หากไม่มีฐานข้อมูลอย่างแน่นอน! ดาวน์โหลด PostgreSQL จากที่นี่ (ฉันใช้เวอร์ชัน 9) PostgreSQL มีผู้ใช้เริ่มต้น 'postgres' คุณจะต้องสร้างรหัสผ่านระหว่างการติดตั้ง อย่าลืมรหัสผ่านของคุณ เราจะต้องใช้มันในภายหลัง! (โดยทั่วไป การใช้ฐานข้อมูลเริ่มต้นในแอปพลิเคชันถือเป็นแนวทางปฏิบัติที่ไม่ดี แต่เพื่อลดจำนวนริดสีดวงทวาร เราจะสร้างฐานข้อมูลของเราเองแทน) หากคุณไม่คุ้นเคยกับบรรทัดคำสั่งและการสืบค้น SQL ก็มีข่าวดี Intellij IDEA มีอินเทอร์เฟซผู้ใช้ที่ค่อนข้างเหมาะสมสำหรับการทำงานกับฐานข้อมูล มีลักษณะดังนี้: (อยู่ที่แถบด้านข้างขวาของ IDEA แท็บฐานข้อมูล) หากต้องการสร้างการเชื่อมต่อ คลิก “+” เลือกผู้ให้บริการของเรา (PostgeSQL) กรอกข้อมูลในฟิลด์ด้วยชื่อผู้ใช้ ชื่อฐานข้อมูล (ทั้งสองเป็น postgres) และป้อนรหัสผ่านที่คุณตั้งไว้เมื่อติดตั้ง PostgreSQL หากจำเป็น ให้ดาวน์โหลดไดรเวอร์ Postgres ซึ่งสามารถทำได้ในหน้าเดียวกันนี้ คลิก "ทดสอบการเชื่อมต่อ" เพื่อตรวจสอบว่ามีการเชื่อมต่อกับฐานข้อมูลแล้ว หากคุณเห็นข้อความว่า "สำเร็จ" เราก็เดินหน้าต่อไป ตอนนี้เรามาสร้างตารางที่เราต้องการกันดีกว่า จะมีสองคน - ผู้ใช้และรถยนต์ พารามิเตอร์สำหรับตารางผู้ใช้: โปรดทราบว่า id เป็นคีย์หลัก หากคุณไม่ทราบว่าคีย์หลักคืออะไรใน SQL Google เป็นสิ่งสำคัญ การตั้งค่าสำหรับตารางรถยนต์: สำหรับรถยนต์คุณต้องกำหนดค่า Foreign Key - Foreign Key มันจะเชื่อมโยงตารางของเรา ฉันแนะนำให้คุณอ่านเพิ่มเติมเกี่ยวกับเขา พูดง่ายๆ ก็คือหมายถึงตารางภายนอก ในกรณีของเราคือผู้ใช้ หากรถยนต์เป็นของผู้ใช้ที่มี id=1 ดังนั้นในช่อง user_id ของตาราง autos ก็จะมี 1 นี่คือวิธีที่เราเชื่อมต่อผู้ใช้กับรถยนต์ของพวกเขาในแอปพลิเคชันของเรา ในตารางรถยนต์ของเรา ช่อง user_id จะทำหน้าที่เป็นคีย์นอก มันจะอ้างอิงถึงฟิลด์ id ของตารางผู้ใช้ ดังนั้นเราจึงสร้างฐานข้อมูลที่มีสองตาราง ยังคงต้องเข้าใจวิธีจัดการจากโค้ด Java เราจะเริ่มต้นด้วยไฟล์ pom.xml ซึ่งเราจำเป็นต้องรวมไลบรารีที่จำเป็น (ในภาษา Maven เรียกว่าการพึ่งพา) ไลบรารีทั้งหมดจะถูกจัดเก็บไว้ในที่เก็บ Maven ส่วนกลาง สิ่งที่คุณระบุใน pom.xml คุณสามารถใช้ในโปรเจ็กต์ได้ pom.xml ของคุณควรมีลักษณะดังนี้: ไม่มีอะไรซับซ้อนอย่างที่คุณเห็น เราได้เพิ่มการอ้างอิงเพียง 2 รายการ - สำหรับการใช้ PostgreSQL และ Hibernate ตอนนี้เรามาดูโค้ด Java กันดีกว่า สร้างแพ็คเกจและคลาสที่จำเป็นทั้งหมดสำหรับโปรเจ็กต์ ขั้นแรกเราจะต้องมีโมเดลข้อมูล - คลาส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 not specify Column name if it matches the name of the column 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 not specify Column name if it matches the name of the column 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 อ่านเกี่ยวกับเรื่องนี้ใน Wikipedia และจำทุกอย่างนี่คือพื้นฐานของพื้นฐาน คำอธิบายประกอบนี้อนุญาตให้อ็อบเจ็กต์ Java ของคลาสของคุณเชื่อมโยงกับฐานข้อมูลได้ หากต้องการให้คลาสเป็นเอนทิตี จะต้องเป็นไปตามข้อกำหนดต่อไปนี้:

• ต้องมีตัวสร้างว่าง ( publicหรือprotected);
• ไม่สามารถซ้อนกัน อินเทอร์เฟซ หรือenum;
• ไม่สามารถเป็นfinalและไม่สามารถมีfinal-fields/properties;
• ต้องมีอย่างน้อยหนึ่งช่อง @Id

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

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

อย่างที่คุณเห็นคลาสนี้Userคล้ายกับตารางผู้ใช้มาก มีสนามid, name, age. คำอธิบายประกอบที่อยู่ด้านบนนั้นไม่ต้องการคำอธิบายมากนัก: เป็นที่ชัดเจนว่า @Id เป็นข้อบ่งชี้ว่าฟิลด์นั้นเป็นตัวระบุของอ็อบเจ็กต์ของคลาสนี้ คำอธิบายประกอบ @Table เหนือคลาสระบุชื่อของตารางที่ใช้เขียนวัตถุ โปรดใส่ใจกับความคิดเห็นเหนือฟิลด์อายุ: หากชื่อฟิลด์ในชั้นเรียนและตารางเหมือนกัน คุณไม่จำเป็นต้องเพิ่มคำอธิบายประกอบ @Column มันจะทำงานเช่นนั้น เกี่ยวกับ “กลยุทธ์ = GenerationType.IDENTITY” ที่ระบุในวงเล็บ: มีกลยุทธ์การสร้าง ID หลายประการ คุณสามารถ Google ได้ แต่ภายในกรอบของแอปพลิเคชันของเรา คุณไม่ต้องกังวล สิ่งสำคัญคือ id สำหรับอ็อบเจ็กต์ของเราจะถูกสร้างขึ้นโดยอัตโนมัติ ดังนั้นจึงไม่มีตัวตั้งค่าสำหรับ id และเราไม่ได้ระบุไว้ใน Constructor ด้วย Userอย่างไรก็ตาม ชั้นเรียน ยังคงโดดเด่นในบางด้าน เขามีรายชื่อรถ! คำอธิบายประกอบ @OneToMany ปรากฏเหนือรายการ หมายความว่าหนึ่งอ็อบเจ็กต์ของคลาสผู้ใช้สามารถสอดคล้องกับหลายเครื่องได้ Autoการตั้งค่า " mappedBY" ชี้ไปที่ฟิลด์ผู้ใช้ของคลาส ด้วยวิธีนี้ เครื่องจักรและผู้ใช้จึงเชื่อมต่อถึงกัน การตั้งค่า orphanRemoval แปลได้ค่อนข้างดีจากภาษาอังกฤษ - "remove orphans" หากเราลบผู้ใช้ออกจากฐานข้อมูล รถยนต์ทุกคันที่เกี่ยวข้องกับเขาจะถูกลบด้วย ในทางกลับกัน ในชั้นเรียนAutoคุณจะเห็นฟิลด์ผู้ใช้พร้อมคำอธิบายประกอบ @ManyToOne (รถยนต์จำนวนมากสามารถสอดคล้องกับผู้ใช้หนึ่งราย) และคำอธิบายประกอบ @JoinColumn ระบุว่าคอลัมน์ใดในตารางอัตโนมัติที่มีการเชื่อมต่อกับตารางผู้ใช้เกิดขึ้น (คีย์ต่างประเทศเดียวกันกับที่เราพูดถึงก่อนหน้านี้) หลังจากสร้างโมเดลข้อมูลแล้ว ก็ถึงเวลาสอนโปรแกรมของเราให้ดำเนินการกับข้อมูลนี้ในฐานข้อมูล เริ่มต้นด้วยคลาสยูทิลิตี้ 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("Exception!" + e);
            }
        }
        return sessionFactory;
    }
}

ในคลาส นี้ เราสร้างอ็อบเจ็กต์การกำหนดค่าใหม่ การกำหนดค่า และส่งต่อคลาสที่ควรรับรู้ว่าเป็นเอนทิตี - Userและ Autoให้ความสนใจกับวิธีconfiguration.getProperties()การ คุณสมบัติอะไรอีกบ้าง? ที่ไหน? คุณสมบัติคือพารามิเตอร์สำหรับวิธีการทำงานของไฮเบอร์เนต ที่ระบุในไฟล์พิเศษ hibernate.cfg.xml Hibernate.cfg.xml อ่านได้ที่นี่: new Configuration().configure(); อย่างที่คุณเห็นไม่มีอะไรพิเศษในนั้น - พารามิเตอร์สำหรับการเชื่อมต่อกับฐานข้อมูลและพารามิเตอร์พิเศษ show_sql จำเป็นเพื่อให้คำสั่ง SQL ทั้งหมดที่ไฮเบอร์เนตจะดำเนินการกับฐานข้อมูลของเราจะถูกส่งออกไปยังคอนโซล ด้วยวิธีนี้ คุณจะเห็นว่า 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 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);
    }


}

บริการคือชั้นข้อมูลในแอปพลิเคชันที่รับผิดชอบในการดำเนินการตรรกะทางธุรกิจ หากโปรแกรมของคุณจำเป็นต้องใช้ตรรกะทางธุรกิจ โปรแกรมจะดำเนินการผ่านบริการต่างๆ บริการประกอบด้วยภายในตัวเอง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("Masha",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("Masha",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("Sasha");
        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("Masha",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("Sasha");
        userService.updateUser(user);
        userService.deleteUser(user);
    }
}

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