hibernate缓存学习之【一级缓存】

      最先接触到缓存机制是在学习计算机操作系统原理时，计算机的缓存机制是为了解决CPU和内存的速度差异。CPU存取数据的速度非常快，相对CPU来说内存的速度就慢很多。CPU需要从内存中读取一些数据但是由于内存的速度慢就无法及时提供，所以内存中使用最频繁的数据、指令会被复制到CPU的缓存中CPU就不需要总是和内存打交道这样可以提高效率。CPU的缓存也分为一级和二级，在实际访问中会先找一级缓存，一级没有就会找二级缓存如果二级缓存中也没有就只能到内存中查找。详细原理小编还需要进一步了解。

对比操作系统的缓存机制我们会发现hibernate的缓存机制大体上和操作系统是一致的。

Why：

       为什么hibernate会出现缓存机制？因为hibernate是属于持久层的所以会频繁的和数据库打交道进行数据的读取，正如CPU需要从内存中读取数据类似。为了减少程序运行时访问物理数据源的次数提高运行程序的性能所以hibernate出现了缓存机制，这样hibernate在进行数据读取时会先从一级缓存中查找如果没有则查找二级缓存如果还没有就会访问数据库。和CPU缓存机制类型hibernate缓存中的数据也会根据特定机制进行更新。

What：

hibernate的缓存也分为一级和二级

       一级缓存也称Session级缓存——

           1、  使用session控制，生命周期同session；所以当前session关闭后，缓存就没了

           2、  只能在当前线程中使用，不同的session间不能共享缓存数据

      二级缓存也称sessionFactory级缓存或进程级缓存——

           1、  使用sessionFactory控制，生命周期同sessionFactory

           2、  在当前进程中使用

       共同特点：只缓存实体对象，如果使用HQL查询普通属性不会缓存。具体的意思可以从实例中体会。

How：

         首先是一级缓存的使用：可分为查询实体和查询个别属性

         查询实体：

                   load或get查询一个实体：               

[java]  view plain  copy

 

1.  /** 
2.  * 在同一个session中发出两次load查询 
3.  */  
4. public void testLoad() {  
5.    Sessionsession = null;  
6.    try {  
7.       session= HibernateUtils.getSession();  
8.       session.beginTransaction();  
9.       Studentstudent = (Student)session.load(Student.class, 1);  
10.       System.out.println("student.name="+ student.getName());  
11.        
12.       //不会发出查询语句，load使用缓存  
13.       student= (Student)session.load(Student.class, 1);  
14.       System.out.println("student.name="+ student.getName());  
15.        
16.       session.getTransaction().commit();  
17.    }catch(Exception e) {  
18.       e.printStackTrace();  
19.       session.getTransaction().rollback();  
20.    }finally {  
21.       HibernateUtils.closeSession(session);  
22.    }  
23. }      

         执行完毕发现只发出一条查询语句，说明在第二次进行查询时session是从自己的缓存中获取的数据而不是从库中获取的。测试get方法和load方法是一样的。load和get方法的区别在于load默认是支持延迟加载的。

         list或iterate查询实体集：

[java]  view plain  copy

 

1. /** 
2.  * 在同一个session中发出两次iterate查询,查询实体对象 
3.  */  
4.       public void testIterate () {  
5.    Sessionsession = null;  
6.    try {  
7.       session= HibernateUtils.getSession();  
8.       session.beginTransaction();  
9.       Iteratoriter = session.createQuery("from Student swhere s.id<5").iterate();  
10.       while (iter.hasNext()) {  
11.          Studentstudent = (Student)iter.next();  
12.          System.out.println(student.getName());  
13.       }  
14.       System.out.println("--------------------------------------");  
15.       //它会发出查询id的语句，但不会发出根据id查询学生的语句，因为iterate使用缓存  
16.       iter= session.createQuery("from Student swhere s.id<5").iterate();  
17.       while (iter.hasNext()) {  
18.          Studentstudent = (Student)iter.next();  
19.          System.out.println(student.getName());  
20.       }  
21.       session.getTransaction().commit();  
22.    }catch(Exception e) {  
23.       e.printStackTrace();  
24.       session.getTransaction().rollback();  
25.    }finally {  
26.       HibernateUtils.closeSession(session);  
27.    }  
28. } </span>  

执行结果如下：

     

        第一次查询时iterate会发出1条查询所有id的语句，然后在打印student的name时发出n条根据id查询详细信息的语句一共N+1条。而第二次查询时只发出一条查询id的语句，其他的数据是从session的缓存中获取的。

使用list在同意session中查询实体集，发出的查询语句如下：会发出两条查询语句

      

        出现如上的结果是不是说明使用iterate查询的结果才会放到session的缓存中而list的结果不会放到缓存中呢？看下面一个实例

[java]  view plain  copy

 

1. /** 
2.  * 在同意session中先使用list，然后使用iterate进行查询 
3.  */  
4. public void testListIterate () {  
5.    Sessionsession = null;  
6.    try {  
7.       session= HibernateUtils.getSession();  
8.       session.beginTransaction();  
9.       Liststudents = session.createQuery("select s fromStudent s where s.id<5")  
10.                          .list();  
11.       for (int i=0;i<students.size(); i++) {  
12.          Studentstudnet = (Student)students.get(i);  
13.          System.out.println(studnet.getName());  
14.       }  
15.       System.out.println("----------------------------------");  
16.       Iteratoriter = session.createQuery("from Student swhere s.id<5").iterate();  
17.       while (iter.hasNext()) {  
18.          Studentstudent = (Student)iter.next();  
19.          System.out.println(student.getName());  
20.       }  
21.       session.getTransaction().commit();  
22.    }catch(Exception e) {  
23.       e.printStackTrace();  
24.       session.getTransaction().rollback();  
25.    }finally {  
26.       HibernateUtils.closeSession(session);  
27.    }  
28. }    </span>  

打印出的查询语句如下：

       

        上图中我们看到在使用iterate进程查询时没有发出N+1条语句，只发出了查询所有id的语句，结合两个例子说明list查出的结果会放到session的缓存中但是list本身的查询不会直接使用缓存中的数据，还是在此查询数据库。

 

查询普通属性：

       使用iterate查询某个普通属性，代码实例如下——

[java]  view plain  copy

 

1. /** 
2.  * 在同一个session中发出两次iterate查询,查询普通属性 
3.  */  
4. public void testCache4() {  
5.    Sessionsession = null;  
6.    try {  
7.       session= HibernateUtils.getSession();  
8.       session.beginTransaction();  
9.       Iteratoriter = session.createQuery("select s.namefrom Student s where s.id<5").iterate();  
10.       while (iter.hasNext()) {  
11.          Stringname = (String)iter.next();  
12.          System.out.println(name);  
13.       }  
14.       System.out.println("--------------------------------------");  
15.        
16.       //iterate查询普通属性，一级缓存不会缓存，所以发出查询语句  
17.       //一级缓存是缓存实体对象的  
18.       iter= session.createQuery("select s.namefrom Student s where s.id<5").iterate();  
19.       while (iter.hasNext()) {  
20.          Stringname = (String)iter.next();  
21.          System.out.println(name);  
22.       }  
23.       session.getTransaction().commit();  
24.    }catch(Exception e) {  
25.       e.printStackTrace();  
26.       session.getTransaction().rollback();  
27.    }finally {  
28.       HibernateUtils.closeSession(session);  
29.    }  
30. }      

       以上代码执行观察结果发现会发出两条查询语句，这说明只查询普通属性时session是不会进行缓存的。

一级缓存的生命周期：

[java]  view plain  copy

 

1. /** 
2.     * 在两个session中发load查询 
3.     */  
4.    public void testCache5() {  
5.       Sessionsession = null;  
6.       try {  
7.          session= HibernateUtils.getSession();  
8.          session.beginTransaction();  
9.          Studentstudent = (Student)session.load(Student.class, 1);  
10.          System.out.println("student.name="+ student.getName());  
11.          session.getTransaction().commit();  
12.       }catch(Exception e) {  
13.          e.printStackTrace();  
14.          session.getTransaction().rollback();  
15.       }finally {  
16.          HibernateUtils.closeSession(session);  
17.       }  
18.        
19.       try {  
20.          session= HibernateUtils.getSession();  
21.          session.beginTransaction();  
22.          Studentstudent = (Student)session.load(Student.class, 1);  
23.          //会发出查询语句，session间不能共享一级缓存数据  
24.          //因为他会伴随着session的消亡而消亡  
25.          System.out.println("student.name="+ student.getName());  
26.          session.getTransaction().commit();  
27.       }catch(Exception e) {  
28.          e.printStackTrace();  
29.          session.getTransaction().rollback();  
30.       }finally {  
31.          HibernateUtils.closeSession(session);  
32.       }  
33. }      

执行打印出的查询语句如下：

       

        发出两条查询语句和在第一个测试中使用同一个session只发一条查询语句是有差别的，这说明了一级缓存的生命周期是和session一致的，session关闭缓存就会消失。