Hibernate 检索策略详解 （1）

Hibernate 检索策略详解 （1）

      在session 的缓存中可以存放关联的对象图，当数据库从查询一个对象的时候如果同时自动加载其关联的对象，而程序此时不需要处理其关联的对象的时候，那么就白白浪费了许多的内存资源。所以hibernate通过其检索策略解决了实际运用的效率问题。其提供了丰富的检索策略。

下面就结合具体的测试源码讲述其基本原理及其优化策略。

 

先准备环境

 

 1： junit3.8.jar

 2： mysql.jar

 3: hibernate相关的包

 

Customer 类

 

package com.macower.hibernate.strategy; import java.util.Set; public class Customer { private int id; private String name; private Set<Order> orders; public Customer() { } public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Set<Order> getOrders() { return orders; } public void setOrders(Set<Order> orders) { this.orders = orders; } } 

 

订单类 Order

package com.macower.hibernate.strategy; /** * 订单类 * * @author Runner * */ public class Order { public Order() { } private int id; // 订单的id号 private String name;// 订单的名称 private Customer customer;// 订单所属的顾客 // 属性的 setter 和 getter public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Customer getCustomer() { return customer; } public void setCustomer(Customer customer) { this.customer = customer; } }  

 

 

HibernateUtils 

package com.macower.hibernate.strategy; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.cfg.Configuration; public class HibernateUtils { private static SessionFactory factory; static { try { Configuration cfg = new Configuration().configure(); factory = cfg.buildSessionFactory(); }catch(Exception e) { e.printStackTrace(); } } public static SessionFactory getSessionFactory() { return factory; } public static Session getSession() { return factory.openSession(); } public static void closeSession(Session session) { if (session != null) { if (session.isOpen()) { session.close(); } } } }

 

 Customer.hbm.xml 

<?xml version="1.0"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <hibernate-mapping> <class name="com.macower.hibernate.strategy.Customer" table="CUSTOMERS"> <id name="id" type="int" column="ID"> <generator class="native" /> </id> <property name="name" type="string"> <column name="NAME" length="15" /> </property> <set name="orders" cascade="all" inverse="true" lazy="true"> <key column="customer"></key> <one-to-many class="com.macower.hibernate.strategy.Order"/> </set> </class> </hibernate-mapping> 

Order.hbm.xml

 

<?xml version="1.0"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <hibernate-mapping> <class name="com.macower.hibernate.strategy.Order" table="ORDERS"> <id name="id" type="int" column="ID"> <generator class="native" /> </id> <property name="name" type="string"> <column name="NAME" length="100" /> </property> <many-to-one name="customer" class="com.macower.hibernate.strategy.Customer"></many-to-one> </class> </hibernate-mapping> 

用junit 的debug模式测试得到如下结论

 

package com.macower.hibernate.strategy; import junit.framework.TestCase; import org.hibernate.Hibernate; import org.hibernate.Session; public class CustomerClassTest extends TestCase { /** * get方法是不会发生LazyInitizationException异常的 * * @throws Exception */ public void testGetLazyInitializationException() throws Exception { Session session = HibernateUtils.getSession(); Customer customer = (Customer) session.get(Customer.class, 1); session.close(); System.out.println(customer.getName()); } /** * load会发生LazyInitizationException异常的 * 因为load方法使用的是代理，如果不作其他处理，关闭session，而没有将代理对性初始化其实例就不能被访问该属性了 * * * @throws Exception */ public void testLoadLazyInitializationException() throws Exception { Session session = HibernateUtils.getSession(); Customer customer = (Customer) session.load(Customer.class, 1); session.close(); System.out.println(customer.getName()); } /** * load会发生LazyInitizationException异常的 * 因为load方法使用的是代理，如果不作其他处理，关闭session就不能被访问该属性了。 * 但是假设将用initialize()方法将显式的初始化代理实例，因此在session关闭的后 * * * @throws Exception */ public void testLoadInitialized() throws Exception { Session session = HibernateUtils.getSession(); Customer customer = (Customer) session.load(Customer.class, 1); if (!Hibernate.isInitialized(customer)) { Hibernate.initialize(customer); } session.close(); System.out.println(customer.getName()); } } 

 

package com.macower.hibernate.strategy; import java.util.List; import junit.framework.TestCase; import org.hibernate.Session; import org.hibernate.Transaction; public class CustomerOrderTest extends TestCase { /** * 1:先加入数据方便测试 */ public void testAddCustomers() { Customer customer1 = new Customer(); customer1.setName("customer1"); Customer customer2 = new Customer(); customer2.setName("customer2"); Customer customer3 = new Customer(); customer3.setName("customer3"); Customer customer4 = new Customer(); customer4.setName("custome4"); Session session = HibernateUtils.getSession(); Transaction tx = session.beginTransaction(); session.save(customer1); session.save(customer2); session.save(customer3); session.save(customer4); tx.commit(); session.close(); } /** * 2:加入测试数据方便测试 * * @throws Exception */ public void testAddOrders() throws Exception { Order order1 = new Order(); Order order2 = new Order(); Session session = HibernateUtils.getSession(); Customer customer1 = (Customer) session.get(Customer.class, 1); order1.setCustomer(customer1); order1.setName("order1_" + customer1.getName()); order2.setCustomer(customer1); order2.setName("order2_" + customer1.getName()); Order order3 = new Order(); Customer customer2 = (Customer) session.get(Customer.class, 2); order3.setCustomer(customer2); order3.setName("order3_" + customer2.getName()); Order order4 = new Order(); Customer customer3 = (Customer) session.get(Customer.class, 3); order4.setCustomer(customer3); order4.setName("order4_" + customer3.getName()); Order order5 = new Order(); Customer customer4 = (Customer) session.get(Customer.class, 4); order5.setCustomer(customer4); order5.setName("order5_" + customer4.getName()); Order order6 = new Order(); order6.setName("unkowncustomer_"); Transaction tx = session.beginTransaction(); session.save(order1); session.save(order2); session.save(order3); session.save(order4); session.save(order5); session.save(order6); tx.commit(); session.close(); } public void testQueryList() throws Exception { Session session = HibernateUtils.getSession(); /* * 1：<set name="orders" cascade="all" inverse="true">或者 <set * name="orders" cascade="all" inverse="true" lazy="true"> 发出的SQL语句 * 查询出符合条件的Customer，而不会查询出其关联的Orders 只有当其调用 * c.getOrders().size(),iterator()等调用的时候才会发出相应的SQL语句 * * 2： 当 <set name="orders" cascade="all" inverse="true" lazy="false"> 时 * 发出的SQL语句时立刻查询出其对象及其关联对象orders * * 3：当<set name="orders" cascade="all" inverse="true" lazy="extra"> * 效果同lazy=true */ List<Customer> customers = session.createQuery( "from Customer customer ").list(); for (Customer c : customers) { System.out.println(c.getOrders().iterator()); } session.close(); } public void testQueryLoad() throws Exception { Session session = HibernateUtils.getSession(); /* * 1:当 <set name="orders" cascade="all" inverse="true">或者 <set * name="orders" cascade="all" inverse="true" lazy="true"> * 时采用的是懒加载策略，是不会发出sql语句的，只有当其调用其属性的时候才会发出相应SQL * 在加载关联对象的时候也是必须显式的调用关联对象的size(),iterator()及其非主键的属性的时候才会发出关联查询的SQL * * 2:当<set name="orders" cascade="all" inverse="true" lazy="false"> * 时候，当调用customer.getName()的时候会发出两条SQL，一条为查询Customer自身的，另外一条查询其关联对象的 * 后面的ustomer.getOrders().size()调用的时候就不会再发出SQL语句了 * * 3：当<set name="orders" cascade="all" inverse="true" lazy="extra"> * 效果同lazy=true */ Customer customer = (Customer) session.load(Customer.class, 1); System.out.println(customer.getName()); System.out.println(customer.getOrders().size()); session.close(); } /* * 1:当 <set name="orders" cascade="all" inverse="true">或者 <set name="orders" * cascade="all" inverse="true" lazy="true"> * 的时候，当调用session.get(Customer.class, 1)方法的时候会立马发出一条SQL语句查询Customer * 当调用customer.getName()就不会再发，直接将查询上来的结果返回 * 当调用customer.getOrders().size()的时候会发出一条SQL来查询相关的orders的记录 * 2：当<set name="orders" cascade="all" inverse="true" lazy="false">的时候 * 会在调用session.get(Customer.class, 1)方法的时候发出两条SQL，分别查询类级别的和关联级别的SQL语句 * 3:当<set name="orders" cascade="all" inverse="true" lazy="extra"> * 效果和true一样，只是会按照调用函数进行稍微智能点的查询，比如在调用customer.getOrders().size()的时候 * 会发出select count（ID）这样的语句进行查询。 */ public void testQueryGet() throws Exception { Session session = HibernateUtils.getSession(); Customer customer = (Customer) session.get(Customer.class, 1); System.out.println(customer.getName()); System.out.println(customer.getOrders().size()); session.close(); } }  

 

当lazy=false的时候

hibernate采取是立即加载的策略：

* 在进行list()调用的时候会加载其关联的对象，这样会先查出对象然后会将关联的对象也查出来。这样就有1+N次查询。

* 在利用load进行加载的时候 在加载时不会发出SQL语句，只有当其调用getter的时候才会发出两条SQL，一条为load参数中索要查询的对象本身相关的表的SQL，另外一条查询其关联对象的SQL

* 在利用get方式进行查询加载的时候，一旦调用了get方法就会立即发出两条SQL，分别查询类级别的和关联级别的SQL语句

 

lazy= false的时候并不采用懒加载的方式进行，只有当系统或者程序显示的使用加载的时候，才会对lazy=false这一配置进行覆盖。使用lazy=false的场合一般是需要加载其关联对象的时候，在使用这个标签属性的时候可以结合 batch-size属性一起使用，减少SQL的发送量，以提高检索的效率。

 

当使用lazy=true的时候

hibernate采取懒加载的模式进行

   * 在进行list()的时候，只会加载其类的对象本身，如果没有显示的调用获取关联对象的getter（获取主键属性也是不会进行SQL发送的）的话是不能加载其关联对象的。

   * 在load 的时候，是不会发出SQL语句的，只有当其显式的调用getter（非主键的）才会进行SQL发出加载对象的属性，若要加载其关联对象还需要显示的调用获取关联对象或者集合的getter方法，才会进行SQL的发送

  * 在进行get方法的时候，会立即发出SQL语句加载其要查询的对象，并且只有显示的调用获取关联对象或者集合的getter方法，才会进行SQL的发送，对数据进行查询。

 

当在集合中使用 lazy=extra 时大体和lazy=true相似，只是在查询SQL的时候根据所调用的函数。进行了一定的判断和优化。在策略上和lazy=true是一致的。

 

另外值得注意的一个地方是：

 

   load加载上来的是一个代理，在没对其进行初始化的时候，并切session关闭后是不能直接取值的。

这个时候需要在session关闭前 用initialize()方法将显式的初始化代理实例化才能调用，否则会报告LazyInitializationException异常。