Hibernate 的检索有两种：

　　1：立即检索。立即加载检索方法指定的对象。

　　2：延迟检索。延迟加载检索方法指定的对象。

好比老板让你去买包烟。然后1是拿着钱就去买了。2是先拿着钱。然后答应老板去买。等老板要抽烟的时候她才去买。

准备持久化类和相对应的映射文件。

package com.hibernate.strategy;import java.util.HashSet;import java.util.Set;public class Customer {    private Integer customerId;    private String customerName;        private Set
     
       orders = new HashSet
      
       ();    public Integer getCustomerId() {        return customerId;    }    public void setCustomerId(Integer customerId) {        this.customerId = customerId;    }    public String getCustomerName() {        return customerName;    }    public void setCustomerName(String customerName) {        this.customerName = customerName;    }    public Set
       
         getOrders() {        return orders;    }    public void setOrders(Set
        
          orders) {        this.orders = orders;    }   }
        
       
      
     

package com.hibernate.strategy;public class Order {        private Integer orderId;    private String orderName;        private Customer customer;    public Integer getOrderId() {        return orderId;    }    public void setOrderId(Integer orderId) {        this.orderId = orderId;    }    public String getOrderName() {        return orderName;    }    public void setOrderName(String orderName) {        this.orderName = orderName;    }    public Customer getCustomer() {        return customer;    }    public void setCustomer(Customer customer) {        this.customer = customer;    }    @Override    public int hashCode() {        final int prime = 31;        int result = 1;        result = prime * result + ((orderId == null) ? 0 : orderId.hashCode());        return result;    }    @Override    public boolean equals(Object obj) {        if (this == obj)            return true;        if (obj == null)            return false;        if (getClass() != obj.getClass())            return false;        Order other = (Order) obj;        if (orderId == null) {            if (other.orderId != null)                return false;        } else if (!orderId.equals(other.orderId))            return false;        return true;    } }

开始操作：

　　1：类级别的检索。通过设置<class>元素的lazy属性。

　　　　1）：get方法获得类对象。

@Test    public void testLeiStrategy(){        Customer customer=(Customer) session.get(Customer.class, 1);        System.out.println(customer.getCustomerName());        System.out.println(customer.getClass());    }

解释：得到的是类本身。get是立即检索。

　　2）：load方法

1 @Test2     public void testLeiStrategy(){3         Customer customer=(Customer) session.load(Customer.class, 1);4         System.out.println(customer.getCustomerName());5         System.out.println(customer.getClass());6     }

解释：返回的是一个代理对象。是延迟检索。

通过设置 

懒惰相反。就是立即加载。返回的也是一个customer类对象。

lazy="false"   只对load有效。对get无效。 2：一对多。多对多检索

因为无论是1对多，还是多对多。都是多的作为一个set集合，放到1 或多的中。其实就是对<set>设置。

　　1）：lazy:主要决定orders集合被初始化的时机。一共有三个设置。true 是默认的。false 立即加载。  extra就是增加延迟加载。就是比延迟加载还狠。

　　2）：fetch 决定初始化集合orders的查询语句的方式。

　　　　1>:默认：select 正常的查询。

　　　　2>:subselect   子查询的形式。因为是子查询。所以in()中需要order的ID。都要把set集合中的order都查询出来。batch-size会失效。

　　　　3>:join  检索1一端的时候。采用迫切左外连接去检索集合order。lazy会失效。

@Test    public void testGetFeth(){        List
     
       customers=session.createQuery("FROM Customer").list();        System.out.println(customers.size());        for(Customer customer :customers){            if(customer.getOrders() != null){                System.out.println(customer.getOrders().size());            }        }    }
     

fetch="subselect"  查询的结果

解释：把order都给初始化了。

用select：

Hibernate:     select        customer0_.CUSTOMER_ID as CUSTOMER1_0_,        customer0_.CUSTOMER_NAME as CUSTOMER2_0_     from        CUSTOMERS customer0_4Hibernate:     select        orders0_.CUSTOMER_ID as CUSTOMER3_0_1_,        orders0_.ORDER_ID as ORDER_ID1_1_1_,        orders0_.ORDER_ID as ORDER_ID1_1_0_,        orders0_.ORDER_NAME as ORDER_NA2_1_0_,        orders0_.CUSTOMER_ID as CUSTOMER3_1_0_     from        ORDERS orders0_     where        orders0_.CUSTOMER_ID=?     order by        orders0_.ORDER_NAME desc2Hibernate:     select        orders0_.CUSTOMER_ID as CUSTOMER3_0_1_,        orders0_.ORDER_ID as ORDER_ID1_1_1_,        orders0_.ORDER_ID as ORDER_ID1_1_0_,        orders0_.ORDER_NAME as ORDER_NA2_1_0_,        orders0_.CUSTOMER_ID as CUSTOMER3_1_0_     from        ORDERS orders0_     where        orders0_.CUSTOMER_ID=?     order by        orders0_.ORDER_NAME desc2Hibernate:     select        orders0_.CUSTOMER_ID as CUSTOMER3_0_1_,        orders0_.ORDER_ID as ORDER_ID1_1_1_,        orders0_.ORDER_ID as ORDER_ID1_1_0_,        orders0_.ORDER_NAME as ORDER_NA2_1_0_,        orders0_.CUSTOMER_ID as CUSTOMER3_1_0_     from        ORDERS orders0_     where        orders0_.CUSTOMER_ID=?     order by        orders0_.ORDER_NAME desc3Hibernate:     select        orders0_.CUSTOMER_ID as CUSTOMER3_0_1_,        orders0_.ORDER_ID as ORDER_ID1_1_1_,        orders0_.ORDER_ID as ORDER_ID1_1_0_,        orders0_.ORDER_NAME as ORDER_NA2_1_0_,        orders0_.CUSTOMER_ID as CUSTOMER3_1_0_     from        ORDERS orders0_     where        orders0_.CUSTOMER_ID=?     order by        orders0_.ORDER_NAME desc1

需要1次查询一次。

　　3>:join

@Test    public void testSetFetch2(){        Customer customer = (Customer) session.get(Customer.class, 1);        System.out.println(customer.getOrders().size());     }

Hibernate:     select        customer0_.CUSTOMER_ID as CUSTOMER1_0_1_,        customer0_.CUSTOMER_NAME as CUSTOMER2_0_1_,        orders1_.CUSTOMER_ID as CUSTOMER3_0_3_,        orders1_.ORDER_ID as ORDER_ID1_1_3_,        orders1_.ORDER_ID as ORDER_ID1_1_0_,        orders1_.ORDER_NAME as ORDER_NA2_1_0_,        orders1_.CUSTOMER_ID as CUSTOMER3_1_0_     from        CUSTOMERS customer0_     left outer join        ORDERS orders1_             on customer0_.CUSTOMER_ID=orders1_.CUSTOMER_ID     where        customer0_.CUSTOMER_ID=?     order by        orders1_.ORDER_NAME desc2

3：多对1  1对1

都是把1的一方放到多的。作为多的一个属性。

 

 false  :默认的。

proxy :延迟加载。

no-proxy：无代理延迟加载。

fetch只有2个