面向切面编程-日志切面应用

/**
 * aop增强类
 */
@Aspect
public class MyUserAop {
    //前置通知
    @Before(value = "execution(* cn.com.yang.modules.base.model.User.*(..))")
    public void before1() {
        System.out.println("前置增强......");
    }
    //后置通知
    @After(value = "execution(* cn.com.yang.modules.base.model.User.*(..))")
    public void after1() {
        System.out.println("后置增强......");
    }

    //环绕通知
    @Around(value = "execution(* cn.com.yang.modules.base.model.User.*(..))")
    public void around1(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        //方法之前
        System.out.println("方法之前.....");

        //执行被增强的方法
        proceedingJoinPoint.proceed();

        //方法之后
        System.out.println("方法之后.....");
    }
}

/**
 * 日志注解,不需要入库的则不加本注解(返回值中responseCode为"0000"才会入库)
 * value:需要记录到数据库中的操作信息，如：@Log("删除渠道：{channelId}")，其中channelId为请求参数中的值，
 *      没有占位符则直接记录value值，目前只支持入库传入参数中的值
 * ElementType.METHOD 此注解只可应用在方法上，因为Spring只能对方法增强
 * RetentionPolicy.RUNTIME 此注解在运行期仍保留，所以可在运行期使用代理获取有此注解的方法
 * Documented 此注解包含在JavaDoc中
 */
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Log {
    String value() default "";
}

package com.suning.epp.maarms.release.monitor;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.PropertyFilter;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.suning.epp.maarms.common.constants.Constants;
import com.suning.epp.maarms.common.utils.StringUtil;
import com.suning.epp.maarms.release.service.intf.OperateLogService;
import com.suning.epp.pu.common.aop.lang.CommonResult;
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.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 日志切面,切controller方法，记录方法调用、退出与调用时间，如果有responseCode也会记录调用结果日志，<br/>
 * 如果加了@Log注解，会将操作记录加到数据库
 *
 * @author 17111829
 */
@Aspect
@Component
public class LogAdvice {

    private static final Logger LOGGER = LoggerFactory.getLogger(LogAdvice.class);

    /**
     * 日志文件中配置的线程号占位符
     */
    private static final String STR_INVOKE_NO = "invokeNo";

    private static final Pattern PATTERN = Pattern.compile("\\{[^{]*}");

    private static final String LEFT_BRACE = "{";

    /**
     * @Resource 默认按照bean id名称进行注入依赖
     * 日志入库服务
     */
    @Resource
    private OperateLogService operateLogService;

    /**
     * 切点，所有含有@RequestMapping的方法
     */
    @Pointcut("@annotation(org.springframework.web.bind.annotation.RequestMapping)")
    private void webPointcut() {
        // Do nothing
    }

    /**
     * 在方法执行前后增强
     *
     * @param joinPoint joinPoint
     * @return 方法返回值
     */
    @Around("webPointcut()")
    public Object around(ProceedingJoinPoint joinPoint) {
        MDC.put(STR_INVOKE_NO, StringUtil.getUuid());
        // 记录整个方法的执行用时
        long start = System.currentTimeMillis();
        // 获取当前方法执行的上下文的request
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes())
                .getRequest();
        String requestURI = request.getRequestURI();
        // 获取请求发起操作人
        String userId = request.getRemoteUser();
        // 获取请求参数
        Map<String, Object> paramMap = getRequestParams(request);
        // 不输出map中字段值为null的字段
        String requestParams = JSONObject.toJSONString(paramMap, SerializerFeature.WriteMapNullValue);
        // 打印入参日志
        LOGGER.info("URI：{},用户：{}, 入参：{}", requestURI, userId, requestParams);
        // 获取被增强的方法的相关信息
        MethodSignature ms = (MethodSignature) joinPoint.getSignature();
        // 获取被增强的方法
        Method pointcutMethod = ms.getMethod();
        // @Log注解的value属性值
        String logContent = null;
        // 判断被增强的方法上是否有@Log注解
        if (pointcutMethod.isAnnotationPresent(Log.class)) {
            Log logAnon = pointcutMethod.getAnnotation(Log.class);
            logContent = logAnon.value();
        }

        Object result = null;
        try {
            // 执行被增强的方法并获取方法的返回值
            result = joinPoint.proceed();
            String responseCode = null;
            String resultStr;
            // 如果返回的结果是个字符串
            if (result instanceof String) {
                resultStr = (String) result;
                // 如果有@Log注解并且@Log注解的value不为空
                if (StringUtils.isNotBlank(logContent)) {
                    JSONObject jso = JSON.parseObject(resultStr);
                    responseCode = jso.getString(Constants.RESPONSE_CODE);
                }
                // 方法执行返回的结果不是字符串
            } else {
                // 如果方法的返回值一个分页查询的结果
                if (result instanceof PageResult) {
                    // 分页数据过滤掉 data，不打印日志,SerializerFeature.WriteMapNullValue不输出Map中为null的字段
                    resultStr = JSON.toJSONString(result, dataFilter, SerializerFeature.WriteMapNullValue);
                } else {
                    resultStr = JSON.toJSONString(result, SerializerFeature.WriteMapNullValue);
                }
                // 有@Log注解时，如果返回0000则记录操作日志
                if (StringUtils.isNotBlank(logContent)) {
                    if (result instanceof Map) {
                        responseCode = (String) ((Map) result).get(Constants.RESPONSE_CODE);
                    } else if (result instanceof CommonResult) {
                        responseCode = ((CommonResult) result).getResponseCode();
                    }
                }
            }
            // 返回0000则记录操作日志
            if ("0000".equals(responseCode)) {
                insertOperateLog(logContent, userId, paramMap);
            }

            long end = System.currentTimeMillis();
            long useTime = end - start;
            LOGGER.info("用时：{}ms,返回结果：{}", useTime, resultStr);
        } catch (Throwable throwable) {
            LOGGER.error("发生异常, 异常信息：{}", ExceptionUtil.getAllStackTrace(throwable));
        }
        // 方法执行结束，移除上下文中的线程号
        MDC.remove(STR_INVOKE_NO);
        return result;
    }

    /**
     * 获取请求参数
     *
     * @param request request
     * @return json格式参数
     */
    private Map<String, Object> getRequestParams(HttpServletRequest request) {
        Enumeration pNames = request.getParameterNames();
        Map<String, Object> paramMap = new HashMap<>(6);
        String paramName;
        String[] paramValues;
        while (pNames.hasMoreElements()) {
            paramName = String.valueOf(pNames.nextElement());
            paramValues = request.getParameterValues(paramName);
            if (paramValues != null && paramValues.length == 1) {
                paramMap.put(paramName, paramValues[0]);
            } else {
                paramMap.put(paramName, paramValues);
            }
        }
        return paramMap;
    }

    /**
     * 日志入库
     *
     * @param logContent 操作事件
     */
    private void insertOperateLog(String logContent, String userId, Map<String, Object> paramMap) {
        if (StringUtils.isNotBlank(logContent)) {
            String newLogContent = logContent;
            // 如果有占位符则替换
            if (logContent.contains(LEFT_BRACE) && paramMap != null) {
                newLogContent = replaceParam(logContent, paramMap);
            }
            // 入库，谁干了什么
            operateLogService.insertOperateLog(userId, newLogContent);
        }
    }

    /**
     * 用入参中的值 替换@Log注解中的占位符
     *
     * @param logContent @Log注解中的value值
     * @return 替换后的操作内容
     */
    private String replaceParam(String logContent, Map<String, Object> paramMap) {
        Matcher matcher = PATTERN.matcher(logContent);
        String matchedStr;
        String oldContent;
        Object newContent;
        String newLogContent = logContent;
        while (matcher.find()) {
            matchedStr = matcher.group();
            oldContent = matchedStr.substring(1, matchedStr.length() - 1).trim();
            newContent = paramMap.get(oldContent);
            if (newContent != null) {
                if (newContent instanceof String[]) {
                    newLogContent = newLogContent.replace(matchedStr, Arrays.toString((String[]) newContent));
                } else {
                    newLogContent = newLogContent.replace(matchedStr, newContent.toString());
                }
            }
        }
        return newLogContent;
    }

    /**
     * 字段过滤器，过滤掉data字段不打印
     */
    private PropertyFilter dataFilter = new PropertyFilter() {
        @Override
        public boolean apply(Object object, String name, Object value) {
            // false表示 data字段将被排除在外
            return !"data".equals(name);
        }
    };

}