简单聊聊Ehcache缓存

最近工做没有那么忙，有时间来写写东西。今年的系统分析师报名已经开始了，面对历年的真题，真的难以入笔，因此忽然对将来充满了担心，仍是得抓紧时间学习技术。

同事推了一篇软文，看到了这个Ehcache，感受简单又好用，因此在本身这边也作个记录。

先来谈谈什么是Ehcache缓存，咱们从实际场景出发，支撑一个系统最直接的东西就是数据库，针对数据库咱们最经常使用的操做就是查询。反复的查询数据库会致使数据库压力变大，传统的数据库查询效率就不高（网络、sql语句复杂），致使查询体验很差。尤为当咱们查询的语句仍是相似甚至重复的时候，这就是浪费资源了。那这个时候，缓存机制就变得颇有必要了。像咱们常用的实现缓存的方式大体有两种，一种是NoSQL数据库，好比Redis、MongoDB等，另外一种即是今天要提的缓存框架：Ehcache、Memcache等。

引用官方的内容一句话定义：EhCache 是一个纯Java的进程内缓存框架，具备快速、精干等特色，是Hibernate中默认的CacheProvider。

下面就开始使用了：

整合Ehcache-优化性能-下降查询数据库的频率

Spring集成Ehcache：

配置Ehcache缓存管理器（EhcacheManager），将其注入给Spring平台缓存管理器(cachemanager)，Spring平台缓存管理器再注入给Spring缓存注解驱动。代码中使用注解进行缓存。

 

Shiro集成Ehcache：

配置Ehcache缓存管理器（EhcacheManager），将其注入给Shiro缓存管理器（这里是shiro整合ehcache的缓存管理器），最后将Shiro的缓存管理器注入给Shiro安全管理器

1．经过maven坐标导入jar（ehcache和spring的context-support）

 

<ehcache.version>2.6.10</ehcache.version>

<dependency>

    <groupId>net.sf.ehcache</groupId>

    <artifactId>ehcache-core</artifactId>

    <version>${ehcache.version}</version>

</dependency>

<dependency>

    <groupId>org.springframework</groupId>

    <artifactId>spring-context-support</artifactId>

    <version>${spring.version}</version>

</dependency>

 

2．配置ApplicationContext.xml （Shiro整合ehcache）

 

 <!-- ehchace缓存管理器：ehcache缓存大对象 -->

<bean id="ehcacheManager"

	class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">

	<!-- 注入缓存配置文件的位置 -->

	<property name="configLocation" value="classpath:ehcache.xml" />

</bean>

<!-- shiro缓存管理器:整合ehcache -->

<bean id="shrioCacheManager" class="org.apache.shiro.cache.ehcache.EhCacheManager">

	<!-- 注入ehcache的缓存管理器 -->

	<property name="cacheManager" ref="ehcacheManager" />

</bean>

<!-- shiro安全管理器 -->

<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">

	<!-- 注入 Realm链接安全数据 -->

	<property name="realm" ref="bosRealm"></property>

	<!-- 注入shiro的缓存管理器 -->

	<property name="cacheManager" ref="shiroCacheManager" />

</bean>

<!--经过配置的方式配置realm对象，这里参考 -->

<!-- <bean id="bosRealm" class="cn.itcast.bos.auth.realm.BosRealm"> 注入缓存具体对象的名字,该名字在ehcache.xml中配置的 

	<property name="authenticationCacheName" value="BosShiroCache"/> </bean> -->

 

3.BosRealm中添加注解

 

@Component("bosRealm")

public class BosRealm extends AuthorizingRealm{

    //注入缓存名称

    @Value("BosShiroCache")//注入缓存具体对象的名字,该名字在ehcache.xml中配置的

    public void setSuperAuthenticationCacheName(String authenticationCacheName){

        super.setAuthenticationCacheName(authenticationCacheName);

    }

}

 

4.配置ehcache.xml

 

<!-- 自定义缓存区域 -->

<cache name=" BosShiroCache " maxElementsInMemory="10000" eternal="false"

	timeToIdleSeconds="120" timeToLiveSeconds="120" maxElementsOnDisk="10000000"

	diskExpiryThreadIntervalSeconds="120" memoryStoreEvictionPolicy="LRU">

	<persistence strategy="localTempSwap" />

</cache>

默认的策略：

<!-- 硬盘缓存的临时路径 -->

<diskStore path="java.io.tmpdir" />

<!-- 默认的缓存区域的缓存策略 maxElementsInMemory：内存中最大容纳的元素数量 eternal:对象是否永生，默认是false

	timeToIdleSeconds:发呆不用超过多长时间，over死掉 timeToLiveSeconds:活多久就死掉。 maxElementsOnDisk：硬盘上能存放多少元素 

	diskExpiryThreadIntervalSeconds:轮询的时间，检查的时间。 memoryStoreEvictionPolicy：若是缓存满了怎么办？LRU,LFU,FIFO

	persistence strategy：若是内存满了，溢出到硬盘 -->

<defaultCache maxElementsInMemory="10000" eternal="false"

	timeToIdleSeconds="120" timeToLiveSeconds="120" maxElementsOnDisk="10000000"

	diskExpiryThreadIntervalSeconds="120" memoryStoreEvictionPolicy="LRU">

	<persistence strategy="localTempSwap" />

</defaultCache>

 

 

动态菜单优化

减小无用数据查询（减小SQL的发出）

 

问题：每次菜单生成的语句太多。生成了不少与功能权限菜单无关的语句，如角色等

解决：在Function的实体类中，使用@JSON(serialize=fase)

 

对每一个用户菜单进行缓存

 

问题：每次刷新整个页面都会从新生成菜单，都会从新查询一次数据库。

解决方案：使用缓存。具体：使用spring 整合ehcache的缓存

 

1．使用maven坐标引入jar

略（上面已经引过了）

2．配置ApplicationContext.xml

 

xmlns:cache="http://www.springframework.org/schema/cache"

http://www.springframework.org/schema/cache

http://www.springframework.org/schema/cache/spring-cache.xsd

 

<!-- 配置Spring的缓存管理器 -->

<bean id="springCacheManagerSpring" class="org.springframework.cache.ehcache.EhCacheCacheManager">

	<!-- 注入ehcache的管理器 - -->

	<property name="cacheManager" ref="ehCacheManager" />

</bean>

<!-- 配置缓存的注解驱动，它会自动到spring的bean中寻找缓存相关注解，并使其有效 -->

<cache:annotation-driven cache-manager="springCacheManagerSpring" />

 

3．编写ehcache.xml，添加一个新的缓存区域，如MenuSpringCache

 

4．在方法上添加注解

提示：spring的缓存管理器默认的key是方法名+参数,若是参数是个对象，那么会发生每次缓存的key都不同，虽然数据的同样的。所以这种状况下，须要手动指定key

 

/**

 * 获取用户权限

 */

@Override

//value:缓存区域，缓存的东西往哪放

//缓存的的key的生成策略

//1.没有参数,key='0'

//2.有1个参数,那么key是对象自己,通常是对象地址

//3.有多个参数,那么key是多个对象的hash值

@Cacheable(value="SpringCache",key="#user.id")

public List<Function> findFunctionByUser(User user) {

 

如添加权限，要清除缓存

 

/**

 * 添加功能

 */

@Override

//清除ehcache的某区域的全部对象

@CacheEvict(value="SpringCache",allEntries=true)

public void save(Function function) {

 

 

Hibernate中使用ehcache

 

1.导入 jar 包：ehcache-1.5.0.jar/ commons-logging.jar/ backport-util-concurrent.jar

2.开启二级缓存(我要使用二级缓存)

3.肯定二级缓存提供商(我要使用哪一个二级缓存)

4.肯定须要缓存内容

1>配置须要缓存的类

2>配置须要缓存的集合

5.配置 ehcache 自定义配置文件

 

<dependency>

	<groupId>org.hibernate</groupId>

	<artifactId>hibernate-ehcache</artifactId>

	<version>5.0.7.Final</version>

</dependency>

 

在 hibernate.cfg.xml 配置缓存，或者交由spring管理，在sessionFactory中配置

 

开启二级缓存

 

<!-- 开启二级缓存 -->

<property name="hibernate.cache.use_second_level_cache">true</property>

 

肯定缓存提供商

 

<property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>

 

肯定缓存内容

 

<!-- 类缓存 -->

<!-- 指定二级缓存类 ,以及并发访问策略 -->

<class-cache usage="read-write" class="cn.aric.domain.User"/>

<!-- 集合缓存 -->

<collection-cache usage="read-write" collection="cn.aric.doain.Customer.orderSet"/>

 

ehcache 配置文件

 

文件名：ehcache.xml

参考官方文件配置

 

<ehcache>

	<diskStore path="f:cache" />

	<defaultCache maxElementsInMemory="10000"

		eternal="false"

		timeToIdleSeconds="120"

		timeToLiveSeconds="120"

		overflowToDisk="true" />

	<cache name="hibernateCache"

		maxElementsInMemory="10000"

		eternal="false"

		timeToIdleSeconds="300"

		timeToLiveSeconds="600"

		overflowToDisk="true" />

</ehcache>

 

测试

 

//测试二级缓存是否配置成功

@Test

public void test(){

    Configuration configuration = new Configuration().configure();

    SessionFactory sessionFactory = configuration.buildSessionFactory();

    //获取session1

    Session session1 = sessionFactory.openSession();

    Transaction tx = session1.beginTransaction();

    User user1 = session1.get(User.class, 10L);

    System.out.println(user1.getUser_code());

    tx.commit();

    session1.close();

    //获取session2

    Session session2 = sessionFactory.openSession();

    Transaction tx2 = session2.beginTransaction();

    User user2 = session2.get(User.class, 10L);

    System.out.println(user2.getUser_code());

    tx2.commit();

    session2.close();

}

 

查询缓存

 

查询缓存默认不使用。须要手动开启

查询缓存：将 HQL 语句与 查询结果进行绑定。经过 HQL 相同语句能够缓存内容。

默认状况 Query 对象只将查询结果存放在一级和二级缓存，不从一级或二级缓存获取。

查询缓存就是让 Query 能够从二级缓存得到内容。

 

<!-- 开启查询缓存 -->

<property name="hibernate.cache.use_query_cache">true</property>

@Test

public void demo(){

    // 查询缓存

    Session s1 = factory.openSession();

    s1.beginTransaction();

    //1 query查询

    Query q1 = s1.createQuery("from Customer");

    //设置查询缓存为true

    q1.setCacheable(true);

    List<Customer> a1 = q1.list();

    for (Customer c1 : a1) {

        System.out.println(c1);

    }

    //2 cid =1 -- 一级缓存得到

    Customer customer = (Customer) s1.get(Customer.class, 1);

    System.out.println(customer);

    s1.getTransaction().commit();

    s1.close();

    System.out.println("----------");

    Session s2 = factory.openSession();

    s2.beginTransaction();

    //2 cid =1 -- 二级缓存得到

    Customer customer2 = (Customer) s2.get(Customer.class, 1);

    System.out.println(customer2);

    //3 query查询

    Query q2 = s2.createQuery("from Customer");

    q2.setCacheable(true);

    List<Customer> a2 = q2.list();

    for (Customer c2 : a2) {

        System.out.println(c2);

    }

    s2.getTransaction().commit();

    s2.close();

}