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

LinkMan

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

Customer

　　第二步：让两个实体类之间互相表示

　　　　在客户实体类里面表示多个联系人（一个客户里面多个联系人）：

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

Customer

　　　　联系人实体类里面表示所属客户（一个联系人只能属于一个客户）：

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

LinkMan

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

　　　　在映射文件中配置一对多关系

　　　　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>

Customer.hbm.xml

　　　　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>

LinkMan.hbm.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>
 <!-- 此配置文件的文件名和位置是固定的的
     文件名：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>

hibernate.cfg.xml

　　创建工具类生成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;
     }

 }

HibernateUtils

在工具类中直接写一个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();
         }
     }
 }

HibernateOneToMany

简化做法：

首先在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执行过程

（一对多修改操作）

执行结果底层的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=?

底层SQL语句

性能优化，解决方法，在一对多中让一放弃外键维护，即让customer放弃外键维护

具体实现：

在需要放弃外键的对象的映射文件中的set标签中进行配置，添加inverse属性：默认值是false，修改为true，就是放弃外键维护

底层SQL的变化：