将方法参数值动态绑定到注解属性上

背景

相关接口调用时需要记录日志，并且要保存到操作记录表，如果写在业务代码里面难免出现臃肿，而且侵入性较强，所以想到注解的方式，通过注解可以很清晰地记录日志，而且和真正的业务实现解耦。

问题

方法参数是动态的，比如操作人、操作原因等，如果直接从参数中获取，无法区分出参数的对应，此时需要将方法参数值绑定到注解属性上，可是如何绑定上去呢？

实现

我们知道在Controller层，通过@PathVariable注解可以将URI中的路径参数绑定到方法参数上，底层是怎么解析的，读者自行探索Spring，比如，常用的@Cacheable中的key属性，可以通过#和参数名称和具体参数进行绑定。如果要将方法参数动态绑定到注解上，那么肯定是通过切面的方式来实现，下面给出示例代码。

注解定义

@Documented
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface LogRecord {
    
    LogTypeEnum logType();
    
    String adminId() default "";
}
           

使用示例

@LogRecord(logType = LogTypeEnum.DELETE, adminId = "adminId")
@Override
public int doSomething(Long adminId) {
	// do something
}
           

参数解析器

自定义一个注解参数解析器

public class AnnotationResolver {

    private static AnnotationResolver resolver;

    public static AnnotationResolver newInstance() {

        if (resolver == null) {
            return resolver = new AnnotationResolver();
        } else {
            return resolver;
        }

    }


    /**
     * 解析注解上的值
     *
     * @param joinPoint
     * @param str       需要解析的字符串
     * @return
     */
    public Object resolver(JoinPoint joinPoint, String str) {

        if (str == null) {
            return null;
        }
        Object value = null;
        // 如果name匹配上了#,则把内容当作变量
        if (str.matches("#\\D*")) {
            String newStr = str.replaceAll("#", "").replaceAll("", "");
            // 复杂类型
            if (newStr.contains(".")) {
                try {
                    value = complexResolver(joinPoint, newStr);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            } else {
                value = simpleResolver(joinPoint, newStr);
            }
        } else { //非变量
            value = str;
        }
        return value;
    }


    private Object complexResolver(JoinPoint joinPoint, String str) throws Exception {

        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();

        String[] names = methodSignature.getParameterNames();
        Object[] args = joinPoint.getArgs();
        String[] strs = str.split("\\.");

        for (int i = 0; i < names.length; i++) {
            if (strs[0].equals(names[i])) {
                Object obj = args[i];
                Method dmethod = obj.getClass().getDeclaredMethod(getMethodName(strs[1]), null);
                Object value = dmethod.invoke(args[i]);
                return getValue(value, 1, strs);
            }
        }

        return null;

    }

    private Object getValue(Object obj, int index, String[] strs) {

        try {
            if (obj != null && index < strs.length - 1) {
                Method method = obj.getClass().getDeclaredMethod(getMethodName(strs[index + 1]), null);
                obj = method.invoke(obj);
                getValue(obj, index + 1, strs);
            }

            return obj;

        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    private String getMethodName(String name) {
        return "get" + name.replaceFirst(name.substring(0, 1), name.substring(0, 1).toUpperCase());
    }


    private Object simpleResolver(JoinPoint joinPoint, String str) {
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        String[] names = methodSignature.getParameterNames();
        Object[] args = joinPoint.getArgs();

        for (int i = 0; i < names.length; i++) {
            if (str.equals(names[i])) {
                return args[i];
            }
        }
        return null;
    }
}
           

AOP中的使用

@AfterReturning(returning = "obj", pointcut = "xxx")
public void after(JoinPoint joinPoint, Object obj){
    MethodSignature signature = (MethodSignature) joinPoint.getSignature();
  	LogRecord annotation = signature.getMethod().getAnnotation(LogRecord.class);
	  // 通过AnnotationResolve解析注解属性参数
    AnnotationResolver annotationResolver = AnnotationResolver.newInstance()；
    Object paramObj = annotationResolver.resolver(joinPoint, annotation.adminId());
  	...
}
           

从上面的示例中也可以看到，核心就是AnnotationResolver注解解析器，注解属性值通过#和参数形参名的方式 "#adminId"和参数值进行映射，从而解析出相应的值。除了上述的简单使用示例外，还支持复杂的参数的解析，比如参数是user对象是，属性值只需要userName，那么相关注解属性的值可配置为"#user.userName"。

遗留问题

上述方案解决了自定义注解将方法参数值动态绑定到注解属性上的实现，但略有遗憾的是并未实现和@Cacheable配置key时，输入#后，IDEA可以直接提示相关参数名，输入完成后还可以通过CTRL + 鼠标左键的链接效果，有此技巧者看到后，还望不吝赐教！