Spring3.1整合EhCache注解实例

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