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"
	"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>
		<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;

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;

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;

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"
    "http://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"
    "http://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;

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