Spring Boot集成Redisson实现分布式锁

素颜马尾好姑娘i 2023-10-13 17:36 20阅读 0赞

## Spring Boot集成Redisson实现分布式锁 ##

![在这里插入图片描述][f0e7a9b7f15b4e03b3f4263e19c132a4.png]

在分布式系统中，为保证数据的一致性和并发访问的安全性，我们经常会使用分布式锁来协调多个节点之间对共享资源的访问。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!";
        }
    }

上述代码展示了如何在Spring Boot的Controller中使用分布式锁。当客户端请求`/doSomething`接口时，会调用`doSomethingWithLock()`方法，并在获取到锁后执行加锁保护的业务逻辑。

### 总结 ###

通过以上步骤，我们成功地在Spring Boot项目中集成了Redisson，并实现了分布式锁的功能。分布式锁可以保证多个节点对共享资源的安全访问，避免了并发访问带来的数据不一致和安全问题。在实际开发中，我们可以根据具体业务需求，使用分布式锁来保证数据的一致性和并发访问的安全性。

[f0e7a9b7f15b4e03b3f4263e19c132a4.png]: https://img-blog.csdnimg.cn/f0e7a9b7f15b4e03b3f4263e19c132a4.png