java鬼混笔记：Hibernate：6、二级缓存配置

这次的笔记是配置 二级缓存 直拉上代码了

hibernate.cfg.xml

<<!--开启二级缓存配置-->
<property name="hibernate.cache.use_second_level_cache">true</property>
<!-- 二级缓存提供商 -->
<property name="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</property>
<!-- 开启统计 -->
<property name="hibernate.generate_statistics">true</property>
<!-- 查询缓存 -->
<property name="hibernate.cache.use_query_cache">true</property>

<!-- 注册映射文件 -->
<mapping resource="com/ywj/TestHibernate/e/User.hbm.xml" />

<!-- 要做缓存的对象 可以在这是配置，也可以不在这里配置，在User.hbm.xml中配置<cache usage="read-write"/> -->
<!-- <class-cache usage="read-only" class="com.ywj.TestHibernate.e.User" /> -->
如果不在hibernate.cfg.xml中配置<class-cache usage="read-only" class="com.ywj.TestHibernate.e.User" />，那么要在

user.hbm.xml配置<cache usage="read-write"/>

user.hbml.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.ywj.TestHibernate.e">
<class name="User" table="User">
<cache usage="read-write"/>
<id name="id" column="id" type="java.lang.Long">
<generator class="identity" />
</id>

<property name="name" />
</class>
</hibernate-mapping>

其中 usage有4种配置,这个我就直接从网上复制了，，，
1：事务（Transaction）仅在受管理的环境中可用。它保证可重读的事务隔离级别，可以对读/写比例高，很少更新的数据采用该策略。
2：读写（read-write）使用时间戳机制维护读写提交事务隔离级别。可以对读/写比例高，很少更新的数据采用该策略。
3：非严格读写（notstrict-read-write）不保证Cache和数据库之间的数据库的一致性。使用此策略时，应该设置足够的缓存过期时间，否则可能从缓存中读出脏数据。当一些数据极少改变，并且当这些数据和数据库有一部份不量影响不大时，可以使用此策略。
4：只读（read-only）当确保数据永不改变时，可以使用此策略。(用了这个，保存会报错)

测试一下：

Test.java

package com.ywj.TestHibernate.test;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.stat.Statistics;

import com.ywj.TestHibernate.e.User;

public class Test {

public static void main(String[] args) {

one();
two();

}

public static void one() {
Session s = HibernateUtils.getSession();
Transaction t = null;

try {

t = s.beginTransaction();

Statistics st = HibernateUtils.getSessionFactory().getStatistics();
System.out.println("第一次查询前错过次数:"+st.getSecondLevelCacheMissCount());
System.out.println("第一次查询前放入次数:"+st.getSecondLevelCachePutCount());
System.out.println("第一次查询前命中次数:"+st.getSecondLevelCacheHitCount());
System.out.println();
System.out.println("第一次开始查询了");

User u = (User) s.get(User.class, 1L);
System.out.println(u.getName());

System.out.println();
System.out.println("第一次查询时错过次数:"+st.getSecondLevelCacheMissCount());
System.out.println("第一次查询后放入次数:"+st.getSecondLevelCachePutCount());
System.out.println("第一次查询后命中次数:"+st.getSecondLevelCacheHitCount());
System.out.println();
System.out.println("第二次开始查询了");
System.out.println();
User u2 = (User) s.get(User.class, 1L);
System.out.println(u2.getName());
System.out.println();
System.out.println("第二次查询后错过次数:"+st.getSecondLevelCacheMissCount());
System.out.println("第二次查询后放入次数:"+st.getSecondLevelCachePutCount());
System.out.println("第二次查询后命中次数:"+st.getSecondLevelCacheHitCount() +" 此时session没有关闭，还是从一级缓存获取");
System.out.println();
t.commit();

} catch (Exception e) {
e.printStackTrace();
t.rollback();
} finally {
s.close();
}

}

public static void two() {
Session s = HibernateUtils.getSession();
Transaction t = null;

try {

t = s.beginTransaction();

System.out.println("第三次开始查询了");
Statistics st = HibernateUtils.getSessionFactory().getStatistics();
System.out.println();
User u = (User) s.get(User.class, 1L);
System.out.println(u.getName());
System.out.println();
System.out.println("第三次查询后错过次数:"+st.getSecondLevelCacheMissCount());
System.out.println("第三次查询后放入次数:"+st.getSecondLevelCachePutCount());
System.out.println("第三次查询后命中次数:"+st.getSecondLevelCacheHitCount() +" 这里没有执行sql语句，说明了从二级缓存里获取的");
System.out.println();
System.out.println();
t.commit();

} catch (Exception e) {
e.printStackTrace();
t.rollback();
} finally {
s.close();
}
}

}


控制台打印：
第一次查询前错过次数:0
第一次查询前放入次数:0
第一次查询前命中次数:0

第一次开始查询了
Hibernate: select user0_.id as id1_0_0_, user0_.name as name2_0_0_ from User user0_ where user0_.id=?
name

第一次查询时错过次数:1
第一次查询后放入次数:1
第一次查询后命中次数:0

第二次开始查询了

name

第二次查询后错过次数:1
第二次查询后放入次数:1
第二次查询后命中次数:0 此时session没有关闭，还是从一级缓存获取

八月 23, 2017 8:55:31 下午 org.hibernate.engine.internal.StatisticalLoggingSessionEventListener end
INFO: Session Metrics {
15389 nanoseconds spent acquiring 1 JDBC connections;
0 nanoseconds spent releasing 0 JDBC connections;
8879028 nanoseconds spent preparing 1 JDBC statements;
689421 nanoseconds spent executing 1 JDBC statements;
0 nanoseconds spent executing 0 JDBC batches;
3741886 nanoseconds spent performing 1 L2C puts;
0 nanoseconds spent performing 0 L2C hits;
329663 nanoseconds spent performing 1 L2C misses;
2729641 nanoseconds spent executing 1 flushes (flushing a total of 1 entities and 0 collections);
0 nanoseconds spent executing 0 partial-flushes (flushing a total of 0 entities and 0 collections)
}
第三次开始查询了

name

第三次查询后错过次数:1
第三次查询后放入次数:1
第三次查询后命中次数:1 这里没有执行sql语句，说明了从二级缓存里获取的

八月 23, 2017 8:55:31 下午 org.hibernate.engine.internal.StatisticalLoggingSessionEventListener end
INFO: Session Metrics {
7524 nanoseconds spent acquiring 1 JDBC connections;
0 nanoseconds spent releasing 0 JDBC connections;
0 nanoseconds spent preparing 0 JDBC statements;
0 nanoseconds spent executing 0 JDBC statements;
0 nanoseconds spent executing 0 JDBC batches;
0 nanoseconds spent performing 0 L2C puts;
171330 nanoseconds spent performing 1 L2C hits;
0 nanoseconds spent performing 0 L2C misses;
110116 nanoseconds spent executing 1 flushes (flushing a total of 1 entities and 0 collections);
0 nanoseconds spent executing 0 partial-flushes (flushing a total of 0 entities and 0 collections)
}


OK， 二级缓存有效了。。。

怎么清除二级缓存，一般用

HibernateUtils.getSessionFactory().evict(XXX.class)等等。不过这个方法在4.2过期了，看API，换

HibernateUtils.getSessionFactory().getCache().evictEntityRegion(User.class);