Apakah hubungan antara kelas kegigihan dan kelas entiti dalam Java Hibernate?

Hibernate ialah rangka kerja ORM (Object Relational Mapping) sumber terbuka, digunakan untuk memetakan objek dalam program Java kepada data hubungan dalam pangkalan data. Dalam Hibernate, kelas kegigihan ialah kelas yang digunakan untuk memetakan objek Java dan jadual pangkalan data hubungan.

Anda perlu mengikut peraturan berikut semasa menulis kelas kegigihan Hibernate:

• Kelas kegigihan mesti mempunyai pembina tanpa hujah, jika tidak Hibernate tidak boleh mencipta objek.

• Kelas kegigihan mesti dipetakan ke jadual dalam pangkalan data dan nama jadual boleh ditentukan menggunakan anotasi @Table.

• Atribut kelas kegigihan mesti sepadan satu-dengan-satu dengan lajur jadual pangkalan data Anda boleh menggunakan anotasi @Column untuk menentukan nama lajur.

• Kelas berterusan mesti mempunyai pengecam unik, yang boleh ditentukan menggunakan anotasi @Id.

• Atribut kelas persisten boleh menggunakan anotasi @Basic untuk menentukan sama ada ia adalah jenis asas, seperti rentetan, nombor, dsb.

• Atribut kelas persisten boleh ditentukan menggunakan anotasi @Transient dan tidak perlu disimpan ke pangkalan data.

Dalam Hibernate, terdapat banyak strategi penjanaan kunci utama, yang biasa termasuk autoincrement, UUID, jujukan, dsb. Anda boleh menggunakan anotasi @GeneratedValue untuk menentukan strategi penjanaan kunci utama, contohnya:

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

Atribut strategi dalam anotasi @GeneratedValue menentukan kaedah strategi penjanaan kunci utama dan IDENTITY bermaksud menggunakan kenaikan automatik kaedah untuk menjana kunci utama.

Selain menggunakan anotasi untuk menentukan strategi penjanaan kunci utama, anda juga boleh menggunakan fail XML untuk mengkonfigurasi strategi penjanaan kunci utama, contohnya:

<id name="id" type="java.lang.Long">
    <column name="id" />
    <generator class="identity" />
</id>

Atribut kelas dalam teg menentukan kaedah strategi penjanaan kunci utama, dan identiti bermakna menggunakan Kunci utama dijana oleh kenaikan automatik.

Tiga keadaan kelas kegigihan Hibernate

Dalam Hibernate, kelas kegigihan mempunyai tiga keadaan: keadaan sementara, keadaan berterusan dan keadaan bebas.

• Keadaan sementara: Objek kelas persisten tidak dikaitkan dengan Sesi dan belum disimpan ke pangkalan data Pada masa ini, sifat objek yang diubah suai tidak akan disimpan ke pangkalan data.

• Keadaan berterusan: Objek kelas berterusan telah disimpan ke pangkalan data dan dikaitkan dengan Sesi Pada masa ini, atribut objek yang diubah suai akan disimpan ke pangkalan data.

• Keadaan bebas: Objek berterusan telah disimpan ke pangkalan data, tetapi tidak lagi dikaitkan dengan Sesi Pada masa ini, sifat objek yang diubah suai tidak akan disimpan ke pangkalan data.

Anda boleh menggunakan kaedah simpan, berterusan, kemas kini dan cantumkan Sesi untuk menukar objek kelas berterusan daripada keadaan sementara kepada keadaan berterusan atau keadaan bebas.

Kaedah simpan digunakan untuk menyimpan objek keadaan sementara ke pangkalan data dan mengembalikan objek keadaan berterusan. Jika objek sudah berterusan, tiada tindakan dilakukan.

Kaedah berterusan digunakan untuk menyimpan objek keadaan sementara ke pangkalan data dan tidak mengembalikan objek keadaan berterusan. Jika objek sudah berterusan, tiada tindakan dilakukan.

Kaedah kemas kini digunakan untuk mengemas kini objek keadaan bebas ke pangkalan data dan mengembalikan objek keadaan berterusan. Jika objek adalah sementara, pengecualian dilemparkan.

Kaedah gabungan digunakan untuk menggabungkan objek keadaan bebas ke dalam Sesi dan mengembalikan objek keadaan berterusan. Jika objek adalah sementara, simpan objek ke pangkalan data dan kembalikan objek dalam keadaan berterusan.

Cache peringkat pertama Hibernate

Cache peringkat pertama Hibernate ialah cache peringkat Sesi, digunakan untuk cache objek kelas berterusan. Apabila menanyakan objek kelas berterusan daripada pangkalan data, Hibernate akan terlebih dahulu mencarinya daripada cache peringkat pertama Jika ia tidak wujud dalam cache, ia akan menanyakannya daripada pangkalan data dan meletakkan hasil pertanyaan ke dalam cache peringkat pertama.

Kitaran hayat cache peringkat pertama adalah sama dengan Sesi Apabila Sesi ditutup, cache peringkat pertama juga akan dikosongkan. Anda boleh menggunakan kaedah evict dan clear Session untuk mengosongkan cache peringkat pertama.

Kaedah evict digunakan untuk mengalih keluar objek yang ditentukan daripada cache peringkat pertama, menjadikan objek menjadi bebas.

Kaedah jelas digunakan untuk mengosongkan semua objek dalam cache peringkat pertama dan menukar semua objek berterusan kepada keadaan bebas.

Pengurusan transaksi Hibernate

Dalam Hibernate, urus niaga digunakan untuk memastikan atomicity, konsistensi, pengasingan dan ketahanan operasi pangkalan data. Anda boleh menggunakan antara muka Transaksi untuk mengurus urus niaga, contohnya:

Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
try {
    // 执行数据库操作
    tx.commit();
} catch (Exception e) {
    tx.rollback();
} finally {
    session.close();
}

Dalam transaksi, anda boleh menggunakan kaedah simpan, berterusan, kemas kini, cantum, padam dan lain-lain Sesi untuk mengendalikan objek kelas berterusan dan operasi akan dilakukan apabila transaksi diserahkan Hasilnya disimpan ke pangkalan data.

API Hibernate yang lain

Selain API yang diperkenalkan di atas, Hibernate juga menyediakan banyak API lain, seperti:

• API Kriteria: Gunakan Untuk pertanyaan dinamik objek kelas berterusan.

• HQL (Bahasa Pertanyaan Hibernate): Bahasa pertanyaan berasaskan SQL yang digunakan untuk menanyakan objek kelas berterusan.

• Pertanyaan Dinamakan: Simpan pernyataan pertanyaan HQL dalam kelas kegigihan untuk kegunaan semula yang mudah.

• Cache Tahap Kedua: digunakan untuk cache objek kelas berterusan untuk meningkatkan kecekapan pertanyaan.

Pemetaan hubungan kelas entiti Hibernate

Dalam Hibernate, hubungan antara kelas entiti boleh dipetakan melalui anotasi, fail konfigurasi XML atau kod Java. Perhubungan yang biasa digunakan ialah satu-dengan-satu, satu-dengan-banyak, banyak-dengan-satu dan banyak-ke-banyak.

一对一关系

一对一关系表示两个实体类之间的关系是一对一的关系。在Hibernate中，可以使用@OneToOne注解来进行映射。

例如，一个Person实体类和一个IDCard实体类之间的关系是一对一的关系，可以使用如下的代码进行映射：

@Entity
public class Person {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    @OneToOne(mappedBy = "person", cascade = CascadeType.ALL)
    private IDCard idCard;
    // getters and setters
}
@Entity
public class IDCard {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String number;
    @OneToOne
    @JoinColumn(name = "person_id")
    private Person person;
    // getters and setters
}

其中，Person实体类中使用了@OneToOne注解来映射与IDCard实体类的关系，属性mappedBy指定了IDCard实体类中的person属性与Person实体类中的idCard属性之间的关系，cascade属性指定了级联操作。

IDCard实体类中使用了@OneToOne注解来映射与Person实体类的关系，属性JoinColumn指定了Person实体类中与IDCard实体类关联的外键列名。

一对多关系

一对多关系表示一个实体类可以对应多个另一个实体类的对象。在Hibernate中，可以使用@OneToMany注解来进行映射。

例如，一个Department实体类中有多个Employee实体类的对象，可以使用如下的代码进行映射：

@Entity
public class Department {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    @OneToMany(mappedBy = "department", cascade = CascadeType.ALL)
    private List<Employee> employees;
    // getters and setters
}
@Entity
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    @ManyToOne
    @JoinColumn(name = "department_id")
    private Department department;
    // getters and setters
}

其中，Department实体类中使用了@OneToMany注解来映射与Employee实体类的关系，属性mappedBy指定了Employee实体类中的department属性与Department实体类中的employees属性之间的关系，cascade属性指定了级联操作。

Employee实体类中使用了@ManyToOne和@JoinColumn注解来映射与Department实体类的关系，属性JoinColumn指定了Department实体类中与Employee实体类关联的外键列名。

多对一关系

多对一关系表示多个实体类可以对应一个另一个实体类的对象。在Hibernate中，可以使用@ManyToOne注解来进行映射。

例如，一个Employee实体类所属于一个Department实体类，可以使用如下的代码进行映射：

@Entity
public class Department {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    // getters and setters
}
@Entity
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    @ManyToOne
    @JoinColumn(name = "department_id")
    private Department department;
    // getters and setters
}

其中，Employee实体类中使用了@ManyToOne和@JoinColumn注解来映射与Department实体类的关系，属性JoinColumn指定了Department实体类中与Employee实体类关联的外键列名。

多对多关系

多对多关系表示多个实体类之间互相关联。在Hibernate中，可以使用@ManyToMany注解来进行映射。

例如，一个Student实体类可以选择多个Course实体类，一个Course实体类也可以有多个Student实体类，可以使用如下的代码进行映射：

@Entity
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    @ManyToMany(mappedBy = "students", cascade = CascadeType.ALL)
    private List<Course> courses;
    // getters and setters
}
@Entity
public class Course {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    @ManyToMany
    @JoinTable(
        name = "course_student",
        joinColumns = @JoinColumn(name = "course_id"),
        inverseJoinColumns = @JoinColumn(name = "student_id")
    )
    private List<Student> students;
    // getters and setters
}

其中，Student实体类中使用了@ManyToMany注解来映射与Course实体类的关系，属性mappedBy指定了Course实体类中的students属性与Student实体类中的courses属性之间的关系，cascade属性指定了级联操作。

Course实体类中使用了@ManyToMany和@JoinTable注解来映射与Student实体类的关系，属性JoinTable指定了关联表的名称和两个实体类之间的关联关系。

Atas ialah kandungan terperinci Apakah hubungan antara kelas kegigihan dan kelas entiti dalam Java Hibernate?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!