28hibernate_cache_level_2

hibernate二级缓存

二级缓存也称进程级的缓存或SessionFactory级的缓存，二级缓存可以被所有的session共享
二级缓存的生命周期和SessionFactory的生命周期一致，SessionFactory可以管理二级缓存

二级缓存的配置和使用：
    * 将echcache.xml文件拷贝到src下:

<defaultCache
maxElementsInMemory="10000"
eternal="false"
timeToIdleSeconds="120"
timeToLiveSeconds="120"
overflowToDisk="true"
/>
    * 开启二级缓存，修改hibernate.cfg.xml文件
        <property name= " hibernate.cache.use_second_level_cache "> true</property>
    * 指定缓存产品提供商，修改hibernate.cfg.xml文件
        <property name= " hibernate.cache.provider_class ">org.hibernate.cache.EhCacheProvider</property>
    * 指定那些实体类使用二级缓存（两种方法）
        * 在映射文件中采用<cache>标签：<cache usage= " read-only "/>
        * 在hibernate.cfg.xml文件中，采用< class-cache>标签：< class-cache  class= " com.bjsxt.hibernate.Student " usage= " read-only "/>
        
二级缓存是缓存实体对象的

了解一级缓存和二级缓存的交互        
        
                
invalidation n. 失效；无效
replication  n. 复制；回答；反响


package com.bjsxt.hibernate;

import java.io.Serializable;

import org.hibernate.CacheMode;
import org.hibernate.Session;
import org.hibernate.SessionFactory;

import junit.framework.TestCase;

public  class CacheLevel2Test extends TestCase {

     /* *
     * 开启两个session，分别调用load
     * 测试结果：select ... ...
      */
     public  void testCache1() {
        Session session =  null;
         try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            
            Student student = (Student)session.load(Student. class,  1);
            System. out.println( " student.name= " + student.getName());
            
            session.getTransaction().commit();
        } catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            HibernateUtils.closeSession(session);
        }
        
         try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            
             // 不会发出sql，因为开启了二级缓存，session是共享二级缓存的
            Student student = (Student)session.load(Student. class,  1);
            System. out.println( " student.name= " + student.getName());
            
            session.getTransaction().commit();
        } catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            HibernateUtils.closeSession(session);
        }
        
    }    
    
     /* *
     * 开启两个session，分别调用get
     * 测试结果：select ... ...
      */
     public  void testCache2() {
        Session session =  null;
         try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            
            Student student = (Student)session. get(Student. class,  1);
            System. out.println( " student.name= " + student.getName());
            
            session.getTransaction().commit();
        } catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            HibernateUtils.closeSession(session);
        }
        
         try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            
             // 不会发出sql，因为开启了二级缓存，session是共享二级缓存的
            Student student = (Student)session. get(Student. class,  1);
            System. out.println( " student.name= " + student.getName());
            
            session.getTransaction().commit();
        } catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            HibernateUtils.closeSession(session);
        }
    }    
    
     /* *
     * 开启两个session，分别调用load,再使用SessionFactory清除二级缓存
     * 测试结果：select ...  select ...
      */
     public  void testCache3() {
        Session session =  null;
         try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            
            Student student = (Student)session.load(Student. class,  1);
            System. out.println( " student.name= " + student.getName());
            
            session.getTransaction().commit();
        } catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            HibernateUtils.closeSession(session);
        }
        
         // 管理二级缓存
        SessionFactory factory = HibernateUtils.getSessionFactory();
         // factory.evict(Student.class); // 清除所有对象
        factory.evict(Student. class,  1); // 清除某一个对象
        
         try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            
             // 会发出查询sql，因为二级缓存中的数据被清除了
            Student student = (Student)session.load(Student. class,  1);
            System. out.println( " student.name= " + student.getName());
            
            session.getTransaction().commit();
        } catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            HibernateUtils.closeSession(session);
        }
    }
    
    
     /* *
     * 一级缓存和二级缓存的交互
     * 1、执行load默认会把数据写入二级缓存一份，并且能读出来。
     * 2、设置CacheMode_GET,则只能把数据从二级缓存中读出来，不能写进去一份，此时二级缓存中是没有数据的(二级缓存中没有数据，能读出来)
     * 3、设置CacheMode_PUT,则只能把数据写入二级缓存中一份，此时二级缓存中是有一份数据的,但是却不能把数据从二级缓存中读出来(二级缓存中有数据，读不出来)
       */
    
    
     // Test1:先load默认,再load默认
     // 测试结果：select ... ...
     public  void testCache4_A_defaultLoad_defaultLoad() {
        Session session =  null;
         try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            
             // 向一级缓存和二级缓存中各写入一份
            Student student = (Student)session.load(Student. class,  1);
            System. out.println( " student.name= " + student.getName());
            
            session.getTransaction().commit();
        } catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            HibernateUtils.closeSession(session);
        }
         // 新开一session,清理一级缓存的数据，但是二级缓存中还有数据，再加载的时候直接用二级缓存中的数据
         try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            
            Student student = (Student)session.load(Student. class,  1);
            System. out.println( " student.name= " + student.getName());
            
            session.getTransaction().commit();
        } catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            HibernateUtils.closeSession(session);
        }    
    }    
    


     // Test2:先设置load的模式为：CacheMode.GET，再load默认
     // 测试结果：select ... select ...
     public  void testCache4_B_CacheModeGET_defaultLoad() {
        Session session =  null;
         try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            
             // 仅从二级缓存读数据，而不向二级缓存写数据
            session.setCacheMode(CacheMode.GET);
            
            Student student = (Student)session.load(Student. class,  1);
            System. out.println( " student.name= " + student.getName());
            
            session.getTransaction().commit();
        } catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            HibernateUtils.closeSession(session);
        }
        
         // 新开的session，所以一级缓存中是没有数据的
         try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
             // 此时二级缓存中是没有数据的，要读出数据，得先发select查
            Student student = (Student)session.load(Student. class,  1);
            System. out.println( " student.name= " + student.getName());
            
            session.getTransaction().commit();
        } catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            HibernateUtils.closeSession(session);
        }
                
    }    
    
    
     // Test3:先设置load的模式为：CacheMode.GET，再load默认，再load默认
     // 测试结果：select ... select  ... ...
     public  void testCache4_C_CacheModeGET_defaultLoad__defaultLoad() {
        Session session =  null;
         try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            
             // 仅从二级缓存读数据，而不向二级缓存写数据
            session.setCacheMode(CacheMode.GET);
            
            Student student = (Student)session.load(Student. class,  1);
            System. out.println( " student.name= " + student.getName());
            
            session.getTransaction().commit();
        } catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            HibernateUtils.closeSession(session);
        }
        
        
         // 新开的session，所以一级缓存中是没有数据的
         // 下面的第二个session中，二级缓存中被写入数据
         try {
            
            session = HibernateUtils.getSession();
            session.beginTransaction();
             // 此时二级缓存中是没有数据的，要读出数据，得先发select查
            Student student = (Student)session.load(Student. class,  1);
            System. out.println( " student.name= " + student.getName());
            
            session.getTransaction().commit();
        } catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            HibernateUtils.closeSession(session);
        }
         // 新开每三个session
         try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            
             // 不发sql，因为第二个session中，二级缓存中被写入数据，所以在第三个session中直接使用
            Student student = (Student)session.load(Student. class,  1);
            System. out.println( " student.name= " + student.getName());
            
            session.getTransaction().commit();
        } catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            HibernateUtils.closeSession(session);
        }
        
    }    
    
     // Test4:先设置load的模式为：load=CacheMode.GET，再load默认，再load=CacheMode.PUT
     // 测试结果：select ... select ... select ... 
     public  void testCache4_D_CacheModeGET_defaultLoad_CacheModePUT() {
        Session session =  null;
         try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            
             // 仅从二级缓存读数据，而不向二级缓存写数据
            session.setCacheMode(CacheMode.GET);
            Student student = (Student)session.load(Student. class,  1);
            System. out.println( " student.name= " + student.getName());
            
            session.getTransaction().commit();
        } catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            HibernateUtils.closeSession(session);
        }
        
         try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            
             // 发出sql语句，因为session设置了CacheMode为GET，所以二级缓存中没有数据
             // 此时二级缓存中是没有数据的，要读出数据，得先发select查
            Student student = (Student)session.load(Student. class,  1);
            System. out.println( " student.name= " + student.getName());
            
            session.getTransaction().commit();
        } catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            HibernateUtils.closeSession(session);
        }
        
         try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            
             // 只向二级缓存写数据，而不从二级缓存读数据
            session.setCacheMode(CacheMode.PUT);
            
             // 会发出查询sql，因为session将CacheMode设置成了PUT
            Student student = (Student)session.load(Student. class,  1);
            System. out.println( " student.name= " + student.getName());
            
            session.getTransaction().commit();
        } catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            HibernateUtils.closeSession(session);
        }
        
    }    

/*     20:38:10,265  WARN CacheFactory:43 - read-only cache configured for mutable class: com.bjsxt.hibernate.Student
    20:38:10,265  WARN EhCacheProvider:86 - Could not find configuration [com.bjsxt.hibernate.Student]; using defaults.
    Hibernate: select student0_.id as id1_0_, student0_.name as name1_0_, student0_.classesid as classesid1_0_ from t_student student0_ where student0_.id=?
    student.name=班级0的学生0
    Hibernate: select student0_.id as id1_0_, student0_.name as name1_0_, student0_.classesid as classesid1_0_ from t_student student0_ where student0_.id=?
    student.name=班级0的学生0
    Hibernate: select student0_.id as id1_0_, student0_.name as name1_0_, student0_.classesid as classesid1_0_ from t_student student0_ where student0_.id=?
    student.name=班级0的学生0 */
}

转载于:https://www.cnblogs.com/alamps/archive/2012/08/10/2633062.html