Hibernate入门-03

最新推荐文章于 2024-03-03 23:01:23 发布

绿谷小初九

最新推荐文章于 2024-03-03 23:01:23 发布

阅读量698

点赞数

CC 4.0 BY-SA版权

分类专栏： SSH

本文链接：https://blog.youkuaiyun.com/qq_36974281/article/details/81407501

SSH 专栏收录该内容

9 篇文章

订阅专栏

本文详细介绍了Hibernate框架中一对多及多对多关联关系的设计原则、JavaBean编写规则、映射配置方法以及级联操作等内容。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

课程回顾：Hibernate第二天

    1. 持久化类和一级缓存
        * 持久化类：JavaBean + 映射的配置文件
        * 持久化对象的三种状态
            * 瞬时态
            * 持久态：有自动更新数据的能力
            * 托管态
        * Session的一级缓存，快照机制 
        * 主键的生成策略

    2. 管理事务
        * 设置隔离级别
        * 丢失更新的问题，乐观锁：添加属性version，配置<version name="version">
        * 绑定本地的Session，事务需要service层开启，dao层需要使用Session对象

    3. 查询的接口
        * Query接口：HQL的查询
        * Criteria接口：QBC查询（按条件进行查询）

一对多(添加联系人案例)

因为客户和联系人是一对多的关系，在有客户的情况下，完成联系人的添加保存操作

javaWEB中一对多的设计以及建表原则

自己滚去复习
导入SQL的建表语句

编写JavaBean(注意一对多的编写规则)

客户的JavaBean(一方)


public class Customer {
    private Long cust_id;
    private String cust_name;
    private Long cust_user_id;
    private Long cust_create_id;
    private String cust_source;
    private String cust_industry;
    private String cust_level;
    private String cust_linkman;
    private String cust_phone;
    private String cust_mobile;

    //一对多 一方写个集合
    //hibernate框架默认的集合是 set 
    //必须自己手动初始化
    private Set<Linkman> linkmans = new HashSet<Linkman>();

}

联系人的JavaBean(多方)

public class Linkman {
    private Long lkm_id;
    private String lkm_name;
    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;

    //老生常谈的问题 外键直接写对象
    private Customer 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.xiaoming.day01.domain.Customer" table="cst_customer">
        <id name="cust_id" column="cust_id">
            <!--主键生成策略-->
            <generator class="native"/>
        </id>

        <!--配置乐观锁-->
        <version name="version"/>

        <!-- 配置其他的属性 -->
        <property name="cust_name" column="cust_name"/>
        <property name="cust_user_id" column="cust_user_id"/>
        <property name="cust_create_id" column="cust_create_id"/>
        <property name="cust_source" column="cust_source"/>
        <property name="cust_industry" column="cust_industry"/>
        <property name="cust_level" column="cust_level"/>
        <property name="cust_linkman" column="cust_linkman"/>
        <property name="cust_phone" column="cust_phone"/>
        <property name="cust_mobile" column="cust_mobile"/>

        <!--
            配置一方:
                set标签的  name属性 :表示集合的名称
        -->
        <set name="linkmans">
            <!--
                需要出现的子标签
                    key: 多的一方的外键名称
            -->
            <key column="lkm_cust_id"></key>
            <one-to-many class="com.xiaoming.day01.domain.Linkman"/>
        </set>

    </class>

</hibernate-mapping>

联系人的配置文件(多方)

<?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.xiaoming.day01.domain.Linkman" table="cst_linkman">
        <id name="lkm_id" column="lkm_id">
            <!--主键生成策略-->
            <generator class="native"/>
        </id>

        <!--配置乐观锁-->
        <version name="version"/>

        <!-- 配置其他的属性 -->
        <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"/>


        <!--
            配置多方:
                name JavaBean中的属性
                class 属性对应类的类路径
                column 表的外键字段(该文件上述配置中并没有配置表的外键)
        -->
        <many-to-one name="customer" class="com.xiaoming.day01.domain.Customer" column="lkm_cust_id"/>

    </class>


</hibernate-mapping>

操作客户和联系人的数据

进行双向关联进行数据的保存（不设置级联）

 /**
     * 最麻烦的方式双向关联的方式 保存数据
     */
    @Test
    public void fun1(){
        Session session = HibernateUtils.getCurrentSession();
        Transaction transaction = session.beginTransaction();

        //保存客户和联系人的数据
        Customer customer = new Customer();
        customer.setCust_name("测试双向关联");

        //创建两个联系人
        Linkman l1 = new Linkman();
        l1.setLkm_name("熊大");
        Linkman l2 = new Linkman();
        l2.setLkm_name("熊二");

        //双向关联  客户关联联系人  联系人呢关联客户
        Set<Linkman> linkmans = customer.getLinkmans();
        linkmans.add(l1);
        linkmans.add(l2);

        l1.setCustomer(customer);
        l2.setCustomer(customer);

        //保存数据
        session.save(customer);
        session.save(l1);
        session.save(l2);

        //提交
        transaction.commit();

    }

        @Test
    //为客户增加联系人
    public void fun2(){
        //1 获得session
        Session session = HibernateUtils.openSession();
        //2 开启事务
        Transaction tx = session.beginTransaction();
        //-------------------------------------------------
        //3操作
        //1> 获得要操作的客户对象
        Customer c = session.get(Customer.class,1l);
        //2> 创建联系人
        LinkMan lm1 = new LinkMan();
        lm1.setLkm_name("郝强勇");
        //3> 将联系人添加到客户,将客户设置到联系人中
        c.getLinkMens().add(lm1);
        lm1.setCustomer(c);
        //4> 执行保存
        session.save(lm1);
        //-------------------------------------------------
        //4提交事务
        tx.commit();
        //5关闭资源
        session.close();
    }

    @Test
    //为客户删除联系人
    public void fun3(){
        //1 获得session
        Session session = HibernateUtils.openSession();
        //2 开启事务
        Transaction tx = session.beginTransaction();
        //-------------------------------------------------
        //3操作
        //1> 获得要操作的客户对象
        Customer c = session.get(Customer.class,1l);
        //2> 获得要移除的联系人
        LinkMan lm = session.get(LinkMan.class, 3l);
        //3> 将联系人从客户集合中移除
        c.getLinkMens().remove(lm);
        lm.setCustomer(null);
        //-------------------------------------------------
        //4提交事务
        tx.commit();
        //5关闭资源
        session.close();
    }

级联的取值（cascade的取值）

1. 级联操作是指当主控方执行保存更新或者删除操作时,其关联对象(被控方)也执行相同的操作
    * 在映射文件中配置 cascade属性来设置是否采取级联操作
    * 级联操作对各种关联关系(3种)都是有效的
    * 级联保存是方向性

2. 需要大家掌握的取值如下
    * none                      -- 不使用级联
    * save-update               -- 级联保存或更新
    * delete                    -- 级联删除
    * delete-orphan             -- 孤儿删除.(注意：只能应用在一对多关系)
    * all                       -- 除了delete-orphan的所有情况.（包含save-update delete）
    * all-delete-orphan         -- 包含了delete-orphan的所有情况.（包含save-update delete delete-orphan）

3. 孤儿删除（孤子删除），只有在一对多的环境下才有孤儿删除
    * 在一对多的关系中,可以将一的一方认为是父方.将多的一方认为是子方.孤儿删除:在解除了父子关系的时候.将子方记录就直接删除。
    * <many-to-one cascade="delete-orphan" />

级联操作

1. 测试：如果现在代码只插入其中的一方的数据
    * 如果只保存其中的一方的数据，那么程序会抛出异常。(瞬时态的对象没转成持久态的对象)
    * 如果想完成只保存一方的数据，并且把相关联的数据都保存到数据库中，那么需要配置级联！！


. 级联保存效果
    * 级联保存：保存一方同时可以把关联的对象也保存到数据库中！！
    * 使用cascade="save-update"

级联保存或更新 sascade = save-update

    /**
     * 级联保存：保存客户，级联联系人 (方向性)
     * 在Customer的配置文件中配置级联属性  customer是主控方,linkman是被控方
     *              级联客户同理
     */
    @Test
    public void run3(){
        Session session = HibernateUtils.getCurrentSession();
        Transaction tr = session.beginTransaction();
        // 保存客户和联系人的数据

        //创建一个客户
        Customer c1 = new Customer();
        c1.setCust_name("美美");

        // 创建2个联系人
        Linkman l1 = new Linkman();
        l1.setLkm_name("熊大");
        Linkman l2 = new Linkman();
        l2.setLkm_name("熊二");

        // 单向关联 在customer.hbm.xml中配置级联属性
        //cascade="save-update"
        c1.getLinkmans().add(l1);
        c1.getLinkmans().add(l2);

        // 保存数据
        // 将c1设置为持久态
        session.save(c1);

        tr.commit();
    }

    /**
     * 深入探索双方之间的关系-1
     */
    @Test
    public void run5(){
        Session session = HibernateUtils.getCurrentSession();
        Transaction tr = session.beginTransaction();
        // 保存客户和联系人的数据
        Customer c1 = new Customer();
        c1.setCust_name("美美");

        // 创建2个联系人
        Linkman l1 = new Linkman();
        l1.setLkm_name("熊大");
        Linkman l2 = new Linkman();
        l2.setLkm_name("熊二");

        l1.setCustomer(c1);
        c1.getLinkmans().add(l2);

        //两边映射文件都配置了级联属性
        //保存联系人(l1)就把级联的客户保存进去了
        //而客户还级联了l2所以就都保存进去了
        session.save(l1);

        tr.commit();
    }

    /**
     * 深入探索双方之间的关系-2
     */
    @Test
    public void run5(){
        Session session = HibernateUtils.getCurrentSession();
        Transaction tr = session.beginTransaction();
        // 保存客户和联系人的数据
        Customer c1 = new Customer();
        c1.setCust_name("美美");

        // 创建三个联系人
        Linkman l1 = new Linkman();
        l1.setLkm_name("熊大");
        Linkman l2 = new Linkman();
        l2.setLkm_name("熊二");
        Linkman l3 = new Linkman();
        l3.setLkm_name("熊三");

        //建立关系
        l1.setCustomer(c1);
        c1.getLinkmans().add(l2);
        c1.getLinkmans().add(l3);
        // 双方都配置了级联属性

        //l1级联了c1,c1级联了l2,l3
        session.save(l1) // 发送4条 insert语句
        sesison.save(c1) // 发送3条 insert语句
        session.sace(l2) // 发送1条 insert语句

        tr.commit();
    }

级联删除(慎用)

1. 先来给大家在数据库中演示含有外键的删除客户功能，那么SQL语句是会报出错误的
    * 例如：delete from customers where cid = 1;

2. 如果使用Hibernate框架直接删除客户的时候，测试发现是可以删除的
    *hibernate会先让外键=null,然后再删除
    *删除客户但是联系人数据没删 只是外键没了  这些数据也没意义

3. 上述的删除是普通的删除，那么也可以使用级联删除，注意：级联删除也是有方向性的！！
    * <many-to-one cascade="save-update,delete" />

    @Test
    //测试删除客户时,级联删除客户下的联系人
    //cascade:delete
    public void fun2(){
        //1 获得session
        Session session = HibernateUtils.openSession();
        //2 开启事务
        Transaction tx = session.beginTransaction();
        //级联删除必须是先查询再删除
        //因为查询到客户,这个时候客户的联系人的集合就会有数据
        Customer c = session.get(Customer.class,1l);
        //2>调用delete删除客户
        session.delete(c);
        //-------------------------------------------------
        //4提交事务
        tx.commit();
        //5关闭资源
        session.close();
    }

级联关系进阶 inverse属性

1. 先测试双方都维护外键的时候，会产生多余的SQL语句。
    * 想修改客户和联系人的关系，进行双向关联，双方都会维护外键，会产生多余的SQL语句。
    * 客户(一的一方)维护外键有点多余
    * inverse属性可以优化sql语句提高性能


    * 产生的原因：session的一级缓存中的快照机制，会让双方都更新数据库，产生了多余的SQL语句。

2. 如果不想产生多余的SQL语句，那么需要一方来放弃外键的维护！
    * 在<set>标签上配置一个inverse=”true”.true:放弃.false:不放弃.默认值是false
    * <inverse="true">
    * 肯定是也只能是一的哪一方放弃外键维护,以为多的哪一方外键是它自己的属性

@Test
    //保存客户 以及客户 下的联系人
    public void fun1(){
        //1 获得session
        Session session = HibernateUtils.openSession();
        //2 开启事务
        Transaction tx = session.beginTransaction();
        //-------------------------------------------------
        //3操作
        Customer c = new Customer();
        c.setCust_name("传智播客");

        LinkMan lm1 = new LinkMan();
        lm1.setLkm_name("黎活明");

        LinkMan lm2 = new LinkMan();
        lm2.setLkm_name("刘悦东");

        //表达一对多,客户下有多个联系人. 
        // 如果客户放弃维护与联系人的关系. 维护关系的代码可以省略
        //c.getLinkMens().add(lm1);
        //c.getLinkMens().add(lm2);

        //联系人维护客户的关系
        lm1.setCustomer(c);
        lm2.setCustomer(c);

        session.save(c);
        session.save(lm1);
        session.save(lm2);
        //4提交事务
        tx.commit();
        //5关闭资源
        session.close();
    }

cascade和inverse的区别

1. cascade用来级联操作（保存、修改和删除）
            是用来简化代码的
2. inverse用来维护外键的
            是用来提高效率的
3. 一对多的情况下 我们通常将一方设置inverse 将多放设置 cascade

一的一方放弃主键维护另外设置级联删除

多对多(用户和角色为例)

多对多的建表原则

JavaWEB的多对多:
    一个用户对应多个角色 ,一个角色对应多个用户
    很明显多对多之间需要建立中间表
    设立两个外键 分别指向两张表的主键

Hibernate框架:
    只需要编写2个JavaBean编写两个配置文件
    中间表会自动生成

多对多JavaBean的编写

用户的JavaBean代码如下

public class User {
    private Long user_id;
    private String user_code;
    private String user_name;
    private String user_password;
    private String user_state;

    private Set<Role> roles = new HashSet<Role>();
}

角色的JavaBean代码如下

public class Role {
    private Long role_id;
    private String role_name;
    private String role_memo;

    private Set<User> users = new HashSet<User>();
}

多对多映射配置文件

用户的映射配置文件如下

<class name="com.itheima.domain.User" table="sys_user">
    <id name="user_id" column="user_id">
        <generator class="native"/>
    </id>
    <property name="user_code" column="user_code"/>
    <property name="user_name" column="user_name"/>
    <property name="user_password" column="user_password"/>
    <property name="user_state" column="user_state"/>

    <!--
        set标签
            name   关联的另一方集合的属性名称
            table  中间表的名称

       key标签
            coiumn  当前对象在中间表中的外键名称

       many-tomany标签
            class   关联另一方的类的全路径
            column  关联的另一方在中间表的外键名称

    -->

    <!--这里的配置中间表已全部维护-->

    <set name="roles" table="sys_user_role">
        <key column="user_id"/>
        <many-to-many class="com.itheima.domain.Role" column="role_id"/>
    </set>
</class>

角色的映射配置文件如下

            <class name="com.itheima.domain.Role" table="sys_role">
                <id name="role_id" column="role_id">
                    <generator class="native"/>
                </id>
                <property name="role_name" column="role_name"/>
                <property name="role_memo" column="role_memo"/>

                <set name="users" table="sys_user_role">
                    <key column="role_id"/>
                    <many-to-many class="com.itheima.domain.User" column="user_id"/>
                </set>
            </class>

注意多对多进行双向关联的时候:必须有一方去放弃外键维护权

多对多双向关联

    @Test
    //保存员工以及角色
    public void fun1(){
        Session session = HibernateUtils.openSession();
        Transaction tx = session.beginTransaction();

        // 创建两个 User
        User u1 = new User();
        u1.setUser_name("郝强勇");

        User u2 = new User();
        u2.setUser_name("金家德");

        // 创建两个 Role
        Role r1 = new Role();
        r1.setRole_name("保洁");

        Role r2 = new Role();
        r2.setRole_name("保安");


    <!--
        如果多对多建立了双向关联,一定要有一方放弃外键维护
            一般是由被动方放弃,用户主动选择角色,角色是
            被动选择的

        其实不放弃也可以,我们可以只描述其中一张表中的内容
        只执行下面的 "用户表达关系"  "角色表达式"
        但是都得持久化

    -->
    <!--
        之所以要一方放弃维护外键,是因为不放弃会报错因为
        多对多关联维护外键是想中间表插入数据,双方都维护
        相同的数据插入两次,但是插入的还都是主键信息,不能重复,
        所以会保错

        而一对多不报错的原因是因为外键维护是修改(先执行的insert)的而不是
        直接insert
    -->

        //3> 用户表达关系
        u1.getRoles().add(r1);
        u1.getRoles().add(r2);

        u2.getRoles().add(r1);
        u2.getRoles().add(r2);

        //4> 角色表达关系
        r1.getUsers().add(u1);
        r1.getUsers().add(u2);

        r2.getUsers().add(u1);
        r2.getUsers().add(u2);

        //5> 调用Save方法一次保存
        session.save(u1);
        session.save(u2);
        session.save(r1);
        session.save(r2);
        //-------------------------------------------------
        //4提交事务
        tx.commit();
        //5关闭资源
        session.close();
    }

多对多级联操作

    @Test
    //保存员工以及角色
    public void fun1(){
        //1 获得session
        Session session = HibernateUtils.openSession();
        //2 开启事务
        Transaction tx = session.beginTransaction();
        //-------------------------------------------------
        //3操作
        //1> 创建两个 User
        User u1 = new User();
        u1.setUser_name("郝强勇");

        User u2 = new User();
        u2.setUser_name("金家德");

        //2> 创建两个 Role
        Role r1 = new Role();
        r1.setRole_name("保洁");

        Role r2 = new Role();
        r2.setRole_name("保安");


        //3> 用户表达关系
        u1.getRoles().add(r1);
        u1.getRoles().add(r2);

        u2.getRoles().add(r1);
        u2.getRoles().add(r2);

        //4> 角色表达关系
        r1.getUsers().add(u1);
        r1.getUsers().add(u2);

        r2.getUsers().add(u1);
        r2.getUsers().add(u2);

        //5> 调用Save方法一次保存
        session.save(u1);
        session.save(u2);
        //没错配置级联之后就少了这么两句
        //session.save(r1);
        //session.save(r2);
        //-------------------------------------------------
        //4提交事务
        tx.commit();
        //5关闭资源
        session.close();

    @Test
    //为郝强勇新增一个角色
    public void fun3(){
        //1 获得session
        Session session = HibernateUtils.openSession();
        //2 开启事务
        Transaction tx = session.beginTransaction();
        //-------------------------------------------------
        //3操作
        //1> 获得郝强勇用户
        User user = session.get(User.class, 1l);
        //2> 创建公关角色
        Role r = new Role();
        r.setRole_name("男公关");
        //3> 将角色添加到用户中
        user.getRoles().add(r);
        //4> 将角色转换为持久化 级联之后就不用了
        //session.save(r);
        //-------------------------------------------------
        //4提交事务
        tx.commit();
        //5关闭资源
        session.close();
    }

    @Test
    //为郝强勇解除一个角色
    public void fun4(){
        //1 获得session
        Session session = HibernateUtils.openSession();
        //2 开启事务
        Transaction tx = session.beginTransaction();
        //-------------------------------------------------
        //3操作
        //1> 获得郝强勇用户
        User user = session.get(User.class, 1l);
        //2> 获得要操作的角色对象(保洁,保安)
        Role r1 = session.get(Role.class, 1l);
        Role r2 = session.get(Role.class, 2l);
        //3> 将角色从用户的角色集合中移除
        user.getRoles().remove(r1);
        user.getRoles().remove(r2);

        //-------------------------------------------------
        //4提交事务
        tx.commit();
        //5关闭资源
        session.close();
    }