用注解实现redis分布式锁，防止短时间内重复请求

朴灿烈づ我的快乐病毒、 2023-01-06 12:00 176阅读 0赞

用注解实现redis分布式锁，防止短时间内重复请求：  
    可以写一个进程锁注解，在需要方式重复请求的方法上加上即可，结合切面  
    这个工具类使用了lua脚本直接加锁解锁，业务超时，没有操作超时---脚本中没有，但是切面中有

基于注解的切面优于基于类路径的切面，使用方便可以在controller,service,dao任意地方使用  
此示例以方法名，类名为key,可以从切面获取参数加入也作为key---避免一个方法只能调用一次

private String getKey(OperationLock operationLock, ProceedingJoinPoint joinPoint, Method method) \{  
        if (StringUtils.isEmpty(operationLock.key())) \{  
            //method.getName()理论上存在重复可能，最好手动设置锁的名称  
            Object\[\] args = joinPoint.getArgs();  
            String id ="";  
            if(null != args && args.length>0)\{  
                id =args\[0\]+"";  
            \}  
            return joinPoint.getTarget().getClass().getName() + "." + method.getName()+"."\+id;  
        \}  
        return operationLock.key();  
    \}  
      
release = false---相当于操作超时---对于异步方法使用，固定时间才unlock

@ApiOperation(value = "test", notes = "test")  
    @OperationLock(desc = "test", time = 300)  
    @GetMapping("/test")  
    public aaaResult<Object> test(@RequestParam("dataVersion") String dataVersion, @RequestParam("posMenuVersion") String posMenuVersion, @RequestParam("sequenceNo") String sequenceNo) throws SQLException \{  
        int updateInt = test.test(dataVersion, posMenuVersion, sequenceNo);  
        return new aaaResult<>(updateInt);  
    \}  
      
\---  
注解  
    
      
    package com.aaa.cn.aaa.aaa.product.business.lock;

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

@Documented  
@Retention(RetentionPolicy.RUNTIME)  
@Target(\{ElementType.METHOD\})  
public @interface OperationLock \{  
    /\*\*  
     \* redis锁名称 默认类名.方法名 如com.aaa.cn.aaa.aaa.product.business.lock.OperationLock.name  
     \* 异步操作需要主动释放锁时，应该自己赋值，否则释放锁是不知道锁的名称  
     \* @return  
     \*/  
    String key() default "";

/\*\*  
     \* 业务描述  
     \*  
     \* @return  
     \*/  
    String desc();

/\*\*  
     \* 自动释放时间 默认5秒  
     \*  
     \* @return  
     \*/  
    long time() default 5L;

/\*\*  
     \* 方法结束是否释放锁，默认释放。  
     \* 异步方法时传false，应该根据时间或者自己主动释放  
     \*  
     \* @return  
     \*/  
    boolean release() default true;

/\*\*  
     \* 错误信息，不为空时，将返回作为国际化的key，需要在portal中配置国际化  
     \*  
     \* @return  
     \*/  
    String msg() default "";

\---  
切面

package com.aaa.cn.aaa.aaa.product.business.lock;

import com.aaa.cn.aaa.aaa.product.business.constant.aaaConstants;  
import com.aaa.cn.aaa.aaa.product.common.utils.DateUtils;  
import com.aaa.cn.aaa.aaa.product.common.utils.StringUtils;  
import com.movitech.generics.framework.context.RequestContextProxy;  
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.jetbrains.annotations.NotNull;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;  
import java.util.Date;

@Component  
@Aspect  
@Slf4j  
public class OperationLockAspect \{  
    /\*\*  
     \* 切点  
     \*/  
    @Pointcut("@annotation(com.aaa.cn.aaa.aaa.product.business.lock.OperationLock)")  
    public void operationLockAdvice() \{  
    \}

@Autowired  
    private RedisOperationLock redisLock;

/\*\*  
     \* 环绕通知  
     \*  
     \* @param joinPoint  
     \* @return  
     \* @throws Throwable  
     \*/  
    @Around("operationLockAdvice()")  
    public Object operationAroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable \{  
        Method method = ((MethodSignature) joinPoint.getSignature()).getMethod();  
        OperationLock operationLock = method.getAnnotation(OperationLock.class);  
        String key = getKey(operationLock, joinPoint, method);  
        //操作信息  
        Operation operation = buildOperation(operationLock);  
        //1加锁  
        redisLock.lock(key, operation, operationLock.time());  
        //2执行方法  
        Object result;  
        try \{  
            result = joinPoint.proceed();  
        \} catch (Throwable throwable) \{  
            //3执行失败，不管release的值，直接释放锁。然后往上抛  
            redisLock.unlock(key);  
            throw throwable;  
        \}  
        //3执行成功 释放锁  
        if (operationLock.release()) \{  
            redisLock.unlock(key);  
        \}  
        return result;

@NotNull  
    private Operation buildOperation(OperationLock operationLock) \{  
        String userName = RequestContextProxy.getRequestUsername();  
        userName = userName == null ? aaaConstants.SystemCode.MENU\_MANAGER : userName;  
        return new Operation(operationLock.desc(), userName, DateUtils.dateToString(new Date(), DateUtils.SQL\_TIME), operationLock.msg());  
    \}

private String getKey(OperationLock operationLock, ProceedingJoinPoint joinPoint, Method method) \{  
        if (StringUtils.isEmpty(operationLock.key())) \{  
            //method.getName()理论上存在重复可能，最好手动设置锁的名称  
            return joinPoint.getTarget().getClass().getName() + "." + method.getName();  
        \}  
        return operationLock.key();  
    \}  
\}

\----  
redis锁

package com.aaa.cn.aaa.aaa.product.business.lock;

import com.alibaba.fastjson.JSON;  
import com.aaa.cn.aaa.aaa.product.business.constant.ResultMsg;  
import com.aaa.cn.aaa.aaa.product.business.exception.BusinessException;  
import com.aaa.cn.aaa.aaa.product.common.utils.StringUtils;  
import com.aaa.cn.aaa.redis.autoconfigure.RedisService;  
import lombok.extern.slf4j.Slf4j;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.data.redis.connection.ReturnType;  
import org.springframework.data.redis.core.RedisCallback;  
import org.springframework.stereotype.Component;

import java.nio.charset.Charset;

@Slf4j  
@Component  
public class RedisOperationLock \{  
    private static final String LOCK\_SUCCESS = "success";  
    /\*\*  
     \* 加锁脚本---参数用占位形式  
     \*/  
    private static final String LOCK\_LUA = "if redis.call('setnx', KEYS\[1\], ARGV\[1\]) == 1 then redis.call('expire', KEYS\[1\], ARGV\[2\]) return 'success' else return redis.call('get', KEYS\[1\]) end";  
    /\*\*  
     \* 释放锁脚本  
     \*/  
    private static final String UNLOCK\_LUA = "if redis.call('exists',KEYS\[1\]) == 1 then  return redis.call('del',KEYS\[1\]) else  return 0 end ";

@Autowired  
    private RedisService redisService;

/\*\*  
     \* 加锁，如果加锁失败抛出异常  
     \* redis连接失败或者超时，会导致获取锁失败  
     \*  
     \* @param key       key  
     \* @param operation value  
     \* @param expire    过期时间秒  
     \*/  
    public void lock(String key, Operation operation, long expire) \{  
        String value = JSON.toJSONString(operation);  
        String result;  
        try \{  
            //lua脚本，判断key是否存，如果存在返回key对应的value；  
            //如果不存在，设置key=value,同时设置过期时间，返回'success'字符串  ---各种参数的字节码转化  
            RedisCallback<byte\[\]> callback = (connection) -> connection.eval(LOCK\_LUA.getBytes(), ReturnType.VALUE, 1,  
                    new byte\[\]\[\]\{key.getBytes(Charset.forName("UTF-8")), value.getBytes(Charset.forName("UTF-8")), String.valueOf(expire).getBytes(Charset.forName("UTF-8"))\});  
            result = new String((byte\[\]) this.redisService.execute(callback));  
        \} catch (Exception e) \{  
            //捕获redis的操作异常，抛出异常  
            log.error("\[redis操作锁\] 获取锁异常key=\{\} value=\{\}", key, value, e);  
            throw new BusinessException(ResultMsg.FAIL);  
        \}  
        //判断redis的返回结果，如果加锁失败，就解析结果，将结果以异常的形式抛出  
        if (!LOCK\_SUCCESS.equals(result)) \{  
            operation = JSON.parseObject(result, Operation.class);  
            log.warn("\[redis操作锁\] 获取锁失败key=\{\},msg=\{\}", key, result);  
            if (StringUtils.isEmpty(operation.getMsg())) \{  
                //此异常需要前端特殊处理  
                throw new BusinessException(ResultMsg.OPERATION\_IN\_PROGRESS\_DEFAULT.getCode(), operation.toString(), null);  
            \} else \{  
                //此异常需要配置国际化  
                throw new BusinessException(ResultMsg.OPERATION\_IN\_PROGRESS.getCode(), operation.getMsg(), null);  
            \}

\}  
        log.info("\[redis操作锁\] 获取锁成功key=\{\}，expire=\{\}", key, expire);  
    \}

/\*\*  
     \* 释放锁  
     \*  
     \* @param key key  
     \* @return true释放成功 false释放失败  
     \*/  
    public boolean unlock(String key) \{  
        boolean result = false;  
        try \{  
            RedisCallback<Boolean> callback = (connection) -> (Boolean) connection.eval(UNLOCK\_LUA.getBytes(), ReturnType.BOOLEAN, 1, new byte\[\]\[\]\{key.getBytes(Charset.forName("UTF-8"))\});  
            result = (Boolean) this.redisService.execute(callback);  
        \} catch (Exception e) \{  
            //捕获redis的操作异常，这里不继续往上抛，可以根据返回值判断  
            log.error("\[redis操作锁\] 释放锁异常key=\{\}", key, e);  
        \}  
        log.info("\[redis操作锁\] 释放锁key=\{\},result=\{\}", key, result);  
        return result;  
    \}