Hibernate进阶之单向多对一关系映射

最新推荐文章于 2017-05-16 21:04:24 发布
最新推荐文章于 2017-05-16 21:04:24 发布
阅读量598 收藏
点赞数
分类专栏： Hibernate 文章标签： java web hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenchudongsg/article/details/30496147
版权

Hibernate中实现对象与对象之间的关系：有一对一，一对多，多对多。下面来认识Hibernate的单向多对一关系。

 在配置映射文件中让我们来认识<many-to-one name="" column="" cascade=""/>多对一这个标签。

首先，我们定义两个实体类：Customer，Order。

代码如下：

Customer类：

package example.many2one_single;
/**
 * 客户（一方）
 * @author Administrator
 *
 */
public class Customer {

	private Integer id;//对应表的主键
	private String name;
	private Integer age;
	public Customer() {
	}
	public Customer(String name, Integer age) {
		super();
		this.name = name;
		this.age = age;
	}
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	
}
Order类： 

package example.many2one_single;
/**
 * 订单（多的一方）
 * @author Administrator
 *
 */
public class Order {

	private Integer id;
	private String OrderNo;//订单编号
	private Integer price;//价格
	private Customer customer;
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getOrderNo() {
		return OrderNo;
	}
	public void setOrderNo(String orderNo) {
		OrderNo = orderNo;
	}
	public Integer getPrice() {
		return price;
	}
	public void setPrice(Integer price) {
		this.price = price;
	}
	public Order(String orderNo, Integer price) {
		super();
		OrderNo = orderNo;
		this.price = price;
	}
	public Order() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Customer getCustomer() {
		return customer;
	}
	public void setCustomer(Customer customer) {
		this.customer = customer;
	}
	
	
}

第二步：配置映射文件，把Customer和Order的映射都写在同一个映射文件中：

CustomerOrder.hbm.xml：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="example.many2one_single">
	<class name="Customer" table="customers">
		<id name="id" column="id" type="int">
			<generator class="native"></generator>
		</id>
		<property name="name" column="name" type="string"></property>
		<property name="age" column="age" type="int"></property>
	</class>
	<class name="Order" table="Orders">
		<id name="id" column="id">
			<generator class="native"></generator>
		</id>
		<property name="orderNo" column="orderNo"></property>
		<property name="price" column="price"></property>
		<!--many-to-one映射多方的关联属性
		name表示关联的属性名
		column表示多方的外键列
		  -->
		<many-to-one name="customer" column="customers_id" ></many-to-one>
	</class>
</hibernate-mapping>

第三步：在mysql建表： 

create table customers(
id int(5) primary key auto_increment,name varchar(50),age int(5)
);
create table orders(
	id int primary key auto_increment,
	orderNo varchar(255),
	price int(5)，
	customer_id int(5),
	constraint customer_order_FK foreign key(id) references customers(id)
);

第四步，写执行代码： 

package example.dao;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Test;

import example.many2one_single.Customer;
import example.many2one_single.Order;
import example.utils.HibernateUtils;

public class CustomerOrderDao {

	private static  SessionFactory sessionFactory;
	static{
		//创建configure配置文件hibernate.properties
		Configuration cfg=new Configuration();
		//加载映射文件hibernate.cfg.xml
		cfg.configure();
		//创建sessionFactory工厂对象
		sessionFactory=cfg.buildSessionFactory();
	}
	/**
	 * 先保存1客户，再保存2订单------3条SQL
	 */
	@Test
	public void test01(){
		Customer customer=new Customer("小李",14);
		Order o1=new Order("order2011",100);
		Order o2=new Order("order2012",100);
		//创建创建单项关联
		o1.setCustomer(customer);
		o2.setCustomer(customer);
		
		Session session=null;
		Transaction ts=null;
		try{
			//创建session对象
			//session= sessionFactory.openSession();
			session=HibernateUtils.getSession();
			//开启事务
			ts= session.getTransaction();
			//开始事务
			ts.begin();
			//保存对象到数据库
			session.save(o1);
			session.save(o2);
			session.save(customer);
			ts.commit();
		}catch (Exception e) {
			// TODO: handle exception
			ts.rollback();
			e.printStackTrace();
		}finally{
			//session.close();
			HibernateUtils.closeSession();
		}
	}
	/**
	 * 先保存2订单，再保存1客户------5条SQL
	 */
	@Test
	public void test02(){
		Customer customer=new Customer("小李",14);
		Order o1=new Order("order2011",100);
		Order o2=new Order("order2012",100);
		//创建创建单项关联
		o1.setCustomer(customer);
		o2.setCustomer(customer);
		
		Session session=null;
		Transaction ts=null;
		try{
			//创建session对象
			//session= sessionFactory.openSession();
			session=HibernateUtils.getSession();
			//开启事务
			ts= session.getTransaction();
			//开始事务
			ts.begin();
			//保存对象到数据库
			session.save(customer);
			session.save(o1);
			session.save(o2);
			ts.commit();
		}catch (Exception e) {
			// TODO: handle exception
			ts.rollback();
			e.printStackTrace();
		}finally{
			//session.close();
			HibernateUtils.closeSession();
		}
	}

接下来我们认识cascade="save-update/all"：当我们在代码中这样写的话会出现临时对象出错异常（org.hibernate.TransientObjectException: object references an unsaved transient instance - save the transient instance before flushing: example.many2one_single.Customer）。 

/**
	 * 只保存2订单，级联保存1客户(cascade="save-update/all")
	 */
	@Test
	public void test03(){
		Customer customer=new Customer("小名",14);
		Order o1=new Order("order2011",100);
		Order o2=new Order("order2012",100);
		//创建创建单项关联
		o1.setCustomer(customer);
		o2.setCustomer(customer);
		
		Session session=null;
		Transaction ts=null;
		try{
			//创建session对象
			//session= sessionFactory.openSession();
			session=HibernateUtils.getSession();
			//开启事务
			ts= session.getTransaction();
			//开始事务
			ts.begin();
			//保存对象到数据库
			session.save(o1);
			session.save(o2);
			ts.commit();
		}catch (Exception e) {
			// TODO: handle exception
			ts.rollback();
			e.printStackTrace();
		}finally{
			//session.close();
			HibernateUtils.closeSession();
		}
	}

这是因为持久对象引用临时对象导致的错误，所以要避免这种错误，就应该在映射文件中添加 cascade="save-update"
配置如下： 

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="example.many2one_single">
	<class name="Customer" table="customers">
		<id name="id" column="id" type="int">
			<generator class="native"></generator>
		</id>
		<property name="name" column="name" type="string"></property>
		<property name="age" column="age" type="int"></property>
	</class>
	<class name="Order" table="Orders">
		<id name="id" column="id">
			<generator class="native"></generator>
		</id>
		<property name="orderNo" column="orderNo"></property>
		<property name="price" column="price"></property>
		<!--many-to-one映射多方的关联属性
		name表示关联的属性名
		column表示多方的外键列
		  -->
		<many-to-one name="customer" column="customers_id" cascade="save-update"></many-to-one>
	</class>
</hibernate-mapping>

只更新2订单，级联更新1客户【cascade="save-update/all"】:

/**
	 * 只更新2订单，级联更新1客户【cascade="save-update/all"】
	 */
	@Test
	public void test04(){
		Session session=null;
		Transaction ts=null;
		try{
			//创建session对象
			//session= sessionFactory.openSession();
			session=HibernateUtils.getSession();
			//开启事务
			ts= session.getTransaction();
			//开始事务
			ts.begin();
			Order o6= (Order) session.get(Order.class, 6);
			o6.setPrice(o6.getPrice()+20);
			Order o7=(Order) session.get(Order.class, 7);
			o7.setPrice(o7.getPrice()+30);
			Customer cus=o6.getCustomer();
			cus.setAge(cus.getAge()+4);
			//保存对象到数据库
			session.save(o6);
			session.save(o7);
			ts.commit();
		}catch (Exception e) {
			// TODO: handle exception
			ts.rollback();
			e.printStackTrace();
		}finally{
			//session.close();
			HibernateUtils.closeSession();
		}
	}

只删除订单，级联删除客户【cascade="delete/all"】，只删除订单，不级联删除客户【cascade="none",默认值】： 

/**
	 * 只删除订单，级联删除客户【cascade="delete/all"】
	 */
	@Test
	public void test05(){
		Session session=null;
		Transaction ts=null;
		try{
			//创建session对象
			//session= sessionFactory.openSession();
			session=HibernateUtils.getSession();
			//开启事务
			ts= session.getTransaction();
			//开始事务
			ts.begin();
			Order o6= (Order) session.get(Order.class, 8);
			session.delete(o6);
			ts.commit();
		}catch (Exception e) {
			// TODO: handle exception
			ts.rollback();
			e.printStackTrace();
		}finally{
			//session.close();
			HibernateUtils.closeSession();
		}
	}





chenchudongsg
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【SSH进阶之路】Hibernate映射——多对一单向关联映射（四）
努力+坚持，而且还很年轻
10-22 3万+
基本映射是对一个实体进行映射，关联映射就是处理多个实体之间的关系，将关联关系映射到数据库中，所谓的关联关系在对象模型中有一个或多个引用。
【SSH进阶之路】Hibernate映射——一对一单向关联映射（五）
热门推荐
努力+坚持，而且还很年轻
10-23 2万+
两个实体对象之间是一对一的关联映射，即一个对象只能与另外唯一的一个对象相对应。例如：一个人(Person)只有一张身份证(IdCard)。
Hibernate进阶之单向一对多关系映射
陈楚东的专栏-学编程切记心浮气躁，贵在坚持
06-14 607
上一篇介绍了Hibernate进阶之单向一对多关系映射
Hibernate进阶之双向一对多关系映射
陈楚东的专栏-学编程切记心浮气躁，贵在坚持
06-15 433
上一篇介绍了Hibernate的单向一对多关系，接下来用代码s
hibernate进阶--一对多映射配置
weiguang111的博客
01-15 3778
Hibernate作为一款优秀的ORM框架，广受大家喜爱，也被Java社区公认为持久层的首选。虽然jdbc为Java数据库操作带来了诸多便利，但是并没有统一SQL语句的写法，而且具体操作数据库的代码也足够复杂，且存在大量重复。所以有了ORM框架，让Java程序员可以从SQL语句中解放，Hibernate就是其中的翘楚。Hibernate将JDBC进一步的封装了，在SQL的可移植性方面表现优秀，并且
Hibernate（五）:Hibernate映射——一对一单向关联映射
zjkC050818的博客
05-16 399
本文转载自：http://blog.csdn.net/jiuqiyuliang/article/details/40350515 【SSH进阶之路】Hibernate基本原理（一） ，小编介绍了hibernate的基本原理以及它的核心，采用对象化的思维操作关系型数据库。 【SSH进阶之路】Hibernate搭建开发环境+简单实例（二），小编搭建了基本Hibernate的开发
hibernate进阶之路之一对多映射（四）
05-31 326
上篇博客介绍如何进行多对一的映射，这种一般都是查询多的一端，然后把一的一端数据连带着查询出来，但是，如果有查询一个班级，然后把这个班级所有学生信息查询出来的需求，就可以采用一对多的关联映射来完成。         一、单向关联         1、创建实体：Class和Student，Class添加一个set类型的属性，用于存放student实体集合： Class： public clas
hibernate进阶（6） 一对多映射
程序员
11-14 422
注意这里使用hibernate4.3.11的jar包 映射类型： 一对多（one-to-many） 多对一（many-to-one） 一对一（one - to -one） 多对多（many-to-many） 常用的是一对多和多对一的映射 下面学习一对多映射类型 比如：一个班级有多个学生 在数据库中：可以通过添加主外键的关联（学生表中添加外键指向班级），表现一对多的关系 在H
hibernate进阶 （7）多对一映射
程序员
11-14 340
多对一的关系和关系数据库中的外键参照关系最匹配，即在己方的表中的一个外键参照另外一个表的主键 通过在多方持有一方的引用实现，需要在“多”的一端使用配置 首先说明一下下面几个名词的区别 单向多对一（多方定义一个一方的引用但是，一方没有多方的引用）学生类定义一个对班级对象属性 单向一对多（一方定义多方的引用，多方没有定义一方的引用）一个班级有多个学生对象，班级类定义一个集合属性，集合里
hibernate
03-15
11. **一对一、一对多、多对多关系映射**: Hibernate支持多种关联映射，如单向、双向关联，以及集合映射。 **在Job4J项目中学习Hibernate** 1. **环境搭建**: 首先需要在项目中引入Hibernate的依赖库，并配置相应...
hibernate教程
05-14
2. **单向 Set-based 的关联**：介绍如何设置一个实体类对另一个实体类的单向集合关联，例如一个人有多条电话记录。 3. **使关联工作**：讨论如何在代码中操作关联对象，如添加、删除关联项。 4. **值类型的集合**...
韩顺平老师Hibernate教程PPT（完整）
10-11
Hibernate支持一对一、一对多、多对一和多对多四种关联关系的映射，包括单向和双向关联，以及懒加载和立即加载策略。 十、性能优化 为了提高性能，可以采用批处理、延迟加载、缓存策略等手段。比如，使用BatchSize...
Hibernate中文帮助文档
11-28
7. **一对多、一对一和多对多关系映射**：文档会详细讲解如何配置和处理不同类型的关联关系，包括单向和双向关联，以及级联操作的配置。 8. **缓存机制**：Hibernate支持二级缓存，可以显著提升性能。文档会介绍...
Hibernate进阶之如何使用Hql内连接，外连接以及自连接
陈楚东的专栏-学编程切记心浮气躁，贵在坚持
06-20 9567
我们在sql语句中熟悉的  （3）HQL实战         （A）使用等值连接查询，查询客户姓名，订单编号，订单价格     select c.name,o.orderno,o.price     from Customer c join c.orderSet o     where c.id = o.customer.id         （B）使用左外连接，按客户分组，查询每个客
Hibernate进阶：理解Hibernate中的四种状态（临时状态，持久状态，游离状态，删除状态）
陈楚东的专栏-学编程切记心浮气躁，贵在坚持
06-03 1549
首先来理解一下四种状态的相关区别以及必要的知识点： （1）什么是OID OID的中文名叫对象标识符，是hibernate框架为每个进入session一级缓存中的对象设置的一个唯一性标识， 将来对应表中的主健，是决不能重复的。 session对象的四种状态转换：    （2）对象在整个hibernate框架中运行，一共有四种不同的状态产生： 我们从三个方面进行比较：（1）OID是否为NU
org.hibernate.QueryException: could not resolve property:
陈楚东的专栏-学编程切记心浮气躁，贵在坚持
06-18 1447
log4j:WARN No appenders could be found for logger (org.hibernate.cfg.Environment). log4j:WARN Please initialize the log4j system properly. org.hibernate.QueryException: could not resolve property: c
Hibernate实现增删改查以及和JDBC的关系
陈楚东的专栏-学编程切记心浮气躁，贵在坚持
06-03 880
当我们在学习hibernate必然会学习到增删查改，所以下面的是自己在学习过程涉及到的
Hibernate3.6中文教程：关系型持久化入门与进阶
Hibernate是一款流行的开源对象关系映射（ORM）框架，用于Java开发，它提供了一种将Java类与数据库表之间的映射机制，简化了数据库操作。Hibernate3.6是该框架的一个版本，包含了一些重要的特性和改进。 **前言** ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值