SpringBoot 整合Redisson（*）

Posted 2022-07-20 Firm陈

一、Redission整合

redission是一个redis客户端，用于分布式系统中
1、创建SpringBoot项目
　　引入SpringBoot的redission启动器:

 <dependency>
     <groupId>org.redisson</groupId>
     <artifactId>redisson-spring-boot-starter</artifactId>
     <version>3.15.5</version>
 </dependency>

查看jar包相关依赖

2、配置redission

1. 在application.yml 中添加redission 配置文件路径

spring:
   redis:
     database: 0
     timeout: 3000
     password: 
     # 单节点模式
     host: 127.0.0.1
     port: 6379
     # redisson配置文件路径
     redisson:
       file: classpath:redisson.yml

2. 新建resources/redission.yml文件, 内容如下:

# 单节点配置
 singleServerConfig:
   # 连接空闲超时，单位：毫秒
   idleConnectionTimeout: 10000
   # 连接超时，单位：毫秒
   connectTimeout: 10000
   # 命令等待超时，单位：毫秒
   timeout: 3000
   # 命令失败重试次数,如果尝试达到 retryAttempts（命令失败重试次数） 仍然不能将命令发送至某个指定的节点时，将抛出错误。
   # 如果尝试在此限制之内发送成功，则开始启用 timeout（命令等待超时） 计时。
   retryAttempts: 3
   # 命令重试发送时间间隔，单位：毫秒
   retryInterval: 1500
   # 密码
   password:
   # 单个连接最大订阅数量
   subscriptionsPerConnection: 5
   # 客户端名称
   clientName: myredis
   # 节点地址
   address: redis://127.0.0.1:6379
   # 发布和订阅连接的最小空闲连接数
   subscriptionConnectionMinimumIdleSize: 1
   # 发布和订阅连接池大小
   subscriptionConnectionPoolSize: 50
   # 最小空闲连接数
   connectionMinimumIdleSize: 32
   # 连接池大小
   connectionPoolSize: 64
   # 数据库编号
   database: 0
   # DNS监测时间间隔，单位：毫秒
   dnsMonitoringInterval: 5000
 # 线程池数量,默认值: 当前处理核数量 * 2
 #threads: 0
 # Netty线程池数量,默认值: 当前处理核数量 * 2
 #nettyThreads: 0
 # 编码
 codec: !<org.redisson.codec.JsonJacksonCodec> 
 # 传输模式
 transportMode : "NIO"

3、编辑启动类 和 配置类

1. 主启动类 Application.java

 @SpringBootApplication
 public class Application 
 
     /**
      * 测试 Redis客户端 Redission 的使用
      * @param args
      */
     public static void main(String[] args) 
         SpringApplication.run(Application.class);
     
 

2. 测试类 TestApplication.java

 package com.test.redis;
 
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.redisson.api.RLock;
 import org.redisson.api.RedissonClient;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.context.ApplicationContext;
 import org.springframework.test.context.junit4.SpringRunner;
 
 @RunWith(SpringRunner.class)
 @SpringBootTest
 public class TestApplication 
 
     @Autowired
     ApplicationContext context;
 
     // redisson客户端
     @Autowired
     RedissonClient redissonClient;
 
     // 测试分布式锁
     @Test
     public void terst1() throws InterruptedException 
         RLock lock = redissonClient.getLock("anyLock");
 
         new Thread(() -> 
             lock.lock();
 
             try 
                 System.out.println(Thread.currentThread().getName() + ":	 获得锁");
                 Thread.sleep(3000);
              catch (InterruptedException e) 
                 e.printStackTrace();
              finally 
                 System.out.println(Thread.currentThread().getName() + ":	 释放锁");
                 lock.unlock();
             
         ).start();
 
 
         new Thread(() -> 
             lock.lock();
             try 
                 System.out.println(Thread.currentThread().getName() + ":	 获得锁");
                 Thread.sleep(3000);
              catch (InterruptedException e) 
                 e.printStackTrace();
              finally 
                 System.out.println(Thread.currentThread().getName() + ":	 释放锁");
                 lock.unlock();
             
         ).start();
 
         Thread.sleep(100000);
     
 

4、测试运行
正常运行,且能加锁成功
控制台输出:

redis数据:

　分布式锁原理参考:【Redis】分布式锁之Redis实现

二、Redission整合原理

1、Redission的自动配置类 RedissonAutoConfiguration

 @Configuration
 @ConditionalOnClass(Redisson.class, RedisOperations.class)
 
 // @AutoConfigureBefore表示在 RedisAutoConfiguration 之前注入
 @AutoConfigureBefore(RedisAutoConfiguration.class)
 
 @EnableConfigurationProperties(RedissonProperties.class, RedisProperties.class)
 public class RedissonAutoConfiguration 
     ......
     
     // Redisson属性配置
     @Autowired
     private RedissonProperties redissonProperties;
     // Redis属性配置
     @Autowired
 
 
     // 注入了 redisTemplate
     @Bean
     @ConditionalOnMissingBean(name = "redisTemplate")
     public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) 
         RedisTemplate<Object, Object> template = new RedisTemplate<Object, Object>();
         template.setConnectionFactory(redisConnectionFactory);
         return template;
     
 
     // 注入了 stringRedisTemplate
     @Bean
     @ConditionalOnMissingBean(StringRedisTemplate.class)
     public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) 
         StringRedisTemplate template = new StringRedisTemplate();
         template.setConnectionFactory(redisConnectionFactory);
         return template;
     
 
     // 注入了 redissonConnectionFactory redission连接工厂
     @Bean
     @ConditionalOnMissingBean(RedisConnectionFactory.class)
     public RedissonConnectionFactory redissonConnectionFactory(RedissonClient redisson) 
         return new RedissonConnectionFactory(redisson);
     
 
     // 注入了 RedissonClient 客户端
     @Bean(destroyMethod = "shutdown")
     @ConditionalOnMissingBean(RedissonClient.class)
     public RedissonClient redisson() throws IOException 
         Config config = null;
         ......
         return Redisson.create(config);
     
     ......