hibernate(一对多)

Hibernate关联关系
关联指的是类之间的引用关系。如果类A与类B关联，那么被引用的类B将被定义为类A的属性。例如:
订单和订单项
一个订单对应多个订单项
Order.java

package entity;
import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;
public class Order implements Serializable {
 private static final long serialVersionUID = -1737859893948370664L;
 private Integer orderId;
 private String orderNo;
private Set<OrderItem> orderItem = new HashSet<OrderItem>();
 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 Set<OrderItem> getOrderItem() {
  return orderItem;
 }
 public void setOrderItem(Set<OrderItem> orderItem) {
  this.orderItem = orderItem;
 }
 @Override
 public String toString() {
  return "Order [orderId=" + orderId + ", orderNo=" + orderNo + "]";
 }
}

订单配置文件Order.hbm.xml

<!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="entity.Order" table="t_order">
  <id name="orderId" column="order_id" type="integer">
   <generator class="native"></generator>
  </id>
  <property name="orderNo" column="order_no" type="string"></property>
  <!-- 
	   lazy：是否懒加载，默认是懒加载的true  懒汉模式
	   name：类的关联属性名
	   cascade：级联关系  级联新增与修改
	   inverse：关联关系交给对方控制  默认是true，当前类不维护关联关系
	   子标签key:column:主表的主键，从表的外键
   -->
 <set name="orderItem" inverse="true" cascade="save-update">
  <key column="oid"></key>
  <one-to-many class="entity.OrderItem"/>
 </set>
 </class>
</hibernate-mapping>

订单项
OrderItem.java

package entity;
import java.io.Serializable;
public class OrderItem implements Serializable{
 private static final long serialVersionUID = 7224901622594643894L;
 private Integer orderItemId;
 private Integer productId;
 private Integer quantity;
 private Integer oid;
 //如果类OrderItem与Order关联，那么被引用的类Order将被定义为类OrderItem的属性
 private Order order;
 public OrderItem() {
  super();
 }
 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 Order getOrder() {
  return order;
 }
 public void setOrder(Order order) {
  this.order = order;
 }
 @Override
 public String toString() {
  return "OrderItem [orderItemId=" + orderItemId + ", productId=" + productId + ", quantity=" + quantity
    +"]";
 }
}

订单项配置文件OrderItem.hbm.xml

<!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="entity.OrderItem" table="t_order_item">
  <id name="orderItemId" column="order_item_id" type="integer">
   <generator class="native"></generator>
  </id>
  <property name="productId" column="product_id" type="integer"></property>
  <property name="quantity" column="quantity" type="integer"></property>
  <property insert="false"  update="false" name="oid" column="oid" type="integer"></property>
  <many-to-one name="order" class="entity.Order" column="oid"></many-to-one>
 </class>
</hibernate-mapping>

编写Junit测试类
OrderDAOTest

package dao;
import org.junit.Before;
import org.junit.Test;
import entity.Order;
import entity.OrderItem;
public class OrderDAOTest {
 private OrderDAO orderDAO;
 private Order order;
 @Before
 public void setUp() throws Exception {
  orderDAO = new OrderDAO();
  
  order = new Order();
 }
 @Test
 public void testAdd() {
  order.setOrderNo("p3");
  OrderItem orderItem = null;
  for (int i = 1; i <= 10; i++) {
   orderItem = new OrderItem();
   orderItem.setProductId(i);
   orderItem.setQuantity(i+1);
   orderItem.setOrder(order);
   order.getOrderItem().add(orderItem);
  }
  orderDAO.add(order);
 }
 @Test
 public void testLoad() {
  order.setOrderId(3);
  Order load = orderDAO.load(order);
  System.out.println(load.getOrderId());
  System.out.println(load.getOrderNo());
  System.out.println(load.getOrderItem().size());
 }
}

懒汉模式：加载是不创建实例，用户获取时才真正判断是否为空，如果为空才创建实例

public class Singleton2 {
    //构造方法私有化，不允许外面直接创建对象
    private Singleton2(){}
    //声明类的唯一实例，使用private static 修饰
    private static Singleton2 instance;
    //提供一个获取实例的方法，使用 public staitc修饰
    public static Singleton2 getInstance()
    {
        if(instance==null)
        {
            instance=new Singleton2();
        }
        return instance;
    }
}
public class Test {
	public static void main(String[] args) {
	        Singleton2 s3=Singleton2.getInstance();
	        Singleton2 s4=Singleton2.getInstance();
	        if(s3==s4)
	            System.out.println("s1和s2是同一个实例");
	        else
	            System.out.println("s1和s2不是同一个实例");
	}
}

懒加载(lazy)：就是延时加载，延迟加载。
lazy有三个属性：true、false、extra（集合属性时候使用）
true:默认取值，它的意思是只有在调用这个集合获取里面的元素对象时，才发出查询语句，加载其集合元素的数据。
false:取消懒加载特性，即在加载对象的同时，就发出第二条查询语句加载其关联集合的数据。
extra:一种比较聪明的懒加载策略，即调用集合的size/contains等方法的时候，hibernate并不会去加载整个集合的数据，而是发出一条聪明的SQL语句，以便获得需要的值，只有在真正需要用到这些集合元素对象数据的时候，才去发出查询语句加载所有对象的数据。extra能够更高性能的提升Hibernate的查询效率。