Hibernate的学习详解(3)

 1 /**
 2      * 优点:
 3      * 1. 无需使用辨别者列.
 4      * 2. 子类独有的字段能添加非空约束.
 5      * 
 6      * 缺点:
 7      * 1. 存在冗余的字段
 8      * 2. 若更新父表的字段, 则更新的效率较低
 9      */
10     
11     /**
12      * 查询:
13      * 1. 查询父类记录, 需把父表和子表记录汇总到一起再做查询. 性能稍差. 
14      * 2. 对于子类记录, 也只需要查询一张数据表
15      */
16     @Test
17     public void testQuery(){
18         List<Person> persons = session.createQuery("FROM Person").list();
19         System.out.println(persons.size()); 
20         
21         List<Student> stus = session.createQuery("FROM Student").list();
22         System.out.println(stus.size()); 
23     }
24     
25     /**
26      * 插入操作: 
27      * 1. 对于子类对象只需把记录插入到一张数据表中.
28      */
29     @Test
30     public void testSave(){
31         
32         Person person = new Person();
33         person.setAge(11);
34         person.setName("AA");
35         
36         session.save(person);
37         
38         Student stu = new Student();
39         stu.setAge(22);
40         stu.setName("BB");
41         stu.setSchool("ATGUIGU");
42         
43         session.save(stu);
44         
45     }

 1 @Test
 2     public void testMany2OneStrategy(){
 3 //        Order order = (Order) session.get(Order.class, 1);
 4 //        System.out.println(order.getCustomer().getCustomerName()); 
 5         
 6         List<Order> orders = session.createQuery("FROM Order o").list();
 7         for(Order order: orders){
 8             if(order.getCustomer() != null){
 9                 System.out.println(order.getCustomer().getCustomerName()); 
10             }
11         }
12         
13         //1. lazy 取值为 proxy 和 false 分别代表对应对应的属性采用延迟检索和立即检索
14         //2. fetch 取值为 join, 表示使用迫切左外连接的方式初始化 n 关联的 1 的一端的属性
15         //忽略 lazy 属性. 
16         //3. batch-size, 该属性需要设置在 1 那一端的 class 元素中: 
17         //<class name="Customer" table="CUSTOMERS" lazy="true" batch-size="5">
18         //作用: 一次初始化 1 的这一段代理对象的个数. 
19     }
20     
21     @Test
22     public void testSetFetch2(){
23         Customer customer = (Customer) session.get(Customer.class, 1);
24         System.out.println(customer.getOrders().size()); 
25     }
26     
27     @Test
28     public void testSetFetch(){
29         List<Customer> customers = session.createQuery("FROM Customer").list();
30         
31         System.out.println(customers.size()); 
32         
33         for(Customer customer: customers){
34             if(customer.getOrders() != null)
35                 System.out.println(customer.getOrders().size());
36         }
37         
38         //set 集合的 fetch 属性: 确定初始化 orders 集合的方式. 
39         //1. 默认值为 select. 通过正常的方式来初始化 set 元素
40         //2. 可以取值为 subselect. 通过子查询的方式来初始化所有的 set 集合. 子查询
41         //作为 where 子句的 in 的条件出现, 子查询查询所有 1 的一端的 ID. 此时 lazy 有效.
42         //但 batch-size 失效. 
43         //3. 若取值为 join. 则
44         //3.1 在加载 1 的一端的对象时, 使用迫切左外连接(使用左外链接进行查询, 且把集合属性进行初始化)的方式检索 n 的一端的集合属性
45         //3.2 忽略 lazy 属性.
46         //3.3 HQL 查询忽略 fetch=join 的取值
47     }
48     
49     @Test
50     public void testSetBatchSize(){
51         List<Customer> customers = session.createQuery("FROM Customer").list();
52         
53         System.out.println(customers.size()); 
54         
55         for(Customer customer: customers){
56             if(customer.getOrders() != null)
57                 System.out.println(customer.getOrders().size());
58         }
59         
60         //set 元素的 batch-size 属性: 设定一次初始化 set 集合的数量. 
61     }
62     
63     @Test
64     public void testOne2ManyLevelStrategy(){
65         Customer customer = (Customer) session.get(Customer.class, 1);
66         System.out.println(customer.getCustomerName()); 
67         
68         System.out.println(customer.getOrders().size());
69         Order order = new Order();
70         order.setOrderId(1);
71         System.out.println(customer.getOrders().contains(order));
72         
73         Hibernate.initialize(customer.getOrders()); 
74         
75         //---------------set 的 lazy 属性------------------
76         //1. 1-n 或 n-n 的集合属性默认使用懒加载检索策略.
77         //2. 可以通过设置 set 的 lazy 属性来修改默认的检索策略. 默认为 true
78         //并不建议设置为  false. 
79         //3. lazy 还可以设置为 extra. 增强的延迟检索. 该取值会尽可能的延迟集合初始化的时机!
80     }
81     
82     @Test
83     public void testClassLevelStrategy(){
84         Customer customer = (Customer) session.load(Customer.class, 1);
85         System.out.println(customer.getClass()); 
86         
87         System.out.println(customer.getCustomerId()); 
88         System.out.println(customer.getCustomerName()); 
89     }