Hibernate学习笔记（六）—— 查询优化

一、Hibernate的抓取策略

1.1 什么是抓取策略

　　抓取策略是当应用程序需要在（Hibernate实体对象图的）关联关系间进行导航的时候，Hibernate如何获取关联对象的策略。

　　HIbernate的抓取策略是Hibernate提升性能的一种手段，可以在获取关联对象的时候，对发送的语句进行优化，但是往往抓取策略需要和延迟加载一起使用来提升性能。我们首先来学习一下延迟加载的内容。

1.2 延迟加载的分类

　　延迟加载（lazy load）是（也称为懒加载）Hibernate关联关系对象默认的加载方式，延迟加载机制是为了避免一些无谓的性能开销而提出来的，所谓延迟加载就是当在真正需要数据的时候，才真正执行数据加载操作。可以简单理解为，只有在使用的时候，才会发出sql语句进行查询。

【类级别的延迟加载】

　　使用load方法查询某个对象的时候，这个类是否采用延迟加载的策略，就是类级别的延迟。类级别的延迟一般在<class>上配置lazy属性，lazy的默认值是true。默认是延迟加载的，所以使用load方法去查询的时候，不会马上发送SQL语句，当真正使用该对象的时候，才会发送SQL语句。

　　@Test
    public void fun1() throws Exception {
        Session session = HibernateUtils.openSession();
        Transaction tx = session.beginTransaction();

        Customer customer = session.load(Customer.class, 1l); // 不会马上发送SQL语句
        System.out.println(customer); //使用到该对象后，才会发送SQL语句

        tx.commit();
        session.close();
    }

 　　其实如果不想使用延迟加载也有很多种方法，当然最简单的就是在这个类的映射文件上将<class>的lazy属性设置为false（当lazy为false时，load方法和get方法没有任何区别，都是调用时就加载数据）；当然也可以将这个持久化类改为final修饰，这样就无法生成代理类，就会使延迟加载失效。

　　

　　这就是类级别的延迟加载，为了提高效率，类延迟加载我们一般不进行修改，采用默认值lazy="true"即可。

　　注意:使用懒加载时要确保,调用属性加载数据时,session还是打开的.不然会抛出异常：

　　　　

【关联级别的延迟加载】

　　关联级别的延迟加载指的是，在查询到某个对象的时候，查询其关联的对象时，是否采用延迟加载。

Customer customer = session.load(Customer.class, 1l);
Set<LinkMan> linkMans = customer.getLinkMans();

　　通过客户查询其关联的联系人对象，在查询联系人的时候是否采用延迟加载称为是关联级别的延迟。关联级别的延迟通常是在<set>和<many-to-one>上进行配置。

• <set>标签：

　　　　

• <many-to-one>标签：

　　　　

1.3 抓取策略

 　　抓取策略指的是查询到某个对象的时候，如何抓取其关联的对象。通常可以在<set>和<many-to-one>上配置fetch属性（决定使用什么类型的sql语句加载集合数据）

• <set>标签

　　　

• <many-to-one>标签

　　 

　　这样来看在<set>上配置fetch有三个值，lazy有三个值，这样就会产生很多种效果。其实不用担心，因为fetch如果设置为join，lazy就会失效了。

　　下面我们通过在<set>标签上设置fetch和lazy来查看每种取值的效果。

1.4 测试代码

 　　需求1：查询1号客户，同时查询1号客户的联系人数量

• 默认情况下

      @Test
      public void fun1() throws Exception {
          Session session = HibernateUtils.openSession();
          Transaction tx = session.beginTransaction();
  
          // 查询1号客户
          Customer customer = session.get(Customer.class, 1l);// 发送一条select语句查询1号客户
          // 获得1号客户联系人的数量
          System.out.println(customer.getLinkMans().size()); // 发送一条select语句查询1号客户的所有联系人 
  
          tx.commit();
          session.close();
      }

• 在<set>上配置fetch="select"  lazy="true"

      @Test
      public void fun2() throws Exception {
          Session session = HibernateUtils.openSession();
          Transaction tx = session.beginTransaction();
          
          // 查询1号客户
          Customer customer = session.get(Customer.class, 1l);// 发送一条select语句查询1号客户
          // 获得1号客户联系人的数量
          System.out.println(customer.getLinkMans().size()); // 发送一条select语句查询1号客户的所有联系人 
          
          tx.commit();
          session.close();
      }

• 在<set>上配置fetch="select"  lazy="false"

      @Test
      public void fun3() throws Exception {
          Session session = HibernateUtils.openSession();
          Transaction tx = session.beginTransaction();
          
          // 查询1号客户
          Customer customer = session.get(Customer.class, 1l);// 发送两条select语句,一条查询1号客户,一条查询1号客户的所有联系人
          // 获得1号客户联系人的数量
          System.out.println(customer.getLinkMans().size()); // 不发送sql语句
          
          tx.commit();
          session.close();
      }

• 在<set>上配置fetch="select"  lazy="extra"

      @Test
      public void fun4() throws Exception {
          Session session = HibernateUtils.openSession();
          Transaction tx = session.beginTransaction();
          
          // 查询1号客户
          Customer customer = session.get(Customer.class, 1l);// 发送一条select语句查询1号客户
          // 获得1号客户联系人的数量
          System.out.println(customer.getLinkMans().size()); // 发送一条select count(*)语句统计个数
          
          tx.commit();
          session.close();
      }

• 在<set>上配置fetch="join"  lazy="..."(当fetch为join时，lazy会失效）

      @Test
      public void fun5() throws Exception {
          Session session = HibernateUtils.openSession();
          Transaction tx = session.beginTransaction();
          
          // 查询1号客户
          Customer customer = session.get(Customer.class, 1l);//发送一条迫切左外连接直接将关联的对象一起查询了
          // 获得1号客户联系人的数量
          System.out.println(customer.getLinkMans().size()); //不发送了
          
          tx.commit();
          session.close();
      }

• 在<set>上配置fetch="subselect"  lazy="true"

      @Test
      public void fun6() throws Exception {
          Session session = HibernateUtils.openSession();
          Transaction tx = session.beginTransaction();
          
          // 子查询不能查询某个对象,查询多个对象来测试
          List<Customer> list = session.createQuery("from Customer").list(); //发送查询客户的语句
          for (Customer customer : list) {
              System.out.println(customer.getLinkMans().size()); //发送一条子查询,查询客户关联的联系人
          }
          
          tx.commit();
          session.close();
      }

• 在<set>上配置fetch="subselect"  lazy="false" 

      @Test
      public void fun7() throws Exception {
          Session session = HibernateUtils.openSession();
          Transaction tx = session.beginTransaction();
          
          // 子查询不能查询某个对象,查询多个对象来测试
          List<Customer> list = session.createQuery("from Customer").list(); //发送两条sql:一条查询所有客户;一条子查询,查询客户关联的联系人
          for (Customer customer : list) {
              System.out.println(customer.getLinkMans().size()); 
          }
          
          tx.commit();
          session.close();
      }

　　在<set>标签上的抓取策略已经明白了，那么在<many-to-one>上的fetch和lazy又是什么样的效果呢？我们也可以通过程序来测试一下。

　　需求2：查询1号联系人，同时查询1号联系人所关联客户的信息

• 默认情况

      @Test
      public void demo1() throws Exception {
          Session session = HibernateUtils.openSession();
          Transaction tx = session.beginTransaction();
          
          // 查询1号联系人
          LinkMan linkMan = session.get(LinkMan.class, 1l);//发送一条select语句查询1号联系人
          System.out.println(linkMan.getCustomer().getCust_name());//发送一条select语句查询1号联系人对应的客户信息
          
          tx.commit();
          session.close();
      }

• 在<many-to-one>上配置fetch="select" lazy="proxy"

      @Test
      public void demo2() throws Exception {
          Session session = HibernateUtils.openSession();
          Transaction tx = session.beginTransaction();
          
          // 查询1号联系人
          LinkMan linkMan = session.get(LinkMan.class, 1l);//发送一条select语句查询1号联系人
          System.out.println(linkMan.getCustomer().getCust_name());//发送一条select语句查询1号联系人对应的客户信息
          
          tx.commit();
          session.close();
      }

• 在<many-to-one>上配置fetch="select" lazy="false"

      @Test
      public void demo3() throws Exception {
          Session session = HibernateUtils.openSession();
          Transaction tx = session.beginTransaction();
          
          // 查询1号联系人
          LinkMan linkMan = session.get(LinkMan.class, 1l);//发送两条select:一条发送查询1号联系人;一条查询1号联系人对应的客户信息
          System.out.println(linkMan.getCustomer().getCust_name());//不发送
          
          tx.commit();
          session.close();
      }

• 在<many-to-one>上配置fetch="join" lazy="失效"

      @Test
      public void demo4() throws Exception {
          Session session = HibernateUtils.openSession();
          Transaction tx = session.beginTransaction();
          
          // 查询1号联系人
          LinkMan linkMan = session.get(LinkMan.class, 1l);//发送一条迫切左外连接查询关联对象
          System.out.println(linkMan.getCustomer().getCust_name());//不发送
          
          tx.commit();
          session.close();
      }

1.5 <set>标签的fetch和lazy总结

　　fetch：控制的是查询其关联对象的时候采用的SQL语句的格式。 　　　　

　　　　* select：默认值。发送一条select语句查询其关联对象 　　　　

　　　　* join：发送一条迫切左外连接查询关联对象 　　　　

　　　　* subselect：发送一条子查询查询其关联对象

　　lazy：控制的是查询其关联对象的时候是否采用延迟加载的策略 　　　　

　　　　* true：默认值。默认查询对象的时候采用延迟加载 　　　　

　　　　* false：查询关联对象的时候，不采用延迟加载 　　　　

　　　　* extra：极其懒惰。查询关联对象的时候，采用比延迟加载更懒惰的方式进行查询

1.6 批量抓取

　　当我们想查询所有客户，然后再查询所有客户关联的联系人时，为了提高效率，就可以考虑使用批量抓取。

　　如果要实现批量的抓取效果，可以通过配置batch-size来完成。

【查询客户批量抓取联系人】

    @Test
    public void demo1() throws Exception {
        Session session = HibernateUtils.openSession();
        Transaction tx = session.beginTransaction();

        List<Customer> list = session.createQuery("from Customer").list();
        for (Customer customer : list) {
            System.out.println("客户的名称:" + customer.getCust_name());
            for (LinkMan linkMan : customer.getLinkMans()) {
                System.out.println("客户对应的联系人名称:"+linkMan.getLkm_name());
            }
        }

        tx.commit();
        session.close();
    }

　　在没有设置batch-size之前运行以上代码，会出现如下效果：

　　

　　目前数据库中有两个客户，会发现执行代码发送了3条sql语句。我们能不能发送一条sql语句直接将两个客户关联的联系人一起查询出来呢？我们可以在<set>上配置batch-size来实现优化效果。

　　　　

　　配置完batch-size以后，再次运行以上代码会发现：

　　

　　这时会发现SQL语句发生了变化，当数据量越大，效果越明细。

【查询联系人批量抓取客户】

    @Test
    public void demo2() throws Exception {
        Session session = HibernateUtils.openSession();
        Transaction tx = session.beginTransaction();
        
        List<LinkMan> list = session.createQuery("from LinkMan").list();
        for (LinkMan linkMan : list) {
            System.out.println("联系人:"+linkMan.getLkm_name());
            System.out.println("联系人对应的客户:"+linkMan.getCustomer().getCust_name());
        }
        
        tx.commit();
        session.close();
    }

 　　如果没有配置batch-size，执行上述代码会得到如下效果：

　　

　　如果配置了batch-size，再次执行上述代码得到如下效果：

　　注意：这时候要在Customer.hbm.xml的<class>标签上配置batch-size

　　

　　

　　可以看到语句和之前已经发生变化了。这些优化都是Hibernate提升自身性能的手段。