Ausführliche Erläuterung von Beispielen für zwei Arten der Hibernate-Klassenzuordnung

In diesem Artikel wird hauptsächlich die grundlegende Klassenzuordnung und die objektrelationale Zuordnung der Hibernate-Zuordnung vorgestellt. Es ist von großem praktischem Wert. Freunde, die es benötigen, können darauf zurückgreifen.

Erinnern Sie sich an einige der Dinge, die wir gemacht haben Als wir SSH nicht lernten, wurde die Datenbank zunächst als E-R-Diagramm modelliert, dann wurde das relationale Modell durch das Entitätsmodell erstellt und dann wurden die entsprechenden Tabellen erstellt. Es gibt drei Arten von Beziehungen zwischen Entitäten: Eins-zu-Eins, Eins-zu-Viele (oder Viele-zu-Eins) und Viele-zu-Viele. Wenn wir nun die entsprechende Tabelle basierend auf der Klasse zuordnen möchten, können wir die Datenbanktabelle nur über die Beziehung zwischen Klassen und Zuordnungsdateien zuordnen. Wir lernen UML-Modellierung. Es gibt fünf Beziehungen zwischen Klassen: Vererbung, Implementierung, Assoziation, Abhängigkeit, Aggregation/Kombination sind bereits mit der Code-Implementierung vertraut, die verschiedenen Beziehungen entspricht, daher ist es eine Überprüfung Kenntnis über Entitätsklassen.

Die Essenz von Hibernate ist die objektrelationale Zuordnung (ObjektORM realisiert das Speichern von Objektdaten in der Datenbank und führt diese durch). Beim Hinzufügen, Löschen und Ändern von Abfragen und anderen Aufgaben arbeiten wir jetzt nicht mehr an der relationalen Tabelle, sondern direkt am Objekt. ORM-Zuordnungsdateien im Ruhezustand haben normalerweise das Suffix .hbm.xml. Die Verwendung dieser Zuordnungsdatei ist nicht nur einfach zu lesen, sondern kann auch manuell geändert werden, oder Sie können einige Tools zum Generieren von Zuordnungsdokumenten verwenden. Die Zuordnung im Ruhezustand wird im Folgenden vorgestellt.

Hibernate-Mapping-Klassifizierung, wie in der folgenden Abbildung dargestellt.

1 Grundlegende Klassenzuordnung

Erstellen Sie entsprechende Tabellen basierend auf Entitätsklassen, dieser einfachen Beziehung. Grundlegende Zuordnung für den Winterschlaf.

Benutzer1-Entitätsklassencode lautet wie folgt:

//user实体。 
public classUser1 { 
  //用户编号。 
  private String id; 
  
  //名字。 
  private String name; 
  
  //密码。 
  private String password; 
  
  //创建日期。 
  private Date createTime; 
  
  //失效时间。 
  private Date expireTime; 
  
  public String getId() { 
   return id; 
  } 
  
// publicvoid setId(String id) { 
//  this.id= id; 
// } 
  
  public String getName() { 
   return name; 
  } 
  
  public void setName(String name) { 
   this.name = name; 
  } 
  
  public String getPassword() { 
   return password; 
  } 
  
  public void setPassword(Stringpassword) { 
   this.password = password; 
  } 
  
  public Date getCreateTime() { 
   return createTime; 
  } 
  
  public void setCreateTime(DatecreateTime) { 
   this.createTime = createTime; 
  } 
  
  public Date getExpireTime() { 
   return expireTime; 
  } 
  
  public void setExpireTime(DateexpireTime) { 
   this.expireTime = expireTime; 
  } 
 }

Benutzer1.hbm.xml-Zuordnungsdatei lautet wie folgt:

<hibernate-mapping package="com.bjpowernode.hibernate"> 
  
  <class name="User1" table="t_user1"> 
   <id name="id"column="user_id" length="32"access="field"> 
     <generator class="uuid" /> 
   </id> 
   <!-- 设置主键不能重复和不能为空的属性. --> 
   <property name="name" length="30"unique="true" not-null="true"/> 
   <property name="password"/> 
   <property name="createTime" type="date" column="create_time"/> 
   <property name="expireTime"/> 
  </class> 
</hibernate-mapping>

Konvertieren Sie das User1-Objekt über die Zuordnungsdatei User1.hbm.xml in die Tabelle t_user1 in der relationalen Datenbank.

Das konvertierte Ergebnis lautet wie folgt:

2 Objektrelationale Zuordnung

2.1 Zuordnung von Viele-zu-Eins-Zuordnungen (einseitig)

Zum Beispiel ist die Beziehung zwischen Benutzern und Gruppen eine Viele-zu-Eins-Beziehung, und mehrere Benutzer entsprechen einer Gruppe .

Entitäten in Tabellen zuordnen und entsprechende Entitäten in Tabellen zuordnen. Die entsprechenden Attribute werden auf Tabellenfelder abgebildet.

Viele-zu-Eins-Assoziationszuordnung verwaltet Assoziationsfelder auf der Viele-Seite. In unserem Beispiel werden Beziehungsfelder auf der Benutzerseite verwaltet.

User.hbm.xml-Datei.

<hibernate-mapping package="org.hibernate.auction"> 
  
  <class name="com.bjpowernode.hibernate.User" table="t_user" > 
   <id name="id"> 
     <generator class="native" /> 
   </id> 
   <property name="name"/> 
   <many-to-one name="group" column="groupid"cascade="save-update"></many-to-one> 
  </class> 
</hibernate-mapping>

Group.hbm.xml-Datei.

<hibernate-mapping package="org.hibernate.auction"> 
  
  <class name="com.bjpowernode.hibernate.Group" table="t_group"> 
   <id name="id"> 
     <generator class="native" /> 
   </id> 
   <property name="name"/> 
  </class> 
</hibernate-mapping>

Der Code, den wir hier betrachten, ist der *.hbm.mlx-Code, da für die Zuordnung zwischen Klassen während der Implementierung eine Klasse als Als privates Mitglied einer anderen Klasse haben wir das alle verstanden, als wir die UML-Modellierung lernten. Was wir hier hauptsächlich betrachten, ist die *.hbm.xml-Datei.

2.2 Eins-zu-eins-Assoziationszuordnung

Eins-zu-eins-Assoziationszuordnung ist im wirklichen Leben relativ häufig, beispielsweise in der Beziehung zwischen einer Person und seine Heimatadresse, über das Personenobjekt können Inhalte gefunden werden, die sich auf seine Heimatadresse beziehen.

2.2.1 Eins-zu-eins-Zuordnung (einseitige Primärschlüsselzuordnung)

Eins-zu-Zuordnung -eine Eins-zu-Eins-Primärschlüsselzuordnung, basierend auf der Tatsache, dass ihre Primärschlüssel gleich sind. Sie können IdCard von Person sehen, das heißt, der Primärschlüssel in t_idCard wird als Primärschlüssel von t_Pseron verwendet.

Im Definiert durch Eins-zu-eins-Elemente.

2.2.2 Eins-zu-eins-Zuordnung (zweiseitige Primärschlüsselzuordnung)

<class name="com.bjpowernode.hibernate.Person"table="t_person" > 
   <id name="id"> 
   <!-- 采用foreign生成策略，foreign会取得关联对象的标识 --> 
     <generator class="foreign" > 
     <!--property指的是关联对象。 --> 
      <param name="property">idCard</param> 
     </generator> 
   </id> 
   <property name="name"/> 
   <!-- 一对一关联映射,主键关联. --> 
   <!-- 
   one-to-one标签指示hibernate如何加载其关联对象,默认根据主键加载. 
   也就是拿到关系字段值,根据对端的主键来加载关联对象. 
   constrained="true",表示当前主键(Person的主键)还是一个外键 . 
   参照了对端的主键(IdCard的主键),也就是会生成外键约束语句. 
   --> 
   <one-to-one name="idCard" constrained="true"/> 
  </class>

Der Unterschied zwischen einer eins-zu-eins-zuordnung von zweiseitigen Primärschlüsseln und Bei der unidirektionalen Eins-zu-eins-Primärschlüsselzuordnung handelt es sich um ein Paar. Bei einer unidirektionalen Primärschlüsselzuordnung ist idCard auf der Personenseite zu sehen, idCard jedoch nicht auf der Personenseite. Die bidirektionale Zuordnung bedeutet, dass die Person auch auf der IDCard-Seite angezeigt werden kann, d .hbm.xml-Datei. Der Code wird unten angezeigt.

<hibernate-mapping package="org.hibernate.auction"> 
  
  <class name="com.bjpowernode.hibernate.IdCard" table="t_idCard" > 
   <id name="id"> 
     <generator class="native" /> 
   </id> 
   <property name="cardNo"/> 
  </class> 
</hibernate-mapping>

2.2.3 Eins-zu-Eins-Zuordnung (eins -way eindeutige Fremdschlüsselzuordnung)

一对一单向唯一外键关联，也就是多对一关联的特例，把多的一端限制为一，就是一对一唯一外键关联。同多对一一样，在一端加入另一端的并采用0f3b36ce07ca4f65616ce0254f1e356f标签，通过unique="true"，这样来限制了多的一端为一。
先上代码。

IdCard.hbm.xml

<hibernate-mapping package="org.hibernate.auction"> 
  
  <class name="com.bjpowernode.hibernate.IdCard" table="t_idCard" > 
   <id name="id"> 
     <generator class="native" /> 
   </id> 
   <property name="cardNo"/> 
  </class> 
</hibernate-mapping>

Person.hbm.xml

<hibernate-mapping package="org.hibernate.auction"> 
  
  <class name="com.bjpowernode.hibernate.Person" table="t_person" > 
   <id name="id"> 
   <!-- 采用foreign生成策略，foreign会取得关联对象的标识 --> 
     <generator class="native" /> 
    
   </id> 
   <property name="name"/> 
   <many-to-one name="idCard" unique="true"></many-to-one> 
  
  </class> 
</hibernate-mapping>

图如下所示：

 

在t_pserson端加上一个外键字段idCard，限制idCard的唯一性就是一对一唯一外键关联。

2.2.4 一对一映射（双向唯一外键关联）

一对一唯一外键单向关联我们已经了解了，双向反过来就是在没有的一端加上就可以了。

我们的IdCard.hbm.xml中采用eb3c88118c17ef85b056b8a514885a94标签。

<hibernate-mapping package="org.hibernate.auction"> 
  
  <class name="com.bjpowernode.hibernate.IdCard" table="t_idCard" > 
   <id name="id"> 
     <generator class="native" /> 
   </id> 
   <property name="cardNo"/> 
   <one-to-one name="person" property-ref="idCard"></one-to-one> 
  </class> 
</hibernate-mapping>

而person.hbm.xml同一对一唯一外键单向关联一样。

<class name="com.bjpowernode.hibernate.Person" table="t_person" > 
  <id name="id"> 
  <!-- 采用foreign生成策略，foreign会取得关联对象的标识 --> 
    <generator class="native" /> 
   
  </id> 
  <property name="name"/> 
  <many-to-one name="idCard" unique="true"></many-to-one> 
 
 </class>

 

 

从上述中可以总结出，对于一对一关联映射，主键关联和唯一外键关联单向和双向产生出的表结构是一样的，不同的是在加载的时候不同。也就是一对一双向关联和一对一单向关联的相比，只是改变了一对一关联映射的加载，而没有改变存储。

2.3 一对多关联映射

2.3.1 一对多关联映射（单向）

上面我们介绍了多对一，我们反过来看一对多不就是多对一吗？那还用再进行不同的映射吗？有什么差别吗？一对多和多对一映射原理是一致的，存储是相同的，也就是生成的数据库的表是一样的，他们之间不同的是维护的关系不同。

他们之间不同点是维护的关系不同

1. 多对一维护的关系是：多指向一的关系，有了此关系，加载多的时候可以将一加载上来。

2. 一对多维护的关系是：一指向多的关系，有了此关系，在加载一的时候可以将多加载上来。

 

代码如下所示。

Class.hbm.xml

<class name="com.bjpowernode.hibernate.Classes" table="t_Classes" > 
   <id name="id"> 
     <generator class="native" /> 
   </id> 
   <property name="name"/> 
   <set name="students"> 
   <!-- 
     <keycolumn="classesid" not-null="true"/> 
   --> 
     <key column="classesid" /> 
     <one-to-many class="com.bjpowernode.hibernate.Student"/> 
   </set> 
  </class>

Students.hbm.xml

<class name="com.bjpowernode.hibernate.Student" table="t_student" > 
   <id name="id"> 
    <generator class="native" /> 
   </id> 
   <property name="name"/> 
 </class>

从班级能看到学生，是班级来维护关系，不是学生来维护关系，学生不知道自己是哪个班，所以在存储学生的时候，班级的代码不知道。为了更新学生是哪个班级的要发出很多update语句来告诉学生是哪个班级的。当我们设置classesid not-null=“true”时，则将无法保存数据，解决办法我们改为双向关联映射。

2.3.2 一对多关联映射（双向）

为了解决一对多单向可能存在的问题，我们采用双向一对多，每一方都能维护对方。

一对多双向关联映射方式：

1. 在一的一端的集合上采用42538adbdb6240b2b083a000a615d5bd标签，在多的一端加入一个外键。

2. 在多的一端采用0f3b36ce07ca4f65616ce0254f1e356f的标签

！~注意42538adbdb6240b2b083a000a615d5bd标签和0f3b36ce07ca4f65616ce0254f1e356f标签加入字段保持一致，否则会产生数据混乱。

代码如下所示。

<class name="com.bjpowernode.hibernate.Classes" table="t_Classes" > 
   <id name="id"> 
     <generator class="native" /> 
   </id> 
   <property name="name"/> 
   <set name="students" inverse="true"> 
   <!-- 
     <keycolumn="classesid" not-null="true"/> 
   --> 
     <key column="classesid" /> 
     <one-to-many class="com.bjpowernode.hibernate.Student"/> 
   </set> 
  </class>

<class name="com.bjpowernode.hibernate.Student" table="t_student" > 
   <id name="id"> 
     <generator class="native" /> 
   </id> 
   <property name="name"/> 
    <many-to-one name="classes"column="classesid"/> 
  </class>

注意：Inverse属性

1、 Inverse中文意思为相反的，反转。在hibernate中inverse可以用在一对多和多对多双向关联上，inverse默认是false，为false的时候表示本端可以维护关系，如果inverse为true，则本端不能维护关系，会交给另一端维护关系，本端失效，所以在一对多关联映射我们通常在多的一端维护关系，让一的一端失效。

2、Inverse是控制方向上的反转，只影响存储。

比较一对多单向和双向映射，从存储结构上看没有什么区别，但是从配置文件上看，一对多双向比一对多单向，一对多双向关联的配置文件中在多的一端的配置文件上存在0f3b36ce07ca4f65616ce0254f1e356f相关配置，即保证多对一的映射。

2.4 多对多关联映射

2.4.1 多对多关联映射（单向）

多对多对象关系映射，需要加入一张新表完成基本映射。如下图所示。

代码。

Role.hbm.xml

<class name="com.bjpowernode.hibernate.Role" table="t_role"> 
   <id name="id"> 
     <generator class="native" /> 
   </id> 
   <property name="name"/> 
    
  </class>

User.hbm.xml

<class name="com.bjpowernode.hibernate.User" table="t_user" > 
   <id name="id"> 
     <generator class="native" /> 
   </id> 
   <property name="name"/> 
     
   <set name="roles" table="t_user_role"> 
     <key column="user_id"/> 
     <many-to-many class="com.bjpowernode.hibernate.Role" column="role_id"/> 
   </set> 
  </class>

2.4.2 多对多关联映射（双向）

双向多对多对象关系映射，是两端都能将对方加载上来，双向都需要加上标签映射。
要注意：

1. 生成中间表名必须一样

2. 生成中间表字段必须一样

代码如下所示。

Role.hbm.xml

<class name="com.bjpowernode.hibernate.Role" table="t_role"> 
   <id name="id"> 
    <generator class="native" /> 
   </id> 
   <property name="name"/> 
   
   <set name="users" table="t_user_role"> 
    <key column="role_id"/> 
    <many-to-many class="com.bjpowernode.hibernate.User" column="user_id"/> 
   </set> 
 </class>

User.hbm.xml

<class name="com.bjpowernode.hibernate.User"table="t_user" > 
   <id name="id"> 
     <generator class="native" /> 
   </id> 
   <property name="name"/> 
     
   <set name="roles" table="t_user_role"> 
     <key column="user_id"/> 
     <many-to-many class="com.bjpowernode.hibernate.Role" column="role_id"/> 
   </set> 
  </class>

区别：单向多对多和双向多对多存储结构没有任何的区别，但他们的映射文件是有区别的，加载过程是不同的。

 3  关系映射总结

综上所述，可以看出，同一类映射，无论是单向还是双向，他们的存储结构是相同的，之所以映射文件不同，是因为加载时不同（在增删改时）。

无论是多对一、一对多、一对一还是多对一，A对B，A就是主动方，A主动想要了解B的情况，这样把B设置到A端。而双向，也就是A对B，A想了解B的信息，而B也想了解A的信息，那就要同时把A设置到B端了。

【相关推荐】

1. 特别推荐：“php程序员工具箱”V0.1版本下载

2. Java免费视频教程

3. 阿里巴巴Java开发手册

Das obige ist der detaillierte Inhalt vonAusführliche Erläuterung von Beispielen für zwei Arten der Hibernate-Klassenzuordnung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!