hiberate 映射关系 详解

　

　　在我们平时所学的关系型数据库中，我们会大量处理表与表之间的关系，如果表比较多的话处理起来就比较繁琐了，但是hibernate给我们提供了很大的便利，这些便利让我们处理起来方便。我们所讲的源码地址:http://download.csdn.net/detail/yfyzy/8953565

　　如果我们把表的每条记录当成一个对象的话，那我们我们的映射关系可以分为四种

　　1）一对一

　　2）一对多

　　3）多对一

　　4）多对多

准备工作

现在我们假设有四个表，员工表，部门表，办工作表，职位表，有如下映射关系

　　1）多个员工对应一个部门

　　2）一个部门对应多个员工

　　3）一个员工对应多个职位（这里我们假设一个人有多大能力，就要承担多大责任，所有就先多对多啦~O(∩_∩)O~）。

　　4）一个职位对应多个员工

　　5）一个员工对应一张办公桌，一张办公桌对应一个员工。

1.多对一 与 一对多

　　通过上面的描述我们知道员工多个员工对应着一个部门

员工实体（多方）

 package entity;

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

 public class Emp {

     private int id ;        //员工id
     private String name ;   //员工姓名
     private int age ;    //员工年龄
     private Dept dept;   //员工部门 ,注意这里是Dept对象哦，不是id哦

     public int getId() {
         return id;
     }
     public void setId(int id) {
         this.id = id;
     }
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public int getAge() {
         return age;
     }
     public void setAge(int age) {
         this.age = age;
     }
     public Dept getDept() {
         return dept;
     }
     public void setDept(Dept dept) {
         this.dept = dept;
     }
     public Set<Position> getPositions() {
         return positions;
     }
     public void setPositions(Set<Position> positions) {
         this.positions = positions;
     }

     }

 }

员工实例与数据库表映射关系配置（多方）

 <!DOCTYPE hibernate-mapping PUBLIC
     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

  <!-- 员工实体类Emp与员工表t_emp的映射  -->
 <hibernate-mapping >
     <class name="entity.Emp" table="t_emp">

        <!-- 主键id配置 -->
         <id name="id" column="id">
         <!--
             数据库的主键生成策略  native配置为使用数据库自带的生成策略  关于参数详解参考：http://www.cnblogs.com/yfyzy/p/4675041.html
         -->
             <generator class="native"></generator>
         </id>

         <!-- 属性设置 -->
         <property name="name" column="name" >
         </property>
         <property name="age" column="age">
         </property>

         <!-- 多对一配置，多个员工对应一个部门 -->
         <many-to-one  name = "dept" class="entity.Dept"
         column = "dept_id" cascade="save-update">
         </many-to-one>

     </class>
 </hibernate-mapping>

部门实体（一方）

 package entity;

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

 public class Dept {
     private int id; // 部门id
     private String dname; // 部门名称
     private Set<Emp> emps = new HashSet<Emp>();  //该部门的员工，是一个集合。

     public int getId() {
         return id;
     }

     public void setId(int id) {
         this.id = id;
     }

     public String getDname() {
         return dname;
     }

     public void setDname(String dname) {
         this.dname = dname;
     }

     public Set<Emp> getEmps() {
         return emps;
     }

     public void setEmps(Set<Emp> emps) {
         this.emps = emps;
     }

 }

部门实体与数据表的映射（一方）

 <!DOCTYPE hibernate-mapping PUBLIC
     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

  <!-- 部门实体类Dept与员工表t_dept的映射  -->
   <hibernate-mapping>
       <class name = "entity.Dept" table = "t_dept">

             <!-- 主键id配置 -->
            <id name="id" column="id">
         <!--
             数据库的主键生成策略  native配置为使用数据库自带的生成策略  关于参数详解参考：http://www.cnblogs.com/yfyzy/p/4675041.html
         -->
             <generator class="native"></generator>
         </id>

          <!-- 属性设置 -->
         <property name="dname" column="dname" >
         </property>

         <!-- 一对多配置，一个部门有多个员工，所以是一个集合 -->
         <set name = "emps" cascade = "all" inverse="true">
                <key column = "dept_id"></key>
                <one-to-many class="entity.Emp"></one-to-many>
         </set>

       </class>
   </hibernate-mapping>

 2.多对多

　　这里我们假设的是，一个员工对应多个职位，一个职位有多个员工。

员工实体类

 package entity;

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

 public class Emp {

     private int id ;        //员工id
     private String name ;   //员工姓名
     private int age ;    //员工年龄
     private Dept dept;   //员工部门 ,注意这里是Dept对象哦，不是id哦
     private Set<Position> positions = new HashSet<Position>();  //注意这里是一个Position职位集合，我们这里假设一个员工可以对应多个职位

     public int getId() {
         return id;
     }
     public void setId(int id) {
         this.id = id;
     }
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public int getAge() {
         return age;
     }
     public void setAge(int age) {
         this.age = age;
     }
     public Dept getDept() {
         return dept;
     }
     public void setDept(Dept dept) {
         this.dept = dept;
     }
     public Set<Position> getPositions() {
         return positions;
     }
     public void setPositions(Set<Position> positions) {
         this.positions = positions;
     }
 }

员工实体与数据库映射关系

 <!DOCTYPE hibernate-mapping PUBLIC
     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

  <!-- 员工实体类Emp与员工表t_emp的映射  -->
 <hibernate-mapping >
     <class name="entity.Emp" table="t_emp">

        <!-- 主键id配置 -->
         <id name="id" column="id">
         <!--
             数据库的主键生成策略  native配置为使用数据库自带的生成策略  关于参数详解参考：http://www.cnblogs.com/yfyzy/p/4675041.html
         -->
             <generator class="native"></generator>
         </id>

         <!-- 属性设置 -->
         <property name="name" column="name" >
         </property>
         <property name="age" column="age">
         </property>

         <!-- 多对一配置，多个员工对应一个部门 -->
         <many-to-one  name = "dept" class="entity.Dept"
         column = "dept_id" cascade="save-update">
         </many-to-one>

         <!-- 多对多配置，一个员工可以对应多个职位 -->
         <set name="positions" inverse="false" cascade="save-update" table="t_emp_position">
             <key column="emp_id"></key>
             <many-to-many class = "entity.Position" column = "position_id">
             </many-to-many>
         </set>

     </class>
 </hibernate-mapping>

职位实体

 package entity;

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

 public class Position {
     private int id ;   //职位id
     private String positionName ;  //职位名称
     private Set<Emp> emps = new HashSet<Emp>();     //存放这种职位的员工

     public Set<Emp> getEmps() {
         return emps;
     }
     public void setEmps(Set<Emp> emps) {
         this.emps = emps;
     }
     public int getId() {
         return id;
     }
     public void setId(int id) {
         this.id = id;
     }
     public String getPositionName() {
         return positionName;
     }
     public void setPositionName(String positionName) {
         this.positionName = positionName;
     }  

 }

实体与数据库表的映射关系

 <!DOCTYPE hibernate-mapping PUBLIC
     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

 <!-- 职位实体类Emp与员工表t_position的映射  -->
 <hibernate-mapping>
     <class name="entity.Position" table="t_position">

          <!-- 主键id配置 -->
         <id name="id" column = "id">
             <generator class="native"></generator>
         </id>    

          <!-- 属性设置 -->
         <property name="positionName" column="position_name"/>

           <!-- 多对多配置，一个职位可以对应多个员工 -->
         <set name="emps" inverse="true" cascade="save-update" table="t_emp_position">
             <key column="position_id"></key>
             <many-to-many class = "entity.Emp" column = "emp_id">
             </many-to-many>
         </set>

     </class>

 </hibernate-mapping>

3.一对一

　　 一个员工对应一个办公桌，一张办公桌也只对应一个员工

一对关联的方式有两种

　　1）外键关联

　　2）主键关联

3.1外键关联

　　本质上是一对多的蜕化形式。在<many-to-one>元素中设置属性unique=”true”就变成了一对一。

员工实体

 package entity;

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

 public class Emp {

     private int id ;        //员工id
     private String name ;   //员工姓名
     private int age ;    //员工年龄
     private Dept dept;   //员工部门 ,注意这里是Dept对象哦，不是id哦
     private Set<Position> positions = new HashSet<Position>();  //注意这里是一个Position职位集合，我们这里假设一个员工可以对应多个职位。
     private Desk desk;  //办工桌对象

     public int getId() {
         return id;
     }
     public void setId(int id) {
         this.id = id;
     }
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public int getAge() {
         return age;
     }
     public void setAge(int age) {
         this.age = age;
     }
     public Dept getDept() {
         return dept;
     }
     public void setDept(Dept dept) {
         this.dept = dept;
     }
     public Set<Position> getPositions() {
         return positions;
     }
     public void setPositions(Set<Position> positions) {
         this.positions = positions;
     }
     public Desk getDesk() {
         return desk;
     }
     public void setDesk(Desk desk) {
         this.desk = desk;
     }

 }

员工实体类Emp与数据库表t_emp的映射关系

 <!DOCTYPE hibernate-mapping PUBLIC
     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

  <!-- 员工实体类Emp与员工表t_emp的映射  -->
 <hibernate-mapping >
     <class name="entity.Emp" table="t_emp">

        <!-- 主键id配置 -->
         <id name="id" column="id">
         <!--
             数据库的主键生成策略  native配置为使用数据库自带的生成策略  关于参数详解参考：http://www.cnblogs.com/yfyzy/p/4675041.html
         -->
             <generator class="native"></generator>
         </id>

         <!-- 属性设置 -->
         <property name="name" column="name" >
         </property>
         <property name="age" column="age">
         </property>

         <!-- 多对一配置，多个员工对应一个部门 -->
         <many-to-one  name = "dept" class="entity.Dept"
         column = "dept_id" cascade="save-update">
         </many-to-one>

         <!-- 多对多配置，一个员工可以对应多个职位 -->
         <set name="positions" inverse="false" cascade="save-update" table="t_emp_position">
             <key column="emp_id"></key>
             <many-to-many class = "entity.Position" column = "position_id">
             </many-to-many>
         </set>

         <!-- 一对一配置，设置属性unique=”true”就变成了一对一  -->
         <many-to-one name="desk" class="entity.Desk" column="desk_id" unique="true"></many-to-one>

     </class>
 </hibernate-mapping>

办工桌实体类

 package entity;

 public class Desk {

     private int id ; // 办公桌id
     private String deskName; //办工桌名称
     private Emp emp ;  //员工，这张桌子的拥有者

     public int getId() {
         return id;
     }
     public void setId(int id) {
         this.id = id;
     }
     public String getDeskName() {
         return deskName;
     }
     public void setDeskName(String deskName) {
         this.deskName = deskName;
     }
     public Emp getEmp() {
         return emp;
     }
     public void setEmp(Emp emp) {
         this.emp = emp;
     }
 }

办工桌实体类Desk与数据库表t_desk的映射

 <!DOCTYPE hibernate-mapping PUBLIC
     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

  <!-- 部门实体类Dept与员工表t_dept的映射  -->
   <hibernate-mapping>
       <class name = "entity.Desk" table = "t_desk">

             <!-- 主键id配置 -->
            <id name="id" column="id">
         <!--
             数据库的主键生成策略  native配置为使用数据库自带的生成策略  关于参数详解参考：http://www.cnblogs.com/yfyzy/p/4675041.html
         -->
             <generator class="native"></generator>
         </id>

          <!-- 属性设置 -->
         <property name="deskName" column="desk_name" >
         </property>

         <!-- 一对一配置，一个员工对应一张桌子   -->
         <one-to-one name="emp" class="entity.Emp" cascade="all" >
         </one-to-one>

       </class>
   </hibernate-mapping>

3.2主键关联

 　　主键关联即其中一个表的主键参照另外一张表的主键而建立起一对一关联关系

员工实体类Emp与数据库表t_emp的映射关系修改如下

       <!-- 一对一主键关联配置，一个员工对应一张桌子   -->
      <one-to-one name="desk" class="entity.Desk"></one-to-one>        

办工桌实体类Desk与数据库表t_desk修改如下

   <!-- 一对一配置，一个员工对应一张桌子   -->
 <one-to-one name="emp" class="entity.Emp" cascade="all" >
         </one-to-one>