切面实现Redis锁

参考: 使用redis+切面完成分布式锁_辉家大少的博客-CSDN博客_分布式锁 切面

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库时根据此值进行区分
    boolean openApplicationPrefix() default true;

    // 锁前缀
    String lockPrefix() default "";

    // 方法参数名（用于取参数名的值与锁前缀拼接成锁名），尽量不要用对象map等，对象会toString后与锁前缀拼接
    String lockParameter() default "";

    // 自动解锁时间 （秒）
    long autoUnlockTime() default 10L;

    // 加锁失败重试次数
    int retryNum() default 0;

    // 加锁失败，重试等待时间 （毫秒）
    long retryWait() default 200L;

}

import com.framework.exception.HandleException;
import com.framework.redis.FetRedisManager;
import com.framework.utils.Asrt;
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.context.EnvironmentAware;
import org.springframework.core.env.Environment;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.Arrays;
import java.util.List;

/**
 * redis锁切面.
 * <p>
 * 实现了EnvironmentAware接口重写setEnvironment方法后，在工程启动时可以获得application.properties的配置文件配置的属性值。
 */
@Aspect
@Component
@Slf4j
public class RedisLockAspect implements EnvironmentAware {

    private Environment environment;

    private String application_prefix;

    @Override
    public void setEnvironment(Environment environment) {
        this.environment = environment;
        this.application_prefix = this.environment.resolvePlaceholders("${spring.application.name}");
    }

    @Resource
    private FetRedisManager fetRedisManager;

    private SpelExpressionParser spelExpressionParser = new SpelExpressionParser();

    @Pointcut("@annotation(com.hongshi.act.annotation.RedisLock) && @annotation(redisLock)")
    public void pointcut(RedisLock redisLock) {
    }

    @Around(value = "pointcut(redisLock)")
    public Object around(ProceedingJoinPoint proceeding, RedisLock redisLock) throws Throwable {
        String lockName = this.getLockName(proceeding, redisLock);
        if (Asrt.isNull(lockName)) {
            log.error("锁名不能为空");
            throw new HandleException("登录超时，请刷新重试");
        }
        if (this.lock(lockName, redisLock)) {
            return this.proceedingProceedAndUnlock(proceeding, lockName);
        }
        log.error("已经被锁");
        throw new HandleException("登录超时，请刷新重试");
    }

    private boolean lock(String lockName, RedisLock redisLock) throws InterruptedException {
        long autoUnlockTime = redisLock.autoUnlockTime();
        if (this.fetRedisManager.lock(lockName, 1, autoUnlockTime)) {
            return true;
        }
        /** ====================
         *    重试加锁
         * =====================
         */

        long retryNum = redisLock.retryNum();
        long retryWait = redisLock.retryWait();
        if (retryNum <= 0) {
            if (log.isInfoEnabled()) {
                log.info("不重试 key:{}", lockName);
            }
            return false;
        }
        int fail_count = 1;
        while (fail_count <= retryNum) {
            Thread.sleep(retryWait);   // 等待指定时间ms
            if (this.fetRedisManager.lock(lockName, 1, autoUnlockTime)) {
                return true;
            }
            if (log.isInfoEnabled()) {
                log.info("已经加锁:{} 正在重试[{},{}],重试间隔{}毫秒", lockName, fail_count, retryNum, retryWait);
            }
            fail_count++;
        }
        return false;
    }

    /**
     * 继续执行程序，完成后解锁
     *
     * @param proceeding 进行
     * @param lockName   锁的名字
     * @return {@link Object}
     * @throws Throwable throwable
     */
    private Object proceedingProceedAndUnlock(ProceedingJoinPoint proceeding, String lockName) throws Throwable {
        if (log.isInfoEnabled()) {
            log.info("加锁成功 key:{}", lockName);
        }
        try {
            return proceeding.proceed();
        } finally {
            this.fetRedisManager.unlock(lockName);
            if (log.isInfoEnabled()) {
                log.info("解锁成功 key:{}", lockName);
            }
        }
    }

    /**
     * 解析锁名称
     *
     * @param proceeding
     * @return
     */
    private String getLockName(ProceedingJoinPoint proceeding, RedisLock redisLock) {
        //获取方法的参数名和参数值
        MethodSignature methodSignature = (MethodSignature) proceeding.getSignature();
        List<String> paramNameList = Arrays.asList(methodSignature.getParameterNames());
        List<Object> paramList = Arrays.asList(proceeding.getArgs());

        //将方法的参数名和参数值一一对应的放入上下文中
        EvaluationContext evaluationContext = new StandardEvaluationContext();
        for (int i = 0; i < paramNameList.size(); i++) {
            evaluationContext.setVariable(paramNameList.get(i), paramList.get(i));
        }

        String lockPrefix = redisLock.lockPrefix();
        String lockParameter = redisLock.lockParameter();
        // 解析SpEL表达式获取结果
        String lockName = this.spelExpressionParser.parseExpression(lockParameter).getValue(evaluationContext).toString();
        if (redisLock.openApplicationPrefix()) {
            return this.application_prefix + lockPrefix + lockName;
        }
        return lockPrefix + lockName;
    }
}

	// 使用
    @RedisLock(lockPrefix = RedisLockKeyPrefixDict.DRAW_KEY, lockParameter = "#user_code")
    public String draw(String user_code) {
        return "success";
    }