本文共 13646 字，大约阅读时间需要 45 分钟。

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）

   
   	
    		
     		
     
      com.mysql.jdbc.Driver
     		
     
      jdbc:mysql:///hibernate_day03
     		
     
      root
     		
     
      root
     		
     		
     
      org.hibernate.dialect.MySQLDialect
     		
     		
     		
     
      true
     		
     		
     
      true
     		
     		
     
      create
     		
     		
     
      org.hibernate.connection.C3P0ConnectionProvider
     		
     		
     
      5
     		
     		
     
      20
     		
     		
     
      120
     		
     		
     
      3000
     		
     		
     
      4
     		
     		
     
      thread
     		
     		
     		
     	
    
   

（3）log4j.properties

### direct log messages to stdout ###log4j.appender.stdout=org.apache.log4j.ConsoleAppenderlog4j.appender.stdout.Target=System.errlog4j.appender.stdout.layout=org.apache.log4j.PatternLayoutlog4j.appender.stdout.layout.ConversionPattern=%d{
   ABSOLUTE} %5p %c{
   1}:%L - %m%n### direct messages to file mylog.log ###log4j.appender.file=org.apache.log4j.FileAppenderlog4j.appender.file.File=c\:mylog.loglog4j.appender.file.layout=org.apache.log4j.PatternLayoutlog4j.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 tracelog4j.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

Role.hbm.xml

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

转载地址：https://code100.blog.csdn.net/article/details/106187775 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！