Springboot2 配置AOP日志的方法步骤

Spring boot2 配置AOP前置增强,后置增强,异常增强,环绕增强,最终增强

关于AOP切面相关具体概念不做过多阐述(概念弄懂有利于理解思想),这是配置AOP的各种增强日志,解决日志嵌套在业务代码的麻烦和不科学

先来个Git demo项目压压惊: https://github.com/zhang-xiao-xiang/boot-aop  (有的更新了一些)

1pom依赖(这里使用log4j2作为日志框架,因为比log4j或者其他日志框架,它效率更高,功能更加强大)

    <!-- 引入log4j2依赖(注意还有排除依赖) -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-log4j2</artifactId>
    </dependency>
    <!-- 排除exclude掉spring-boot的默认log框架配置 -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter</artifactId>
      <exclusions>
        <exclusion>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-logging</artifactId>
        </exclusion>
      </exclusions>
    </dependency>
    <dependency>
      <!-- 加上这个才能辨认到log4j2.yml文件(如果日志要输出到本地或者具体磁盘,需要配置yml) -->
      <groupId>com.fasterxml.jackson.dataformat</groupId>
      <artifactId>jackson-dataformat-yaml</artifactId>
    </dependency>
    <!--AOP的支持依赖-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>

2编写切面类

package com.example.nba.aop;//改成你的包名即可

import java.util.Arrays;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
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;

import javax.servlet.http.HttpServletRequest;

/**
 * AopLog
 *
 * @author 10905 2019/1/4
 * @version 1.0
 */
@Aspect
@Component
public class AopLog {
  //使用org.slf4j.Logger,这是Spring实现日志的方法
  private final static Logger logger = LoggerFactory.getLogger(AopLog.class);

  //	切入点注解的表达式：就是需要AOP的地方(一般是业务逻辑层service,当然服务接口调用层controller也行,两者一起打印日志也行
  //	这个类似正则表达式,可以控制日志的精度(包下,类下,方法下)和切面的类型(业务层面,服务接口层面)相当灵活)
    @Pointcut("execution(* com.example.nba.controller.PlayerApi.*(..))")
  // @Pointcut("execution(* com.example.nba.repository.PlayerRep.*(..))")
  //切入点签名的方法，注意返回值必须是void,相当于切入点的无参构造
  public void mypointcut() {
  }

  //	前置增强
  @Before("mypointcut()")
  public void Mybefore(JoinPoint jp) {
    logger.info("*前置增强*调用了【" + jp.getTarget().getClass().getSimpleName() +
        "】的【" + jp.getSignature().getName() + "】的方法，方法入参为【"
        + Arrays.toString(jp.getArgs()) + "】");
    // 接收到请求，记录请求内容(这里同样可以在前置增强配置请求的相关信息)
    ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
    HttpServletRequest request = attributes.getRequest();
    logger.info("请求的地址URL : " + request.getRequestURL().toString());
    logger.info("请求的方式HTTP_METHOD : " + request.getMethod());
    logger.info("请求的IP : " + request.getRemoteAddr());
    logger.info("请求的全类名 : " + jp.getSignature().getDeclaringTypeName() + "." + jp.getSignature().getName());
    logger.info("请求的参数(数组形式) : " + Arrays.toString(jp.getArgs()));

  }

  //后置增强
  @AfterReturning(pointcut = "mypointcut()", returning = "result")
  public void MyafterReturing(JoinPoint jp, Object result) {
    logger.info("*后置增强*调用了【" + jp.getTarget().getClass().getSimpleName() +
        "】的【" + jp.getSignature().getName() + "】的方法，方法返回值【" + result + "】");
  }

  //	异常抛出增强
  @AfterThrowing(pointcut = "mypointcut()", throwing = "e")
  public void afterThrowing(JoinPoint jp, RuntimeException e) {
    logger.error("*异常增强*【" + jp.getSignature().getName().getClass().getSimpleName() + "】方法发生异常【" + e + "】");
  }

  //	最终增强
  @After("mypointcut()")
  public void afterLogger(JoinPoint jp) {
    logger.info("*最终增强*【" + jp.getSignature().getName() + "】方法结束执行。");
  }

  //环绕增强
  @Around("mypointcut()")
  public Object aroundLogger(ProceedingJoinPoint jp) throws Throwable {
    logger.info("在==>>" + jp.getTarget().getClass().getName() + "类里面使用AOP环绕增强==");
    logger.info("*环绕增强*调用【" + jp.getTarget().getClass().getSimpleName() + "】的【 " + jp.getSignature().getName()
        + "】方法。方法入参【" + Arrays.toString(jp.getArgs()) + "】");
    try {
      Object result = jp.proceed();
      logger.info("*环绕增强*调用 " + jp.getTarget() + "的【 "
          + jp.getSignature().getName() + "】方法。方法返回值【" + result + "】");
      return result;
    } catch (Throwable e) {
      logger.error(jp.getSignature().getName() + " 方法发生异常【" + e + "】");
      throw e;
    } finally {
      logger.info("*环绕增强*执行finally【" + jp.getSignature().getName() + "】方法结束执行<<==。");
    }
  }
}

3测试(数据库代码和业务层等代码就不贴上去了,主要参考AOP的pom依赖和切面类),比如我浏览器请求

http://localhost:8080/player/findAll

控制器显示:

json格式的aop配置(注意文件格式入参需要判断一下(因为excel,PDF,png等格式无法转json)),假如现在的需求是请求和返回参数均以json格式为主,并且记录日志到数据库(排除查询日志的接口,因为查询日志不需要记录到数据库,这里涉及到AOP排除某个接口或者说是某个切面,具体见下)

日志实体(表)

package com.xinzuo.lvyou.pojo;

import java.io.Serializable;
import java.util.Date;

import com.baomidou.mybatisplus.annotation.TableId;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;

/**
 * <p>
 * 日志记录监控表
 * </p>
 *
 * @author zhangxiaoxiang
 * @since 2019-07-08
 */
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
public class LogMonitor implements Serializable {

  private static final long serialVersionUID = 1L;

  /**
   * 日志主键ID
   */
  @TableId
  private String logId;

  /**
   * 请求IP地址
   */
  private String requestIp;

  /**
   * 操作接口反馈描述
   */
  private String summarize;
  /**
   * 响应状态吗
   */
  private Integer responseCode;

  /**
   * 请求方式
   */
  private String requestType;

  /**
   * 请求接口
   */
  private String requestApi;

  /**
   * 请求参数
   */
  private String requestPara;

  /**
   * 返回参数
   */
  private String responsePara;

  /**
   * 请求到响应处理时间(毫秒)
   */
  private Integer responseTime;

  /**
   * 创建时间(请求发出的时间)
   */
  private Date createTime;

  /**
   * 日志所属(0移动前端日志,1PC端日志)
   */
  private Integer belongTo;
}

下面是json格式并带有记录到数据库的需求的,假如返回的格式是三段式json,如下

{
  "code": 200,
  "msg": "查询打卡次数成功",
  "data": {
    "photoSave": null,
    "user": null,
    "amount": 27
  }
}

切面类的编写如下

package com.xinzuo.lvyou.aop;

import com.alibaba.fastjson.JSONArray;
import com.gexin.fastjson.JSON;
import com.gexin.fastjson.JSONObject;
import com.xinzuo.lvyou.dao.LogMonitorDao;
import com.xinzuo.lvyou.pojo.LogMonitor;
import com.xinzuo.lvyou.util.KeyUtil;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.util.Arrays;
import java.util.Date;

/**
 * AopLog:日志切面类
 *
 * @author zhangxiaoxiang
 * @date: 2019/05/22
 */
@Component
@Aspect
public class AopJsonLog {
  /**
   * 记录日志到数据库
   */
  @Autowired
  private LogMonitorDao logMonitorDao;
  //记录到数据库
  LogMonitor logMonitor = new LogMonitor();
  long start = 0;

  /**
   * 使用org.slf4j.Logger,这是Spring实现日志的方法
   */
  private final static Logger logger = LoggerFactory.getLogger(AopJsonLog.class);

  @Pointcut("execution(* com.xinzuo.lvyou.admin..*(..)) ")
  public void myPointcut() {
  }

  /**
   * 前置增强 单独配置的前端接口切面
   * 日志打印排除在外,查询日志接口就不记录数据库
   * 排除某个方法使用!execution(* com.xinzuo.lvyou.controller.LogMonitorController.*(..))
   *
   * @param jp
   */
  @Before("execution(* com.xinzuo.lvyou.controller..*(..)) && !execution(* com.xinzuo.lvyou.controller.LogMonitorController.*(..))")
  public void MyBefore(JoinPoint jp) {
    logger.info("---------------------------------前端请求接口日志----------------------------------------------");
    // 接收到请求，记录请求内容(这里同样可以在前置增强配置请求的相关信息)
    ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
    HttpServletRequest request = attributes.getRequest();
    logger.info("访问的接口:" + jp.getTarget().getClass().getName() + "." + jp.getSignature().getName());
    try {
      logger.info("请求入参为:" + new JSONArray(Arrays.asList(jp.getArgs())).toString());
    } catch (Exception e) {
      logger.info("请求入参为:图片,视频,excel,PDF等格式(此时无法转换成JSON格式)");
      //由于知道这里异常的原因是json转换参数异常,所以就不打印了,不捕获,以免控制台难看或者日志难看
      //e.printStackTrace();
    }
    //logger.info("请求的地址URL:      " + request.getRequestURL().toString());
    //logger.info("请求的方式HTTP_METHOD:  " + request.getMethod());
    //logger.info("请求的IP:        " + request.getRemoteAddr());

    start = System.currentTimeMillis();
    logMonitor.setLogId(KeyUtil.genUniqueKey());
    logMonitor.setRequestType(request.getMethod());
    logMonitor.setRequestApi(jp.getTarget().getClass().getName() + "." + jp.getSignature().getName());
    try {
      logMonitor.setRequestPara(new JSONArray(Arrays.asList(jp.getArgs())).toString());
    } catch (Exception e) {
      logMonitor.setRequestPara("请求入参为:图片,视频,excel,PDF等格式(此时无法转换成JSON格式)");
    }
    logMonitor.setRequestIp(request.getRemoteAddr());
    logMonitor.setCreateTime(new Date());

  }

  /**
   * 后置增强
   * 排除某个方法使用!execution(* com.xinzuo.lvyou.controller.LogMonitorController.*(..))
   * 日志打印排除在外,查询日志接口就不记录数据库
   * @param jp
   * @param vo
   */
  @AfterReturning(pointcut = "execution(* com.xinzuo.lvyou.controller..*(..)) && !execution(* com.xinzuo.lvyou.controller.LogMonitorController.*(..))", returning = "vo")
  public void MyafterReturing(JoinPoint jp, Object vo) {

    //logger.info("访问的接口: " + jp.getTarget().getClass().getName() + "." + jp.getSignature().getName());
    //入参打印json数组格式
//    try {
//      logger.info("请求入参为:" + new JSONArray(Arrays.asList(jp.getArgs())).toString());
//    } catch (Exception e) {
//      logger.info("请求入参为图片,视频,excel,PDF等格式(此时无法转换成JSON格式)");
//      //由于知道这里异常的原因是json转换参数异常,所以就不打印了,不捕获,以免控制台难看或者日志难看
//      //e.printStackTrace();
//    }
    logger.info("方法返回值:" + JSON.toJSONString(vo));
    logMonitor.setResponsePara(JSON.toJSONString(vo));
    long end = System.currentTimeMillis();
    //解析json
    JSONObject json= null;
    try {
      json = JSON.parseObject(JSON.toJSONString(vo));
      logMonitor.setResponseCode(Integer.valueOf(json.get("code").toString()));
      logMonitor.setSummarize(json.get("msg").toString());
    } catch (Exception e) {
      logMonitor.setSummarize("进行图片,视频,excel,PDF等格式操作(由于这个操作特殊一点,所以后台直接把返回状态码默认为200,以实际为准)");
      logMonitor.setResponseCode(200);
      //e.printStackTrace();
    }

    logMonitor.setBelongTo(0);
    logMonitor.setResponseTime((int) (end - start));
    try {
      logMonitorDao.insert(logMonitor);
    } catch (Exception e) {
      logger.info("AOP系统故障!");
    }
  }

//  /**
//   * 异常抛出增强
//   *
//   * @param jp
//   * @param e
//   */
//  @AfterThrowing(pointcut = "myPointcut()", throwing = "e")
//  public void afterThrowing(JoinPoint jp, RuntimeException e) {
//    logger.error("异常增强:" + jp.getSignature().getName().getClass().getSimpleName() + "方法发生异常【" + e + "】");
//  }

  /**
   * 环绕增强 :测试的时候finally的切面日志注释不打印,因为日志多了反而不好调试,上线时再取消注释
   *
   * @param jp
   * @return
   * @throws Throwable
   */
  @Around("myPointcut()")
  public Object aroundLogger(ProceedingJoinPoint jp) throws Throwable {

    logger.info("admin---------------------------------后台请求接口日志----------------------------------------------");
    logger.info("访问的接口:" + jp.getTarget().getClass().getName() + "." + jp.getSignature().getName());
    //入参打印json数组格式

    try {
      logger.info("请求入参为:" + new JSONArray(Arrays.asList(jp.getArgs())).toString());
    } catch (Exception e) {
      logger.info("请求入参为:图片,视频,excel,PDF等格式(此时无法转换成JSON格式)");
      //由于知道这里异常的原因是json转换参数异常,所以就不打印了,不捕获,以免控制台难看或者日志难看
      //e.printStackTrace();
    }

    try {
      Object result = jp.proceed();
      logger.info("方法返回值:" + JSON.toJSONString(result));
      return result;
    } catch (Throwable e) {
      logger.info("访问的接口:" + jp.getTarget().getClass().getName() + "." + jp.getSignature().getName());
      logger.info("请求入参为:" + new JSONArray(Arrays.asList(jp.getArgs())).toString());
      logger.error(jp.getSignature().getName() + " 方法发生异常【" + e + "】");
      throw e;
    } finally {
      //logger.info("访问的接口: " + jp.getTarget().getClass().getName() + "."+jp.getSignature().getName());
      //logger.info("请求入参为: "+ new JSONArray(Arrays.asList(jp.getArgs())).toString());
      //logger.info("执行   :" + jp.getSignature().getName() + "方法结束。");
    }
  }
}

------------------------------------下面是spring AOP配置需要的额外依赖-----------------------------------------

    <dependency>
      <groupId>aopalliance</groupId>
      <artifactId>aopalliance</artifactId>
      <version>1.0</version>
    </dependency>
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjrt</artifactId>
      <version>1.6.12</version>
    </dependency>
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.6.12</version>
    </dependency>
    <dependency>
      <groupId>cglib</groupId>
      <artifactId>cglib</artifactId>
      <version>2.2</version>
    </dependency>

到此这篇关于Springboot2 配置AOP日志的方法步骤的文章就介绍到这了,更多相关Springboot2 配置AOP日志内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！