`

many to many 单向

阅读更多

hibernate多对多关联映射(单向User---->Role)

具体映射方式:
 <set name="roles" table="t_user_role">
  <key column="userid"/>
  <many-to-many class="com.bjsxt.hibernate.Role" column="roleid"/>
 </set>
 

 

 

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

 

 

<?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"/>
	</class>
</hibernate-mapping>

 

 

package com.bjsxt.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);
		}
	}		
	
}

 

分享到:
评论

相关推荐

    Hibernate单向关联代码示例

    &lt;many-to-one name="department" column="DEPT_ID" class="Department" cascade="all"/&gt; ``` 或者,如果你使用注解,可以在实体类上进行配置: ```java @Entity public class Department { @OneToMany(mapped...

    Hibernate教程10_关系映射之多对一单向关联

    这里的`many-to-one`元素定义了多对一的关系。`name`属性指定了在员工类中对应的属性名(这里是`department`),`class`属性是部门实体的全限定类名,`column`属性是数据库表中对应的外键列名(假设为`dept_id`)。 ...

    hibernate多对多单向关联

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

    hibernate_1700_one2many_many2one_bi_crud(5)

    在压缩包中的“hibernate_1400_one2many_many2one_uni”文件可能包含了关于单向一对多(One-to-Many)和多对一关联的例子。单向关联只在一个方向上有引用,而双向关联在两个方向上都有引用。 为了实现这些关联,...

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

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

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

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

    Hibernate学习:单向多对一关联 工程

    1. **配置XML映射文件**:在实体类的XML映射文件中,使用`&lt;many-to-one&gt;`标签定义多对一关联。例如,如果有一个`Employee`类对应`Department`类,可以在`Employee.hbm.xml`中写入以下代码: ```xml &lt;many-to-one ...

    hibernate多对多双向关联

    多对多双向关联 &lt;br&gt;注意映射规则: ... &lt;key&gt;中的column属性值必须等于单向关联中&lt;many-to-many&gt;标签指向的column的属性值 &lt;many-to-many&gt;中column属性值必须等于单向关联中中column的属性值

    hibernate单向多对多映射(XML版)

    `&lt;key&gt;`元素指定了`Student`的外键列,`&lt;many-to-many&gt;`元素则指定了`Course`的外键列和关联的实体类。 在`Course`的映射文件中,因为是单向映射,所以不需要额外的配置。不过,如果需要双向映射,`Course`也需要...

    Hibernate 一对多外键单向关联

    这里的`many-to-one`元素表示Address与Person的一对多关联,column属性指定了外键列的名称,class属性指定了Person实体的全限定类名,cascade属性可以指定级联操作。 在实际使用中,可以通过Hibernate的Session接口...

    Hibernate一对多单向关联(annotation/xml)

    在Hibernate的XML映射文件中,我们可以使用`&lt;one-to-many&gt;`和`&lt;many-to-one&gt;`元素来定义关联。 1. **在父类的映射文件中**,使用`&lt;one-to-many&gt;`元素声明一对多关联,并通过`class`属性指定子类的全限定类名。 ```...

    Hibernate教程11_关系映射之一对多单向关联

    &lt;one-to-many class="com.example.Course"/&gt; ``` `inverse="true"`表示Course是关系的“拥有者”,`STUDENT_ID`是Course表中对应Student的外键。 4. **保存和查询**:在保存数据时,你需要同时保存Student和...

    一对多单向和双向映射

    在配置文件中,我们需要定义`&lt;one-to-many&gt;`标签来指定关联的集合: ```xml &lt;!-- ... --&gt; &lt;one-to-many class="Employee"/&gt; ``` 2. **一对多双向映射**: 双向映射则意味着两个实体都可以访问彼此...

    Hibernate多对多单向关联(annotation/xml)

    在Java的持久化框架Hibernate中,多对多(Many-to-Many)关联是一种常见的关系映射类型,它用于表示两个实体之间可以有多个对应的关系。本篇将详细讲解如何使用Hibernate实现多对多单向关联,包括注解(Annotation)...

    hibernate的关联映射

    关联映射主要包括四种类型:一对一(One-to-One)、一对多(One-to-Many)、多对一(Many-to-One)和多对多(Many-to-Many)。下面我们将逐一探讨这些关联映射的配置方法。 1. **一对一关联映射** - **主键关联**...

    Hibernate 系列教程 单向一对多

    `&lt;key&gt;`元素指定了关联的外键字段,`one-to-many`元素则指定被关联的子类。如果使用注解,可以在`Department`类上使用`@OneToMany`注解,并通过`mappedBy`属性指定子类中的关联字段。 ```xml &lt;!-- Hibernate XML...

    Hibernate映射文件[文].pdf

    - **单向**:在维护关系的一方,使用 `&lt;set&gt;` 标签定义一个集合,同时指定中间表和引用的实体类,`&lt;key&gt;` 和 `&lt;many-to-many&gt;` 分别表示两个实体的外键。 - **双向**:在双方都需要添加对应的 `&lt;set&gt;` 或 `&lt;many-...

Global site tag (gtag.js) - Google Analytics