`

hibernate学习7之many-to-many双向关联

阅读更多
Hibernate.cfg.xml配置同前一节。

import java.util.Set;
public class User {
	private int id;
	private String name;
	private Set roles; 
	//setter,getter
}

import java.util.Set;
public class Role {	
	private int id;	
	private String name;	
	private Set users;
	//setter,getter
}

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.bjsxt.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.bjsxt.hibernate.Role" column="roleid"/>
		</set>
	</class>
</hibernate-mapping>

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>
	<class name="com.bjsxt.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.bjsxt.hibernate.User" column="userid"/>
		</set>
	</class>
</hibernate-mapping>

比较上面2个配置,其实userid和roleid互换位置而已;
这里order-by="userid"是查出来的数据根据userid排序,去掉也没关系。
测试一下:
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关系映射

    3. 双向关联的管理:确保双向关联的正确维护,避免数据一致性问题。 4. 外键策略:根据数据库规范和业务需求,选择合适的外键策略,如自动生成、指定值或使用主键共享。 总结,Hibernate的one-to-many和many-to-one...

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

    `&lt;set&gt;`标签里的`&lt;one-to-many&gt;`子标签指定了与之关联的类。 在XML映射文件中,`Student.hbm.xml`包含了`&lt;many-to-one&gt;`元素,表示学生对象引用了一个班级对象,通过`classesid`列连接。而`Classes.hbm.xml`则使用...

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

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

    Hibernate Many-To-Many Mapping Annotations

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

    Hibernate many-to-many

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

    Hibernate one-to-many-annotation

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

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

    在Hibernate中,一对一唯一外键关联映射可以通过 `&lt;many-to-one&gt;` 标签来配置。例如,以下是Person实体与IdCard实体的一对一唯一外键关联映射配置: ```xml &lt;many-to-one name="idCard" column="card_id...

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

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

    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...

    Hibernate之第3解之-hibernate_hibernate_many2one_1

    虽然`@ManyToOne`注解在Employee类中,但Department类也可以通过`@OneToMany`注解反向引用Employee,实现双向关联。这在需要从单的一方获取所有多的一方实例时非常有用。 5. **外键约束**: Many-to-One关系通常...

    Many-To-Many_Element.rar_hibernate 多对多

    在Hibernate中,我们可以使用`&lt;many-to-many&gt;`标签来配置多对多映射。下面是一个简单的例子: ```xml &lt;many-to-many column="USER_ID" foreign-key="FK_USER_ROLE" entity-name="com.example.Role" table="USER...

    hibernate 全面学习->hibernate 关联映射学习

    本文将深入探讨Hibernate的关联映射学习,包括一对多、多对一、一对一等多种关系映射的方式。 首先,我们来看一下“一对多”(One-to-Many)的映射关系。在Hibernate中,这种关系通常用在一个实体可以拥有多个子...

    Hibernate-Many-to-many-Relationship-in-Spring-MVC:展示如何在 Spring MVC HIbernate 项目中建立多对多关系的示例项目

    本示例项目"Hibernate-Many-to-many-Relationship-in-Spring-MVC"着重展示了如何实现多对多(Many-to-Many)关联,这是一种复杂但常见的数据模型关系。在这个项目中,我们将深入探讨以下知识点: 1. **多对多关系**...

    Hibernate关联映射

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

    hibernate的关联映射

    - **双向关联**:在两个实体的映射文件中都需要`&lt;many-to-many&gt;`标签,并且需要一个共享的中间表。 关联映射的配置涉及到`cascade`属性,它决定了级联操作的行为,如`save-update`、`delete`等。`inverse`属性则...

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

    为了使双向关联正常工作,还需要在Java代码中进行相应的设置。例如,在创建新订单时,不仅要设置订单的用户属性,也要在用户对象的订单集合中添加该订单: ```java User user = new User(); Order order = new ...

    Hibernate性能调优

    `many-to-one`关联是另一个重要的关联类型,在Hibernate中,它通常用来表示外键存储方向。 - **定义**:`many-to-one`关联意味着多个实体可以指向同一个实体。 - **示例**:如学生与教师之间的关联。 - **注意点**...

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

    本知识点将深入探讨Hibernate中的双向多对多关联映射,并通过XML配置文件进行设置。 在关系型数据库中,多对多(Many-to-Many)关系是两个表之间的一种复杂关联,表示一个实体可以与多个其他实体相关联,反之亦然。...

Global site tag (gtag.js) - Google Analytics