Hibernate中表與表之間的關聯一對多，級聯保存和級聯刪除

 

1：Hibernate的一對多操作（重點）

　　一對多映射配置

　　第一步：創建兩個實體類：客戶和聯系人（例）以客戶為一，聯系人為多：　　

package com.yinfu.entity;

public class LinkMan {

    private Integer lkm_id;
    private String lkm_name;
    private String lkm_gender;
    private String lkm_phone;
    public Integer getLkm_id() {
        return lkm_id;
    }
    public void setLkm_id(Integer lkm_id) {
        this.lkm_id = lkm_id;
    }
    public String getLkm_name() {
        return lkm_name;
    }
    public void setLkm_name(String lkm_name) {
        this.lkm_name = lkm_name;
    }
    public String getLkm_gender() {
        return lkm_gender;
    }
    public void setLkm_gender(String lkm_gender) {
        this.lkm_gender = lkm_gender;
    }
    public String getLkm_phone() {
        return lkm_phone;
    }
    public void setLkm_phone(String lkm_phone) {
        this.lkm_phone = lkm_phone;
    }
}

package com.yinfu.entity;

public class Customer {

    private Integer cid;
    private String custName;
    private String custLevel;
    private String custSource;
    private String custPhone;
    private String custMobile;
    public Integer getCid() {
        return cid;
    }
    public void setCid(Integer cid) {
        this.cid = cid;
    }
    public String getCustName() {
        return custName;
    }
    public void setCustName(String custName) {
        this.custName = custName;
    }
    public String getCustLevel() {
        return custLevel;
    }
    public void setCustLevel(String custLevel) {
        this.custLevel = custLevel;
    }
    public String getCustSource() {
        return custSource;
    }
    public void setCustSource(String custSource) {
        this.custSource = custSource;
    }
    public String getCustPhone() {
        return custPhone;
    }
    public void setCustPhone(String custPhone) {
        this.custPhone = custPhone;
    }
    public String getCustMobile() {
        return custMobile;
    }
    public void setCustMobile(String custMobile) {
        this.custMobile = custMobile;
    }
}

　　第二步：讓兩個實體類之間互相表示

　　　　在客戶實體類里面表示多個聯系人（一個客戶里面多個聯系人）：

package com.yinfu.entity;

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

public class Customer {

    private Integer cid;
    private String custName;
    private String custLevel;
    private String custSource;
    private String custPhone;
    private String custMobile;
    
    //客戶中表示多個聯系人，一個客戶有多個聯系人
    //Hibernate要求使用集合表示多的數據，有set表示（set無序，主要是set可有重復元素）
    private Set<LinkMan> setLinkMan = new HashSet<LinkMan>();
    
    public Set<LinkMan> getSetLinkMan() {
        return setLinkMan;
    }
    public void setSetLinkMan(Set<LinkMan> setLinkMan) {
        this.setLinkMan = setLinkMan;
    }
    public Integer getCid() {
        return cid;
    }
    public void setCid(Integer cid) {
        this.cid = cid;
    }
    public String getCustName() {
        return custName;
    }
    public void setCustName(String custName) {
        this.custName = custName;
    }
    public String getCustLevel() {
        return custLevel;
    }
    public void setCustLevel(String custLevel) {
        this.custLevel = custLevel;
    }
    public String getCustSource() {
        return custSource;
    }
    public void setCustSource(String custSource) {
        this.custSource = custSource;
    }
    public String getCustPhone() {
        return custPhone;
    }
    public void setCustPhone(String custPhone) {
        this.custPhone = custPhone;
    }
    public String getCustMobile() {
        return custMobile;
    }
    public void setCustMobile(String custMobile) {
        this.custMobile = custMobile;
    }
}

　　　　聯系人實體類里面表示所屬客戶（一個聯系人只能屬於一個客戶）：

package com.yinfu.entity;

public class LinkMan {

    private Integer lkm_id;
    private String lkm_name;
    private String lkm_gender;
    private String lkm_phone;
    
    //在聯系人中表示所屬客戶，一個聯系人對應一個客戶
    private Customer customer;
    
    public Customer getCustomer() {
        return customer;
    }
    public void setCustomer(Customer customer) {
        this.customer = customer;
    }
    public Integer getLkm_id() {
        return lkm_id;
    }
    public void setLkm_id(Integer lkm_id) {
        this.lkm_id = lkm_id;
    }
    public String getLkm_name() {
        return lkm_name;
    }
    public void setLkm_name(String lkm_name) {
        this.lkm_name = lkm_name;
    }
    public String getLkm_gender() {
        return lkm_gender;
    }
    public void setLkm_gender(String lkm_gender) {
        this.lkm_gender = lkm_gender;
    }
    public String getLkm_phone() {
        return lkm_phone;
    }
    public void setLkm_phone(String lkm_phone) {
        this.lkm_phone = lkm_phone;
    }
}

　　第三步：配置映射關系（映射文件）

　　　　在映射文件中配置一對多關系

　　　　Customer的配置文件：

<?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>

    <class name="com.yinfu.entity.Customer" table="t_customer">
        <id name="cid" column="cid">
            <generator class="native"></generator>
        </id>
        <property name="custName" column="custName"></property>
        <property name="custLevel" column="custLevel"></property>
        <property name="custSource" column="custSource"></property>
        <property name="custPhone" column="custPhone"></property>
        <property name="custMobile" column="custMobile"></property>
        <!-- 客戶配置文件中表示所有的聯系人
            set標簽表示所有聯系人
            set標簽中的name屬性：寫在客戶實體類里面表示所有聯系人的set集合名稱
         -->
         <set name="setLinkMan" cascade="save-update,delete" inverse="true">
             <!-- 一對多建表有外鍵
                 Hibernate機制：雙向維護外鍵，在一和多那方都配置外鍵
                 column屬性：外鍵值
              -->
             <key column="clid"></key>
             <!-- 客戶表表示的所有聯系人，class表示聯系人實體類的全類名 -->
             <one-to-many class="com.yinfu.entity.LinkMan"/>
         </set>
    </class>
    
</hibernate-mapping>

　　　　LinkMan的配置文件：

<?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>

    <class name="com.yinfu.entity.LinkMan" table="t_linkman">
        <id name="lkm_id" column="lkm_id">
            <generator class="native"></generator>
        </id>
        <property name="lkm_name" column="lkm_name"></property>
        <property name="lkm_gender" column="lkm_gender"></property>
        <property name="lkm_phone" column="lkm_phone"></property>
        <!-- 表示聯系人所屬的客戶
            name屬性：在聯系人實體類中用來表示客戶的字段名
            class屬性：客戶實體類的全類名
            column屬性：外鍵名，要與客戶映射文件中的外鍵名相同
         -->
        <many-to-one name="customer" class="com.yinfu.entity.Customer" column="clid"></many-to-one>
    </class>
    
</hibernate-mapping>

　　第四步：創建核心配置文件

<?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>
<!-- 此配置文件的文件名和位置是固定的的
    文件名：hibernate.cfg.xml
    位置：要寫在src文件中
 -->
    <session-factory>
        <!-- 第一部分：配置數據庫信息 -->
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/test</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">song12345</property>
        
        <!-- 第二部分：配置hibernate信息（可有可無） -->
        <!-- 輸出底層的SQL語句 -->
        <property name="hibernate.show_sql">true</property>
        <!-- 對底曾語句進行格式化 -->
        <property name="hibernate.format_sql">true</property>
        <!-- hibernate幫創建表，需要配置
            update：如果有表就更新，沒有表就創建
         -->
        <property name="hibernate.hbm2ddl.auto">update</property>
        <!-- 配置數據庫的方言 
            識別不同數據庫中的特有的語句和關鍵字
            比如：分頁查詢
                    MySQL關鍵字是limit
                    oracle中的使用的是top-n分析中的rownum
        -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <!-- 指定線程管理方式，與本地線程進行綁定，實現單線程操作 -->
        <property name="hibernate.current_session_context_class">thread</property>
    
        <!-- 第三部分：把映射文件放到核心配置文件中 -->
        <mapping resource="com/yinfu/entity/Customer.hbm.xml"/>
        <mapping resource="com/yinfu/entity/LinkMan.hbm.xml"/>
    </session-factory>
    
</hibernate-configuration>

　　創建工具類生成SessionFactory和session對象

package com.yinfu.utils;

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

//工具類
public class HibernateUtils {

    private final static Configuration cfg;
    private final static SessionFactory sessionFactory;
    
    //用靜態代碼塊來實現對象只在類加載的時候創建一次(靜態代碼塊只執行一次)
    static{
        //創建configuration對象，
        cfg = new Configuration();
        cfg.configure();
        //根據Configuration對象創建sessionFactory對象
        sessionFactory = cfg.buildSessionFactory();
    }
    
    //返回與本地線程綁定的session
    public static Session getSession(){
        return sessionFactory.getCurrentSession();
    }
    
    //創建一個方法用於返回sessionFactory對象
    public static SessionFactory getSessionFactory(){
        return sessionFactory;
    }
    
    
}

在工具類中直接寫一個main方法，內部不寫代碼，直接執行，生成兩個表，而外鍵是在一對多的多中的表上創建的

 （一：級聯保存）：

復雜的測試類：

package com.yinfu.test;

import java.util.List;

import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.junit.Test;

import com.yinfu.entity.Customer;
import com.yinfu.entity.LinkMan;
import com.yinfu.entity.User;
import com.yinfu.utils.HibernateUtils;

public class HibernateOneToMany {

    //一對多的級聯保存
    @Test
    public void testAddDemo(){
        SessionFactory sessionFactory = null;
        Session session = null;
        Transaction tx = null;
        try {
            sessionFactory = HibernateUtils.getSessionFactory();
            session = sessionFactory.openSession();
            tx = session.beginTransaction();
            
            //添加客戶，為這個客戶添加一個聯系人
            //1：創建客戶和聯系人對象
            Customer customer = new Customer();
            customer.setCustName("傳智播客");
            customer.setCustLevel("VIP");
            customer.setCustSource("網絡");
            customer.setCustMobile("110");
            customer.setCustPhone("911");
            
            LinkMan linkMan = new LinkMan();
            linkMan.setLkm_name("張三");
            linkMan.setLkm_gender("男");
            linkMan.setLkm_phone("123");;
            
            //2：客戶里面表示所有聯系人，聯系人里面表示客戶
            //建立客戶對象和聯系人對象關系
            //2.1：把聯系人對象放到客戶對象中的set集合里面
            customer.getSetLinkMan().add(linkMan);
            //2.2把客戶對象放到聯系人中的Customer屬性中
            linkMan.setCustomer(customer);
            
            //3:保存到數據庫
            session.save(customer);
            session.save(linkMan);
            
            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        }finally{
            session.close();
            sessionFactory.close();
        }
    }
}

簡化做法：

首先在Customer的配置文件Customer.hbm.xml文件中的set標簽上添加一個cascade屬性值為save-update：

然后在測試類中這樣修改一下就行：

（二：級聯刪除）

刪除客戶的同時將客戶對應的聯系人全部刪除

首先在Customer的配置文件Customer.hbm.xml文件中的set標簽上添加一個cascade屬性值為delete，如果cascade屬性有多個值，用英文逗號隔開；

測試代碼：根據ID查出customer在調用delete方法就行：

Hibernate: 
    select
        customer0_.cid as cid1_0_0_,
        customer0_.custName as custName2_0_0_,
        customer0_.custLevel as custLeve3_0_0_,
        customer0_.custSource as custSour4_0_0_,
        customer0_.custPhone as custPhon5_0_0_,
        customer0_.custMobile as custMobi6_0_0_ 
    from
        t_customer customer0_ 
    where
        customer0_.cid=?
Hibernate: 
    select
        setlinkman0_.clid as clid5_1_0_,
        setlinkman0_.lkm_id as lkm_id1_1_0_,
        setlinkman0_.lkm_id as lkm_id1_1_1_,
        setlinkman0_.lkm_name as lkm_name2_1_1_,
        setlinkman0_.lkm_gender as lkm_gend3_1_1_,
        setlinkman0_.lkm_phone as lkm_phon4_1_1_,
        setlinkman0_.clid as clid5_1_1_ 
    from
        t_linkman setlinkman0_ 
    where
        setlinkman0_.clid=?
Hibernate: 
    update
        t_linkman 
    set
        clid=null 
    where
        clid=?
Hibernate: 
    delete 
    from
        t_linkman 
    where
        lkm_id=?
Hibernate: 
    delete 
    from
        t_customer 
    where
        cid=?

 （一對多修改操作）

 執行結果底層的SQL語句：（這樣存在雙向維護外鍵，存在性能不足）

Hibernate: 
    select
        customer0_.cid as cid1_0_0_,
        customer0_.custName as custName2_0_0_,
        customer0_.custLevel as custLeve3_0_0_,
        customer0_.custSource as custSour4_0_0_,
        customer0_.custPhone as custPhon5_0_0_,
        customer0_.custMobile as custMobi6_0_0_ 
    from
        t_customer customer0_ 
    where
        customer0_.cid=?
Hibernate: 
    select
        linkman0_.lkm_id as lkm_id1_1_0_,
        linkman0_.lkm_name as lkm_name2_1_0_,
        linkman0_.lkm_gender as lkm_gend3_1_0_,
        linkman0_.lkm_phone as lkm_phon4_1_0_,
        linkman0_.clid as clid5_1_0_ 
    from
        t_linkman linkman0_ 
    where
        linkman0_.lkm_id=?
Hibernate: 
    select
        setlinkman0_.clid as clid5_1_0_,
        setlinkman0_.lkm_id as lkm_id1_1_0_,
        setlinkman0_.lkm_id as lkm_id1_1_1_,
        setlinkman0_.lkm_name as lkm_name2_1_1_,
        setlinkman0_.lkm_gender as lkm_gend3_1_1_,
        setlinkman0_.lkm_phone as lkm_phon4_1_1_,
        setlinkman0_.clid as clid5_1_1_ 
    from
        t_linkman setlinkman0_ 
    where
        setlinkman0_.clid=?
Hibernate: 
  下面進行了兩次修改，由於Hibernate是雙向維護外鍵，所以，客戶和聯系人中都要進行外鍵維護，存在性能不足
  update
        t_linkman 
    set
        lkm_name=?,
        lkm_gender=?,
        lkm_phone=?,
        clid=? 
    where
        lkm_id=?
Hibernate: 
    update
        t_linkman 
    set
        clid=? 
    where
        lkm_id=?

性能優化，解決方法，在一對多中讓一放棄外鍵維護，即讓customer放棄外鍵維護

具體實現：

在需要放棄外鍵的對象的映射文件中的set標簽中進行配置，添加inverse屬性：默認值是false，修改為true，就是放棄外鍵維護

底層SQL的變化：