基于自定义注解和SpringEL表达式的分布式锁实现

Z时代
2024-01-10
分类：综合

需求

1、项目中不可避免的需要使用分布式保证幂等。所以一个简单可靠，易用的工具提上日程。

2、演进过程

最开始使用try finally 块实现。代码臃肿。还要时刻记得释放。

改用回调方式封装锁的获取和释放，但是依然臃肿，需要实现成功和获取锁失败的回调方法。然而获取锁失败几乎都做的一样的事。

使用注解，代价就是使用范围是整个方法。需要自己确认好了使用范围。另外第一版不支持Spring EL。想使用参数值做锁实在太麻烦。

改进注解，使用spring EL引擎。提供强大的数据获取功能。并且对返回值使用调用静态方法和创建新对象十分友好。

我们并没有直接使用spirng EL的所有语法。而是选择包装了一下，因为大家对Spring EL认识参差不齐。

demo:


@LockMethod(
value = {
@ExtractParam(paramName = "accountInfo", fieldName = "accountId"),
@ExtractParam(paramName = "order", fieldName = "id"),
@ExtractParam(paramName = "uid")
        }
, formatter = "lockTest:%s:%s:%s"
, failureExpression = "new java.util.ArrayList()")
public Object lockTest(TAccountInfo accountInfo, TPayOrder order, Long uid) {
return CommonResultEntity.success();
}

代码：


@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Repeatable(value = LockMethod.class)
public @interface ExtractParam {
/**
     * 作为锁的参数名称
     */
String paramName();
/**
     * 参数的 属性值。可以为空
     */
String fieldName() default "";
}


@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface LockMethod {
/**
     * 提取的参数
     */
ExtractParam[] value();
/**
     * 自定义
     */
String formatter() default "";
/**
     * 失败后返回类型
     */
Class<?> failureType() default void.class;
/**
     * 失败返回 表达式
     */
String failureExpression() default "";
}


@Aspect
@Component
@Slf4j
public class LockInterceptor {
/**
     * spring 参数名称解析器
     */
private static final ParameterNameDiscoverer LOCAL_VARIABLE_TABLE_PARAMETER_NAME_DISCOVERER
= new LocalVariableTableParameterNameDiscoverer();
/**
     * spring el 表达式解析解
     */
private static final ExpressionParser SPEL_EXPRESSION_PARSER = new SpelExpressionParser();
/**
     * Elvis运算符 在一些编程语言中（比如C#、Kotlin等）提供该功能，语法是?:。意义是当某变量不为空的时候使用该变量，当该变量为空的时候使用指定的默认值。
     */
@Around("@annotation(com.xxx.xxx.support.LockMethod)")
public Object lock(ProceedingJoinPoint pjp) throws Throwable {
        String methodName = pjp.getSignature().getName();
Object[] args = pjp.getArgs();
Class<?> classTarget = pjp.getTarget().getClass();
Class<?>[] par = ((MethodSignature) pjp.getSignature()).getParameterTypes();
Method targetMethod = classTarget.getMethod(methodName, par);
String[] parameterNames = LOCAL_VARIABLE_TABLE_PARAMETER_NAME_DISCOVERER.getParameterNames(targetMethod);
LockMethod lockMethod = targetMethod.getAnnotation(LockMethod.class);
        final String lockName = parseLockName(args, lockMethod, parameterNames);
log.info("lockName={} act=LockInterceptor", lockName);
        return doLock(pjp, lockMethod, lockName);
}
private Object doLock(ProceedingJoinPoint pjp, LockMethod lockMethod, String lockName) {
return DistributedLock.acquireLock(MDCUtils.getLogStr(), lockName, new LockCallback<Object>() {
@Override
public Object onSuccess(String logStr) {
try {
return pjp.proceed();
} catch (Throwable throwable) {
throw new RuntimeException(throwable);
}
            }
@Override
public Object onFailure(String logStr) {
                String onFailureMethodEL = lockMethod.failureExpression();
                if (StringUtils.isEmpty(onFailureMethodEL)) {
return null;
}
                Class<?> onFailureCallType = lockMethod.failureType();
                if (onFailureCallType == void.class) {
return SPEL_EXPRESSION_PARSER.parseExpression(onFailureMethodEL).getValue();
} else {
                    EvaluationContext context = new StandardEvaluationContext(onFailureCallType);
Expression expression = SPEL_EXPRESSION_PARSER.parseExpression(onFailureMethodEL);
                    return expression.getValue(context);
}
            }
        });
}
private String parseLockName(Object[] args, LockMethod lockMethod, String[] parameterNames) {
ExtractParam[] extractParams = lockMethod.value();
        if (extractParams.length == 0) {
throw new RuntimeException("not allow no extract param");
}
        List<String> fieldValues = new ArrayList<>();
Map<String, Object> paramNameMap = buildParamMap(args, parameterNames);
        for (ExtractParam extractParam : extractParams) {
            String paramName = extractParam.paramName();
Object paramValue = paramNameMap.get(paramName);
String springEL = extractParam.fieldName();
String paramFieldValue = "";
            if (StringUtils.isNotEmpty(springEL)) {
                Expression expression = SPEL_EXPRESSION_PARSER.parseExpression(springEL);
paramFieldValue = expression.getValue(paramValue).toString();
} else {
if (isSimpleType(paramValue.getClass())) {
                    paramFieldValue = String.valueOf(paramValue);
}
            }
            fieldValues.add(paramFieldValue);
}
return String.format(lockMethod.formatter(), fieldValues.toArray());
}
/**
     * 构建请求参数map
     * @param args 参数列表
     * @param parameterNames 参数名称列表
     * @return key:参数名称 value:参数值
     */
private Map<String, Object> buildParamMap(Object[] args, String[] parameterNames) {
        Map<String, Object> paramNameMap = new HashMap<>();
        for (int i = 0; i < parameterNames.length; i++) {
            paramNameMap.put(parameterNames[i], args[i]);
}
return paramNameMap;
}
/**
     * 基本类型 int, double, float, long, short, boolean, byte, char， void.
     */
private static boolean isSimpleType(Class<?> clazz) {
return clazz.isPrimitive()
                || clazz.equals(Long.class)
                || clazz.equals(Integer.class)
                || clazz.equals(String.class)
                || clazz.equals(Double.class)
                || clazz.equals(Short.class)
                || clazz.equals(Byte.class)
                || clazz.equals(Character.class)
                || clazz.equals(Float.class)
                || clazz.equals(Boolean.class);
}
}