Spring aop+自定义注解统一记录用户行为日志

写在前面

本文不涉及过多的Spring aop基本概念以及基本用法介绍，以实际场景使用为主。

场景

我们通常有这样一个需求：打印后台接口请求的具体参数，打印接口请求的最终响应结果，以及记录哪个用户在什么时间点，访问了哪些接口，接口响应耗时多长时间等等。这样做的目的是为了记录用户的访问行为，同时便于跟踪接口调用情况，以便于出现问题时能够快速定位问题所在。

最简单的做法是这样的：

1    @GetMapping(value = "/info")
2    public BaseResult userInfo() {
3        //1.打印接口入参日志信息,标记接口访问时间戳
4        BaseResult result = mUserService.userInfo();
5        //2.打印/入库 接口响应信息，响应时间等
6        return result;
7    }

这种做法没毛病，但是稍微比较敏感的同学就会发觉有以下缺点：

• 每个接口都充斥着重复的代码，有没有办法提取这部分代码，做到统一管理呢？答案是使用 Spring aop 面向切面执行这段公共代码。
• 充斥着 硬编码 的味道，有些场景会要求在接口响应结束后，打印日志信息，保存到数据库，甚至要把日志记录到elk日志系统等待，同时这些操作要做到可控，有没有什么操作可以直接声明即可？答案是使用自定义注解，声明式的处理访问日志。

自定义注解

新增日志注解类，注解作用于方法级别，运行时起作用。

 1@Target({ElementType.METHOD}) //注解作用于方法级别
 2@Retention(RetentionPolicy.RUNTIME) //运行时起作用
 3public @interface Loggable {
 4
 5    /**
 6     * 是否输出日志
 7     */
 8    boolean loggable() default true;
 9
10    /**
11     * 日志信息描述,可以记录该方法的作用等信息。
12     */
13    String descp() default "";
14
15    /**
16     * 日志类型，可能存在多种接口类型都需要记录日志，比如dubbo接口，web接口
17     */
18    LogTypeEnum type() default LogTypeEnum.WEB;
19
20    /**
21     * 日志等级
22     */
23    String level() default "INFO";
24
25    /**
26     * 日志输出范围,用于标记需要记录的日志信息范围，包含入参、返回值等。
27     * ALL-入参和出参, BEFORE-入参, AFTER-出参
28     */
29    LogScopeEnum scope() default LogScopeEnum.ALL;
30
31    /**
32     * 入参输出范围，值为入参变量名，多个则逗号分割。不为空时，入参日志仅打印include中的变量
33     */
34    String include() default "";
35
36    /**
37     * 是否存入数据库
38     */
39    boolean db() default true;
40
41    /**
42     * 是否输出到控制台
43     *
44     * @return
45     */
46    boolean console() default true;
47}

日志类型枚举类:

 1public enum LogTypeEnum {
 2
 3    WEB("-1"), DUBBO("1"), MQ("2");
 4
 5    private final String value;
 6
 7    LogTypeEnum(String value) {
 8        this.value = value;
 9    }
10
11    public String value() {
12        return this.value;
13    }
14}

日志作用范围枚举类：

 1public enum LogScopeEnum {
 2
 3    ALL, BEFORE, AFTER;
 4
 5    public boolean contains(LogScopeEnum scope) {
 6        if (this == ALL) {
 7            return true;
 8        } else {
 9            return this == scope;
10        }
11    }
12
13    @Override
14    public String toString() {
15        String str = "";
16        switch (this) {
17            case ALL:
18                break;
19            case BEFORE:
20                str = "REQUEST";
21                break;
22            case AFTER:
23                str = "RESPONSE";
24                break;
25            default:
26                break;
27        }
28        return str;
29    }
30}

相关说明已在代码中注释，这里不再说明。

使用 Spring aop 重构

引入依赖：

 1    <dependency>
 2            <groupId>org.aspectj</groupId>
 3            <artifactId>aspectjweaver</artifactId>
 4            <version>1.8.8</version>
 5        </dependency>
 6        <dependency>
 7            <groupId>org.aspectj</groupId>
 8            <artifactId>aspectjrt</artifactId>
 9            <version>1.8.13</version>
10        </dependency>
11        <dependency>
12            <groupId>org.javassist</groupId>
13            <artifactId>javassist</artifactId>
14            <version>3.22.0-GA</version>
15    </dependency>

配置文件启动aop注解，基于类的代理，并且在 spring 中注入 aop 实现类。

 1<?xml version="1.0" encoding="UTF-8"?>
 2<beans xmlns="http://www.springframework.org/schema/beans"
 3    .....省略部分代码">
 4
 5    <!-- 扫描controller -->
 6    <context:component-scan base-package="**.*controller"/>
 7    <context:annotation-config/>
 8
 9    <!-- 启动aop注解基于类的代理（这时需要cglib库），如果proxy-target-class属值被设置为false或者这个属性被省略，那么标准的JDK 基于接口的代理将起作用 -->
10    <aop:config proxy-target-class="true"/>
11
12     <!-- web层日志记录AOP实现 -->
13    <bean class="com.easywits.common.aspect.WebLogAspect"/>
14</beans>
15

新增 WebLogAspect 类实现

  1/**
  2 * 日志记录AOP实现
  3 * create by zhangshaolin on 2018/5/1
  4 */
  5@Aspect
  6@Component
  7public class WebLogAspect {
  8
  9    private static final Logger LOGGER = LoggerFactory.getLogger(WebLogAspect.class);
 10
 11    // 开始时间
 12    private long startTime = 0L;
 13
 14    // 结束时间
 15    private long endTime = 0L;
 16
 17    /**
 18     * Controller层切点
 19     */
 20    @Pointcut("execution(* *..controller..*.*(..))")
 21    public void controllerAspect() {
 22    }
 23
 24    /**
 25     * 前置通知 用于拦截Controller层记录用户的操作
 26     *
 27     * @param joinPoint 切点
 28     */
 29    @Before("controllerAspect()")
 30    public void doBeforeInServiceLayer(JoinPoint joinPoint) {
 31    }
 32
 33    /**
 34     * 配置controller环绕通知,使用在方法aspect()上注册的切入点
 35     *
 36     * @param point 切点
 37     * @return
 38     * @throws Throwable
 39     */
 40    @Around("controllerAspect()")
 41    public Object doAround(ProceedingJoinPoint point) throws Throwable {
 42        // 获取request
 43        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
 44        ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes) requestAttributes;
 45        HttpServletRequest request = servletRequestAttributes.getRequest();
 46
 47        //目标方法实体
 48        Method method = ((MethodSignature) point.getSignature()).getMethod();
 49        boolean hasMethodLogAnno = method
 50                .isAnnotationPresent(Loggable.class);
 51        //没加注解 直接执行返回结果
 52        if (!hasMethodLogAnno) {
 53            return point.proceed();
 54        }
 55
 56        //日志打印外部开关默认关闭
 57        String logSwitch = StringUtils.equals(RedisUtil.get(BaseConstants.CACHE_WEB_LOG_SWITCH), BaseConstants.YES) ? BaseConstants.YES : BaseConstants.NO;
 58
 59        //记录日志信息
 60        LogMessage logMessage = new LogMessage();
 61
 62        //方法注解实体
 63        Loggable methodLogAnnon = method.getAnnotation(Loggable.class);
 64
 65        //处理入参日志
 66        handleRequstLog(point, methodLogAnnon, request, logMessage, logSwitch);
 67
 68        //执行目标方法内容，获取执行结果
 69        Object result = point.proceed();
 70
 71        //处理接口响应日志
 72        handleResponseLog(logSwitch, logMessage, methodLogAnnon, result);
 73        return result;
 74    }
 75
 76    /**
 77     * 处理入参日志
 78     *
 79     * @param point          　切点
 80     * @param methodLogAnnon 　日志注解
 81     * @param logMessage     　日志信息记录实体
 82     */
 83    private void handleRequstLog(ProceedingJoinPoint point, Loggable methodLogAnnon, HttpServletRequest request,
 84                                 LogMessage logMessage, String logSwitch) throws Exception {
 85
 86        String paramsText = "";
 87        //参数列表
 88        String includeParam = methodLogAnnon.include();
 89        Map<String, Object> methodParamNames = getMethodParamNames(
 90                point.getTarget().getClass(), point.getSignature().getName(), includeParam);
 91        Map<String, Object> params = getArgsMap(
 92                point, methodParamNames);
 93        if (params != null) {
 94            //序列化参数列表
 95            paramsText = JSON.toJSONString(params);
 96        }
 97        logMessage.setParameter(paramsText);
 98        //判断是否输出日志
 99        if (methodLogAnnon.loggable()
100                && methodLogAnnon.scope().contains(LogScopeEnum.BEFORE)
101                && methodLogAnnon.console()
102                && StringUtils.equals(logSwitch, BaseConstants.YES)) {
103            //打印入参日志
104            LOGGER.info("【{}】 接口入参成功!, 方法名称:【{}】, 请求参数:【{}】", methodLogAnnon.descp().toString(), point.getSignature().getName(), paramsText);
105        }
106        startTime = System.currentTimeMillis();
107        //接口描述
108        logMessage.setDescription(methodLogAnnon.descp().toString());
109
110        //...省略部分构造logMessage信息代码
111    }
112
113    /**
114     * 处理响应日志
115     *
116     * @param logSwitch         外部日志开关，用于外部动态开启日志打印
117     * @param logMessage        日志记录信息实体
118     * @param methodLogAnnon    日志注解实体
119     * @param result         　 接口执行结果
120     */
121    private void handleResponseLog(String logSwitch, LogMessage logMessage, Loggable methodLogAnnon, Object result) {
122        endTime = System.currentTimeMillis();
123        //结束时间
124        logMessage.setEndTime(DateUtils.getNowDate());
125        //消耗时间
126        logMessage.setSpendTime(endTime - startTime);
127        //是否输出日志
128        if (methodLogAnnon.loggable()
129                && methodLogAnnon.scope().contains(LogScopeEnum.AFTER)) {
130            //判断是否入库
131            if (methodLogAnnon.db()) {
132                //...省略入库代码
133            }
134            //判断是否输出到控制台
135            if (methodLogAnnon.console() 
136                    && StringUtils.equals(logSwitch, BaseConstants.YES)) {
137                //...省略打印日志代码
138            }
139        }
140    }
141    /**
142     * 获取方法入参变量名
143     *
144     * @param cls        触发的类
145     * @param methodName 触发的方法名
146     * @param include    需要打印的变量名
147     * @return
148     * @throws Exception
149     */
150    private Map<String, Object> getMethodParamNames(Class cls,
151                                                    String methodName, String include) throws Exception {
152        ClassPool pool = ClassPool.getDefault();
153        pool.insertClassPath(new ClassClassPath(cls));
154        CtMethod cm = pool.get(cls.getName()).getDeclaredMethod(methodName);
155        LocalVariableAttribute attr = (LocalVariableAttribute) cm
156                .getMethodInfo().getCodeAttribute()
157                .getAttribute(LocalVariableAttribute.tag);
158
159        if (attr == null) {
160            throw new Exception("attr is null");
161        } else {
162            Map<String, Object> paramNames = new HashMap<>();
163            int paramNamesLen = cm.getParameterTypes().length;
164            int pos = Modifier.isStatic(cm.getModifiers()) ? 0 : 1;
165            if (StringUtils.isEmpty(include)) {
166                for (int i = 0; i < paramNamesLen; i++) {
167                    paramNames.put(attr.variableName(i + pos), i);
168                }
169            } else { // 若include不为空
170                for (int i = 0; i < paramNamesLen; i++) {
171                    String paramName = attr.variableName(i + pos);
172                    if (include.indexOf(paramName) > -1) {
173                        paramNames.put(paramName, i);
174                    }
175                }
176            }
177            return paramNames;
178        }
179    }
180
181    /**
182     * 组装入参Map
183     *
184     * @param point　　　　　　　切点
185     * @param methodParamNames　参数名称集合
186     * @return
187     */
188    private Map getArgsMap(ProceedingJoinPoint point,
189                           Map<String, Object> methodParamNames) {
190        Object[] args = point.getArgs();
191        if (null == methodParamNames) {
192            return Collections.EMPTY_MAP;
193        }
194        for (Map.Entry<String, Object> entry : methodParamNames.entrySet()) {
195            int index = Integer.valueOf(String.valueOf(entry.getValue()));
196            if (args != null && args.length > 0) {
197                Object arg = (null == args[index] ? "" : args[index]);
198                methodParamNames.put(entry.getKey(), arg);
199            }
200        }
201        return methodParamNames;
202    }
203}

使用注解的方式处理接口日志

接口改造如下：

1    @Loggable(descp = "用户个人资料", include = "")
2    @GetMapping(value = "/info")
3    public BaseResult userInfo() {
4        return mUserService.userInfo();
5    }

可以看到，只添加了注解@Loggable，所有的web层接口只需要添加@Loggable注解就能实现日志处理了，方便简洁！最终效果如下：

访问入参，响应日志信息：

用户行为日志入库部分信息：

简单总结

• 编写代码时，看到重复性代码应当立即重构，杜绝重复代码。
• Spring aop　可以在方法执行前，执行时，执行后切入执行一段公共代码，非常适合用于公共逻辑处理。
• 自定义注解，声明一种行为，使配置简化，代码层面更加简洁。

最后

更多原创文章会第一时间推送公众号【张少林同学】，欢迎关注！