Spring Boot整合Redis

在上一章中，我们讨论了Redis服务的运维，包括单机运行和Sentinel运行。

在本小节中，我们讨论如何在Spring Boot中集成Redis。

Spring Boot内置了Redis的接入方式，spring-data-redis，这种方案在Jedis客户端的基础上尽心过了简单的封装。若只使用Redis的KV存储特性，该方案可以满足要求。但对于Redis的高级特性(如SortedSet、SETNX等)，则需要手动调用底层Jedis客户端的API，使用方式较为晦涩且容易出错。

为此，我们推荐使用Redisson作为接入客户端，它提供了简单易用的封装，可以用最小的编程代价来发挥Redis的最大功能。

库依赖及自动配置

为了方便类库的复用，我们将Redisson的依赖及自动配置抽成一个单独的项目lmsia-redis 。

首先来看一下依赖：

  1.     compileOnly 'org.springframework.boot:spring-boot-autoconfigure:1.5.6.RELEASE'
  2.     compileOnly 'com.fasterxml.jackson.core:jackson-databind:2.9.0'
  3.     compileOnly 'ch.qos.logback:logback-classic:1.2.3'
  5.     compile 'org.redisson:redisson:3.7.3'
  7.     // Use JUnit test framework
  8.     testCompile 'junit:junit:4.12'

如上述的代码片段所示，编译依赖了Sping Boot的自动注解、jackson、以及logback，此外显式依赖了redisson库。

上一小节已经介绍，Redis有单机、Sentinel、Cluster三种部署方式，我们这里介绍前两种。

首先看一下单机Redis的自动配置：

  1. package com.coder4.sbmvt.redis.configuration;
  3. import com.coder4.sbmvt.redis.utils.RedissonUtils;
  4. import org.redisson.Redisson;
  5. import org.redisson.api.RedissonClient;
  6. import org.redisson.config.Config;
  7. import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
  8. import org.springframework.boot.context.properties.ConfigurationProperties;
  9. import org.springframework.context.annotation.Bean;
  10. import org.springframework.context.annotation.Configuration;
  12. import java.io.IOException;
  14. /**
  15.  * @author coder4
  16.  */
  17. @Configuration
  18. @ConfigurationProperties(prefix = "redis")
  19. public class RedissonAutoConfiguration {
  21.     // server list
  22.     private String server;
  24.     // redis password
  25.     private String password;
  27.     // connection pool size, default 128
  28.     private int connPoolSize = 128;
  30.     // retry interval in ms
  31.     private int retryInterval = 100;
  33.     @Bean(destroyMethod = "shutdown")
  34.     @ConditionalOnMissingBean(RedissonClient.class)
  35.     public RedissonClient createRedissonClient() throws IOException {
  36.         if (getServer() == null || getServer().isEmpty()) {
  37.             throw new IllegalArgumentException("server is empty");
  38.         }
  40.         Config config = new Config();
  42.         config.useSingleServer()
  43.                 .setAddress(RedissonUtils.wrapSchema(server))
  44.                 .setPassword(password)
  45.                 .setRetryInterval(retryInterval)
  46.                 .setConnectionPoolSize(connPoolSize);
  48.         return Redisson.create(config);
  49.     }
  52.     public String getServer() {
  53.         return server;
  54.     }
  56.     public void setServer(String server) {
  57.         this.server = server;
  58.     }
  60.     public String getPassword() {
  61.         return password;
  62.     }
  64.     public void setPassword(String password) {
  65.         this.password = password;
  66.     }
  68.     public int getConnPoolSize() {
  69.         return connPoolSize;
  70.     }
  72.     public void setConnPoolSize(int connPoolSize) {
  73.         this.connPoolSize = connPoolSize;
  74.     }
  76.     public int getRetryInterval() {
  77.         return retryInterval;
  78.     }
  80.     public void setRetryInterval(int retryInterval) {
  81.         this.retryInterval = retryInterval;
  82.     }
  83. }

如上所示:

  • 若yaml配置中包含”redis”前缀的配置，则注解被激活。
  • 尝试解析server、password、connPoolSize、retryInterval4个配置字段。
    • server是redis服务器的IP:Port
    • password是redis服务器的密码
    • connPoolSize是连接池默认大小，默认是128
    • retryInterval是命令执行失败后的重试间隔，默认是100ms
  • 根据上述配置自动生成ResissonClient

再来看一下Sentinel方式的自动配置：

  1. package com.coder4.sbmvt.redis.configuration;
  3. import com.coder4.sbmvt.redis.utils.RedissonUtils;
  4. import org.redisson.Redisson;
  5. import org.redisson.api.RedissonClient;
  6. import org.redisson.config.Config;
  7. import org.redisson.config.ReadMode;
  8. import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
  9. import org.springframework.boot.context.properties.ConfigurationProperties;
  10. import org.springframework.context.annotation.Bean;
  11. import org.springframework.context.annotation.Configuration;
  13. import java.io.IOException;
  14. import java.util.List;
  16. @Configuration
  17. @ConfigurationProperties(prefix = "redis-sentinel")
  18. public class RedissonSentinelAutoConfiguration {
  20.     // server list
  21.     private String sentinelServerList;
  23.     // sentinel master name
  24.     private String masterName;
  26.     // redis password
  27.     private String password;
  29.     // connection pool size, default 128
  30.     private int connPoolSize = 128;
  32.     // retry interval in ms
  33.     private int retryInterval = 100;
  35.     @Bean(destroyMethod = "shutdown")
  36.     @ConditionalOnMissingBean(RedissonClient.class)
  37.     public RedissonClient createRedissonClient() throws IOException {
  38.         List<String> sentinelAddrs = RedissonUtils.splitStr(sentinelServerList);
  39.         if (sentinelAddrs == null || sentinelAddrs.size() == 0) {
  40.             throw new IllegalArgumentException("sentinel address is empty");
  41.         }
  43.         Config config = new Config();
  45.         config.useSentinelServers()
  46.                 .setMasterName(masterName)
  47.                 .addSentinelAddress(sentinelAddrs.stream().map(RedissonUtils::wrapSchema).toArray(String[]::new))
  48.                 .setPassword(password)
  49.                 .setMasterConnectionPoolSize(connPoolSize)
  50.                 .setSlaveConnectionPoolSize(connPoolSize)
  51.                 .setRetryInterval(retryInterval)
  52.                 .setReadMode(ReadMode.MASTER);
  54.         return Redisson.create(config);
  55.     }
  58.     public String getSentinelServerList() {
  59.         return sentinelServerList;
  60.     }
  62.     public void setSentinelServerList(String sentinelServerList) {
  63.         this.sentinelServerList = sentinelServerList;
  64.     }
  66.     public String getMasterName() {
  67.         return masterName;
  68.     }
  70.     public void setMasterName(String masterName) {
  71.         this.masterName = masterName;
  72.     }
  74.     public String getPassword() {
  75.         return password;
  76.     }
  78.     public void setPassword(String password) {
  79.         this.password = password;
  80.     }
  82.     public int getConnPoolSize() {
  83.         return connPoolSize;
  84.     }
  86.     public void setConnPoolSize(int connPoolSize) {
  87.         this.connPoolSize = connPoolSize;
  88.     }
  90.     public int getRetryInterval() {
  91.         return retryInterval;
  92.     }
  94.     public void setRetryInterval(int retryInterval) {
  95.         this.retryInterval = retryInterval;
  96.     }
  97. }

上述自动配置和RedissonAutoConfiguration基本一致，唯一的差别是配置了Sentinal服务集群列表和masterName。

最后，在别的项目引用这个包时，我们要将上述两个自动配置暴露给Spring Boot扫描，添加到spring.factories中：

  1. org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  2. com.coder4.sbmvt.redis.configuration.RedissonAutoConfiguration,\
  3. com.coder4.sbmvt.redis.configuration.RedissonSentinelAutoConfiguration

接下来，我们来看一下在Spring Boot中的具体集成方法。

Spring Boot中集成Redis

在Spring Boot中集成Redis，首先依赖刚才的lmsia-redis类库:

  1. compile 'com.github.liheyuan:lmsia-redis:0.0.4'

然后在yaml中添加配置：

  1. # redis
  2. redis.server: "192.168.99.100:6379"

经过上述配置后，Spring Boot在启动后，会自动注入RedissonClient，我们可以直接Autowired使用：

  1. @Service
  2. public class MyListRedissonImpl implements MyListRepository {
  4.     @Autowired
  5.     private RedissonClient redissonClient;
  7.     private static String getKey(int userId) {
  8.         return String.format("list:%d", userId);
  9.     }
  11.     private RSet<Long> obtainSet(int userId) {
  12.         return redissonClient.getSet(getKey(userId), new LongCodec());
  13.     }
  15.     @Override
  16.     public List<Long> get(int userId) {
  17.         return new ArrayList(obtainSet(userId).readAll());
  18.     }
  20.     @Override
  21.     public void add(int userId, long data) {
  22.         obtainSet(userId).add(data);
  23.     }

我们通过上述代码，简单看一下Redisson的用法。

  • 通过getKey拼接一个key
  • 通过redissonClient.getSet获取key对应的RSet，编码是Long，这里的RSet和Java的Set完全兼容。
  • add进行添加、get返回set中全部数据。

Redisson将较为繁琐的Redis命令进行了封装和组合，我们操作的是类Java的数据结构，但实际底层命令都是Redis的。

关于Sentinel的配置方法，是类似的，这里不再赘述。

至此，我们完成了Spring Boot中Redis服务的整合工作。

拓展阅读

  1. Redisson还提供了锁、排序集合等许多高级数据结构，可以参考Redisson官方文档