原文： https://howtodoinjava.com/hibernate/hibernate-many-to-many-mapping-using-annotations/

在两个实体之间建立多对多 Hiberate 的映射，其中一个实体可以与多个其他实体实例相关。 例如，对于订阅服务，SubscriptionEntity和ReaderEntity可以是两种类型的实体。 任何订阅都可以有多个阅读器，其中一个阅读器可以订阅多个订阅。

在此 hibernate 教程中，我们将学习使用 hibernate 在数据库中创建多对多映射。

  1. Table of contents
  3. Hibernate many to many mapping design
  4. Owner entity
  5. Mapped entity
  6. Configure entities in hibernate config file
  7. Demo

1. Hiberate 多对多映射设计

为了演示使用 Hiberate 注解的多对多映射，我们将关联两个实体，即ReaderEntity和SubscriptionEntity。

他们的数据库架构应如下所示。 使用这些表，任何应用都可以保存读者和订阅之间的多个关联。

Hiberate 多对多映射注解示例 - 图1

2. 所有者实体

所有者实体是负责建立关联并维护它的实体。 在我们的情况下，我将ReaderEntity设置为所有者实体。 @JoinTable注解已用于建立此关联。

  1. package hibernate.test.manyToMany.joinTable;
  3. import java.io.Serializable;
  4. import java.util.Set;
  6. import javax.persistence.CascadeType;
  7. import javax.persistence.Column;
  8. import javax.persistence.Entity;
  9. import javax.persistence.GeneratedValue;
  10. import javax.persistence.GenerationType;
  11. import javax.persistence.Id;
  12. import javax.persistence.JoinColumn;
  13. import javax.persistence.JoinTable;
  14. import javax.persistence.ManyToMany;
  15. import javax.persistence.Table;
  16. import javax.persistence.UniqueConstraint;
  18. @Entity(name = "ReaderEntity")
  19. @Table(name = "READER", uniqueConstraints = {
  20.         @UniqueConstraint(columnNames = "ID"),
  21.         @UniqueConstraint(columnNames = "EMAIL") })
  23. public class ReaderEntity implements Serializable 
  24. {
  25.     private static final long serialVersionUID = -1798070786993154676L;
  27.     @Id
  28.     @GeneratedValue(strategy = GenerationType.IDENTITY)
  29.     @Column(name = "ID", unique = true, nullable = false)
  30.     private Integer readerId;
  32.     @Column(name = "EMAIL", unique = true, nullable = false, length = 100)
  33.     private String email;
  35.     @Column(name = "FIRST_NAME", unique = false, nullable = false, length = 100)
  36.     private String firstName;
  38.     @Column(name = "LAST_NAME", unique = false, nullable = false, length = 100)
  39.     private String lastName;
  41.     @ManyToMany(cascade=CascadeType.ALL)
  42.     @JoinTable(name="READER_SUBSCRIPTIONS", joinColumns={@JoinColumn(referencedColumnName="ID")}
  43.                                         , inverseJoinColumns={@JoinColumn(referencedColumnName="ID")})    
  44.     private Set<SubscriptionEntity> subscriptions;
  46.     //Getters and setters
  47. }

3. 映射实体

我们的映射实体是SubscriptionEntity，它使用“mappingBy”属性映射到ReaderEntity。

  1. package hibernate.test.manyToMany.joinTable;
  3. import java.io.Serializable;
  4. import java.util.Set;
  6. import javax.persistence.Column;
  7. import javax.persistence.Entity;
  8. import javax.persistence.GeneratedValue;
  9. import javax.persistence.GenerationType;
  10. import javax.persistence.Id;
  11. import javax.persistence.ManyToMany;
  12. import javax.persistence.Table;
  13. import javax.persistence.UniqueConstraint;
  15. @Entity(name = "SubscriptionEntity")
  16. @Table(name = "SUBSCRIPTION", uniqueConstraints = {
  17.         @UniqueConstraint(columnNames = "ID")})
  19. public class SubscriptionEntity implements Serializable 
  20. {
  21.     private static final long serialVersionUID = -6790693372846798580L;
  23.     @Id
  24.     @GeneratedValue(strategy = GenerationType.IDENTITY)
  25.     @Column(name = "ID", unique = true, nullable = false)
  26.     private Integer subscriptionId;
  28.     @Column(name = "SUBS_NAME", unique = true, nullable = false, length = 100)
  29.     private String subscriptionName;
  31.     @ManyToMany(mappedBy="subscriptions")
  32.     private Set<ReaderEntity> readers;
  34.     //Getters and setters
  35. }

4. 在 Hiberate 配置文件中配置实体

我们使两个实体都可以在运行时使用。 为此，我们必须将它们添加到hibernate.cfg.xml文件中。

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!DOCTYPE hibernate-configuration PUBLIC
  3. "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
  4. "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
  5. <hibernate-configuration>
  6.     <session-factory>
  7.         <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
  8.         <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernatetest</property>
  9.         <property name="hibernate.connection.password">XXXXXX</property>
  10.         <property name="hibernate.connection.username">root</property>
  11.         <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
  12.         <property name="show_sql">true</property>
  13.         <property name="hbm2ddl.auto">create</property>
  14.         <mapping class="hibernate.test.manyToMany.joinTable.ReaderEntity"/>
  15.         <mapping class="hibernate.test.manyToMany.joinTable.SubscriptionEntity"/>
  16.     </session-factory>
  17. </hibernate-configuration>

5. Hiberate 多对多注解映射示例

现在，该测试代码了。 我编写了以下代码来测试上述实体及其多对多关系。

  1. package hibernate.test.manyToMany;
  3. import hibernate.test.HibernateUtil;
  4. import hibernate.test.manyToMany.joinTable.*;
  6. import java.util.HashSet;
  7. import java.util.Set;
  9. import org.hibernate.Session;
  11. public class TestJoinTable
  12. {
  13.     public static void main(String[] args) 
  14.     {
  15.         Session session = HibernateUtil.getSessionFactory().openSession();
  16.         session.beginTransaction();
  18.         //Add subscription
  19.         SubscriptionEntity subOne = new SubscriptionEntity();
  20.         subOne.setSubscriptionName("Entertainment");
  22.         SubscriptionEntity subTwo = new SubscriptionEntity();
  23.         subTwo.setSubscriptionName("Horror");
  25.         Set<SubscriptionEntity> subs = new HashSet<SubscriptionEntity>();
  26.         subs.add(subOne);
  27.         subs.add(subTwo);
  29.         //Add readers
  30.         ReaderEntity readerOne = new ReaderEntity();
  31.         readerOne.setEmail("demo-user1@mail.com");
  32.         readerOne.setFirstName("demo");
  33.         readerOne.setLastName("user");
  35.         ReaderEntity readerTwo = new ReaderEntity();
  36.         readerTwo.setEmail("demo-user2@mail.com");
  37.         readerTwo.setFirstName("demo");
  38.         readerTwo.setLastName("user");
  40.         Set<ReaderEntity> readers = new HashSet<ReaderEntity>();
  41.         readers.add(readerOne);
  42.         readers.add(readerTwo);
  44.         readerOne.setSubscriptions(subs);
  45.         readerTwo.setSubscriptions(subs);
  47.         session.save(readerOne);
  48.         session.save(readerTwo);
  50.         session.getTransaction().commit();
  51.         HibernateUtil.shutdown();
  52.     }
  53. }

程序输出：

  1. Hibernate: insert into READER (EMAIL, FIRST_NAME, LAST_NAME) values (?, ?, ?)
  2. Hibernate: insert into SUBSCRIPTION (SUBS_NAME) values (?)
  3. Hibernate: insert into SUBSCRIPTION (SUBS_NAME) values (?)
  4. Hibernate: insert into READER (EMAIL, FIRST_NAME, LAST_NAME) values (?, ?, ?)
  5. Hibernate: insert into READER_SUBSCRIPTIONS (readers_ID, subscriptions_ID) values (?, ?)
  6. Hibernate: insert into READER_SUBSCRIPTIONS (readers_ID, subscriptions_ID) values (?, ?)
  7. Hibernate: insert into READER_SUBSCRIPTIONS (readers_ID, subscriptions_ID) values (?, ?)
  8. Hibernate: insert into READER_SUBSCRIPTIONS (readers_ID, subscriptions_ID) values (?, ?)

下载源码

在此示例中，我们了解了在 Hiberate 中使用多对多注解来连接表。

学习愉快！