Spring Boot添加切面，记录日志

一、AOP简介

AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是Spring框架中的一个重要内容，

它通过对既有程序定义一个切入点，然后在其前后切入不同的执行内容，比如常见的有：打开数据库连接/关闭数据库连接、打开事务/关闭事务、记录日志等。基于AOP不会破坏原

来程序逻辑，因此它可以很好的对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

下面主要讲两个内容，一个是如何在Spring Boot中引入Aop功能，二是如何使用Aop做切面去统一处理Web请求的日志。

 

二、引入jar包

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

　　

三、实现Web层的日志切面

而当我们需要使用CGLIB来实现AOP的时候，需要配置spring.aop.proxy-target-class=true，不然默认使用的是标准Java的实现。

实现AOP的切面主要有以下几个要素：

使用@Aspect注解将一个java类定义为切面类
使用@Pointcut定义一个切入点，可以是一个规则表达式，比如下例中某个package下的所有函数，也可以是一个注解等。
根据需要在切入点不同位置的切入内容
使用@Before在切入点开始处切入内容
使用@After在切入点结尾处切入内容
使用@AfterReturning在切入点return内容之后切入内容（可以用来对处理返回值做一些加工处理）
使用@Around在切入点前后切入内容，并自己控制何时执行切入点自身的内容
使用@AfterThrowing用来处理当切入内容部分抛出异常之后的处理逻辑

import java.util.Arrays;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import org.apache.commons.lang.StringUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

/**
 * 项目日志 切面
 * @author zengdq
 * 2019年1月5日
 */
@Aspect
@Component
public class WebLogAspect {

    private static final Logger logger = LoggerFactory.getLogger(WebLogAspect.class);

    private static final String PLATFORM_NAME = "xxx项目名称";
    /**
     * 统计时间
     */
    ThreadLocal<Long> startTime = new ThreadLocal<>();
    
    @Pointcut("execution(public * com.web.controller..*.*(..))")
    public void webLog(){}
    
    @Before("webLog()")
    public void doBefore(JoinPoint joinPoint) throws Throwable {
        startTime.set(System.currentTimeMillis());
        
        // 接收到请求，记录请求内容
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        
        //打印请求参数
        Map<String, String[]> paramMap = request.getParameterMap();
        if(paramMap != null && paramMap.size() > 0) {
            StringBuffer paramSbf = new StringBuffer();
            for(String mapKey:paramMap.keySet()) {
                String[] mapValue = paramMap.get(mapKey);
                
                //添加判断
                if(mapValue != null && mapValue.length > 0) {
                    for(String paramStr:mapValue) {
                        if(StringUtils.isNotBlank(paramStr)) {
                            paramSbf.append("参数"+mapKey+"=");
                            paramSbf.append(paramStr);
                            paramSbf.append(";");
                        }
                    }
                    
                }//END if
                
            }//END for
            
            //打印日志参数
            logger.info(PLATFORM_NAME+"-->request请求参数PARAM : " + paramSbf);
        }//END if        
        // 记录下请求内容
        logger.info(PLATFORM_NAME+"-->request请求URL : " + request.getRequestURL().toString());
        logger.info(PLATFORM_NAME+"-->request请求方法HTTP_METHOD : " + request.getMethod());
        logger.info(PLATFORM_NAME+"-->request请求方法IP : " + getIP(request));
        logger.info(PLATFORM_NAME+"-->request请求类方法CLASS_METHOD : " + joinPoint.getSignature().getDeclaringTypeName() + "." + joinPoint.getSignature().getName());
        logger.info(PLATFORM_NAME+"-->request请求ARGS : " + Arrays.toString(joinPoint.getArgs()));
    }

    @AfterReturning(returning = "ret", pointcut = "webLog()")
    public void doAfterReturning(Object ret) throws Throwable {
        // 处理完请求，返回内容
        logger.info(PLATFORM_NAME+"-->response请求响应结果RESULT: " + ret);
        logger.info(PLATFORM_NAME+"-->response请求响应时间= 【" + (System.currentTimeMillis() - startTime.get())+"】毫秒");
    }
    
    /**
     * 
     * @param request
     * @return
     */
    private static String getIP(HttpServletRequest request) {
        String ip = request.getHeader("x-forwarded-for");

        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("WL-Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
        }
        return ip;
    }
}

 

有时会使用到反射

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.reflect.MethodSignature;

import java.lang.reflect.Method;

@AfterReturning( pointcut = "log()" )
public void addLog( JoinPoint joinPoint ){
    
    // 从切面织入点通过反射获取织入点的方法
    MethodSignature  methodSignature = (MethodSignature)joinPoint.getSignature();
    // 获取切入点的方法
    Method method = methodSignature.getMethod();
    RequestMapping mapping = method.getAnnotation(RequestMapping.calss);
    String methodMapping = mapping.value()[0];
    
    // 获取请求的类映射路径
    String className = joinPoint.getTarget().getClass().getAnnotation(RequestMapping.class).value()[0];
    
    // 业务操作
}

 

 

参考 ：   https://blog.csdn.net/zengdeqing2012/article/details/86076217