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集合在实体类里面初始化和不初始化出现下面两种情况,所以需要注意两种测试测试的方法):

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


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();
} }

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

上一篇:【CodeLab 科技创新营】为了逃避每天关灯,我直接开发了一个app…


下一篇:【转】Source Insight中文注释为乱码的解决办法