Hibernate的關聯映射

一 .關聯映射的主要內容

    1. 集合映射
    2. 一對多與多對一映射 (重點)
    3. 多對多映射
    4. inverse/lazy/cascade 關鍵字

1.1 關聯映射的使用

普通類型的集合使用:
例子,一個用戶對應了多個收貨地址

javabean的設計:User.java

package com.mrq.entity;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class User {
    
    
    private Integer userId;
    private String userName;
    private Set<String> addressSet = new HashSet<>();  //set
    private List<String> addressList = new ArrayList<>(); //list
    private Map<String, String> addressMap = new HashMap<>(); //map
    
    public Integer getUserId() {
        return userId;
    }
    
    public void setUserId(Integer userId) {
        this.userId = userId;
    }
    
    public String getUserName() {
        return userName;
    }
    
    public void setUserName(String userName) {
        this.userName = userName;
    }
    
    public Set<String> getAddressSet() {
        return addressSet;
    }
    
    public void setAddressSet(Set<String> addressSet) {
        this.addressSet = addressSet;
    }
    
    public List<String> getAddressList() {
        return addressList;
    }
    
    public void setAddressList(List<String> addressList) {
        this.addressList = addressList;
    }
    
    public Map<String, String> getAddressMap() {
        return addressMap;
    }
    
    public void setAddressMap(Map<String, String> addressMap) {
        this.addressMap = addressMap;
    }
    
    @Override
    public String toString() {
        return "User [userId=" + userId + ", userName=" + userName + ", addressSet=" + addressSet + ", addressList="
                + addressList + ", addressMap=" + addressMap + "]";
    }
}

對于不同的集合類型的配置

set集合屬性的映射
                name 指定要映射的set集合的屬性
                table 集合屬性要映射到的表
                key  指定集合表(t_addressSet)的外鍵字段
                element 指定集合表的其他字段
                    type 元素類型，一定要指定
list集合映射
                list-index  指定的是排序列的名稱 (因為要保證list集合的有序)
                
map集合的映射
                key  指定外鍵字段
                map-key 指定map的key 
                element  指定map的value

User.hbm.xml配置文件配置

<?xml version="1.0" encoding="UTF-8"?>
<!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.mrq.entity">
    <class name="User" table="t_user">
        <id name="userId">
            <generator class="native"></generator>
        </id>
        
        <property name="userName" type="string"></property>
        
        <!-- 
            set集合屬性的映射
                name 指定要映射的set集合的屬性
                table 集合屬性要映射到的表
                key  指定集合表(t_address)的外鍵字段
                element 指定集合表的其他字段
                    type 元素類型，一定要指定
         -->
        
        <set name="addressSet" table="t_addressSet">
            <key column="uid"></key>
            <element column="address" type="string"></element>
        </set>
        
         <!-- 
            list集合映射
                list-index  指定的是排序列的名稱 (因為要保證list集合的有序)
          -->
        
        <list name="addressList" table="t_addressList">
            <key column="uid"></key>
            <list-index column="idx"></list-index>
            <element column="address" type="string"></element>
        </list>
        
         <!-- 
            map集合的映射
                key  指定外鍵字段
                map-key 指定map的key 
                element  指定map的value
           -->
        
        <map name="addressMap" table="t_addressMap">
            <key column="uid"></key>
            <map-key column="short_name" type="string"></map-key>
            <element column="address" type="string"></element>
        </map>
        
    </class>
</hibernate-mapping>

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>
        <!-- 數據庫配置 -->

        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql:///hibernate?useUnicode=true&characterEncoding=utf8</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">1l9o9v0e</property>
        <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>
        <property name="hibernate.show_sql">true</property>
        <property name="hibernate.hbm2ddl.auto">update</property><!-- 表創建的策略 -->

        <mapping resource="com/mrq/entity/User.hbm.xml" />

    </session-factory>

</hibernate-configuration>

測試類App.java :不同的集合類型映射保存方式

package com.mrq.main;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

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

import com.mrq.entity.User;

public class App {
    
    
    private SessionFactory sf = new Configuration().configure().buildSessionFactory();

    
    @Test
    public void testSetSave() throws Exception{
        Session session = sf.openSession();
        session.beginTransaction();
        
        Set<String> addressSet = new HashSet<>();
        addressSet.add("廣州");
        addressSet.add("北京");
        
        User user = new User();
        //user.setUserId(1);
        user.setUserName("姥姥");
        user.setAddressSet(addressSet);
        
        session.save(user);
        
        session.getTransaction().commit();
        session.close();
    }
    
    @Test
    public void testListSave() throws Exception{
        Session session = sf.openSession();
        session.beginTransaction();
        
        List<String> addressList = new ArrayList<>();
        addressList.add("太原");
        addressList.add("陜西");
        
        User user = new User();
        //user.setUserId(1);
        user.setUserName("姥爺");
        user.setAddressList(addressList);
        
        session.save(user);
        
        session.getTransaction().commit();
        session.close();
    }
    
    @Test
    public void testMapSave() throws Exception{
        Session session = sf.openSession();
        session.beginTransaction();
        
        Map<String, String> map = new HashMap<>();
        map.put("city", "南京");
        map.put("province", "江蘇");
        
        User user = new User();
        //user.setUserId(1);
        user.setUserName("小笑");
        user.setAddressMap(map);
        
        session.save(user);
        
        session.getTransaction().commit();
        session.close();
    }

}

上面的集合映射，映射的集合元素，都是普通的數據類型,下面是對象的集合映射

二. 對象集合的映射

2.1 一對多和多對一的例子:
部門與員工

• 一個部門有多個員工(一對多)
• 多個員工屬于一個部門 (多對一)

Javabean的設計

Dept.java

package com.mrq.entity;

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

public class Dept {
    private Integer deptId;
    private String deptName;
    private Set<Employee> emps =  new HashSet<>();//一對多:一個部門對應多個員工
    public Integer getDeptId() {
        return deptId;
    }
    public void setDeptId(Integer 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;
    }
    @Override
    public String toString() {
        return "Dept [deptId=" + deptId + ", deptName=" + deptName + ", emps=" + emps + "]";
    }
    
}

員工:Employee.java

package com.mrq.entity;

public class Employee {
    private Integer empId;
    private String empName;
    private Double salary;
    private Dept dept; //多對一:多個員工對應一個部門
    public Integer getEmpId() {
        return empId;
    }
    public void setEmpId(Integer 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;
    }
    @Override
    public String toString() {
        return "Employee [empId=" + empId + ", empName=" + empName + ", salary=" + salary + ", dept=" + dept + "]";
    }   
}

映射配置的關鍵點

一對多關聯映射配置  （通過部門管理到員工）
            Dept 映射關鍵點：
            1.  指定 映射的集合屬性： "emps"
            2.  集合屬性對應的集合表： "t_employee"
            3.  集合表的外鍵字段   "t_employee. dept_id"
            4.  集合元素的類型



多對一映射配置
            Employee 映射關鍵點：
            1.  映射的部門屬性  ：  dept
            2.  映射的部門屬性，對應的外鍵字段: dept_id
            3.  部門的類型

Dept.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!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.mrq.entity">
    <class name="Dept" table="t_dept">
        <id name="deptId">
            <generator class="native"></generator>
        </id>
        
        <property name="deptName" type="string"></property>
        
        <!-- 
            key:Employee對應的外鍵名稱
         -->
        <set name="emps"><!-- table="t_employee"可省略 -->
            <key column="dept_id"></key>
            <one-to-many class="Employee" />
        </set>
        
    </class>
</hibernate-mapping>

Employee.hbm.xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!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.mrq.entity">
    <class name="Dept" table="t_dept">
        <id name="deptId">
            <generator class="native"></generator>
        </id>
        
        <property name="deptName" type="string"></property>
        
        <!-- 
            key:Employee對應的外鍵名稱
         -->
        <set name="emps"><!-- table="t_employee"可省略 -->
            <key column="dept_id"></key>
            <one-to-many class="Employee" />
        </set>
        
    </class>
</hibernate-mapping>

測試保存方法:App02.java

package com.mrq.main;

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

import com.mrq.entity.Dept;
import com.mrq.entity.Employee;

public class App2 {
    
    private SessionFactory sf = new Configuration().configure().buildSessionFactory();

    @Test
    public void testSaveMany() {
        Session session = sf.openSession();
        session.beginTransaction();
        
        Dept dept = new Dept();
        dept.setDeptName("技術部");
        
        
        Employee emp1 = new Employee();
        emp1.setEmpName("張三");
        emp1.setSalary(223.0);
        
        Employee emp2 = new Employee();
        emp2.setEmpName("李四");
        emp2.setSalary(74.9);
        
        //關系
        emp1.setDept(dept);
        emp2.setDept(dept);
        
        
        //保存:先一的一方,再多的一方
        session.save(dept);
        session.save(emp1);
        session.save(emp2);
        session.getTransaction().commit();
        session.close();
        
    }
}

小結:

總結：
  在一對多與多對一的關聯關系中，保存數據最好的通過多的一方(Employee)來維護關系，這樣可以減少update語句的生成，從而提高hibernate的執行效率！
    
配置一對多與多對一，這種叫“雙向關聯”
只配置一對多，           叫“單項一對多”
只配置多對一，           叫“單項多對一”

注意：
    配置了哪一方，哪一方才有維護關聯關系的權限！

2.2 多對多關聯映射的配置

• 一個項目有多個開發者
• 一個開發者可能參與到多個項目中

Javabean的設計:

Developer.java

package com.mrq.entity;

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

public class Developer {
    
    private Integer developerId;
    private String developerName;
    //開發者參與多個項目
    private Set<Project> projects = new HashSet<>();
    
    public Integer getDeveloperId() {
        return developerId;
    }

    public void setDeveloperId(Integer developerId) {
        this.developerId = developerId;
    }

    public String getDeveloperName() {
        return developerName;
    }

    public void setDeveloperName(String developerName) {
        this.developerName = developerName;
    }

    public Set<Project> getProjects() {
        return projects;
    }

    public void setProjects(Set<Project> projects) {
        this.projects = projects;
    }

    @Override
    public String toString() {
        return "Developer [develpoerId=" + this.developerId + ", developerName=" + developerName + ", projects=" + projects
                + "]";
    }
}

Project.java

package com.mrq.entity;

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

public class Project {
    
    private Integer projectId;
    private String projectName;
    //一個項目有多個開發者
    private Set<Developer> developers = new HashSet<>();
    public Integer getProjectId() {
        return projectId;
    }
    public void setProjectId(Integer projectId) {
        this.projectId = projectId;
    }
    public String getProjectName() {
        return projectName;
    }
    public void setProjectName(String projectName) {
        this.projectName = projectName;
    }
    public Set<Developer> getDevelopers() {
        return developers;
    }
    public void setDevelopers(Set<Developer> developers) {
        this.developers = developers;
    }
    @Override
    public String toString() {
        return "Project [projectId=" + projectId + ", projectName=" + projectName + ", developers=" + developers + "]";
    }
}

關聯映射配置文件要點:

Project.hbm.xml
多對多映射:
            1.  映射的集合屬性： “developers”
            2.  集合屬性，對應的中間表： “t_relation”
            3. 外鍵字段:  project_id
            4. 外鍵字段，對應的中間表字段:  developer_id
            5.   集合屬性元素的類型

Developer.hbm.xml
    多對多映射配置： 員工方
                name  指定映射的集合屬性
                table 集合屬性對應的中間表
                key   指定中間表的外鍵字段(引用當前表t_developer主鍵的外鍵字段)
                many-to-many
                    column 指定外鍵字段對應的項目字段
                    class  集合元素的類型


            

Developer.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!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.mrq.entity">
    <class name="Developer" table="t_developer">
        <id name="developerId">
            <generator class="native"></generator>
        </id>
        
        <property name="developerName" type="string"></property>
        
        <!-- 
        多對多映射配置： 開發人員方
                name  指定映射的集合屬性
                table 集合屬性對應的中間表
                key   指定中間表的外鍵字段(引用當前表t_developer主鍵的外鍵字段)
                many-to-many
                    column 指定外鍵字段對應的項目字段
                    class  集合元素的類型
         -->
        
        <set name="projects" table="t_relation"><!-- table="t_employee"可省略 -->
            <key column="developer_id"></key>
            <many-to-many column="project_id" class="Project"></many-to-many>      
        </set>
        
    </class>
</hibernate-mapping>

Project.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!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.mrq.entity">
    <class name="Project" table="t_project">
        <id name="projectId">
            <generator class="native"></generator>
        </id>
        
        <property name="projectName" type="string"></property>
        
        <!-- 
            多對多映射:
            1.  映射的集合屬性： “developers”
            2.  集合屬性，對應的中間表： “t_relation”
            3. 外鍵字段:  project_id
            4. 外鍵字段，對應的中間表字段:  developer_id
            5.   集合屬性元素的類型
         -->
        
        <set name="developers" table="t_relation" cascade="save-update">
            <key column="project_id"></key>
            <many-to-many column="developer_id" class="Developer"></many-to-many>
        </set>
        
    </class>
</hibernate-mapping>

三. inverse/lazy/cascade 關鍵字

Inverse屬性，是在維護關聯關系的時候起作用的。
       表示控制權是否轉移。(在一的一方起作用)

Inverse , 控制反轉。
Inverse = false  不反轉；   當前方有控制權
        True  控制反轉； 當前方沒有控制權

維護關聯關系中，是否設置inverse屬性：
    1. 保存數據 
        有影響。
       如果設置控制反轉,即inverse=true, 然后通過部門方維護關聯關系。在保存部門的時候，同時保存員工， 數據會保存，但關聯關系不會維護。即外鍵字段為NULL
         
    2. 獲取數據
        無。
    3. 解除關聯關系？
        有影響。
        inverse=false，  可以解除關聯
inverse=true，  當前方(部門)沒有控制權，不能解除關聯關系
(不會生成update語句,也不會報錯)
    4. 刪除數據對關聯關系的影響？
        有影響。
        inverse=false, 有控制權， 可以刪除。先清空外鍵引用，再刪除數據。
        inverse=true,  沒有控制權: 如果刪除的記錄有被外鍵引用，會報錯，違反主外鍵引用約束！  如果刪除的記錄沒有被引用，可以直接刪除。
     
     
lazy:是否使用懶加載對象


cascade 屬性
cascade  表示級聯操作  【可以設置到一的一方或多的一方】
    none          不級聯操作， 默認值
    save-update     級聯保存或更新
    delete        級聯刪除
    save-update,delete    級聯保存、更新、刪除
    all                 同上。級聯保存、更新、刪除


思考:inverse與cascade區別？