SpringBoot日志记录切面Aspect--项目案例实战

因为项目需要，有时需要针对两个系统对接提供的接口服务，记录调用日志，包括请求IP、请求参数、响应时间、响应信息、异常信息等，并保存到数据库。

下面案例，使用的是SpringBoot构建，采用Swagger2提供了页面测试功能，发布RESTful API，你可以根据这个进行自己的个性化定制。

1. pom.xml 主要依赖如下：

       
       <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
  
  
       <!-- 数据库连接池 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
        </dependency>

        <!--Swagger2提供了页面测试功能调试RESTful API-->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

2. 新增一张日志记录表，记录请求信息，包括异常信息等，SQL如下：

CREATE TABLE `sys_log` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT COMMENT '日志ID',
  `request_ip` varchar(20) DEFAULT '' COMMENT '请求ip',
  `system_model` varchar(20) DEFAULT '' COMMENT '系统模块，属于哪一个模块的请求日志，如spring-cloud-test',
  `request_url` varchar(100) DEFAULT '' COMMENT '请求的地址',
  `request_type` varchar(10) DEFAULT '' COMMENT '请求方式：get、post等',
  `class_path` varchar(100) DEFAULT '' COMMENT '请求执行的类路径',
  `method_name` varchar(20) DEFAULT '' COMMENT '请求方法名',
  `request_params` varchar(2000) DEFAULT '' COMMENT '请求参数json',
  `session_id` varchar(100) DEFAULT '' COMMENT '请求接口唯一的session标识',
  `request_date` datetime DEFAULT NULL COMMENT '请求时间',
  `return_date` datetime DEFAULT NULL COMMENT '返回时间',
  `response_time` decimal(20,0) DEFAULT NULL COMMENT '响应时间，即消耗多少毫秒',
  `response_params` varchar(2000) DEFAULT '' COMMENT '返回的数据json',
  `status` tinyint(2) DEFAULT '0' COMMENT '请求状态：0-成功，-1-异常',
  `error_msg` varchar(2000) DEFAULT '' COMMENT '异常信息',
  `error_date` datetime DEFAULT NULL COMMENT '异常发生的时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=130 DEFAULT CHARSET=utf8 COMMENT='请求日志表';

3. 对应的日志实体类：

import com.baomidou.mybatisplus.enums.IdType;
import java.util.Date;
import com.baomidou.mybatisplus.annotations.TableId;
import java.io.Serializable;

import com.baomidou.mybatisplus.annotations.Version;

import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;

/**
 * <p>
 * 接口请求日志表
 * </p>
 *
 * @author gxh
 * @since 2019-07-11
 */
@Data
@Accessors(chain = true)
public class SysLog implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 日志ID
     */
    @TableId(value = "id", type = IdType.AUTO)
    private Integer id;
    /**
     * 请求ip
     */
    private String requestIp;
    /**
     * 系统模块，属于哪一个模块的请求日志
     */
    private String systemModel;
    /**
     * 请求的地址
     */
    private String requestUrl;
    /**
     * 请求方式：get、post等
     */
    private String requestType;
    /**
     * 请求执行的类路径
     */
    private String classPath;
    /**
     * 请求方法名
     */
    private String methodName;
    /**
     * 请求参数json
     */
    private String requestParams;
    /**
     * 请求接口唯一的session标识
     */
    private String sessionId;
    /**
     * 请求时间
     */
    private Date requestDate;
    /**
     * 返回时间
     */
    private Date returnDate;
    /**
     * 响应时间，即消耗多少毫秒
     */
    private Long responseTime;
    /**
     * 返回的数据json
     */
    private String responseParams;
    /**
     * 请求状态：0-成功，-1-异常
     */
    private Integer status;
    /**
     * 异常信息
     */
    private String errorMsg;
    /**
     * 异常发生的时间
     */
    private Date errorDate;


}

4. 新增一个类，命名  SysLogAspect

•  增加@Component注解，将此对象加到Spring 容器管理，
•  增加@Aspect注解，表示切面
•  定义切入点，也就是真正请求的方法，你需要对此做日志记录切面逻辑，@Pointcut("execution(public * com.stwen.api..*.*(..))")当请求该包下的所有方法时都会执行切面逻辑

@Component
@Aspect
@Slf4j
public class SysLogAspect {

    @Resource
    private SysLogDao sysLogDao;

    /**
     * 切入点名称
     */
    @Pointcut("execution(public * com.stwen.api..*.*(..))")
    public void apiLog() {
    }


}

5. 创建一个环绕方法doAround() 

• 增加@Around注解，可以同时在所拦截方法（切入点）的前后执行自己的切面逻辑
• 通过 ProceedingJoinPoint   joinPoint 参数，可以在具体的切入点方法前后插入自己的日志逻辑：joinPoint.proceed()
• 其中，切入点执行之后，需要try  catch后面的切面逻辑，不能因为保存日志逻辑切面失败，而影响切入点方法的正常逻辑

    /**
     * 环绕（方法执行前、方法执行后）
     *
     * @param joinPoint
     * @return
     * @throws Throwable
     */
    @Around("apiLog()")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {

        long startTime = System.currentTimeMillis();

        //这个RequestContextHolder是SpringMvc提供以获得请求的信息
        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = ((ServletRequestAttributes) requestAttributes).getRequest();
        sysLog sysLog = newSysLog(joinPoint, request);

        // 执行切点方法，result的值就是被拦截方法的返回值
        Object result = joinPoint.proceed();

        //计算响应时间
        long endTime = System.currentTimeMillis();
        long responseTime = endTime - startTime;

        try{
            //响应数据转json串
            String responseParams = JSON.toJSONString(result, SerializerFeature.WriteMapNullValue);
            sysLog.setReturnDate(new Date())
                    .setResponseParams(responseParams.length() > 1999 ? responseParams.substring(0, 1999) : responseParams)
                    .setResponseTime(responseTime)
                    .setReturnDate(new Date())
                    .setStatus(ResponseCode.SUCCESS.getCode());
            sysLogDao.insert(sapApiLog);
            log.info("【Aspect日志记录】请求成功，返回数据: {}", JSON.toJSONString(result, SerializerFeature.WriteMapNullValue));

        }catch (Exception e){
            log.info("【Aspect日志记录】请求结束，保存日志失败");
            e.printStackTrace();
        }
        return result;
    }

其中 newSysLog()  方法，抽取出来，提供新建一个日志实体对象，因为后面异常捕获也需要调用：

    /**
     * 封装日志实体SysLog
     *
     * @param joinPoint
     * @param request
     * @return
     */
    private SysLog newSysLog(JoinPoint joinPoint, HttpServletRequest request) {

        Object[] objects = joinPoint.getArgs();
        String requestParams = JsonUtil.argsToJson(objects);

        String requestUrl = request.getRequestURL().toString();
        String requestIp = RequestUtil.getRealIp(request);

        log.info("【Aspect日志记录】请求开始, 请求IP: {}，请求URL：{}，请求参数：{}", requestIp, requestUrl, requestParams);

        SysLog sysLog = new SysLog();
        sysLog .setRequestIp(requestIp)
                .setSystemModel(SystemModelConstants.API_MODEL)
                .setRequestUrl(requestUrl)
                //请求类型：get、post等
                .setRequestType(request.getMethod())
                // 获取包.类名
                //.setClassPath(joinPoint.getSignature().getDeclaringTypeName())
                .setClassPath(joinPoint.getTarget().getClass().getName())
                .setMethodName(joinPoint.getSignature().getName())
                .setRequestParams(requestParams.length() > 1999 ? requestParams.substring(0, 1999) : requestParams)
                .setSessionId(request.getSession().getId())
                .setRequestDate(new Date());

        return sysLog;
    }

其中 ，RequestUtil.getRealIp(request) 是获取请求方的真实 IP 工具类：

/**
 * @description: 请求工具类
 * @author: ganxianhao
 * @create: 
 **/
public class RequestUtil {

    /**
     * 获取真实IP，包括了对反向代理、代理客户端、多个IP情况的处理
     * @param request 请求体
     * @return 真实IP
     */
    public static String getRealIp(HttpServletRequest request) {
        // 这个一般是Nginx反向代理设置的参数
        String ip = request.getHeader("X-Real-IP");
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            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();
        }
        // 处理多IP的情况（只取第一个IP）
        if (ip != null && ip.contains(",")) {
            String[] ipArray = ip.split(",");
            ip = ipArray[0];
        }
        return ip;
    }

    /**
     * 获取请求方式：1-普通请求，2-ajax请求
     * @param request
     * @return
     * @throws Exception
     */
    public static Integer getRequestType(HttpServletRequest request) throws Exception{
        if(request == null){
            throw new Exception("HttpServletRequest对象为空");
        }
        String xRequestWith = request.getHeader("X-Request-With");
        return xRequestWith == null ? 1 : 2;
    }
}

异常日志记录,需要增加注解@AfterThrowing ，当请求切入点方法执行异常后，会调用此方法，进行异常日志记录：

    /**
     * 异常日志
     *
     * @param joinPoint
     * @param e
     */
    @AfterThrowing(value = "apiLog()", throwing = "e")
    public void doAfterThrowing(JoinPoint joinPoint, Exception e) {

        try {
            //这个RequestContextHolder是SpringMvc提供以获得请求的信息
            RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
            HttpServletRequest request = ((ServletRequestAttributes) requestAttributes).getRequest();

            SysLog sysLog = newSysLog(joinPoint, request);

            //获取详细的异常信息
            String errorStr = ExceptionUtil.getDetailException(e);

            sysLog.setStatus(ResponseCode.ERROR.getCode())
                    .setErrorDate(new Date())
                    //截取只保存前2000个字符串异常信息
                    .setErrorMsg(errorStr.length() > 1999 ? errorStr.substring(0, 1999) : errorStr);

            sysLogDao.insert(sysLog);
            log.error("【Aspect日志记录】请求异常，异常详情查看表sys_log，id: {}", sysLog.getId());
        } catch (Exception ex) {
            log.error("【Aspect日志记录】请求异常，并且保存日志记录失败！");
            ex.printStackTrace();
        }
    }

其中，ExceptionUtil.getDetailException(e) 是获取具体异常信息：

import java.io.PrintWriter;
import java.io.StringWriter;

/**
 * @description: 异常工具类
 * @author: ganxianhao
 * @create: 
 **/
public class ExceptionUtil {

    /**
     * 获取详细的异常信息转String
     * @param e
     * @return
     */
    public static String getDetailException(Exception e){
        StringWriter sw=new StringWriter();
        e.printStackTrace(new PrintWriter(sw,true));
        String errorStr = sw.toString();
        return errorStr;
    }
}

6. 在切入点定义的扫描包名下，新增一个测试类，提供HTTP接口（使用Swagger2发布REST API）:

/**
 * @description: 测试Api
 * @author: gxh
 * @create: 2019-06-17 17:14:40
 **/
@RestController
@Api(tags = "测试接口")
public class TestApi {

    @ApiOperation("首页")
    @GetMapping(value ="/")
    public String index() throws Exception {
        //测试异常日志记录时，打开下面这个注解即可
        //int a = 1/0;
        System.out.println(" hello,马马哈哈");
        return "hello,马马哈哈";
    }
}

7.运行应用，测试HTTP请求接口：localhost:8088

这个是正常请求，无异常情况的日志记录：

这个是异常日志记录（将上面的测试类方法中的注解去掉即可）：

看完后是不是觉得很简单，觉得有用点个赞再走吧0.0，整理不易。

本文来自：CSDN  作者：stwen_gan  https://blog.csdn.net/a1036645146/article/details/97660456

转载请注明出处，谢谢。