《hibernate的一对多的关系》

1.entity

package com.zy.three.entity;

import java.util.HashSet;
import java.util.Set;

public class Order {
	
//	order_id int primary key auto_increment,
//	order_no varchar(50) not null
	
	private Integer order_id;
	private String order_no;
	
	private Set<OrderItem> orderItem = new HashSet<>();
	
	private Integer initOrderItem = 0; //0:代表懒加载，1:代表强制加载
	
	public Set<OrderItem> getOrderItem() {
		return orderItem;
	}
	public void setOrderItem(Set<OrderItem> orderItem) {
		this.orderItem = orderItem;
	}
	
	public Integer getInitOrderItem() {
		return initOrderItem;
	}
	public void setInitOrderItem(Integer initOrderItem) {
		this.initOrderItem = initOrderItem;
	}
	
	public Integer getOrder_id() {
		return order_id;
	}
	public void setOrder_id(Integer order_id) {
		this.order_id = order_id;
	}
	public String getOrder_no() {
		return order_no;
	}
	public void setOrder_no(String order_no) {
		this.order_no = order_no;
	}
	
	public Order() {
		super();
	}
	public Order(Integer order_id, String order_no) {
		super();
		this.order_id = order_id;
		this.order_no = order_no;
	}
	
	@Override
	public String toString() {
		return "Order [order_id=" + order_id + ", order_no=" + order_no + "]";
	}
	

}

package com.zy.three.entity;

public class OrderItem {
	
//	  order_item_id int primary key auto_increment,
//	  product_id int not null,
//	  quantity int not null,
//	  oid int not null,
	
	private Integer order_item_id;
	private Integer product_id;
	private Integer quantity;
	private Integer oid;
	
	private Order order;
	
	public Order getOrder() {
		return order;
	}
	public void setOrder(Order order) {
		this.order = order;
	}
	
	public Integer getOrder_item_id() {
		return order_item_id;
	}
	public void setOrder_item_id(Integer order_item_id) {
		this.order_item_id = order_item_id;
	}
	public Integer getProduct_id() {
		return product_id;
	}
	public void setProduct_id(Integer product_id) {
		this.product_id = product_id;
	}
	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() {
		super();
	}
	public OrderItem(Integer order_item_id, Integer product_id, Integer quantity, Integer oid) {
		super();
		this.order_item_id = order_item_id;
		this.product_id = product_id;
		this.quantity = quantity;
		this.oid = oid;
	}
	
	@Override
	public String toString() {
		return "OrderItem [order_item_id=" + order_item_id + ", product_id=" + product_id + ", quantity=" + quantity + ", oid=" + oid + "]";
	}
	

}

2.entity.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>
    <!-- name:类的全限定名； table:类对应的数据库表名 -->
	<class name="com.zy.three.entity.Order" table="t_hibernate_order">
	    <!-- name:实体类属性名； type：类属性类型； column:表列列段名 -->
		<id name="order_id" type="java.lang.Integer" column="order_id">
		    <!-- 配置数据库表的主键生成策略 -->
			<generator class="increment"/> <!-- 自增长id(用于int/Integer):increment; 随机id(用于String):uuid; 自己配置：assigned; 数据库控制：identity-->
		</id>
		
		<!-- name:实体类属性名； type：类属性类型； column:表列列段名 -->
		<property name="order_no" type="java.lang.String" column="order_no"></property>
		
		<!-- lazy:是否懒加载，  cascade:级联属性的配置，  inverse：关联关系交给对方维护吗-->
		<set name="orderItem" cascade="save-update" inverse="true">
		     <key column="oid"></key>
		     <one-to-many class="com.zy.three.entity.OrderItem"/>
		</set>
		
	</class>
</hibernate-mapping>

<?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>
    <!-- name:类的全限定名； table:类对应的数据库表名 -->
	<class name="com.zy.three.entity.OrderItem" table="t_hibernate_order_item">
	    <!-- name:实体类属性名； type：类属性类型； column:表列列段名 -->
		<id name="order_item_id" type="java.lang.Integer" column="order_item_id">
		    <!-- 配置数据库表的主键生成策略 -->
			<generator class="increment"/> <!-- 自增长id(用于int/Integer):increment; 随机id(用于String):uuid; 自己配置：assigned; 数据库控制：identity-->
		</id>
		
		<!-- name:实体类属性名； type：类属性类型； column:表列列段名 -->
		<property name="product_id" 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>
		
		<!-- name:类属性   class：类全限定名  column:外键 -->
		<!-- 错误：Caused by: org.hibernate.MappingException: Repeated column in mapping for entity: com.zy.three.entity.OrderItem column: oid (should be mapped with insert="false" update="false") -->
		<many-to-one name="order" class="com.zy.three.entity.Order" insert="false" update="false" column="oid"></many-to-one>
		
	</class>
</hibernate-mapping>

3.hibernate.cfg.xml

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

4.dao

package com.zy.three.dao;

import java.util.List;

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

import com.zy.three.entity.Order;
import com.zy.three.entity.OrderItem;
import com.zy.two.util.SessionFactoryUtil;

public class OrderDao {
	
	/**
	 * 增加订单方法
	 * @param order
	 */
	public void addOrder(Order order) {
		Session session = SessionFactoryUtil.getSession(); //获取session会话
		Transaction transaction = session.beginTransaction(); //开启事物
		session.save(order); //操作数据库
		transaction.commit(); //提交事物
		session.close(); //关闭会话
	}
	
	/**
	 * 查询
	 * @param order
	 * @return
	 */
	public Order get(Order order) {
		Session session = SessionFactoryUtil.getSession(); //获取session会话
		Transaction transaction = session.beginTransaction(); //开启事物
		Order os = session.get(Order.class, order.getOrder_id()); //操作数据库
		
		//如果查询订单的数据不为空，并且设置的是强制加载（0:代表懒加载，1:代表强制加载）
		if(os != null && new Integer(1).equals(order.getInitOrderItem())) {
			Hibernate.initialize(os.getOrderItem()); //强制加载第二张表的数据（订单项表）
		}
		transaction.commit(); //提交事物
		session.close(); //关闭会话
		return os;
	}
	
	/**
	 * 查询所有
	 * @return
	 */
	public List<Order> OrderList(Order order) {
		Session session = SessionFactoryUtil.getSession(); //获取session会话
		Transaction transaction = session.beginTransaction(); //开启事物
		List<Order> oList = session.createQuery("from Order").list(); //操作数据库
		for (Order o : oList) {
			//如果查询订单的数据不为空，并且设置的是强制加载（0:代表懒加载，1:代表强制加载）
			if(o != null && new Integer(1).equals(order.getInitOrderItem())) {
				Hibernate.initialize(o.getOrderItem()); //强制加载第二张表的数据（订单项表）
			}
		}
		transaction.commit(); //提交事物
		session.close(); //关闭会话
		return oList;
	}
	
	/**
	 * 删除
	 * @param order
	 */
	public void delete(Order order) {
		Session session = SessionFactoryUtil.getSession(); //获取session会话
		Transaction transaction = session.beginTransaction(); //开启事物
		
		Order os = session.get(Order.class, order.getOrder_id()); //操作数据库
		for (OrderItem oi : os.getOrderItem()) {
			session.delete(oi);
		}
		session.delete(os);
		
		transaction.commit(); //提交事物
		session.close(); //关闭会话
	}
	
}

package com.zy.three.dao;

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

import com.zy.three.entity.OrderItem;
import com.zy.two.util.SessionFactoryUtil;

public class OrderItemDao {
	
	/**
	 * 增加订单项方法
	 * @param order
	 */
	public void addOrderItem(OrderItem orderItem) {
		Session session = SessionFactoryUtil.getSession(); //获取session会话
		Transaction transaction = session.beginTransaction(); //开启事物
		session.save(orderItem); //操作数据库
		transaction.commit(); //提交事物
		session.close(); //关闭会话
	}
	
	/**
	 * 查询订单项
	 * @param orderItem
	 * @return
	 */
	public OrderItem get(OrderItem orderItem) {
		Session session = SessionFactoryUtil.getSession(); //获取session会话
		Transaction transaction = session.beginTransaction(); //开启事物
		OrderItem ois = session.get(OrderItem.class, orderItem.getOrder_item_id()); //操作数据库
		transaction.commit(); //提交事物
		session.close(); //关闭会话
		return ois;
	}

}

5.daoTest

package com.zy.three.dao;

import static org.junit.Assert.*;

import java.util.List;

import org.junit.Test;

import com.zy.three.entity.Order;

public class OrderDaoTest {
	
	private OrderDao orderDao = new OrderDao();
	
	/**
	 * 增加订单
	 */
	@Test
	public void addOrder() {
		Order order = new Order();
		order.setOrder_no("zyj");
		orderDao.addOrder(order);
	}

	/**
	 * 查询
	 */
	@Test
	public void testGet() {
		Order order = new Order();
		order.setOrder_id(3);
		order.setInitOrderItem(1); //是否强制加载
		Order o = orderDao.get(order);
		System.out.println(o.getOrder_id());
		System.out.println(o.getOrder_no());
		System.out.println(o.getOrderItem());
	}
	
	/**
	 * 查询所有
	 */
	@Test
	public void OrderList() {
		Order order = new Order();
		order.setInitOrderItem(1); //是否强制加载
		List<Order> orderList = orderDao.OrderList(order);
		System.out.println("订单："+orderList+"\r");
		for (Order o : orderList) {
			System.out.println("订单项："+o.getOrderItem());
		}
	}
	
	/**
	 * 删除订单
	 */
	@Test
	public void testDelete() {
		Order order = new Order();
		order.setOrder_id(3);
		orderDao.delete(order);
	}
	

}

package com.zy.three.dao;

import static org.junit.Assert.*;

import org.junit.Test;

import com.zy.three.entity.OrderItem;

public class OrderItemDaoTest {
	
	private OrderItemDao orderItemDao = new OrderItemDao();

	@Test
	public void addOrderItem() {
		OrderItem orderItem = new OrderItem();
		orderItem.setProduct_id(30);
		orderItem.setQuantity(303);
		orderItem.setOid(3);
		orderItemDao.addOrderItem(orderItem);
	}
	
	@Test
	public void testGet() {
		OrderItem orderItem = new OrderItem();
		orderItem.setOrder_item_id(2);
		OrderItem item = orderItemDao.get(orderItem);
		System.out.println(item);
	}

}