007——hibernate一对多关联映射

最新推荐文章于 2023-04-05 17:31:32 发布
最新推荐文章于 2023-04-05 17:31:32 发布
阅读量252 收藏
点赞数
分类专栏： Hibernate 文章标签： hibernate 一对多关联映射
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/msj_god_boy/article/details/51941082
版权

本次以Teacher和Student为例

一对多关联映射：有单向一对多关联映射和双向一对多关联映射

一对多关联映射和多对一关联映射映射原理是一致的，都是在多的一端加入一个外键，指向一的一端

它们的区别在于维护的关系不同：

  • 多对一维护的关系是：多指向一的关系，有了此关系，在加载多的时候可以将一加载上来
  • 一对多维护的关系是：一指向多的关系，有了此关系，在加载一的时候可以将多加载上来
在一的一端维护关系存在缺陷：
  •  因为多的一端Student不知道Teacher的存在（也就是Student没有维护与Teache的关系）所以在保存Student的时候关系字段teacherid是为null的，如果将该关系字段设置为非空，则将无法保存数据
  • 另外因为Student不维护关系，而Teacher维护关系，Teacher就会发出多余的update语句，保证Teacher和Student有关系，这样加载Teacher的时候才可以把该Teacher对应的学生加载上来
单向关联映射：
实体类：
Teacher.java 
package com.java.hibernate;

import java.util.Set;

public class Teacher {

	private int id;
	
	private String name;
	
	private Set<Student> students;

	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<Student> getStudents() {
		return students;
	}

	public void setStudents(Set<Student> students) {
		this.students = students;
	}
	
}
Student.java 
package com.java.hibernate;

public class Student {
	
	private int id;
	
	private String name;

	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;
	}
	
}
实体类映射文件：
Teacher.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.java.hibernate.Teacher" table="t_teacher">
		<id name="id">
			<generator class="native" />
		</id>
		<property name="name" />
		<set name="students">
			<key column="teacherid"/>
			<one-to-many class="com.java.hibernate.Student"/>
		</set>
	</class>
</hibernate-mapping>
Student.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.java.hibernate.Student" table="t_student">
		<id name="id">
			<generator class="native"></generator>
		</id>
		<property name="name"></property>
	</class>
</hibernate-mapping>
测试类：
Test.java
 
package com.java.hibernate;

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

import junit.framework.TestCase;

import org.hibernate.Session;

public class Test extends TestCase{

	public void testSave1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();
			
			Student student1 = new Student();
			student1.setName("张三");
			
			Student student2 = new Student();
			student2.setName("李四");
			
			Teacher teacher = new Teacher();
			teacher.setName("周杰伦");

			Set<Student> students = new HashSet<Student>();
			students.add(student1);
			students.add(student2);
			
			teacher.setStudents(students);
			//抛出TransientObjectException
			//因为Student不是Persistent状态的对象,它是Transient状态的对象
			session.save(students);
			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback(); 
		} finally {
			HibernateUtils.closeSession(session);
		}
	}
	
	public void testSave2() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();
			
			Student student1 = new Student();
			student1.setName("张三");
			session.save(student1);
			
			Student student2 = new Student();
			student2.setName("李四");
			session.save(student2);
			
			Teacher teacher = new Teacher();
			teacher.setName("周杰伦");

			Set<Student> students = new HashSet<Student>();
			students.add(student1);
			students.add(student2);
			
			teacher.setStudents(students);
			//可以成功保存数据
			//但是会发出多余的update语句来维持关系
			session.save(teacher);
			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback(); 
		} finally {
			HibernateUtils.closeSession(session);
		}
	}
	
	public void testLoad() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();
			
			Teacher teacher = (Teacher) session.load(Teacher.class, 1);
			System.out.println(teacher.getName());
			Set<Student> students = teacher.getStudents();
			for (Iterator iter = students.iterator(); iter.hasNext();) {
				Student student = (Student) iter.next();
				System.out.println(student.getName());
			}
			
			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		} finally {
			HibernateUtils.closeSession(session);
		}
	}
}<span style="color:#ff0000;">
</span>

双向关联映射：
采用一对多双向关联映射的目的主要是为了解决一对多单向关联的缺陷，而不是需求驱动的。
一对多双向关联映射的映射方式：
  • 在一的一端的集合上采用<key>标签，在多的一端加入一个外键
  • 在多的一端采用<many-to-one>标签
注意：<key>标签和<many-to-one>标签加入的字段保持一直，否则会产生数据混乱
实体类：
Teacher.java 
package com.java.hibernate;

import java.util.Set;

public class Teacher {

	private int id;
	
	private String name;
	
	private Set<Student> students;

	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<Student> getStudents() {
		return students;
	}

	public void setStudents(Set<Student> students) {
		this.students = students;
	}
	
}
Student.java 
package com.java.hibernate;

public class Student {
	
	private int id;
	
	private String name;
	
	private Teacher teacher;

	public Teacher getTeacher() {
		return teacher;
	}

	public void setTeacher(Teacher teacher) {
		this.teacher = teacher;
	}

	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;
	}
	
}
实体类映射文件：
Teacher.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.java.hibernate.Teacher" table="t_teacher">
		<id name="id">
			<generator class="native" />
		</id>
		<property name="name" />
		<set name="students">
			<key column="studentid"/>
			<one-to-many class="com.java.hibernate.Student"/>
		</set>
	</class>
</hibernate-mapping>
Student。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.java.hibernate.Student" table="t_student">
		<id name="id">
			<generator class="native"></generator>
		</id>
		<property name="name"></property>
		<many-to-one name="teacher" column="studentid" />
	</class>
</hibernate-mapping>
测试类：
Test.java 
package com.java.hibernate;

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

import junit.framework.TestCase;

import org.hibernate.Session;

public class Test extends TestCase {

	public void testSave() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();
			
			Student student1 = new Student();
			student1.setName("张三");
			session.save(student1);
			
			Student student2 = new Student();
			student2.setName("李四");
			session.save(student2);
			
			Set<Student> students = new HashSet<Student>();
			students.add(student1);
			students.add(student2);
			
			Teacher teacher = new Teacher();
			teacher.setName("周杰伦");
			teacher.setStudents(students);
		
			session.save(teacher);
			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		} finally {
			HibernateUtils.closeSession(session);
		}
	}
	
	public void testLoad() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();
			
			Student student = (Student) session.load(Student.class, 1);
			System.out.println(student.getName());
			System.out.println(student.getTeacher().getName());
			
			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		} finally {
			HibernateUtils.closeSession(session);
		}
	}
}

MsjGodBoy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【SSH进阶之路】Hibernate映射——多对一单向关联映射（四）
努力+坚持，而且还很年轻
10-22 3万+
基本映射是对一个实体进行映射，关联映射就是处理多个实体之间的关系，将关联关系映射到数据库中，所谓的关联关系在对象模型中有一个或多个引用。
006——hibernate一对一关联映射
msj_god_boy的博客
07-17 1040
一对一关联映射有两种方式：主键关联和外键关联 以夫妻为例（Husband----Wife） 单向关联实体类： Husband.java package com.java.hibernate; public class Husband { private int id; private String name; private Wife wife; public Wi
Hibernate（4）——关系关联一对多映射
程序员的时光
10-22 299
目录 1. 班级——学生一对多映射； ​​​​​​​ 1. 班级——学生一对多映射； 先建立Class班级类； package com.java.model; public class Class { private int id; private String name; public int getId() { return...
Hibernate映射—— 多对一单向关联映射
Snow丶的博客
10-16 309
概念        基本映射是对一个实体进行映射，关联映射就是处理多个实体之间的关系，将关联关系映射到数据库中，所谓的关联关系在对象模型中有一个或多个引用。 分类   关联关系分为上述七种，但是由于相互之间有各种关系，可以简化，例如：多对一与一对多映射，只是侧重的角度不对而已。 映射技巧        映射技巧是小编写映射文件的过程，总结的经典内容，总共分为四步，咋看
Hibernate（五）:Hibernate映射——一对一单向关联映射
zjkC050818的博客
05-16 403
本文转载自：http://blog.csdn.net/jiuqiyuliang/article/details/40350515 【SSH进阶之路】Hibernate基本原理（一） ，小编介绍了hibernate的基本原理以及它的核心，采用对象化的思维操作关系型数据库。 【SSH进阶之路】Hibernate搭建开发环境+简单实例（二），小编搭建了基本Hibernate的开发
Hibernate（四）：Hibernate映射——多对一单向关联映射
zjkC050818的博客
05-16 409
本文转载自：http://blog.csdn.net/jiuqiyuliang/article/details/40345389 【SSH进阶之路】Hibernate基本原理（一） ，小编介绍了hibernate的基本原理以及它的核心，采用对象化的思维操作关系型数据库。 【SSH进阶之路】Hibernate搭建开发环境+简单实例（二），小编搭建了基本Hibernate的开发
Hibernate映射—— 一对多关联映射
Snow丶的博客
10-16 293
一对多关联映射 映射原理       一对多关联映射和多对一关联映射的映射原理是一致的，都是在多的一端加入一个外键，指向一的一端。关联关系都是由多端维护，只是在写映射时发生了变化。 多对一和一对多的区别          多对一和一对多的区别在于维护的关系不同： （1）多对一：多端维护一端的关系，在加载多端时，可以将一端加载上来。 （2）一对多：一端维护多端的关系，在加载一端时，可以将
Hibernate多表关联——（一对多关系）
最新发布
闲来垂钓碧溪上的博客
04-05 1978
hibernate是连接数据库使得更容易操作数据库数据的一个框架，在上期我们演示了单表建立查询。接触过数据库的都知道数据库表有三种关系，。而接下来我们在hibernate中建立关系，首先应该检查一下数据库是否打开，根据，接下来继续建立表的关系。
Hibernate——一对多关联映射（CRUD）
WannaRunning的博客
12-18 261
目录 实体类增加关联对象 下面是映射文件： save相关操作 正常的保存操作： 级联保存： 外键维护： 查询操作： delete相关操作： 删除one的一方（customer）： 删除many的一方： 级联删除（通常是删除one连带many）： 两张表，用户和订单，记录一下一对多和多对一关联映射的实现。 实体类增加关联对象 客户实体类中除了客户自己的属性外，还要加一个...
Hibernate入门第十讲——Hibernate的一对多关联映射
李阿昀的博客
04-13 1万+
Hibernate关联映射——一对多（多对一）我们以客户(Customer)与订单(Order)为例来讲解Hibernate关联映射中的一对多关联关系。 首先肯定是搭建好Hibernate的开发环境，我在此也不过多赘述，读者自行实践。接着在src目录下创建一个cn.itheima.oneToMany包，并在该包下创建两个实体类，如下： 客户类// 客户 ---- 一的一方 public class
JavaEE第七次实验——Hibernate关联关系映射
qq_46015650的博客
11-24 590
实验七 Hibernate关联关系映射——登录用户的地址管理 一、基础实验——多对一/一对多关联 （一）实验目的 掌握 Hibernate 关联关系映射的基本概念，理解关联的方向和数量，重点理 解双向一对多/多对一的关联关系，及其在实际应用中的体现； 学习 Hibernate 框架处理一对多/多对一关联关系的方法，掌握关联关系中持 久化类的实现方法、以及相应 Hibernate 映射文件的配置方案； 能在实际应用中通过 Hibernate 建立正确的一对多/多对一关联关系映射，并 以面向对象的方式进行数据
【Hibernate】——多对多关联映射
许小乖……是总攻
05-12 821
对比单向和双向关联映射，可以从查询加载的地方看出二者的不同，单向关联映射只能从循环遍历用户获得角色，但是双向关联映射既可以循环遍历用户获得角色，也可以循环遍历角色获得用户。 需要注意的是<key>中的column对应的是当前类在中间表中对应的字段，即对方想要的外键，而<many-to-manyclass="com.bjpowernode.hibernate.Role"column="role_id"/>中的column指示的是中间表中本类想要的外键。还要注意的是inverse的值只能
【SSH进阶之路】Hibernate映射——一对多关联映射（七）
热门推荐
努力+坚持，而且还很年轻
11-16 1万+
一对多关联映射和多对一关联映射的映射原理是一致的，都是在多的一端加入一个外键，指向一的一端。关联关系都是由多端维护，一端维护多端的关系，在加载一端时，可以将多端加载上来。
010——hibernate具体表继承：每个子类一个表
msj_god_boy的博客
07-18 1004
具体表继承：这种策略是使用joined-subclass标签来定义子类的。父类、子类，每个类都对应一张数据库表。在父类对应的数据库表中，实际上会存储所有的记录，包括父类和子类的记录；在子类对应的数据库表中，这个表只定义了子类中所特有的属性映射的字段。子类与父类，通过相同的主键值来关联。 实现这种策略的时候，有如下步骤： 父类用普通的标签定义即可父类不再需要定义discriminat
021——hibernateDML操作
msj_god_boy的博客
07-22 469
实体类以及映射文件参考015篇 测试类： package test; import junit.framework.TestCase; import org.hibernate.Session; import com.java.hibernate.HibernateUtils; import com.java.hibernate.Student; public class DMLQue
014——hibernate的悲观锁和乐观锁
msj_god_boy的博客
07-19 406
举例： 初始化类： package com.java.hibernate; import org.hibernate.Session; public class InitData { public static void main(String[] args) { Session session = null; try { session = HibernateU
008——hibernate多对多关联映射
msj_god_boy的博客
07-18 381
多对多关联映射分为单向多对多关联映射和双向多对多关联映射 单向多对多关联映射（单向User--------->Role）： 具体映射： 实体类： User.java package com.java.hibernate; import java.util.Set; public class User { private int id; privat
020——hibernate对象导航查询
msj_god_boy的博客
07-22 347
实体类及映射文件参考015篇 测试类： package test; import java.util.Iterator; import java.util.List; import junit.framework.TestCase; import org.hibernate.Session; import com.java.hibernate.HibernateUtils; impor
Hibernate框架中的多对一关联映射
这篇资料主要讲解了Java EE开发中的一个关键概念——多对一关联，以及如何在Hibernate框架中实现这种关联。Hibernate是一个流行的开源对象关系映射（ORM）框架，它允许开发者用面向对象的方式处理数据库操作。 在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值