首页 > 代码库 > hibernate学习(6)——加载策略(优化)
hibernate学习(6)——加载策略(优化)
1、 检索方式
1 立即检索:立即查询,在执行查询语句时,立即查询所有的数据。
2 延迟检索:延迟查询,在执行查询语句之后,在需要时在查询。(懒加载)
2、 检查策略
1 类级别检索:当前的类的属性获取是否需要延迟。
2 关联级别的检索:当前类 关联 另一个类是否需要延迟。
3、类级别检索
1 get:立即检索。get方法一执行,立即查询所有字段的数据。
2 load:延迟检索。默认情况,load方法执行后,如果只使用OID的值不进行查询,如果要使用其他属性值将查询 。 Customer.hbm.xml <class lazy="true | false">
lazy 默认值true,表示延迟检索,如果设置false表示立即检索,相当于get方法。
package com.alice.hibernate02.lazy; import org.hibernate.Session; import org.hibernate.Transaction; import org.junit.Test; import com.alice.hibernate02.util.HibernateUtil; import com.alice.hibernate02.vo.Customer; public class Demo1 { // 类级别懒加载 // load方法 // class lazy属性 // 默认值: true load获得时,会返回代理对象,不查询数据库.使用时才查询 @Test public void test01(){ Session session = HibernateUtil.openSession(); Transaction tran = session.beginTransaction(); Customer cus = (Customer) session.load(Customer.class, 6); System.out.println(cus.getName()); tran.commit(); session.close(); } //类级别懒加载 //load方法 // class lazy属性 // lazy: false load方法执行就会发送sql语句.与get方法一致. @Test public void test02(){ Session session = HibernateUtil.openSession(); Transaction tran = session.beginTransaction(); Customer cus = (Customer) session.load(Customer.class, 6); System.out.println(cus.getName()); tran.commit(); session.close(); } }
4、 关联级别检索
在查询有关联关系的数据时,加载一方的数据是否需要将另一方立即查询出.
默认: 与我关联的数据,在使用时才会加载.
集合(一对多):
set
lazy: 是否对set数据使用懒加载
true:(默认值) 对集合使用才加载
false: 集合将会被立即加载
extra: 极其懒惰,如果使用集合时,之调用size方法查询数量, Hibernate会发送count语句,只查询数量.不加载集合内数据.
fetch : 决定加载集合使用的sql语句种类
select: (默认值) 普通select查询
join: 表链接语句查询集合数据
subselect: 使用子查询 一次加载多个Customer的订单数据
fetch | lazy | 结论 |
select | true | 默认值, 会在使用集合时加载,普通select语句 |
select | false | 立刻使用select语句加载集合数据 |
select | extra | 会在使用集合时加载,普通select语句,如果只是获得集合的长度,会发送Count语句查询长度 |
join | true | 查询集合时使用表链接查询,会立刻加载集合数据 |
join | false | 查询集合时使用表链接查询,会立刻加载集合数据 |
jojn | extra | 查询集合时使用表链接查询,会立刻加载集合数据 |
subselect | true | 会在使用集合时加载,子查询语句 |
subselect | false | 会在查询用户时,立即使用子查询加载客户的订单数据 |
subselect | extra | 会在使用集合时加载,子查询语句,如果只是获得集合的长度,会发送Count语句查询长度. |
代码测试:
package com.alice.hibernate02.lazy; import java.util.List; import org.hibernate.Session; import org.hibernate.Transaction; import org.junit.Test; import com.alice.hibernate02.util.HibernateUtil; import com.alice.hibernate02.vo.Customer; import com.alice.hibernate02.vo.Order; public class Demo02 { // 关联级别懒加载 // 默认: 与我关联的数据,在使用时才会加载. @Test public void test01() { Session session = HibernateUtil.openSession(); Transaction tran = session.beginTransaction(); Customer cus = (Customer) session.get(Customer.class, 6); for (Order o : cus.getOrders()) { System.out.println(o.getName()); } tran.commit(); session.close(); } //关联级别懒加载 //lazy: false @Test public void test02() { Session session = HibernateUtil.openSession(); Transaction tran = session.beginTransaction(); Customer cus = (Customer) session.get(Customer.class, 6); for (Order o : cus.getOrders()) { System.out.println(o.getName()); } tran.commit(); session.close(); } //关联级别懒加载 //lazy:false //fetch:subselect @Test public void test03() { Session session = HibernateUtil.openSession(); Transaction tran = session.beginTransaction(); Customer cus = (Customer) session.get(Customer.class, 6); for (Order o : cus.getOrders()) { System.out.println(o.getName()); } tran.commit(); session.close(); } //关联级别懒加载 //lazy:true/false //fetch:subselect @Test public void test04() { Session session = HibernateUtil.openSession(); Transaction tran = session.beginTransaction(); List<Customer> list = session.createQuery("from Customer").list(); for (Customer c: list) { System.out.println(c.getName()+"下单数量"+c.getOrders().size()); } tran.commit(); session.close(); } //关联级别懒加载 //lazy:extra //fetch:select @Test public void test05() { Session session = HibernateUtil.openSession(); Transaction tran = session.beginTransaction(); Customer cus = (Customer) session.get(Customer.class, 6); //查询Customer下订单 数量 System.out.println(cus.getOrders().size()); //真正使用订单中的数据 for (Order o: cus.getOrders()) { System.out.println(o.getName()); } tran.commit(); session.close(); } //关联级别懒加载 //lazy:extra //fetch:subselect @Test public void test06() { Session session = HibernateUtil.openSession(); Transaction tran = session.beginTransaction(); @SuppressWarnings("unchecked") List<Customer> list = session.createQuery("from Customer").list(); for(Customer c:list){ System.out.println(c.getName()+"下单数量:"+c.getOrders().size()); } for(Customer c:list){ for(Order o :c.getOrders()){ System.out.println(c.getName()+"下单名称:"+o.getName()); } } tran.commit(); session.close(); } }
多对一:
<many-to-one>
lazy
false: 加载订单时,会立即加载客户
proxy:看客户对象的类加载策略来决定
no-proxy : 不做研究.
fetch
select : (默认值)使用普通select加载
join : 使用表链接加载数据
fetch | lazy | 结果 |
select | false | 加载订单时,立即加载客户数据.普通select语句加载客户. |
select | proxy |
类加载策略为:lazy=false 同上 |
join | false | 使用表链接查询订单以及对应客户信息.lazy属性无效 |
join | proxy | 使用表链接查询订单以及对应客户信息.lazy属性无效 |
package com.alice.hibernate02.lazy; import org.hibernate.Session; import org.hibernate.Transaction; import org.junit.Test; import com.alice.hibernate02.util.HibernateUtil; import com.alice.hibernate02.vo.Order; //多对一检索策略 public class Demo03 { // 多对一检索策略 @Test // fetch: select // lazy: false public void test01() { Session session = HibernateUtil.openSession(); Transaction tran = session.beginTransaction(); Order o = (Order) session.get(Order.class, 8); System.out.println(o.getCustomer().getName()); tran.commit(); session.close(); } // fetch: select // lazy: proxy // Customer lazy:false @Test public void test02() { Session session = HibernateUtil.openSession(); Transaction tran = session.beginTransaction(); Order o = (Order) session.get(Order.class, 8); System.out.println(o.getCustomer().getName()); tran.commit(); session.close(); } // fetch: select // lazy: proxy // Customer lazy:true @Test public void test03() { Session session = HibernateUtil.openSession(); Transaction tran = session.beginTransaction(); Order o = (Order) session.get(Order.class, 8); System.out.println(o.getCustomer().getName()); tran.commit(); session.close(); } // fetch: join // lazy: proxy|false @Test public void test04() { Session session = HibernateUtil.openSession(); Transaction tran = session.beginTransaction(); Order o = (Order) session.get(Order.class, 8); System.out.println(o.getCustomer().getName()); tran.commit(); session.close(); } }
5、批量加载
set
batch-size: 决定一次加载几个对象的集合数据. in 条件加载多个用户的订单.
package com.alice.hibernate02.lazy; import java.util.List; import org.hibernate.Session; import org.hibernate.Transaction; import org.junit.Test; import com.alice.hibernate02.util.HibernateUtil; import com.alice.hibernate02.vo.Customer; import com.alice.hibernate02.vo.Order; //批量策略 public class Demo04 { @Test //查询所有客户 //遍历客户,打印客户下的订单信息 public void test() { Session session = HibernateUtil.openSession(); Transaction tran = session.beginTransaction(); List<Customer> list = session.createQuery("from Customer").list(); for(Customer c:list){ System.out.println(c.getOrders().size()); } tran.commit(); session.close(); } }
Customer Get(int id)
Return Session.load(Customer.class,id);
- layz=false
- 在Service层获得在页面要上要用到的属性=> 在Service层中确保数据已经
hibernate学习(6)——加载策略(优化)