hibernate基础（六）--多对多关联映射

最新推荐文章于 2020-09-02 23:48:43 发布

zhangjiekong12138

最新推荐文章于 2020-09-02 23:48:43 发布

阅读量142

点赞数

分类专栏： hibernate

本文链接：https://blog.csdn.net/zhangjiekong12581/article/details/79097097

版权

hibernate 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

hibernate的多对多关联映射

以用户和角色为例
创建用户实体

package cn.imau.entity;


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

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>();

    public Long getUser_id() {
        return user_id;
    }

    public void setUser_id(Long user_id) {
        this.user_id = user_id;
    }

    public String getUser_code() {
        return user_code;
    }

    public void setUser_code(String user_code) {
        this.user_code = user_code;
    }

    public String getUser_name() {
        return user_name;
    }

    public void setUser_name(String user_name) {
        this.user_name = user_name;
    }

    public String getUser_password() {
        return user_password;
    }

    public void setUser_password(String user_password) {
        this.user_password = user_password;
    }

    public String getUser_state() {
        return user_state;
    }

    public void setUser_state(String user_state) {
        this.user_state = user_state;
    }

    public Set<Role> getRoles() {
        return roles;
    }

    public void setRoles(Set<Role> roles) {
        this.roles = roles;
    }
}

创建角色实体

package cn.imau.entity;

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

public class Role {
    private Long role_id;
    private String role_name;
    private String role_memo;
    //一个角色包含多个用户
    private Set<User> users=new HashSet<User>();

    public Long getRole_id() {
        return role_id;
    }

    public void setRole_id(Long role_id) {
        this.role_id = role_id;
    }

    public String getRole_name() {
        return role_name;
    }

    public void setRole_name(String role_name) {
        this.role_name = role_name;
    }

    public String getRole_memo() {
        return role_memo;
    }

    public void setRole_memo(String role_memo) {
        this.role_memo = role_memo;
    }

    public Set<User> getUsers() {
        return users;
    }

    public void setUsers(Set<User> users) {
        this.users = users;
    }
}

用户映射

<?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="cn.imau.entity">

    <class name="User" table="sys_user">
        <id name="user_id" >
            <generator class="native"></generator>
        </id>
        <property name="user_code" />
        <property name="user_name"/>
        <property name="user_password" />
        <property name="user_state"/>
        <!-- 多对多关系表达 -->
        <!--
         set标签
            name: 关联的另一方的集合属性名
            table: 中间表的名称
            key
              |-column:外键,别人引用"我"的外键列名
             class: 我与哪个类是多对多关系
             column:外键.我引用比人的外键列名
         -->
        <!-- cascade级联操作:
                    save-update: 级联保存更新
                    delete:级联删除
                    all:级联保存更新+级联删除
            结论: cascade简化代码书写.该属性使不使用无所谓. 建议要用只用save-update.
                 如果使用delete操作太过危险.尤其在多对多中.不建议使用.
                     -->
        <set name="roles" table="sys_user_role">
            <key column="user_id" ></key>
            <!--
            many-to-many标签
               class:关联的另一方的类的全路径
               column：关联的另一方的中间表的外键名称
            -->
            <many-to-many class="Role" column="role_id" ></many-to-many>
        </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 package="cn.imau.entity">
    <class name="Role" table="sys_role">
        <id name="role_id">
            <generator class="native"/>
        </id>
        <property name="role_name"/>
        <property name="role_memo"/>
        <set name="users" table="sys_user_role">
            <key column="role_id"></key>
            <many-to-many class="User" column="user_id">
            </many-to-many>
        </set>
    </class>

</hibernate-mapping>

在核心配置文件中引入映射文件

 <mapping resource="cn/imau/entity/User.hbm.xml" />
 <mapping resource="cn/imau/entity/Role.hbm.xml" />

编写测试类

package cn.imau.test;

import cn.imau.entity.User;
import cn.imau.entity.Role;
import cn.utils.HibernateUtils;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

public class test {
    @Test
    //保存用户和角色
    public void demo1(){
        Session session= HibernateUtils.getCurrentSession();
        Transaction transaction=session.beginTransaction();

        User user1=new User();
        user1.setUser_name("zhangsan");

        User user2=new User();
        user2.setUser_name("lisi");

        Role role1=new Role();
        role1.setRole_name("assistant");

        Role role2=new Role();
        role2.setRole_name("HR");

        Role role3=new Role();
        role3.setRole_name("Manager");

        //如果多对多建立了双向关联，一定要有一方放弃外键维护权
        user1.getRoles().add(role1);
        user1.getRoles().add(role3);
        user2.getRoles().add(role2);
        user2.getRoles().add(role3);

        role1.getUsers().add(user1);
        role2.getUsers().add(user1);
        role2.getUsers().add(user2);
        role3.getUsers().add(user2);

        session.save(user1);
        session.save(user2);
        session.save(role1);
        session.save(role2);
        session.save(role3);

        transaction.commit();
    }

}

多对多的相关操作

级联保存或更新

保存用户级联角色

配置映射

<set name="roles" table="sys_user_role" cascade="save-update">
       <key column="user_id" ></key>
       <many-to-many class="Role" column="role_id" ></many-to-many>
</set>

编写测试代码

package cn.imau.test;

import cn.imau.entity.User;
import cn.imau.entity.Role;
import cn.utils.HibernateUtils;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

public class test {
    @Test
    /*
    * 多对多只保存一边也是不可以的
    * 配置级联：保存用户级联角色，在User.hbm.xml中<set>上配置cascade="save-update"
    * */
    public void demo2(){
        Session session= HibernateUtils.getCurrentSession();
        Transaction transaction=session.beginTransaction();

        User user1=new User();
        user1.setUser_name("zhangsan");

        User user2=new User();
        user2.setUser_name("lisi");

        Role role1=new Role();
        role1.setRole_name("assistant");

        Role role2=new Role();
        role2.setRole_name("HR");

        Role role3=new Role();
        role3.setRole_name("Manager");

        //如果多对多建立了双向关联，一定要有一方放弃外键维护权
        user1.getRoles().add(role1);
        user1.getRoles().add(role3);
        user2.getRoles().add(role2);
        user2.getRoles().add(role3);

        role1.getUsers().add(user1);
        role2.getUsers().add(user1);
        role2.getUsers().add(user2);
        role3.getUsers().add(user2);

        session.save(user1);
        session.save(user2);
       /* session.save(role1);
        session.save(role2);
        session.save(role3);*/

        transaction.commit();
    }

}

保存角色级联用户

配置映射

<set name="users" table="sys_user_role" cascade="save-update">
            <key column="role_id"></key>
            <many-to-many class="User" column="user_id">
            </many-to-many>
</set>

编写测试代码

package cn.imau.test;

import cn.imau.entity.User;
import cn.imau.entity.Role;
import cn.utils.HibernateUtils;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

public class test {
    @Test
    /*
    * 多对多只保存一边也是不可以的
    * 配置级联：保存角色级联用户，在Role.hbm.xml中<set>上配置cascade="save-update"
    * */
    public void demo3(){
        Session session= HibernateUtils.getCurrentSession();
        Transaction transaction=session.beginTransaction();

        User user1=new User();
        user1.setUser_name("zhangsan");

        User user2=new User();
        user2.setUser_name("lisi");

        Role role1=new Role();
        role1.setRole_name("assistant");

        Role role2=new Role();
        role2.setRole_name("HR");

        Role role3=new Role();
        role3.setRole_name("Manager");

        //如果多对多建立了双向关联，一定要有一方放弃外键维护权
        user1.getRoles().add(role1);
        user1.getRoles().add(role3);
        user2.getRoles().add(role2);
        user2.getRoles().add(role3);

        role1.getUsers().add(user1);
        role2.getUsers().add(user1);
        role2.getUsers().add(user2);
        role3.getUsers().add(user2);

        /*session.save(user1);
        session.save(user2);*/
        session.save(role1);
        session.save(role2);
        session.save(role3);

        transaction.commit();
    }

}

级联删除

删除用户级联角色
映射配置

<set name="roles" table="sys_user_role" cascade="delete,save-update">
       <key column="user_id" ></key>
       <many-to-many class="Role" column="role_id" ></many-to-many>
</set>

编写测试代码

@Test
    //级联删除：删除用户 级联删除角色
    public void demo4(){
        Session session= HibernateUtils.getCurrentSession();
        Transaction transaction=session.beginTransaction();

        User user=session.get(User.class,1L);
        session.delete(user);

        transaction.commit();
    }

删除角色级联删除用户
映射配置

 <set name="users" table="sys_user_role" cascade="delete,save-update">
       <key column="role_id"></key>
       <many-to-many class="User" column="user_id">
            </many-to-many>
</set>

编写测试代码

@Test
    //级联删除：删除角色 级联删除用户
    public void demo5(){
        Session session= HibernateUtils.getCurrentSession();
        Transaction transaction=session.beginTransaction();

        Role role=session.get(Role.class,3L);
        session.delete(role);

        transaction.commit();
    }

多对多的其他操作

删除某个用户的角色

@Test
    //将2号用户中的1号角色去掉
    public void demo6(){
        Session session= HibernateUtils.getCurrentSession();
        Transaction transaction=session.beginTransaction();

        //查询2号用户
        User user =session.get(User.class,2L);
        //查询1号角色
        Role role=session.get(Role.class,1L);
        //操作集合相当于操作中间表
        user.getRoles().remove(role);

        transaction.commit();
    }

将某个用户的角色改选

@Test
    //将2号用户中的1号角色去掉,改为3号角色
    public void demo7(){
        Session session= HibernateUtils.getCurrentSession();
        Transaction transaction=session.beginTransaction();

        //查询2号用户
        User user =session.get(User.class,2L);
        //查询1号角色
        Role role1=session.get(Role.class,1L);
        //查询3号角色
        Role role3=session.get(Role.class,3L);

        user.getRoles().remove(role1);
        user.getRoles().add(role3);

        transaction.commit();
    }

给某个用户添加新角色

@Test
    //给1号用户添加2号角色
    public void demo8(){
        Session session= HibernateUtils.getCurrentSession();
        Transaction transaction=session.beginTransaction();

        //查询1号用户
        User user =session.get(User.class,1L);
        //查询2号角色
        Role role=session.get(Role.class,2L);


        user.getRoles().add(role);

        transaction.commit();
    }

zhangjiekong12138

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
hibernate基础（六）--多对多关联映射

hibernate的多对多关联映射以用户和角色为例创建用户实体package cn.imau.entity;import java.util.HashSet;import java.util.Set;public class User { private Long user_id; private String user_code; private
复制链接

扫一扫

专栏目录