转载  

定义数据访问接口：

[java] 

1. package org.kevin.cache.dao;  
2.   
3. import java.util.Collection;  
4.   
5. import org.kevin.cache.domain.Data;  
6.   
7. public interface DataDAO {  
8.   
9.     public void add(Data data);  
10.   
11.     public void update(Data data);  
12.   
13.     public Data find(Integer id);  
14.   
15.     public void delete(Integer id);  
16.       
17.     public Collection<Data> getAll();  
18. }  

对接口方法进行实现，使用Map模拟数据库的表进行存储数据：

[java] 

1. package org.kevin.cache.dao;  
2.   
3. import java.util.Collection;  
4. import java.util.HashMap;  
5. import java.util.Map;  
6.   
7. import org.kevin.cache.domain.Data;  
8. import org.springframework.cache.annotation.CacheEvict;  
9. import org.springframework.cache.annotation.Cacheable;  
10.   
11. public class DataDAOImpl implements DataDAO {  
12.   
13.     private Map<Integer, Data> dataMap = new HashMap<>();  
14.   
15.     @Override  
16.     @CacheEvict(value = "data", allEntries = true)  
17.     public void add(Data data) {  
18.         System.out.println("Execute：public void add(Data data)");  
19.         dataMap.put(data.getId(), data);  
20.     }  
21.   
22.     @Override  
23.     @CacheEvict(value = "data", allEntries = true)  
24.     public void update(Data data) {  
25.         System.out.println("Execute：public void update(Data data) ");  
26.         dataMap.put(data.getId(), data);  
27.     }  
28.   
29.     @Override  
30.     @Cacheable(value = "data")  
31.     public Data find(Integer id) {  
32.         System.out.println("Execute：public Data find(Integer id)");  
33.         return dataMap.get(id);  
34.     }  
35.   
36.     @Override  
37.     @CacheEvict(value = "data", allEntries = true)  
38.     public void delete(Integer id) {  
39.         System.out.println("Execute：public void delete(Integer id)");  
40.         dataMap.remove(id);  
41.     }  
42.   
43.     @Override  
44.     @Cacheable(value = "data")  
45.     public Collection<Data> getAll() {  
46.         System.out.println("Execute：public Collection<Data> getAll()");  
47.         return dataMap.values();  
48.     }  
49. }  

如上，对数据进行增删改的时候清空缓存，查询时使用缓存。其中value为缓存区，allEntries表示清空缓存区中的所有数据。为了稍后验证缓存是否生效，打印出执行的方法签名。

定义领域模型：

[java] 

1. package org.kevin.cache.domain;  
2.   
3. public class Data {  
4.   
5.     private Integer id;  
6.     private String first;  
7.     private String second;  
8.   
9.     public Data(Integer id, String first, String second) {  
10.         this.id = id;  
11.         this.first = first;  
12.         this.second = second;  
13.     }  
14.   
15.     public String getFirst() {  
16.         return first;  
17.     }  
18.   
19.     public void setFirst(String first) {  
20.         this.first = first;  
21.     }  
22.   
23.     public String getSecond() {  
24.         return second;  
25.     }  
26.   
27.     public void setSecond(String second) {  
28.         this.second = second;  
29.     }  
30.   
31.     public void setId(Integer id) {  
32.         this.id = id;  
33.     }  
34.   
35.     public Integer getId() {  
36.         return id;  
37.     }  
38. }  

接下来编写spring配置文件：

[html] 

1. <beans xmlns="http://www.springframework.org/schema/beans"   
2.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"   
3.      xmlns:cache="http://www.springframework.org/schema/cache"   
4.     xsi:schemaLocation="   
5.             http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd   
6.             http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache-3.1.xsd">   
7.   
8.     <cache:annotation-driven />  
9.       
10.     <bean id="cacheManager" class="org.springframework.cache.support.SimpleCacheManager">  
11.         <property name="caches">  
12.             <set>  
13.                 <bean class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean" p:name="default" />  
14.                 <bean class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean" p:name="data" />  
15.             </set>  
16.         </property>  
17.     </bean>  
18.   
19.     <bean id="dataDao" class="org.kevin.cache.dao.DataDAOImpl" />  
20. </beans>  

最后编写main方法验证缓存是否生效：

[java] 

1. package org.kevin.cache;  
2.   
3. import java.util.Collection;  
4.   
5. import org.kevin.cache.dao.DataDAO;  
6. import org.kevin.cache.domain.Data;  
7. import org.springframework.context.support.ClassPathXmlApplicationContext;  
8.   
9. public class CacheMain {  
10.   
11.     public static void main(String[] args) {  
12.           
13.         ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring-cache-demo.xml");  
14.         DataDAO dataDAO = context.getBean("dataDao", DataDAO.class);  
15.           
16.         dataDAO.add(new Data(1, "li", "wenkai"));  
17.         Collection<Data> dataCollection = dataDAO.getAll();  
18.         System.out.println(dataCollection.size());  
19.           
20.         System.out.println("=================================");  
21.           
22.         dataDAO.add(new Data(2, "jack", "lee"));  
23.         dataCollection = dataDAO.getAll();  
24.         System.out.println(dataCollection.size());;  
25.         Data data = dataDAO.find(1);  
26.         System.out.println(data.getFirst());  
27.         data = dataDAO.find(2);  
28.         System.out.println(data.getFirst());  
29.         data = dataDAO.find(2);  
30.         System.out.println(data.getFirst());;  
31.           
32.         System.out.println("====================================");  
33.         dataDAO.add(new Data(3, "kevin", "lee"));  
34.         data = dataDAO.find(2);  
35.         System.out.println(data.getFirst());  
36.         data = dataDAO.find(3);  
37.         System.out.println(data.getFirst());  
38.         data = dataDAO.find(2);  
39.         System.out.println(data.getFirst());  
40.     }  
41. }  

打印接过如下，表示已经生效：

[plain] 

1. Execute：public void add(Data data)  
2. Execute：public Collection<Data> getAll()  
3. 1  
4. =================================  
5. Execute：public void add(Data data)  
6. Execute：public Collection<Data> getAll()  
7. 2  
8. Execute：public Data find(Integer id)  
9. li  
10. Execute：public Data find(Integer id)  
11. jack  
12. jack  
13. ====================================  
14. Execute：public void add(Data data)  
15. Execute：public Data find(Integer id)  
16. jack  
17. Execute：public Data find(Integer id)  
18. kevin  
19. jack  

 

最后，spring支持的缓存机制，是方法级的缓存，而不关注底层是否使用了数据库以及通过什么方式访问的数据库；因此这种缓存不止可以放到DAO层，也可以放置到Service层，甚至可以对各种代码数据进行缓存。

如果应用中同时使用了Hibernate和Ibatis，或者这种方式是一种好的缓存解决方案。