`
schy_hqh
  • 浏览: 559176 次
  • 性别: Icon_minigender_1
社区版块
存档分类
最新评论

Hibernate基于配置文件（十三）多对多双向关联映射及其拆分

 
阅读更多


 

多对多关联，都会引入第三张表


package org.leadfar.hibernate.model;

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


public class Person {
	private int id;
	private String name;
	private Set<Role> roles;
	
	Person(){}
	
	//给人分配角色
	public void addRole(Role role) {
		if(roles==null) {
			roles = new HashSet<Role>();
		}
		roles.add(role);
	}
	
	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Set<Role> getRoles() {
		return roles;
	}

	public void setRoles(Set<Role> roles) {
		this.roles = roles;
	}

	
}

 

<?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="org.hibernate.auction">
	<class name="org.leadfar.hibernate.model.Person" table="t_persons" >
		<!-- id为数据库标识，作为主键 -->
		<id name="id">
			<generator class="native">
			</generator>
		</id>
		<property name="name"/>
		
		<!-- t_person_role为中间表，记录Person的id与Role的id -->
		<set name="roles" table="t_person_role">
		<!-- key column="personId" 表示在t_person_role表中用personId字段来记录Person的id-->
			<key column="personId"></key>
			<!-- class指名对方是哪个类--由类即能确定表， colunm指定保存对方id的字段，通过column的id值就能到对应表中取出记录-->
			<many-to-many class="org.leadfar.hibernate.model.Role" column="roleId"></many-to-many>
		</set>
		
	</class>
	
</hibernate-mapping>

 

package org.leadfar.hibernate.model;

import java.util.Set;

public class Role {
	private int id;
	private String name;
	private Set<Person> persons;
	
	
	Role(){}
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Set<Person> getPersons() {
		return persons;
	}
	public void setPersons(Set<Person> persons) {
		this.persons = persons;
	}
	
}

 

<?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="org.hibernate.auction">
	<class name="org.leadfar.hibernate.model.Role" table="t_roles" >
		<!-- id为数据库标识，作为主键 -->
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="name"/>		
		<!-- 表一致 都为t_person_role -->
		<set name="persons" table="t_person_role">
		<!-- 用roleId记录本方Role -->
			<key column="roleId"></key>
			<!-- 用personId记录对方的id -->
			<!-- 注意：两张表的表名字段名都必须一致，才能将关系存储到一张表中！ -->
			<many-to-many class="org.leadfar.hibernate.model.Person" column="personId"></many-to-many>
		</set>
	</class>
	
</hibernate-mapping>

 

测试

package org.leadfar.hibernate.model;

import java.util.Set;

import junit.framework.TestCase;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class Many2ManyTest extends TestCase {
	
	public void many2many_save() {
		Configuration cfg = new Configuration().configure();
		SessionFactory sf = cfg.buildSessionFactory();
		Session session = sf.openSession();
		
		try {
			session.beginTransaction();
			
			Person p1= new Person();
			p1.setName("1abc");
			session.save(p1);
			
			Person p2= new Person();
			p2.setName("2abc");
			session.save(p2);
			
			Person p3= new Person();
			p3.setName("3abc");
			session.save(p3);
			
			Role r1 = new Role();
			r1.setName("系统管理员");
			session.save(r1);
			
			Role r2 = new Role();
			r2.setName("档案管理员");
			session.save(r2);
			
			Role r3 = new Role();
			r3.setName("项目管理员");
			session.save(r3);
			
			p1.addRole(r3);
			p1.addRole(r2);
			
			p2.addRole(r1);
			
			p3.addRole(r3);
			p3.addRole(r2);
			p3.addRole(r1);
			
			
			session.getTransaction().commit();
			
		} catch(Exception e) {
			session.getTransaction().rollback();
			e.printStackTrace();
		} finally {
			session.close();
		}
	}
	public void many2many_load01() {
		Configuration cfg = new Configuration().configure();
		SessionFactory sf = cfg.buildSessionFactory();
		Session session = sf.openSession();
		
		try {
			session.beginTransaction();
		
			Person p = (Person)session.load(Person.class, 3);
			Set<Role> role = p.getRoles();
			for(Role r : role) {
				System.out.println(p.getName()+","+r.getName());
			}
			
			
			session.getTransaction().commit();
			
		} catch(Exception e) {
			session.getTransaction().rollback();
			e.printStackTrace();
		} finally {
			session.close();
		}
	}
	public void many2many_load02() {
		Configuration cfg = new Configuration().configure();
		SessionFactory sf = cfg.buildSessionFactory();
		Session session = sf.openSession();
		
		try {
			session.beginTransaction();
			
			Role r = (Role)session.load(Role.class, 3);
			Set<Person> persons = r.getPersons();
			for(Person p : persons) {
				System.out.println(r.getName()+","+p.getName());
			}
			
			session.getTransaction().commit();
			
		} catch(Exception e) {
			session.getTransaction().rollback();
			e.printStackTrace();
		} finally {
			session.close();
		}
	}
	
	
	
}

 

 

====================================================================

 

拆分多对多--->2个一对多

多的一方(PersonRole)，关联两个一的一端（Person,Role）

引入第三个类，不但可以保持关联关系，并可以在类中增加额外属性

而且避免了对集合的操作，在多的一端进行操作即可！

 

package org.leadfar.hibernate.model;


import java.util.Set;


public class Person {
	private int id;
	private String name;
	private Set<PersonRole> personRoles;
	
	Person(){}
	

	
	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Set<PersonRole> getPersonRoles() {
		return personRoles;
	}

	public void setPersonRoles(Set<PersonRole> personRoles) {
		this.personRoles = personRoles;
	}

	

	
}

   

package org.leadfar.hibernate.model;

import java.util.Set;

public class Role {
	private int id;
	private String name;
	private Set<PersonRole> rolePersons;
	
	
	Role(){}
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}

	public Set<PersonRole> getRolePersons() {
		return rolePersons;
	}

	public void setRolePersons(Set<PersonRole> rolePersons) {
		this.rolePersons = rolePersons;
	}


	
}

 

 

package org.leadfar.hibernate.model;

import java.util.Date;

public class PersonRole {
	/**
	 * PersonRole作为多的一方，持有Person和Role的引用
	 * 
	 */
	private int id;
	private Person person;
	private Role role;
	private Date createTime;
	
	PersonRole(){}
	
	public PersonRole(Person person,Role role) {
		this.person = person;
		this.role = role;
		this.createTime = new Date();
	}
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public Person getPerson() {
		return person;
	}
	public void setPerson(Person person) {
		this.person = person;
	}
	public Role getRole() {
		return role;
	}
	public void setRole(Role role) {
		this.role = role;
	}
	public Date getCreateTime() {
		return createTime;
	}
	public void setCreateTime(Date createTime) {
		this.createTime = createTime;
	}
	
	
}

 

<?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="org.hibernate.auction">
	<class name="org.leadfar.hibernate.model.Person" table="t_persons" >
		<!-- id为数据库标识，作为主键 -->
		<id name="id">
			<generator class="native">
			</generator>
		</id>
		<property name="name"/>
		
		<set name="personRoles" lazy="extra" inverse="true">
			<key column="personId"></key>
			<one-to-many class="org.leadfar.hibernate.model.PersonRole"></one-to-many>
		</set>
		
	</class>
	
</hibernate-mapping>

 

<?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="org.hibernate.auction">
	<class name="org.leadfar.hibernate.model.Role" table="t_roles" >
		<!-- id为数据库标识，作为主键 -->
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="name"/>		
		<set name="rolePersons" lazy="extra" inverse="true">
			<key column="roleId"></key>
			<one-to-many class="org.leadfar.hibernate.model.PersonRole"></one-to-many>
		</set>
	</class>
	
</hibernate-mapping>

 

<?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="org.hibernate.auction">
	<class name="org.leadfar.hibernate.model.PersonRole" table="t_person_role" >
		<!-- id为数据库标识，作为主键 -->
		<id name="id">
			<generator class="native"/>
		</id>
		<many-to-one name="person" column="personId"></many-to-one>
		<many-to-one name="role" column="roleId"></many-to-one>
		<property name="createTime" type="timestamp"></property>
	</class>
	
</hibernate-mapping>

 

测试

package org.leadfar.hibernate.model;


import java.util.Set;

import junit.framework.TestCase;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class Many2ManyTest extends TestCase {
	
	public void many2many_save() {
		Configuration cfg = new Configuration().configure();
		SessionFactory sf = cfg.buildSessionFactory();
		Session session = sf.openSession();
		
		try {
			session.beginTransaction();
			
			Person p1= new Person();
			p1.setName("1abc");
			session.save(p1);
			
			Person p2= new Person();
			p2.setName("2abc");
			session.save(p2);
			
			Person p3= new Person();
			p3.setName("3abc");
			session.save(p3);
			
			Role r1 = new Role();
			r1.setName("系统管理员");
			session.save(r1);
			
			Role r2 = new Role();
			r2.setName("档案管理员");
			session.save(r2);
			
			Role r3 = new Role();
			r3.setName("项目管理员");
			session.save(r3);
			
			//从多的一端维护关联关系
			session.save(new PersonRole(p1,r1));
			session.save(new PersonRole(p2,r2));
			session.save(new PersonRole(p3,r1));
			session.save(new PersonRole(p3,r2));
			session.save(new PersonRole(p3,r3));
			
			
			session.getTransaction().commit();
			
		} catch(Exception e) {
			session.getTransaction().rollback();
			e.printStackTrace();
		} finally {
			session.close();
		}
	}
	public void many2many_load01() {
		Configuration cfg = new Configuration().configure();
		SessionFactory sf = cfg.buildSessionFactory();
		Session session = sf.openSession();
		
		try {
			session.beginTransaction();
		
			Person p = (Person)session.load(Person.class, 3);
		
			Set<PersonRole> prs = p.getPersonRoles();
			for(PersonRole pr : prs) {
				System.out.println(p.getName()+","+pr.getRole().getName());
			}
			
			session.getTransaction().commit();
			
		} catch(Exception e) {
			session.getTransaction().rollback();
			e.printStackTrace();
		} finally {
			session.close();
		}
	}
	public void many2many_load02() {
		Configuration cfg = new Configuration().configure();
		SessionFactory sf = cfg.buildSessionFactory();
		Session session = sf.openSession();
		
		try {
			session.beginTransaction();
			
			Role r = (Role)session.load(Role.class, 3);
		
			Set<PersonRole> prs = r.getRolePersons();
			for(PersonRole pr : prs) {
				System.out.println(r.getName()+","+pr.getPerson().getName());
			}
			
			session.getTransaction().commit();
			
		} catch(Exception e) {
			session.getTransaction().rollback();
			e.printStackTrace();
		} finally {
			session.close();
		}
	}
	

	
}

 

=================================================================

 

 分析对象之间的关系：

1个用户拥有多个组，1个组只属于1个用户；

1个用户可以属于多个组（1个学生只属于1个班级），1个组可以包含多个用户；



 

  • 大小: 21.1 KB
分享到：
| Hibernate基于配置文件（十二）一对一双向 ...
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    hibernate关联映射详解

    包含《多对多双向关联映射》《多对一单向关联映射》《多对一双向关联映射》《一对多单向关联映射》等文档，并有图解及例子，非常适合新手学习，尤其是刚刚接触hibernate，对映射关系不清楚的。。。。

    Hibernate一对一主键关联映射（双向关联）

    标题"Hibernate一对一主键关联映射（双向关联）"中的"主键关联"指的是两个实体通过共享相同的主键来建立关联。"双向关联"则意味着在两个实体类中，都可以直接访问到对方的实例，即在实体A中有一个对实体B的引用，...

    hibernate多对多关联映射

    本文将深入探讨Hibernate如何实现多对多关联映射，并通过实际例子解析相关配置和操作。 一、多对多关联概述 在数据库设计中，多对多关联表示两个表之间的关系，如学生和课程的关系，一个学生可以选修多门课程，而...

    Hibernate双向一对一关联映射(注解版)

    本主题聚焦于“Hibernate双向一对一关联映射”的注解实现，这是一种高级的数据库设计模式，用于处理两个实体之间一对一的关系。 在Hibernate中，一对一关联映射分为单向和双向。单向一对一映射通常涉及一个实体持有...

    hibernate表之间3种双向关联映射

    本篇文章将详细探讨三种常见的双向关联映射方式：双向多对多（BidirectionalManyToMany）、双向一对多（BidirectionalOneToMany）以及双向一对一（BidirectionalOneToOne），包括它们的概念、配置和实际应用。...

    Hibernate ORM - 一对多双向关联关系

    这个压缩包文件“HibernateORM”很可能包含了关于如何在实际项目中设置和使用Hibernate一对多双向关联的示例代码、配置文件或者详细教程。通过学习这些材料，开发者能够深入理解如何在Java应用中利用Hibernate来处理...

    hibernate多对多关联映射（单项关联）

    在Java的持久化框架Hibernate中，多对多关联映射是一种常见的关系模型，它用于处理两个实体类之间存在多个对应关系的情况。这篇博客"hibernate多对多关联映射（单项关联）"深入探讨了如何在Hibernate中实现这种映射...

    hibernate一对多关联映射（双向关联）

    在Java的持久化框架Hibernate中，一对多关联映射是一种常见的关系映射方式，它用于表示一个实体（如用户）可以拥有多个子实体（如订单）的情况。在本篇文章中，我们将深入探讨如何实现双向关联的一对多映射，以及在...

    hibernate 双向多对多关联映射练习

    在Java的持久化框架Hibernate中，双向多对多关联映射是一种常见的数据关系模型，它允许两个实体类之间存在多个实例互相引用的情况。本练习旨在帮助开发者深入理解并熟练运用这种映射方式。通过以下详细讲解，我们将...

    hibernate多对多双向关联

    总结来说，理解并能正确使用Hibernate中的多对多双向关联是Java开发中的重要技能，涉及到实体设计、映射配置、数据操作和性能优化等多个方面。通过学习提供的博客和相关代码示例，开发者可以深入掌握这一主题，并将...

    一对一双向关联映射

    在Java持久化框架Hibernate中，一对一双向关联映射是一种重要的数据对象关系映射策略，它允许我们在数据库中的两个实体之间建立一对一的关系，并且在Java对象模型中可以从任一侧访问另一侧的对象。这种映射方式增加...

    hibernate双向多对多关联映射(注解版)

    在这个“hibernate双向多对多关联映射(注解版)”的主题中，我们将深入探讨如何使用Hibernate的注解配置来处理数据库中的双向多对多关联关系。 首先，多对多关联在数据库设计中是指两个实体之间存在多个对应关系，...

    hibernate双向一对多关联映射(注解版)

    在Java的持久化框架Hibernate中，双向一对多关联映射是一种常见的关系映射方式，它模拟了数据库中的外键关联，使得一个实体可以拥有多个另一个实体的实例。在这个注解版的实现中，我们将深入探讨如何使用Hibernate的...

    hibernate 双向一对一基于主键的关联映射

    在提供的压缩包文件`bionetoonetable`中，可能包含了示例代码或者相关的配置文件，用于演示双向一对一基于主键的关联映射的实现。具体的内容需要查看文件才能了解详情。 总结，双向一对一基于主键的关联映射是...

    Hibernate一对一唯一外键关联映射（双向关联）

    在Hibernate中，一对一关联可以通过配置XML映射文件或使用注解来实现。这里我们将使用注解方式进行说明。首先，我们需要在两个实体类中分别定义对应的属性，并使用`@OneToOne`注解来指定关联关系。 1. 实体类A： ``...

    hibernate对映射xml的一对多的双向关联详解

    2. **在子类映射文件中定义多对一关联** 在子类（如“课程”）的映射文件中，使用`&lt;many-to-one&gt;`元素来表示多对一的关系。`class`属性指定父类的全限定类名，`column`属性对应父类在子类表中的外键字段。 ```xml...

    hibernate关联映射实例

    本文将深入探讨“hibernate关联映射实例”中的关键知识点，包括一对多、多对多和继承映射，这些都是Hibernate中至关重要的概念。 1. **一对多关联映射**： 在现实世界中，一个实体可能会与多个其他实体相关联，...

    hibernate一对多，多对一，一对多双向关联

    “Hibernate 一对多，多对一，一对多双向关联”是指在Java持久化框架Hibernate中，实体间常见的三种关联关系。在数据库设计中，这种关联关系是常见的，例如一个用户可以有多个订单（一对多），一个订单对应一个用户...

    Hibernate关联映射

    9. Hibernate 一对一外键双向关联、主键双向关联、连接表双向关联、一对多外键双向关联、一对多连接表双向关联、多对多双向关联： 这些关联方式与单向关联类似，区别在于两个实体类都知道彼此的关联。在双向关联中...

Magicbox
Global site tag (gtag.js) - Google Analytics