1. Redission是Redis客户端中比较优秀的一个。学好Redission的使用是必要的。现在的项目开发，主要使用SpringBoot框架。那么我们就介绍一下SpringBoot如何整合Redission。

1.整合方式

SpringBoot整合Redission需要关注一下SpringBoot的版本信息。作者使用的是SpringBoot2.6.2版本。于是我整合Redission的方式是：

  1.         <dependency>
  2.             <groupId>org.redisson</groupId>
  3.             <artifactId>redisson-spring-boot-starter</artifactId>
  4.             <version>3.16.7</version>
  5.             <exclusions>
  6.                 <exclusion>
  7.                     <groupId>org.redisson</groupId>
  8.                     <artifactId>redisson-spring-data-25</artifactId>
  9.                 </exclusion>
  10.             </exclusions>
  11.         </dependency>
  13.         <dependency>
  14.             <groupId>org.redisson</groupId>
  15.             <artifactId>redisson-spring-data-26</artifactId>
  16.             <version>3.16.7</version>
  17.         </dependency>

这里作者剔除**redisson-spring-data-25**呢？

image.png 如果我使用SpringBoot2.6.x的话，最后匹配redission-spring-data-26

2.配置

这里我们只需像使用spring-boot-starter-redis那样配置一下redis位置就可以了。其他一些Bean配置都不需要我们做。Redission这个整合包中的RedissonAutoConfiguration已经帮我们配置好了。

  2. @Configuration
  3. @ConditionalOnClass({Redisson.class, RedisOperations.class})
  4. @AutoConfigureBefore(RedisAutoConfiguration.class)
  5. @EnableConfigurationProperties({RedissonProperties.class, RedisProperties.class})
  6. public class RedissonAutoConfiguration {
  8.     private static final String REDIS_PROTOCOL_PREFIX = "redis://";
  9.     private static final String REDISS_PROTOCOL_PREFIX = "rediss://";
  11.     @Autowired(required = false)
  12.     private List<RedissonAutoConfigurationCustomizer> redissonAutoConfigurationCustomizers;
  14.     @Autowired
  15.     private RedissonProperties redissonProperties;
  17.     @Autowired
  18.     private RedisProperties redisProperties;
  20.     @Autowired
  21.     private ApplicationContext ctx;
  23.     /** redisTemplate注入就用*/
  24.     @Bean
  25.     @ConditionalOnMissingBean(name = "redisTemplate")
  26.     public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
  27.         RedisTemplate<Object, Object> template = new RedisTemplate<Object, Object>();
  28.         template.setConnectionFactory(redisConnectionFactory);
  29.         return template;
  30.     }
  32.      /** stringRedisTemplate注入就用*/
  33.     @Bean
  34.     @ConditionalOnMissingBean(StringRedisTemplate.class)
  35.     public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
  36.         StringRedisTemplate template = new StringRedisTemplate();
  37.         template.setConnectionFactory(redisConnectionFactory);
  38.         return template;
  39.     }
  41.     @Bean
  42.     @ConditionalOnMissingBean(RedisConnectionFactory.class)
  43.     public RedissonConnectionFactory redissonConnectionFactory(RedissonClient redisson) {
  44.         return new RedissonConnectionFactory(redisson);
  45.     }
  47.     @Bean
  48.     @Lazy
  49.     @ConditionalOnMissingBean(RedissonReactiveClient.class)
  50.     public RedissonReactiveClient redissonReactive(RedissonClient redisson) {
  51.         return redisson.reactive();
  52.     }
  54.     @Bean
  55.     @Lazy
  56.     @ConditionalOnMissingBean(RedissonRxClient.class)
  57.     public RedissonRxClient redissonRxJava(RedissonClient redisson) {
  58.         return redisson.rxJava();
  59.     }
  61.     @Bean(destroyMethod = "shutdown")
  62.     @ConditionalOnMissingBean(RedissonClient.class)
  63.     public RedissonClient redisson() throws IOException {
  64.         Config config = null;
  65.         Method clusterMethod = ReflectionUtils.findMethod(RedisProperties.class, "getCluster");
  66.         Method timeoutMethod = ReflectionUtils.findMethod(RedisProperties.class, "getTimeout");
  67.         Object timeoutValue = ReflectionUtils.invokeMethod(timeoutMethod, redisProperties);
  68.         int timeout;
  69.         if(null == timeoutValue){
  70.             timeout = 10000;
  71.         }else if (!(timeoutValue instanceof Integer)) {
  72.             Method millisMethod = ReflectionUtils.findMethod(timeoutValue.getClass(), "toMillis");
  73.             timeout = ((Long) ReflectionUtils.invokeMethod(millisMethod, timeoutValue)).intValue();
  74.         } else {
  75.             timeout = (Integer)timeoutValue;
  76.         }
  78.         if (redissonProperties.getConfig() != null) {
  79.             try {
  80.                 config = Config.fromYAML(redissonProperties.getConfig());
  81.             } catch (IOException e) {
  82.                 try {
  83.                     config = Config.fromJSON(redissonProperties.getConfig());
  84.                 } catch (IOException e1) {
  85.                     throw new IllegalArgumentException("Can't parse config", e1);
  86.                 }
  87.             }
  88.         } else if (redissonProperties.getFile() != null) {
  89.             try {
  90.                 InputStream is = getConfigStream();
  91.                 config = Config.fromYAML(is);
  92.             } catch (IOException e) {
  93.                 // trying next format
  94.                 try {
  95.                     InputStream is = getConfigStream();
  96.                     config = Config.fromJSON(is);
  97.                 } catch (IOException e1) {
  98.                     throw new IllegalArgumentException("Can't parse config", e1);
  99.                 }
  100.             }
  101.         } else if (redisProperties.getSentinel() != null) {
  102.             Method nodesMethod = ReflectionUtils.findMethod(Sentinel.class, "getNodes");
  103.             Object nodesValue = ReflectionUtils.invokeMethod(nodesMethod, redisProperties.getSentinel());
  105.             String[] nodes;
  106.             if (nodesValue instanceof String) {
  107.                 nodes = convert(Arrays.asList(((String)nodesValue).split(",")));
  108.             } else {
  109.                 nodes = convert((List<String>)nodesValue);
  110.             }
  112.             config = new Config();
  113.             config.useSentinelServers()
  114.                 .setMasterName(redisProperties.getSentinel().getMaster())
  115.                 .addSentinelAddress(nodes)
  116.                 .setDatabase(redisProperties.getDatabase())
  117.                 .setConnectTimeout(timeout)
  118.                 .setPassword(redisProperties.getPassword());
  119.         } else if (clusterMethod != null && ReflectionUtils.invokeMethod(clusterMethod, redisProperties) != null) {
  120.             Object clusterObject = ReflectionUtils.invokeMethod(clusterMethod, redisProperties);
  121.             Method nodesMethod = ReflectionUtils.findMethod(clusterObject.getClass(), "getNodes");
  122.             List<String> nodesObject = (List) ReflectionUtils.invokeMethod(nodesMethod, clusterObject);
  124.             String[] nodes = convert(nodesObject);
  126.             config = new Config();
  127.             config.useClusterServers()
  128.                 .addNodeAddress(nodes)
  129.                 .setConnectTimeout(timeout)
  130.                 .setPassword(redisProperties.getPassword());
  131.         } else {
  132.             config = new Config();
  133.             String prefix = REDIS_PROTOCOL_PREFIX;
  134.             Method method = ReflectionUtils.findMethod(RedisProperties.class, "isSsl");
  135.             if (method != null && (Boolean)ReflectionUtils.invokeMethod(method, redisProperties)) {
  136.                 prefix = REDISS_PROTOCOL_PREFIX;
  137.             }
  139.             config.useSingleServer()
  140.                 .setAddress(prefix + redisProperties.getHost() + ":" + redisProperties.getPort())
  141.                 .setConnectTimeout(timeout)
  142.                 .setDatabase(redisProperties.getDatabase())
  143.                 .setPassword(redisProperties.getPassword());
  144.         }
  145.         if (redissonAutoConfigurationCustomizers != null) {
  146.             for (RedissonAutoConfigurationCustomizer customizer : redissonAutoConfigurationCustomizers) {
  147.                 customizer.customize(config);
  148.             }
  149.         }
  150.         return Redisson.create(config);
  151.     }
  153.     private String[] convert(List<String> nodesObject) {
  154.         List<String> nodes = new ArrayList<String>(nodesObject.size());
  155.         for (String node : nodesObject) {
  156.             if (!node.startsWith(REDIS_PROTOCOL_PREFIX) && !node.startsWith(REDISS_PROTOCOL_PREFIX)) {
  157.                 nodes.add(REDIS_PROTOCOL_PREFIX + node);
  158.             } else {
  159.                 nodes.add(node);
  160.             }
  161.         }
  162.         return nodes.toArray(new String[nodes.size()]);
  163.     }
  165.     private InputStream getConfigStream() throws IOException {
  166.         Resource resource = ctx.getResource(redissonProperties.getFile());
  167.         InputStream is = resource.getInputStream();
  168.         return is;
  169.     }
  172. }

jar包引入后，我们可以直接通过注入的方式使用一下类：