在Spring Boot中实现加锁操作通常可以利用Redis作为分布式锁的实现工具，而下面我们要介绍的就是通过注解的方式来实现对于某些接口来进行加锁操作。下面我们就来一起看看吧。

引入Redis依赖

在SpringBoot项目中添加Redis依赖配置如下所示。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

接下来就是需要创建一个注解，用来进行加锁操作。并且这个注解是用于在方法级别上的，还要确保在同一时刻只能有一个线程执行标注了该注解的方法。

创建加锁注解

根据上面的要求，我们来定义一个RedisLock的注解，用来对加锁操作进行标注。如下所示。

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 RedisLock {

    /**
     * Redis 锁的 key，支持 SpEL 表达式
     */
    String value() default "";

    /**
     * 锁的过期时间，单位秒，默认 10 秒
     */
    long expire() default 10L;

    /**
     * 尝试加锁的时间，单位毫秒，默认 100 毫秒
     */
    long timeout() default 100L;
}

实现加锁的切面

创建好注解之后，接下来就是需要创建注解对应的切面类，通过这个切面类来控制加锁操作的逻辑，并且通过AOP方法来在执行前进行加锁，在执行后进行锁的释放操作，如下所示。

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import java.util.Objects;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

@Aspect
@Component
public class RedisLockAspect {

    @Autowired
    private StringRedisTemplate redisTemplate;

    @Around("@annotation(redisLock)")
    public Object around(ProceedingJoinPoint joinPoint, RedisLock redisLock) throws Throwable {
        String lockKey = redisLock.value();
        if (lockKey.isEmpty()) {
            throw new IllegalArgumentException("RedisLock value must not be empty");
        }

        // 构造锁的唯一标识，使用UUID确保唯一性
        String lockValue = UUID.randomUUID().toString();

        try {
            // 尝试加锁
            boolean success = redisTemplate.opsForValue().setIfAbsent(lockKey, lockValue, redisLock.expire(), TimeUnit.SECONDS);
            if (!success) {
                throw new IllegalStateException("Failed to acquire lock for key: " + lockKey);
            }

            // 执行方法
            return joinPoint.proceed();

        } finally {
            // 释放锁
            String currentValue = redisTemplate.opsForValue().get(lockKey);
            if (Objects.equals(currentValue, lockValue)) {
                redisTemplate.delete(lockKey);
            }
        }
    }
}

有兴趣的读者可以考虑一下这样实现分布式锁会出现哪些问题，并且如何避免这些问题的出现。

使用加锁注解

这样，我们就可以在需要进行加锁操作的方法上通过@RedisLock 注解来进行标注，如下所示，我们在Service层对象的方法上添加上这个注解。

import org.springframework.stereotype.Service;

@Service
public class MyService {

    @RedisLock(value = "myLockKey", expire = 30L, timeout = 200L)
    public void myMethod() {
        // 需要加锁保护的代码逻辑
        System.out.println("Executing protected method with Redis lock...");
    }
}

在上面的例子中，当有逻辑调用了myMethod()方法的时候，就会进入到注解的逻辑中，先尝试去获取一个名为myLockKey的Redis锁，并且锁的过期时间为30秒，尝试加锁的超时时间为200毫秒，如果成功获取锁，则执行方法体逻辑；如果获取锁失败，则抛出异常或进行其他处理，也就是进入到一个新的处理等待逻辑中。

但是这里会存在几个问题

• 锁的续约
• 锁的超时等待
• 锁的重入
• 锁的异常释放

有兴趣的读者可以考虑一下，通过上面的这种方式实现分布式锁的话看上去使用确实是非常的简单，在操作的方法上通过注解的方式就可以实现加锁操作，不需要在去处理非常复杂的加锁逻辑，使得代码更容易维护。

但是在实际使用的过程中可能会遇到上面这些问题，那么在实际使用的过程中我们应该如何避免这些问题呢。这里我们不做详细的说明，有兴趣的读者可以在评论区讨论一下，笔者会在后续的分享中介绍到关于分布式锁相关的内容，多多关注，敬请期待吧！