【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() + ":\t 獲得鎖");
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                System.out.println(Thread.currentThread().getName() + ":\t 釋放鎖");
                lock.unlock();
            }
        }).start();


        new Thread(() -> {
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + ":\t 獲得鎖");
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                System.out.println(Thread.currentThread().getName() + ":\t 釋放鎖");
                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