SpringBoot 使用Redis分布式锁

1.redis配置文件

package cn.qg.ec.config.redisson;

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;

import java.io.IOException;

/**
 * @author suziqing
 * redis 配置
 */
@Configuration
public class MyRedissonConfig {

    @Value("${redisson.config}")
    private String configurationFiles;


    @Bean(destroyMethod="shutdown")
    RedissonClient redisson() throws IOException {
        //1、创建配置
//        Config config = new Config();
//        config.useSingleServer().setAddress("172.24.17.119:6371");

        //Config config = Config.fromYAML(new ClassPathResource("redisson.yml").getInputStream());
        Config config = Config.fromYAML(new ClassPathResource(configurationFiles).getInputStream());
        return Redisson.create(config);
    }
    
}

2.yml配置文件

clusterServersConfig:
  # 连接空闲超时 如果当前连接池里的连接数量超过了最小空闲连接数，而同时有连接空闲时间超过了该数值，那么这些连接将会自动被关闭，并从连接池里去掉。时间单位是毫秒。
  idleConnectionTimeout: 10000
  pingTimeout: 1000
  # 连接超时
  connectTimeout: 10000
  # 命令等待超时
  timeout: 3000
  # 命令失败重试次数
  retryAttempts: 3
  # 命令重试发送时间间隔
  retryInterval: 1500
  # 重新连接时间间隔
  reconnectionTimeout: 3000
  # failedAttempts
  failedAttempts: 3
  # 密码
  password: redis
  # 单个连接最大订阅数量
  subscriptionsPerConnection: 5
  # 客户端名称
  clientName: null
  #负载均衡算法类的选择  默认轮询调度算法RoundRobinLoadBalancer
  loadBalancer: !<org.redisson.connection.balancer.RoundRobinLoadBalancer> {}
  slaveSubscriptionConnectionMinimumIdleSize: 1
  slaveSubscriptionConnectionPoolSize: 50
  # 从节点最小空闲连接数
  slaveConnectionMinimumIdleSize: 32
  # 从节点连接池大小
  slaveConnectionPoolSize: 64
  # 主节点最小空闲连接数
  masterConnectionMinimumIdleSize: 32
  # 主节点连接池大小
  masterConnectionPoolSize: 64
  # 只在从服务节点里读取
  readMode: "SLAVE"
  # 主节点信息
  nodeAddresses:
    - "redis://127.0.0.1:6371"
    - "redis://127.0.0.1:6372"
    - "redis://127.0.0.1:6373"
    - "redis://127.0.0.1:6374"
    - "redis://127.0.0.1:6375"
    - "redis://127.0.0.1:6376"
  #集群扫描间隔时间 单位毫秒
  scanInterval: 1000
threads: 0
nettyThreads: 0
codec: !<org.redisson.codec.JsonJacksonCodec> {}

3.pom配置文件

 <!--redisson客户端-->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.7.5</version>
        </dependency>

4.测试

@RequestMapping("/redisson")
    public String testRedisson(){
        //获取分布式锁，只要锁的名字一样，就是同一把锁
        RLock redissonLock = redissonClient.getLock("lock");
        //加锁（阻塞等待），默认过期时间是30秒
        redissonLock.lock();
        try{
            //如果业务执行过长，Redisson会自动给锁续期
            Thread.sleep(1000);
            System.out.println("加锁成功，执行业务逻辑");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //为了能应对更大的并发量、判断是否同一个线程
            if(redissonLock.isLocked()){
                if(redissonLock.isHeldByCurrentThread()){
                    //解锁，如果业务执行完成，就不会继续续期，即使没有手动释放锁，在30秒过后，也会释放锁
                    redissonLock.unlock();
                }
            }
        }
        return "Hello Redisson!";
    }