hibernate关联关系（一对多）以及懒加载

hibernate关联关系（一对多）

1.什么是关联(association)
关联指的是类之间的引用关系。如果类A与类B关联，那么被引用的类B将被定义为类A的属性。

  t_hibernate_order
	  t_hibernate_order_item
	  一个订单对应多个订单项
	  
	  class Order{ //一个订单对应多个订单项
		private List<OrderItem> orderItems;
	  }
	  
	  class OrderItem{//一个订单项对应一个订单
		private Order order;
	  }
	  

需求：
解决每次增加订单时需要操作数据库的两张表（订单表以及订单项表）
提供项目大体图片：

提供代码：
DemoDao.java

package com.wangcong.three.dao;

import java.util.List;

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

import com.wangcong.three.entity.Order;
import com.wangcong.three.entity.OrderItem;
import com.wangcong.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();
	}
}

DemoDaoTest.java

package com.wangcong.three.dao;

import static org.junit.Assert.*;


import org.junit.Test;

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

public class DemoDaoTest {
	private DemoDao demoDao=new DemoDao();

	@Test
	public void testAddOrder() {
		Order order=new Order();
		order.setOrderNo("T237购物");
		for (int i = 0; i < 6; i++) {
			OrderItem oi=new OrderItem();
			oi.setProductId(10+i);
			oi.setQuantity(20+i);
//以前做法	  demoDao.addOrderItem(oi);
			//绑定订单项和订单的关系
			order.getOrderItems().add(oi);
			oi.setOrder(order);
		}
//以前做法       demoDao.addOrder(order);
		demoDao.addOrder(order);
	}

	@Test
	public void testAddOrderItem() {
	}

	@Test
	public void testGetOrder() {
	}

	@Test
	public void testGetOrderList() {
	}

	@Test
	public void testDelOrder() {
	}

}

Order.java

package com.wangcong.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<>();

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.java

package com.wangcong.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;
}
@Override
public String toString() {
	return "OrderItem [orderItemId=" + orderItemId + ", productId=" + productId + ", quantity=" + quantity + ", oid="
			+ oid + "]";
}

}

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.zking.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标签：e
		name:当前要映射的类的关联属性
		cascade:维护关联关系
		inverse:决定由谁来维护关联关系
		
		key标签
		column:表的外键对应的列段
		
		one-to-many：
		class:关联属性对应的类的全路径名
		 -->
		<bag name="orderItems" inverse="true" cascade="save-update">
		<key column="oid"></key>
		<one-to-many class="com.wangcong.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.wangcong.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">
		</property>
		<!-- many-to-one
		    多对一的配置(因为多个订单项对应一个订单）
		    name:指的是当前所要映射的类的关联com.wangcong.three.entity.OrderItem属性order
		    class:指的是关联属性的类别（全路径名）
		    column:填的是从表外键(主表是一的一方：从表是多的一方)
		 -->
		<many-to-one name="order" class="com.wangcong.three.entity.Order" column="oid"></many-to-one>
	</class>
</hibernate-mapping>

并且在hibernate.cfg.xml进行配置

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
	"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
	"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
	<session-factory>
		<!-- 1. 数据库相关 -->
		<property name="connection.username">root</property>
		<property name="connection.password">123</property>
		<property name="connection.url">jdbc:mysql://localhost:3306/hibernate?useUnicode=true&amp;characterEncoding=UTF-8
		</property>
		<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
		<!-- <property name="dialect">org.hibernate.dialect.MySQLDialect</property> -->
     <property name="dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property> 
      <!--  <property name="dialect">org.hibernate.dialect.Oracle12cDialect</property>  -->
       <!-- 14与19行一起使用 -->
		<!-- 配置本地事务（No CurrentSessionContext configured!） -->
		<property name="hibernate.current_session_context_class">thread</property>
       <property name="hbm2ddl.auto">update</property> 
		<!-- 2. 调试相关  -->
		<!-- 后台执行了什么sql控制台会打印 -->
		<property name="show_sql">true</property>
		<!-- 换行作用，格式化比较漂亮一些 -->
		<property name="format_sql">true</property>

		<!-- 3. 添加实体映射文件 -->
		<mapping resource="com/wangcong/one/entity/User.hbm.xml"/>
		<!-- 讲解主键生成策略 -->
		<mapping resource="com/wangcong/two/entity/Student.hbm.xml" />
		<mapping resource="com/wangcong/two/entity/Worker.hbm.xml" /> 
		<!-- 讲解一对多 -->
		<mapping resource="com/wangcong/three/entity/Order.hbm.xml" />
		<mapping resource="com/wangcong/three/entity/OrderItem.hbm.xml" />  
	</session-factory>
</hibernate-configuration>

运行有错误：
如图：

解决方案：（粗心导致）

问题二：（列段维护问题）
在OrderItem.hbm.xml中有两个对oid进行了维护需要有一个放弃维护

解决方案：

测试成功。

测试增加订单项：
提供DemoDaoTest.java

package com.wangcong.three.dao;

import static org.junit.Assert.*;


import org.junit.Test;

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

public class DemoDaoTest {
	private DemoDao demoDao=new DemoDao();

	@Test
	public void testAddOrder() {
		Order order=new Order();
		order.setOrderNo("T237购物");
		for (int i = 0; i < 6; i++) {
			OrderItem oi=new OrderItem();
			oi.setProductId(10+i);
			oi.setQuantity(20+i);
//以前做法	  demoDao.addOrderItem(oi);
			//绑定订单项和订单的关系
			order.getOrderItems().add(oi);
			oi.setOrder(order);
		}
//以前做法       demoDao.addOrder(order);
		demoDao.addOrder(order);
	}

	@Test
	public void testAddOrderItem() {
		OrderItem oi=new OrderItem();
		oi.setProductId(66);
		oi.setQuantity(66);
		Order order=new Order();
		order.setOrderId(11);
		oi.setOrder(order);
		demoDao.addOrderItem(oi);
	}

	@Test
	public void testGetOrder() {
	}

	@Test
	public void testGetOrderList() {
	}

	@Test
	public void testDelOrder() {
	}

}

结果：

懒加载

测试：
提供DemoDaoTest.java

package com.wangcong.three.dao;

import static org.junit.Assert.*;


import org.junit.Test;

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

public class DemoDaoTest {
	private DemoDao demoDao=new DemoDao();

	@Test
	public void testAddOrder() {
		Order order=new Order();
		order.setOrderNo("T237购物");
		for (int i = 0; i < 6; i++) {
			OrderItem oi=new OrderItem();
			oi.setProductId(10+i);
			oi.setQuantity(20+i);
//以前做法	  demoDao.addOrderItem(oi);
			//绑定订单项和订单的关系
			order.getOrderItems().add(oi);
			oi.setOrder(order);
		}
//以前做法       demoDao.addOrder(order);
		demoDao.addOrder(order);
	}

	@Test
	public void testAddOrderItem() {
		OrderItem oi=new OrderItem();
		oi.setProductId(66);
		oi.setQuantity(66);
		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);
		//得到11这个订单
		System.out.println(o.getOrderNo());
		//得到11所有的订单项
		System.out.println(o.getOrderItems());
	}

	@Test
	public void testGetOrderList() {
	}

	@Test
	public void testDelOrder() {
	}

}

问题：懒加载问题

两种解决方案：
第一种:(不推荐）
在Order.hbm.xml文件

即可解决问题。
测试：

	@Test
	public void testGetOrderList() {
		List<Order> orderlist=new 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
T237购物
7

每次这样查询每次sql语句进行多次（多少条数据就进行多少次+1）。导致性能变差

提供第二种处理方法：

更改Order.java

package com.wangcong.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 InitChildren=0;//0代表默认。默认代表懒加载.1代表强制加载


public Integer getInitChildren() {
	return InitChildren;
}
public void setInitChildren(Integer initChildren) {
	InitChildren = initChildren;
}
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 + "]";
}

}

更改DenoDao.java方法：

package com.wangcong.three.dao;

import java.util.List;

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

import com.wangcong.three.entity.Order;
import com.wangcong.three.entity.OrderItem;
import com.wangcong.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();
	}
}

测试DemoDaoTest.java中的testGetOrdee不报错，问题解决

进行删除方法：
提供DemoDaoTest.java

package com.wangcong.three.dao;

import static org.junit.Assert.*;

import java.util.List;

import org.junit.Test;

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

public class DemoDaoTest {
	private DemoDao demoDao=new DemoDao();

	@Test
	public void testAddOrder() {
		Order order=new Order();
		order.setOrderNo("T237购物");
		for (int i = 0; i < 6; i++) {
			OrderItem oi=new OrderItem();
			oi.setProductId(10+i);
			oi.setQuantity(20+i);
//以前做法	  demoDao.addOrderItem(oi);
			//绑定订单项和订单的关系
			order.getOrderItems().add(oi);
			oi.setOrder(order);
		}
//以前做法       demoDao.addOrder(order);
		demoDao.addOrder(order);
	}

	@Test
	public void testAddOrderItem() {
		OrderItem oi=new OrderItem();
		oi.setProductId(66);
		oi.setQuantity(66);
		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.setInitChildren(1);
		Order o = demoDao.getOrder(order);
		//得到11这个订单
		System.out.println(o.getOrderNo());
		//得到11所有的订单项
		System.out.println(o.getOrderItems());
	}

	@Test
	public void testGetOrderList() {
		List<Order> orderlist=new DemoDao().getOrderList();
		for (Order order : orderlist) {
			System.out.println(order.getOrderNo());
		//System.out.println(order.getOrderItems().size());
		}
	}
//删除
	@Test
	public void testDelOrder() {
		Order order=new Order();
		order.setOrderId(11);
		this.demoDao.delOrder(order);
	}

}

测试结果成功：
Console控制台显示

Hibernate: 
    select
        order0_.order_id as order_id1_0_0_,
        order0_.order_no as order_no2_0_0_ 
    from
        t_hibernate_order order0_ 
    where
        order0_.order_id=?
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: 
    delete 
    from
        t_hibernate_order_item 
    where
        order_item_id=?
Hibernate: 
    delete 
    from
        t_hibernate_order_item 
    where
        order_item_id=?
Hibernate: 
    delete 
    from
        t_hibernate_order_item 
    where
        order_item_id=?
Hibernate: 
    delete 
    from
        t_hibernate_order_item 
    where
        order_item_id=?
Hibernate: 
    delete 
    from
        t_hibernate_order_item 
    where
        order_item_id=?
Hibernate: 
    delete 
    from
        t_hibernate_order_item 
    where
        order_item_id=?
Hibernate: 
    delete 
    from
        t_hibernate_order_item 
    where
        order_item_id=?
Hibernate: 
    delete 
    from
        t_hibernate_order 
    where
        order_id=?