Spring Boot 实现表单锁

通过注解和 SpEL 表达式实现表单动态锁业务

FormLock 注解

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

/**
 * 防止表单重复提交锁实现注解
 *
 * @author yangli
 */
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface FormLock {
    /**
     * Spring Expression Language (SpEL) expression for computing the key dynamically.
     * <p>
     * 表单锁 key 的值，spring el 表达式（Spring Expression Language (SpEL) expression），动态获取表单锁的 key 值
     */
    String key() default "";
}

FormLockAspect 切面

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
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.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.core.LocalVariableTableParameterNameDiscoverer;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.EvaluationException;
import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.concurrent.TimeUnit;

/**
 * @author yangli
 */
@Aspect
@Slf4j
@Component
@RequiredArgsConstructor
public class FormLockAspect {
    private final RedissonClient redissonClient;

    /**
     * 锁
     */
    private static final String LOCK_KEY = "redisson::lock::%s::%s";

    private final ExpressionParser parser = new SpelExpressionParser();
    private final LocalVariableTableParameterNameDiscoverer discoverer = new LocalVariableTableParameterNameDiscoverer();

    @Pointcut("@annotation(com.grgbanking.prms.common.lock.FormLock)")
    public void pointcut() {
    }

    @Around("pointcut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        Method method = resolveMethod(point);
        FormLock formLock = AnnotationUtils.findAnnotation(method, FormLock.class);
        if (formLock == null) {
            return point.proceed();
        }
        String el = formLock.key();
        if (StringUtils.isBlank(el)) {
            return point.proceed();
        }
        if (!el.startsWith("#")) {
            return point.proceed();
        }
        Object[] args = point.getArgs();

        // Expose indexed variables as well as parameter names (if discoverable)
        String[] paramNames = this.discoverer.getParameterNames(method);
        int paramCount = (paramNames != null ? paramNames.length : method.getParameterCount());
        int argsCount = args.length;

        EvaluationContext eval = new StandardEvaluationContext();
        for (int i = 0; i < paramCount; i++) {
            Object value = null;
            if (argsCount > paramCount && i == paramCount - 1) {
                // Expose remaining arguments as vararg array for last parameter
                value = Arrays.copyOfRange(args, i, argsCount);
            } else if (argsCount > i) {
                // Actual argument found - otherwise left as null
                value = args[i];
            }
            /**
             * see {@link MethodBasedEvaluationContext#lazyLoadArguments()}
             */
            eval.setVariable("a" + i, value);
            eval.setVariable("p" + i, value);
            if (paramNames != null) {
                eval.setVariable(paramNames[i], value);
            }
        }
        Expression expression = parser.parseExpression(el);
        /**
         * 这里可能会抛出异常，不用处理，这样有利于程序发现{@link FormLock#key()}配置错误问题
         */
        String lockKey;
        try {
            lockKey = expression.getValue(eval, String.class);
        } catch (EvaluationException e) {
            throw new EvaluationException(String.format("%s 表达式错误", el));
        }
        if (StringUtils.isBlank(lockKey)) {
            log.warn("{} 表达式的值为空，直接执行逻辑", el);
            return point.proceed();
        }
        String name = point.getTarget().getClass().getSimpleName() + "#" + method.getName();
        RLock lock = null;
        try {
            lock = redissonClient.getLock(String.format(LOCK_KEY, name, lockKey));
            // 如果不主动释放锁，300 秒后自动释放
            boolean success = lock.tryLock(100L, 300000L, TimeUnit.MILLISECONDS);
            if (!success) {
                // todo 改成自己的返回格式：json、页面等
                return Rs.error("表单已提交，不可重复提交");
            }
            // log.info("获得表单执行锁 ---> 结束，获取数量：{}", notifications.size());
            return point.proceed();
        } finally {
            if (lock != null && lock.isLocked() && lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }

    private Method resolveMethod(ProceedingJoinPoint point) {
        MethodSignature signature = (MethodSignature) point.getSignature();
        Class<?> targetClass = point.getTarget().getClass();

        Method method = getDeclaredMethod(targetClass, signature.getName(),
            signature.getMethod().getParameterTypes());
        if (method == null) {
            throw new IllegalStateException("无法解析目标方法: " + signature.getMethod().getName());
        }
        return method;
    }

    private Method getDeclaredMethod(Class<?> clazz, String name, Class<?>... parameterTypes) {
        try {
            return clazz.getDeclaredMethod(name, parameterTypes);
        } catch (NoSuchMethodException e) {
            Class<?> superClass = clazz.getSuperclass();
            if (superClass != null) {
                return getDeclaredMethod(superClass, name, parameterTypes);
            }
        }
        return null;
    }
}

使用例子

@FormLock(key = "#command.reportNo")
@RequestMapping(value = "/list", method = RequestMethod.GET)
public Rs<AssetsAppraisalsPagingVo<AssetsAppraisal>> list(AssetsAppraisalQueryCommand command) {
  log.info("command: {}", command);
  return assetsAppraisalService.selectPage(command);
}