Hibernate一级缓存（基于查询分析）

首先我们应该弄清什么是hibernate缓存:hibernate缓存是指为了降低应用程序对物理数据源的访问频次，从而提高应用程序的运行性能的一种策略。我们要将这个跟计算机内存或者cpu的缓存区分开。

一、hibernate查询的几种方式

既然是基于查询分析hibernate一级缓存，我们就来分析分析hibernate查询方式

1、通过session对象的get()方法

我们通过查看hibernate的api文档找到了session接口，并重点看了get()方法，我们主要使用一下两种get()方法：

通过传入由实体类获得的Class类对象（姑且叫做类类型）和该类的唯一标识符两个参数，返回一个Object类型的查询对象。

通过传入实体类名和该类对象的唯一标识符两个参数，返回一个Object类型的查询对象。

代码示例：

 1 package com.third;
 2 
 3 import java.util.List;
 4 
 5 import org.hibernate.Query;
 6 import org.hibernate.Session;
 7 import org.hibernate.SessionFactory;
 8 import org.hibernate.Transaction;
 9 import org.hibernate.cfg.Configuration;
10 import org.hibernate.service.ServiceRegistry;
11 import org.hibernate.service.ServiceRegistryBuilder;
12 import org.junit.After;
13 import org.junit.Before;
14 import org.junit.Test;
15 
16 import com.third.Dao2.Students2;
17 import com.third.Dao2.Students2PartInfo;
18 
19 public class Test3 {
20     private static SessionFactory sessionFactory;
21     private static Session session;
22     private static Transaction transaction;
23     @Before
24     public void init(){
25         //先获取配置对象，匹配hibernate.cfg.xml文件
26         Configuration config=new Configuration().configure();
27         //获取注册服务对象（该对象中包含hibernate.cfg.xml中的<properties>和<maping>信息
28         ServiceRegistry serviceRegistry=new ServiceRegistryBuilder().applySettings(config.getProperties()).buildServiceRegistry();
29         //获取sessionFactory对象，通过sessionFactory对象读取hibernate.cfg.xml文档信息，并通过<mapping>标签加载hbm.xml文件信息
30         sessionFactory=config.buildSessionFactory(serviceRegistry);
31     }
32     
33     @Test
34     public void test3(){
35         //通过sessionFactory对象获取session对象
36         session=sessionFactory.openSession();
37         //通过session对象开启事务，并且返回事务(transaction)对象
38         transaction=session.beginTransaction();    
39     
40         //第一个session对象通过get()方法第一次查询相同记录
41         Students2 stu1=(Students2) session.get(Students2.class, 1);
42         //第一个session对象通过get()函数第二次查询相同记录
43         Students2 stu2=(Students2) session.get(Students2.class, 1);
44         System.out.println("学号："+stu1.getSid()
45             +"  姓别："+stu1.getSgender()+"  姓名："+stu1.getSname());
46         System.out.println("学号："+stu2.getSid()
47         +"  姓别："+stu2.getSgender()+"  姓名："+stu2.getSname());
48         
49         //重新获得一个session对象，再一次执行session对象的get()方法查询相同记录
50         Session session1=sessionFactory.openSession();
51         Students2 stu3=(Students2) session1.get(Students2.class, 1);
52         System.out.println("学号："+stu3.getSid()
53             +"  姓别："+stu3.getSgender()+"  姓名："+stu3.getSname());
54         
55         
56     }
57     
58     @After
59     public void destory(){
60         transaction.commit();
61         //关闭开启的资源
62         if(session!=null){
63             session.close();
64         }
65         if(sessionFactory!=null){
66             sessionFactory.close();
67         }
68     }
69 }

运行结果：

Hibernate: 
    select
        students2x0_.SID as SID1_1_0_,
        students2x0_.SNAME as SNAME2_1_0_,
        students2x0_.SGENDER as SGENDER3_1_0_ 
    from
        STUDENTS2 students2x0_ 
    where
        students2x0_.SID=?
学号：1  姓别：女  姓名：小美
学号：1  姓别：女  姓名：小美
Hibernate: 
    select
        students2x0_.SID as SID1_1_0_,
        students2x0_.SNAME as SNAME2_1_0_,
        students2x0_.SGENDER as SGENDER3_1_0_ 
    from
        STUDENTS2 students2x0_ 
    where
        students2x0_.SID=?
学号：1  姓别：女  姓名：小美

分析：在同一个session对象的条件下查询同一表格记录，hibernate解析的SQL语句只会执行一次，重新获得一个session对象后，再去查询相同的表格记录时，hibernate解析而成的SQL语句会在执行一次。

我们不难得出：在同一个session对象的情况下，使用get()方法查询相同的对象会使用到缓存（一级缓存），不同的session对象在查询相同对象正常情况下是不会使用缓存。

2、通过session的load()方法

我们通过查看hibernate的api文档找到了session接口，并重点看了load()方法，我们主要使用一下两种load()方法：

通过传入由实体类获得的Class类对象（姑且叫做类类型）和该类的唯一标识符两个参数，返回一个Object类型的查询对象。

通过传入实体类名和该类对象的唯一标识符两个参数，返回一个Object类型的查询对象。

代码示例：

 1 package com.third;
 2 
 3 import java.util.List;
 4 
 5 import org.hibernate.Query;
 6 import org.hibernate.Session;
 7 import org.hibernate.SessionFactory;
 8 import org.hibernate.Transaction;
 9 import org.hibernate.cfg.Configuration;
10 import org.hibernate.service.ServiceRegistry;
11 import org.hibernate.service.ServiceRegistryBuilder;
12 import org.junit.After;
13 import org.junit.Before;
14 import org.junit.Test;
15 
16 import com.third.Dao2.Students2;
17 import com.third.Dao2.Students2PartInfo;
18 
19 public class Test3 {
20     private static SessionFactory sessionFactory;
21     private static Session session;
22     private static Transaction transaction;
23     @Before
24     public void init(){
25         //先获取配置对象，匹配hibernate.cfg.xml文件
26         Configuration config=new Configuration().configure();
27         //获取注册服务对象（该对象中包含hibernate.cfg.xml中的<properties>和<maping>信息
28         ServiceRegistry serviceRegistry=new ServiceRegistryBuilder().applySettings(config.getProperties()).buildServiceRegistry();
29         //获取sessionFactory对象，通过sessionFactory对象读取hibernate.cfg.xml文档信息，并通过<mapping>标签加载hbm.xml文件信息
30         sessionFactory=config.buildSessionFactory(serviceRegistry);
31     }
32     
33     @Test
34     public void test3(){
35         //通过sessionFactory对象获取session对象
36         session=sessionFactory.openSession();
37         //通过session对象开启事务，并且返回事务(transaction)对象
38         transaction=session.beginTransaction();    
39         
40         //第一个session对象通过get()方法第一次查询相同记录
41         Students2 stu1=(Students2) session.load(Students2.class, 1);
42         //第一个session对象通过get()函数第二次查询相同记录
43         Students2 stu2=(Students2) session.load(Students2.class, 1);
44         System.out.println("学号："+stu1.getSid()
45             +"  姓别："+stu1.getSgender()+"  姓名："+stu1.getSname());
46         System.out.println("学号："+stu2.getSid()
47         +"  姓别："+stu2.getSgender()+"  姓名："+stu2.getSname());
48         
49         //重新获得一个session对象，再一次执行session对象的get()方法查询相同记录
50         Session session1=sessionFactory.openSession();
51         Students2 stu3=(Students2) session1.load(Students2.class, 1);
52         System.out.println("学号："+stu3.getSid()
53             +"  姓别："+stu3.getSgender()+"  姓名："+stu3.getSname());
54         
55     }
56     
57     @After
58     public void destory(){
59         transaction.commit();
60         //关闭开启的资源
61         if(session!=null){
62             session.close();
63         }
64         if(sessionFactory!=null){
65             sessionFactory.close();
66         }
67     }
68 }

运行结果：

Hibernate: 
    select
        students2x0_.SID as SID1_1_0_,
        students2x0_.SNAME as SNAME2_1_0_,
        students2x0_.SGENDER as SGENDER3_1_0_ 
    from
        STUDENTS2 students2x0_ 
    where
        students2x0_.SID=?
学号：1  姓别：女  姓名：小美
学号：1  姓别：女  姓名：小美
Hibernate: 
    select
        students2x0_.SID as SID1_1_0_,
        students2x0_.SNAME as SNAME2_1_0_,
        students2x0_.SGENDER as SGENDER3_1_0_ 
    from
        STUDENTS2 students2x0_ 
    where
        students2x0_.SID=?
学号：1  姓别：女  姓名：小美

我们不难得出：在同一个session对象的情况下，使用load()方法查询相同的对象会使用到缓存（一级缓存），不同的session对象在查询相同对象正常情况下是不会使用缓存。

我们可以总结得到，load()函数的查询流程和get()函数的查询流程基本相同。

3、通过session对象的createQuery(String HQL)方法

我们通过查看hibernate的api文档找到了session接口，找到createQuery(String HQL)方法，该方法的返回值类型是一个Query（查询），于是，我们找到Query接口，我们找到了两个方法，是将查询结果返回的。

以List的方式返回查询结果

以迭代器的方式返回查询结果

（1）以List的方式返回查询结果

1）有select子句

 1 package com.third;
 2 
 3 import java.util.List;
 4 
 5 import org.hibernate.Query;
 6 import org.hibernate.Session;
 7 import org.hibernate.SessionFactory;
 8 import org.hibernate.Transaction;
 9 import org.hibernate.cfg.Configuration;
10 import org.hibernate.service.ServiceRegistry;
11 import org.hibernate.service.ServiceRegistryBuilder;
12 import org.junit.After;
13 import org.junit.Before;
14 import org.junit.Test;
15 
16 import com.third.Dao2.Students2;
17 import com.third.Dao2.Students2PartInfo;
18 
19 public class Test3 {
20     private static SessionFactory sessionFactory;
21     private static Session session;
22     private static Transaction transaction;
23     @Before
24     public void init(){
25         //先获取配置对象，匹配hibernate.cfg.xml文件
26         Configuration config=new Configuration().configure();
27         //获取注册服务对象（该对象中包含hibernate.cfg.xml中的<properties>和<maping>信息
28         ServiceRegistry serviceRegistry=new ServiceRegistryBuilder().applySettings(config.getProperties()).buildServiceRegistry();
29         //获取sessionFactory对象，通过sessionFactory对象读取hibernate.cfg.xml文档信息，并通过<mapping>标签加载hbm.xml文件信息
30         sessionFactory=config.buildSessionFactory(serviceRegistry);
31     }
32     
33     @Test
34     public void test3(){
35         //通过sessionFactory对象获取session对象
36         session=sessionFactory.openSession();
37         //通过session对象开启事务，并且返回事务(transaction)对象
38         transaction=session.beginTransaction();    
39         
40         //创建HQL语句用于后面的查询需要
41         //查询所有记录的sid和sname信息(hql语句)
42         String hql=" select sid,sname,sgender from Students2";
43         
44         //创建多条记录查询对象query1
45         Query query=session.createQuery(hql);
46         
47         /*
48          * 相同session对象，相同query对象，查询相同的对象
49          */
50         List<Object[]> list=query.list();
51         for (Object[] objects : list) {
52             System.out.println("学号："+objects[0]+" 姓名："+objects[1]+" 性别："+objects[2]);
53         }
54         
55         List<Object[]> list1=query.list();
56         for (Object[] objects : list1) {
57             System.out.println("学号："+objects[0]+" 姓名："+objects[1]+" 性别："+objects[2]);
58         }
59     }
60     
61     @After
62     public void destory(){
63         transaction.commit();
64         //关闭开启的资源
65         if(session!=null){
66             session.close();
67         }
68         if(sessionFactory!=null){
69             sessionFactory.close();
70         }
71     }
72 }

运行结果：

Hibernate: 
    select
        students2x0_.SID as col_0_0_,
        students2x0_.SNAME as col_1_0_,
        students2x0_.SGENDER as col_2_0_ 
    from
        STUDENTS2 students2x0_
学号：1 姓名：小美 性别：女
学号：2 姓名：小泽 性别：男
学号：3 姓名：小敏 性别：女
Hibernate: 
    select
        students2x0_.SID as col_0_0_,
        students2x0_.SNAME as col_1_0_,
        students2x0_.SGENDER as col_2_0_ 
    from
        STUDENTS2 students2x0_
学号：1 姓名：小美 性别：女
学号：2 姓名：小泽 性别：男
学号：3 姓名：小敏 性别：女

2）没有select子句

 1 package com.third;
 2 
 3 import java.awt.event.FocusEvent;
 4 import java.util.Iterator;
 5 import java.util.List;
 6 
 7 import org.hibernate.Query;
 8 import org.hibernate.Session;
 9 import org.hibernate.SessionFactory;
10 import org.hibernate.Transaction;
11 import org.hibernate.cfg.Configuration;
12 import org.hibernate.service.ServiceRegistry;
13 import org.hibernate.service.ServiceRegistryBuilder;
14 import org.junit.After;
15 import org.junit.Before;
16 import org.junit.Test;
17 
18 import com.third.Dao2.Students2;
19 import com.third.Dao2.Students2PartInfo;
20 
21 public class Test3 {
22     private static SessionFactory sessionFactory;
23     private static Session session;
24     private static Transaction transaction;
25     @Before
26     public void init(){
27         //先获取配置对象，匹配hibernate.cfg.xml文件
28         Configuration config=new Configuration().configure();
29         //获取注册服务对象（该对象中包含hibernate.cfg.xml中的<properties>和<maping>信息
30         ServiceRegistry serviceRegistry=new ServiceRegistryBuilder().applySettings(config.getProperties()).buildServiceRegistry();
31         //获取sessionFactory对象，通过sessionFactory对象读取hibernate.cfg.xml文档信息，并通过<mapping>标签加载hbm.xml文件信息
32         sessionFactory=config.buildSessionFactory(serviceRegistry);
33     }
34     
35     @Test
36     public void test3(){
37         //通过sessionFactory对象获取session对象
38         session=sessionFactory.openSession();
39         //通过session对象开启事务，并且返回事务(transaction)对象
40         transaction=session.beginTransaction();    
41         
42         String hql="from Students2";
43         Query query=session.createQuery(hql);
44         List<Students2> stu=query.list();
45         for (Students2 stu1 : stu) {
46             System.out.println("学号："+stu1.getSid()+" 姓名："+stu1.getSname()+" 性别："+stu1.getSgender());
47         }
48         List<Students2> stu2=query.list();
49         for (Students2 stu3 : stu2) {
50             System.out.println("学号："+stu3.getSid()+" 姓名："+stu3.getSname()+" 性别："+stu3.getSgender());
51         }
52         
53         
54     }
55     
56     @After
57     public void destory(){
58         transaction.commit();
59         //关闭开启的资源
60         if(session!=null){
61             session.close();
62         }
63         if(sessionFactory!=null){
64             sessionFactory.close();
65         }        
66     }    
67 }

运行结果：

Hibernate: 
    select
        students2x0_.SID as SID1_1_,
        students2x0_.SNAME as SNAME2_1_,
        students2x0_.SGENDER as SGENDER3_1_ 
    from
        STUDENTS2 students2x0_
学号：1 姓名：小美 性别：女
学号：2 姓名：小泽 性别：男
学号：3 姓名：小敏 性别：女
Hibernate: 
    select
        students2x0_.SID as SID1_1_,
        students2x0_.SNAME as SNAME2_1_,
        students2x0_.SGENDER as SGENDER3_1_ 
    from
        STUDENTS2 students2x0_
学号：1 姓名：小美 性别：女
学号：2 姓名：小泽 性别：男
学号：3 姓名：小敏 性别：女

分析：相同session，甚至相同query对象情况下，查询相同的对象，hibernate解析的SQL语句在数据库执行了两次。

很明显能看出：session.createQuery(hql).list()方法，不会使用缓存。

（2）以迭代的方式返回查询结果

代码示例：

  1 package com.third;
  2 
  3 import java.util.Iterator;
  4 import java.util.List;
  5 
  6 import org.hibernate.Query;
  7 import org.hibernate.Session;
  8 import org.hibernate.SessionFactory;
  9 import org.hibernate.Transaction;
 10 import org.hibernate.cfg.Configuration;
 11 import org.hibernate.service.ServiceRegistry;
 12 import org.hibernate.service.ServiceRegistryBuilder;
 13 import org.junit.After;
 14 import org.junit.Before;
 15 import org.junit.Test;
 16 
 17 import com.third.Dao2.Students2;
 18 import com.third.Dao2.Students2PartInfo;
 19 
 20 public class Test3 {
 21     private static SessionFactory sessionFactory;
 22     private static Session session;
 23     private static Transaction transaction;
 24     @Before
 25     public void init(){
 26         //先获取配置对象，匹配hibernate.cfg.xml文件
 27         Configuration config=new Configuration().configure();
 28         //获取注册服务对象（该对象中包含hibernate.cfg.xml中的<properties>和<maping>信息
 29         ServiceRegistry serviceRegistry=new ServiceRegistryBuilder().applySettings(config.getProperties()).buildServiceRegistry();
 30         //获取sessionFactory对象，通过sessionFactory对象读取hibernate.cfg.xml文档信息，并通过<mapping>标签加载hbm.xml文件信息
 31         sessionFactory=config.buildSessionFactory(serviceRegistry);
 32     }
 33     
 34     @Test
 35     public void test3(){
 36         //通过sessionFactory对象获取session对象
 37         session=sessionFactory.openSession();
 38         //通过session对象开启事务，并且返回事务(transaction)对象
 39         transaction=session.beginTransaction();    
 40         
 41         /*
 42          * 这里我们执行带有select子句的查询
 43          */
 44         //创建HQL语句用于后面的查询需要
 45         //查询所有记录的sid和sname信息(hql语句)
 46         String hql=" select sid,sname,sgender from Students2";
 47         
 48         //创建多条记录查询对象query1
 49         Query query=session.createQuery(hql);
 50         System.out.println("*************带有select子句的查询*********************");
 51         Iterator it=query.iterate();
 52         while(it.hasNext()){
 53             Object[] obj=(Object[])it.next();
 54             System.out.println("学号："+obj[0]+" 姓名："+obj[1]+" 性别："+obj[2]);
 55         }
 56         //在同一session同一query1对象下查询相同的对象
 57         System.out.println("同一个session并且同一个query对象下查询相同对象：");
 58         Iterator it2=query.iterate();
 59         while(it2.hasNext()){
 60             Object[] obj=(Object[])it2.next();
 61             System.out.println("学号："+obj[0]+" 姓名："+obj[1]+" 性别："+obj[2]);
 62         }
 63         System.out.println("**************不带select子句的查询**********************");
 64         /*
 65          * 这里我们执行不带有select子句的查询
 66          */
 67         Session session1=sessionFactory.openSession();
 68         String hql1="from Students2";
 69         Query query1=session.createQuery(hql1);
 70         Iterator<Students2> it1=query1.iterate();
 71         while(it1.hasNext()){
 72             Students2 stu=it1.next();
 73             System.out.println("学号："+stu.getSid()
 74             +"  姓别："+stu.getSgender()+"  姓名："+stu.getSname());
 75         }
 76         //在同一session同一query1对象下查询相同的对象
 77         System.out.println("在同一session同一query1对象下查询相同的对象:");
 78         Iterator<Students2> it3=query1.iterate();
 79         while(it3.hasNext()){
 80             Students2 stu=it3.next();
 81             System.out.println("学号："+stu.getSid()
 82             +"  姓别："+stu.getSgender()+"  姓名："+stu.getSname());
 83         }
 84         //在同一个session但是不是一个query对象下查询相同对象
 85         System.out.println("在同一个session但是不是一个query对象下查询相同对象:");
 86          Query query2=session.createQuery(hql1);
 87             Iterator<Students2> it4=query2.iterate();
 88             while(it4.hasNext()){
 89                 Students2 stu=it4.next();
 90                 System.out.println("学号："+stu.getSid()
 91                 +"  姓别："+stu.getSgender()+"  姓名："+stu.getSname());
 92             }
 93         //在不同的session中，查询相同的对象
 94             System.out.println("在不同的session中，查询相同的对象:");
 95             Session session2=sessionFactory.openSession();
 96             String hql2="from Students2";
 97             Query query3=session2.createQuery(hql1);
 98             Iterator<Students2> it5=query3.iterate();
 99             while(it5.hasNext()){
100                 Students2 stu=it5.next();
101                 System.out.println("学号："+stu.getSid()
102                 +"  姓别："+stu.getSgender()+"  姓名："+stu.getSname());
103             }
104     }
105     
106     @After
107     public void destory(){
108         transaction.commit();
109         //关闭开启的资源
110         if(session!=null){
111             session.close();
112         }
113         if(sessionFactory!=null){
114             sessionFactory.close();
115         }
116     }
117 }

运行结果：

*************带有select子句的查询*********************
Hibernate: 
    select
        students2x0_.SID as col_0_0_,
        students2x0_.SNAME as col_1_0_,
        students2x0_.SGENDER as col_2_0_ 
    from
        STUDENTS2 students2x0_
学号：1 姓名：小美 性别：女
学号：2 姓名：小泽 性别：男
学号：3 姓名：小敏 性别：女
同一个session并且同一个query对象下查询相同对象：
Hibernate: 
    select
        students2x0_.SID as col_0_0_,
        students2x0_.SNAME as col_1_0_,
        students2x0_.SGENDER as col_2_0_ 
    from
        STUDENTS2 students2x0_
学号：1 姓名：小美 性别：女
学号：2 姓名：小泽 性别：男
学号：3 姓名：小敏 性别：女
**************不带select子句的查询**********************
Hibernate: 
    select
        students2x0_.SID as col_0_0_ 
    from
        STUDENTS2 students2x0_
Hibernate: 
    select
        students2x0_.SID as SID1_1_0_,
        students2x0_.SNAME as SNAME2_1_0_,
        students2x0_.SGENDER as SGENDER3_1_0_ 
    from
        STUDENTS2 students2x0_ 
    where
        students2x0_.SID=?
学号：1  姓别：女  姓名：小美
Hibernate: 
    select
        students2x0_.SID as SID1_1_0_,
        students2x0_.SNAME as SNAME2_1_0_,
        students2x0_.SGENDER as SGENDER3_1_0_ 
    from
        STUDENTS2 students2x0_ 
    where
        students2x0_.SID=?
学号：2  姓别：男  姓名：小泽
Hibernate: 
    select
        students2x0_.SID as SID1_1_0_,
        students2x0_.SNAME as SNAME2_1_0_,
        students2x0_.SGENDER as SGENDER3_1_0_ 
    from
        STUDENTS2 students2x0_ 
    where
        students2x0_.SID=?
学号：3  姓别：女  姓名：小敏
在同一session同一query1对象下查询相同的对象:
Hibernate: 
    select
        students2x0_.SID as col_0_0_ 
    from
        STUDENTS2 students2x0_
学号：1  姓别：女  姓名：小美
学号：2  姓别：男  姓名：小泽
学号：3  姓别：女  姓名：小敏
在同一个session但是不是一个query对象下查询相同对象:
Hibernate: 
    select
        students2x0_.SID as col_0_0_ 
    from
        STUDENTS2 students2x0_
学号：1  姓别：女  姓名：小美
学号：2  姓别：男  姓名：小泽
学号：3  姓别：女  姓名：小敏
在不同的session中，查询相同的对象:
Hibernate: 
    select
        students2x0_.SID as col_0_0_ 
    from
        STUDENTS2 students2x0_
Hibernate: 
    select
        students2x0_.SID as SID1_1_0_,
        students2x0_.SNAME as SNAME2_1_0_,
        students2x0_.SGENDER as SGENDER3_1_0_ 
    from
        STUDENTS2 students2x0_ 
    where
        students2x0_.SID=?
学号：1  姓别：女  姓名：小美
Hibernate: 
    select
        students2x0_.SID as SID1_1_0_,
        students2x0_.SNAME as SNAME2_1_0_,
        students2x0_.SGENDER as SGENDER3_1_0_ 
    from
        STUDENTS2 students2x0_ 
    where
        students2x0_.SID=?
学号：2  姓别：男  姓名：小泽
Hibernate: 
    select
        students2x0_.SID as SID1_1_0_,
        students2x0_.SNAME as SNAME2_1_0_,
        students2x0_.SGENDER as SGENDER3_1_0_ 
    from
        STUDENTS2 students2x0_ 
    where
        students2x0_.SID=?
学号：3  姓别：女  姓名：小敏

分析：以迭代器方式返回的查询，执行我们分成使用select子句和没有使用select子句的查询：

1）使用了select子句的查询，是不会使用缓存的

2）不使用select子句的查询，情况可以分为在同一个session下和不同的session下查询相同的对象。在同一个session下，第一次查询缓存中不存在的对象时，会先到数据库中查询要查对象的主键，然后依靠主键使用where子句限定主键，然后一一按照主键到数据库中执行SQL语句查询对象；再次查询相同对象时，会现在缓存中查询对象的编号，找到相同编号的返回，找不到的，再到数据库去按照编号查找。在不同session下，缓存一般不能使用。

二、一级缓存相关介绍

1、hibernate一级缓存也称为“会话级缓存”、“session缓存”。

2、一级缓存的生命周期和session相同，session销毁，缓存也销毁。

3、一级缓存数据的使用范围，或者说是作用域为当前会话。

4、hibernate一级缓存的API

一级缓存无法取消，用两个方法管理。

evict()：用于将某个对象从session中的一级缓存中清除。

clear()：用于将一级缓存中的对象全部清除。

 1 package com.third;
 2 
 3 import org.hibernate.Session;
 4 import org.hibernate.SessionFactory;
 5 import org.hibernate.Transaction;
 6 import org.hibernate.cfg.Configuration;
 7 import org.hibernate.service.ServiceRegistry;
 8 import org.hibernate.service.ServiceRegistryBuilder;
 9 import org.junit.After;
10 import org.junit.Before;
11 import org.junit.Test;
12 
13 import com.third.Dao2.Students2;
14 
15 public class Test3 {
16     private static SessionFactory sessionFactory;
17     private static Session session;
18     private static Transaction transaction;
19     @Before
20     public void init(){
21         //先获取配置对象，匹配hibernate.cfg.xml文件
22         Configuration config=new Configuration().configure();
23         //获取注册服务对象（该对象中包含hibernate.cfg.xml中的<properties>和<maping>信息
24         ServiceRegistry serviceRegistry=new ServiceRegistryBuilder().applySettings(config.getProperties()).buildServiceRegistry();
25         //获取sessionFactory对象，通过sessionFactory对象读取hibernate.cfg.xml文档信息，并通过<mapping>标签加载hbm.xml文件信息
26         sessionFactory=config.buildSessionFactory(serviceRegistry);
27     }
28     
29     @Test
30     public void test3(){
31         //通过sessionFactory对象获取session对象
32         session=sessionFactory.openSession();
33         //通过session对象开启事务，并且返回事务(transaction)对象
34         transaction=session.beginTransaction();    
35         
36         Students2 stu1=(Students2) session.get(Students2.class, 1);
37         Students2 stu2=(Students2) session.get(Students2.class, 2);
38         Students2 stu3=(Students2) session.get(Students2.class, 3);
39         
40         System.out.println("第一遍查询：");
41         System.out.println("学号："+stu1.getSid()+" 姓名："+stu1.getSname()+" 性别："+stu1.getSgender());
42         System.out.println("学号："+stu2.getSid()+" 姓名："+stu2.getSname()+" 性别："+stu2.getSgender());
43         System.out.println("学号："+stu3.getSid()+" 姓名："+stu3.getSname()+" 性别："+stu3.getSgender());
44         
45         //先使用evict()方法，然后在查询相同session下之前查过的对象
46         System.out.println("先使用evict()方法，然后在查询相同session下之前查过的对象:");
47         session.evict(stu1);
48         Students2 stu4=(Students2) session.get(Students2.class, 1);
49         System.out.println("学号："+stu4.getSid()+" 姓名："+stu4.getSname()+" 性别："+stu4.getSgender());
50         
51         //使用clear()方法，然后再查询相同session下之前查过的对象。
52         System.out.println("使用clear()方法，然后再查询相同session下之前查过的对象:");
           session.clear();
53         Students2 stu5=(Students2) session.get(Students2.class, 1);
54         Students2 stu6=(Students2) session.get(Students2.class, 2);
55         Students2 stu7=(Students2) session.get(Students2.class, 3);
56         
57         System.out.println("学号："+stu5.getSid()+" 姓名："+stu5.getSname()+" 性别："+stu5.getSgender());
58         System.out.println("学号："+stu6.getSid()+" 姓名："+stu6.getSname()+" 性别："+stu6.getSgender());
59         System.out.println("学号："+stu7.getSid()+" 姓名："+stu7.getSname()+" 性别："+stu7.getSgender());
60     }
61     
62     @After
63     public void destory(){
64         transaction.commit();
65         //关闭开启的资源
66         if(session!=null){
67             session.close();
68         }
69         if(sessionFactory!=null){
70             sessionFactory.close();
71         }        
72     }    
73 }

运行结果：

Hibernate: 
    select
        students2x0_.SID as SID1_1_0_,
        students2x0_.SNAME as SNAME2_1_0_,
        students2x0_.SGENDER as SGENDER3_1_0_ 
    from
        STUDENTS2 students2x0_ 
    where
        students2x0_.SID=?
Hibernate: 
    select
        students2x0_.SID as SID1_1_0_,
        students2x0_.SNAME as SNAME2_1_0_,
        students2x0_.SGENDER as SGENDER3_1_0_ 
    from
        STUDENTS2 students2x0_ 
    where
        students2x0_.SID=?
Hibernate: 
    select
        students2x0_.SID as SID1_1_0_,
        students2x0_.SNAME as SNAME2_1_0_,
        students2x0_.SGENDER as SGENDER3_1_0_ 
    from
        STUDENTS2 students2x0_ 
    where
        students2x0_.SID=?
第一遍查询：
学号：1 姓名：小美 性别：女
学号：2 姓名：小泽 性别：男
学号：3 姓名：小敏 性别：女
先使用evict()方法，然后在查询相同session下之前查过的对象:
Hibernate: 
    select
        students2x0_.SID as SID1_1_0_,
        students2x0_.SNAME as SNAME2_1_0_,
        students2x0_.SGENDER as SGENDER3_1_0_ 
    from
        STUDENTS2 students2x0_ 
    where
        students2x0_.SID=?
学号：1 姓名：小美 性别：女
使用clear()方法，然后再查询相同session下之前查过的对象:
Hibernate: 
    select
        students2x0_.SID as SID1_1_0_,
        students2x0_.SNAME as SNAME2_1_0_,
        students2x0_.SGENDER as SGENDER3_1_0_ 
    from
        STUDENTS2 students2x0_ 
    where
        students2x0_.SID=?
Hibernate: 
    select
        students2x0_.SID as SID1_1_0_,
        students2x0_.SNAME as SNAME2_1_0_,
        students2x0_.SGENDER as SGENDER3_1_0_ 
    from
        STUDENTS2 students2x0_ 
    where
        students2x0_.SID=?
Hibernate: 
    select
        students2x0_.SID as SID1_1_0_,
        students2x0_.SNAME as SNAME2_1_0_,
        students2x0_.SGENDER as SGENDER3_1_0_ 
    from
        STUDENTS2 students2x0_ 
    where
        students2x0_.SID=?
学号：1 姓名：小美 性别：女
学号：2 姓名：小泽 性别：男
学号：3 姓名：小敏 性别：女

三、总结：

（1）一级缓存的数据的作用范围为一个session，缓存会随着session的销毁而销毁。

（2）其中通过get()、load()、和以Iterator（迭代器）方式返回无select子句查询都会使用到缓存，但是通过以list方式和Iterator（迭代器）方式返回的有select子句的查询不会使用缓存。

（3）其中以Iterator（迭代器）方式返回的hibernate查询都是先从数据库中查询对象的编号，然后到缓存中查找匹配的编号，找到了直接返回，找不到通过where子句限定以编号去数据库中查找，然后返回。

一级缓存查询的流程图：

posted on 2017-03-06 11:36 小调~ 阅读(764) 评论(0) 编辑收藏举报

刷新页面返回顶部

小调~