Hibernate学习第三天（2）（多对多关系映射）

 

 

 

 

 

 

1.1.1      Hibernate多对多关系的配置

1.1.1.1   创建表

l   用户表

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;

　　

l  角色表

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;

　　

l  中间表

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;

1.1.1.1   创建映射 

用户的映射

角色映射：

数据库关系图如下：

中间表的两个字段分别为多对多的两个表的外键

核心配置文件引入映射：

 编写测试类：

此时配置文件未设置级联 执行报错：

 提示id重复 是因为多对多不和一对多一样 中间表会生成两次数据 主键重复。

所以在role里配置放弃主键维护权。此时可以存入数据 。

注意： 如果是单向关联 是可以不配置放弃主键维护权的。

 

不可以，瞬时对象异常

 还是需要使用级联操作 cascade

1.1.1.1   多对多的级联保存或更新

l  1 保存用户级联保存角色

 * 在Role.hbm.xml中的set上配置 cascade="save-update"  

注意：inverse=true这配置也要同时交给user 因为此时保存的主体时role 主键维护权必须有role来维护

role：

 user：

执行demo1 初始化数据后进行下面操作：

注意：修改数据库创建方式为update

 会把一号用户及其所对应的角色删除。中间表也会删除。注意级联的角色只级联于此用户。

1.1.1.1   多对多的其他的操作

l  给用户选择角色

执行demo1 初始化数据

结果1：

结果2：

l  给用户删除角色

 代码：

domain和工具类略；

demo2：

package com.hibernate.demo2;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import com.hibernate.domain.Role;
import com.hibernate.domain.User;
import com.hibernate.utils.HibernateUtils;



/**
 * Hibernate的多对多的映射
 * @author jt
 *
 */
public class TestDemo2 {

	@Test
	/**
	 * 保存多条记录：保存多个用户和角色
	 */
	public void demo1(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = 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); //1-1
		user1.getRoles().add(role2); //1-2
		user2.getRoles().add(role2); //2-2
		user2.getRoles().add(role3); //2-3
		// 设置双向的关联关系:
		role1.getUsers().add(user1); //1-1
		role2.getUsers().add(user1); //2-1
		role2.getUsers().add(user2); //2-2
		role3.getUsers().add(user2); //3-2
		// 保存操作:多对多建立了双向的关系必须有一方放弃外键维护。
		// 一般是被动方放弃外键维护权。
		session.save(user1);
		session.save(user2);
		session.save(role1);
		session.save(role2);
		session.save(role3);
		
		tx.commit();
	}
	
	@Test
	/**
	 * 多对多的操作：
	 * * 只保存一边是否可以？不可以，瞬时对象异常
	 */
	public void demo2(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
		// 创建个用户
		User user1 = new User();
		user1.setUser_name("赵洪");
		
		// 创建个角色
		Role role1 = new Role();
		role1.setRole_name("研发部");
		
		// 设置双向的关联关系:
		user1.getRoles().add(role1);
		role1.getUsers().add(user1);
		// 只保存用户：
		 session.save(user1);
//		session.save(role1);
		
		tx.commit();
	}
	
	@Test
	/**
	 * 多对多的级联保存：
	 * * 保存用户级联保存角色。在用户的映射文件中配置。
	 * * 在User.hbm.xml中的set上配置 cascade="save-update"
	 */
	public void demo3(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
		// 创建2个用户
		User user1 = new User();
		user1.setUser_name("赵洪");
		
		// 创建3个角色
		Role role1 = new Role();
		role1.setRole_name("研发部");
		
		// 设置双向的关联关系:
		user1.getRoles().add(role1);
		role1.getUsers().add(user1);
		// 只保存用户：
		session.save(user1);
		
		tx.commit();
	}
	
	/**
	 * 多对多的级联保存：
	 * * 保存角色级联保存用户。在角色的映射文件中配置。
	 * * 在Role.hbm.xml中的set上配置 cascade="save-update"
	 */
	@Test
	public void demo4(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
		// 创建2个用户
		User user1 = new User();
		user1.setUser_name("李兵");
		
		// 创建3个角色
		Role role1 = new Role();
		role1.setRole_name("公关部");
		
		// 设置双向的关联关系:
		user1.getRoles().add(role1);
		role1.getUsers().add(user1);
		// 只保存用户：
		session.save(role1);
		
		tx.commit();
	}
	
	/**
	 * 多对多的级联删除(基本用不上)：
	 * * 删除用户级联删除角色
	 * * 在User.hbm.xml中的set上配置 cascade="delete"
	 */
	@Test
	public void demo5(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
		// 查询1号用户:
		User user  = session.get(User.class, 1l);
		session.delete(user);
		
		tx.commit();
	}
	
	/**
	 * 多对多的级联删除：
	 * * 删除角色级联删除用户
	 * * 在Role.hbm.xml中的set上配置 cascade="delete"
	 */
	@Test
	public void demo6(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
		// 查询2号角色:
		Role role  = session.get(Role.class, 2l);
		session.delete(role);
		
		tx.commit();
	}
	
	@Test
	/**
	 * 给用户选择角色
	 */
	public void demo7(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
		// 给1号用户多选2号角色
		// 查询1号用户
		User user  = session.get(User.class, 1l);
		// 查询2号角色
		Role role = session.get(Role.class, 2l);
		user.getRoles().add(role);
		
		tx.commit();
	}
	
	@Test
	/**
	 * 给用户改选角色
	 */
	public void demo8(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
		// 给2号用户将原有的2号角色改为3号角色
		// 查询2号用户
		User user  = session.get(User.class, 2l);
		// 查询2号角色
		Role role2 = session.get(Role.class, 2l);
		Role role3 = session.get(Role.class, 3l);
		user.getRoles().remove(role2);
		user.getRoles().add(role3);
		
		tx.commit();
	}
	
	@Test
	/**
	 * 给用户改选角色
	 */
	public void demo9(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
		// 给2号用户删除1号角色
		// 查询2号用户
		User user  = session.get(User.class, 2l);
		// 查询2号角色
		Role role = session.get(Role.class, 1l);
		user.getRoles().remove(role);
		
		tx.commit();
	}
}

　映射配置文件：

<?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.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" cascade="save-update,delete" >
			<!-- key标签：* column	：当前的对象对应中间表的外键的名称。 -->
			<key column="user_id"/>
			<!-- 
				many-to-many标签：
					* class		：对方的类的全路径
					* column	：对方的对象在中间表中的外键的名称。
			 -->
			<many-to-many class="com.hibernate.domain.Role" column="role_id"/>
		</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.hibernate.domain.Role" table="sys_role">
		<!-- 建立OID与主键的映射 -->
		<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		：对方的集合的属性名称。
				* table		：多对多的关系需要使用中间表，放的是中间表的名称。
		 -->
		<set name="users" table="sys_user_role" cascade="save-update,delete" inverse="true">
			<!-- 
				key标签：
					* column	：当前的对象对应中间表的外键的名称。
			 -->
			<key column="role_id"/>
			<!-- 
				many-to-many标签：
					* class		：对方的类的全路径
					* column	：对方的对象在中间表中的外键的名称。
			 -->
			<many-to-many class="com.hibernate.domain.User" column="user_id"/>
		</set>
	</class>
</hibernate-mapping>

　

<?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:///hibernate3</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">update</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.isolation">4</property>
		<!-- 配置当前线程绑定的Session -->
		<property name="hibernate.current_session_context_class">thread</property>
		
		<!-- 引入映射 -->
		<mapping resource="com/hibernate/domain/Customer.hbm.xml"/>
		<mapping resource="com/hibernate/domain/LinkMan.hbm.xml"/>
		<mapping resource="com/hibernate/domain/User.hbm.xml"/>
		<mapping resource="com/hibernate/domain/Role.hbm.xml"/>
	</session-factory>
</hibernate-configuration>

　　

代码只代表最终代码 无演进过程。注意！！！！！