1. @Test  
2.     public void demo02() {  
3.         //类级别  
4.         Session session = factory.openSession();  
5.         session.beginTransaction();  
6.   
7.         //1立即  
8. //      Customer customer = (Customer) session.get(Customer.class, 1);  
9.         //2延迟  
10.         Customer customer = (Customer) session.load(Customer.class, 1);  
11.           
12.           
13.           
14.         //打印  
15.         System.out.println(customer.getCid());  
16.         System.out.println(customer.getCname());  
17.   
18.         session.getTransaction().commit();  
19.         session.close();  
20.     }  

1. package com.itheima.b_lazy;  
2.   
3. import org.hibernate.Session;  
4. import org.junit.Test;  
5.   
6. import com.itheima.domain.Course;  
7. import com.itheima.domain.Customer;  
8. import com.itheima.domain.Student;  
9. import com.itheima.utils.HibernateUtils;  
10.   
11. public class Demo {  
12.     @Test  
13.     //类级别懒加载  
14.     //load方法  
15.     // class lazy属性  
16.     // 默认值: true load获得时,会返回代理对象,不查询数据库.使用时才查询  
17.     public void fun1(){  
18.         Session session = HibernateUtils.openSession();  
19.         session.beginTransaction();  
20.         //------------------------------------------------  
21.         Customer c = (Customer) session.load(Customer.class, 1);  
22.           
23.         System.out.println(c.getName());  
24.         //------------------------------------------------  
25.         session.getTransaction().commit();  
26.         session.close(); // 游离状态  
27.     }  
28.     @Test  
29.     //类级别懒加载  
30.     //load方法  
31.     // class lazy属性  
32.     // lazy: false  load方法执行就会发送sql语句.与get方法一致.  
33.     public void fun2(){  
34.         Session session = HibernateUtils.openSession();  
35.         session.beginTransaction();  
36.         //------------------------------------------------  
37.         Customer c = (Customer) session.load(Customer.class, 1);  
38.           
39.         System.out.println(c.getName());  
40.         //------------------------------------------------  
41.         session.getTransaction().commit();  
42.         session.close(); // 游离状态  
43.     }  
44.       
45. }  

l  容器<set> 提供两个属性：fetch、lazy

       fetch：确定使用sql格式

       lazy：关联对象是否延迟。

l  fetch：join、select、subselect

       join：底层使用迫切左外连接

       select：使用多个select语句（默认值）

       subselect：使用子查询

l  lazy：false、true、extra

       false：立即

       true：延迟（默认值）

       extra：极其懒惰

l  fetch="join" ，lazy无效。底层使用迫切左外连接，使用一条select将所有内容全部查询。

fetch="select"

l  当前对象 和 关联对象 使用多条select语句查询。

l  lazy="false" , 立即，先查询客户select，立即查询订单select

l  lazy="true",延迟，先查询客户select，需要订单时，再查询订单select

l  lazy="extra"，极其懒惰（延迟），先查询客户select， 如果只需要订单数，使用聚合函数（不查询详情）

fetch="subselect"

l  将使用子查询。注意：必须使用Query否则看不到效果。

l  lazy= 同上

[java] view plain copy

 

1. @Test  
2.     public void demo04() {  
3.         //关联级别：一对多，  
4.         // 演示3：* Customer.hbm.xml  <set fetch="subselect">  
5.         Session session = factory.openSession();  
6.         session.beginTransaction();  
7.   
8.         //1 查询客户  
9.         List<Customer> allCustomer = session.createQuery("from Customer").list();  
10.         Customer customer = allCustomer.get(0);  
11.         System.out.println(customer.getCname());  
12.           
13.         //2 查询客户订单数  
14.         Set<Order> orderSet = customer.getOrderSet();  
15.         System.out.println(orderSet.size());  
16.           
17.         //3 查询客户订单详情  
18.         for (Order order : orderSet) {  
19.             System.out.println(order);  
20.         }  
21.           
22.   
23.         session.getTransaction().commit();  
24.         session.close();  
25.     }  

 

l  <many-to-one fetch="" lazy="">  (<one-to-one>)

l  fetch取值：join、select

       join：底层使用迫切左外连接

       select：多条select语句

l  lazy取值：false、proxy、no-proxy

       false：立即

       proxy：采用关联对象 类级别检索的策略。

              订单 关联 客户 （多对一）

              订单 立即获得 客户，需要在客户Customer.hbm.xml <class lazy="false">

              订单 延迟获得 客户，需要在客户Customer.hbm.xml <classlazy="true">

       no-proxy不研究

fetch="join"

fetch="select"

l  将采用多条select语句，lazy="proxy"是否延迟，取决关联对象 类级别检索策略。

l  lazy="false"

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <!DOCTYPE hibernate-mapping PUBLIC   
3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
4.     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">  
5.  <hibernate-mapping package="com.itheima.domain" >  
6.     <class name="Order" table="t_order"  >  
7.         <id name="id" column="id"    >  
8.             <generator class="native"></generator>  
9.         </id>       
10.         <property name="name" column="name" type="string" ></property>  
11.           
12.         <!--   
13.         lazy  
14.             false  
15.             proxy  
16.             no-proxy : 不做研究.   
17.         fetch=  
18.             select  
19.             join  
20.         -->  
21.         <many-to-one name="customer" column="cid" class="Customer"   ></many-to-one>  
22.     </class>  
23.  </hibernate-mapping>  

1. package com.itheima.b_lazy;  
2.   
3. import java.util.List;  
4.   
5. import org.hibernate.Session;  
6. import org.junit.Test;  
7.   
8. import com.itheima.domain.Customer;  
9. import com.itheima.domain.Order;  
10. import com.itheima.utils.HibernateUtils;  
11. //多对一检索策略  
12. public class Demo3 {  
13.     @Test  
14.     //fetch: select  
15.     //lazy: false  
16.     public void fun1(){  
17.         Session session = HibernateUtils.openSession();  
18.         session.beginTransaction();  
19.         //------------------------------------------------  
20.         Order o = (Order) session.get(Order.class, 2);  
21.           
22.         System.out.println(o.getCustomer().getName());  
23.           
24.         //------------------------------------------------  
25.         session.getTransaction().commit();  
26.         session.close(); // 游离状态  
27.     }  
28.       
29.       
30.     @Test  
31.     //fetch: select  
32.     //lazy: proxy  
33.     // Customer lazy:false  
34.     public void fun2(){  
35.         Session session = HibernateUtils.openSession();  
36.         session.beginTransaction();  
37.         //------------------------------------------------  
38.         Order o = (Order) session.get(Order.class, 2);  
39.           
40.         System.out.println(o.getCustomer().getName());  
41.           
42.         //------------------------------------------------  
43.         session.getTransaction().commit();  
44.         session.close(); // 游离状态  
45.     }  
46.     @Test  
47.     //fetch: select  
48.     //lazy: proxy  
49.     // Customer lazy:true  
50.     public void fun3(){  
51.         Session session = HibernateUtils.openSession();  
52.         session.beginTransaction();  
53.         //------------------------------------------------  
54.         Order o = (Order) session.get(Order.class, 2);  
55.           
56.         System.out.println(o.getCustomer().getName());  
57.           
58.         //------------------------------------------------  
59.         session.getTransaction().commit();  
60.         session.close(); // 游离状态  
61.     }  
62.       
63.     @Test  
64.     //fetch: join  
65.     //lazy: proxy|false  
66.     public void fun4(){  
67.         Session session = HibernateUtils.openSession();  
68.         session.beginTransaction();  
69.         //------------------------------------------------  
70.         Order o = (Order) session.get(Order.class, 2);  
71.           
72.         System.out.println(o.getCustomer().getName());  
73.           
74.         //------------------------------------------------  
75.         session.getTransaction().commit();  
76.         session.close(); // 游离状态  
77.     }  
78. }