SpringBoot中使用注解来实现 Redis 分布式锁-学习笔记

1.背景

有些业务请求，属于耗时操作，需要加锁，防止后续的并发操作，同时对数据库的数据进行操作，需要

避免对之前的业务造成影响。

2.分析流程

使用 Redis 作为分布式锁，将锁的状态放到 Redis 统一维护，解决集群中单机 JVM 信息不互通的问

题，规定操作顺序，保护用户的数据正确。

梳理设计流程

1. 新建注解 @interface，在注解里设定入参标志

2. 增加 AOP 切点，扫描特定注解

3. 建立 @Aspect 切面任务，注册 bean 和拦截特定方法

4. 特定方法参数 ProceedingJoinPoint，对方法 pjp.proceed() 前后进行拦截

5. 切点前进行加锁，任务执行后进行删除 key

3.业务属性枚举设定

@Getter
public enum RedisLockTypeEnum {
    /**
     * 自定义 key 前缀
     */
    ONE("Business1", "Test1"),
    TWO("Business2", "Test2");

    private  String code;
    private String desc;

    RedisLockTypeEnum(String code, String desc){
        this.code = code;
        this.desc = desc;
    }
    public String getUniqueKey(String key){
        return String.format("%s:%s",this.getCode(),key);
    }
}

4.自定义redis锁注解

import com.example.redislock.enums.RedisLockTypeEnum;

import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD,ElementType.TYPE})
@Documented
public @interface RedisLockAnnotation {

    /**
     * 特定参数识别，默认取第 0 个下标
     */
    int lockFiled() default 0;
    /**
     * 超时重试次数
     */
    int tryCount() default 3;
    /**
     * 自定义加锁类型
     */
    RedisLockTypeEnum typeEnum();
    /**
     * 释放时间，秒 s 单位
     */
    long lockTime() default 30;

}

5.创建一个任务队列

import lombok.Getter;
import lombok.Setter;

@Getter
@Setter
public class RedisLockDefinitionHolder {

    /**
     * 业务唯一 key
     */
    private String businessKey;
    /**
     * 加锁时间 (秒 s)
     */
    private Long lockTime;
    /**
     * 上次更新时间（ms）
     */
    private Long lastModifyTime;
    /**
     * 保存当前线程
     */
    private Thread currentTread;
    /**
     * 总共尝试次数
     */
    private int tryCount;
    /**
     设定被拦截的注解名字
     核心切面拦截的操作
     RedisLockAspect.java 该类分成三部分来描述具体作用
     Pointcut 设定
     * 当前尝试次数
     */
    private int currentCount;

    /**
     * 更新的时间周期（毫秒）,公式 = 加锁时间（转成毫秒） / 3
     */
    private Long modifyPeriod;

    public RedisLockDefinitionHolder(String businessKey, Long lockTime, Long lastModifyTime, Thread currentTread, int tryCount) {
        this.businessKey = businessKey;
        this.lockTime = lockTime;
        this.lastModifyTime = lastModifyTime;
        this.currentTread = currentTread;
        this.tryCount = tryCount;
        this.modifyPeriod = lockTime * 1000 / 3;
    }

}

6.创建redis锁核心切面拦截

import com.example.redislock.annotation.RedisLockAnnotation;
import com.example.redislock.enums.RedisLockTypeEnum;
import com.example.redislock.task.RedisLockDefinitionHolder;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;
import java.util.Iterator;
import java.util.UUID;
import java.util.concurrent.*;


@Slf4j
@Aspect
@Component
public class RedisLockAspect {

    @Autowired
    private RedisTemplate redisTemplate;


    @Pointcut("@annotation(com.example.redislock.annotation.RedisLockAnnotation)")
    public void redisLockPC(){

    }

    @Around(value = "redisLockPC()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable{
        Method method = ((MethodSignature)pjp.getSignature()).getMethod();
        RedisLockAnnotation annotation = method.getAnnotation(RedisLockAnnotation.class);
        RedisLockTypeEnum typeEnum = annotation.typeEnum();
        Object[] params = pjp.getArgs();
        String ukString = params[annotation.lockFiled()].toString();
        String businessKey = typeEnum.getUniqueKey(ukString);
        String uniqueValue = UUID.randomUUID().toString();
        Object result =  null;
        try {
            boolean isSuccess = redisTemplate.opsForValue().setIfAbsent(businessKey, uniqueValue);
            if (!isSuccess) {
                throw new Exception("You can't do it，because another has get the lock =-=");
            }
            redisTemplate.expire(businessKey, annotation.lockTime(), TimeUnit.SECONDS);
            Thread currentThread = Thread.currentThread();
// 将本次 Task 信息加入「延时」队列中
            holderList.add(new RedisLockDefinitionHolder(businessKey, annotation.lockTime(),
                    System.currentTimeMillis(),
                    currentThread, annotation.tryCount()));
// 执行业务操作
            result = pjp.proceed();
// 线程被中断，抛出异常，中断此次请求
            if (currentThread.isInterrupted()) {
                throw new InterruptedException("You had been interrupted =-=");
            }
        } catch (InterruptedException e ) {
            log.error("Interrupt exception, rollback transaction", e);
            throw new Exception("Interrupt exception, please send request again");
        } catch (Exception e) {
            log.error("has some error, please check again", e);
        } finally {
// 请求结束后，强制删掉 key，释放锁
            redisTemplate.delete(businessKey);
            log.info("release the lock, businessKey is [" + businessKey + "]");
        }
        return result;
    }
    // 扫描的任务队列
    private static ConcurrentLinkedQueue holderList = new
            ConcurrentLinkedQueue();
    /**
     * 线程池，维护keyAliveTime
     */
    private static final ScheduledExecutorService SCHEDULER = new ScheduledThreadPoolExecutor(1,
            Executors.defaultThreadFactory());
    {
// 两秒执行一次「续时」操作
        SCHEDULER.scheduleAtFixedRate(() -> {
// 这里记得加 try-catch，否者报错后定时任务将不会再执行=-=
            Iterator iterator = holderList.iterator();
            while (iterator.hasNext()) {
                RedisLockDefinitionHolder holder = iterator.next();
// 判空
                if (holder == null) {
                    iterator.remove();
                    continue;
                }
// 判断 key 是否还有效，无效的话进行移除
                if (redisTemplate.opsForValue().get(holder.getBusinessKey()) == null) {
                    iterator.remove();
                    continue;
                }
// 超时重试次数，超过时给线程设定中断
                if (holder.getCurrentCount() > holder.getTryCount()) {
                    holder.getCurrentTread().interrupt();
                    iterator.remove();
                    continue;
                }
// 判断是否进入最后三分之一时间
                long curTime = System.currentTimeMillis();
                boolean shouldExtend = (holder.getLastModifyTime() + holder.getModifyPeriod()) <=
                        curTime;
                if (shouldExtend) {
                    holder.setLastModifyTime(curTime);
                    redisTemplate.expire(holder.getBusinessKey(), holder.getLockTime(),
                            TimeUnit.SECONDS);
                    log.info("businessKey : [" + holder.getBusinessKey() + "], try count : " +
                            holder.getCurrentCount());
                    holder.setCurrentCount(holder.getCurrentCount() + 1);
                }
            }
        }, 0, 2, TimeUnit.SECONDS);
    }
}

上述流程简单总结一下：

解析注解参数，获取注解值和方法上的参数值

redis 加锁并且设置超时时间

将本次 Task 信息加入「延时」队列中，进行续时，方式提前释放锁

加了一个线程中断标志

结束请求，finally 中释放锁

续时操作

这里用了 ScheduledExecutorService ，维护了一个线程，不断对任务队列中的任务进行判断和延长超时

时间

7.开始测试

import com.example.redislock.annotation.RedisLockAnnotation;
import com.example.redislock.enums.RedisLockTypeEnum;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@Slf4j
@RestController
public class TestController {

    @GetMapping("/testRedisLock")
    @RedisLockAnnotation(typeEnum = RedisLockTypeEnum.ONE,lockTime = 3)
    public String testRedisLock(@RequestParam("userId") Long userId){
        try {
            log.info("before");
            Thread.sleep(10000);
            log.info("after");
        }catch (Exception e){
            log.info("has some error", e);
        }
        return null;
    }
}

8.测试结果

如果redis加锁时间内多次请求会出现错误提示