Hibernate多对多的关系映射，详解（代码+图解）与应用 举个栗子，搞的清楚数据库,mysql,hibernateqq44757034的博客-

Hibernate多对多的关系映射

多对多代表着，两个表之间（或者群体之间）存在着多重关系，一个群群体当中对象可以与另外一个群体之间，产生联系，相反另外一个群体当中的对象也一样

举一个简单的例子：
在游戏当中有玩家和角色，玩家可以选择多个不同的角色，同时角色也可以被多个玩家同时选择
或者一个游戏当中有多种不同的武器，玩家可以选择多个不同的武器，同时武器也可以被不同的玩家选择

或者课程与学生之间

数据库表能够描述实体数据之间的关系，通过对象也可以进行描述，关系映射就是将关联关系映射到数据库当中，在对象模型当中就是一个或者多个引用，在Hibernate当中采用Java对象关系来描述数据表之间的关系
如下：

上述图当中，为多对多的关系，在A类当中定义了B类的set集合，在B类集合当中定义A类类型的set集合，set集合是为了避免数据的重复

一、Hibernate多对多关系的配置

1、创建表

用户表

CREATE TABLE `sys_user` ( `user_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '用户id', `user_code` varchar(32) NOT NULL COMMENT '用户账号', `user_name` varchar(64) NOT NULL COMMENT '用户名称', `user_password` varchar(32) NOT NULL COMMENT '用户密码', `user_state` char(1) NOT NULL COMMENT '1:正常,0:暂停', PRIMARY KEY (`user_id`) ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8; 

角色表

CREATE TABLE `sys_role` ( `role_id` bigint(32) NOT NULL AUTO_INCREMENT, `role_name` varchar(32) NOT NULL COMMENT '角色名称', `role_memo` varchar(128) DEFAULT NULL COMMENT '备注', PRIMARY KEY (`role_id`) ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8; 

中间表

CREATE TABLE `sys_user_role` ( `role_id` BIGINT(32) NOT NULL COMMENT '角色id', `user_id` BIGINT(32) NOT NULL COMMENT '用户id', PRIMARY KEY (`role_id`,`user_id`), KEY `FK_user_role_user_id` (`user_id`), CONSTRAINT `FK_user_role_role_id` FOREIGN KEY (`role_id`) REFERENCES `sys_role` (`role_id`) ON DELETE NO ACTION ON UPDATE NO ACTION, CONSTRAINT `FK_user_role_user_id` FOREIGN KEY (`user_id`) REFERENCES `sys_user` (`user_id`) ON DELETE NO ACTION ON UPDATE NO ACTION ) ENGINE=INNODB DEFAULT CHARSET=utf8; 

2、相关配置

（1）引入相关架包

（2）核心配置文件（Hibernate.cfg.xml）

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "https://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"> <hibernate-configuration> <session-factory> <!-- 链接数据库的基本参数 --> <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property> <property name="hibernate.connection.url">jdbc:mysql:///hibernate_day03</property> <property name="hibernate.connection.username">root</property> <property name="hibernate.connection.password">root</property> <!-- 配置hibernate的方言的 目的是生成对应不同数据的语句 --> <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property> <!-- 可选配置 --> <!-- 打印SQL --> <property name="hibernate.show_sql">true</property> <!-- 格式化sql --> <property name="hibernate.format_sql">true</property> <!-- 自动创建表 --> <property name="hibernate.hbm2ddl.auto">create</property> <!-- 配置C3P0连接池 --> <property name="connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property> <!--在连接池中可用的数据库连接的最少数目 --> <property name="c3p0.min_size">5</property> <!--在连接池中所有数据库连接的最大数目 --> <property name="c3p0.max_size">20</property> <!--设定数据库连接的过期时间,以秒为单位, 如果连接池中的某个数据库连接处于空闲状态的时间超过了timeout时间,就会从连接池中清除 --> <property name="c3p0.timeout">120</property> <!--每3000秒检查所有连接池中的空闲连接 以秒为单位 --> <property name="c3p0.idle_test_period">3000</property> <!-- 设置事务隔离级别 --> <property name="hibernate.connection.isolaction">4</property> <!-- 配置当前线程来绑定的session --> <property name="hibernate.current_session_context_class">thread</property> <!-- 引入两个映射文件 --> <mapping    resource="com/itzheng/hibernate/domain/Customer.hbm.xml" /> <mapping    resource="com/itzheng/hibernate/domain/LinkMan.hbm.xml" /> </session-factory> </hibernate-configuration> 

（3）log4j.properties

### direct log messages to stdout ### log4j.appender.stdout=org.apache.log4j.ConsoleAppender log4j.appender.stdout.Target=System.err  log4j.appender.stdout.layout=org.apache.log4j.PatternLayout log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n ### direct messages to file mylog.log ### log4j.appender.file=org.apache.log4j.FileAppender log4j.appender.file.File=c:mylog.log log4j.appender.file.layout=org.apache.log4j.PatternLayout log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n  ### set log levels - for more verbose logging change 'info' to 'debug' ### # error warn info debug trace log4j.rootLogger= info, stdout 

（4）工具类

package com.itzheng.hibernate.utils; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.cfg.Configuration; /* Hibernate的工具类 做hibernate的小练习，对configuration的configure()方法很好奇，为啥创建的对象还要执行这个方法呢。 Configuration cfg = new Configuration().configure(); 原来configure()方法默认会在classpath下面寻找hibernate.cfg.xml文件， 如果没有找到该文件，系统会打印如下信息并抛出HibernateException异常。 其实不使用configure()方法也可以 Configuration cfg = new Configuration(); 这时hibernate会在classpath下面寻找hibernate.properties文件， 如果没有找到该文件，系统会打印如下信息并抛出HibernateException异常。  */ 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(); } } 

3、创建实体

（1）创建用户的实体

package com.itzheng.hibernate.domain; /*  * 用户的实体 CREATE TABLE `sys_user` (   `user_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '用户id',   `user_code` varchar(32) NOT NULL COMMENT '用户账号',   `user_name` varchar(64) NOT NULL COMMENT '用户名称',   `user_password` varchar(32) NOT NULL COMMENT '用户密码',   `user_state` char(1) NOT NULL COMMENT '1:正常,0:暂停',   PRIMARY KEY (`user_id`) ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8; */ public class User { private Long user_id; private String user_code; private String user_name; private String user_password; private String user_state; 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; } } 

（2）创建角色的实体

package com.itzheng.hibernate.domain; /*  * 角色的实体 CREATE TABLE `sys_role` (   `role_id` bigint(32) NOT NULL AUTO_INCREMENT,   `role_name` varchar(32) NOT NULL COMMENT '角色名称',   `role_memo` varchar(128) DEFAULT NULL COMMENT '备注',   PRIMARY KEY (`role_id`) ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;  */ public class Role { private Long role_id; private String role_name; private String role_memo; 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; } } 

4、设置多对多的关系（放置对方的集合）

（1）一个用户选择多个角色

同时生成get和set方法
（2）一个角色被多个用户选择

同时生成get和set方法

4、创建映射

User.hbm.xml

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <hibernate-mapping> <class name="com.itzheng.hibernate.domain.User" table="sys_user"> <!-- 建立oid与主键的映射 --> <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 属性：多对多的关系需要使用中间表，中间表的名称    --> <set name="roles" table="sys_user_role"> <!--      key 标签的：     column:当前的对象对应中间表的外键的名称。     --> <key column="user_id"/> <!--      many-to-many 标签：     *class :对象的类的全路径     *column：对方的对象对应的中间表中的外键名称。        --> <many-to-many class="com.itzheng.hibernate.domain.Role" column="role_id"/> </set> </class> </hibernate-mapping> 

Role.hbm.xml

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "https://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <hibernate-mapping> <class name="com.itzheng.hibernate.domain.Role" table="sys_role"> <!-- 建立IOD与主键的映射 --> <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"/> <!--      key 标签的：     column:当前的对象对应中间表的外键的名称。     --> <set name="users" table="sys_user_role"> <!--      key 标签的：      column:当前的对象对应中间表的外键的名称。     --> <key column="role_id"/> <!--      many-to-many 标签：     *class :对象的类的全路径     *column：对方的对象对应的中间表中的外键名称。        --> <many-to-many class="com.itzheng.hibernate.domain.User" column="user_id"/> </set> </class> </hibernate-mapping> 

5、将映射添加到核心配置文件

在hibernate.cfg.xml

二、编写测试类

直接执行下面代码会报错

package com.itzheng.hibernate.demo2; import org.hibernate.Session; import org.hibernate.Transaction; import org.junit.Test; import com.itzheng.hibernate.domain.Role; import com.itzheng.hibernate.domain.User; import com.itzheng.hibernate.utils.HibernateUtils; /*  * Hibernate的多对多的映射  */ public class HibernateDemo2 { @Test /*   * 保存多条记录：保存多个用户和角色   */ public void demo01() {   Session session = HibernateUtils.getCurrentSession();   Transaction transaction = session.beginTransaction(); // 创建2个用户   User user1 = new User();   user1.setUser_name("李白");   User user2 = new User();   user2.setUser_name("杜甫"); // 创建3个角色   Role role1 = new Role();   role1.setRole_name("研发部");   Role role2 = new Role();   role2.setRole_name("市场部");   Role role3 = new Role();   role3.setRole_name("公关部"); // 设置双向的关联关系,获取到对应的集合将对象添加进去,用户和角色相互对应   user1.getRoles().add(role1);   user1.getRoles().add(role2);   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(); } } 

报主键重混异常

需要被动方放弃外键维护权，这里是在角色的一方放弃外键维护权
在Role.hbm.xml当中的set集合当中

设置完后执行
成功执行

三、Hibernate多对多的一些操作

1、多对多的情况下在不设置级联的情况下，只保存一边会报错

（1）值保存用户（测试代码）

@Test /*   * 多对多的一些操作 只是保存一边是否可以，答案在不设置级联的情况下会报，瞬时对象异常   */ public void demo02() {   Session session = HibernateUtils.getCurrentSession();   Transaction transaction = session.beginTransaction(); // 创建2个用户   User user1 = new User();   user1.setUser_name("李白"); // 创建3个角色   Role role1 = new Role();   role1.setRole_name("研发部");   Role role2 = new Role();   role2.setRole_name("市场部");   Role role3 = new Role();   role3.setRole_name("公关部"); // 设置双向的关联关系,获取到对应的集合将对象添加进去,用户和角色相互对应   user1.getRoles().add(role1);   role1.getUsers().add(user1); // 只保存角色   session.save(user1);   transaction.commit(); } 

（2）只保存角色，因为Role放弃了外键维护权，保存角色的时候，不影用户，所以不会报错（但是因为在核心配置文件当中是create从新建表，所以用户表会被置空）

@Test /*   * 多对多的一些操作 只是保存一边是否可以，答案在不设置级联的情况下会报，瞬时对象异常   */ public void demo02() {   Session session = HibernateUtils.getCurrentSession();   Transaction transaction = session.beginTransaction(); // 创建2个用户   User user1 = new User();   user1.setUser_name("李白"); // 创建3个角色   Role role1 = new Role();   role1.setRole_name("研发部");   Role role2 = new Role();   role2.setRole_name("市场部");   Role role3 = new Role();   role3.setRole_name("公关部"); // 设置双向的关联关系,获取到对应的集合将对象添加进去,用户和角色相互对应   user1.getRoles().add(role1);   role1.getUsers().add(user1); // 只保存用户 //session.save(user1); //只保存角色   session.save(role1);   transaction.commit(); } 

2、多对多的级联保存或者更新

（1） 保存用户，级联保存角色。在用户的映射文件当中配置。
在User.hbm.xml中的set当中配置cascade=“save-update”

这是只保存User的时候

@Test /*   * 多对多的一个级联保存   * 保存用户，级联保存角色。在用户的映射文件当中配置。   */ public void demo03() {   Session session = HibernateUtils.getCurrentSession();   Transaction transaction = session.beginTransaction(); // 创建2个用户   User user1 = new User();   user1.setUser_name("李白"); // 创建3个角色   Role role1 = new Role();   role1.setRole_name("研发部");   Role role2 = new Role();   role2.setRole_name("市场部");   Role role3 = new Role();   role3.setRole_name("公关部"); // 设置双向的关联关系,获取到对应的集合将对象添加进去,用户和角色相互对应   user1.getRoles().add(role1);   role1.getUsers().add(user1); // 只保存用户   session.save(user1); // 只保存角色 //session.save(role1);   transaction.commit(); } 

成功执行并插入了数据（一号用户选择了一号角色）

多对多的一个级联保存
（2） 保存角色去，级联保存用户。在角色的映射文件当中配置。
在Role.hbm.xml当中

@Test /*   * 多对多的一个级联保存   * 保存角色去，级联保存用户。在角色的映射文件当中配置。   */ public void demo04() {    Session session = HibernateUtils.getCurrentSession();   Transaction transaction = session.beginTransaction(); // 创建2个用户    User user1 = new User();   user1.setUser_name("李白"); // 创建3个角色    Role role1 = new Role();   role1.setRole_name("研发部");    Role role2 = new Role();   role2.setRole_name("市场部");    Role role3 = new Role();   role3.setRole_name("公关部"); // 设置双向的关联关系,获取到对应的集合将对象添加进去,用户和角色相互对应   user1.getRoles().add(role1);   role1.getUsers().add(user1); // 只保存用户 //session.save(role1); // 只保存角色   session.save(role1);   transaction.commit(); } 

3、多对多的级联删除（基本不用）

中间表

（1）测试级联删除的功能，当中删除用户的时候级联删除角色
在User.hbm.xml当中配置

更改核心配置文件当中的hibernate.cfg.xml

执行下列代码

 @Test /*   * 多对多的一个级联删除 删除用户级联删除角色，    * 在User.hbm.xml中的set上配置cascade="delete"   */ public void demo05() {   Session session = HibernateUtils.getCurrentSession();   Transaction transaction = session.beginTransaction(); // 先查询1号用户   User user = session.get(User.class, 1l); //删除对应的用户    session.delete(user);   transaction.commit(); } 

级联删除

（2）删除角色级联删除用户
在Role.hbm.xml中的set上配置cascade=“delete”

执行下面代码

@Test /*   * 多对多的一个级联删除    * 删除角色级联删除用户   * 在Role.hbm.xml中的set上配置cascade="delete"   */ public void demo06() {    Session session = HibernateUtils.getCurrentSession();   Transaction transaction = session.beginTransaction(); // 先查询2号角色   Role role = session.get(Role.class, 2l); //删除对应的角色，级联删除用户    session.delete(role);    transaction.commit(); } 

4、多对多的其他操作

（1）给用户选择角色

a、更改核心配置文件

b、运行下面代码创建用户表和角色表

@Test /*   * 保存多条记录：保存多个用户和角色   */ public void demo01() {   Session session = HibernateUtils.getCurrentSession();   Transaction transaction = session.beginTransaction(); // 创建2个用户   User user1 = new User();   user1.setUser_name("李白");   User user2 = new User();   user2.setUser_name("杜甫"); // 创建3个角色   Role role1 = new Role();   role1.setRole_name("研发部");   Role role2 = new Role();   role2.setRole_name("市场部");   Role role3 = new Role();   role3.setRole_name("公关部"); // 设置双向的关联关系,获取到对应的集合将对象添加进去,用户和角色相互对应   user1.getRoles().add(role1);   user1.getRoles().add(role2);   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(); } 

c、给一号用户选择二号角色
角色放弃关联外键的维护由

创建好表之后，更改核心配置文件当中

一号用户选择到二号角色
user.getRoles().add(role);//将二号角色添加到1号用户的集合当中，就相党与用户获取到角色

@Test /*   * 给用户选择角色   */ public void demo07() {   Session session = HibernateUtils.getCurrentSession();   Transaction transaction = session.beginTransaction(); // 给1号用户多选二号角色 //查询1号用户   User user = session.get(User.class, 1l); // 查询2号角色   Role role = session.get(Role.class, 2l); //一号用户选择到二号角色   user.getRoles().add(role);//将二号角色添加到1号用户的集合当中，就相党与用户获取到角色   transaction.commit(); } 

（2）给用户改选角色

给2号用户将原有的二号角色改为3号角色
查询2号用户

@Test /*   * 给用户改选角色   */ public void demo08() {    Session session = HibernateUtils.getCurrentSession();   Transaction transaction = session.beginTransaction(); // 给2号用户将原有的二号角色改为3号角色 // 查询2号用户   User user = session.get(User.class, 2l);   Role role2 = session.get(Role.class, 2l);   Role role3 = session.get(Role.class, 3l);    user.getRoles().remove(role2);// 将集合当中原有的二号角色删除   user.getRoles().add(role3);//然后将3号用户添加到对应的集合当中    transaction.commit(); } 

（3）给用户删除角色

删除角色
给二号用户删除1号角色

@Test /*   * 删除角色   * 给二号用户删除1号角色   */ public void demo09() {    Session session = HibernateUtils.getCurrentSession();   Transaction transaction = session.beginTransaction(); // 给2号用户删除1号角色 // 查询2号用户   User user = session.get(User.class, 2l);   Role role1 = session.get(Role.class, 1l);    user.getRoles().remove(role1);// 将集合当中原有的1号角色删除    transaction.commit(); }