hiberbate一对多的级联新增和级联查询与级联删除

1. 什么是关联(association)
1.1 关联指的是类之间的引用关系。如果类A与类B关联，那么被引用的类B将被定义为类A的属性。例如:
public class A{
private B b = new B;
public A(){}
}
1.2 关联的分类：关联可以分为一对一、一对多/多对一、多对多关联
关联是有方向的

2. 案例:如何建立客户和订单一对多双向关联
   2.1 先建立客户和订单的关联关系,定义实体及映射文件,单独执行保存操作
   2.2 建立客户到订单的一对多关联关系
   
   
   
   

2.3 建立订单到客户的多对一关联关系

  <!--1.注释 2.只读-->
  <property name="cid" type="java.lang.Integer" column="cid" insert="false" update="false">
  </property>

2.4 注意:在Hibernate当中定义实体对象的集合属性时,只能使用接口而不能使用类
级联新增
外键处理的三种方式
1、删除从表对应的实体类中的外键属性
2、在配置的xml中外键属性上添加 insert=false，update=false的设置。
3、在配置的xml中的manyToOne标签中添加insert=false，update=false的设置。
级联新增 casecade=save-update 介绍

级联查询
配置文件介绍以及后台sql的形成过程
级联查询时的问题
Lazy=true介绍 查单个时存在问题
Lazy=false介绍 查所有时存在问题
解决方案：通过字段控制，强制加载。Hibernate.initialize()

普通删除
Order
Add 讲外键的处理
Get/list order.getOrderItems.size讲懒加载的处理，sql形成过程
Del 将关系的处理中的删除

  **一对多主表xml创建代码**

<!DOCTYPE hibernate-configuration PUBLIC
	"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
	"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
	<hibernate-mapping>
	
		<class  table="t_hibernate_order" name="com.zking.four.entity.Order">
		
			<id name="orderId" type="java.lang.Integer" column="order_id">
				<generator class="increment"></generator>
			</id>
			<property name="orderNo" type="java.lang.String" column="order_no"></property>
			<!-- 
				cascade:用来维护实体类之间的关系所用
				inverse：关系交由反方控制
			 -->
			<set name="orderItems" cascade="save-update" inverse="true">
			<!-- column:填外键 -->
				<key column="oid"></key>
				<one-to-many class="com.zking.four.entity.OrderItem"></one-to-many>
			</set>
		</class>
	</hibernate-mapping>

  **一对多从表xml创建代码**

<!DOCTYPE hibernate-configuration PUBLIC
	"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
	"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
	<hibernate-mapping>
	<!-- 
		table:实体类所对应表
		name:实体类的全类名
	 -->
		<class  table="t_hibernate_order_item" name="com.zking.four.entity.OrderItem">
		<!-- 
			name：实体类的属性
			type：实体类的属性类型
			column:指的是数据库表的主键列
		 -->
			<id name="orderitemId" type="java.lang.Integer" column="order_item_id">
				<generator class="increment"></generator>
			</id>
			<property name="productId" type="java.lang.Integer" column="product_id"></property>
			<property name="quantity" type="java.lang.Integer" column="quantity"></property>
			<!-- 
				oid：oid为主表与从表的关联属性
				insert="false" update="false"：代表该属性不能新增（insert）也不能修改（update）只能由主表控制
			 -->
			<property name="oid" type="java.lang.Integer" column="oid" insert="false" update="false"></property>
			
			<many-to-one name="order"  class="com.zking.four.entity.Order" column="oid">
			
			</many-to-one>

		</class>
	</hibernate-mapping>

dao方法

import java.io.Serializable;
import java.util.List;

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

import com.zking.four.entity.Order;
import com.zking.four.entity.OrderItem;
import com.zking.two.util.SessionFactoryUtils;

public class OrderDao {
	
	//增加订单项
	public Integer addOrderItem(OrderItem orderitem) {
		Session session = SessionFactoryUtils.getSession();
		Transaction  transaction= session.beginTransaction();
		Integer otid = (Integer)session.save(orderitem);
		transaction.commit();
		session.close();
		return otid;	
	}
	
	//增加订单
	public Integer addOrder(Order order) {
		Session session = SessionFactoryUtils.getSession();
		Transaction transaction = session.beginTransaction();
		Integer otid = (Integer) session.save(order);
		transaction.commit();
		session.close();
		return otid;
	}
	
	//查询
		public Order getOrder(Order order) {
			Session session = SessionFactoryUtils.getSession();
			Transaction transaction = session.beginTransaction();
			Order o = session.get(Order.class,order.getOrderId());
			if(o!=null&&new Integer(1).equals(order.getInitorderItems())) {
				Hibernate.initialize(o.getOrderItems());
			}
			transaction.commit();
			session.close();
			return o;
		}
		
		public List<Order> getOrderList(){
			Session session = SessionFactoryUtils.getSession();
			Transaction transaction = session.beginTransaction();
			List<Order> list = session.createQuery("from Order").list();
			transaction.commit();
			session.close();
			return list;
		
		}
		
		
		public void delOrder(Order order) {
			Session session = SessionFactoryUtils.getSession();
			Transaction transaction = session.beginTransaction();
			Order o = session.get(Order.class, order.getOrderId());
			for (OrderItem ot : o.getOrderItems()) {
				session.delete(ot);
			}
			session.delete(o);
			transaction.commit();
			session.close();
			
			
		}
}

测试代码

import java.util.Iterator;
import java.util.List;

import org.junit.Test;

import com.zking.four.entity.Order;
import com.zking.four.entity.OrderItem;

public class OrderDaoTest {
	private OrderDao orderdao=new OrderDao();

	@Test
	public void testAddOrderItem() {
		OrderItem orderItem=new OrderItem();
//		orderItem.setOid(10);
		orderItem.setProductId(66);
		orderItem.setQuantity(56);
		Order order=new Order();
		order.setOrderId(1);
		orderItem.setOrder(order);;
		this.orderdao.addOrderItem(orderItem);
	}
	
	@Test
	public void testAddOrder() {
		Order order=new Order();
		order.setOrderNo("jh");
		OrderItem orderItem;
		for (int i = 1; i <=6; i++) {
			orderItem=new OrderItem();
			orderItem.setProductId(665);
			orderItem.setQuantity(566);
			order.getOrderItems().add(orderItem);
			orderItem.setOrder(order);
		}
		this.orderdao.addOrder(order);
	}
	
	//查当个
	@Test
	public void testgetOrder() {
		Order order=new Order();
		order.setOrderId(2);
		order.setInitorderItems(1);
		Order o = this.orderdao.getOrder(order);
		System.out.println(o.getOrderNo());
		for (OrderItem ot : o.getOrderItems()) {
			System.out.println(ot.getProductId());
		}
	}
	
	
	//查所有
	@Test
	public void testgetOrderlist() {
		 List<Order> orderList = this.orderdao.getOrderList();
		for (Order o : orderList) {
			System.out.println(o.getOrderNo());
			for (OrderItem ot : o.getOrderItems()) {
				System.out.println(ot.getProductId());
			}
		}
	}
	
	
	//查所有
		@Test
		public void testDelOrder() {
			Order order=new Order();
			order.setOrderId(1);
			this.orderdao.delOrder(order);
		}

}