Spring 3.1提供了对cache的支持，但到目前为止，支持的第三方cache只有Ehcache一种。在以前版本的spring中，也可以通过添加其它包实现对ehcache的注解化支持，但Spring 3.1提供了对cache的原生支持。
首先建好项目提供必要的包：包的用处不多说，然后写好一个ehcache.xml放到classpath下：
ehcache.xml
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
|
<?
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
>
|
然后在非整合spring的时候，测试一下cache是否使用成功：
NormalTest.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
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]);
}
}
}
|
下面开始整合Spring，建立Spring配置文件：
applicationContext.xml
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
|
<?
xml
version
=
"1.0"
encoding
=
"UTF-8"
?>
xsi:schemaLocation="http://www.springframework.org/schema/beans
<!-- 隐式地向 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
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
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
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
|
@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了。