Spring 3.1 整合 EhCache 博客分类： Spring ehcachespring

Spring 3.1提供了对cache的支持，但到目前为止，支持的第三方cache只有Ehcache一种。在以前版本的spring中，也可以通过添加其它包实现对ehcache的注解化支持，但Spring 3.1提供了对cache的原生支持。

首先建好项目提供必要的包：



包的用处不多说，然后写好一个ehcache.xml放到classpath下：

ehcache.xml

<?xml version="1.0" encoding="UTF-8"?>

<ehcache>

    <!--timeToIdleSeconds 当缓存闲置n秒后销毁 -->

    <!--timeToLiveSeconds 当缓存存活n秒后销毁 -->

    <!-- 缓存配置

    name:缓存名称。

    maxElementsInMemory：缓存最大个数。

    eternal:对象是否永久有效，一但设置了，timeout将不起作用。

    timeToIdleSeconds：设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。

    timeToLiveSeconds：设置对象在失效前允许存活时间（单位：秒）。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用，默认是0.，也就是对象存活时间无穷大。

    overflowToDisk：当内存中对象数量达到maxElementsInMemory时，Ehcache将会对象写到磁盘中。

    diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。

    maxElementsOnDisk：硬盘最大缓存个数。

    diskPersistent：是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.

    diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。

    memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）。

    clearOnFlush：内存数量最大时是否清除。

    -->

    <diskStore path="D:/tmpdir"/>

    <defaultCache

     maxElementsInMemory="500"

     eternal="false"

     timeToIdleSeconds="300"

     timeToLiveSeconds="1200"

     overflowToDisk="true"/>

    <cache name="young" maxElementsInMemory="150" eternal="false" timeToLiveSeconds="36000" timeToIdleSeconds="3600" overflowToDisk="true"/>

</ehcache>

配置文件中进行了基本的配置，建立了一个叫“young”的cache。

然后在非整合spring的时候，测试一下cache是否使用成功：

NormalTest.java

public class NormalTest {

 

public static void main(String[] args) {

CacheManager manager = CacheManager.create();// 默认配置文件创建

String[] names = manager.getCacheNames();

for (int i = 0; i < names.length; i++) {

System.out.println(names[i]);

}

//Cache cache = manager.getCache(names[0]);


Cache cache = new Cache("test", 150, true, false, 5, 2);

manager.addCache(cache);


cache.put(new Element("key1","value1"));


Element element = cache.get("key1");

System.out.println(element.getValue());


String[] names1 = manager.getCacheNames();

for (int i = 0; i < names1.length; i++) {

System.out.println(names1[i]);

}

}

}

运行一下，有输出存进去的值就OK啦。

下面开始整合Spring，建立Spring配置文件：

applicationContext.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:tx="http://www.springframework.org/schema/tx"

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

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

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

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

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

xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

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

http://www.springframework.org/schema/tx/spring-tx-3.0.xsd

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

http://www.springframework.org/schema/context/spring-context-3.0.xsd

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

http://www.springframework.org/schema/util/spring-util-3.0.xsd

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

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


<!-- 隐式地向 Spring 容器注册 

AutowiredAnnotationBeanPostProcessor、

CommonAnnotationBeanPostProcessor、

PersistenceAnnotationBeanPostProcessor 以及

equiredAnnotationBeanPostProcessor 这 4 个 BeanPostProcessor。

在配置文件中使用 context 命名空间之前，

必须在 <beans> 元素中声明 context 命名空间。 -->

        <context:annotation-config/>

<!-- <context:component-scan/> 配置项不但启用了对类包进行扫描

以实施注释驱动 Bean 定义的功能，

同时还启用了注释驱动自动注入的功能

（即还隐式地在内部注册了 AutowiredAnnotationBeanPostProcessor 

和 CommonAnnotationBeanPostProcessor） -->

<context:component-scan base-package="young" />

<!-- 缓存注解驱动 -->

<cache:annotation-driven />

<!-- 

<cache:annotation-driven cache-manager="cacheManager" proxy-target-class="false" mode="proxy"/>-->


<!-- cacheManager工厂类 -->

<bean id="cacheManagerFactory" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean"

     p:configLocation="classpath:ehcache.xml"

     p:shared="false" />


<!-- 声明cacheManager -->

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

   p:cacheManager-ref="cacheManagerFactory"/>


</beans>

建立一个有缓存使用的类：
CacheMethod.java

package young;

 

import org.springframework.cache.annotation.Cacheable;

import org.springframework.stereotype.Component;

 

@Component

public class CacheMethod {

 

@Cacheable("young")

public String getYoung(String str) {

System.out.println("method is running...");

return "1230-1230-1230-0123-0123";

}

}

类中只有一个方法，返回固定值，并且会被缓存。
最后用Junit4对这个类进行测试：
SpringCacheTest.java

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration(locations = { "classpath:applicationContext.xml" })

public class SpringCacheTest {

@Resource

CacheManager manager;

 

@Resource

CacheMethod method;

 

@Test

public void testGetYoung() {

// CacheMethod method = new CacheMethod();这样得到的实例不在Spring的管理之中，也无法Cache

String s = method.getYoung("str");

System.out.println(s);

String s1 = method.getYoung("str");

System.out.println(s1);

String[] names = manager.getCacheNames();

for (int i = 0; i < names.length; i++) {// 输出所有缓存

System.out.println(names[i]);

}

Cache young = manager.getCache("young");// 得到cache

System.out.println("Cache named 'young':" + young);

assertEquals("str", young.getKeys().get(0));

assertEquals(s, young.get("str").getValue());

}

}

到此应该就测试成功啦！~


最后说下我遇到的错误，最一开始在测试中这样写的：

CacheMethod method = new CacheMethod();

然后进行调用 ，发现返回值并没有进行缓存，再次调用时仍然会打印出getYoung（）中的日志。这是由于这种调用并不是在Spring的管理下进行的，所以Spring也就不能对其进行cache了。