Java进阶知识12 Hibernate多对多双向关联（Annotation+XML实现）

1、Annotation 注解版

1.1、应用场景（Student-Teacher）：当学生知道有哪些老师教，老师也知道自己教哪些学生时，可用双向关联

1.2、创建Teacher类和Student类

 package com.shore.model;

 import java.util.HashSet;
 import java.util.Set;

 import javax.persistence.Entity;
 import javax.persistence.GeneratedValue;
 import javax.persistence.GenerationType;
 import javax.persistence.Id;
 import javax.persistence.ManyToMany;
 import javax.persistence.Table;

 /**
  * @author DSHORE/2019-9-22
  * 多对多，双向关联（注解版）
  */
 @Entity
 @Table(name="anno_teacher")
 public class Teacher {
     private Integer id;
     private String name;
     private Integer age;
     private Set<Student> students = new HashSet<Student>();

     @Id
     @GeneratedValue(strategy=GenerationType.IDENTITY)
     public Integer getId() {
         return id;
     }
     public void setId(Integer id) {
         this.id = id;
     }
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public Integer getAge() {
         return age;
     }
     public void setAge(Integer age) {
         this.age = age;
     }

     @ManyToMany(mappedBy="teachers") //和单向的多对多，只多了这一步。 只要是双向关联，必须加上这句话：（mappedBy="xxxxxx"）
     public Set<Student> getStudents() {
         return students;
     }
     public void setStudents(Set<Student> students) {
         this.students = students;
     }
 }

Student类

 package com.shore.model;

 import java.util.HashSet;
 import java.util.Set;

 import javax.persistence.Entity;
 import javax.persistence.GeneratedValue;
 import javax.persistence.GenerationType;
 import javax.persistence.Id;
 import javax.persistence.JoinColumn;
 import javax.persistence.JoinTable;
 import javax.persistence.ManyToMany;
 import javax.persistence.Table;

 /**
  * @author DSHORE/2019-9-22
  * 多对一，双向关联（注解版）
  */
 @Entity
 @Table(name="anno_student")
 public class Student {
     private Integer id;
     private String number;
     private Float sum;
     private Set<Teacher> teachers = new HashSet<Teacher>();

     @Id
     @GeneratedValue(strategy=GenerationType.IDENTITY)
     public Integer getId() {
         return id;
     }
     public void setId(Integer id) {
         this.id = id;
     }
     public String getNumber() {
         return number;
     }
     public void setNumber(String number) {
         this.number = number;
     }
     public Float getSum() {
         return sum;
     }
     public void setSum(Float sum) {
         this.sum = sum;
     }

     /**
      * name：中间表的表名
      * joinColumns：当前对象所对应的id
      * inverseJoinColumns：对方对象所对应的id
      */
     @ManyToMany
     @JoinTable(name="anno_student_teacher",
                joinColumns=@JoinColumn(name="student_id"),
                inverseJoinColumns=@JoinColumn(name="teacher_id"))
     public Set<Teacher> getTeachers() {
         return teachers;
     }
     public void setTeachers(Set<Teacher> teachers) {
         this.teachers = teachers;
     }
 }

1.3、创建hibernate.cfg.xml核心配置文件

 <?xml version='1.0' encoding='utf-8'?>
 <!DOCTYPE hibernate-configuration PUBLIC
         "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
         "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

 <hibernate-configuration>
     <session-factory>
         <!-- Database connection settings -->
         <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
         <property name="connection.url">jdbc:mysql://localhost:3306/hibernate</property>
         <property name="connection.username">root</property>
         <property name="connection.password">123456</property>

         <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
         <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>
         <property name="show_sql">true</property>
         <property name="hbm2ddl.auto">create</property>

         <mapping class="com.shore.model.Teacher" />
         <mapping class="com.shore.model.Student" />
     </session-factory>
 </hibernate-configuration>

1.4、开始测试

 package com.shore.test;

 import org.hibernate.cfg.AnnotationConfiguration;
 import org.hibernate.tool.hbm2ddl.SchemaExport;
 import org.junit.Test;

 /**
  * @author DSHORE/2019-9-22
  *
  */
 public class AnnotationTest {
     @Test
     public void test() {//简单测试，只创建表，不插入数据
                     //注解版，这里用AnnotationConfiguration()方法。
         new SchemaExport(new AnnotationConfiguration().configure()).create(
                 false, true);
     }
 }

测试结果图：

　　　　

　　　　

　　表结构虽然看起来和单向多对多关联的没什么区别，但进行CRUD操作时，就会发现他们的区别了，此处不做解析

2、XML版 的实现

2.1、创建Teacher类和Student类

 package com.shore.model;

 import java.util.HashSet;
 import java.util.Set;

 /**
  * @author DSHORE/2019-9-22
  * 多对多，双向关联（xml版）
  */
 public class Teacher {
     private Integer id;
     private String name;
     private Integer age;
     private Set<Student> students = new HashSet<Student>();

     public Integer getId() {
         return id;
     }
     public void setId(Integer id) {
         this.id = id;
     }
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public Integer getAge() {
         return age;
     }
     public void setAge(Integer age) {
         this.age = age;
     }
     public Set<Student> getStudents() {
         return students;
     }
     public void setStudents(Set<Student> students) {
         this.students = students;
     }
 }

Student类

 package com.shore.model;

 import java.util.HashSet;
 import java.util.Set;

 /**
  * @author DSHORE/2019-9-22
  * 多对多，双向关联（xml版）
  */
 public class Student {
     private Integer id;
     private String number;
     private Float sum;
     private Set<Teacher> teachers = new HashSet<Teacher>();

     public Integer getId() {
         return id;
     }
     public void setId(Integer id) {
         this.id = id;
     }
     public String getNumber() {
         return number;
     }
     public void setNumber(String number) {
         this.number = number;
     }
     public Float getSum() {
         return sum;
     }
     public void setSum(Float sum) {
         this.sum = sum;
     }
     public Set<Teacher> getTeachers() {
         return teachers;
     }
     public void setTeachers(Set<Teacher> teachers) {
         this.teachers = teachers;
     }
 }

2.2、创建 Teacher.hbm.xml 配置文件和 Student.hbm.xml 配置文件

 <?xml version="1.0"?>
 <!DOCTYPE hibernate-mapping PUBLIC
         "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
         "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

 <hibernate-mapping package="com.shore.model">
     <class name="Teacher" table="xml_teacher">
         <id name="id">
             <generator class="native"/>
         </id>
         <property name="name" type="java.lang.String"/>
         <property name="age" type="java.lang.Integer"/>

         <!-- 多对多 双向关联 -->
         <set name="students" table="xml_student_teacher">
             <key column="teacher_id"/> <!-- 当前对象所对应的id -->
             <many-to-many class="com.shore.model.Student" column="student_id"/> <!-- 对方对象所对应的id -->
         </set>
     </class>
 </hibernate-mapping>

Student.hbm.xml 配置文件

 <?xml version="1.0"?>
 <!DOCTYPE hibernate-mapping PUBLIC
         "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
         "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

 <hibernate-mapping package="com.shore.model">
     <class name="Student" table="xml_student">
         <id name="id">
             <generator class="native"/>
         </id>
         <property name="number" type="java.lang.String"/>
         <property name="sum" type="java.lang.Float"/>

         <!-- 多对多 双向关联 -->
         <set name="teachers" table="xml_student_teacher">
             <key column="student_id"/> <!-- 当前对象所对应的id -->
             <many-to-many class="com.shore.model.Teacher" column="teacher_id"/> <!-- 对方对象所对应的id -->
         </set>
     </class>
 </hibernate-mapping>

2.3、创建hibernate.cfg.xml 核心配置文件

 <?xml version='1.0' encoding='utf-8'?>
 <!DOCTYPE hibernate-configuration PUBLIC
         "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
         "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

 <hibernate-configuration>
     <session-factory>
         <!-- Database connection settings -->
         <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
         <property name="connection.url">jdbc:mysql://localhost:3306/hibernate</property>
         <property name="connection.username">root</property>
         <property name="connection.password">123456</property>

         <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
         <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>
         <property name="show_sql">true</property>
         <property name="hbm2ddl.auto">create</property>

         <!-- <mapping class="com.shore.model.Teacher" />
         <mapping class="com.shore.model.Student" /> -->
         <mapping resource="com/shore/model/Teacher.hbm.xml" />
         <mapping resource="com/shore/model/Student.hbm.xml" />
     </session-factory>
 </hibernate-configuration>

2.4、开始测试

 package com.shore.test;

 import org.hibernate.cfg.Configuration;
 import org.hibernate.tool.hbm2ddl.SchemaExport;
 import org.junit.Test;

 /**
  * @author DSHORE/2019-9-22
  *
  */
 public class XMLTest {
     @Test
     public void test() {//简单测试，只创建表，不插入数据
                     //xml版，这里用的是Configuration()方法。
         new SchemaExport(new Configuration().configure()).create(
                 false, true);
     }
 }

测试结果图：

　　　　

　　　　

　　表结构虽然看起来和单向多对多关联的没什么区别，但进行CRUD操作时，就会发现他们的区别了，此处不做解析

Hibernate一对一单向关联映射（Annotation+XML实现）：https://www.cnblogs.com/dshore123/p/11545058.html
Hibernate一对一双向关联映射（Annotation+XML实现）：https://www.cnblogs.com/dshore123/p/11545077.html

Hibernate多对一单向关联映射（Annotation+XML实现）：https://www.cnblogs.com/dshore123/p/11553213.html
Hibernate一对多单向关联映射（Annotation+XML实现）：https://www.cnblogs.com/dshore123/p/11553215.html
Hibernate一对多和多对一双向关联映射（Annotation+XML实现）：https://www.cnblogs.com/dshore123/p/11560433.html

Hibernate多对多单向关联映射（Annotation+XML实现）：https://www.cnblogs.com/dshore123/p/11568536.html
Hibernate多对多双向关联映射（Annotation+XML实现）：https://www.cnblogs.com/dshore123/p/11568963.html

原创作者：DSHORE

作者主页：http://www.cnblogs.com/dshore123/

原文出自：https://www.cnblogs.com/dshore123/p/11568963.html

版权声明：欢迎转载，转载务必说明出处。（如果本文对您有帮助，可以点击一下右下角的 推荐，或评论，谢谢！）