hibernate二级缓存

hibernate二级缓存

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

二级缓存的配置和使用：
    * 将echcache.xml文件拷贝到src下
    * 开启二级缓存，修改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>标签（放在ID标签前面）
        * 在hibernate.cfg.xml文件中，采用<class-cache>标签（推荐使用这个方法）
        
二级缓存是缓存实体对象的

了解一级缓存和二级缓存的交互       


=======================================================
一 级缓存是伴随着session一起的，session消亡了，对应的一级缓存也就没有了，而二级缓存则不一样，不同的session是可以共享二级缓存 的！下面的程序，如果没有开启二级缓存，则会发两次sql，但开启后只会发一次，如果将下面的load换成get效果也是一样的

1.     /**
2.      * 开启两个session，分别调用load，（get和load也一样）
3.      */
4.     public void testCache1() {
5.         Session session = null;
6.         try {
7.             session = HibernateUtils.getSession();
8.             session.beginTransaction();
9.             //get和load也一样
10.             Student student = (Student)session.load(Student.class, 1);
11.             System.out.println("student.name=" + student.getName());
12.            
13.             session.getTransaction().commit();
14.         }catch(Exception e) {
15.             e.printStackTrace();
16.             session.getTransaction().rollback();
17.         }finally {
18.             HibernateUtils.closeSession(session);
19.         }
20.        
21.         try {
22.             session = HibernateUtils.getSession();
23.             session.beginTransaction();
24.            
25.             //不会发出sql，因为开启了二级缓存，session是共享二级缓存的
26.             Student student = (Student)session.load(Student.class, 1);
27.             System.out.println("student.name=" + student.getName());
28.            
29.             session.getTransaction().commit();
30.         }catch(Exception e) {
31.             e.printStackTrace();
32.             session.getTransaction().rollback();
33.         }finally {
34.             HibernateUtils.closeSession(session);
35.         }
38. ================================================================
39.     /**
40.      * 开启两个session，分别调用load,在使用SessionFactory清除二级缓存
41.      */
42.     public void testCache3() {
43.         Session session = null;
44.         try {
45.             session = HibernateUtils.getSession();
46.             session.beginTransaction();
47.            
48.             Student student = (Student)session.load(Student.class, 1);
49.             System.out.println("student.name=" + student.getName());
50.            
51.             session.getTransaction().commit();
52.         }catch(Exception e) {
53.             e.printStackTrace();
54.             session.getTransaction().rollback();
55.         }finally {
56.             HibernateUtils.closeSession(session);
57.         }
58.        
59.         //管理二级缓存
60.         SessionFactory factory = HibernateUtils.getSessionFactory();
61.         //factory.evict(Student.class);　　在这种情况下，会将所有的二级缓存全部清除，下面的只会清除指定的
62.         factory.evict(Student.class, 1);
63.        
64.         try {
65.             session = HibernateUtils.getSession();
66.             session.beginTransaction();
67.            
68.             //会发出查询sql，因为二级缓存中的数据被清除了
69.             Student student = (Student)session.load(Student.class, 1);
70.             System.out.println("student.name=" + student.getName());
71.            
72.             session.getTransaction().commit();
73.         }catch(Exception e) {
74.             e.printStackTrace();
75.             session.getTransaction().rollback();
76.         }finally {
77.             HibernateUtils.closeSession(session);
78.         }
79.     }
80.    
81.    
82.     /**
83.      * 一级缓存和二级缓存的交互
84.      */
85.     public void testCache4() {
86.         Session session = null;
87.         try {
88.             session = HibernateUtils.getSession();
89.             session.beginTransaction();
90.            
91.             //仅向二级缓存读数据，而不向二级缓存写数据
92.             session.setCacheMode(CacheMode.GET);
93.             Student student = (Student)session.load(Student.class, 1);
94.             System.out.println("student.name=" + student.getName());
95.            
96.             session.getTransaction().commit();
97.         }catch(Exception e) {
98.             e.printStackTrace();
99.             session.getTransaction().rollback();
100.         }finally {
101.             HibernateUtils.closeSession(session);
102.         }
103.        
104.         try {
105.             session = HibernateUtils.getSession();
106.             session.beginTransaction();
107.            
108.             //发出sql语句，因为session设置了CacheMode为GET，所以二级缓存中没有数据
109.             Student student = (Student)session.load(Student.class, 1);
110.             System.out.println("student.name=" + student.getName());
111.            
112.             session.getTransaction().commit();
113.         }catch(Exception e) {
114.             e.printStackTrace();
115.             session.getTransaction().rollback();
116.         }finally {
117.             HibernateUtils.closeSession(session);
118.         }
119.        
120.         try {
121.             session = HibernateUtils.getSession();
122.             session.beginTransaction();
123.            
124.             //只向二级缓存写数据，而不从二级缓存读数据
125. 　　　//　如果此处不设置cachemode，但它不会发Sql因为上一个已经存了数据，它已经放到了二级缓存中，
126. 　　　//默认的情况下，是可以读取的，貌似此处的每一次设置cachemode只针对当前的session有效？？
127.             session.setCacheMode(CacheMode.PUT);
128.            
129.             //会发出查询sql，因为session将CacheMode设置成了PUT
130.             Student student = (Student)session.load(Student.class, 1);
131.             System.out.println("student.name=" + student.getName());
132.            
133.             session.getTransaction().commit();
134.         }catch(Exception e) {
135.             e.printStackTrace();
136.             session.getTransaction().rollback();
137.         }finally {
138.             HibernateUtils.closeSession(session);
139.         }
140.        
141.     }   
142. }