Spring3.1整合EhCache注解实例(转)

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

首先建好项目提供必要的包：包的用处不多说，然后写好一个ehcache.xml放到classpath下：

ehcache.xml

code

<?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

code

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

code

<?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

code

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

code

@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了。