Hibernate多对多操作
---------------------siwuxie095
Hibernate 多对多操作
以用户和角色为例
（一）多对多映射配置
第一步：创建两个实体类，用户和角色
第二步：让两个实体类之间互相表示
（1）在用户实体类中表示多个角色
（2）在角色实体类中表示多个用户
第三步：配置映射关系
（1）配置基本的映射
（2）配置关联关系的映射（多对多关系）
1）在用户的映射配置文件中，表示所有角色
2）在角色的映射配置文件中，表示所有用户
第四步：在核心配置文件中引入映射配置文件
（二）多对多级联保存
如：添加两个用户，为每个用户添加两个角色
（1）复杂写法
先在角色的映射配置文件中的 set 标签添加 inverse 属性，并
将其值设置为 true，再进行具体实现
|
/** * 多对多级联保存的复杂写法 * * * 手动加上 @Test 以进行单元测试（将自动导入 JUnit 4 的 jar 包） * * 选中方法名，右键->Run As->JUint Test */ @Test public void testSave(){
SessionFactory sessionFactory=null; Session session=null; Transaction tx=null;
try { //得到 SessionFactory 对象 sessionFactory=HibernateUtils.getSessionFactory(); //创建 Session 对象 session=sessionFactory.openSession(); //开启事务 tx=session.beginTransaction();
//添加两个用户，为每个用户添加两个角色
//(1) //创建用户和角色对象 User user1=new User(); user1.setUserName("小白"); user1.setUserPassword("8888");
User user2=new User(); user2.setUserName("小黑"); user2.setUserPassword("4444");
Role role1=new Role(); role1.setRoleName("保镖"); role1.setRoleMemo("强大的保镖");
Role role2=new Role(); role2.setRoleName("秘书"); role2.setRoleMemo("漂亮的秘书");
Role role3=new Role(); role3.setRoleName("司机"); role3.setRoleMemo("称职的司机");
//(2) //建立用户和角色对象的关系 // //在用户实体类中表示角色，在角色实体类中表示用户 // //具体： //把角色对象放到用户对象的 Set 集合中 //把用户对象放到角色对象的 Set 集合中 // //user1 --- role1 / role2 //user2 --- role1 / role3 // //注意：如果建立了双向的关系，一定要有一方放弃外 //键维护权。如下 user1.getRoleSet().add(role1); user1.getRoleSet().add(role2); user2.getRoleSet().add(role1); user2.getRoleSet().add(role3);
role1.getUserSet().add(user1); role1.getUserSet().add(user2); role2.getUserSet().add(user1); role3.getUserSet().add(user2);
//(3)保存到数据库（级联保存） session.save(user1); session.save(user2); session.save(role1); session.save(role2); session.save(role3);
/* * 由于是多对多且进行了双向关联，所以一定要有一方 * 放弃外键维护权，否则将无法保存到数据库中 * * 一般由被动方放弃外键维护权，这里角色是被动方 * * 具体做法： * * 在角色的映射配置文件中的 set 标签中添加 inverse * 属性，并将其值设置为 true */
//提交事务 tx.commit(); } catch (Exception e) { //回滚事务 tx.rollback(); } finally { //关闭资源 session.close(); sessionFactory.close(); } } |
（2）简化写法
先在用户的映射配置文件中的 set 标签添加 cascade 属性，并
将其值设置为 save-update，再进行具体实现
|
/** * 多对多级联保存的简化写法 * * 在用户的映射配置文件中的 set 标签 * 添加 cascade 属性，并将其值设置为 * save-update */ @Test public void testSaveX(){
SessionFactory sessionFactory=null; Session session=null; Transaction tx=null;
try { //得到 SessionFactory 对象 sessionFactory=HibernateUtils.getSessionFactory(); //创建 Session 对象 session=sessionFactory.openSession(); //开启事务 tx=session.beginTransaction();
//添加两个用户，为每个用户添加两个角色
//(1) //创建用户和角色对象 User user1=new User(); user1.setUserName("小白"); user1.setUserPassword("8888");
User user2=new User(); user2.setUserName("小黑"); user2.setUserPassword("4444");
Role role1=new Role(); role1.setRoleName("保镖"); role1.setRoleMemo("强大的保镖");
Role role2=new Role(); role2.setRoleName("秘书"); role2.setRoleMemo("漂亮的秘书");
Role role3=new Role(); role3.setRoleName("司机"); role3.setRoleMemo("称职的司机");
//(2) //建立用户和角色对象的关系 // //在用户实体类中表示角色 // //具体： //把角色对象放到用户对象的 Set 集合中 // //user1 --- role1 / role2 //user2 --- role1 / role3 user1.getRoleSet().add(role1); user1.getRoleSet().add(role2); user2.getRoleSet().add(role1); user2.getRoleSet().add(role3);
//(3)保存到数据库（级联保存） session.save(user1); session.save(user2);
//提交事务 tx.commit(); } catch (Exception e) { //回滚事务 tx.rollback(); } finally { //关闭资源 session.close(); sessionFactory.close(); } } |
（三）多对多级联删除（一般不使用，仅作了解）
如：删除某个用户
先在用户的映射配置文件中的 set 标签添加 cascade 属性，并
将其值设置为 delete，再进行具体实现
|
/** * 多对多级联删除 * * 简化写法：在用户的映射配置文件中的 set 标签 * 添加 cascade 属性，并将其值设置为 delete */ @Test public void testDelete(){
SessionFactory sessionFactory=null; Session session=null; Transaction tx=null;
try { //得到 SessionFactory 对象 sessionFactory=HibernateUtils.getSessionFactory(); //创建 Session 对象 session=sessionFactory.openSession(); //开启事务 tx=session.beginTransaction();
//(1) //通过 id 查询用户对象 User user=session.get(User.class, 1);
//(2) //调用 Session 的 delete() 方法实现级联删除 session.delete(user);
//多对多级联删除，一般不使用，仅作了解即可 // //注意：此时角色的映射配置文件中的 set 标签 //不能将 inverse 属性设为 true，否则将无法 //删除 // //另外：set 标签也不能将 cascade 属性设为 //delete，否则 testSaveX() 方法保存的数据 //将全部删除
//提交事务 tx.commit(); } catch (Exception e) { //回滚事务 tx.rollback(); } finally { //关闭资源 session.close(); sessionFactory.close(); } } |
（四）维护第三张表
通过第三张表来维护多对多关系
如：让某个用户有某个角色
第一步：根据 id 查询用户和角色
第二步：把角色对象放到用户对象的 Set 集合中
再如：让某个用户没有某个角色
第一步：根据 id 查询用户和角色
第二步：从用户对象的 Set 集合中移除角色对象
|
/** * 维护第三张表 */ @Test public void testTable(){
SessionFactory sessionFactory=null; Session session=null; Transaction tx=null;
try { //得到 SessionFactory 对象 sessionFactory=HibernateUtils.getSessionFactory(); //创建 Session 对象 session=sessionFactory.openSession(); //开启事务 tx=session.beginTransaction();
//让某个用户有某个角色
//(1)根据 id 查询用户对象和角色对象 User user=session.get(User.class, 1); Role role=session.get(Role.class, 3);
//(2)把角色对象放到用户对象的 Set 集合中 user.getRoleSet().add(role);
//让某个用户没有某个角色
//(1)根据 id 查询用户对象和角色对象 User userx=session.get(User.class, 1); Role rolex=session.get(Role.class, 1);
//(2)从用户对象的 Set 集合中移除角色对象 userx.getRoleSet().remove(rolex);
//提交事务 tx.commit(); } catch (Exception e) { //回滚事务 tx.rollback(); } finally { //关闭资源 session.close(); sessionFactory.close(); } } |
工程结构目录如下：
HibernateUtils.java：
|
package com.siwuxie095.utils;
import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.cfg.Configuration;
public class HibernateUtils {
static Configuration cfg=null; static SessionFactory sessionFactory=null;
//或：加上 private final 亦可，不过此时不能等于 null // private static final Configuration cfg; // private static final SessionFactory sessionFactory;
//静态代码块 static { //加载核心配置文件 cfg=new Configuration(); cfg.configure(); sessionFactory=cfg.buildSessionFactory();
}
//提供方法返回 sessionFactory public static SessionFactory getSessionFactory() { return sessionFactory; }
//提供方法返回与本地线程绑定的 Session public static Session getCurrentSession() { return sessionFactory.getCurrentSession(); }
} |
User.java：
|
package com.siwuxie095.entity;
import java.util.HashSet; import java.util.Set;
//用户实体类 public class User {
private Integer uid; //用户 id private String userName; //用户名称 private String userPassword; //用户密码
//在用户实体类中表示多个角色，即一个用户可以有多个角色 // //Hibernate 中要求使用 Set 集合表示"多"的数据 private Set<Role> roleSet=new HashSet<Role>();
public Set<Role> getRoleSet() { return roleSet; } public void setRoleSet(Set<Role> roleSet) { this.roleSet = roleSet; }
public Integer getUid() { return uid; } public void setUid(Integer uid) { this.uid = uid; }
public String getUserName() { return userName; } public void setUserName(String userName) { this.userName = userName; }
public String getUserPassword() { return userPassword; } public void setUserPassword(String userPassword) { this.userPassword = userPassword; }
} |
Role.java：
|
package com.siwuxie095.entity;
import java.util.HashSet; import java.util.Set;
//角色实体类 public class Role {
private Integer rid; //角色 id private String roleName; //角色名称 private String roleMemo; //角色描述
//在角色实体类中表示多个用户，即一个角色可以有多个用户 // //Hibernate 中要求使用 Set 集合表示"多"的数据 private Set<User> userSet=new HashSet<User>();
public Set<User> getUserSet() { return userSet; } public void setUserSet(Set<User> userSet) { this.userSet = userSet; }
public Integer getRid() { return rid; } public void setRid(Integer rid) { this.rid = rid; }
public String getRoleName() { return roleName; } public void setRoleName(String roleName) { this.roleName = roleName; }
public String getRoleMemo() { return roleMemo; } public void setRoleMemo(String roleMemo) { this.roleMemo = roleMemo; }
} |
HibernateManyToMany.java：
|
package com.siwuxie095.hibernatetest;
import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.Transaction; import org.junit.Test;
import com.siwuxie095.entity.Role; import com.siwuxie095.entity.User; import com.siwuxie095.utils.HibernateUtils;
//多对多操作 public class HibernateManyToMany {
/** * 多对多级联保存的复杂写法 * * * 手动加上 @Test 以进行单元测试（将自动导入 JUnit 4 的 jar 包） * * 选中方法名，右键->Run As->JUint Test */ @Test public void testSave(){
SessionFactory sessionFactory=null; Session session=null; Transaction tx=null;
try { //得到 SessionFactory 对象 sessionFactory=HibernateUtils.getSessionFactory(); //创建 Session 对象 session=sessionFactory.openSession(); //开启事务 tx=session.beginTransaction();
//添加两个用户，为每个用户添加两个角色
//(1) //创建用户和角色对象 User user1=new User(); user1.setUserName("小白"); user1.setUserPassword("8888");
User user2=new User(); user2.setUserName("小黑"); user2.setUserPassword("4444");
Role role1=new Role(); role1.setRoleName("保镖"); role1.setRoleMemo("强大的保镖");
Role role2=new Role(); role2.setRoleName("秘书"); role2.setRoleMemo("漂亮的秘书");
Role role3=new Role(); role3.setRoleName("司机"); role3.setRoleMemo("称职的司机");
//(2) //建立用户和角色对象的关系 // //在用户实体类中表示角色，在角色实体类中表示用户 // //具体： //把角色对象放到用户对象的 Set 集合中 //把用户对象放到角色对象的 Set 集合中 // //user1 --- role1 / role2 //user2 --- role1 / role3 // //注意：如果建立了双向的关系，一定要有一方放弃外 //键维护权。如下 user1.getRoleSet().add(role1); user1.getRoleSet().add(role2); user2.getRoleSet().add(role1); user2.getRoleSet().add(role3);
role1.getUserSet().add(user1); role1.getUserSet().add(user2); role2.getUserSet().add(user1); role3.getUserSet().add(user2);
//(3)保存到数据库（级联保存） session.save(user1); session.save(user2); session.save(role1); session.save(role2); session.save(role3);
/* * 由于是多对多且进行了双向关联，所以一定要有一方 * 放弃外键维护权，否则将无法保存到数据库中 * * 一般由被动方放弃外键维护权，这里角色是被动方 * * 具体做法： * * 在角色的映射配置文件中的 set 标签中添加 inverse * 属性，并将其值设置为 true */
//提交事务 tx.commit(); } catch (Exception e) { //回滚事务 tx.rollback(); } finally { //关闭资源 session.close(); sessionFactory.close(); } }
/** * 多对多级联保存的简化写法 * * 在用户的映射配置文件中的 set 标签 * 添加 cascade 属性，并将其值设置为 * save-update */ @Test public void testSaveX(){
SessionFactory sessionFactory=null; Session session=null; Transaction tx=null;
try { //得到 SessionFactory 对象 sessionFactory=HibernateUtils.getSessionFactory(); //创建 Session 对象 session=sessionFactory.openSession(); //开启事务 tx=session.beginTransaction();
//添加两个用户，为每个用户添加两个角色
//(1) //创建用户和角色对象 User user1=new User(); user1.setUserName("小白"); user1.setUserPassword("8888");
User user2=new User(); user2.setUserName("小黑"); user2.setUserPassword("4444");
Role role1=new Role(); role1.setRoleName("保镖"); role1.setRoleMemo("强大的保镖");
Role role2=new Role(); role2.setRoleName("秘书"); role2.setRoleMemo("漂亮的秘书");
Role role3=new Role(); role3.setRoleName("司机"); role3.setRoleMemo("称职的司机");
//(2) //建立用户和角色对象的关系 // //在用户实体类中表示角色 // //具体： //把角色对象放到用户对象的 Set 集合中 // //user1 --- role1 / role2 //user2 --- role1 / role3 user1.getRoleSet().add(role1); user1.getRoleSet().add(role2); user2.getRoleSet().add(role1); user2.getRoleSet().add(role3);
//(3)保存到数据库（级联保存） session.save(user1); session.save(user2);
//提交事务 tx.commit(); } catch (Exception e) { //回滚事务 tx.rollback(); } finally { //关闭资源 session.close(); sessionFactory.close(); } }
/** * 多对多级联删除 * * 简化写法：在用户的映射配置文件中的 set 标签 * 添加 cascade 属性，并将其值设置为 delete */ @Test public void testDelete(){
SessionFactory sessionFactory=null; Session session=null; Transaction tx=null;
try { //得到 SessionFactory 对象 sessionFactory=HibernateUtils.getSessionFactory(); //创建 Session 对象 session=sessionFactory.openSession(); //开启事务 tx=session.beginTransaction();
//(1) //通过 id 查询用户对象 User user=session.get(User.class, 1);
//(2) //调用 Session 的 delete() 方法实现级联删除 session.delete(user);
//多对多级联删除，一般不使用，仅作了解即可 // //注意：此时角色的映射配置文件中的 set 标签 //不能将 inverse 属性设为 true，否则将无法 //删除 // //另外：set 标签也不能将 cascade 属性设为 //delete，否则 testSaveX() 方法保存的数据 //将全部删除
//提交事务 tx.commit(); } catch (Exception e) { //回滚事务 tx.rollback(); } finally { //关闭资源 session.close(); sessionFactory.close(); } }
/** * 维护第三张表 */ @Test public void testTable(){
SessionFactory sessionFactory=null; Session session=null; Transaction tx=null;
try { //得到 SessionFactory 对象 sessionFactory=HibernateUtils.getSessionFactory(); //创建 Session 对象 session=sessionFactory.openSession(); //开启事务 tx=session.beginTransaction();
//让某个用户有某个角色
//(1)根据 id 查询用户对象和角色对象 User user=session.get(User.class, 1); Role role=session.get(Role.class, 3);
//(2)把角色对象放到用户对象的 Set 集合中 user.getRoleSet().add(role);
//让某个用户没有某个角色
//(1)根据 id 查询用户对象和角色对象 User userx=session.get(User.class, 1); Role rolex=session.get(Role.class, 1);
//(2)从用户对象的 Set 集合中移除角色对象 userx.getRoleSet().remove(rolex);
//提交事务 tx.commit(); } catch (Exception e) { //回滚事务 tx.rollback(); } finally { //关闭资源 session.close(); sessionFactory.close(); } } } |
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>
<!-- (1) class 标签：配置实体类和数据库表的对应； name 属性：实体类的全路径，即全限定名； table 属性：数据库表的名称（数据库表由 Hibernate 自动生成） --> <class name="com.siwuxie095.entity.User" table="t_user">
<!-- (2) id 标签：配置实体类 id 和表 id 对应（主键）； name 属性：实体类里 id 属性名称； column 属性：生成表中 id 字段名称 --> <id name="uid" column="uid"> <generator class="native"></generator> </id>
<!-- (3) property 标签：配置其它属性和表中字段对应； name 属性：实体类属性名称； column 属性：生成表中字段名称 --> <property name="userName" column="user_name"></property> <property name="userPassword" column="user_password"></property>
<!-- (4) set 标签：配置关联关系的映射（配置关联对象），代表一个 Set 集合； name 属性：关联另一方的对象的 Set 集合的名称（在用户实体类中声明）； table 属性：第三张表的名称； cascade 属性：save-update 表示级联保存，delete 表示级联删除（逗号隔开）； inverse 属性：true 表示放弃关系维护（放弃外键的维护权）（默认为 false） -->
<set name="roleSet" table="user_role" cascade="delete">
<!-- key 标签：配置当前对象（关联一方）在第三张表中的外键 column 属性：当前对象（关联一方）在第三张表中的外键名称 --> <key column="user_id"></key>
<!-- many-to-many 标签：配置实体类的多对多关联； class：关联另一方的类的全路径，即角色实体类的全限定名； column：关联的另一方在第三张表的外键名称，即角色表在第三张表中的外键名称 --> <many-to-many class="com.siwuxie095.entity.Role" column="role_id"></many-to-many> </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.siwuxie095.entity.Role" table="t_role">
<id name="rid" column="rid"> <generator class="native"></generator> </id>
<property name="roleName" column="role_name"></property> <property name="roleMemo" column="role_memo"></property>
<!-- set 标签：配置关联关系的映射（配置关联对象），代表一个 Set 集合； name 属性：关联另一方的对象的 Set 集合的名称（在角色实体类中声明）； table 属性：第三张表的名称； cascade 属性：save-update 表示级联保存，delete 表示级联删除（逗号隔开）； inverse 属性：true 表示放弃关系维护（放弃外键的维护权）（默认为 false） --> <set name="userSet" table="user_role" cascade="save-update" inverse="false">
<!-- key 标签：配置当前对象（关联一方）在第三张表中的外键 column 属性：当前对象（关联一方）在第三张表中的外键名称 --> <key column="role_id"></key>
<!-- many-to-many 标签：配置实体类的多对多关联； class：关联另一方的类的全路径，即用户实体类的全限定名； column：关联的另一方在第三张表的外键名称，即用户表在第三张表中的外键名称 --> <many-to-many class="com.siwuxie095.entity.User" column="user_id"></many-to-many> </set> </class> </hibernate-mapping> |
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> <!-- 或使用 jdbc:mysql:///hibernate_db 代替，省略 localhost:3306 --> <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_db</property> <property name="hibernate.connection.username">root</property> <property name="hibernate.connection.password">8888</property>
<!-- 第二部分：配置 Hibernate 信息（可选） -->
<!-- 输出底层 sql 语句 --> <property name="hibernate.show_sql">true</property> <!-- 输出底层 sql 语句格式 --> <property name="hibernate.format_sql">true</property> <!-- Hibernate 帮助创建表，不是自动创建，而需要配置之后。 update：如果已经有表，就更新，如果没有，就自动创建 --> <property name="hibernate.hbm2ddl.auto">update</property> <!-- 配置数据库方言，让 Hibernate 框架识别不同数据库自己特有的语句 如：在 MySQL 中实现分页的关键字 limit，只能在 MySQL 中使用，而 在 Oracle 中实现分页的关键字则是 rownum --> <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property> <!-- 配置 Session 绑定本地线程 --> <property name="hibernate.current_session_context_class">thread</property>
<!-- 第三部分：引入映射配置文件，把映射配置文件放到核心配置文件（必须） -->
<mapping resource="com/siwuxie095/entity/User.hbm.xml"/> <mapping resource="com/siwuxie095/entity/Role.hbm.xml"/>
</session-factory> </hibernate-configuration> |
【made by siwuxie095】
posted on 2017-08-07 00:07 siwuxie095 阅读(216) 评论(0) 编辑 收藏 举报
