多对多关系映射,老师举得例子是用户和角色。
一个用户可以有多种角色
一个角色可以分配给多个用户
单从一边看,都是一对多的关系,但是放在一起就是多对多了.看代码吧。
单向关系:user一方持有Role一方的引用
Role.java
package com.ahuzl.hibernate;
public class Role {
private int id;
private String name;
。。。省略 get set方法
}
Role.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.ahuzl.hibernate">
<class name="Role" table="t_role">
<id name="id" column="role_id">
<generator class="native"/>
</id>
<property name="name" column="role_name"/>
</class>
</hibernate-mapping>
User.java
package com.ahuzl.hibernate;
import java.util.Set;
public class User {
private int id;
private String name;
private Set role;
。。。省略 get set方法
}
User.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.ahuzl.hibernate.User" table="t_user" >
<id name="id" column="user_id">
<generator class="native"/>
</id>
<property name="name" column="user_name"/>
<set name="role" table="t_user_role">
<key column="user_id"/>
<many-to-many class="com.ahuzl.hibernate.Role" column="role_id"/>
</set>
</class>
</hibernate-mapping>
特别的地方就在这里了,table="t_user_role"会生成一个中间表,表中的字段为<set></set>
标签中配置的字段。
<key column="user_id"/> : 来自自己对象内部的属性
<many-to-many class="com.ahuzl.hibernate.Role" column="role_id"/> : 来自其他对象的属性,所以要写清楚对象的类名
保存
public class Many2ManyTest extends TestCase {
public void testSave(){
Session session = null;
try{
session = HibernateUtils.getSession();
session.beginTransaction();
//保存三个角色,技术者,reader,manager
Role role1 = new Role();
role1.setName("技術者");
session.save(role1);
Role role2 = new Role();
role2.setName("リーダー");
session.save(role2);
Role role3 = new Role();
role3.setName("マネージャ");
session.save(role3);
User user1 = new User();
user1.setName("陣野");
Set roleOfUser1 = new HashSet();
roleOfUser1.add(role1);
user1.setRole(roleOfUser1);
session.save(user1);
//保存用户,并给其分配相应的权限
User user2 = new User();
user2.setName("幸島");
Set roleOfUser2 = new HashSet();
roleOfUser2.add(role1);
roleOfUser2.add(role2);
user2.setRole(roleOfUser2);
session.save(user2);
User user3 = new User();
user3.setName("桑田");
Set roleOfUser3 = new HashSet();
roleOfUser3.add(role3);
user3.setRole(roleOfUser3);
session.save(user3);
session.getTransaction().commit();
}catch(Exception e){
e.printStackTrace();
session.getTransaction().rollback();
}finally{
if (session != null){
if (session.isOpen()){
session.close();
}
}
}
}
}
查询
public void testLoad(){
Session session = null;
try{
session = HibernateUtils.getSession();
session.beginTransaction();
User user = (User)session.get(User.class, 2);
System.out.println("userId : " + user.getId());
System.out.println("userName : " + user.getName());
//迭代输出id为2的用户的角色
Set roleOfUser = user.getRole();
Iterator it = roleOfUser.iterator();
while(it.hasNext()){
Role role = (Role)it.next();
System.out.println("user's Role : " + role.getName());
}
}catch(Exception e){
e.printStackTrace();
session.getTransaction().rollback();
}finally{
if (session != null){
if (session.isOpen()){
session.close();
}
}
}
}
双向即为:各自持有对方的引用
改变的地方不大,只在Role.java中加入了User的引用,还有在Role.hbm.xml中加入了User属性如下:
Role.java
package com.ahuzl.hibernate;
import java.util.Set;
public class Role {
private int id;
private String name;
private Set user;
...省略 get set 方法
}
Role.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.ahuzl.hibernate">
<class name="Role" table="t_role">
<id name="id" column="role_id">
<generator class="native"/>
</id>
<property name="name" column="role_name"/>
<set name="user" table="t_user_role">
<key column="role_id"></key>
<many-to-many class="User" column="user_id"/>
</set>
</class>
</hibernate-mapping>
这里<set标签的写法和单向时一样,table="t_user_role"注意要一致,还有key 和many-to-many的column,别写错就行了。
还有一点关于结果的排序,如果配置了,那么hibernate会为我们排序,升序默认或esc,降序desc
<set name="user" table="t_user_role" order-by="user_id desc">
<key column="role_id"/>
<many-to-many class="User" column="user_id"/>
</set>
如上面的配置,hibernate会在SQL中加入order by XXX desc
保存不会有任何改变,只是先保存谁都无所谓了,
查询
public class Many2ManyTest extends TestCase {
public void testLoad2(){
Session session = null;
try{
session = HibernateUtils.getSession();
session.beginTransaction();
Role role = (Role)session.load(Role.class, 1);
System.out.println("roleId : " + role.getId());
System.out.println("roleName : " + role.getName());
//迭代输出id为1的角色的用户
Set roleOfUser = role.getUser();
Iterator it = roleOfUser.iterator();
while(it.hasNext()){
User user = (User)it.next();
System.out.println("userID : " + user.getId());
System.out.println("userName: " + user.getName());
}
}catch(Exception e){
e.printStackTrace();
session.getTransaction().rollback();
}finally{
if (session != null){
if (session.isOpen()){
session.close();
}
}
}
}
}
分享到:
相关推荐
在Java的持久化框架Hibernate中,Many-to-Many关系是一种常见的数据库表之间的关联方式,它表示一个实体可以与多个其他实体进行关联,反之亦然。本文将深入探讨如何在Hibernate中处理Many-to-Many关系的级联保存、...
"Hibernate one-to-many / many-to-one关系映射"是两个基本的关系类型,用于表示实体间的关联。在这个主题中,我们将深入探讨这两种关系映射的原理、配置和实际应用。 一、一对一(one-to-one)与一对多(one-to-...
本话题主要探讨两种基本的关系映射类型:many-to-one(多对一)和one-to-many(一对多)。这两种关系映射是数据库中常见的关联类型,理解和掌握它们对于开发高质量的Java应用至关重要。 1. many-to-one关系 many-to...
在Java的持久化框架Hibernate中,Many-to-Many映射是一种常见的关系模型,它用于表示两个实体类之间多对多的关系。在这个主题中,我们将深入探讨如何使用注解来实现这种映射,以及其背后的数据库原理和实际应用。 ...
标题中的"many-to-many-for-D2D_d2d_"指的是多对多(Many-to-Many)的设备到设备(Device-to-Device, D2D)通信模式,这在无线通信领域是一个重要的研究方向。D2D通信允许移动设备之间直接交换数据,而无需通过基站...
本示例将详细讲解如何在Hibernate中实现多对多(many-to-many)的关系映射。 在数据库设计中,多对多关系是指两个实体之间存在多个关联,比如学生和课程的关系,一个学生可以选修多门课程,一门课程也可以被多个...
在现实世界的数据模型中,很多情况下存在多对多(Many-to-Many)的关系,例如学生与课程的关系,用户与角色的关系等。本教程主要讲解如何使用Hibernate来处理多对多的关联映射,尤其是基于HashMap的实现方式。 首先...
"Hibernate many-to-many"指的是Hibernate中处理多对多关联关系的一种方式。多对多关系是两个实体类之间存在的一种复杂关联,比如学生和课程之间的关系,一个学生可以选修多门课程,一门课程也可以被多个学生选修。 ...
在Java的持久化框架Hibernate中,Many-to-Many关系是一种常见的数据模型,它表示一个实体可以与多个其他实体之间存在关联,反之亦然。这篇博客文章可能会深入探讨如何在Hibernate中处理这种多对多的关系,并可能涉及...
本实例将详细讲解如何在Hibernate中实现Many-to-One关系映射,这是一种常见的数据库关联,表示一个实体可以与多个其他实体相关联。 在Many-to-One关系中,通常一个实体(如部门)可以有多个相关实体(如员工),而...
### Hibernate Many-to-One (多对一) 及 Cascade (级联) #### 一、Many-to-One(多对一) 在数据库设计中,实体之间的关系主要包括一对一、一对多、多对多等几种类型。而在ORM(对象关系映射)框架Hibernate中,...
在本文中,我们将深入探讨如何使用Hibernate来实现多对多(many-to-many)的映射关系。 首先,多对多映射关系通常涉及到两个实体类之间的关联,例如在学生选课的例子中,学生(Student)和课程(Course)之间存在多...
关联映射的本质: 将关联关系映射到数据库,所谓的...<many-to-one>会在多的一端加入一个外键,指向一的一端,这个外键是由<many-to-one> 中的column属性定义的,如果忽略了这个属性那么默认的外键与实体的属性一致
many-to-one 配置详解 讲的很清楚 适合新手 值得下载
@ graphile-contrib / pg-many-to-many 该Graphile Engine插件添加了用于多对多关系的连接字段。 需要postgraphile@^4.5.0或graphile-build-pg@^4.5.0 例子: { allPeople { nodes { personName # :backhand_index_...
$ rails new many - to - many $ cd many - to - many $ bundle install $ rails server $ rails generate scaffold Staff full_name : string position : string $ rails generate scaffold Client full_name : ...
Hibernate中many-to-one关系的编写_远航的水手
本示例项目"Hibernate-Many-to-many-Relationship-in-Spring-MVC"着重展示了如何实现多对多(Many-to-Many)关联,这是一种复杂但常见的数据模型关系。在这个项目中,我们将深入探讨以下知识点: 1. **多对多关系**...
#### 一、多对一关联(Many-to-One) 在本章中,我们将探讨如何在 Hibernate 中处理多对一关联。这种关联类型非常常见,在许多应用中都会遇到。例如,在一个在线书店应用中,每本书都与一个出版商关联,而一个出版...
Hibernate中many-to-one关系的编写_远航的水手.htm