Spring整合EhCache的Demo

1. 配置pom.xml

需要在原先的Maven工程的基础上增加ehcache的依赖

		<dependency>
			<groupId>net.sf.ehcache</groupId>
			<artifactId>ehcache</artifactId>
			<version>2.8.2</version>
		</dependency>

---

2. 配置application.xml

这里的主要任务是: 装载缓存管理器, 这个缓存管理器的配置还需要依赖于下面步骤中的xml.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:cache="http://www.springframework.org/schema/cache"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xmlns:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
			http://www.springframework.org/schema/beans/spring-beans.xsd
  			http://www.springframework.org/schema/mvc
			http://www.springframework.org/schema/mvc/spring-mvc.xsd
       		http://www.springframework.org/schema/context
       		http://www.springframework.org/schema/context/spring-context.xsd
       		http://www.springframework.org/schema/cache
       		http://www.springframework.org/schema/cache/spring-cache-3.1.xsd"
	default-lazy-init="true">
		
	<context:component-scan base-package="ehcache" />
    <cache:annotation-driven cache-manager="cacheManager" />  

	<!-- 装载ehcache缓存管理器 -->
    <bean id="cacheManager" class="org.springframework.cache.ehcache.EhCacheCacheManager">  
        <property name="cacheManager" ref="ehcache"></property>  
    </bean>  

	<!-- 装载ehcache配置文件 -->
    <bean id="ehcache" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">  
        <property name="configLocation" value="classpath:ehcache-setting.xml"></property>  
    </bean>


</beans>

---

3. 配置ehcache-servlet.xml

这个配置文件主要配置有哪些缓存, 可以将这个文件视为一个所有缓存的容器. 在容器中我们有各种各样的缓存器, 并且每个缓存器都有不同的配置信息.

<?xml version="1.0" encoding="UTF-8"?>
<ehcache>
    <!-- 指定一个文件目录，当EhCache把数据写到硬盘上时，将把数据写到这个文件目录下 -->
    <diskStore path="java.io.tmpdir"/>

    <!-- 设定缓存的默认数据过期策略 -->
    <defaultCache
            maxElementsInMemory="10000" 
            eternal="false" 
            overflowToDisk="true"
            timeToIdleSeconds="10"
            timeToLiveSeconds="20"
            diskPersistent="false"
            diskExpiryThreadIntervalSeconds="120"/>

    <cache name="cacheTest"
        maxElementsInMemory="1000"
        eternal="false"
        overflowToDisk="true"
        timeToIdleSeconds="10"
        timeToLiveSeconds="20"/>

<!-- cache元素的属性： -->

<!-- name：缓存名称 -->

<!-- maxElementsInMemory：内存中最大缓存对象数 -->

<!-- maxElementsOnDisk：硬盘中最大缓存对象数，若是0表示无穷大 -->

<!-- eternal：true表示对象永不过期，此时会忽略timeToIdleSeconds和timeToLiveSeconds属性，默认为false -->

<!-- overflowToDisk：true表示当内存缓存的对象数目达到了 -->

<!-- maxElementsInMemory界限后，会把溢出的对象写到硬盘缓存中。注意：如果缓存的对象要写入到硬盘中的话，则该对象必须实现了Serializable接口才行。 -->

<!-- diskSpoolBufferSizeMB：磁盘缓存区大小，默认为30MB。每个Cache都应该有自己的一个缓存区。 -->

<!-- diskPersistent：是否缓存虚拟机重启期数据，是否持久化磁盘缓存,当这个属性的值为true时,系统在初始化时会在磁盘中查找文件名 为cache名称,后缀名为index的文件，这个文件中存放了已经持久化在磁盘中的cache的index,找到后会把cache加载到内存，要想把 cache真正持久化到磁盘,写程序时注意执行net.sf.ehcache.Cache.put(Element element)后要调用flush()方法。 -->

<!-- diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认为120秒 -->

<!-- timeToIdleSeconds： 设定允许对象处于空闲状态的最长时间，以秒为单位。当对象自从最近一次被访问后，如果处于空闲状态的时间超过了timeToIdleSeconds属性 值，这个对象就会过期，EHCache将把它从缓存中清空。只有当eternal属性为false，该属性才有效。如果该属性值为0，则表示对象可以无限 期地处于空闲状态 -->

<!-- timeToLiveSeconds：设定对象允许存在于缓存中的最长时间，以秒为单位。当对象自从被存放到缓存中后，如果处于缓存中的时间超过了 timeToLiveSeconds属性值，这个对象就会过期，EHCache将把它从缓存中清除。只有当eternal属性为false，该属性才有 效。如果该属性值为0，则表示对象可以无限期地存在于缓存中。timeToLiveSeconds必须大于timeToIdleSeconds属性，才有 意义 -->

<!-- memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。可选策略有：LRU（最近最少使用，默认策略）、FIFO（先进先出）、LFU（最少访问次数）。 -->
</ehcache>

4. 为方法添加缓存

通过使用@Cacheable注解, 我们可以指定使用的缓存配置, 结果存入缓存的条件, 以及缓存的键(从缓存中存储的信息, 是键值对的形式)

package ehcache.demo;

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;


@Service
public class EhCacheImpl implements EhCacheI {
	// 这里注解中value=”cacheTest”与ehcache-setting.xml中的cache名称属性值一致。
	@Cacheable(value = "cacheTest", key = "#param")
	public String getTimestamp(String param) {
		Long timestamp = System.currentTimeMillis();
		System.out.println("方法被执行");
		return timestamp.toString();
	}

}

抽出来一个接口

package ehcache.demo;

public interface EhCacheI {
    public String getTimestamp(String param);
}

测试

这里我们使用junit进行测试, 需要进行如下的配置:

1. 继承AbstractJUnit4SpringContextTests 抽象类. 通过@ContextConfiguration注解指定需要加载的配置文件

package ehcache.demo;


import org.junit.runner.RunWith;  
import org.springframework.test.context.ContextConfiguration;  
import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;  
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;  

//指定bean注入的配置文件  
@ContextConfiguration(locations = { "classpath:applicationContext.xml" })  
//使用标准的JUnit @RunWith注释来告诉JUnit使用Spring TestRunner  
@RunWith(SpringJUnit4ClassRunner.class)  
public class SpringTestCase extends AbstractJUnit4SpringContextTests {

}

实际进行测试的代码, 需要使用@Test注解才能执行

package ehcache.demo;


import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.Cache;
import org.springframework.cache.ehcache.EhCacheCacheManager;

public class EhCacheTestServiceTest extends SpringTestCase {

    @Autowired  
    private EhCacheI ehcacheI;

    @Autowired
    private EhCacheCacheManager cacheManager;
    
    @Test  
    public void getTimestampTest() throws InterruptedException{  
        System.out.println("第一次调用：" + ehcacheI.getTimestamp("param"));
        Thread.sleep(2000);
        // 查看缓存管理器中的信息 【NikolaZhang 2018年10月5日 下午8:32:26】
        Cache cache = cacheManager.getCache("cacheTest");
        System.out.println("有效期内 从缓存管理器中获取时间:" + cache.get("param").get());
        
        System.out.println("2秒之后调用：" + ehcacheI.getTimestamp("param"));
        Thread.sleep(11000);
        System.out.println("空闲超时后" + cache.get("param"));
        System.out.println("再过11秒之后调用：" + ehcacheI.getTimestamp("param"));
        System.out.println("从缓存管理器中获取时间:" + cache.get("param").get());
        Thread.sleep(30000);
        System.out.println("30s后 从缓存管理器中获取时间:" + cache.get("param"));
    } 
}

结果

可以看到当首次执行和缓存失效(此处表现为空闲超时)之后方法才会被完全执行. 当我们在缓存有效期间调用该方法时, 实际上是从缓存中取出的数据.

---

参考

Spring缓存注解@Cacheable、@CacheEvict、@CachePut使用 :
https://www.cnblogs.com/fashflying/p/6908028.html(推荐)
Spring整合Ehcache管理缓存
https://www.cnblogs.com/manxiaolong/p/7125395.html