`

many to many 双向

阅读更多
<?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.yelang.hibernate.User" table="t_user">
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="name"/>
		<set name="roles" table="t_user_role">
			<key column="userid"/>
			<many-to-many class="com.yelang.hibernate.Role" column="roleid"/>
		</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>
	<class name="com.yelang.hibernate.Role" table="t_role">
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="name"/>
		<set name="users" table="t_user_role" order-by="userid">
			<key column="roleid"/>
			<many-to-many class="com.yelang.hibernate.User" column="userid"/>
		</set>
	</class>
</hibernate-mapping>

 

 

package com.yelang.hibernate;

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

import org.hibernate.Session;

import junit.framework.TestCase;

public class Many2Many extends TestCase {

	public void testSave2() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();
			
			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);
			
			User u1 = new User();
			u1.setName("10");
			Set u1Roles = new HashSet();
			u1Roles.add(r1);
			u1Roles.add(r2);
			u1.setRoles(u1Roles);
			
			User u2 = new User();
			u2.setName("祖儿");
			Set u2Roles = new HashSet();
			u2Roles.add(r2);
			u2Roles.add(r3);
			u2.setRoles(u2Roles);
			
			User u3 = new User();
			u3.setName("杰伦");
			Set u3Roles = new HashSet();
			u3Roles.add(r1);
			u3Roles.add(r2);
			u3Roles.add(r3);
			u3.setRoles(u3Roles);
			
			session.save(u1);
			session.save(u2);
			session.save(u3);
			
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}		
	
	public void testLoad1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();
			User user = (User)session.load(User.class, 1);
			System.out.println(user.getName());
			for (Iterator iter=user.getRoles().iterator(); iter.hasNext();) {
				Role role = (Role)iter.next();
				System.out.println(role.getName());
			}
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}		
	
	public void testLoad2() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();
			Role role = (Role)session.load(Role.class, 1);
			System.out.println(role.getName());
			for (Iterator iter=role.getUsers().iterator(); iter.hasNext();) {
				User user = (User)iter.next();
				System.out.println(user.getName());
			}
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}		
	
}

 

分享到:
评论

相关推荐

    Hibernate one-to-many / many-to-one关系映射

    "Hibernate one-to-many / many-to-one关系映射"是两个基本的关系类型,用于表示实体间的关联。在这个主题中,我们将深入探讨这两种关系映射的原理、配置和实际应用。 一、一对一(one-to-one)与一对多(one-to-...

    (4)Hibernate中的many-to-one和one-to-many关系

    在双向关联中,一方(通常是one-to-many的一方)需要通过`@OneToMany(mappedBy="")`来指定关联的另一方的属性,而另一方(many-to-one)则无需指定`mappedBy`,直接使用`@ManyToOne`即可。 4. 外键的处理 在one-to-...

    hibernate学习5之one-to-many双向关联.docx

    在配置双向一对多关联时,我们通常在"多"一端(这里是`Student`)的集合属性上使用`&lt;many-to-one&gt;`标签,将`Classes`对象映射到数据库中的外键。同时,在"一"端(`Classes`)使用`&lt;set&gt;`标签,表示班级可以包含多个...

    hibernate one-to-many 单/双向关联映射配置心得

    本文主要关注Hibernate中的一个核心概念——一对一(One-to-One)、一对多(One-to-Many)和多对一(Many-to-One)关联映射,特别是关于“一到多”单向和双向关联映射的配置心得。 首先,让我们了解“一到多”关联...

    Hibernate many-to-many

    "Hibernate many-to-many"指的是Hibernate中处理多对多关联关系的一种方式。多对多关系是两个实体类之间存在的一种复杂关联,比如学生和课程之间的关系,一个学生可以选修多门课程,一门课程也可以被多个学生选修。 ...

    Hibernate Many-To-Many Mapping Annotations

    在Java的持久化框架Hibernate中,Many-to-Many映射是一种常见的关系模型,它用于表示两个实体类之间多对多的关系。在这个主题中,我们将深入探讨如何使用注解来实现这种映射,以及其背后的数据库原理和实际应用。 ...

    Hibernate 两种方式映射many to many

    在Java的持久化框架Hibernate中,处理多对多(Many-to-Many)关系映射是一项常见的任务。这种关系类型在数据库设计中很常见,比如学生和课程的关系,一个学生可以选修多门课程,一门课程也可以被多个学生选修。在...

    hibernate多对多双向关联

    多对多双向关联 &lt;br&gt;注意映射规则: &lt;set name="roles" table="t_user_role"&gt;&lt;br&gt; &lt;key column="userid"/&gt;&lt;br&gt; &lt;many-to-many class="com.bjsxt.hibernate.Role" column="roleid"/&gt;&lt;br&gt; &lt;/set&gt;&lt;br&gt;&lt;br&gt;table...

    hiberante - one to many - update

    标题中的“Hibernate - one to many - update”指向的是一个关于Hibernate框架中的一对多关联关系在更新操作时的专题。Hibernate是Java开发中常用的持久化框架,它简化了数据库操作,使得开发者可以更加关注业务逻辑...

    Many-To-Many_Element.rar_hibernate 多对多

    在现实世界的数据模型中,很多情况下存在多对多(Many-to-Many)的关系,例如学生与课程的关系,用户与角色的关系等。本教程主要讲解如何使用Hibernate来处理多对多的关联映射,尤其是基于HashMap的实现方式。 首先...

    hibernate one_to_many

    在Java持久化框架Hibernate中,`one_to_many`映射是一种常见的关系模型,它表示一个实体(类)可以与多个其他实体(类)关联。在这个关系中,一个实体(通常是"one"端)对应多个实体实例("many"端)。在数据库中,...

    Hibernate one-to-many-annotation

    在Hibernate中,`one-to-many`关系是常见的实体间关系之一,表示一个实体可以与多个其他实体相关联。本文将深入探讨`Hibernate one-to-many`注解的使用和实现细节。 ### 一、`@OneToMany`注解概述 `@OneToMany`...

    hibernate_1700_one2many_many2one_bi_crud(5)

    标题中的“hibernate_1700_one2many_many2one_bi_crud(5)”指的是一项关于Hibernate框架的教程,重点在于介绍一对多(One-to-Many)和多对一(Many-to-One)双向关联关系的创建、读取、更新和删除(CRUD)操作。...

    hibernate双向一对多关联映射(XML)

    总结起来,Hibernate的双向一对多关联映射(XML)涉及的主要知识点包括:实体类的关联、`&lt;set&gt;`和`&lt;one-to-many&gt;`标签的使用、`&lt;many-to-one&gt;`标签的使用、以及如何在Java代码中维护这种关联。理解并熟练运用这些...

    A port of the original STL to many platforms

    标题"A port of the original STL to many platforms"表明这个项目的目标是将原始的STL移植到多个平台上,使得在不同操作系统和硬件环境下都能使用这些强大的数据结构和算法。 STLport是一个开源项目,它的主要目的...

    hibernate one-to-one 一对一唯一外键关联映射_单向 and 双向

    在上面的配置中, `&lt;many-to-one&gt;` 标签指定了Person实体与IdCard实体之间的一对一唯一外键关联关系,其中unique="true"指定了多的一端的多重性为一。 Hibernate 一对一唯一外键关联映射的应用 在实际应用中,一对...

    Hibernate之第3解之-hibernate_hibernate_many2one_1

    《深入理解Hibernate:第三解——Many-to-One关系映射实战》 在Java世界里,ORM(Object-Relational Mapping)框架的出现极大地简化了数据库与Java对象之间的交互,而Hibernate作为其中的佼佼者,更是备受开发者青睐...

    hibernate双向多对多关联映射(XML)

    在关系型数据库中,多对多(Many-to-Many)关系是两个表之间的一种复杂关联,表示一个实体可以与多个其他实体相关联,反之亦然。例如,学生和课程之间就可能存在多对多关系,一个学生可以选择多门课程,一门课程也...

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

    在数据库设计中,实体间的关系通常包括一对一(One-to-One)、一对多(One-to-Many)和多对一(Many-to-One)关系,而在Hibernate这个ORM(对象关系映射)框架中,这些关系可以被映射到Java对象上,使得数据操作更加...

    双向数据绑定JS库Bindable.js.zip

    Bindable.js is similar to Ember's data-binding system, except it doesn't include anything View related, so the library has many use-cases - whether replacing Backbone's Model, providing a way to ...

Global site tag (gtag.js) - Google Analytics