hibernate关联关系（一对多）

于 2019-08-04 19:55:38 发布
阅读量141 收藏
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 原创 文章标签： hibernate关联关系（一对多）
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_45139031/article/details/98471649

什么是关联(association)
关联指的是类之间的引用关系。如果类A与类B关联，那么被引用的类B将被定义为类A的属性。
例如:
B类作为A类的一个属性，那么就是B与A有关联关系

   class B{
		private String name;
	  }
	  public class A{
        private B b = new B;
        public A(){}
      }

关联的分类： 关联可以分为一对一、一对多/多对一、多对多关联
关联是有方向的

这次我们就来写一个 hibernate实现订单与订单项的一对多的增删改查

这次我们要用到两个表，所有我们要建立两个实体类：
代码如下：
实体类：orderNo
orderNo实体类中 我添加了一个懒加载 ，等一下我会在下面详细的述说；
我们继续往下面走

package com.thf.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<>();
	private Integer ininChildren=1;//1代表开启懒加载，如果等于0那代表关闭懒加载
	
	
	
	public Integer getIninChildren() {
		return ininChildren;
	}
	public void setIninChildren(Integer ininChildren) {
		this.ininChildren = ininChildren;
	}
	public List<OrderItem> getOrderItems() {
		return orderItems;
	}
	public void setOrderItems(List<OrderItem> orderItems) {
		this.orderItems = orderItems;
	}
	
	
	
	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;
	}
	@Override
	public String toString() {
		return "Order [orderId=" + orderId + ", orderNo=" + orderNo + ", orderItems=" + orderItems + "]";
	}
	public Order(Integer orderId, String orderNo) {
		super();
		this.orderId = orderId;
		this.orderNo = orderNo;
	}
	public Order() {
		super();
	}
	
	
}

实体类 （OrderItem）：

package com.thf.three.entity;

public class OrderItem {
	private Integer orderItemId;
	private Integer productId;
	private Integer quantity;
	private Integer oid;
	private Order order;

	public Order getOrder() {
		return order;
	}
	public void setOrder(Order order) {
		this.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 OrderItem(Integer orderItemId, Integer productId, Integer quantity, Integer oid) {
		super();
		this.orderItemId = orderItemId;
		this.productId = productId;
		this.quantity = quantity;
		this.oid = oid;
	}
	public OrderItem() {
		super();
	}
	
	

}

然后配置映射文件，在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.thf.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 lazy="false" name="orderItems" cascade="save-update" inverse="true">
		<!--从表的外键  -->
		<key column="oid"></key> 
		<!-- 查询从表数据 然后形成list集合填充到orderItems属性中 -->
		<one-to-many class="com.thf.three.entity.OrderItem"/>
		</bag>
	</class>

</hibernate-mapping>

然后再在OrderItem.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.thf.three.entity.OrderItem" table="t_hibernate_order_item">
		<id name="orderItemId" type="java.lang.Integer" column="order_item_id">
			<generator class="increment" />
		</id>
		<property name="productId" type="java.lang.Integer" column="product_id">
		</property>
		<property name="quantity" type="java.lang.Integer" column="quantity">
		</property>
		<property name="oid" type="java.lang.Integer" column="oid" insert="false" update="false">
		</property>
		<!--需要在映射文件中进行关联关系的维护  这里描述的是多对一 的关系 -->
<!-- Repeated column in mapping for entity: com.thf.three.entity.OrderItem column: oid (should be mapped with insert="false" update="false") -->
	  
	  <many-to-one name="order" class="com.thf.three.entity.Order" column="oid"> </many-to-one>
		
	</class>
</hibernate-mapping>

这个就确定了是在那个的表的对应关系

  <many-to-one name="order" class="com.thf.three.entity.Order" column="oid"> </many-to-one>

然后我们在 hibernate.cfg.xml 配置好映射文件

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

然后我们导入我们的工具类
SessionFactoryUtils

package com.thf.three.util;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class SessionFactoryUtils {
	private static SessionFactory sessionFactory;
	static {
		Configuration cfg = new Configuration().configure("hibernate.cfg.xml");
		sessionFactory = cfg.buildSessionFactory();
	}
	
	public static Session openSession() {
		Session session = sessionFactory.getCurrentSession();
		if(session == null) {
			session = sessionFactory.openSession();
		}
		return session;
	}
	
	public static void closeSession() {
		Session session = sessionFactory.getCurrentSession();
		if(session != null && session.isOpen()) {
			session.close();
		}
	}
	
	public static void main(String[] args) {
		Session session = SessionFactoryUtils.openSession();
		session.beginTransaction();
		System.out.println(session.isConnected());
		SessionFactoryUtils.closeSession();
		System.out.println(session.isConnected());
	}
}

然后我们开始测试：
DemoDao

package com.thf.three.dao;

import java.util.List;

import org.hibernate.Hibernate;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import com.thf.three.entity.Order;
import com.thf.three.entity.OrderItem;
import com.thf.three.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(0).equals(order.getIninChildren())) {
			//0代表了程序员想要关闭的懒加载 ，也就意味着需要强制加载关联关系对象
			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();
	}
}

DemoDaoTest
使用junit进行单个测试
增加一个订单与订单项

	private DemoDao demoDao=new DemoDao();

	@Test
	public void testAddOrder() {
		Order order=new Order(); 
		order.setOrderNo("thf");
	    OrderItem oi=null;
	    for (int i = 0; i < 3; i++) {
			oi=new OrderItem();
			oi.setProductId(10+i);
			oi.setQuantity(20+i);
			oi.setOrder(order);
			order.getOrderItems().add(oi);
		}
	    demoDao.addOrder(order);
	}

我们运行会报一个错误
原因：映射文件映射了两次column=“oid”
Repeated column in mapping for entity: com.thf.three.entity.OrderItem column: oid (should be mapped with insert=“false” update=“false”)

解决这个bug 我们要把这一串代码放入
insert=“false” update=“false” 放在column="oid"后面

<property name="oid" type="java.lang.Integer" column="oid" insert="false" update="false"></property>

然后我们在看一下效果
我们数据已经到数据库了
在这里插入图片描述
在这里插入图片描述

懒加载测试

懒加载是：lazy
lazy：这个参数，就是是否开启懒加载模式，为了节省性能，我们在实体类中定义了一个属性来控制是否开启懒加载模式
懒加载就是它会把这个属性关联的另外一个类的表的所用关联数据也查出来，意思就是，我本来只查询了order所有数据，它自动会把这些订单里的订单项数据也全部查出来

	/**
	 * 关于懒加载的问题
	 * hibernate3之后出现的
	 * failed to lazily initialize a collection of role:
	 *  com.thf.three.entity.Order.orderItems, could not initialize 
	 * proxy - no Session
	 * 
	 * orderNo数据来源于t_hivernate_order
	 * OrderItems 数据来源于t_hivernate_order_item
	 * 
	 * 思考：
	 * 查一张表的效率高还是两张？
	 * 一张
	 * 
	 * hibernate默认的策略：是不查询关联关系对应关联表数据的
	 * 
	 */
	@Test
	public void testGetOrder() {
		Order order=new Order();
		order.setOrderId(10);
		Order o = this.demoDao.getOrder(order);
		System.out.println(o.getOrderNo());
		System.out.println(o.getOrderItems());
	}

	/**
	 * 如果说将懒加载的功能关闭  也就是lazy=false,
	 * 那么在查询多条订单数据情况下是非常 影响性能的
	 * 
	 * 思考：
	 * 查单个需要关闭懒加载，目的是需要加载出关联表的数据
	 * 差多个不能关闭懒加载，加载关联表的数据的查询次数过多
	 * 
	 */
	@Test
	public void testGetOrderList() {
		List<Order> orderList = this.demoDao.getOrderList();
		for (Order order : orderList) {
			System.out.println(order.getOrderNo());
			//System.out.println(order.getOrderItems());
		}
	}

运行会报一个错误：

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

这个错误怎么解决呢？
只需要我们 加上 lazy=“false” 如果是true 的话就代表用到了懒加载，false就代表没有用到。

  <bag lazy="false" name="orderItems" cascade="save-update" inverse="true">

如果是将懒加载的功能关闭，也就是lazy=false，那么在查询多条数据订单的情况下是非常影响性能的！
所有我们要用另外一种方式：
我们在Order 实体类加上一个ininChildren属性：
如果这个 ininChildren=1; 1代表开启懒加载，如果等于0那代表关闭懒加载
这个我们可以自己控制是否开启懒加载

    private Integer ininChildren=1;//1代表开启懒加载，如果等于0那代表关闭懒加载
	public Integer getIninChildren() {
		return ininChildren;
	}
	public void setIninChildren(Integer ininChildren) {
		this.ininChildren = ininChildren;
	}

接下来我们还要看一下DemoDao.java里面getOrder这个方法


	/**
	 * 为了讲解懒加载的问题（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(0).equals(order.getIninChildren())) {
			//0代表了程序员想要关闭的懒加载 ，也就意味着需要强制加载关联关系对象
			Hibernate.initialize(o.getOrderItems());
			//System.out.println(o.getOrderItems());
		}
		transaction.commit();
		session.close();
		return o;
	}

然后我们在DemoDaoTest.java进入测试

/**
	 * 关于懒加载的问题
	 * hibernate3之后出现的
	 * failed to lazily initialize a collection of role:
	 *  com.thf.three.entity.Order.orderItems, could not initialize 
	 * proxy - no Session
	 * 
	 * orderNo数据来源于t_hivernate_order
	 * OrderItems 数据来源于t_hivernate_order_item
	 * 
	 * 思考：
	 * 查一张表的效率高还是两张？
	 * 一张
	 * 
	 * hibernate默认的策略：是不查询关联关系对应关联表数据的
	 * 
	 */
	@Test
	public void testGetOrder() {
		Order order=new Order();
		order.setOrderId(10);
		Order o = this.demoDao.getOrder(order);
		System.out.println(o.getOrderNo());
		System.out.println(o.getOrderItems());
	}

	/**
	 * 如果说将懒加载的功能关闭  也就是lazy=false,
	 * 那么在查询多条订单数据情况下是非常 影响性能的
	 * 
	 * 思考：
	 * 查单个需要关闭懒加载，目的是需要加载出关联表的数据
	 * 差多个不能关闭懒加载，加载关联表的数据的查询次数过多
	 * 
	 */
	@Test
	public void testGetOrderList() {
		List<Order> orderList = this.demoDao.getOrderList();
		for (Order order : orderList) {
			System.out.println(order.getOrderNo());
			//System.out.println(order.getOrderItems());
		}
	}

最后一个删除

@Test
	public void testDelOrder() {
		Order order=new Order();
		order.setOrderId(11);
		this.demoDao.delOrder(order);
		
	}

我们来看一下效果：
我们要删除order的OrderId为11的
在这里插入图片描述
id11的已经被删除，
在这里插入图片描述
OK!

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值