【Hibernate步步为营】--多对多映射具体解释

上篇文章具体讨论了一对多映射，在一对多映射中单向的关联映射会有非常多问题，所以不建议使用假设非要採用一对多的映射的话能够考虑使用双向关联来优化之间的关系，一对多的映射事实上质上是在一的一端使用<many-to-one>标签来标明它们之间的关系，另外还须要在一的一端的对象中使用set标明集合映射。

一、单向多对多

仍然依照前几篇的文章格式来讨论。首先来看对象之间的关系，单向的多对多关系是两个对象之间发生的，比方在人和职位之间，一个人能够有多个职位，并且一个职位也能够由多人来负责，所以它们之间就形成了多对多的关系，另外这样的单向性是指仅仅能在一端来查询获取还有一端的内容。

另外由于是多对多之间的关系，所以在生成关系模型时会生成对象之间的关联表。实际它们之间的关系的是关联表，详细的对象模型例如以下：

上面已经说过多对多的关系会生成一个关联表。在关联表中来维护之间的关系。所以相应的关系模型中会有一个关系表，这个关系表中存放着两个关系表的主键，而且关系表的主键是另外两张表的主键的组合。例如以下图：

1.1、映射

上面的关系模型中会生成一个关系表。所以在映射中要编写相应的属性，由于是单向的关联关系所以基本的映射关系是在映射的原方向加入的，相应的上面的关系模型上就是在T_user中加入多对多映射的关系。

1.1.1 User.hbm.xml

文件里要使用<many-to-many>标签，而且在标签中加入上相应的列关系，由于你要让两个对象中都要清楚它们之间的映射是怎样使用的。而且在生成的关系表中哪一列是相应的自己的外键，所以要在该标签中指明，另外在<set>标签中加入table属性会指明要生成新表，以下的演示样例中加入了t_user_role，所以会生成新的关联表。

<?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.src.hibernate.User" table="t_user">
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="name"/>
		<set name="roles" table="t_user_role">
			<key column="user_id"></key>
			<many-to-many class="com.src.hibernate.Role" column="role_id"></many-to-many>
		</set>
	</class>
</hibernate-mapping>

1.1.2 Role.hbm.xml

由于是单向的关系，所以在该映射文件里就不须要加入多余的标签来维护关系了，它的内部代码也会非常easy，相应的映射代码例如以下：

<?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.src.hibernate.Role" table="t_role">
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="name"/>
	</class>
</hibernate-mapping>

1.2、类文件

类文件里代码的编写要和映射文件里配置的同样。它们之间是相互相应的，在user中由于使用了<set>映射，所以在相应的类文件里也要加入Haseset来标明之间的映射关系。

1.2.1 User.java

类代码没有什么好讨论的了，里面的内容和前几篇文章的大致同样，除了主要的属性和方法外还须要加入相应的HashSet。

package com.src.hibernate;
import java.util.Set;

public class User {
	//ID号
	private int id;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}

	//名称
	private String name;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}

	//角色集合
	private Set roles;
	public Set getRoles() {
		return roles;
	}
	public void setRoles(Set roles) {
		this.roles = roles;
	}
}

1.2.2 Role.java

主要的属性和方法，它的页面代码是很easy基础的，不须要加入不论什么复杂的内容。



watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvemhhbmdfeGlueGl1/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast" >

package com.src.hibernate;

public class Role {
	//id标示
	private int id;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}

	//名称
	private String name;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}

}

生成的表结构例如以下：

watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvemhhbmdfeGlueGl1/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast" >

1.3、操作

1.3.1 插入操作

演示插入操作。新创建表后向表中写入数据，相应着关系模型，在关系模型中最复杂的是关联表部分，须要加入多个相应角色，并把角色分配到相应的表中。所以首先要创建关系并把关系保存到数据库中，然后创建用户Hash表。在Hash表中加入相应的关系，最后创建用户，然后将Hash表加入到用户上，代码例如以下：

public void testSave(){
	Session session=null;
	try{
		//创建session对象
		session=HibernateUtils.getSession();
		//开启事务
		session.beginTransaction();

		//创建角色1
		Role r1=new Role();
		r1.setName("Doctor");
		session.save(r1);

		//创建角色2
		Role r2=new Role();
		r2.setName("Teacher");
		session.save(r2);

		//创建角色3
		Role r3=new Role();
		r3.setName("Farmer");
		session.save(r3);

		//创建角色4
		Role r4=new Role();
		r4.setName("Woman");
		session.save(r4);

		//创建角色5
		Role r5=new Role();
		r5.setName("Father");
		session.save(r5);

		//创建用户1。并设置用户角色
		User user1=new User();
		user1.setName("Anne");
		Set roles1=new HashSet();
		roles1.add(r1);
		roles1.add(r5);
		user1.setRoles(roles1);
		session.save(user1);

		//创建用户2，并设置用户角色
		User user2=new User();
		user2.setName("Jack");
		Set roles2=new HashSet();
		roles2.add(r2);
		roles2.add(r4);
		user2.setRoles(roles2);
		session.save(user2);

		//创建用户3，并设置用户角色
		User user3=new User();
		user3.setName("Baby");
		Set roles3=new HashSet();
		roles3.add(r3);
		roles3.add(r2);
		user3.setRoles(roles3);
		session.save(user3);

		session.getTransaction().commit();
	}catch(Exception e){
		e.printStackTrace();
		session.getTransaction().rollback();
	}finally{
		HibernateUtils.closeSession(session);
	}
}

运行上面的測试方法，将结构写入表：

对照上表，一个完整的写入測试方法编写完毕，将数据写入到关系中事实上相当的简单，主要是在写入时弄清楚写入的先后顺序，否则会出现非常多null值。另外须要注意的是Hash表部分，首先须要加入相应的Hash表的内容，最后将Hash表写入到数据库中。

1.3.2 读取操作

读取操作相对于写入来说就非常easy了。由于是单向的关系，所以在读取时仅仅能通过一端来读取还有一端的内容。也就是说通过User对象来读取Role的内容，例如以下代码：

public void testLoad1(){
	Session session=null;
	try{
		session=HibernateUtils.getSession();
		session.beginTransaction();

		User user=(User)session.load(User.class, 1);
		Set users=user.getRoles();
		for(Iterator iter=users.iterator();iter.hasNext();){
			Role role=(Role)iter.next();
			System.out.println("User.name= "+user.getName()+" and Role.name= "+role.getName());
		}

		session.getTransaction().commit();
	}catch(Exception e){
		e.printStackTrace();
		session.getTransaction().rollback();
	}finally{
		HibernateUtils.closeSession(session);
	}
}

运行測试方法。打印生成的内容例如以下：

Hibernate: select user0_.id as id0_0_, user0_.name as name0_0_ from t_user user0_ where user0_.id=?
Hibernate: select roles0_.user_id as user1_1_, roles0_.role_id as role2_1_, role1_.id as id2_0_, role1_.name as name2_0_ from t_user_role roles0_ left outer join t_role role1_ on roles0_.role_id=role1_.id where roles0_.user_id=?
User.name= Anne and Role.name= Father
User.name= Anne and Role.name= Doctor

二、双向多对多

双向的多对多映射可以看做是单向的一种扩展。它事实上是为了设置在两端同一时候维护关系，从不论什么一端都可以载入到还有一端的内容。在实现上和单向的起始端是同样的都要使用<many-to-many>标签。

相同以上面的User和Role来做演示样例。上面的演示样例中使用了单向的多对多。不同的是这里要使用双向关系。所以要在Role的一端加入相同的映射关系。并在相应的对象中加入集合映射，当中相应的User内的代码不会发生改变。

2.1 Role.hbm.xml

由于是双向的多对多所以要在对象的两端同一时候加入双向的集合映射，也就是在配置文件里加入<set>标签。并在标签中加入<many-to-many>标签，详细的配置方法类似于上文的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.src.hibernate.Role" table="t_role">
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="name"/>

		<!-- 加入集合映射，映射的表名应该同User.hbm.xml中配置的表名同样 -->
		<set name="users" table="t_user_role">
			<key column="role_id"/><!-- 加入映射的外键 -->
			<!-- 加入多对多的关系 -->
			<many-to-many class="com.src.hibernate.User" column="user_id"></many-to-many>
		</set>
	</class>
</hibernate-mapping>

2.2 Role.java

同单向的多对多关系中的文件同样，只是须要在对象中加入集合映射Set，使用set来标明映射的集合，例如以下代码：

package com.src.hibernate;

import java.util.Set;

public class Role {
	//id标示
	private int id;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}

	//名称
	private String name;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}

	//用户集合
	private Set users;
	public Set getUsers() {
		return users;
	}
	public void setUsers(Set users) {
		this.users = users;
	}

}

双向关联映射是在单向的关联映射基础上配置而来的。仅仅须要在映射文件的两端同一时候配置<many-to-many>就可以，也就是说User.hbm.xml和User.java代码和上文中的代码同样，不发生变化，所以不再反复加入了。

结语

完整的单向多对多讨论完整，须要注意的主要是user.hbm.xml中配置的方法，须要使用<many-to-many>标签而且须要生成关系表来维护多对多的关系。其他的内容都是非常easy的。

时间： 2024-08-07 17:01:27

【Hibernate步步为营】--多对多映射具体解释的相关文章

【Hibernate步步为营】--继承映射具体解释

上篇文章讨论了多对多映射,在使用多对多映射时重点是使用<many-to-many>标签,并在标签的两端加入外键这样在生成关系时会创建两个关系之间的关系表,通过关系表来维护它们之间的关系,另外对于单向和双向的差别是在映射的哪一端加入标签的问题.在面向对象中非常重要的一个特性就是继承,继承实现了代码的复用,并且Hibernate把基本上全部的对象模型进行了映射封装,当中就包含继承映射,接下来就具体讨论. 一.继承映射 继承是面向对象非常重要的特性,它实现了代码的服用,在关系模型中相同也有继承关系,

【Hibernate步步为营】--关联映射之多对一

上篇文章讨论了Hibernate的基本映射,一个实体类对应着一张表,在相应的Hibernate Mapping文件中使用<class>标签映射.并且实体类中的普通属性对应着表字段,使用<property>标签映射.另外在构造实体类时应注意:在实体类中应实现无参的默认的构造函数,提供一个标示,建议不要使用final修饰实体类,为实体类生成getter和setter方法,最后介绍了几种主要的主键生成策略,接下来讨论多对一映射. 一.关联映射之多对一 对于多对一关联映射其实很容易理解,在

【Hibernate步步为营】--继承映射详解

上篇文章讨论了多对多映射,在使用多对多映射时重点是使用<many-to-many>标签,并在标签的两端加入外键这样在生成关系时会创建两个关系之间的关系表,通过关系表来维护它们之间的关系,另外对于单向和双向的区别是在映射的哪一端添加标签的问题.在面向对象中很重要的一个特性就是继承,继承实现了代码的复用,而且Hibernate把基本上所有的对象模型进行了映射封装,其中就包括继承映射,接下来就详细讨论. 一.继承映射 继承是面向对象很重要的特性,它实现了代码的服用,在关系模型中同样也有继承关系,这种

【Hibernate步步为营】--组合映射详解

上篇文章详细讨论了复合主键的映射原理,对于复合主键映射需要使用<composite-id>标签来标明映射的类属性,并在该标签中添加<key-property>子标签,并且主键列需要实现序列化接口,使用很简单只要学会如何进行映射就可以实现复合映射.接下来讨论组合对象映射,组合映射关系其实是把两个对象的公共部分抽象出来形成一个对象,两个子对象会包含另一个主对像,在配置映射文件时需要使用<component>标签来标明映射关系. 一.组合映射 组合是关联关系的一种特殊情况,是

（08）Hibernate的多对多映射配置

基本需求是:一个项目可以有多个开发人员,一个开发人员可以参加多个项目,因此项目和开发人员是多对多的关系.本文中的学习重点,还和前几篇文章一样,都是JavaBean类的映射文件中的配置. 1.多对多映射 Project.java package com.rk.hibernate.h_many2many; import java.util.Set; public class Project { private int prjId; private String prjName; private Se

Hibernate的多对一映射

一.创建Java工程,新建Lib文件夹,加入Hibernate和数据库(如MySql.Oracle.SqlServer等)的Jar包,创建 hibernate.cfg.xml 文件,并配置,配置项如下: 1 <?xml version="1.0" encoding="UTF-8"?> 2 <!DOCTYPE hibernate-configuration PUBLIC 3 "-//Hibernate/Hibernate Configura

Hibernate的多对多映射关系

example: 老师(teacher)和学生(Student)就是一个多对多的关系吧?老师可以有多个学生,学生也可以由多个老师,那在Hibernate中多对多是怎样实现的呢?? 在Hibernate中多对多关系分为两种:1单向的多对多,2双向的多对多 下面详细说明一些两种有什么不同和实现步骤 I单向的多对多实现步骤: 1新建teacher.student表,可以任意选择在其中一个表添加另一个表的集合,(例如在teacher中添加student的set<Student>集合,例如private

【Hibernate步步为营】--锁机制具体解释

上篇文章具体讨论了hql的各种查询方法.在讨论过程中写了代码演示样例.hql的查询方法类似于sql,查询的方法比較简单,有sql基础的开发者在使用hql时就会变得相当的简单. Hibernate在操作数据库的同一时候也提供了对数据库操作的限制方法.这样的方法被称为锁机制,Hibernate提供的锁分为两种一种是乐观锁.第二种是悲观锁. 通过使用锁可以控制数据库的并发性操作.限制用户对数据库的并发性的操作. 一.锁简单介绍 锁能控制数据库的并发操作,通过使用锁来控制数据库的并发操作,Hiberna

Hibernate单向多对一映射关系（1）

单向 n-1 单向 n-1 关联只需从 n 的一端可以访问 1 的一端 域模型: 从 Order 到 Customer 的多对一单向关联需要在Order 类中定义一个 Customer 属性, 而在 Customer 类中无需定义存放 Order 对象的集合属性 关系数据模型:ORDERS 表中的 CUSTOMER_ID 参照 CUSTOMER 表的主键        Order.hbm.xml <many-to-one name="customer" class="C