Hibernate学习笔记（四）

最新推荐文章于 2024-11-03 10:06:51 发布

Rachel_pan

最新推荐文章于 2024-11-03 10:06:51 发布

阅读量204

点赞数 1

分类专栏： HIbernate学习笔记文章标签： hibernate 多对多关系配置

本文链接：https://blog.csdn.net/Rachel_pan/article/details/86576927

版权

HIbernate学习笔记专栏收录该内容

5 篇文章 0 订阅

订阅专栏

Hibernate的多对多关系映射

一、Hibernate的多对多关系配置

1 、创建一个项目，引入相应的 jar 包

2 、创建数据库和表

创建 hibernate_demo03 数据库

创建用户表

CREATE TABLE `sys_user` (
  `user_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '用户id',
  `user_code` varchar(32) DEFAULT NULL COMMENT '用户账号',
  `user_name` varchar(64) DEFAULT NULL COMMENT '用户名称',
  `user_password` varchar(32) DEFAULT NULL COMMENT '用户密码',
  `user_state` char(1) DEFAULT 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;

3 、创建实体类

创建 User.java

package czm.hibernate.domain;

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

import czm.hibernate.domain.Role;

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 Set<Role> getRoles() {
		return roles;
	}
	public void setRoles(Set<Role> roles) {
		this.roles = roles;
	}
	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;
	}
	
}

创建Role.java

package czm.hibernate.domain;

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

import czm.hibernate.domain.User;

public class Role {
	private Long role_id;
	private String role_name;
	private String role_memo;
	// 设置多对多关系：表示一个角色被多个用户选择----> 放置用户的集合	
	private Set<User> users = new HashSet<User>();
	
	public Set<User> getUsers() {
		return users;
	}
	public void setUsers(Set<User> users) {
		this.users = users;
	}
	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 、创建映射

用户的映射 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="czm.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="czm.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="czm.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		：多对多的关系需要使用中间表，放的是中间表的名称。
                                * inverse       ：设置放弃外键的维护权，true表示放弃
		 -->
		<set name="users" table="sys_user_role" inverse="true">
			<!-- 
				key标签：
					* column	：当前的对象对应中间表的外键的名称。
			 -->
			<key column="role_id"/>
			<!-- 
				many-to-many标签：
					* class		：对方的类的全路径
					* column	：对方的对象在中间表中的外键的名称。
			 -->
			<many-to-many class="czm.hibernate.domain.User" column="user_id"/>
		</set>
	</class>
</hibernate-mapping>

5 、创建核心配置文件

创建 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:///hibernatedemo03</property>
		<property name="hibernate.connection.username">root</property>
		<property name="hibernate.connection.password">123456</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="czm/hibernate/domain/User.hbm.xml"/>
	<mapping resource="czm/hibernate/domain/Role.hbm.xml"/>
	</session-factory>
</hibernate-configuration>

6 、编写测试类 HibernateTsetDemo

package czm.hibernate.testdemo;

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

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



public class HibernateTsetDemo {
	@Test
	/**
	 * 保存多条记录：保存多个用户和角色
	 */
	public void testdemo1(){
		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);
		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);
		
		tx.commit();
	}
}

测试结果：

用户表：

角色表：

中间表：

Hibernate多对多关系操作

完成多对多关系配置 后便可进行多对多关系的相关操作：

操作一、级联保存或更新

级联指的是，操作一个对象的时候，是否会同时操作其关联的对象。下面测试执行 保存用户 一个操作，同时保存联系人

在操作实体配置文件 User.hbm.xml 中进行配置

编写测试类

package czm.hibernate.testdemo;

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

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



public class HibernateTsetDemo {
		
	@Test
	/**
	 * 多对多的操作：
	 * 保存用户级联保存角色
	 */
	public void testdemo2(){
		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();
	}
	
}

操作二、级联删除

在操作实体配置文件 User.hbm.xml 中进行配置

编写测试类

package czm.hibernate.testdemo;

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

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



public class HibernateTsetDemo {
	
	@Test

	public void testdemo3(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
                //查询1号客户后执行级联删除
		User user = session.get(User.class, 1l);
		session.delete(user); //删除用户 ，与用户对应的角色也被删除了
		
		tx.commit();
	}
	
}

操作三、给用户选角色

package czm.hibernate.testdemo;

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

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



public class HibernateTsetDemo {
	
	@Test

	public void testdemo4(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
        //给1号用户选3号角色
		//先查询1号用户
		User user = session.get(User.class, 1l);
		//再查询3号角色
		Role role = session.get(Role.class, 3l);
		
		user.getRoles().add(role);
		
		
		tx.commit();
	}
	
}

操作三、给用户改选角色

package czm.hibernate.testdemo;

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

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



public class HibernateTsetDemo {

	@Test
	public void testdemo5(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
        //给2号用户原来选的3号角色改选为2号角色
		//先查询2号用户
		User user = session.get(User.class, 2l);
		//再查询3号角色
		Role role3 = session.get(Role.class, 3l);
		//再查询2号角色
		Role role2 = session.get(Role.class, 2l);
		
		user.getRoles().remove(role3);
		user.getRoles().add(role2);
		
		
		tx.commit();
	}
	
}

操作四、给用户删除角色

package czm.hibernate.testdemo;

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

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



public class HibernateTsetDemo {

	@Test
	public void testdemo6(){
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
                //删除2号用户的3号角色
		//先查询2号用户
		User user = session.get(User.class, 2l);
		//再查询3号角色
		Role role3 = session.get(Role.class, 3l);
	    			
		user.getRoles().remove(role3);
		
		
		tx.commit();
	}
	
}