hibernate关联管理 ---- 一对多、多对一

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

一对多

public class Order {
	private Integer orderId;//主键
	private String orderNo;
	
	//定义一对多的关系时，一定要采用家口方式，不许使用实现类
	private Set<OrderItem> orderItems = new HashSet<OrderItem>();//一对多
	
	private Integer intiOrderItems = 0;//0代表懒加载  1代表立即加载
	
	public Integer getIntiOrderItems() {
		return intiOrderItems;
	}
	public void setIntiOrderItems(Integer intiOrderItems) {
		this.intiOrderItems = intiOrderItems;
	}
	public Set<OrderItem> getOrderItems() {
		return orderItems;
	}
	public void setOrderItems(Set<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;
	}
	
}

 订单项类

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;
	}
	
}

完之后，在hibernate.cfg.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>
<!-- table:实体类所对应的表
	name:实体类的全类名 -->
	<class table="t_hibernate_order" name="com.zking.four.entity.Order">
		<!-- name:实体类的属性
			type:实体类的属性类型
			column：数据库表的主键列
		-->
		<id name="orderId" type="java.lang.Integer" column="order_id">
		<!-- 自动增长 -->
			<generator class="increment"></generator>
		</id>
		<!--id标签打头，代表配置的书数据库主键与实体类的关系，替他property配置的是数据库表的普通列   -->
		<property name="orderNo" type="java.lang.String" column="order_no"></property>
		<!-- 
		cascade:用来配置维护实体类之间的关系所用
		inverse：关系交由反方控制
		 -->
		<set  name="orderItems" cascade="save-update" inverse="true">
			<!-- 填外键 -->
			<key column="oid"></key>
			<one-to-many class="com.zking.four.entity.OrderItem"/>
		</set>
	</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>
<!-- 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>
		<!--id标签打头，代表配置的书数据库主键与实体类的关系，替他property配置的是数据库表的普通列   -->
		<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.aa.four.entity.OrderItem column: oid
		  (should be mapped with insert="false" update="false")
		  同一个字段被映射了两次
		-->
		<many-to-one name="order" class="com.zking.four.entity.Order" column="oid"></many-to-one>
	</class>
</hibernate-mapping>

 现在我要连级增加订单项写在了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;
	} 用Junit测试时会报错 Repeated column in mapping for entity: com.zking.four.entity.OrderItem column: oid(should be mapped with insert="false" update="false")原因是在orderItem.hbm.xml中外键字段同时被映射了两次那么怎么解决呢？？？？解决：外键处理的三种方式    1、删除从表对应的实体类中的外键属性    2、在配置的xml中外键属性上添加 insert=false，update=false的设置。    3、在配置的xml中的manyToOne标签中添加insert=false，update=false的设置。===================现在要连级新增订单的同时增加订单项//增加订单
	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;
	}

同上用Junit测试增加成功----->是因为在order.hbm.xml中set标签中加入了cascade="save-update" inverse="true"cascade:用来配置维护实体类之间的关系所用--》 增订单时加订单项inverse：关系交由反方控制就是这样子啦！！！！！！==========================

NOW 写一个连级查询单个order的测试//查询单个订单

public Order getOrder(Order order) {
		Session session = SessionFactoryUtils.getSession();
		Transaction transaction = session.beginTransaction();
		Order o = session.get(Order.class, order.getOrderId());
		transaction.commit();
		session.close();
		return o;
	}测试同上@Test
	public void testgetOrder() {
		Order order = new Order();
		order.setOrderId(4);
		order.setIntiOrderItems(1);
		Order o = this.orderDao.getOrder(order);
		System.out.println(o.getOrderNo());
		System.out.println(o.getOrderItems().size());
		// 保存在接口中，PersistentSet
		for (OrderItem orderItem : o.getOrderItems()) {
			System.out.println(orderItem.getProductId());
		}
	}

 加载不出订单项。报了一个代理对象的错

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

在order.hbm.xml的set标签中 lazy=true But  ...这样  查关联的东西出不来可以改为lazy=false

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

 若现在我要查所有订单  还是用lazy=false  查是可以查出来，但性能太差，会查询很多遍综上所述：为了解决查单个的问题，我们可以通过字段控制，强制加载。Hibernate.initialize(),在dao方法加入打星星这段，判断是否是懒加载，不是的话就强制加载，加变成立即加载了。哈哈哈哈！！！

private Integer intiOrderItems = 0;//0代表懒加载  1代表立即加载
	
	public Integer getIntiOrderItems() {
		return intiOrderItems;
	}/查询单个订单
	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.getIntiOrderItems())) {
			Hibernate.initialize(o.getOrderItems());
		}
                //******************************
		transaction.commit();
		session.close();
		return o;
	}

=======================

最后说一下普通的连级删除，若不写以下foreach循环的话，那么就删除不了，连级删除的方法就是先删除从表，在删除主表，这就是hibernate的方法，但也有它的优缺点：

优点：不用写太多复杂的sql语句

缺点：删除时由一步变成了三步//连级删除

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();
	}

总结一下：

①级联新增    

外键处理的三种方式  

 1、删除从表对应的实体类中的外键属性  

 2、在配置的xml中外键属性上添加 insert=false，update=false的设置。  

 3、在配置的xml中的manyToOne标签中添加insert=false，update=false的设置。    

级联新增    casecade=save-update 介绍。。。

②级联查询    

配置文件介绍以及后台sql的形成过程    

级联查询时的问题    

Lazy=true介绍    查单个时存在问题  查关联的东西出不来  lazy=false查单个没毛病  

 Lazy=false介绍    查所有时存在问题  好性能  

 解决方案：通过字段控制，强制加载。Hibernate.initialize()

③普通删除    Order    Add 讲外键的处理  

 Get/list    order.getOrderItems.size讲懒加载的处理，sql形成过程    

Del    将关系的处理中的删除  

1优缺：不用写太多复杂的sql语句，删除时由一部变成了三部

============================================

今天的知识点完美告一段落了！！！查所有还要等学了多对多才会，蒸蒸日上！！！！！！