Redis 缓存 + Spring 的集成示例

深藏阁楼爱情的钟 2022-08-09 03:20 168阅读 0赞

《 [整合 spring 4(包括mvc、context、orm) + mybatis 3 示例][spring 4_mvc_context_orm_ _ mybatis 3] 》一文简要介绍了最新版本的 Spring MVC、IOC、MyBatis ORM 三者的整合以及声明式事务处理。现在我们需要把缓存也整合进来，缓存我们选用的是 Redis，本文将在该文示例基础上介绍 Redis 缓存 + Spring 的集成。关于 Redis 服务器的搭建请参考博客《 [Redhat5.8 环境下编译安装 Redis 并将其注册为系统服务][Redhat5.8 _ Redis] 》。

# 1. 依赖包安装 #

pom.xml 加入：

**\[html\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  
2.  **<****dependency****>**
3.  **<****groupId****>**org.springframework.data**</****groupId****>**
4.  **<****artifactId****>**spring-data-redis**</****artifactId****>**
5.  **<****version****>**1.6.0.RELEASE**</****version****>**
6.  **</****dependency****>**
7.  **<****dependency****>**
8.  **<****groupId****>**redis.clients**</****groupId****>**
9.  **<****artifactId****>**jedis**</****artifactId****>**
10. **<****version****>**2.7.3**</****version****>**
11. **</****dependency****>**
12.

# 2. Spring 项目集成进缓存支持 #

要启用缓存支持，我们需要创建一个新的  [CacheManager][]  bean。 [CacheManager 接口][CacheManager] 有很多实现，本文演示的是和 Redis 的集成，自然就是用 RedisCacheManager 了。Redis 不是应用的共享内存，它只是一个内存服务器，就像 MySql 似的，我们需要将应用连接到它并使用某种“语言”进行交互，因此我们还需要一个连接工厂以及一个 Spring 和 Redis 对话要用的 RedisTemplate，这些都是 Redis 缓存所必需的配置，把它们都放在自定义的 CachingConfigurerSupport 中：

**\[java\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  /\*\*
2.   \* File Name：RedisCacheConfig.java
3.   \*
4.   \* Copyright Defonds Corporation 2015 
5.   \* All Rights Reserved
6.   \*
7.   \*/
8.  **package** com.defonds.bdp.cache.redis; 
9.  
10. **import** org.springframework.cache.CacheManager; 
11. **import** org.springframework.cache.annotation.CachingConfigurerSupport; 
12. **import** org.springframework.cache.annotation.EnableCaching; 
13. **import** org.springframework.context.annotation.Bean; 
14. **import** org.springframework.context.annotation.Configuration; 
15. **import** org.springframework.data.redis.cache.RedisCacheManager; 
16. **import** org.springframework.data.redis.connection.RedisConnectionFactory; 
17. **import** org.springframework.data.redis.connection.jedis.JedisConnectionFactory; 
18. **import** org.springframework.data.redis.core.RedisTemplate; 
19. 
20. /\*\*
21.  \* 
22.  \* Project Name：bdp 
23.  \* Type Name：RedisCacheConfig 
24.  \* Type Description：
25.  \* Author：Defonds
26.  \* Create Date：2015-09-21
27.  \* 
28.  \* @version
29.  \* 
30.  \*/
31. @Configuration
32. @EnableCaching
33. **public****class** RedisCacheConfig **extends** CachingConfigurerSupport \{ 
34. 
35. @Bean
36. **public** JedisConnectionFactory redisConnectionFactory() \{ 
37.  JedisConnectionFactory redisConnectionFactory = **new** JedisConnectionFactory(); 
38. 
39. // Defaults
40.  redisConnectionFactory.setHostName("192.168.1.166"); 
41.  redisConnectionFactory.setPort(6379); 
42. **return** redisConnectionFactory; 
43.  \} 
44. 
45. @Bean
46. **public** RedisTemplate<String, String> redisTemplate(RedisConnectionFactory cf) \{ 
47.  RedisTemplate<String, String> redisTemplate = **new** RedisTemplate<String, String>(); 
48.  redisTemplate.setConnectionFactory(cf); 
49. **return** redisTemplate; 
50.  \} 
51. 
52. @Bean
53. **public** CacheManager cacheManager(RedisTemplate redisTemplate) \{ 
54.  RedisCacheManager cacheManager = **new** RedisCacheManager(redisTemplate); 
55. 
56. // Number of seconds before expiration. Defaults to unlimited (0)
57.  cacheManager.setDefaultExpiration(3000); // Sets the default expire time (in seconds)
58. **return** cacheManager; 
59.  \} 
60. 
61. \}

当然也别忘了把这些 bean 注入 Spring，不然配置无效。在 applicationContext.xml 中加入以下：

**\[html\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  **<****context:component-scan**base-package="com.defonds.bdp.cache.redis"**/>**

# 3. 缓存某些方法的执行结果 #

设置好缓存配置之后我们就可以使用 @Cacheable 注解来缓存方法执行的结果了，比如根据省份名检索城市的 provinceCities 方法和根据 city\_code 检索城市的 searchCity 方法：

**\[java\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  // R
2.  @Cacheable("provinceCities") 
3.  **public** List<City> provinceCities(String province) \{ 
4.   logger.debug("province=" \+ province); 
5.  **return****this**.cityMapper.provinceCities(province); 
6.  \} 
7.  
8.  // R
9.  @Cacheable("searchCity") 
10. **public** City searchCity(String city\_code)\{ 
11.  logger.debug("city\_code=" \+ city\_code); 
12. **return****this**.cityMapper.searchCity(city\_code); 
13. \}

# 4. 缓存数据一致性保证 #

CRUD (Create 创建，Retrieve 读取，Update 更新，Delete 删除) 操作中，除了 R 具备幂等性，其他三个发生的时候都可能会造成缓存结果和数据库不一致。为了保证缓存数据的一致性，在进行 CUD 操作的时候我们需要对可能影响到的缓存进行更新或者清除。

**\[java\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  // C
2.  @CacheEvict(value = \{ "provinceCities"\}, allEntries = **true**) 
3.  **public****void** insertCity(String city\_code, String city\_jb, 
4.   String province\_code, String city\_name, 
5.   String city, String province) \{ 
6.   City cityBean = **new** City(); 
7.   cityBean.setCityCode(city\_code); 
8.   cityBean.setCityJb(city\_jb); 
9.   cityBean.setProvinceCode(province\_code); 
10.  cityBean.setCityName(city\_name); 
11.  cityBean.setCity(city); 
12.  cityBean.setProvince(province); 
13. **this**.cityMapper.insertCity(cityBean); 
14. \} 
15. // U
16. @CacheEvict(value = \{ "provinceCities", "searchCity" \}, allEntries = **true**) 
17. **public****int** renameCity(String city\_code, String city\_name) \{ 
18.  City city = **new** City(); 
19.  city.setCityCode(city\_code); 
20.  city.setCityName(city\_name); 
21. **this**.cityMapper.renameCity(city); 
22. **return**1; 
23. \} 
24. 
25. // D
26. @CacheEvict(value = \{ "provinceCities", "searchCity" \}, allEntries = **true**) 
27. **public****int** deleteCity(String city\_code) \{ 
28. **this**.cityMapper.deleteCity(city\_code); 
29. **return**1; 
30. \}

业务考虑，本示例用的都是 @CacheEvict 清除缓存。如果你的 CUD 能够返回 City 实例，也可以使用 @CachePut 更新缓存策略。笔者推荐能用 @CachePut 的地方就不要用 @CacheEvict，因为后者将所有相关方法的缓存都清理掉，比如上面三个方法中的任意一个被调用了的话，provinceCities 方法的所有缓存将被清除。

# 5. 自定义缓存数据 key 生成策略 #

对于使用 @Cacheable 注解的方法，每个缓存的 key 生成策略默认使用的是参数名+参数值，比如以下方法：

**\[java\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  @Cacheable("users") 
2.  **public** User findByUsername(String username)

这个方法的缓存将保存于 key 为 users~keys 的缓存下，对于 username 取值为 "赵德芳" 的缓存，key 为 "username-赵德芳"。一般情况下没啥问题，二般情况如方法 key 取值相等然后参数名也一样的时候就出问题了，如：

**\[java\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  @Cacheable("users") 
2.  **public** Integer getLoginCountByUsername(String username)

这个方法的缓存也将保存于 key 为 users~keys 的缓存下。对于 username 取值为 "赵德芳" 的缓存，key 也为 "username-赵德芳"，将另外一个方法的缓存覆盖掉。  
解决办法是使用自定义缓存策略，对于同一业务(同一业务逻辑处理的方法，哪怕是集群/分布式系统)，生成的 key 始终一致，对于不同业务则不一致：

**\[java\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  @Bean
2.  **public** KeyGenerator customKeyGenerator() \{ 
3.  **return****new** KeyGenerator() \{ 
4.  @Override
5.  **public** Object generate(Object o, Method method, Object... objects) \{ 
6.   StringBuilder sb = **new** StringBuilder(); 
7.   sb.append(o.getClass().getName()); 
8.   sb.append(method.getName()); 
9.  **for** (Object obj : objects) \{ 
10.  sb.append(obj.toString()); 
11.  \} 
12. **return** sb.toString(); 
13.  \} 
14.  \}; 
15. \}

于是上述两个方法，对于 username 取值为 "赵德芳" 的缓存，虽然都还是存放在 key 为 users~keys 的缓存下，但由于 key 分别为 "类名-findByUsername-username-赵德芳" 和 "类名-getLoginCountByUsername-username-赵德芳"，所以也不会有问题。  
这对于集群系统、分布式系统之间共享缓存很重要，真正实现了分布式缓存。  
笔者建议：缓存方法的 @Cacheable 最好使用方法名，避免不同的方法的 @Cacheable 值一致，然后再配以以上缓存策略。

# 6. 缓存的验证 #

## 6.1 缓存的验证 ##

为了确定每个缓存方法到底有没有走缓存，我们打开了 MyBatis 的 SQL 日志输出，并且为了演示清楚，我们还清空了测试用 Redis 数据库。  
先来验证 provinceCities 方法缓存，Eclipse 启动 tomcat 加载项目完毕，使用 JMeter 调用 /bdp/city/province/cities.json 接口：  
![使用 JMeter 调用 /bdp/city/province/cities.json 接口.png][JMeter _ _bdp_city_province_cities.json _.png]  
Eclipse 控制台输出如下：  
![Eclipse 控制台输出如下.png][Eclipse _.png]  
说明这一次请求没有命中缓存，走的是 db 查询。JMeter 再次请求，Eclipse 控制台输出：  
![Eclipse 控制台输出][Eclipse]  
标红部分以下是这一次请求的 log，没有访问 db 的 log，缓存命中。查看本次请求的 Redis 存储情况：  
![查看本次请求的 Redis 存储情况.png][Redis _.png]  
同样可以验证 city\_code 为 1492 的 searchCity 方法的缓存是否有效：  
![同样可以验证 city\_code 为 1492 的 searchCity 方法的缓存是否有效.png][city_code _ 1492 _ searchCity _.png]  
图中标红部分是 searchCity 的缓存存储情况。

## 6.2 缓存一致性的验证 ##

先来验证 insertCity 方法的缓存配置，JMeter 调用 /bdp/city/create.json 接口：  
![JMeter 调用 /bdp/city/create.json 接口.png][JMeter _ _bdp_city_create.json _.png]  
之后看 Redis 存储：  
![之后看 Redis 存储][Redis]  
可以看出 provinceCities 方法的缓存已被清理掉，insertCity 方法的缓存奏效。  
然后验证 renameCity 方法的缓存配置，JMeter 调用 /bdp/city/rename.json 接口：  
![JMeter 调用 /bdp/city/rename.json 接口.png][JMeter _ _bdp_city_rename.json _.png]  
之后再看 Redis 存储：  
![之后再看 Redis 存储.png][Redis _.png 1]  
searchCity 方法的缓存也已被清理，renameCity 方法的缓存也奏效。

# 7. 注意事项 #

1.  要缓存的 Java 对象必须实现 Serializable 接口，因为 Spring 会将对象先序列化再存入 Redis，比如本文中的 com.defonds.bdp.city.bean.City 类，如果不实现 Serializable 的话将会遇到类似这种错误：nested exception is java.lang.IllegalArgumentException: DefaultSerializer requires a Serializable payload but received an object of type \[com.defonds.bdp.city.bean.City\]\]。
2.  缓存的生命周期我们可以配置，然后托管 Spring CacheManager，不要试图通过 redis-cli 命令行去管理缓存。比如 provinceCities 方法的缓存，某个省份的查询结果会被以 key-value 的形式存放在 Redis，key 就是我们刚才自定义生成的 key，value 是序列化后的对象，这个 key 会被放在 key 名为 provinceCities~keys key-value 存储中，参考下图"provinceCities 方法在 Redis 中的缓存情况"。可以通过 redis-cli 使用 del 命令将 provinceCities~keys 删除，但每个省份的缓存却不会被清除。
3.  CacheManager 必须设置缓存过期时间，否则缓存对象将永不过期，这样做的原因如上，避免一些野数据“永久保存”。此外，设置缓存过期时间也有助于资源利用最大化，因为缓存里保留的永远是热点数据。
4.  缓存适用于读多写少的场合，查询时缓存命中率很低、写操作很频繁等场景不适宜用缓存。

![provinceCities方法在Redis中的存储.png][provinceCities_Redis_.png]

# 后记 #

本文完整 Eclipse 下的开发项目示例已上传 CSDN 资源，有兴趣的朋友可以去下载下来参考： [http://download.csdn.net/detail/defonds/9137505][http_download.csdn.net_detail_defonds_9137505] 。

# 参考资料 #

*  [Caching Data with Spring][]
 *  [35. Cache Abstraction Part VII. Integration][]
 *  [Caching Data in Spring Using Redis][]
 *  [Caching with Spring Data Redis][]
 *  [spring-redis-caching-example][]

[spring 4_mvc_context_orm_ _ mybatis 3]: http://blog.csdn.net/defonds/article/details/48137969
[Redhat5.8 _ Redis]: http://blog.csdn.net/defonds/article/details/48525663
[view plain]: http://blog.csdn.net/defonds/article/details/48716161#
[CacheManager]: http://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/cache/CacheManager.html
[JMeter _ _bdp_city_province_cities.json _.png]: /images/20220731/1d88447cdb1e44e9b99183f0b3defd19.png
[Eclipse _.png]: /images/20220731/b4d02e153dbb45dd8214692bbe8669b2.png
[Eclipse]: /images/20220731/d8ef3486efe44a4885097b07c8c6bdc4.png
[Redis _.png]: /images/20220731/d2a7ac4a630e4e3abdd12abe95404a00.png
[city_code _ 1492 _ searchCity _.png]: /images/20220731/03a0b52e2e814e87b78b1d76cac6d473.png
[JMeter _ _bdp_city_create.json _.png]: /images/20220731/5fa7fc0bb8a44ad2ba3a7bdec100407c.png
[Redis]: /images/20220731/811ae953225f4de88f9739e797d51340.png
[JMeter _ _bdp_city_rename.json _.png]: /images/20220731/e57840bd4b4f42e5abba25f947c6c59f.png
[Redis _.png 1]: /images/20220731/c28baa8283454e8986308bff1287bf4b.png
[provinceCities_Redis_.png]: /images/20220731/e5c8114eba60461b90e06b385a0c67c4.png
[http_download.csdn.net_detail_defonds_9137505]: http://download.csdn.net/detail/defonds/9137505
[Caching Data with Spring]: https://spring.io/guides/gs/caching/
[35. Cache Abstraction Part VII. Integration]: http://docs.spring.io/spring/docs/current/spring-framework-reference/html/cache.html
[Caching Data in Spring Using Redis]: http://caseyscarborough.com/blog/2014/12/18/caching-data-in-spring-using-redis/
[Caching with Spring Data Redis]: http://blog.joshuawhite.com/java/caching-with-spring-data-redis/
[spring-redis-caching-example]: https://github.com/caseyscarborough/spring-redis-caching-example