关联关系
什么是关联？
关联指的是类之间的引用关系。如果类A与类B关联， 那么被引用的类B将被定义为类A的属性。例如:
public class A{
private B b = new B;
public A(){}
}
重点：
我们常见的订单与订单项就是典型的一对多，一个订单对应多个订单项， 搞清这个就关联关系就基本懂
了，如果订单与订单项关联那么被引用的订单项将被定义为订单的属性。
关联的分类
关联可以分为一对一、一对多/多对一、和多对多关联、关联是有方向的。
一对多实战操作
先不建立订单和订单项的关联关系,先定义实体及映射文件。
Order实体类定义相关关联属性orderitem.，这里注意tostring不要把set集合的属性添加进去不然会报错。
package com.liyingdong.entity;
import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;
public class Order implements Serializable{
private Integer orderId;
private String orderNo;
//默认不用去初始化订单项
private boolean initOrderItems=false;
/*关联指的是类之间的引用关系。如果类Order与类OrderItem关联，
那么被引用的类OrderItem将被定义为类Order的属性。例如:*/
private Set<OrderItem>orderItems=new HashSet<>();
public Set<OrderItem> getOrderItems() {
return orderItems;
}
public void setOrderItems(Set<OrderItem> orderItems) {
this.orderItems = orderItems;
}
public Order() {
super();
}
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(Integer orderId, String orderNo) {
super();
this.orderId = orderId;
this.orderNo = orderNo;
}
@Override
public String toString() {
return "Order [orderId=" + orderId + ", orderNo=" + orderNo + "]";
}
public boolean isInitOrderItems() {
return initOrderItems;
}
public void setInitOrderItems(boolean initOrderItems) {
this.initOrderItems = initOrderItems;
}
}
OrderItem订单项的实体定义Order属性关联。
package com.liyingdong.entity;
import java.io.Serializable;
/**
* 多对一
* @author Administrator
*
*/
public class OrderItem implements Serializable{
private Integer orderItemId;
private Integer productId;
private Integer quantity;
private Integer oid;
private Order order;
/*关联指的是类之间的引用关系。如果类OrderItem与类order关联，
那么被引用的类order将被定义为类OrderItem的属性。例如:*/
public OrderItem() {}
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;
}
public OrderItem(Integer orderItemId, Integer productId, Integer quantity, Integer oid) {
super();
this.orderItemId = orderItemId;
this.productId = productId;
this.quantity = quantity;
this.oid = oid;
}
@Override
public String toString() {
return "OrderItem [orderItemId=" + orderItemId + ", productId=" + productId + ", quantity=" + quantity
+ ", oid=" + oid + "]";
}
public Order getOrder() {
return order;
}
public void setOrder(Order order) {
this.order = order;
}
}
创建配置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.liyingdong.entity.Order" table="t_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"/>
<!-- 建立订单到订单项的一对多关联关系
1. lazy:默认值为true,true延迟加载,false立即加载(一般设置为true,不使用立即加载,因为影响查询性能)
2. outter-join:默认值为false,true使用左外联接查询关联的(但一般不用，因为当我们把该属性设置为true时，所有的查询语句都会默认左外联，那样性能不高)
3. inverse:默认值为false,true表示将对方设置为主控方(一对多双向关联中一般将多方设置为主控方,这样可以减少SQL语句的数量,减少多余的操作)
4. cascade:用来控制如何操作关联的持久化对象的(级联删除更新)
1. none:保存，更新或删除当前对象时，忽略其它关联的对象(注意：如果建立了关联关系，则不能使用此属性，报错：对象引用未保存的临时实例-保存临时实例)
2. save-update:保存、更新时级联保存所有的临时对象，并且级联更新关联的游离对象
3. delete:通过session的delete方法删除当前对象，级联删除关联的对象
4. all:等于save-update操作+delete操作
注：级联删除不建议使用（cascade:delete）
-->
<!--set标签name:多的一方的对象集合的属性名称-->
<set name="orderItems" inverse="true" cascade="save-update,delete" >
<!--key标签 column:多的一方的外键的名称 -->
<key column="oid"></key>
<!-- 从one到many的方向：操作one对象能同时操作many对象, class:多的一方的类的全路径 -->
<one-to-many class="com.liyingdong.entity.OrderItem"></one-to-many>
</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>
<class name="com.liyingdong.entity.OrderItem" table="t_order_item">
<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 name="quantity" type="java.lang.Integer" column="quantity"/>
<!--1.注释 2.只读-->
<property name="oid" type="java.lang.Integer" column="oid" insert="false" update="false" />
<!-- 多对一关联关系 放置的是一方的对象 -->
<!--
name :一方的对象的属性名称
class :一方的类的全路劲
column :在多方的表的外键的名称
-->
<!-- 从many到one的方向：操作many对象能同时操作one对象 -->
<many-to-one name="order" class="com.liyingdong.entity.Order" column="oid"/>
</class>
</hibernate-mapping>
配置到核心文件中
简单的junit测试
package com.liyingdong.dao;
import static org.junit.Assert.*;
import org.junit.Before;
import org.junit.Test;
import com.liyingdong.entity.Order;
import com.liyingdong.entity.OrderItem;
public class orderDaoTest {
Order order=null;
orderDao od=new orderDao();
@Before
public void setUp() throws Exception {
order=new Order();
}
@Test
public void testGet() {
order.setOrderId(1);
order.setInitOrderItems(true);
Order o = od.get(order);
System.out.println(o.getOrderNo());
System.out.println(o.getOrderItems());
}
@Test
public void testSave() {
order.setOrderNo("p003");
OrderItem orderItem=null;
for(int i=0;i<5;i++) {
orderItem=new OrderItem();
orderItem.setProductId(2);
orderItem.setQuantity(50);
//建立一对多关联关系
orderItem.setOrder(order);
//建立多对一的关联关系
order.getOrderItems().add(orderItem);
}
od.save(order);
}
@Test
public void testDel() {
order.setOrderId(4);
od.del(order);
}
}
结果
增加：
oid的关联
281
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
