hibernate之一对多关系
1. 什么是关联(association)
1.1 关联指的是类之间的引用关系。如果类A与类B关联，那么被引用的类B将被定义为类A的属性。例如:
public class A{
private B b = new B;
public A(){}
}
1.2 关联的分类：关联可以分为一对一、一对多/多对一、多对多关联
关联是有方向的
现在我们就讲的是一对多
把实体及配置文件导入
Order
/** * hibernate关联关系 * 一对多：一个订单对应多个订单项 * 多对一：多个订单项对应一个订单（注：一个订单项对应一个订单） * @author Administrator * */ public class Order implements Serializable { //订单id private Integer orderId; //订单编号 private String orderNO; //1.1 关联指的是类之间的引用关系。如果Order与类OrderItem关联， //那么被引用的OrderItem将被定义为Order 的属性。例如: private Set<OrderItem> orderitems=new HashSet<OrderItem>(); 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 Order() { super(); } @Override public String toString() { return "Order [orderId=" + orderId + ", orderNO=" + orderNO + ", orderitems=" + orderitems + "]"; } }
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.hmc.hibernate02.entity.Order" table="t_order_hb"> <id name="orderId" type="java.lang.Integer" column="order_id"> <!--native:identity(标识列)+sequence(序列) --> <generator class="native"></generator> </id> <property name="orderNO" type="java.lang.String" column="order_no"/> <!--一方中的主键就是多方中的外键 --> <!-- select o.*,oi.* from t_order_hb o inner join t_order_item_hb oi on o.order_id=oi.oid --> <!--建立关联关系 --> <!-- name:实体类中定义的属性名，指向多方 cassade:用来控制如何操作关联的持久化对象的 --> <set name="orderitems" cascade="save-update" inverse="true" table="t_order_item_hb" > <!-- 指定连接的多方中的外键列 --> <key column="oid"></key> <!--指定实体之间的关联关系：一对多 --> <!--class:指向的是多方的实体类的全路径名 --> <one-to-many class="com.hmc.hibernate02.entity.OrderItem"/> </set> </class> </hibernate-mapping>
OrderItem
/** * 多个订单项对应一个订单（注意：一个订单项唯一对应一个订单） * @author Administrator * */ public class OrderItem implements Serializable{ //订单项id private Integer orderItemId; //产品id private Integer productId; //数量 private Integer quantity; //外键列 private Integer oid; //1.1 关联指的是类之间的引用关系。如果OrderItem与类Order关联， //那么被引用的Order将被定义为OrderItem 的属性。例如: 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 + "]"; }
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.hmc.hibernate02.entity.OrderItem" table="t_order_item_hb"> <id name="orderItemId" type="java.lang.Integer" column="order_item_id"> <!--native:identity(标识列)+sequence(序列) --> <generator class="native"></generator> </id> <property name="productId" type="java.lang.Integer" column="product_id"/> <property name="quantity" type="java.lang.Integer" column="quantity"/> <property insert="false" update="false" name="oid" type="java.lang.Integer" column="oid"/> <!--建立关联关系 --> <!-- name:实体类中定义的属性名，指向一方 --> <many-to-one name="order" cascade="save-update" class="com.hmc.hibernate02.entity.Order"> <!--多方的数据库表中的外键列，指向一方 --> <column name="oid"></column> </many-to-one> </class> </hibernate-mapping>
OrderDao
public void add(Order order) { Session session = SessionFactoryUtils.openSession(); Transaction transaction = session.beginTransaction(); session.save(order); transaction.commit(); SessionFactoryUtils.closeSession(); } public Order get(Order order) { Session session = SessionFactoryUtils.openSession(); Transaction transaction = session.beginTransaction(); Order o = session.get(Order.class, order.getOrderId()); //处理懒加载 if(null!=o) { Hibernate.initialize(o.getOrderitems()); } transaction.commit(); SessionFactoryUtils.closeSession(); return o; } public void update(Order order){ Session session = SessionFactoryUtils.openSession(); Transaction transaction = session.beginTransaction(); //先查，再更新 Order o = session.get(Order.class, order.getOrderId()); if(null!=o) { //拿到多方 Set<OrderItem> orderitems = o.getOrderitems(); OrderItem orderItem=null; for (int i = 0; i <=2; i++) { orderItem=new OrderItem(); orderItem.setProductId(i); orderItem.setQuantity(i+2); //建立关联关系 orderItem.setOrder(o); o.getOrderitems().add(orderItem); } session.update(o); } transaction.commit(); SessionFactoryUtils.closeSession(); } //级联删除 public void delete(Order order) { Session Session = SessionFactoryUtils.openSession(); Transaction Transaction = Session.beginTransaction(); //先查询，在删除 Order o = Session.get(Order.class, order.getOrderId()); if(null!=o) { /** * 解除关联关系：先删从表，再删主表 * 1）禁用联级删除 * 2）先删从表，再删主表 * 3）手动代码维护 */ Set<OrderItem> orderitems = o.getOrderitems(); for (OrderItem orderItem : orderitems) { Session.delete(orderItem); } Session.delete(o); } Transaction.commit(); SessionFactoryUtils.closeSession(); }
测试类进行测试OrderDaoTest
Hibernate: select order0_.order_id as order_id1_0_0_, order0_.order_no as order_no2_0_0_ from t_order_hb 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_order_item_hb orderitems0_ where orderitems0_.oid=? Hibernate: delete from t_order_item_hb where order_item_id=? Hibernate: delete from t_order_item_hb where order_item_id=? Hibernate: delete from t_order_item_hb where order_item_id=? Hibernate: delete from t_order_hb where order_id=?
