springboot redission 自定义注解实现分布式锁

在Spring Boot中，可以使用Redisson作为分布式锁的实现。以下是一个简单的示例：

1. 添加Redisson依赖到`pom.xml`文件中：

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

2. 在`application.properties`文件中配置Redis连接信息：

```properties
spring.data.redis.host=localhost
spring.data.redis.port=6379
```

3. 在`java`文件中配置Redis连接信息：

```properties

package com.solo.platform.common.config;

import lombok.Data;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author: cc
 * @date: 2023/4/09
 * @description:
 */
@Configuration
@ConfigurationProperties(prefix = "spring.data.redis")
@Data
public class RedissonConfig {
    private String host;
    private String port;
    private Integer database;
    private String password;

    /**
     * Redis URI的写法是：redis://[:password@]host[:port][/db-number][?option=value]。
     * <p>
     * 其中：
     * password：可选，用于连接Redis服务器的密码。
     * host：必填，Redis服务器的主机名或IP地址。
     * port：可选，Redis服务器的端口号，默认为6379。
     * db-number：可选，要连接的数据库编号，默认为0。
     * option：可选，连接选项，例如timeout、ssl等。
     *
     * @return
     */
    @Bean
    public RedissonClient redisClient() {
        // 1.创建配置
        Config config = new Config();
        String redisAddress = String.format("redis://:%s@%s:%s/%s", password, host, port, database);
        config.useSingleServer().setAddress(redisAddress);
//                .setDatabase(database);
        // 2.创建实例
        RedissonClient redisson = Redisson.create(config);
        return redisson;
    }

}

```

4. 创建一个`DistributedLock`类，用于封装分布式锁的逻辑：

```java
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 DistributedLock {

    @Autowired
    private RedissonClient redissonClient;

    /**
     * 获取锁
     * @param lockKey 锁的key
     * @return RLock对象
     */
    public RLock getLock(String lockKey) {
        return redissonClient.getLock(lockKey);
    }
}
```

5. 创建一个自定义注解`DistributedLockAnnotation`：

```java
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface DistributedLockAnnotation {
    String key() default "";
    long waitTimeout() default 0;
    long leaseTimeout() default 0;
}
```

6. 创建一个AOP切面类`DistributedLockAspect`，用于拦截带有`@DistributedLockAnnotation`注解的方法：

```java
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.redisson.api.RLock;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;

@Aspect
@Component
public class DistributedLockAspect {

    @Autowired
    private DistributedLock distributedLock;

    @Around("@annotation(distributedLockAnnotation)")
    public Object around(ProceedingJoinPoint joinPoint, DistributedLockAnnotation distributedLockAnnotation) throws Throwable {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        String key = distributedLockAnnotation.key();
        long waitTimeout = distributedLockAnnotation.waitTimeout();
        long leaseTimeout = distributedLockAnnotation.leaseTimeout();

        RLock lock = distributedLock.getLock(key);
        try {
            lock.lock(waitTimeout, leaseTimeout, TimeUnit.SECONDS);
            return joinPoint.proceed();
        } finally {
            lock.unlock();
        }
    }
}
```

6. 在需要使用分布式锁的地方，添加`@DistributedLockAnnotation`注解：

```java
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TestController {

    @DistributedLockAnnotation(key = "test_lock", waitTimeout = 10, leaseTimeout = 10)
    @GetMapping("/test")
    public String test() {
        // 执行业务逻辑
        return "success";
    }
}
```

以上示例展示了如何在Spring Boot中使用Redisson和自定义注解实现分布式锁。在实际项目中，可以根据需要对`DistributedLock`类和`DistributedLockAspect`类进行扩展和优化。