疯狂java


您现在的位置: 疯狂软件 >> 新闻资讯 >> 正文

hibernate教程--抓取策略详解


 

 
Hibernate的抓取策略
1.1、 区分延迟和立即检索:
立即检索:
* 当执行某行代码的时候,马上发出SQL语句进行查询.
* get()
延迟检索:
* 当执行某行代码的时候,不会马上发出SQL语句进行查询.当真正使用这个对象的时候才会发送SQL语句.
* load();
 
 
1.2、类级别检索和关联级别检索:
类级别的检索:
* <class>标签上配置lazy
关联级别的检索:
* <set>/<many-to-one>上面的lazy.
 
 
1.2.1、从一的一方关联多的一方:
* <set>
* fetch:控制sql语句的类型
* join:发送迫切左外连接的SQL查询关联对象.fetch=”join”那么lazy被忽略了.
* select:默认值,发送多条SQL查询关联对象.
* subselect:发送子查询查询关联对象.(需要使用Query接口测试)
 
* lazy:控制关联对象的检索是否采用延迟.
* true:默认值, 查询关联对象的时候使用延迟检索
* false:查询关联对象的时候不使用延迟检索.
* extra:及其懒惰.
 
如果fetch是join的情况,lazy属性将会忽略.
 
1.2.2、在多的一方关联一的一方:
* <many-to-one>
* fetch:控制SQL语句发送格式
* join:发送一个迫切左外连接查询关联对象.fetch=”join”,lay属性会被忽略.
* select:发送多条SQL检索关联对象.
* lazy:关联对象检索的时候,是否采用延迟
* false:不延迟
* proxy:使用代理.检索订单额时候,是否马上检索客户 由Customer对象的映射文件中<class>上lazy属性来决定.
* no-proxy:不使用代理
 
测试:
[java] view plain copy print?在CODE上查看代码片派生到我的代码片
package com.sihai.hibernate3.test;  
  
import java.util.List;  
  
import org.hibernate.Hibernate;  
import org.hibernate.Session;  
import org.hibernate.Transaction;  
import org.junit.Test;  
  
import com.sihai.hibernate3.demo1.Customer;  
import com.sihai.hibernate3.demo1.Order;  
import com.sihai.utils.HibernateUtils;  
  
/** 
 * Hibernate的抓取策略 
 *  
 * @author sihai 
 *  
 */  
public class HibernateTest4 {  
    @SuppressWarnings("unchecked")  
    @Test  
    // 批量抓取:  
    // 从订单批量抓取客户  
    // 在Customer.hbm.xml中<class>标签上设置batch-size=""  
    public void demo9(){  
        Session session = HibernateUtils.openSession();  
        Transaction tx = session.beginTransaction();  
          
        // 查询所有的订单:  
        List<Order> list = session.createQuery("from Order").list();  
        for (Order order : list) {  
            System.out.println(order.getCustomer().getCname());  
        }  
          
        tx.commit();  
        session.close();  
    }  
      
    @Test  
    // 批量抓取:  
    // 从客户批量抓取订单  
    // <set>标签上设置batch-size=""  
    public void demo8(){  
        Session session = HibernateUtils.openSession();  
        Transaction tx = session.beginTransaction();  
          
        // 查询所有客户  
        List<Customer> list = session.createQuery("from Customer").list();  
        for (Customer customer : list) {  
            for (Order order : customer.getOrders()) {  
                System.out.println(order.getAddr());  
            }  
        }  
          
        tx.commit();  
        session.close();  
    }  
      
    @Test  
    // 在Order.hbml.xml中<many-to-one>标签上配置fetch和lazy  
    public void demo7(){  
        Session session = HibernateUtils.openSession();  
        Transaction tx = session.beginTransaction();  
          
        /** 
         * fetch="select",lazy="false" 
         */  
        // 查询一号订单  
        //Order order = (Order) session.get(Order.class, 1);// 发送多条SQL查询关联对象  
        // 查询一号订单所属客户的名称:  
        //System.out.println("客户名称:"+order.getCustomer().getCname());// 不发送SQL  
          
        /** 
         * fetch="select",lazy="proxy" 
         * proxy:查询关联对象的时候,是否采用延迟,由另一端的类级别延迟来决定. 
         *  * Customer的<class>上配置的是lazy="true".检索的时候采用延迟 
         *  * Customer的<class>上配置的是lazy="false".检索的时候不采用延迟 
         */  
        // 查询一号订单  
        Order order = (Order) session.get(Order.class, 1);// 发送多条SQL查询关联对象  
        // 查询一号订单所属客户的名称:  
        System.out.println("客户名称:"+order.getCustomer().getCname());// 不发送SQL  
          
        tx.commit();  
        session.close();  
    }  
      
    @Test  
    // 在Order.hbml.xml中<many-to-one>标签上配置fetch和lazy  
    public void demo6(){  
        Session session = HibernateUtils.openSession();  
        Transaction tx = session.beginTransaction();  
          
        /** 
         * fetch="join",lazy被忽略. 
         */  
        // 查询一号订单  
        Order order = (Order) session.get(Order.class, 1);// 发送一条迫切左外连接查询关联对象.  
        // 查询一号订单所属客户的名称:  
        System.out.println("客户名称:"+order.getCustomer().getCname());  
          
        tx.commit();  
        session.close();  
    }  
      
    @SuppressWarnings("unchecked")  
    @Test  
    // 在Customer.hbm.xml的<set>标签上配置fetch和lazy  
    // fetch="subselect" 子查询  
    public void demo5(){  
        Session session = HibernateUtils.openSession();  
        Transaction tx = session.beginTransaction();  
        /** 
         * 配置fetch="subselect" lazy="true" 
         */  
//      List<Customer> list = session.createQuery("from Customer").list();// 发送查询所有客户的SQL  
//      for (Customer customer : list) {  
//          System.out.println("客户订单数量:"+customer.getOrders().size());// 发送一个子查询去查询关联对象.  
//      }  
          
        // 使用子查询 查询多个的情况.  
        /*Customer customer = (Customer) session.get(Customer.class, 1); 
        System.out.println("客户订单数量:"+customer.getOrders().size());*/  
          
        /** 
         * 配置fetch="subselect" lazy="false" 
         */  
//      List<Customer> list = session.createQuery("from Customer").list();// 发送查询所有客户的SQL,发送一个子查询查询订单  
//      for (Customer customer : list) {  
//          System.out.println("客户订单数量:"+customer.getOrders().size());// 不发送SQL  
//      }  
          
        /** 
         * 配置fetch="subselect" lazy="extra" 
         */  
        List<Customer> list = session.createQuery("from Customer").list();// 发送查询所有客户的SQL  
        for (Customer customer : list) {  
            System.out.println("客户订单数量:"+customer.getOrders().size());// 只发送统计客户订单数量的sql  
            for (Order order : customer.getOrders()) {  
                System.out.println(order.getAddr());  
            }  
        }  
          
        tx.commit();  
        session.close();  
    }  
      
    @Test  
    // 在Customer.hbm.xml的<set>标签上配置fetch和lazy  
    // fetch="select"  
    public void demo4() {  
        Session session = HibernateUtils.openSession();  
        Transaction tx = session.beginTransaction();  
  
        /** 
         * 配置fetch="select" lazy="true" 
         * * 发送多条SQL.默认值就是fetch="select" lazy="true" 
         */  
        // 查询一号客户  
        // Customer customer = (Customer) session.get(Customer.class, 1);//发送一条查询客户的SQL  
        // 查看一号客户的订单的数量:  
        // System.out.println("订单的数量:" + customer.getOrders().size());//又发送一条查询订单的SQL  
          
        /** 
         * 配置fetch="select" lazy="false" 
         */  
        // 查询一号客户  
        //Customer customer = (Customer) session.get(Customer.class, 1);//发送多条SQL查询  
        // 查看一号客户的订单的数量:  
        //System.out.println("订单的数量:" + customer.getOrders().size());//不发送SQL  
          
        /** 
         * 配置fetch="select" lazy="extra" 
         * * extra:及其懒惰的. 
         */  
        // 查询一号客户  
        Customer customer = (Customer) session.get(Customer.class, 1);// 发送一条查询客户的SQL  
        // 查看一号客户的订单的数量:  
        System.out.println("订单的数量:" + customer.getOrders().size());// 查询订单的数量:select count(oid) from orders o where o.cid = ?   
          
        for (Order order : customer.getOrders()) {  
            System.out.println(order);  
        }  
          
        tx.commit();  
        session.close();  
    }  
      
    @Test  
    // 在Customer.hbm.xml的<set>标签上配置fetch和lazy  
    // fetch="join",lazy的取值就会被忽略.  
    public void demo3() {  
        Session session = HibernateUtils.openSession();  
        Transaction tx = session.beginTransaction();  
  
        // 查询一号客户  
        Customer customer = (Customer) session.get(Customer.class, 1);// 发送了一条迫切左外连接的SQL  
          
        // 查看一号客户的订单的数量:  
        System.out.println("订单的数量:" + customer.getOrders().size());// 不发送SQL.  
          
        tx.commit();  
        session.close();  
    }  
  
    @Test  
    // 默认的情况下 没有配置任何信息  
    // 发送多条SQL查询其关联对象.  
    public void demo2() {  
        Session session = HibernateUtils.openSession();  
        Transaction tx = session.beginTransaction();  
  
        // 查询一号客户  
        Customer customer = (Customer) session.get(Customer.class, 1);// 发送一条查询客户的SQL.  
  
        // 查看一号客户的订单的数量:  
        System.out.println("订单的数量:" + customer.getOrders().size());// 使用订单的时候,又会发送一条SQL查询  
  
        tx.commit();  
        session.close();  
    }  
  
    @Test  
    // 区分立即和延迟检索  
    public void demo1() {  
        Session session = HibernateUtils.openSession();  
        Transaction tx = session.beginTransaction();  
  
        // 立即检索  
        // Customer customer = (Customer) session.get(Customer.class, 1);  
  
        // System.out.println(customer.getCname());  
  
        // 延迟检索:  
        Customer customer = (Customer) session.load(Customer.class, 1);  
  
        Hibernate.initialize(customer);  
  
        System.out.println(customer.getCname());  
  
        tx.commit();  
        session.close();  
    }  
}