【SpringBoot】SpringBoot 整合Redisson

　　Redis安装参考：【Redis】安装及简单使用

一、Redission整合

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);
    }
    ......
}

　　可以看到配置类中注入了Redission客户端对象 RedissonClient