Hibernate 关联关系 之 一对多

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

1.了解什么是关联（association）

1.1关联指的是类之间的引用关系。如果类A与类B关联，那么被引用的类B将被定义为类A的属性。
例如：

  	t_hibernate_order 订单表 
	  t_hibernate_order_item 订单项表
	  一个订单对应多个订单项
	  
	  class Order{
		private List<OrderItem> orderItems;
	  }
	  
	  class OrderItem{
		private Order order;
	  }
	  
	  
	  
	  class B{
		private String name;
	  }
	  
	  public class A{
        private B b = new B;
        public A(){}
      }

1.2 关联的分类：关联可以分为一对一、一对多/多对一、多对多关联
这里我们以订单和订单项的关系来示范一对多的增删改查：
①首先准备好实体类，Order和OrderItem

Order：

package com.swx.three.entity;

import java.util.ArrayList;
import java.util.List;

public class Order {
private  Integer orderId;
private String orderNo;
private List<OrderItem> orderItems = new ArrayList<OrderItem>();
public Integer getOrderId() {
	return orderId;
}
public void setOrderId(Integer orderId) {
	this.orderId = orderId;
}
public String getOrderNo() {
	return orderNo;
}
public void setOrderNo(String orderNo) {
	this.orderNo = orderNo;
}
public List<OrderItem> getOrderItems() {
	return orderItems;
}
public void setOrderItems(List<OrderItem> orderItems) {
	this.orderItems = orderItems;
}
@Override
public String toString() {
	return "Order [orderId=" + orderId + ", orderNo=" + orderNo + ", orderItems=" + orderItems + "]";
}

}

OrderItem：

package com.swx.three.entity;

public class OrderItem {
private Integer orderItemId;
private Integer productId;
private Integer quantity;
private Integer oid;
private Order order;
public Integer getOrderItemId() {
	return orderItemId;
}
public void setOrderItemId(Integer orderItemId) {
	this.orderItemId = orderItemId;
}
public Integer getProductId() {
	return productId;
}
public void setProductId(Integer productId) {
	this.productId = productId;
}
public Integer getQuantity() {
	return quantity;
}
public void setQuantity(Integer quantity) {
	this.quantity = quantity;
}
public Integer getOid() {
	return oid;
}
public void setOid(Integer oid) {
	this.oid = oid;
}
public Order getOrder() {
	return order;
}
public void setOrder(Order order) {
	this.order = order;
}
@Override
public String toString() {
	return "OrderItem [orderItemId=" + orderItemId + ", productId=" + productId + ", quantity=" + quantity + ", oid="
			+ oid + "]";
}




}

②配置映射文件，在Order.hbm.xml和OrderItem.hbm.xml配置好关联关系的列，
Order.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
	<class name="com.swx.three.entity.Order" table="t_hibernate_order">
		<id name="orderId" type="java.lang.Integer" column="order_id">
			<generator class="increment" />
		</id>
		<property name="orderNo" type="java.lang.String" column="order_no">
		</property>
		
		<!-- 
		bag ：
			name：当前要映射的类的关联属性
			cascade：维护关联关系
			inverse：决定由谁来维护关联关系
			
		key：
			column：表的外键对应的列段
			
		one-to-many：
			class：关联属性对应的全路径名
		 -->
		<bag name="orderItems" cascade="save-update" inverse="true">
		<key column="oid"></key>
		<one-to-many class="com.swx.three.entity.OrderItem"/>
		</bag>
	</class>

</hibernate-mapping>

OrderItem.hbm.xml

package com.swx.three.entity;

import java.util.ArrayList;
import java.util.List;

public class Order {
private  Integer orderId;
private String orderNo;
private List<OrderItem> orderItems = new ArrayList<OrderItem>();
public Integer getOrderId() {
	return orderId;
}
public void setOrderId(Integer orderId) {
	this.orderId = orderId;
}
public String getOrderNo() {
	return orderNo;
}
public void setOrderNo(String orderNo) {
	this.orderNo = orderNo;
}
public List<OrderItem> getOrderItems() {
	return orderItems;
}
public void setOrderItems(List<OrderItem> orderItems) {
	this.orderItems = orderItems;
}
@Override
public String toString() {
	return "Order [orderId=" + orderId + ", orderNo=" + orderNo + ", orderItems=" + orderItems + "]";
}

}

记得配置核心配置文件：

<!-- 关联关系 一对多 -->
		<mapping resource="com/swx/three/entity/Order.hbm.xml" />
		<mapping resource="com/swx/three/entity/OrderItem.hbm.xml" />

③dao层：

package com.swx.three.dao;

import java.util.List;

import org.hibernate.Session;
import org.hibernate.Transaction;

import com.swx.three.entity.Order;
import com.swx.three.entity.OrderItem;
import com.swx.two.util.SessionFactoryUtils;



public class DemoDao {
	/**
	 * 为了测试关系型映射文件配置准确
	 * 	讲解insert=false，update=false的用途
	 * @param order
	 * @return
	 */
	public Integer addOrder(Order order) {
		Session session = SessionFactoryUtils.openSession();
		Transaction transaction = session.beginTransaction();
		Integer oid = (Integer)session.save(order);
		transaction.commit();
		session.close();
		return oid;
	}
	
	public Integer addOrderItem(OrderItem orderItem) {
		Session session = SessionFactoryUtils.openSession();
		Transaction transaction = session.beginTransaction();
		Integer otid = (Integer)session.save(orderItem);
		transaction.commit();
		session.close();
		return otid;
	}
	
	
	
	/**
	 * 为了讲解懒加载的问题（hibernate3.0后所有查询方式默认采用的是懒加载方式）
	 * 	1、查单个时存在问题，代理对象已经关闭
	 * 	2、查多个存在问题，有性能的问题
	 * @param order
	 * @return
	 */
	public Order getOrder(Order order) {
		Session session = SessionFactoryUtils.openSession();
		Transaction transaction = session.beginTransaction();
		Order o = session.get(Order.class, order.getOrderId());
//		if(o != null && new Integer(1).equals(order.getInitChildren())) {
//			Hibernate.initialize(o.getOrderItems());
			System.out.println(o.getOrderItems());
//		}
		transaction.commit();
		session.close();
		return o;
	}
	
	public List<Order> getOrderList() {
		Session session = SessionFactoryUtils.openSession();
		Transaction transaction = session.beginTransaction();
		List<Order> list = session.createQuery("from Order").list();
		transaction.commit();
		session.close();
		return list;
	}
	
	/**
	 * z主表的数据不能随便删除，得先删除从表中对应信息，才能删除主表的信息。
	 * @param order
	 */
	public void delOrder(Order order) {
		Session session = SessionFactoryUtils.openSession();
		Transaction transaction = session.beginTransaction();
		Order order2 = session.get(Order.class, order.getOrderId());
		for (OrderItem oi : order2.getOrderItems()) {
			session.delete(oi);
		}
		session.delete(order2);
//		session.delete(order);
		transaction.commit();
		session.close();
	}
}

④测试：

package com.swx.three.dao;

import static org.junit.Assert.*;

import org.junit.Test;

import com.swx.three.entity.Order;
import com.swx.three.entity.OrderItem;

public class DemoDaoTest {
	private DemoDao demodao = new DemoDao();
	@Test
	public void testAddOrder() {
		Order order = new Order();
		order.setOrderNo("swx123购物");//创建订单
		for (int i = 0; i < 5; i++) {
			OrderItem oi = new OrderItem();
			oi.setProductId(100+i);
			oi.setQuantity(200+i);
			//demodao.addOrderItem(oi);
			order.getOrderItems().add(oi);
			oi.setOrder(order);
			//绑定订单和订单项 
		}
		demodao.addOrder(order);
	}

	@Test
	public void testAddOrderItem() {
	}

	@Test
	public void testGetOrder() {
	}

	@Test
	public void testGetOrderList() {
	}

	@Test
	public void testDelOrder() {
	}

}

这里会有一个报错：

Repeated column in mapping for entity: com.swx.three.entity.OrderItem column: oid (should be mapped with insert="false" update="false")

oid列段有两个进行维护，重复了！
如何解决：将 insert=“false” update="false"加载到对应的配置文件中

<!-- insert="false" update="false" 解决列段属性重复维护问题 
			当前name=“oid” 放弃对数据库的oid列段进行维护
		 -->
		<property name="oid" type="java.lang.Integer" column="oid" insert="false" update="false">
		</property>

再次运行 ：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
添加成功。

测试增加订单项：

public void testAddOrderItem() {
		OrderItem oi = new OrderItem();
		oi.setProductId(250);
		oi.setQuantity(350);
		Order order = new Order();
		order.setOrderId(11);
		oi.setOrder(order);
		demodao.addOrderItem(oi);
	}

结果：
在这里插入图片描述

懒加载问题：

测试方法

	/**
	 * 懒加载
	 */
	@Test
	public void testGetOrder() {
		Order order = new Order();
		order.setOrderId(11);
		Order o = demodao.getOrder(order);
		System.out.println(o.getOrderNo());
		//failed to lazily initialize a collection of role: 懒加载失败
		//com.swx.three.entity.Order.orderItems,
		//could not initialize proxy - no Session  
		System.out.println(o.getOrderItems());
	}

结果：

org.hibernate.LazyInitializationException:
 failed to lazily initialize a collection of role:
  com.swx.three.entity.Order.orderItems, could not initialize proxy - no Session

这里报错了，问题就是懒加载一个集合失败（o.getOrderItems()）
解决方案：
1.在配置文件Order.hbm.xml中加载lazy（不推荐）

<bag lazy="false" name="orderItems" cascade="save-update" inverse="true">
		<key column="oid"></key>
		<one-to-many class="com.swx.three.entity.OrderItem"/>
		</bag>

结果：
在这里插入图片描述
加载成功，但是并不推荐这种方案，因为有其弊端:
测试方法：

@Test
	public void testGetOrderList() {
		List<Order> orderlist = demodao.getOrderList();
		for (Order order : orderlist) {
			System.out.println(order.getOrderNo());
			System.out.println(order.getOrderItems().size());
		}
	}

结果：

Hibernate: 
    select
        order0_.order_id as order_id1_0_,
        order0_.order_no as order_no2_0_ 
    from
        t_hibernate_order order0_
Hibernate: 
    select
        orderitems0_.oid as oid4_1_0_,
        orderitems0_.order_item_id as order_it1_1_0_,
        orderitems0_.order_item_id as order_it1_1_1_,
        orderitems0_.product_id as product_2_1_1_,
        orderitems0_.quantity as quantity3_1_1_,
        orderitems0_.oid as oid4_1_1_ 
    from
        t_hibernate_order_item orderitems0_ 
    where
        orderitems0_.oid=?
Hibernate: 
    select
        orderitems0_.oid as oid4_1_0_,
        orderitems0_.order_item_id as order_it1_1_0_,
        orderitems0_.order_item_id as order_it1_1_1_,
        orderitems0_.product_id as product_2_1_1_,
        orderitems0_.quantity as quantity3_1_1_,
        orderitems0_.oid as oid4_1_1_ 
    from
        t_hibernate_order_item orderitems0_ 
    where
        orderitems0_.oid=?
Hibernate: 
    select
        orderitems0_.oid as oid4_1_0_,
        orderitems0_.order_item_id as order_it1_1_0_,
        orderitems0_.order_item_id as order_it1_1_1_,
        orderitems0_.product_id as product_2_1_1_,
        orderitems0_.quantity as quantity3_1_1_,
        orderitems0_.oid as oid4_1_1_ 
    from
        t_hibernate_order_item orderitems0_ 
    where
        orderitems0_.oid=?
Hibernate: 
    select
        orderitems0_.oid as oid4_1_0_,
        orderitems0_.order_item_id as order_it1_1_0_,
        orderitems0_.order_item_id as order_it1_1_1_,
        orderitems0_.product_id as product_2_1_1_,
        orderitems0_.quantity as quantity3_1_1_,
        orderitems0_.oid as oid4_1_1_ 
    from
        t_hibernate_order_item orderitems0_ 
    where
        orderitems0_.oid=?
Hibernate: 
    select
        orderitems0_.oid as oid4_1_0_,
        orderitems0_.order_item_id as order_it1_1_0_,
        orderitems0_.order_item_id as order_it1_1_1_,
        orderitems0_.product_id as product_2_1_1_,
        orderitems0_.quantity as quantity3_1_1_,
        orderitems0_.oid as oid4_1_1_ 
    from
        t_hibernate_order_item orderitems0_ 
    where
        orderitems0_.oid=?
Hibernate: 
    select
        orderitems0_.oid as oid4_1_0_,
        orderitems0_.order_item_id as order_it1_1_0_,
        orderitems0_.order_item_id as order_it1_1_1_,
        orderitems0_.product_id as product_2_1_1_,
        orderitems0_.quantity as quantity3_1_1_,
        orderitems0_.oid as oid4_1_1_ 
    from
        t_hibernate_order_item orderitems0_ 
    where
        orderitems0_.oid=?
P1
0
P7
8
P101
6
P20
6
T226
3
swx123购物
6

执行了大量sql语句，会导致性能过差。
2.在Order中添加一个属性来控制是否懒加载（记得将之前的lazy属性清除）：

private Integer initChildren = 0;//0代表默认懒加载 1 代表强制加载

public Integer getInitChildren() {
	return initChildren;
}
public void setInitChildren(Integer initChildren) {
	this.initChildren = initChildren;
}

dao层DemoDao：

/**
	 * 为了讲解懒加载的问题（hibernate3.0后所有查询方式默认采用的是懒加载方式）
	 * 	1、查单个时存在问题，代理对象已经关闭
	 * 	2、查多个存在问题，有性能的问题
	 * @param order
	 * @return
	 */
	public Order getOrder(Order order) {
		Session session = SessionFactoryUtils.openSession();
		Transaction transaction = session.beginTransaction();
		Order o = session.get(Order.class, order.getOrderId());
		//当 order.getInitChildren() 为 1 时 强制加载o.getOrderItems()
		//这样既兼顾了性能，也能成功加载o.getOrderItems()
		if(o != null && new Integer(1).equals(order.getInitChildren())) {
			Hibernate.initialize(o.getOrderItems());
//			System.out.println(o.getOrderItems());
		}
		transaction.commit();
		session.close();
		return o;
	}

现在我们仅需要在之前的测试方法中加一行代码就能解决问题了：

public void testGetOrder() {
		Order order = new Order();
		order.setOrderId(11);
		order.setInitChildren(1);//设置强制加载
		Order o = demodao.getOrder(order);
		System.out.println(o.getOrderNo());
		//failed to lazily initialize a collection of role: 懒加载失败
		//com.swx.three.entity.Order.orderItems,
		//could not initialize proxy - no Session  
		System.out.println(o.getOrderItems());
	}

结果：
在这里插入图片描述
成功拿到。

3.测试删除：

	/**
	 * 删除
	 */
	@Test
	public void testDelOrder() {
		Order order = new Order();
		order.setOrderId(11);
		this.demodao.delOrder(order);
		
	}

结果：
在这里插入图片描述
在这里插入图片描述

秃头使我变强
关注
专栏目录
Hibernate之一对多双向关联查询
qq_41097820的博客
11-25 1708
在这里模拟一个业务场景记录hibernate中一对多双向关联的配置及使用： 当我们在手机上购物付款之后，是会生成订单的。一个订单中会存在着多个订单项，订单与订单项之间就存在着一对多的关系；一个订单中可以有多个订单项，而多个订单项又组成为一个订单。所以这里以订单与订单项为例进行记录： 数据库脚本建表： -- 订单表(主表) create table t_hibernate_o...
hibernate一对多关联映射学习小结
08-29
在Hibernate中，一对多关联映射和多对一关联映射的区别在于维护的关系不同。多对一关联映射中，多的一端维护一的一端的关系，在加载多的一端时，可以将一的一端加载上来。一对多关联映射中，一的一端维护多的一端的...
级联 association 一对一， 一对多 collection，多对多 discrimination
热门推荐
qq_20610631的博客
08-16 2万+
目录 association 一对一， 一对多  collection，多对多 discrimination assiociation(一对一) 实现方式一： 实现方式二（association方式一）： 实现方式三（association方式二）： 实现方式四（association方式三）： 一对多collection 多对多 association 一对一， 一对多  co...
＜collection＞和＜association＞标签
weixin_42595206的博客
06-08 3903
collection标签和association标签
association一对一关联查询
qq_35672147的博客
04-04 1088
在使用mybatis的过程中，会用到关联查询，其中的一对一关联查询（如搜索所有订单，并关联查询出下该订单的用户信息，一个订单只能是某一个用户下的，也就是一对一关联查询） 1.第一个办法是直接生成一个含有订单信息和用户信心的实体类，可以不用association标签，直接使用select标签查询，然后自动将查询到的结果封装成这个新的实体类。这个方法会多生成一个新的实体类，有点不太妥 2.第二个方法是...
【MyBatis学习10】关联关系association：1对1关联的三种方法
程序老兵的博客
03-19 1万+
本篇主要讲关联关系：一对一关系与一对多关系。 先建5个表： DROP TABLE IF EXISTS `category`; CREATE TABLE `category` ( `id` int(10) unsigned NOT NULL AUTO_INCREMENT, `catename` varchar(50) NOT NULL, PRIMARY KEY (`id`) ) ENG
association的使用
qq_32067151的博客
05-21 1万+
association----------第六条使用1.目录结构2.Mybatis-config.xml配置&lt;!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd"&gt; &lt;!-- xml核心...
Hibernate多表关联——（一对多关系）
闲来垂钓碧溪上的博客
04-05 2024
hibernate是连接数据库使得更容易操作数据库数据的一个框架，在上期我们演示了单表建立查询。接触过数据库的都知道数据库表有三种关系，。而接下来我们在hibernate中建立关系，首先应该检查一下数据库是否打开，根据，接下来继续建立表的关系。
Hibernate的一对一关联关系
Alan_Xiang的博客
12-05 1013
Hibernate的一对一关联关系，分为基于外键的一对一关联关系和基于主键的一对一关联关系。在这篇文章中，我们以部门和部门经理的例子来说明，一个部门对应唯一一个部门经理，一个部门经理也对应唯一一个部门。 　　在基于外键的一对一关联关系中，一端通过一个主键以外的字段关联另一端的主键，如下图所示： 　　 　　　 　　在基于主键的一对一关联关系中，一端直接通过主键关联另一端的主键，并通过另一端的主
hibernate关联映射(一对多)
mockingbirds的专栏
06-14 1135
这篇博客将会给大家带来hibernate的关联映射的学习。在现实生活中，不仅只是一对一的映射关系，更多的是一对多，多对多等。一对多单项关联映射这里我以网盘为例，一个用户可以拥有多个文件，及用户和文件之间是一对多的关系。 user实体类：public class Users { private int uid; private String uname; //用户上传的所有文
hibernate中维护“一对多”关系的两种方式
My_name_is_ZwZ的博客
10-11 2234
目录   关于数据库中“一对多”关系的介绍 此篇博客所涉及到的数据库 交给“一”的一方来维护“一对多”关系： 交给“多”的一方来维护“一对多”关系 “一对多”关系究竟交给谁维护？ 关于数据库中“一对多”关系的介绍 在数据库设计的时候我们经常会遇到这样的问题：一个表中的字段可以对应另一张表的很多个字段。这样子的关系我们就称之为“一对多”的关系，而如果站在“多”的一方来看的话，就是“多...
hibernate多对一单向关联关系实现源码
10-08
在Java的持久化框架Hibernate中，多对一（ManyToOne）关联关系是一种常见的对象关系映射（ORM）场景。这种关系通常出现在一个实体类拥有多条与另一个实体类相关的记录，而另一个实体类可能只有一条对应的记录。例如...
Hibernate ORM - 一对多双向关联关系
03-28
标题“Hibernate ORM - 一对多双向关联关系”指的是在数据库建模中，Hibernate ORM（对象关系映射）框架如何处理一个实体类（如User）与多个实体类（如Article）之间的关系。在这种关系中，一个用户可以拥有多个文章...
JSP开发之hibernate之单向多对一关联的实例
01-08
一对多的基础上来测试单向多对一的关联 hibernate多对一的关联关系定义： 和单向一对多不同的是：一对多是在意的一方的一方定义set集合，在映射文件中 ：单向多对一，简单很多在多的一方定义一的一方类的...
基于asp.net的教师授课系统设计与实现.docx
最新发布
09-27
基于asp.net的教师授课系统设计与实现.docx
基于Springboot和Vue的精简博客系统源码 精简博客系统代码（程序，中文注释）
09-27
精简博客系统-精简博客系统-精简博客系统-精简博客系统-精简博客系统-精简博客系统-精简博客系统-精简博客系统-精简博客系统-精简博客系统-精简博客系统-精简博客系统 1、资源说明：精简博客系统源码，本资源内项目代码都经过测试运行成功，功能ok的情况下才上传的。 2、适用人群：计算机相关专业(如计算计、信息安全、大数据、人工智能、通信、物联网、自动化、电子信息等)在校学生、专业老师或者企业员工等学习者，作为参考资料，进行参考学习使用。 3、资源用途：本资源具有较高的学习借鉴价值，可以作为“参考资料”，注意不是“定制需求”，代码只能作为学习参考，不能完全复制照搬。需要有一定的基础，能够看懂代码，能够自行调试代码，能够自行添加功能修改代码。 4. 最新计算机软件毕业设计选题大全(文章底部有博主联系方式): https://blog.csdn.net/2301_79206800/article/details/135931154 技术栈、环境、工具、软件： ① 系统环境:Windows ② 开发语言：Java ③ 框架：SpringBoot ④ 架构:B/S、MVC ⑤ 开发环境:IDE
基于asp.net的客户资源管理系统设计与实现.docx
09-27
基于asp.net的客户资源管理系统设计与实现.docx
嵌入式开发入门指南：硬件基础与软件实践
09-27
嵌入式系统是集成了计算机硬件和软件的专用计算系统，广泛应用于各种设备和行业，如家电、汽车、医疗设备和工业自动化等。嵌入式开发涉及
基于若依3.8.7版本的Java+Vue全栈框架设计源码
09-27
该项目是一款基于若依3.8.7版本的Java+Vue全栈框架设计源码，包含609个文件，涵盖259个Java源文件、95个Vue组件、87个SVG文件、76个JavaScript文件、28个XML配置文件、13个Vue模板文件、9个SCSS样式文件、7个批处理文件、5个YAML配置文件、4个PNG图片文件。该源码集成了lombok、knife4j、mybatis-plus等实用库，并需自行掌握具体实现细节。
Hibernate多对一关联详解与映射技巧
本文主要讲解了Hibernate中的多对一单项关联，这是...对于其他类型的关联关系，如一对一、一对多和多对多，同样有相应的映射规则和技巧，但核心思想是清晰定义对象间的依赖和关系，确保数据在持久层的一致性和完整性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值