Hibernate之关联关系映射(一对多和多对一映射，多对多映射)

~~~接着之前的Hibernate框架接着学习（上篇面试过后发现真的需要学习一下框架了，不然又被忽悠让去培训。）~~~

1：Hibernate的关联映射，存在一对多和多对一映射，多对多映射：

　　1.1：一对多和多对一映射，举例说明：

　　　　 学生和老师：

　　　　　　 一个老师可以教多个学生 【一对多映射】

　　　　　　多个学生可以被一个老师教【多对一映射】

　　　　部门与员工：

　　　　　　一个部门有多个员工【一对多映射】

　　　　　　多个员工属于一个部门【多对一映射】

　　1.2：多对多，举例说明：

　　　　项目和开发员工：【双向一对多即多对多映射】

　　　　　　一个项目有多个开发人员【一对多】

　　　　     一个开发人员参与多个项目【一对多】

---

2：一对多和多对一映射,理清以下思路就可以进行简单的开发了：

　　2.1：首先导入hibernate框架所需要的包哦~~~

　　2.2：由于是在hibernate.cfg.xml配置里面自动生成数据库和表，所以不用手动创建了

　　2.3：进入正题，开发创建实体类;下面是两个实体类的关键点；

　　　　Dept.java：

　　　　　　注意private Set<Employee> emps;//部门对应多个员工，即一对多的关系

　　　　Employee.java：

　　　　　　private Dept dept;//员工和部门的关系

 package com.bie.po;

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

 /**
 * @author BieHongLi
 * @version 创建时间：2017年3月20日 上午9:45:21
 * 部门的实体类
 *     关键点，是通过部门实体类维护到员工的实体类
 */
 public class Dept {

     private int deptId;//部门编号
     private String deptName;//部门名称

     private Set<Employee> emps;//部门对应多个员工，即一对多的关系
     //private Set<Employee> emps = new HashSet<>();//方便赋值，这里可以直接创建实例化

     public int getDeptId() {
         return deptId;
     }
     public void setDeptId(int deptId) {
         this.deptId = deptId;
     }
     public String getDeptName() {
         return deptName;
     }
     public void setDeptName(String deptName) {
         this.deptName = deptName;
     }
     public Set<Employee> getEmps() {
         return emps;
     }
     public void setEmps(Set<Employee> emps) {
         this.emps = emps;
     }

 }

 package com.bie.po;
 /**
 * @author BieHongLi
 * @version 创建时间：2017年3月20日 上午9:46:45
 * 员工的实体类
 */
 public class Employee {

     private int empId;//员工的编号
     private String empName;//员工的名称
     private double salary;//员工的薪资

     private Dept dept;//员工和部门的关系

     public int getEmpId() {
         return empId;
     }
     public void setEmpId(int empId) {
         this.empId = empId;
     }
     public String getEmpName() {
         return empName;
     }
     public void setEmpName(String empName) {
         this.empName = empName;
     }
     public double getSalary() {
         return salary;
     }
     public void setSalary(double salary) {
         this.salary = salary;
     }
     public Dept getDept() {
         return dept;
     }
     public void setDept(Dept dept) {
         this.dept = dept;
     }

 }

　　2.4：创建好实体类就可以进行创建hibernate的映射文件了，如Dept.hbm.xml和Employee.hbm.xml映射文件；

　　　　 部门表进行映射的时候：

　　　　　　需要注意使用set集合进行映射的注意点：

Dept映射关键点：
：指定映射的集合属性："emps"
：集合属性对应的集合表："20171021_employee"
：集合表的外键字段"20171021_employee.deptId"
：集合元素的类型

　　　　员工表进行映射的时候：

　　　　　　需要注意<many-to-one name="dept" column="deptId" class="Dept"></many-to-one>

　　　　　　将一个对象映射成为外键字段，只能使用many-to-one这个配置。

Employee映射关键点：
：映射的部门属性：dept
：映射的部门对象，对应的外键字段：dept_id
：指定部门的类型

 <?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属性直接初始化了，下面就可以直接引用了 -->
 <hibernate-mapping package="com.bie.po">
     <class name="Dept" table="dept">
         <!-- 第一首先写主键映射 -->
         <id name="deptId" column="deptId">
             <generator class="native"></generator>
         </id>
         <!-- 第二写非主键映射 -->
         <property name="deptName" column="deptName" length="20" type="string"></property>

         <!--
             第三写其他映射，比如这里的set集合映射,
         -->
         <!--
             一对多关联映射配置(通过部门管理到员工)
             Dept映射关键点
                 (1)指定映射的集合属性:""emps;
                 (2)集合属性对应的集合表："employee";
                 (3)集合表的外键字段：employee.empId
                 (4)集合元素的类型
          -->
         <!-- name指定了映射的集合的属性，即集合实例化的emps;table指定了集合属性对应的集合表 -->
         <set name="emps" table="employee">
             <!--column指定了集合表的外键  -->
             <key column="deptId"></key>
             <!-- class由于上面已经写了包名，这里直接使用即可 -->
             <one-to-many class="Employee"/>
         </set>
     </class>
 </hibernate-mapping>

 <?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">
 <!-- 这里指定package，里面就可以直接引用了 -->
 <hibernate-mapping package="com.bie.po">
     <class name="Employee" table="employee">
         <!-- 1：主键映射 -->
         <id name="empId" column="empId">
             <generator class="native"></generator>
         </id>

         <!-- 2:非主键映射 -->
         <property name="empName" column="empName" length="20" type="string"></property>
         <property name="salary" column="salary" type="double"></property>

         <!--
              多对一的映射配置;Employee映射的关键点
              (1)映射的部门属性：dept
              (2)映射的部门对新，对应的外键字段：deptId
              (3)部门的类型：Dept
          -->
          <many-to-one name="dept" column="deptId" class="Dept"></many-to-one>
     </class>

 </hibernate-mapping>    

　　2.5：配置好映射文件，就可以配置hibernate的配置文件了，hibernate.cfg.xml;

　　　　注意：

　　　　　　第二部分其他配置的时候注意显示sql语句和方言还有自动创建数据表这些细节问题

　　　　　　第三部分加载映射文件的写法也需要注意

 <!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>
         <!-- 第一部分：连接数据库的操作，加载驱动，连接数据库的url和账号密码 -->
         <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
         <property name="hibernate.connection.url">jdbc:mysql:///test</property>
         <property name="hibernate.connection.username">root</property>
         <property name="hibernate.connection.password">123456</property>

         <!-- 第二部分：其他相关配置 -->
         <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
         <property name="hibernate.show_sql">true</property>
         <property name="hibernate.format_sql">true</property>
         <property name="hibernate.hbm2ddl.auto">update</property>
         <!-- <property name="hibernate.hbm2ddl.auto">create</property> -->

         <!-- 第三部分：加载映射文件 -->
         <mapping resource="com/bie/po/Dept.hbm.xml"/>
         <mapping resource="com/bie/po/Employee.hbm.xml"/>
     </session-factory>
 </hibernate-configuration>

　　2.6:最后就可以使用junit进行测试了，如下所示：

　　　　（1）首先清楚下面两种测试的区别是是否在实体类实例化set集合

　　　　　　  private Set<Employee> emps;//部门对应多个员工，即一对多的关系
    　　　　　 private Set<Employee> emps = new HashSet<>();//方便赋值，这里可以直接创建实例化

　　　　（2）下面两种情况都可以设置好部门和员工的信息。就是在配置映射的时候一定搞清楚set集合映射的配置和many-to-one的配置

　　　　　　　I:从部门的一方设置员工的信息【不推荐】　

　　　　　　　　　dept.getEmps().add(emp1);
        　　　　 　　dept.getEmps().add(emp2);
      
        　　　　II:从员工的一方设置好部门的信息【推荐，在一对多和多对一的关联关系中，保存数据最好是通过多对一来维护关系，这样可以减少update语句的生成，从而提高hibernate的利用效率】
        　　　　　　emp1.setDept(dept);
        　　　　　　emp2.setDept(dept);

　　　　（3）最后是保存的顺序，保存的顺序最好是先保存一的一方再保存多的一方，这样可以提高效率，少执行sql语句

　　　　　  　第一种方法（推荐）

session.save(dept);//先保存一的一方
session.save(emp1);
session.save(emp2);//再保存多的一方，关系会自动维护(但是映射配置必须配置好的 )　　　　　       　　　　　

　　　　　　　第二种方法（不推荐）

session.save(emp1);//先保存多的一方，关系会自动维护(但是映射配置必须配置好的 )
session.save(emp2);
session.save(dept);//再保存一的一方

 package com.bie.test;

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

 import org.hibernate.Session;
 import org.hibernate.SessionFactory;
 import org.hibernate.cfg.Configuration;
 import org.junit.Test;

 import com.bie.po.Dept;
 import com.bie.po.Employee;

 /**
 * @author BieHongLi
 * @version 创建时间：2017年3月20日 上午10:29:38
 *
 */
 public class OneManyTest {

     //初始化静态的session工厂
     private static SessionFactory sf = null;
     static{
         //这里使用简写的方法，首先加载默认的hibernate.cfg.xml，然后是创建session工厂
         sf = new Configuration().configure().buildSessionFactory();
     }

     @Test
     public void test(){
         //创建session,import org.hibernate.Session;
         Session session = sf.openSession();
         //session开始事务
         session.beginTransaction();

         //1:关键点，部门对象的初始化,创建一个部门
         Dept dept = new Dept();
         dept.setDeptName("开发部");

         //2:关键点，员工的初始化，创建两个人对象
         Employee emp1 = new Employee();
         emp1.setEmpName("张三");
         Employee emp2 = new Employee();
         emp2.setEmpName("李四");

         //3:然后将创建的人添加到set集合中
         Set<Employee> set = new HashSet<>();
         set.add(emp1);
         set.add(emp2);

         //4:再将set集合中保存的人保存到部门里面
         dept.setEmps(set);

         //5:最后保存员工对象，部门
         session.save(emp1);
         session.save(emp2);
         session.save(dept);

         //提交事务，省去了事务new实例化了
         session.getTransaction().commit();
         //关闭session
         session.close();
     }

     @Test
     public void test2(){
         //创建session,import org.hibernate.Session;
         Session session = sf.openSession();
         //session开始事务
         session.beginTransaction();

         //1:关键点，部门对象的初始化,创建一个部门
         Dept dept = new Dept();
         dept.setDeptName("研发部2");

         //2:关键点，员工的初始化，创建两个人对象
         Employee emp1 = new Employee();
         emp1.setEmpName("小三子2");
         Employee emp2 = new Employee();
         emp2.setEmpName("小四子2");

         //3:再将set集合中保存的人保存到部门里面
         //dept.getEmps().add(emp1);
         //dept.getEmps().add(emp2);

         //或者是从员工的一方设置好部门的信息
         emp1.setDept(dept);
         emp2.setDept(dept);

         //4:最后保存员工对象，部门，保存的顺序也会影响sql语句的，所以最好先保存一的一方
         session.save(dept);//先保存一的一方
         session.save(emp1);
         session.save(emp2);//再保存多的一方，关系会自动维护(但是映射配置必须配置好的 )

         //提交事务，省去了事务new实例化了
         session.getTransaction().commit();
         //关闭session
         session.close();
     }

 }

测试结果如下所示（由于set集合在实体类里面初始化和不初始化出现下面两种情况，所以需要注意两种测试测试的方法）：

---

3:多对多映射，这个需要理解清楚他们之间的关系。不然很容易搞混乱的。

　　3.1：创建实体类：

　　　　Project.java

　　　　　 项目下面的多个员工
    　　　　private Set<Develope> deve = new HashSet<Develope>();

　　　  Develope.java

　　　　　开发人员参入的多个项目
    　　　  private Set<Project> project = new HashSet<Project>();　

 package com.bie.domain;

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

 /**
 * @author BieHongLi
 * @version 创建时间：2017年3月20日 下午5:32:42
 * 项目的实体类
 */
 public class Project {

     private int proId;
     private String proName;

     //项目下面的多个员工
     private Set<Develope> deve = new HashSet<Develope>();

     public int getProId() {
         return proId;
     }
     public void setProId(int proId) {
         this.proId = proId;
     }
     public String getProName() {
         return proName;
     }
     public void setProName(String proName) {
         this.proName = proName;
     }
     public Set<Develope> getDeve() {
         return deve;
     }
     public void setDeve(Set<Develope> deve) {
         this.deve = deve;
     }

 }

 package com.bie.domain;

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

 /**
 * @author BieHongLi
 * @version 创建时间：2017年3月20日 下午5:33:53
 * 项目参入人员
 */
 public class Develope {

     private int deveId;
     private String deveName;

     //开发人员参入的多个项目
     private Set<Project> project = new HashSet<Project>();

     public int getDeveId() {
         return deveId;
     }
     public void setDeveId(int deveId) {
         this.deveId = deveId;
     }
     public String getDeveName() {
         return deveName;
     }
     public void setDeveName(String deveName) {
         this.deveName = deveName;
     }
     public Set<Project> getProject() {
         return project;
     }
     public void setProject(Set<Project> project) {
         this.project = project;
     }

 }

　　3.2:如上面的，创建好实体类就可以配置就可以配置映射文件了：【注意，主键一定设置自增，开始我没写，报错了哦~~~】

　　　　Project.hbm.xml:【关键点】

　　　　　　<!-- 实体类set集合实例化的对象name和中间表table -->
          　　 <set name="deve" table="relation">
              　　<!-- 设置项目的主键 -->
              　　<key column="proId"></key>
              　　<!-- 设置人员的主键作为中间表的外键和人员对应的实体类 -->
              　　<many-to-many column="deve_Id" class="Develope"></many-to-many>
          　　</set>

　　　　Develope.hbm.xml:【关键点】

　　　　　　<set name="project" table="relation">
            　　　　<key column="deveId"></key>
           　　　　 <many-to-many column="proId" class="Project"></many-to-many>
        　　   </set>

 <?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.bie.domain">
     <class name="Project" table="project">
         <!-- 主键映射 -->
         <id name="proId" column="proId">
             <generator class="native"></generator>
         </id>
         <!-- 非主键映射 -->
         <property name="proName" column="proName" type="string" length="20"></property>

         <!-- 其他映射配置 -->
         <!--
             多对多映射：
                 1:映射的集合属性：deve
                 2:集合属性，对应的中间表：relation
                 3:外键字段：proId
                 4:外键字段，对应的中间表字段：deveId
                 5:集合属性元素的类型

          -->
         <!-- 实体类set集合实例化的对象name和中间表table -->
           <set name="deve" table="relation">
               <!-- 设置项目的主键 -->
               <key column="proId"></key>
               <!-- 设置人员的主键作为中间表的外键和人员对应的实体类 -->
               <many-to-many column="deve_Id" class="Develope"></many-to-many>
           </set> 

     </class>

 </hibernate-mapping>    

 <?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.bie.domain">
     <class name="Develope" table="develope">
         <!-- 主键映射 -->
         <id name="deveId" column="deveId">
             <generator class="native"></generator>
         </id>
         <!-- 非主键映射 -->
         <property name="deveName" column="deveName"></property>

         <!-- 其他映射配置 -->
         <!--
             多对多映射：员工方
                 1:映射的集合属性：project
                 2:集合属性，对应的中间表：relation
                 3:外键字段：deveId
                 4:外键字段，对应的中间表字段：proId
                 5:集合属性元素的类型
          -->
         <set name="project" table="relation">
             <key column="deveId"></key>
             <many-to-many column="proId" class="Project"></many-to-many>
         </set> 

     </class>

 </hibernate-mapping>

　　3.3：这里配置Hibernate.cfg.xml，和上面的配置类似。

　　　<!-- 第三部门：多对多映射的映射加载文件 -->
        <mapping resource="com/bie/domain/Project.hbm.xml"/>
        <mapping resource="com/bie/domain/Develope.hbm.xml"/>

 <!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>
         <!-- 第一部分：连接数据库的操作，加载驱动，连接数据库的url和账号密码 -->
         <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
         <property name="hibernate.connection.url">jdbc:mysql:///test</property>
         <property name="hibernate.connection.username">root</property>
         <property name="hibernate.connection.password">123456</property>

         <!-- 第二部分：其他相关配置 -->
         <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
         <property name="hibernate.show_sql">true</property>
         <!-- <property name="hibernate.format_sql">true</property> -->
         <property name="hibernate.hbm2ddl.auto">update</property>
         <!-- <property name="hibernate.hbm2ddl.auto">create</property> -->

         <!-- 第三部分：加载映射文件 -->
         <mapping resource="com/bie/po/Dept.hbm.xml"/>
         <mapping resource="com/bie/po/Employee.hbm.xml"/>

         <!-- 第三部门：多对多映射的映射加载文件 -->
         <mapping resource="com/bie/domain/Project.hbm.xml"/>
         <mapping resource="com/bie/domain/Develope.hbm.xml"/>

     </session-factory>
 </hibernate-configuration>

　　3.4:最后测试就可以了，多对多的关系映射：

 package com.bie.test;

 import org.hibernate.Session;
 import org.hibernate.SessionFactory;
 import org.hibernate.cfg.Configuration;
 import org.junit.Test;

 import com.bie.domain.Develope;
 import com.bie.domain.Project;

 /**
 * @author BieHongLi
 * @version 创建时间：2017年3月20日 下午7:27:00
 * 多对多的测试
 */
 public class Many2ManyTest {

     public static SessionFactory sf =null;
     static{
         sf = new Configuration().configure().buildSessionFactory();
     }

     @Test
     public void test(){
         Session session = sf.openSession();
         session.beginTransaction();

         //创建项目和员工进行保存测试
         Project pro1 = new Project();
         pro1.setProName("企业费用管理系统");
         Project pro2 = new Project();
         pro2.setProName("企业办公系统");

         Develope dev1 = new Develope();
         dev1.setDeveName("张三");
         Develope dev2 = new Develope();
         dev2.setDeveName("李四");
         Develope dev3 = new Develope();
         dev3.setDeveName("王五");

         //设置关系，
         pro1.getDeve().add(dev1);
         pro1.getDeve().add(dev2);
         pro2.getDeve().add(dev1);
         pro2.getDeve().add(dev3);

         //保存到session中,保存员工和项目到session中
         session.save(dev1);
         session.save(dev2);
         session.save(dev3);

         session.save(pro1);
         session.save(pro2);

         //提交
         session.getTransaction().commit();
         session.close();
     }

 }

只有学习才能使我快乐~~~，加油~~~