Quelle est la relation entre les classes de persistance et les classes d’entités dans Java Hibernate ?

Hibernate est un framework ORM (Object Relational Mapping) open source, utilisé pour mapper des objets dans des programmes Java aux données relationnelles dans des bases de données. Dans Hibernate, les classes de persistance sont des classes utilisées pour mapper des objets Java et des tables de bases de données relationnelles.

Vous devez suivre les règles suivantes lors de l'écriture des classes de persistance Hibernate :

• La classe de persistance doit avoir un constructeur sans argument, sinon Hibernate ne peut pas créer l'objet.

• La classe de persistance doit être mappée à une table de la base de données. Vous pouvez utiliser l'annotation @Table pour spécifier le nom de la table.

• Les attributs de la classe de persistance doivent correspondre un à un avec les colonnes de la table de la base de données. Vous pouvez utiliser l'annotation @Column pour spécifier le nom de la colonne.

• La classe persistante doit avoir un identifiant unique, qui peut être spécifié à l'aide de l'annotation @Id.

• Les attributs de la classe persistante peuvent utiliser l'annotation @Basic pour spécifier s'il s'agit de types de base, tels que des chaînes, des nombres, etc.

• Les attributs de la classe persistante peuvent être spécifiés à l'aide de l'annotation @Transient et n'ont pas besoin d'être conservés dans la base de données.

Dans Hibernate, il existe de nombreuses stratégies de génération de clé primaire, les plus courantes incluent l'auto-incrémentation, l'UUID, la séquence, etc. Vous pouvez utiliser l'annotation @GeneratedValue pour spécifier la stratégie de génération de clé primaire, par exemple :

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

L'attribut de stratégie dans l'annotation @GeneratedValue spécifie la méthode de stratégie de génération de clé primaire, et IDENTITY signifie utiliser la méthode d'incrémentation automatique pour générer la clé primaire. clé primaire.

En plus d'utiliser des annotations pour spécifier la stratégie de génération de clé primaire, vous pouvez également utiliser des fichiers XML pour configurer la stratégie de génération de clé primaire, par exemple :

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

L'attribut class dans la balise spécifie la méthode de stratégie de génération de clé primaire, et un moyen d'identité utilisant le procédé d'auto-incrémentation pour générer la clé primaire.

Trois états de la classe de persistance d'Hibernate

Dans Hibernate, la classe de persistance a trois états : état transitoire, état persistant et état libre.

• État transitoire : l'objet de classe persistant n'est pas associé à la session et n'a pas été enregistré dans la base de données. À ce stade, les propriétés de l'objet modifié ne seront pas enregistrées dans la base de données.

• État persistant : l'objet persistant a été enregistré dans la base de données et associé à la session. À ce moment, les propriétés de l'objet modifié seront enregistrées dans la base de données.

• État libre : L'objet persistant a été enregistré dans la base de données, mais il n'est plus lié à la session. À ce stade, les propriétés de l'objet modifié ne seront pas enregistrées dans la base de données.

Vous pouvez utiliser les méthodes de sauvegarde, de persistance, de mise à jour et de fusion de Session pour convertir des objets de classe persistants d'un état transitoire à un état persistant ou à un état libre.

La méthode save est utilisée pour enregistrer les objets d'état transitoire dans la base de données et renvoyer les objets d'état persistants. Si l'objet est déjà persistant, aucune action n'est effectuée.

La méthode persist est utilisée pour enregistrer les objets d'état transitoire dans la base de données et ne renvoie pas d'objets d'état persistants. Si l'objet est déjà persistant, aucune action n'est effectuée.

La méthode update est utilisée pour mettre à jour les objets d'état libres dans la base de données et renvoyer les objets d'état persistants. Si l'objet est transitoire, une exception est levée.

La méthode de fusion est utilisée pour fusionner des objets d'état libre dans Session et renvoyer des objets d'état persistants. Si l'objet est transitoire, enregistrez-le dans la base de données et renvoyez-le dans un état persistant.

Cache de premier niveau d'Hibernate

Le cache de premier niveau d'Hibernate est un cache de niveau session, utilisé pour mettre en cache les objets de classe persistants. Lors de l'interrogation d'un objet de classe persistant dans la base de données, Hibernate le recherchera d'abord dans le cache de premier niveau. S'il n'existe pas dans le cache, il l'interrogera dans la base de données et placera les résultats de la requête dans le cache de premier niveau.

Le cycle de vie du cache de premier niveau est le même que celui de la Session. Lorsque la Session est fermée, le cache de premier niveau sera également vidé. Vous pouvez utiliser les méthodes evict et clear de Session pour vider le cache de premier niveau. La méthode

evict est utilisée pour supprimer l'objet spécifié du cache de premier niveau, rendant ainsi l'objet libre.

La méthode clear est utilisée pour effacer tous les objets du cache de premier niveau et mettre tous les objets persistants dans un état libre.

Gestion des transactions d'Hibernate

Dans Hibernate, les transactions sont utilisées pour garantir l'atomicité, la cohérence, l'isolement et la durabilité des opérations de base de données. Vous pouvez utiliser l'interface Transaction pour gérer les transactions, par exemple :

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

Dans une transaction, vous pouvez utiliser les méthodes de sauvegarde, de persistance, de mise à jour, de fusion, de suppression et d'autres méthodes de session pour faire fonctionner des objets de classe persistants et enregistrer les résultats de l'opération dans la base de données. lorsque la transaction est soumise au milieu.

Autres API d'Hibernate

En plus des API présentées ci-dessus, Hibernate fournit également de nombreuses autres API, telles que :

• API Criteria : utilisée pour interroger dynamiquement des objets de classe persistants.

• HQL (Hibernate Query Language) : un langage de requête basé sur SQL utilisé pour interroger des objets de classe persistants.

• Requête nommée : enregistrez les instructions de requête HQL dans des classes de persistance pour une réutilisation facile.

• Cache de deuxième niveau : utilisé pour mettre en cache les objets de classe persistants afin d'améliorer l'efficacité des requêtes.

Mappage des relations entre les classes d'entités d'Hibernate

Dans Hibernate, la relation entre les classes d'entités peut être cartographiée via des annotations, des fichiers de configuration XML ou du code Java. Les relations couramment utilisées sont un à un, un à plusieurs, plusieurs à un et plusieurs à plusieurs.

一对一关系

一对一关系表示两个实体类之间的关系是一对一的关系。在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指定了关联表的名称和两个实体类之间的关联关系。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!