springboot redission 分布式锁

Spring Boot中使用Redisson实现分布式锁的方法如下：

1. 首先，需要在项目中引入Redisson依赖。在pom.xml文件中添加以下依赖：

```xml
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.16.4</version>
</dependency>
```

2. 在Spring Boot配置文件（如application.yml）中配置Redisson连接信息：

```yaml
redisson:
  config:
    singleServerConfig:
      address: "redis://127.0.0.1:6379"
      timeout: 10000
      pingTimeout: 10000
```

3. 创建一个Redisson配置类，用于初始化RedissonClient实例：

```java
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;

@Configuration
public class RedissonConfig {

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

    @Value("${redisson.config.singleServerConfig.timeout}")
    private int timeout;

    @Value("${redisson.config.singleServerConfig.pingTimeout}")
    private int pingTimeout;

    @Bean
    public RedissonClient redissonClient() {
        Config config = new Config();
        config.useSingleServer()
                .setAddress(address)
                .setTimeout(timeout)
                .setPingTimeout(pingTimeout);
        return Redisson.create(config);
    }
}
```

4. 使用RedissonClient实例获取分布式锁：

```java
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

@Service
public class DistributedLockService {

    @Autowired
    private RedissonClient redissonClient;

    public void lock(String lockKey, Runnable task, long waitTime, long leaseTime) {
        RLock lock = redissonClient.getLock(lockKey);
        try {
            // 尝试获取锁，等待时间waitTime，锁过期时间leaseTime
            if (lock.tryLock(waitTime, leaseTime, TimeUnit.SECONDS)) {
                try {
                    task.run();
                } finally {
                    lock.unlock();
                }
            } else {
                System.out.println("获取锁失败");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }
}
```

5. 在需要使用分布式锁的地方调用DistributedLockService的lock方法：

```java
@Autowired
private DistributedLockService distributedLockService;

public void someMethod() {
    String lockKey = "someLockKey";
    distributedLockService.lock(lockKey, () -> {
        // 需要加锁执行的代码
    }, 10, 60);
}
```

以上代码示例展示了如何在Spring Boot项目中使用Redisson实现分布式锁。