Spring Boot集成Redisson实现分布式锁-蒲公英云

Spring Boot集成Redisson实现分布式锁

在这里插入图片描述

在分布式系统中，为保证数据的一致性和并发访问的安全性，我们经常会使用分布式锁来协调多个节点之间对共享资源的访问。Redisson是一个基于Redis的Java驻内存数据网格（In-Memory Data Grid）和分布式锁服务，它提供了强大而灵活的分布式锁实现。

本文将介绍如何使用Spring Boot集成Redisson来实现分布式锁，并展示一个示例代码来演示其用法。

步骤一：添加依赖

首先，我们需要在Spring Boot项目中添加Redisson的依赖。在pom.xml文件中添加以下依赖：

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

其中，{redisson-version}是Redisson的版本号，你可以根据需要进行替换。

步骤二：配置Redisson

单机模式

接下来，我们需要在Spring Boot项目的配置文件中进行Redisson的配置。在application.properties或application.yml文件中添加以下配置：

spring:
  redis:
    host: localhost
    port: 6379
    database: 1
    password: 
# 其他Redis相关配置...

这里的配置项spring.redis.host和spring.redis.port分别指定了Redis的主机和端口，你需要根据实际情况进行配置。除了这两个必填项，你还可以根据需要配置其他的Redis相关配置项。

添加配置信息类：

/**
 * 分布式锁配置
 * 单机模式
 */
@Configuration
public class RedissonConfig {
    @Value("${spring.redis.host}")
    private String redisHost;
    @Value("${spring.redis.port}")
    private String redisPort;
    @Value("${spring.redis.password}")
    private String password;
    @Value("${spring.redis.database}")
    private int database;
    @Bean(destroyMethod = "shutdown")
    public RedissonClient redissonClient() {
        Config config = new Config();
        config.useSingleServer()
                .setAddress("redis://" + redisHost + ":" + redisPort)
                .setPassword(password)
                .setDatabase(database)
        ;
        return Redisson.create(config);
    }
}

集群模式

以下是如何在 Spring Boot 的 application.yaml 配置文件中配置 Redisson 的集群配置：

spring:
  redisson:
    cluster-servers-config:
      # 最大空闲连接超时时间（毫秒）
      idle-connection-timeout: 10000
      # 发送心跳包的超时时间（毫秒）
      ping-timeout: 1000
      # 连接超时时间（毫秒）
      connect-timeout: 10000
      # 读写操作的超时时间（毫秒）
      timeout: 3000
      # 失败的重试次数
      retry-attempts: 3
      # 重试的间隔时间（毫秒）
      retry-interval: 1500
      # 连接密码
      password: null
      # 每个连接允许的最大订阅数
      subscriptions-per-connection: 5
      # 客户端名称
      client-name: null
      # 负载均衡策略（默认为轮询）
      load-balancer: !<org.redisson.connection.balancer.RoundRobinLoadBalancer> {
    }
      # 读取模式（默认为从从服务器读取）
      read-mode: "SLAVE"
      # 订阅模式（默认为从从服务器订阅）
      subscription-mode: "SLAVE"
      # Redis 集群节点地址列表
      node-addresses:
        - "redis://127.0.0.1:7000"
        - "redis://127.0.0.1:7001"
        - "redis://127.0.0.1:7002"

配置方法一

然后，你可以创建一个 Spring Boot 的配置类，使用 @ConfigurationProperties 注解将配置文件中的 Redisson 配置映射到一个自定义的配置类中：

@Configuration
public class RedissonClusterConfig {
    @Bean
    @ConfigurationProperties(prefix = "spring.redisson.cluster-servers-config")
    public ClusterServersConfig redissonConfig() {
        return new ClusterServersConfig();
    }
}

在上面的配置类中，@ConfigurationProperties(prefix = “spring.redisson.cluster-servers-config”) 注解将会自动将 application.yaml 中以 spring.redisson.cluster-servers-config 为前缀的配置项映射到 ClusterServersConfig 类中。

接着，你可以在其他组件中注入这个 ClusterServersConfig 配置对象，并在创建 RedissonClient 时使用它：

@Configuration
public class RedissonConfig {
    @Autowired
    private ClusterServersConfig clusterServersConfig;
    @Bean(destroyMethod = "shutdown")
    public RedissonClient redissonClient() {
        Config config = new Config();
        config.useClusterServers().setAll(clusterServersConfig);
        return Redisson.create(config);
    }
}

2. 配置方法二

@Configuration
public class RedissonConfig {
    @Value("${spring.redisson.cluster-servers-config.idle-connection-timeout}")
    private int idleConnectionTimeout;
    @Value("${spring.redisson.cluster-servers-config.ping-timeout}")
    private int pingTimeout;
    @Value("${spring.redisson.cluster-servers-config.connect-timeout}")
    private int connectTimeout;
    @Value("${spring.redisson.cluster-servers-config.timeout}")
    private int timeout;
    @Value("${spring.redisson.cluster-servers-config.retry-attempts}")
    private int retryAttempts;
    @Value("${spring.redisson.cluster-servers-config.retry-interval}")
    private int retryInterval;
    @Value("${spring.redisson.cluster-servers-config.password:#{null}}")
    private String password;
    @Value("${spring.redisson.cluster-servers-config.subscriptions-per-connection}")
    private int subscriptionsPerConnection;
    @Value("${spring.redisson.cluster-servers-config.client-name:#{null}}")
    private String clientName;
    @Autowired
    private ClusterServersConfig clusterServersConfig;
    @Bean(destroyMethod = "shutdown")
    public RedissonClient redissonClient() {
        Config config = new Config();
        config.useClusterServers().setAll(clusterServersConfig);
        return Redisson.create(config);
    }
    @Bean
    public ClusterServersConfig clusterServersConfig() {
        ClusterServersConfig clusterServersConfig = new ClusterServersConfig();
        clusterServersConfig.setIdleConnectionTimeout(idleConnectionTimeout);
        clusterServersConfig.setPingTimeout(pingTimeout);
        clusterServersConfig.setConnectTimeout(connectTimeout);
        clusterServersConfig.setTimeout(timeout);
        clusterServersConfig.setRetryAttempts(retryAttempts);
        clusterServersConfig.setRetryInterval(retryInterval);
        clusterServersConfig.setPassword(password);
        clusterServersConfig.setSubscriptionsPerConnection(subscriptionsPerConnection);
        clusterServersConfig.setClientName(clientName);
        return clusterServersConfig;
    }
}

通过这种方式，你可以将 Redisson 配置信息放入 Spring Boot 的 application.yaml 配置文件中，并且通过 Spring Boot 提供的自动配置功能将其映射到相应的配置类中，从而更加方便地集成 Redisson 到你的应用程序中。

步骤三：实现分布式锁

在Spring Boot项目中，我们可以通过org.redisson.api.RLock接口来使用Redisson实现分布式锁。下面是一个简单的分布式锁示例代码：

import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class DistributedLockExample {
    @Resource
    private RedissonClient redissonClient;
    public void doSomethingWithLock() {
        // 获取一个分布式锁
        RLock lock = redissonClient.getLock("myLock");
        try {
            // 尝试加锁，最多等待3秒，上锁后10秒自动解锁
            boolean locked = lock.tryLock(3, 10, TimeUnit.SECONDS);
            if (locked) {
                // 获取锁成功，执行需要加锁保护的业务逻辑
                // ...
            } else {
                // 获取锁失败，处理获取锁失败的逻辑
                // ...
            }
        } catch (InterruptedException e) {
            // 处理异常情况
            // ...
        } finally {
            // 释放自己的锁
            if(lock != null && lock.isHeldByCurrentThread()){
                lock.unlock();
            }
        }
    }
}

在上述代码中，我们通过注入RedissonClient实例来获取一个分布式锁对象RLock。然后，我们使用tryLock()方法尝试加锁，并指定等待锁的最大时间和锁的自动解锁时间。如果获取锁成功，我们可以执行需要加锁保护的业务逻辑；如果获取锁失败，我们可以处理获取锁失败的逻辑。最后，我们在finally块中释放锁。

步骤四：使用分布式锁

在需要使用分布式锁的地方，我们可以直接调用DistributedLockExample中的doSomethingWithLock()方法，即可实现对共享资源的安全访问。

@RestController
public class SomeController {
    @Autowired
    private DistributedLockExample distributedLockExample;
    @GetMapping("/doSomething")
    public String doSomething() {
        distributedLockExample.doSomethingWithLock();
        return "Do something with lock successfully!";
    }
}