Welche Beziehung besteht zwischen Persistenzklassen und Entitätsklassen in Java Hibernate?

Hibernate ist ein Open-Source-ORM-Framework (Object Relational Mapping), das zum Zuordnen von Objekten in Java-Programmen zu relationalen Daten in Datenbanken verwendet wird. Persistenzklassen sind in Hibernate Klassen, die zum Zuordnen von Java-Objekten und relationalen Datenbanktabellen verwendet werden.

Sie müssen die folgenden Regeln befolgen, wenn Sie Hibernate-Persistenzklassen schreiben:

• Die Persistenzklasse muss einen Konstruktor ohne Argumente haben, andernfalls kann Hibernate das Objekt nicht erstellen.

• Die Persistenzklasse muss einer Tabelle in der Datenbank zugeordnet sein. Sie können die Annotation @Table verwenden, um den Tabellennamen anzugeben.

• Die Attribute der Persistenzklasse müssen eins zu eins mit den Spalten der Datenbanktabelle übereinstimmen. Sie können die Annotation @Column verwenden, um den Spaltennamen anzugeben.

• Die persistente Klasse muss über einen eindeutigen Bezeichner verfügen, der mithilfe der @Id-Annotation angegeben werden kann.

• Die Attribute der persistenten Klasse können mithilfe der @Basic-Annotation angeben, ob es sich um Basistypen wie Zeichenfolgen, Zahlen usw. handelt.

• Attribute persistenter Klassen können mithilfe der @Transient-Annotation angegeben werden und müssen nicht in der Datenbank gespeichert werden.

In Hibernate gibt es viele Strategien zur Generierung von Primärschlüsseln. Zu den häufigsten gehören automatische Inkrementierung, UUID, Sequenz usw. Sie können die Annotation @GeneratedValue verwenden, um die Strategie zur Generierung des Primärschlüssels anzugeben, zum Beispiel:

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

Das Strategieattribut in der Annotation @GeneratedValue gibt die Methode der Strategie zur Generierung des Primärschlüssels an, und IDENTITY bedeutet, dass zum Generieren die Methode der automatischen Inkrementierung verwendet wird Primärschlüssel.

Zusätzlich zur Verwendung von Anmerkungen zur Angabe der Primärschlüsselgenerierungsstrategie können Sie auch XML-Dateien verwenden, um die Primärschlüsselgenerierungsstrategie zu konfigurieren, zum Beispiel:

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

Das Klassenattribut im Tag gibt die Methode der Primärschlüsselgenerierungsstrategie an. und Identität bedeutet die Verwendung der Auto-Inkrementierungsmethode zum Generieren des Primärschlüssels.

Drei Zustände der Persistenzklasse von Hibernate

In Hibernate hat die Persistenzklasse drei Zustände: Übergangszustand, persistenter Zustand und freier Zustand.

• Vorübergehender Zustand: Das persistente Klassenobjekt ist nicht mit der Sitzung verknüpft und wurde nicht in der Datenbank gespeichert. Zu diesem Zeitpunkt werden die Eigenschaften des geänderten Objekts nicht in der Datenbank gespeichert.

• Persistenter Status: Das persistente Objekt wurde in der Datenbank gespeichert und der Sitzung zugeordnet. Zu diesem Zeitpunkt werden die Eigenschaften des geänderten Objekts in der Datenbank gespeichert.

• Freier Zustand: Das persistente Objekt wurde in der Datenbank gespeichert, hat jedoch keinen Bezug mehr zur Sitzung. Zu diesem Zeitpunkt werden die Attribute des geänderten Objekts nicht in der Datenbank gespeichert.

Sie können die Methoden „Speichern“, „Peristieren“, „Aktualisieren“ und „Zusammenführen“ von Session verwenden, um persistente Klassenobjekte vom Übergangszustand in den dauerhaften Zustand oder den freien Zustand zu konvertieren.

Die Methode save wird verwendet, um Objekte mit vorübergehendem Zustand in der Datenbank zu speichern und Objekte mit dauerhaftem Zustand zurückzugeben. Wenn das Objekt bereits persistent ist, wird keine Aktion ausgeführt.

Die Persist-Methode wird zum Speichern von Objekten mit vorübergehendem Zustand in der Datenbank verwendet und gibt keine Objekte mit dauerhaftem Zustand zurück. Wenn das Objekt bereits persistent ist, wird keine Aktion ausgeführt.

Die Update-Methode wird verwendet, um freie Statusobjekte in der Datenbank zu aktualisieren und persistente Statusobjekte zurückzugeben. Wenn das Objekt transient ist, wird eine Ausnahme ausgelöst.

Die Merge-Methode wird verwendet, um freie Zustandsobjekte in der Sitzung zusammenzuführen und persistente Zustandsobjekte zurückzugeben. Wenn das Objekt vorübergehend ist, speichern Sie es in der Datenbank und geben Sie das Objekt im dauerhaften Zustand zurück.

Der Cache der ersten Ebene von Hibernate

Der Cache der ersten Ebene von Hibernate ist ein Cache auf Sitzungsebene, der zum Zwischenspeichern persistenter Klassenobjekte verwendet wird. Wenn ein persistentes Klassenobjekt aus der Datenbank abgefragt wird, durchsucht Hibernate es zunächst im Cache der ersten Ebene. Wenn es nicht im Cache vorhanden ist, fragt es es aus der Datenbank ab und legt die Abfrageergebnisse im Cache der ersten Ebene ab.

Der Lebenszyklus des First-Level-Cache ist derselbe wie der der Sitzung. Wenn die Sitzung geschlossen wird, wird auch der First-Level-Cache geleert. Sie können die Evict- und Clear-Methoden von Session verwenden, um den Cache der ersten Ebene zu löschen. Die Methode

evict wird verwendet, um das angegebene Objekt aus dem Cache der ersten Ebene zu entfernen, wodurch das Objekt frei wird.

Die Clear-Methode wird verwendet, um alle Objekte im Cache der ersten Ebene zu löschen und alle persistenten Objekte in einen freien Zustand zu versetzen.

Transaktionsmanagement von Hibernate

In Hibernate werden Transaktionen verwendet, um Atomizität, Konsistenz, Isolation und Haltbarkeit von Datenbankoperationen sicherzustellen. Sie können die Transaktionsschnittstelle verwenden, um Transaktionen zu verwalten, zum Beispiel:

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

In einer Transaktion können Sie die Sitzungsmethoden Speichern, Beibehalten, Aktualisieren, Zusammenführen, Löschen und andere verwenden, um persistente Klassenobjekte zu betreiben und die Operationsergebnisse in der Datenbank zu speichern wenn die Transaktion in der Mitte eingereicht wird. Weitere APIs von Hibernate

HQL (Hibernate Query Language): Eine SQL-basierte Abfragesprache, die zum Abfragen persistenter Klassenobjekte verwendet wird.

• Benannte Abfrage: Speichern Sie HQL-Abfrageanweisungen zur einfachen Wiederverwendung in Persistenzklassen.

• Cache der zweiten Ebene: Wird zum Zwischenspeichern persistenter Klassenobjekte verwendet, um die Abfrageeffizienz zu verbessern.

• Hibernate-Entitätsklassenbeziehungszuordnung

In Hibernate kann die Beziehung zwischen Entitätsklassen durch Anmerkungen, XML-Konfigurationsdateien oder Java-Code abgebildet werden. Häufig verwendete Beziehungen sind Eins-zu-Eins, Eins-zu-Viele, Viele-zu-Eins und Viele-zu-Viele.

• 一对一关系

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

Das obige ist der detaillierte Inhalt vonWelche Beziehung besteht zwischen Persistenzklassen und Entitätsklassen in Java Hibernate?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!