Springboot 2.X中Spring-cache与redis整合

一、本次案例

Springboot中Spring-cache与redis整合。这也是一个不错的框架，与spring的事务使用类似，只要添加一些注解方法，就可以动态的去操作缓存了，减少代码的操作。如果这些注解不满足项目的需求，我们也可以参考spring-cache的实现思想，使用AOP代理+缓存操作来管理缓存的使用。

在这个例子中我使用的是redis，当然，因为spring-cache的存在，我们可以整合多样的缓存技术，例如Ecache、Mamercache等。

二、创建springBoot 项目  king-cache

1. 在pom.xml中添加以下依赖

1. <dependency>
2. <groupId>org.springframework.boot</groupId>
3. <artifactId>spring-boot-starter-cache</artifactId>
4. </dependency>
5. <dependency>
6. <groupId>org.springframework.boot</groupId>
7. <artifactId>spring-boot-starter-data-redis</artifactId>
8. </dependency>

 

三、redis客户端配置

无论使用spring-boot的哪个版本，我们都需要先配置redis连接，两个版本的redis客户端连接池使用有所不同。

spring-boot版本	默认客户端类型
1.5.x	jedis
2.x	lettuce

在1.5.x中，我们配置jedis连接池只需要配置 spring.redis.pool.* 开始的配置即可，如下配置

1. spring.redis.pool.max-active=8
2. spring.redis.pool.max-wait=-1
3. spring.redis.pool.min-idle=0
4. spring.redis.pool.max-idle=8

但在2.x版本中由于引入了不同的客户端，需要指定配置哪种连接池，如下配置

在application.properties中添加如下代码:

1. #jedis客户端
2. server.port=8080
3. spring.cache.type=redis
4. spring.redis.host=192.168.140.130 # server host
5. spring.redis.password= 123456
6. spring.redis.port= 6379
7. spring.redis.jedis.pool.max-active=8
8. spring.redis.jedis.pool.max-wait=-1ms
9. spring.redis.jedis.pool.min-idle=0
10. spring.redis.jedis.pool.max-idle=8
11. #lettuce客户端
12. spring.redis.lettuce.pool.min-idle=0
13. spring.redis.lettuce.pool.max-idle=8
14. spring.redis.lettuce.pool.max-wait=-1ms
15. spring.redis.lettuce.pool.max-active=8
16. spring.redis.lettuce.shutdown-timeout=100ms

除此之外还可以看到时间配置上还需要带上对应的单位。

四、JavaConfig方式配置

通用配置方式只能满足整个程序所有缓存都采用相同公共配置的方式，如果需要特殊处理，如我们的案列，则需要自己采用代码的方式来配置。
采用代码的方式，只要需要配置的是CacheMananger，采用Redis时具体实现我们需要使用其子类RedisCacheMananger来做配置

1. 创建redis的配置类RedisConfig.java
2. 注意一定要在类上加上以下两个注解:
3.     @Configuration  可理解为用spring的时候xml里面的<beans>标签
4.     @EnableCaching 注解是spring framework中的注解驱动的缓存管理功能。

1. package com.answer.config;
3. import java.lang.reflect.Method;
4. import java.time.Duration;
5. import java.util.HashMap;
6. import java.util.Map;
8. import org.springframework.cache.CacheManager;
9. import org.springframework.cache.annotation.CachingConfigurerSupport;
10. import org.springframework.cache.annotation.EnableCaching;
11. import org.springframework.cache.interceptor.KeyGenerator;
12. import org.springframework.context.annotation.Bean;
13. import org.springframework.context.annotation.Configuration;
14. import org.springframework.data.redis.cache.RedisCacheConfiguration;
15. import org.springframework.data.redis.cache.RedisCacheManager;
16. import org.springframework.data.redis.cache.RedisCacheWriter;
17. import org.springframework.data.redis.connection.RedisConnectionFactory;
18. import org.springframework.data.redis.core.RedisTemplate;
19. import org.springframework.data.redis.core.StringRedisTemplate;
20. import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
22. import com.fasterxml.jackson.annotation.JsonAutoDetect;
23. import com.fasterxml.jackson.annotation.PropertyAccessor;
24. import com.fasterxml.jackson.databind.ObjectMapper;
26. /**
27. * <p>redis缓存配置</p>
28. * Created by zhezhiyong@163.com on 2017/9/21.
29. */
30. @Configuration
31. @EnableCaching
32. public class RedisConfig extends CachingConfigurerSupport {
34. @Bean
35. public KeyGenerator KeyGenerator() {
36. return new KeyGenerator() {
37. @Override
38. public Object generate(Object target, Method method, Object... params) {
39. StringBuilder sb = new StringBuilder();
40. sb.append(target.getClass().getName());
41. sb.append(method.getName());
42. for (Object obj : params) {
43. sb.append(obj.toString());
44. }
45. return sb.toString();
46. }
47. };
48. }
50. /* @Bean
51. public CacheManager cacheManager(RedisTemplate redisTemplate) {
52. RedisCacheManager manager = new RedisCacheManager(redisTemplate);
53. manager.setUsePrefix(true);
54. RedisCachePrefix cachePrefix = new RedisPrefix("prefix");
55. manager.setCachePrefix(cachePrefix);
56. // 整体缓存过期时间
57. manager.setDefaultExpiration(3600L);
58. // 设置缓存过期时间。key和缓存过期时间，单位秒
59. Map<String, Long> expiresMap = new HashMap<>();
60. expiresMap.put("user", 1000L);
61. manager.setExpires(expiresMap);
62. return manager;
63. }*/
65. @Bean
66. CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
67. //初始化一个RedisCacheWriter
68. RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(connectionFactory);
69. //设置CacheManager的值序列化方式为JdkSerializationRedisSerializer,但其实RedisCacheConfiguration默认就是使用StringRedisSerializer序列化key，JdkSerializationRedisSerializer序列化value,所以以下注释代码为默认实现
70. //ClassLoader loader = this.getClass().getClassLoader();
71. //JdkSerializationRedisSerializer jdkSerializer = new JdkSerializationRedisSerializer(loader);
72. //RedisSerializationContext.SerializationPair<Object> pair = RedisSerializationContext.SerializationPair.fromSerializer(jdkSerializer);
73. //RedisCacheConfiguration defaultCacheConfig=RedisCacheConfiguration.defaultCacheConfig().serializeValuesWith(pair);
74. RedisCacheConfiguration defaultCacheConfig = RedisCacheConfiguration.defaultCacheConfig();
75. //设置默认超过期时间是30秒
76. defaultCacheConfig.entryTtl(Duration.ofSeconds(30));
77. //初始化RedisCacheManager
78. RedisCacheManager cacheManager = new RedisCacheManager(redisCacheWriter, defaultCacheConfig);
79. return cacheManager;
80. }
81. @Bean
82. public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
83. StringRedisTemplate template = new StringRedisTemplate(factory);
84. Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
85. ObjectMapper om = new ObjectMapper();
86. om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
87. om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
88. jackson2JsonRedisSerializer.setObjectMapper(om);
89. template.setValueSerializer(jackson2JsonRedisSerializer);
90. template.afterPropertiesSet();
91. return template;
92. }
93. }

以上代码中RedisCacheConfiguration类为2.x新增的配置类，增加了几个配置项。这里比较奇怪的是调用它的配置方法每一次都会重新生成一个配置对象，而不是在原对象上直接修改参数值，这一点本人没搞懂作者为何要选择这种方式。

到这里基本的配置就已经完成了

五、具体使用

如果我们想在其他项目中添加该微服务想进行缓存的操作，需依赖king-cache模块：

1. <!-- redis-cache 工具类 -->
2. <dependency>
3. <groupId>com.answer</groupId>
4. <artifactId>king-cache</artifactId>
5. <version>0.0.1-SNAPSHOT</version>
6. </dependency>

六、测试Demo------新建项目:king-cache-1

添加以下依赖:

1. <!-- redis-cache 工具类 -->
2. <dependency>
3. <groupId>com.answer</groupId>
4. <artifactId>king-cache</artifactId>
5. <version>0.0.1-SNAPSHOT</version>
6. </dependency>
8. <dependency>
9. <groupId>com.google.guava</groupId>
10. <artifactId>guava</artifactId>
11. <version>19.0</version>
12. </dependency>
14. <dependency>
15. <groupId>org.projectlombok</groupId>
16. <artifactId>lombok</artifactId>
17. <scope>compile</scope>
18. </dependency>

依上图所示分别创建以下实例:

Info.java

1. package com.answer.entity;
3. import java.io.Serializable;
5. import lombok.AllArgsConstructor;
6. import lombok.Data;
8. /**
9. * <p></p>
10. * Created by zhezhiyong@163.com on 2017/9/22.
11. */
12. @Data
13. @AllArgsConstructor
14. public class Info implements Serializable{
15. /**
16. * @Fields serialVersionUID : TODO(用一句话描述这个变量表示什么)
17. */
18. private static final long serialVersionUID = 5457507957150215600L;
19. public Info(String string, String string2) {
20. // TODO Auto-generated constructor stub
21. }
22. public String getPhone() {
23. return phone;
24. }
25. public void setPhone(String phone) {
26. this.phone = phone;
27. }
28. public String getAddress() {
29. return address;
30. }
31. public void setAddress(String address) {
32. this.address = address;
33. }
34. private String phone;
35. private String address;
37. }

User.java

1. package com.answer.entity;
3. import java.io.Serializable;
5. import lombok.AllArgsConstructor;
6. import lombok.Data;
7. import lombok.NoArgsConstructor;
9. /**
10. * <p></p>
11. * Created by zhezhiyong@163.com on 2017/9/21.
12. */
13. @Data
14. @AllArgsConstructor
15. @NoArgsConstructor
16. public class User implements Serializable{
19. /**
20. * @Fields serialVersionUID : TODO(用一句话描述这个变量表示什么)
21. */
22. private static final long serialVersionUID = 1L;
23. public Long getId() {
24. return id;
25. }
26. public void setId(Long id) {
27. this.id = id;
28. }
29. public String getName() {
30. return name;
31. }
32. public void setName(String name) {
33. this.name = name;
34. }
35. public String getPassword() {
36. return password;
37. }
38. public void setPassword(String password) {
39. this.password = password;
40. }
41. private Long id;
42. private String name;
43. private String password;
45. }

IndexController.java

1. package com.answer.web;
3. import java.util.List;
4. import java.util.Map;
6. import org.springframework.beans.factory.annotation.Autowired;
7. import org.springframework.web.bind.annotation.GetMapping;
8. import org.springframework.web.bind.annotation.PathVariable;
9. import org.springframework.web.bind.annotation.ResponseBody;
10. import org.springframework.web.bind.annotation.RestController;
12. import com.answer.entity.User;
13. import com.answer.service.UserService;
14. import com.google.common.collect.ImmutableMap;
16. /**
17. * <p></p>
18. * Created by zhezhiyong@163.com on 2017/9/21.
19. */
20. @RestController
21. public class IndexController {
23. @Autowired
24. private UserService userService;
26. @GetMapping("/users")
27. @ResponseBody
28. public List<User> users() {
29. return userService.list();
30. }
32. @GetMapping("/user/{id}")
33. @ResponseBody
34. public User findUserById(@PathVariable("id") Long id) {
35. return userService.findUserById(id);
36. }
38. @GetMapping("/upuser/{id}")
39. @ResponseBody
40. public User upuser(@PathVariable("id") Long id) {
41. return userService.upuser(id);
42. }
44. @GetMapping("/info/{id}")
45. @ResponseBody
46. public User findInfoById(@PathVariable("id") Long id) {
47. return userService.findInfoById(id);
48. }
50. @GetMapping("/user/{id}/{name}")
51. @ResponseBody
52. public Map update(@PathVariable("id") Long id, @PathVariable("name") String name) {
53. User user = userService.findUserById(id);
54. user.setName(name);
55. userService.update(user);
56. return ImmutableMap.of("ret", 0, "msg", "ok");
57. }
60. }

UserService.java

1. package com.answer.service;
3. import java.util.List;
5. import com.answer.entity.User;
7. /**
8. * <p></p>
9. * Created by zhezhiyong@163.com on 2017/9/21.
10. */
11. public interface UserService {
13. List<User> list();
15. User findUserById(Long id);
17. User findInfoById(Long id);
19. void update(User user);
21. void remove(Long id);
23. User upuser(Long id);
25. }

UserServiceImpl.java

1. package com.answer.service.impl;
2. import java.util.Arrays;
3. import java.util.HashMap;
4. import java.util.List;
5. import java.util.Map;
7. import org.springframework.cache.annotation.CacheEvict;
8. import org.springframework.cache.annotation.CachePut;
9. import org.springframework.cache.annotation.Cacheable;
10. import org.springframework.stereotype.Service;
12. import com.answer.entity.Info;
13. import com.answer.entity.User;
14. import com.answer.service.UserService;
16. import lombok.extern.slf4j.Slf4j;
18. /**
19. * <p></p>
20. * Created by zhezhiyong@163.com on 2017/9/21.
21. */
22. @Service
23. @Slf4j
24. public class UserServiceImpl implements UserService {
26. private Map<Long, User> userMap = new HashMap<>();
27. private Map<Long, Info> infoMap = new HashMap<>();
29. public UserServiceImpl() {
30. User u1=new User();
31. u1.setId(1L);
32. u1.setName("1111");
33. u1.setPassword("11223434");
34. User u2=new User();
35. u2.setId(1L);
36. u2.setName("1111");
37. u2.setPassword("11223434");
38. User u3=new User();
39. u3.setId(1L);
40. u3.setName("1111");
41. u3.setPassword("11223434");
43. userMap.put(1L,u1);
44. userMap.put(2L,u2);
45. userMap.put(3L,u3);
46. infoMap.put(1L, new Info("18559198715", "福州市"));
47. }
49. @Override
50. public List list() {
51. return Arrays.asList(userMap.values().toArray());
52. }
54. @Override
55. @Cacheable(value = "user", key = "'user'.concat(#id.toString())")
56. public User findUserById(Long id) {
57. //log.info("findUserById query from db, id: {}", id);
58. System.out.println("findUserById query from db, id: {}======"+id);
59. return userMap.get(id);
60. }
62. @Override
63. @Cacheable(value = "info", key = "'info'.concat(#id.toString())")
64. public User findInfoById(Long id) {
65. // log.info("findInfoById query from db, id: {}", id);
66. System.out.println("findUserById query from db, id: {}======"+id);
67. return userMap.get(id);
68. }
70. @Override
71. @CachePut(value = "user", key = "'user'.concat(#user.id.toString())")
72. public void update(User user) {
73. //log.info("update db, user: {}", user.toString());
74. System.out.println("findUserById query from db, id: {}======");
75. userMap.put(user.getId(), user);
76. }
78. @Override
79. @CacheEvict(value = "user", key = "'user'.concat(#id.toString())")
80. public void remove(Long id) {
81. //log.info("remove from db, id: {}", id);
82. System.out.println("findUserById query from db, id: {}======");
83. userMap.remove(id);
84. }
86. @Override
87. @CacheEvict(value = "user", key = "'user'.concat(#id.toString())")
88. public User upuser(Long id) {
89. User d= userMap.get(id);
90. d.setName("000000000000000000000000000000000000000000000000");
91. return d;
92. }
93. }

注意:启动项目前一定要对king-cache进行打包(右键项目:Run As ---Maven Install)

然后:king-cache-1 右键 maven ---Update Project

最后:以Debug 模式启动 项目:king-cache-1

在以下方法出添加断点:

然后多次访问:http://localhost:8080/user/3

你会发现第一次进入断点,后面几次不再进入断点.

一定要添加上这个注解:@Cacheable

 

项目源码下载地址: https://download.csdn.net/download/guokezhongdeyuzhou/10322780

注意以下注解的作用:

缓存的注解介绍

@Cacheable 触发缓存入口

@CacheEvict 触发移除缓存

@CacahePut 更新缓存

@Caching 将多种缓存操作分组

@CacheConfig 类级别的缓存注解，允许共享缓存名称

@CacheConfig

该注解是可以将缓存分类，它是类级别的注解方式。我们可以这么使用它。
这样的话，UseCacheRedisService的所有缓存注解例如@Cacheable的value值就都为user。

1. @CacheConfig(cacheNames = "user")
2. @Service
3. public class UseCacheRedisService {}

在redis的缓存中显示如下

1. 127.0.0.1:6379> keys *
2. 1) "user~keys"
3. 2) "user_1"
4. 127.0.0.1:6379> get user~keys
5. (error) WRONGTYPE Operation against a key holding the wrong kind of value
6. 127.0.0.1:6379> type user~keys
7. zset
8. 127.0.0.1:6379> zrange user~keys 0 10
9. 1) "user_1"

我们注意到，生成的user~keys，它是一个zset类型的key，如果使用get会报WRONGTYPE Operation against a key holding the wrong kind of value。这个问题坑了我很久

@Cacheable

一般用于查询操作，根据key查询缓存.

1. 如果key不存在，查询db，并将结果更新到缓存中。
2. 如果key存在，直接查询缓存中的数据。

查询的例子，当第一查询的时候，redis中不存在key，会从db中查询数据，并将返回的结果插入到redis中。

1. @Cacheable
2. public List<User> selectAllUser(){
3. return userMapper.selectAll();
4. }

调用方式。

1. @Test
2. public void selectTest(){
3. System.out.println("===========第一次调用=======");
4. List<User> list = useCacheRedisService.selectAllUser();
5. System.out.println("===========第二次调用=======");
6. List<User> list2 = useCacheRedisService.selectAllUser();
7. for (User u : list2){
8. System.out.println("u = " + u);
9. }
10. }

打印结果，大家也可以试一试
只输出一次sql查询的语句，说明第二次查询是从redis中查到的。

1. ===========第一次调用=======
2. keyGenerator=com.lzl.redisService.UseCacheRedisService.selectAllUser.
3. keyGenerator=com.lzl.redisService.UseCacheRedisService.selectAllUser.
4. DEBUG [main] - ==> Preparing: SELECT id,name,sex,age,password,account FROM user
5. DEBUG [main] - ==> Parameters:
6. DEBUG [main] - <== Total: 1
7. ===========第二次调用=======
8. keyGenerator=com.lzl.redisService.UseCacheRedisService.selectAllUser.
9. u = User{id=1, name='fsdfds', sex='fdsfg', age=24, password='gfdsg', account='gfds'}

redis中的结果
我们可以看到redis中已经存在
com.lzl.redisService.UseCacheRedisService.selectAllUser.记录了。
这么长的一串字符key是根据自定义key值生成的。

1. 127.0.0.1:6379> keys *
2. 1) "user~keys"
3. 2) "com.lzl.redisService.UseCacheRedisService.selectAllUser."
4. 3) "user_1"
5. 127.0.0.1:6379> get com.lzl.redisService.UseCacheRedisService.selectAllUser.
6. "[\"java.util.ArrayList\",[[\"com.lzl.bean.User\",{\"id\":1,\"name\":\"fsdfds\",\"sex\":\"fdsfg\",\"age\":24,\"password\":\"gfdsg\",\"account\":\"gfds\"}]]]"

@CachePut

一般用于更新和插入操作，每次都会请求db
通过key去redis中进行操作。
1. 如果key存在，更新内容
2. 如果key不存在，插入内容。

1. /**
2. * 单个user对象的插入操作，使用user+id
3. * @param user
4. * @return
5. */
6. @CachePut(key = "\"user_\" + #user.id")
7. public User saveUser(User user){
8. userMapper.insert(user);
9. return user;
10. }

redis中的结果
多了一条记录user_2

1. 127.0.0.1:6379> keys *
2. 1) "user~keys"
3. 2) "user_2"
4. 3) "com.lzl.redisService.UseCacheRedisService.selectAllUser."
5. 4) "user_1"
6. 127.0.0.1:6379> get user_2
7. "[\"com.lzl.bean.User\",{\"id\":2,\"name\":\"fsdfds\",\"sex\":\"fdsfg\",\"age\":24,\"password\":\"gfdsg\",\"account\":\"gfds\"}]"

@CacheEvict

根据key删除缓存中的数据。allEntries=true表示删除缓存中的所有数据。

1. @CacheEvict(key = "\"user_\" + #id")
2. public void deleteById(Integer id){
3. userMapper.deleteByPrimaryKey(id);
4. }

测试方法

1. @Test
2. public void deleteTest(){
3. useCacheRedisService.deleteById(1);
4. }

redis中的结果
user_1已经移除掉。

1. 127.0.0.1:6379> keys *
2. 1) "user~keys"
3. 2) "user_2"
4. 3) "com.lzl.redisService.UseCacheRedisService.selectAllUser."

测试allEntries=true时的情形。

1. @Test
2. public void deleteAllTest(){
3. useCacheRedisService.deleteAll();
4. }
5. @CacheEvict(allEntries = true)
6. public void deleteAll(){
7. userMapper.deleteAll();
8. }

redis中的结果
redis中的数据已经全部清空

1. 127.0.0.1:6379> keys *
2. (empty list or set)

@Caching

通过注解的属性值可以看出来，这个注解将其他注解方式融合在一起了，我们可以根据需求来自定义注解，并将前面三个注解应用在一起

1. public @interface Caching {
2. Cacheable[] cacheable() default {};
4. CachePut[] put() default {};
6. CacheEvict[] evict() default {};
7. }

使用例子如下

1. @Caching(
2. put = {
3. @CachePut(value = "user", key = "\"user_\" + #user.id"),
4. @CachePut(value = "user", key = "#user.name"),
5. @CachePut(value = "user", key = "#user.account")
6. }
7. )
8. public User saveUserByCaching(User user){
9. userMapper.insert(user);
10. return user;
11. }

1. @Test
2. public void saveUserByCachingTest(){
3. User user = new User();
4. user.setName("dkjd");
5. user.setAccount("dsjkf");
6. useCacheRedisService.saveUserByCaching(user);
7. }

redis中的执行结果
一次添加三个key

1. 127.0.0.1:6379> keys *
2. 1) "user~keys"
3. 2) "dsjkf"
4. 3) "dkjd"
5. 4) "user_3"