如何优雅地记录操作日志(动态解析参数和返回结果)

背景

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

问题

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

实现 2（2024-05）

基于实现 1 我们可以发现，没有支持返回结果的记录，同时对于注解中用到的参数需要手动做解析，很不优雅，于是对此做了改进优化，使用 spring-expression 组件协助我们解析配置参数，同时可以提升性能，下面一起看下具体的实现步骤。

使用示例

  其中动态参数的解析使用 SpEL 表达式引擎，所以动态参数的配置完全支持 SpEL的配置，具体可参考spring-expression组件。

@LogRecord(content = "'查询用户' + #userId + ', 是否管理员：' + #queryRequest.isAdmin",
            type = LogRecordTypeEnum.QUERY, success = "'200'.equals(#result.code)", failMsg = "#result.msg")
    public Result<UserVO> queryUser(Long userId, UserQueryRequest queryRequest){
        return Result.success(null);
    }

 LogRecord 注解的定义，根据业务需要可以自行扩展

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Documented
public @interface LogRecord {

    /**
     * 日志内容，支持SpEL表达式，常量需要用英文单引号，占位符需要用英文双引号，如："'用户' + #user.name + '创建了订单'"
     */
    String content();

    /**
     * 操作类型
     */
    LogRecordTypeEnum type();


    /**
     * 被操作对象主体id，支持SpEL表达式，常量需要用英文单引号，占位符需要用英文双引号，如："#result.id" 或 "requestParam.id"
     */
    String principalId() default "";


    /**
     * 是否成功，支持SpEL表达式，常量需要用英文单引号，占位符需要用英文双引号，如："#result.code == 200"
     */
    String success() default "true";


    /**
     * 失败原因，支持SpEL表达式，常量需要用英文单引号，占位符需要用英文双引号，如："#result.msg"
     */
    String failMsg() default "";


}

代码实现

当前操作用户获取

public interface SessionUserService {

    SessionUser getSessionUser();

}


@Data
public class SessionUser {

    private String userIdentity;

    private String name;

}

操作注解解析

实现1

我们知道在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 + 鼠标左键的链接效果，有此技巧者看到后，还望不吝赐教！