【Java中级】9.0 SSH之Hibernate框架（六）——一对多关联映射的配置和级联操作...

最新推荐文章于 2020-09-04 15:51:33 发布

我睡醒刚刚

最新推荐文章于 2020-09-04 15:51:33 发布

阅读量204

点赞数

本文链接：https://blog.csdn.net/u013002228/article/details/104193004

版权

1.0 数据库表与表之间的关系

数据库表与表之间的关系

1.1 一对多关系

什么样关系属于一对多？

一个部门对应多个员工，一个员工只能属于某一个部门。
一个客户对应多个联系人，一个联系人只能属于某一个客户。

一对多的建表原则：

image.png

1.2 多对多关系

什么样关系属于多对多？

一个学生可以选择多门课程，一门课程也可以被多个学生选择。
一个用户可以选择多个角色，一个角色也可以被多个用户选择。

多对多的建表原则：

image.png

1.3 一对一关系（了解）

什么样关系属于一对一？

一个公司只能有一个注册地址，一个注册地址只能被一个公司注册。

一对一的建表原则：

image.png

2.0 Hibernate一对多的关系配置

2.1 创建一个java项目，引入相应jar包

image.png

2.2 创建数据库和表

创建一个新的数据库hibernate0204。

image.png

CREATE TABLE `cst_customer` (
  `cust_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)',
  `cust_name` varchar(32) NOT NULL COMMENT '客户名称(公司名称)',
  `cust_source` varchar(32) DEFAULT NULL COMMENT '客户信息来源',
  `cust_industry` varchar(32) DEFAULT NULL COMMENT '客户所属行业',
  `cust_level` varchar(32) DEFAULT NULL COMMENT '客户级别',
  `cust_phone` varchar(64) DEFAULT NULL COMMENT '固定电话',
  `cust_mobile` varchar(16) DEFAULT NULL COMMENT '移动电话',
  PRIMARY KEY (`cust_id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

CREATE TABLE `cst_linkman` (
  `lkm_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '联系人编号(主键)',
  `lkm_name` varchar(16) DEFAULT NULL COMMENT '联系人姓名',
  `lkm_cust_id` bigint(32) DEFAULT NULL COMMENT '客户id',
  `lkm_gender` char(1) DEFAULT NULL COMMENT '联系人性别',
  `lkm_phone` varchar(16) DEFAULT NULL COMMENT '联系人办公电话',
  `lkm_mobile` varchar(16) DEFAULT NULL COMMENT '联系人手机',
  `lkm_email` varchar(64) DEFAULT NULL COMMENT '联系人邮箱',
  `lkm_qq` varchar(16) DEFAULT NULL COMMENT '联系人qq',
  `lkm_position` varchar(16) DEFAULT NULL COMMENT '联系人职位',
  `lkm_memo` varchar(512) DEFAULT NULL COMMENT '联系人备注',
  PRIMARY KEY (`lkm_id`),
  KEY `FK_cst_linkman_lkm_cust_id` (`lkm_cust_id`),
  CONSTRAINT `FK_cst_linkman_lkm_cust_id` FOREIGN KEY (`lkm_cust_id`) REFERENCES `cst_customer` (`cust_id`) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

'客户id'就是外键。在Navicat Premium软件中创建新的查询，语句建表如下：

image.png

如下可知表成功建好，并通过E-R图表示关系如下：

image.png

2.3 创建实体

image.png

Customer.java

package com.edp.hibernate.domain;
/**
 * 
 * @Title: Customer.java
 * @Package com.edp.hibernate.domain
 * @author EdPeng
 * @version 创建时间 2020年2月4日上午1:03:39
 * @Description 客户的实体
 * @version V1.0
 */
public class Customer {

}

LinkMan.java

package com.edp.hibernate.domain;
/**
 * 
 * @Title: LinkMan.java
 * @Package com.edp.hibernate.domain
 * @author EdPeng
 * @version 创建时间 2020年2月4日上午1:04:07
 * @Description 联系人的实体
 * @version V1.0
 */
public class LinkMan {

}

完善实体代码：
Customer.java

package com.edp.hibernate.domain;

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

/**
 * 
 * @Title: Customer.java
 * @Package com.edp.hibernate.domain
 * @author EdPeng
 * @version 创建时间 2020年2月4日上午1:03:39
 * @Description 客户的实体
 * @version V1.0 
CREATE TABLE `cst_customer` (
  `cust_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)',
  `cust_name` varchar(32) NOT NULL COMMENT '客户名称(公司名称)',
  `cust_source` varchar(32) DEFAULT NULL COMMENT '客户信息来源',
  `cust_industry` varchar(32) DEFAULT NULL COMMENT '客户所属行业',
  `cust_level` varchar(32) DEFAULT NULL COMMENT '客户级别',
  `cust_phone` varchar(64) DEFAULT NULL COMMENT '固定电话',
  `cust_mobile` varchar(16) DEFAULT NULL COMMENT '移动电话',
  PRIMARY KEY (`cust_id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
 *
 */
public class Customer {
    private Long cust_id;// 客户id
    private String cust_name;// 客户的名称
    private String cust_source;// 客户的来源
    private String cust_industry;// 客户所属行业
    private String cust_level;// 客户的级别
    private String cust_phone;// 客户的固定电话
    private String cust_mobile;// 客户的移动电话
    // 通过ORM方式表示：一个客户对应多个联系人
    // 放置多的一方的集合。Hibernate默认使用的是Set集合
    // 因为Hibernate中需要对list的数据进行有序排列，就会在数据库中多建一列用来排序，表中就会多出来一列
    // 因此一般情况下使用Set集合
    // 这里采用双向关联，即客户查联系人能查，联系人查客户也能查
    private Set<LinkMan> linkMans = new HashSet<LinkMan>();

    public Set<LinkMan> getLinkMans() {
        return linkMans;
    }

    public void setLinkMans(Set<LinkMan> linkMans) {
        this.linkMans = linkMans;
    }

    public Long getCust_id() {
        return cust_id;
    }

    public void setCust_id(Long cust_id) {
        this.cust_id = cust_id;
    }

    public String getCust_name() {
        return cust_name;
    }

    public void setCust_name(String cust_name) {
        this.cust_name = cust_name;
    }

    public String getCust_source() {
        return cust_source;
    }

    public void setCust_source(String cust_source) {
        this.cust_source = cust_source;
    }

    public String getCust_industry() {
        return cust_industry;
    }

    public void setCust_industry(String cust_industry) {
        this.cust_industry = cust_industry;
    }

    public String getCust_level() {
        return cust_level;
    }

    public void setCust_level(String cust_level) {
        this.cust_level = cust_level;
    }

    public String getCust_phone() {
        return cust_phone;
    }

    public void setCust_phone(String cust_phone) {
        this.cust_phone = cust_phone;
    }

    public String getCust_mobile() {
        return cust_mobile;
    }

    public void setCust_mobile(String cust_mobile) {
        this.cust_mobile = cust_mobile;
    }

    @Override
    public String toString() {
        return "Customer [cust_id=" + cust_id + ", cust_name=" + cust_name + ", cust_source=" + cust_source
                + ", cust_industry=" + cust_industry + ", cust_level=" + cust_level + ", cust_phone=" + cust_phone
                + ", cust_mobile=" + cust_mobile + ", linkMans=" + linkMans + "]";
    }

}

LinkMan.java

package com.edp.hibernate.domain;

/**
 * 
 * @Title: LinkMan.java
 * @Package com.edp.hibernate.domain
 * @author EdPeng
 * @version 创建时间 2020年2月4日上午1:04:07
 * @Description 联系人的实体
 * @version V1.0
 * CREATE TABLE `cst_linkman` (
  `lkm_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '联系人编号(主键)',
  `lkm_name` varchar(16) DEFAULT NULL COMMENT '联系人姓名',
  `lkm_cust_id` bigint(32) DEFAULT NULL COMMENT '客户id',
  `lkm_gender` char(1) DEFAULT NULL COMMENT '联系人性别',
  `lkm_phone` varchar(16) DEFAULT NULL COMMENT '联系人办公电话',
  `lkm_mobile` varchar(16) DEFAULT NULL COMMENT '联系人手机',
  `lkm_email` varchar(64) DEFAULT NULL COMMENT '联系人邮箱',
  `lkm_qq` varchar(16) DEFAULT NULL COMMENT '联系人qq',
  `lkm_position` varchar(16) DEFAULT NULL COMMENT '联系人职位',
  `lkm_memo` varchar(512) DEFAULT NULL COMMENT '联系人备注',
  PRIMARY KEY (`lkm_id`),
  KEY `FK_cst_linkman_lkm_cust_id` (`lkm_cust_id`),
  CONSTRAINT `FK_cst_linkman_lkm_cust_id` FOREIGN KEY (`lkm_cust_id`) REFERENCES `cst_customer` (`cust_id`) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

 */

public class LinkMan {
    private Long lkm_id;
    private String lkm_name;
//  private String lkm_cust_id;不要写此外键的名称
    private String lkm_gender ;
    private String lkm_phone;
    private String lkm_mobile;
    private String lkm_email;
    private String lkm_qq;
    private String lkm_position;
    private String lkm_memo;
    
    //通过ORM方式表示：一个联系人只能属于某一个客户
    private Customer customer;
    //见到外键不要写相应外键的名称，把外键改成一的一方的对象
    //并写相应对象的get和set方法
    public Customer getCustomer() {
        return customer;
    }
    public void setCustomer(Customer customer) {
        this.customer = customer;
    }
    public Long getLkm_id() {
        return lkm_id;
    }
    public void setLkm_id(Long 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;
    }
    public String getLkm_mobile() {
        return lkm_mobile;
    }
    public void setLkm_mobile(String lkm_mobile) {
        this.lkm_mobile = lkm_mobile;
    }
    public String getLkm_email() {
        return lkm_email;
    }
    public void setLkm_email(String lkm_email) {
        this.lkm_email = lkm_email;
    }
    public String getLkm_qq() {
        return lkm_qq;
    }
    public void setLkm_qq(String lkm_qq) {
        this.lkm_qq = lkm_qq;
    }
    public String getLkm_position() {
        return lkm_position;
    }
    public void setLkm_position(String lkm_position) {
        this.lkm_position = lkm_position;
    }
    public String getLkm_memo() {
        return lkm_memo;
    }
    public void setLkm_memo(String lkm_memo) {
        this.lkm_memo = lkm_memo;
    }
    
    @Override
    public String toString() {
        return "LinkMan [lkm_id=" + lkm_id + ", lkm_name=" + lkm_name + ", lkm_gender=" + lkm_gender + ", lkm_phone="
                + lkm_phone + ", lkm_mobile=" + lkm_mobile + ", lkm_email=" + lkm_email + ", lkm_qq=" + lkm_qq
                + ", lkm_position=" + lkm_position + ", lkm_memo=" + lkm_memo + ", customer=" + customer + "]";
    }
}

这里注意java是面向对象编程，所以不要写外键的get和set方法，而是一的一方的相应对象的get和set方法。

2.4 创建映射文件

image.png

Customer.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>
    <!-- hibernate-mapping是根标签 -->
    <!-- 建立类与表的映射 -->
    <class name="com.edp.hibernate.domain.Customer"
        table="cst_customer" catalog="hibernate0204">
        <!-- name：哪个类,全路径，table：哪个表 catalog 哪个数据库 -->

        <!-- Id：建立类中的属性与表中的主键对应 -->
        <id name="cust_id" column="cust_id">
            <!-- name:在类中的名字 column:表中的字段;此处为一样的名称 -->
            <generator class="native" />
            <!-- 组件都有一种生成策略,此处使用一种本地策略。 -->
        </id>
        <!-- 建立类中的普通属性和表的字段的对应 -->
        <!-- 除了主键以外的属性，都用property -->
        <property name="cust_name" column="cust_name" />
        <property name="cust_source" column="cust_source" />
        <property name="cust_industry" column="cust_industry"/>
        <property name="cust_level" column="cust_level" />
        <property name="cust_phone" column="cust_phone" />
        <property name="cust_mobile" column="cust_mobile" />
    </class>

</hibernate-mapping>

LinkMan.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>
    <!-- hibernate-mapping是根标签 -->
    <!-- 建立类与表的映射 -->
    <class name="com.edp.hibernate.domain.LinkMan"
        table="cst_linkman" catalog="hibernate0204">
        <!-- name：哪个类,全路径，table：哪个表 catalog 哪个数据库 -->

        <!-- Id：建立类中的属性与表中的主键对应 -->
        <id name="lkm_id" column="lkm_id">
            <!-- name:在类中的名字 column:表中的字段;此处为一样的名称 -->
            <generator class="native" />
            <!-- 组件都有一种生成策略,此处使用一种本地策略。 -->
        </id>
        <!-- 建立类中的普通属性和表的字段的对应 -->
        <!-- 除了主键以外的属性，都用property -->
        <property name="lkm_name" column="lkm_name" />
        <property name="lkm_gender " column="lkm_gender" />
        <property name="lkm_phone" column="lkm_phone"/>
        <property name="lkm_mobile" column="lkm_mobile" />
        <property name="lkm_email" column="lkm_email" />
        <property name="lkm_qq" column="lkm_qq" />
        <property name="lkm_position" column="lkm_position" />
        <property name="lkm_memo" column="lkm_memo" />
    </class>
</hibernate-mapping>

基本配置完毕，下面配置相互之间的关系：
在LinkMan.hbm.xml中配置外键的绑定：

<hibernate-mapping>
    <!-- hibernate-mapping是根标签 -->
    <!-- 建立类与表的映射 -->
    <class name="com.edp.hibernate.domain.Customer"
        table="cst_customer" catalog="hibernate0204">
            …………
        <!-- 配置多对一的关系：放置的是一的一方的对象 -->
        <!-- 联系人是多，客户是一 -->
        <!-- 
              many-to-one标签
              name：一的一方的对象的属性名称
              class：一的一方的类的全路径。
              column：在多的一方的表的外键的名称
         -->
        <many-to-one name="customer" class="com.edp.hibernate.domain.Customer" column="lkm_cust_id"/>
    </class>
</hibernate-mapping>

其中class的取值可以如下操作不会出错：

image.png

在Customer.hbm.xml中配置联系人的绑定：

<hibernate-mapping>
    <!-- hibernate-mapping是根标签 -->
    <!-- 建立类与表的映射 -->
    <class name="com.edp.hibernate.domain.Customer"
        table="cst_customer" catalog="hibernate0204">
            …………
<!-- 配置一对多的关系：放置的是多的一方的集合 -->
        <!-- 联系人是多，客户是一 -->
        <!-- set标签
            name：对的一方的对象集合的属性名称
         -->
        <set name="linkMans">
        <!-- key标签
            column：多的一方的外键的名称
         -->
            <key column="lkm_cust_id"></key>
            <!-- one-to-many标签
                class：多的一方的类的全路径
             -->
            <one-to-many class="com.edp.hibernate.domain.LinkMan" />
        </set>
    </class>
</hibernate-mapping>

2.5 创建核心配置文件和Log4j配置文件

image.png

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> -->
        <!-- MySQL8.0以后，用的连接驱动改变了，driver必须加上.cj -->
        <property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>

        <!--MySQL8.0以后， url为jdbc:mysql://localhost:3306/test后面加?useSSL=false&serverTimezone=UTC -->
        <property name="hibernate.connection.url">jdbc:mysql:///hibernate0204?useSSL=false&amp;serverTimezone=UTC</property>
        <!-- &符号在Hibernate不可用，需写成&amp;使用MySQL8Dialect -->
        <!-- jdbc:mysql://localhost:3306/hibernate_learn连接本地库可以省略,所以这里用/// -->
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">bywwcnll</property>

        <!-- 配置hibernate的方言 告诉hibernate要识别MySQL的“方言”（这样，hibernate就能帮开发者生成MySQL识别的SQL语句） -->
        <!-- name="hibernate.dialect":表示Hibernate的方言就是MySQL -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQL8Dialect</property>
        <!--<property name="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property> -->
        <!--<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property> -->



        <!-- 可选配置 -->
        <!-- 打印SQL语句 -->
        <property name="hibernate.show_sql">true</property>
        <!-- 格式化SQL，使SQL语句在打印的时候更加漂亮 -->
        <property name="hibernate.format_sql">true</property>
        <!-- 自动创建表 -->
        <!--<property name="hibernate.hbm2ddl.auto">update</property> -->

        <!-- 配置C3P0连接池 -->
        <property name="hibernate.connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>
        <!--在连接池中可用的数据库连接的最少数目 -->
        <property name="hibernate.c3p0.min_size">5</property>
        <!--在连接池中所有数据库连接的最大数目 -->
        <property name="hibernate.c3p0.max_size">20</property>
        <!--设定数据库连接的过期时间,以秒为单位, 如果连接池中的某个数据库连接处于空闲状态的时间超过了timeout时间,就会从连接池中清除 -->
        <property name="hibernate.c3p0.timeout">120</property>
        <!-- 当连接池里面的连接用完的时候，C3P0一下获取的新的连接数 -->
        <property name="hibernate.c3p0.acquire_increment">2</property>
        <!-- 每次都验证连接是否可用 -->
        <property name="hibernate.c3p0.validate">true</property>
        <!--每3000秒检查所有连接池中的空闲连接 以秒为单位 -->
        <property name="c3p0.idle_test_period">3000</property>

        <!-- 事务隔离级别 hibernate.connection.isolation 1->Read uncommitted isolation 
            2->read committed isolation 4->Repeatable read isolation（MySQL默认级别） 8->Serializable 
            isolation -->
        <property name="hibernate.connection.isolation">4</property>
        <!-- 配置当前线程绑定的Session -->
        <!-- 用于指定Session的管理方式 thread：Session对象的生命周期与本地线程绑定 jta：Session对象的生命周期与JTA事务（跨数据库的事务）绑定 
            managed：Hibernate委托程序来管理Session对象的生命周期 -->
        <property name="hibernate.current_session_context_class">thread</property>
        <!-- 告诉核心配置文件，我要加载哪个映射，引入2个 -->
        <mapping resource="com/edp/hibernate/domain/Customer.hbm.xml" />
        <mapping resource="com/edp/hibernate/domain/LinkMan.hbm.xml" />
    </session-factory>
</hibernate-configuration>

log4j2.xml

<?xml version="1.0" encoding="UTF-8"?>


<!--日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL -->
<!--Configuration后面的status，这个用于设置log4j2自身内部的信息输出，可以不设置，当设置成trace时，你会看到log4j2内部各种详细输出 -->
<!--monitorInterval：Log4j能够自动检测修改配置 文件和重新配置本身，设置间隔秒数 -->
<configuration status="OFF" monitorInterval="30">
    <!--先定义所有的appender -->
    <appenders>
        <!--这个输出控制台的配置 -->
        <console name="Console" target="SYSTEM_OUT">
            <!--输出日志的格式 -->
            <PatternLayout
                pattern="[%d{HH:mm:ss:SSS}] [%p] - %l - %m%n" />
        </console>
        <!--文件会打印出所有信息，这个log每次运行程序会自动清空，由append属性决定，这个也挺有用的，适合临时测试用 -->
        <File name="log" fileName="resource/RollingFileAppender.log" append="false">
            <PatternLayout
                pattern="%d{HH:mm:ss.SSS} %-5level %class{36} %L %M - %msg%xEx%n" />
        </File>
        <!-- 这个会打印出所有的info及以下级别的信息，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档 -->
        <!-- <RollingFile name="RollingFileInfo" fileName="${sys:user.home}/logs/info.log" 
            filePattern="${sys:user.home}/logs/$${date:yyyy-MM}/info-%d{yyyy-MM-dd}-%i.log"> -->
        <!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch） -->
        <!--<ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY" /> -->
        <!--<PatternLayout pattern="[%d{HH:mm:ss:SSS}] [%p] - %l - %m%n" /> -->
        <!--<Policies> <TimeBasedTriggeringPolicy /> <SizeBasedTriggeringPolicy 
            size="100 MB" /> -->
        <!--</Policies> -->
        <!--</RollingFile> -->
        <!--<RollingFile name="RollingFileWarn" fileName="${sys:user.home}/logs/warn.log" 
            filePattern="${sys:user.home}/logs/$${date:yyyy-MM}/warn-%d{yyyy-MM-dd}-%i.log"> -->
        <!--<ThresholdFilter level="warn" onMatch="ACCEPT" onMismatch="DENY" /> -->
        <!--<PatternLayout pattern="[%d{HH:mm:ss:SSS}] [%p] - %l - %m%n" /> -->
        <!--<Policies> <TimeBasedTriggeringPolicy /> <SizeBasedTriggeringPolicy 
            size="100 MB" /> -->
        <!--</Policies> --><!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件，这里设置了20 -->
        <!--<DefaultRolloverStrategy max="20" /> -->
        <!--</RollingFile> -->
        <!--<RollingFile name="RollingFileError" fileName="${sys:user.home}/logs/error.log" 
            filePattern="${sys:user.home}/logs/$${date:yyyy-MM}/error-%d{yyyy-MM-dd}-%i.log"> -->
        <!--<ThresholdFilter level="error" onMatch="ACCEPT" onMismatch="DENY" /> -->
        <!--<PatternLayout pattern="[%d{HH:mm:ss:SSS}] [%p] - %l - %m%n" /> -->
        <!--<Policies> <TimeBasedTriggeringPolicy /> -->
        <!--<SizeBasedTriggeringPolicy size="100 MB" /> -->
        <!--</Policies> -->
        <!--</RollingFile> -->
    </appenders>
    <!--然后定义logger，只有定义了logger并引入的appender，appender才会生效 -->
    <loggers>
        <!--过滤掉spring和mybatis的一些无用的DEBUG信息 -->
        <logger name="org.springframework" level="INFO"></logger>
        <logger name="org.mybatis" level="INFO"></logger>
        <root level="info">
            <appender-ref ref="Console" />
            <appender-ref ref="RollingFileInfo" />
            <appender-ref ref="RollingFileWarn" />
            <appender-ref ref="RollingFileError" />
        </root>
    </loggers>
</configuration>

2.6 引入工具类

image.png

HibernateUtils.java

package com.edp.hibernate.utils;

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

public class HibernateUtils {
    public static final Configuration cfg;
    public static final SessionFactory sf;

    static {
        cfg = new Configuration().configure();
        sf = cfg.buildSessionFactory();
    }

    public static Session openSession() {
        return sf.openSession();
    }

    public static Session getCurrentSession() {
        return sf.getCurrentSession();
    }
}

2.7 编写测试类

image.png

HibernateDemo1.java

package com.edp.hibernate.demo1;

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

import com.edp.hibernate.domain.Customer;
import com.edp.hibernate.domain.LinkMan;
import com.edp.hibernate.utils.HibernateUtils;

/**
 * 
 * @Title: HibernateDemo1.java
 * @Package com.edp.hibernate.demo1
 * @author EdPeng
 * @version 创建时间 2020年2月4日上午2:12:53
 * @Description 一对多的测试类
 * @version V1.0
 */
public class HibernateDemo1 {
    @Test
    // 保存2个客户和3个联系人，并建立好关系
    public void demo1() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction txTransaction = session.beginTransaction();
        
        // 创建2个客户
        Customer customer1 = new Customer();
        customer1.setCust_name("王二小");
        Customer customer2 = new Customer();
        customer2.setCust_name("孙悟空");

        // 创建3个联系人
        LinkMan linkMan1 = new LinkMan();
        linkMan1.setLkm_name("青牛精");
        LinkMan linkMan2 = new LinkMan();
        linkMan2.setLkm_name("鸡毛精");
        LinkMan linkMan3 = new LinkMan();
        linkMan3.setLkm_name("包谷怪");

        // 需要设置关系：
        linkMan1.setCustomer(customer1);
        linkMan2.setCustomer(customer1);
        linkMan3.setCustomer(customer2);
        customer1.getLinkMans().add(linkMan1);
        customer1.getLinkMans().add(linkMan2);
        customer2.getLinkMans().add(linkMan3);

        // 保存数据
        session.save(linkMan1);
        session.save(linkMan2);
        session.save(linkMan3);
        session.save(customer1);
        session.save(customer2);

        txTransaction.commit();
    }
}

日志打印执行语句：

image.png

数据库成功存储并关联：

image.png

3.0 一对多的级联保存和更新

3.1 一对多关系只保存一边是否可以

image.png

报错，不行。只保存联系人linkman也是不行的。

image.png

3.2 一对多的级联操作

什么叫做级联

级联指的是，操作一个对象的时候，是否会同时操作其关联的对象。

级联是有方向性

操作一的一方的时候，是否操作到多的一方
操作多的一方的时候，是否操作到一的一方

因为一对多关系只保存一边不可以操作，就需要我们设置好级联操作，当我们操作某一方的数据时，另一方能很智能的随之更新。

3.3 保存客户,级联联系人

在HibernateDemo1.java中新建方法：

    @Test
    /**
     * 
     * @Title: demo3
     * @Description: 级联保存或更新——保存客户级联联系人
     * 操作的主体对象是客户对象
     * <set name="linkMans" cascade="save-update">
     * @param
     * @return void
     * @throws
     *
     */
    public void demo3() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction txTransaction = session.beginTransaction();

        Customer customer1 = new Customer();
        customer1.setCust_name("冬瓜");

        LinkMan linkMan1 = new LinkMan();
        linkMan1.setLkm_name("铁勺");

        linkMan1.setCustomer(customer1);
        customer1.getLinkMans().add(linkMan1);

        session.save(customer1);

        txTransaction.commit();
    }

修改Customer.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>
    <!-- hibernate-mapping是根标签 -->
    <!-- 建立类与表的映射 -->
    <class name="com.edp.hibernate.domain.Customer" table="cst_customer" catalog="hibernate0204">

         …………

        <!-- 配置一对多的关系：放置的是多的一方的集合 -->
        <!-- 联系人是多，客户是一 -->
        <!-- set标签
            name：对的一方的对象集合的属性名称
        -->
        <set name="linkMans" cascade="save-update">
            <!-- key标签
                column：多的一方的外键的名称
            -->
            <key column="lkm_cust_id"></key>
            <!-- one-to-many标签
                class：多的一方的类的全路径
            -->
            <one-to-many class="com.edp.hibernate.domain.LinkMan" />
        </set>
    </class>

</hibernate-mapping>

执行：

image.png

3.4 保存联系人，级联客户

在HibernateDemo1.java中新建方法：

    @Test
    /**
     * 
     * @Title: demo4
     * @Description: 级联保存或更新——保存联系人级联客户
     * 操作的主体对象是联系人对象，设置cascade="save-update"
     * <many-to-one name="customer" cascade="save-update"
     * class="com.edp.hibernate.domain.Customer" column="lkm_cust_id" />
     * 
     * @param
     * @return void
     * @throws
     *
     */
    public void demo4() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction txTransaction = session.beginTransaction();

        Customer customer1 = new Customer();
        customer1.setCust_name("菊花");

        LinkMan linkMan1 = new LinkMan();
        linkMan1.setLkm_name("陶盆");

        linkMan1.setCustomer(customer1);
        customer1.getLinkMans().add(linkMan1);

        session.save(linkMan1);

        txTransaction.commit();
    }

修改LinkMan.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>
    <!-- hibernate-mapping是根标签 -->
    <!-- 建立类与表的映射 -->
    <class name="com.edp.hibernate.domain.LinkMan" table="cst_linkman" catalog="hibernate0204">

         …………
    
        <!-- 配置多对一的关系：放置的是一的一方的对象 -->
        <!-- 联系人是多，客户是一 -->
        <!--
            many-to-one标签
            name：一的一方的对象的属性名称
            class：一的一方的类的全路径。
            column：在多的一方的表的外键的名称
        -->
        <many-to-one name="customer" cascade="save-update" class="com.edp.hibernate.domain.Customer"
            column="lkm_cust_id" />
    </class>
</hibernate-mapping>

执行：

image.png

3.4 测试对象的导航

对象的导航：以上操作的都是双向关联，即客户关联了联系人，联系人也关联了客户，这就叫做对象的导航。
测试前提：一对多的双方，都设置了cascade="save-update"

1. 测试一

在HibernateDemo1.java中新建方法：

    @Test
    /**
     * 
     * @Title: demo5
     * @Description: 测试对象的导航
     * 前提：一对多的双方，都设置了cascade="save-update"
     * @param
     * @return void
     * @throws
     *
     */
    public void demo5() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction txTransaction = session.beginTransaction();
        
        //1个客户
        Customer customer1 = new Customer();
        customer1.setCust_name("浙江省委");
        
        // 创建3个联系人
        LinkMan linkMan1 = new LinkMan();
        linkMan1.setLkm_name("宁波市委");
        LinkMan linkMan2 = new LinkMan();
        linkMan2.setLkm_name("台州市委");
        LinkMan linkMan3 = new LinkMan();
        linkMan3.setLkm_name("绍兴市委");
        
        linkMan1.setCustomer(customer1);
        customer1.getLinkMans().add(linkMan2);
        customer1.getLinkMans().add(linkMan3);
        
        //双方都设置了cascade
        session.save(linkMan1);//发送几条insert语句 ——4条
        
        txTransaction.commit();
    }

执行：

image.png

以上案例， 发送几条insert语句？
linkMan1保存，发送一条；关联到customer1，customer1保存，又发送一条；customer1级联linkMan2、linkMan3，再发送2条，如上图可见，的的确确发送了4条insert语句。

2. 测试二

修改demo5()方法：

    @Test
    /**
     * 
     * @Title: demo5
     * @Description: 测试对象的导航
     * 前提：一对多的双方，都设置了cascade="save-update"
     * @param
     * @return void
     * @throws
     *
     */
    public void demo5() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction txTransaction = session.beginTransaction();
        
        //1个客户
        Customer customer1 = new Customer();
        customer1.setCust_name("宫崎骏");
        
        // 创建3个联系人
        LinkMan linkMan1 = new LinkMan();
        linkMan1.setLkm_name("波妞她妈");
        LinkMan linkMan2 = new LinkMan();
        linkMan2.setLkm_name("宗介");
        LinkMan linkMan3 = new LinkMan();
        linkMan3.setLkm_name("波妞");
        
        linkMan1.setCustomer(customer1);
        customer1.getLinkMans().add(linkMan2);
        customer1.getLinkMans().add(linkMan3);
        
        //双方都设置了cascade
//      session.save(linkMan1);//发送几条insert语句 —— 4条
        session.save(customer1);//发送几条insert语句 —— 3条
        
        txTransaction.commit();

执行：

image.png

可以发现，发送 3条条insert语句，而且linkMan1没有存进去。

先执行session.save(customer1); ,customer1存入。
customer1存入,其关联的联系人linkMan2、linkMan3也会存进去，但是和linkMan1没关系，存不进去。

3. 测试三

修改demo5()方法：

    @Test
    /**
     * 
     * @Title: demo5
     * @Description: 测试对象的导航
     * 前提：一对多的双方，都设置了cascade="save-update"
     * @param
     * @return void
     * @throws
     *
     */
    public void demo5() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction txTransaction = session.beginTransaction();

        // 1个客户
        Customer customer1 = new Customer();
        customer1.setCust_name("五行学说");

        // 创建3个联系人
        LinkMan linkMan1 = new LinkMan();
        linkMan1.setLkm_name("金行");
        LinkMan linkMan2 = new LinkMan();
        linkMan2.setLkm_name("木行");
        LinkMan linkMan3 = new LinkMan();
        linkMan3.setLkm_name("水行");

        linkMan1.setCustomer(customer1);
        customer1.getLinkMans().add(linkMan2);
        customer1.getLinkMans().add(linkMan3);

        session.save(linkMan2);// 发送几条insert语句 —— 1条
        txTransaction.commit();
    }

执行：

image.png

发送1条insert语句 —— linkMan2没有关联客户，客户存不进去。

4.0 级联删除

级联删除：

删除一边的时候，同时将另一方的数据也一并删除。
删除客户级联删除联系人

4.1 默认情况

在HibernateDemo1.java中新建方法：

    @Test
    /**
     * 
     * @Title: demo6
     * @Description: 测试 级联删除
     * 删除客户，级联删除联系人
     * @param 
     * @return void
     * @throws
     *
     */
    public void demo6() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction txTransaction = session.beginTransaction();
        
        //没有设置级联删除，默认情况
        Customer customer = session.get(Customer.class, 1l);
        session.delete(customer);
        
        txTransaction.commit();
    }

准备删除数据库的第一个客户“王二小”：

image.png

可见，他被 “青牛精”和 “鸡毛精”给关联着。
执行语句：

image.png

可见，Hibernate默认情况下，是先把联系人关联设置为 null，修改外键，解绑后再删除客户，非常智能。

再次查阅数据库：

image.png

4.2 级联删除

1. 删除客户，级联删除联系人

修改demo6()方法：

    @Test
    /**
     * 
     * @Title: demo6
     * @Description: 测试 级联删除
     * 删除客户，级联删除联系人：删除的主体是客户，需要在Customer.hbm.xml中配置
     * <set name="linkMans" cascade="delete">
     * @param
     * @return void
     * @throws
     *
     */
    public void demo6() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction txTransaction = session.beginTransaction();

        // 没有设置级联删除，默认情况,修改联系人的外键，删除客户
// Customer customer = session.get(Customer.class, 1l);
// session.delete(customer);

        // 删除客户，同时删除联系人 ——→ 级联删除
        Customer customer = session.get(Customer.class, 2l);
        session.delete(customer);

        txTransaction.commit();
    }

配置Customer.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>
    <!-- hibernate-mapping是根标签 -->
    <!-- 建立类与表的映射 -->
    <class name="com.edp.hibernate.domain.Customer" table="cst_customer" catalog="hibernate0204">
    
          …………

        <!-- 配置一对多的关系：放置的是多的一方的集合 -->
        <!-- 联系人是多，客户是一 -->
        <!-- set标签
            name：对的一方的对象集合的属性名称
            cascade:级联，用逗号隔开，就同时拥有保存或更新、删除功能
        -->
        <set name="linkMans" cascade="save-update,delete">
            <!-- key标签
                column：多的一方的外键的名称
            -->
            <key column="lkm_cust_id"></key>
            <!-- one-to-many标签
                class：多的一方的类的全路径
            -->
            <one-to-many class="com.edp.hibernate.domain.LinkMan" />
        </set>
    </class>

</hibernate-mapping>

执行：

image.png

数据库变化：

image.png

1. 删除联系人，级联删除客户

这种情况基本不用，现实中往往不存在这样的数据处理逻辑。
但是Hibernate提供了这样的功能。

修改demo6()方法：

    @Test
    /**
     * 
     * @Title: demo6
     * @Description: 测试 级联删除
     * 删除客户，级联删除联系人：删除的主体是客户，需要在Customer.hbm.xml中配置
     * <set name="linkMans" cascade="delete">
     * 删除联系人，级联删除客户：删除的主体是联系人，需要在LinkMan.hbm.xml中配置
     * <many-to-one name="customer" cascade="delete"
     * class="com.edp.hibernate.domain.Customer" column="lkm_cust_id" />
     * @param
     * @return void
     * @throws
     *
     */
    public void demo6() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction txTransaction = session.beginTransaction();

        // 没有设置级联删除，默认情况,修改联系人的外键，删除客户
// Customer customer = session.get(Customer.class, 1l);
// session.delete(customer);

        // 删除客户，同时删除联系人 ——→ 级联删除
// Customer customer = session.get(Customer.class, 2l);
// session.delete(customer);

        // 删除联系人，同时删除客户 ——→ 级联删除（但不常用）
        LinkMan linkMan = session.get(LinkMan.class, 4l);
        session.delete(linkMan);

        txTransaction.commit();
    }

修改LinkMan.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>
    <!-- hibernate-mapping是根标签 -->
    <!-- 建立类与表的映射 -->
    <class name="com.edp.hibernate.domain.LinkMan" table="cst_linkman" catalog="hibernate0204">
        
          …………

        <!-- 配置多对一的关系：放置的是一的一方的对象 -->
        <!-- 联系人是多，客户是一 -->
        <!--
            many-to-one标签
            name：一的一方的对象的属性名称
            class：一的一方的类的全路径。
            column：在多的一方的表的外键的名称
        -->
        <many-to-one name="customer" cascade="save-update,delete" class="com.edp.hibernate.domain.Customer"
            column="lkm_cust_id" />
    </class>
</hibernate-mapping>

执行：

image.png

数据库变化：

image.png

5.0 一对多设置了双向关联产生多余的SQL语句——inverse的配置

5.1 基本案例

例如如下数据库，若将联系人“绍兴市委”，换到归属于客户“冬瓜”：

image.png

在HibernateDemo1.java中新建方法：

    @Test
    /**
     * 
     * @Title: demo7
     * @Description: 将6号联系人原来归为5号客户，改为3号客户
     * @param 
     * @return void
     * @throws
     *
     */
    public void demo7() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction txTransaction = session.beginTransaction();
        
        //查询6号联系人
        LinkMan linkMan = session.get(LinkMan.class, 6l);
        //查询3号客户
        Customer customer = session.get(Customer.class, 3l);
        linkMan.setCustomer(customer);
        
        //双向的关联 
        linkMan.setCustomer(customer);
        customer.getLinkMans().add(linkMan);
        //不需要用update方法，持久态对象自动更新数据库
        txTransaction.commit();
    }

执行：

image.png

数据库：

image.png

5.2 解决多余的SQL语句

为什么要解决：对服务器资源来说，是资源浪费的。

单向维护（只设置客户关联联系人，或者只设置联系人关联客户）

但是在复杂情况下，如此处理容易出现问题。

使一方放弃外键维护权
使一的一方放弃。
在set上配置inverse=”true”

修改Customer.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>
    <!-- hibernate-mapping是根标签 -->
    <!-- 建立类与表的映射 -->
    <class name="com.edp.hibernate.domain.Customer" table="cst_customer" catalog="hibernate0204">

          …………

        <!-- 配置一对多的关系：放置的是多的一方的集合 -->
        <!-- 联系人是多，客户是一 -->
        <!-- set标签
            name：对的一方的对象集合的属性名称
            cascade:级联，用逗号隔开，就同时拥有保存或更新、删除功能
            inverse：放弃外键维护权，true是确定放弃外键维护权。默认的false是不放弃。
        -->
        <set name="linkMans" cascade="save-update,delete" inverse="false">
            <!-- key标签
                column：多的一方的外键的名称
            -->
            <key column="lkm_cust_id"></key>
            <!-- one-to-many标签
                class：多的一方的类的全路径
            -->
            <one-to-many class="com.edp.hibernate.domain.LinkMan" />
        </set>
    </class>

</hibernate-mapping>

将数据库修改回demo7方法运行之前的状态：

image.png

再次执行demo7方法：

image.png

可见update语句只执行一次，不会产生多余的语句。

5.3 区分cascade和inverse的区别

cascade是控制关联对象的，inverse是控制一的一方能不能去维护外键。
在HibernateDemo1.java中新建方法：


    @Test
    /**
     * 
     * @Title: demo8
     * @Description: 区分cascade和inverse的区别
     * @param
     * @return void
     * @throws
     *
     */
    public void demo8() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction txTransaction = session.beginTransaction();

        Customer customer = new Customer();
        customer.setCust_name("四川麻将");

        LinkMan linkMan = new LinkMan();
        linkMan.setLkm_name("跑胡子");

        customer.getLinkMans().add(linkMan);
        // 条件：在cascade="save-update" inverse="true"
        session.save(customer); //执行时，客户会插入到数据库，联系人也会插入到数据库,但是外键为null

        txTransaction.commit();
    }

重建数据库，并将demo1()运行,注入数据，再执行demo8()。

执行结果：

image.png

数据库变化：

image.png

执行时， 客户会插入到数据库，联系人也会插入到数据库,但是外键为null。

6.0 测试类HibernateDemo1.java完整代码

package com.edp.hibernate.demo1;

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

import com.edp.hibernate.domain.Customer;
import com.edp.hibernate.domain.LinkMan;
import com.edp.hibernate.utils.HibernateUtils;

/**
 * 
 * @Title: HibernateDemo1.java
 * @Package com.edp.hibernate.demo1
 * @author EdPeng
 * @version 创建时间 2020年2月4日上午2:12:53
 * @Description 一对多的测试类
 * @version V1.0
 */
public class HibernateDemo1 {
    @Test
    // 保存2个客户和3个联系人，并建立好关系
    public void demo1() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction txTransaction = session.beginTransaction();

        // 创建2个客户
        Customer customer1 = new Customer();
        customer1.setCust_name("王二小");
        Customer customer2 = new Customer();
        customer2.setCust_name("孙悟空");

        // 创建3个联系人
        LinkMan linkMan1 = new LinkMan();
        linkMan1.setLkm_name("青牛精");
        LinkMan linkMan2 = new LinkMan();
        linkMan2.setLkm_name("鸡毛精");
        LinkMan linkMan3 = new LinkMan();
        linkMan3.setLkm_name("包谷怪");

        // 需要设置关系：
        linkMan1.setCustomer(customer1);
        linkMan2.setCustomer(customer1);
        linkMan3.setCustomer(customer2);
        customer1.getLinkMans().add(linkMan1);
        customer1.getLinkMans().add(linkMan2);
        customer2.getLinkMans().add(linkMan3);

        // 保存数据
        session.save(linkMan1);
        session.save(linkMan2);
        session.save(linkMan3);
        session.save(customer1);
        session.save(customer2);

        txTransaction.commit();
    }

    @Test
    // 一对多关系只保存一边是否可以
    public void demo2() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction txTransaction = session.beginTransaction();

        Customer customer1 = new Customer();
        customer1.setCust_name("王二小");

        LinkMan linkMan1 = new LinkMan();
        linkMan1.setLkm_name("青牛精");

        linkMan1.setCustomer(customer1);
        customer1.getLinkMans().add(linkMan1);

        session.save(customer1);

        txTransaction.commit();
    }

    @Test
    /**
     * 
     * @Title: demo3
     * @Description: 级联保存或更新——保存客户级联联系人
     * 操作的主体对象是客户对象
     * <set name="linkMans" cascade="save-update">
     * @param
     * @return void
     * @throws
     *
     */
    public void demo3() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction txTransaction = session.beginTransaction();

        Customer customer1 = new Customer();
        customer1.setCust_name("冬瓜");

        LinkMan linkMan1 = new LinkMan();
        linkMan1.setLkm_name("铁勺");

        linkMan1.setCustomer(customer1);
        customer1.getLinkMans().add(linkMan1);

        session.save(customer1);

        txTransaction.commit();
    }

    @Test
    /**
     * 
     * @Title: demo4
     * @Description: 级联保存或更新——保存联系人级联客户
     * 操作的主体对象是联系人对象，设置cascade="save-update"
     * <many-to-one name="customer" cascade="save-update"
     * class="com.edp.hibernate.domain.Customer" column="lkm_cust_id" />
     * 
     * @param
     * @return void
     * @throws
     *
     */
    public void demo4() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction txTransaction = session.beginTransaction();

        Customer customer1 = new Customer();
        customer1.setCust_name("菊花");

        LinkMan linkMan1 = new LinkMan();
        linkMan1.setLkm_name("陶盆");

        linkMan1.setCustomer(customer1);
        customer1.getLinkMans().add(linkMan1);

        session.save(linkMan1);

        txTransaction.commit();
    }

    @Test
    /**
     * 
     * @Title: demo5
     * @Description: 测试对象的导航
     * 前提：一对多的双方，都设置了cascade="save-update"
     * @param
     * @return void
     * @throws
     *
     */
    public void demo5() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction txTransaction = session.beginTransaction();

        // 1个客户
        Customer customer1 = new Customer();
// customer1.setCust_name("浙江省委");
//
// // 创建3个联系人
// LinkMan linkMan1 = new LinkMan();
// linkMan1.setLkm_name("宁波市委");
// LinkMan linkMan2 = new LinkMan();
// linkMan2.setLkm_name("台州市委");
// LinkMan linkMan3 = new LinkMan();
// linkMan3.setLkm_name("绍兴市委");
//
// linkMan1.setCustomer(customer1);
// customer1.getLinkMans().add(linkMan2);
// customer1.getLinkMans().add(linkMan3);
//
// //双方都设置了cascade
// session.save(linkMan1);//发送几条insert语句 —— 4条

//
// customer1.setCust_name("宫崎骏");
//
// // 创建3个联系人
// LinkMan linkMan1 = new LinkMan();
// linkMan1.setLkm_name("波妞她妈");
// LinkMan linkMan2 = new LinkMan();
// linkMan2.setLkm_name("宗介");
// LinkMan linkMan3 = new LinkMan();
// linkMan3.setLkm_name("波妞");
//
// linkMan1.setCustomer(customer1);
// customer1.getLinkMans().add(linkMan2);
// customer1.getLinkMans().add(linkMan3);
// session.save(customer1);//发送几条insert语句 —— 3条

        customer1.setCust_name("五行学说");

        // 创建3个联系人
        LinkMan linkMan1 = new LinkMan();
        linkMan1.setLkm_name("金行");
        LinkMan linkMan2 = new LinkMan();
        linkMan2.setLkm_name("木行");
        LinkMan linkMan3 = new LinkMan();
        linkMan3.setLkm_name("水行");

        linkMan1.setCustomer(customer1);
        customer1.getLinkMans().add(linkMan2);
        customer1.getLinkMans().add(linkMan3);

        session.save(linkMan2);// 发送几条insert语句 —— 1条
        txTransaction.commit();
    }

    @Test
    /**
     * 
     * @Title: demo6
     * @Description: 测试 级联删除
     * 删除客户，级联删除联系人：删除的主体是客户，需要在Customer.hbm.xml中配置
     * <set name="linkMans" cascade="delete">
     * 删除联系人，级联删除客户：删除的主体是联系人，需要在LinkMan.hbm.xml中配置
     * <many-to-one name="customer" cascade="delete"
     * class="com.edp.hibernate.domain.Customer" column="lkm_cust_id" />
     * @param
     * @return void
     * @throws
     *
     */
    public void demo6() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction txTransaction = session.beginTransaction();

        // 没有设置级联删除，默认情况,修改联系人的外键，删除客户
// Customer customer = session.get(Customer.class, 1l);
// session.delete(customer);

        // 删除客户，同时删除联系人 ——→ 级联删除
// Customer customer = session.get(Customer.class, 2l);
// session.delete(customer);

        // 删除联系人，同时删除客户 ——→ 级联删除（但不常用）
        LinkMan linkMan = session.get(LinkMan.class, 4l);
        session.delete(linkMan);

        txTransaction.commit();
    }

    @Test
    /**
     * 
     * @Title: demo7
     * @Description: 将6号联系人原来归为5号客户，改为3号客户
     * @param
     * @return void
     * @throws
     *
     */
    public void demo7() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction txTransaction = session.beginTransaction();

        // 查询6号联系人
        LinkMan linkMan = session.get(LinkMan.class, 6l);
        // 查询3号客户
        Customer customer = session.get(Customer.class, 3l);

        // 双向的关联
        linkMan.setCustomer(customer);
        customer.getLinkMans().add(linkMan);
        // 不需要用update方法，持久态对象自动更新数据库

        txTransaction.commit();
    }

    @Test
    /**
     * 
     * @Title: demo8
     * @Description: 区分cascade和inverse的区别
     * @param
     * @return void
     * @throws
     *
     */
    public void demo8() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction txTransaction = session.beginTransaction();

        Customer customer = new Customer();
        customer.setCust_name("四川麻将");

        LinkMan linkMan = new LinkMan();
        linkMan.setLkm_name("跑胡子");

        customer.getLinkMans().add(linkMan);
        // 条件：在cascade="save-update" inverse="true"
        session.save(customer); //执行时，客户会插入到数据库，联系人也会插入到数据库,但是外键为null

        txTransaction.commit();
    }
}

END