Spring boot2 配置AOP日志

最新推荐文章于 2022-03-18 21:16:09 发布
原创 最新推荐文章于 2022-03-18 21:16:09 发布 · 10w+ 阅读 · 19 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#aop日志处理 #spring boot2配置AOP日志 #aop异常日志 #aop增强 #aop排除某个切面或者方法

本文介绍如何在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>
spring aop 操作日志
06-04
本资源用来展示如何使用 spring aop 进行日志记录，例子里面通过aop的配置，把产生的日志存放到当前项目的根目录下，而且对方法执行过程中的参数进行了记录，对于aop如何记录日志不清楚的同学可以看看。
Spring AOP--日志管理
01-26
Spring AOP--日志管理，注释齐全，欢迎大家共同交流。
SpringAOP日志管理
01-06
采用SpringAOP拦截Controller，Service实现操作日志管理，统一处理异常，登陆日志管理，是SpringAOP的应用实践。通过SpringAOP的处理，可以方便移植日志管理功能，是个不错的学习demo
SpringBoot AOP 记录WEB请求日志
dbeautifulLife的博客
06-21 630
接上一篇文章：  http://blog.youkuaiyun.com/catoop/article/details/71541612 实现AOP的切面主要有以下几个要素： 使用@Aspect注解将一个Java类定义为切面类  使用@Pointcut定义一个切入点，可以是一个规则表达式，比如下例中某个package下的所有函数，也可以是一个注解等。  根据需要在切入点不同位置的切入内容 
SpringBoot通过SpringAOP特性实现系统日志记录（Controller层注解日志监控，将日志信息保存到数据库）
温故而知新
04-09 4539
SpringBoot通过AOP实现系统日志记录（Controller层日志监控，将日志信息保存到数据库） springBoot 项目中需要记录服务端访问日志，所谓的服务端访问日志其实就是Controller层的访问日志，首先想到通过AOP切面实现。 导入pom文件 <!--用于日志存储，不引用打包时会找不到JDBCAppender --> &lt...
Spring Boot配置AOP打印日志的全过程
08-25
Spring Boot配置AOP打印日志的全过程 Spring Boot是一个流行的Java框架，通过使用AOP（Aspect-Oriented Programming，面向切面编程）可以实现日志的打印，并减少重复的代码。下面将详细介绍如何在Spring Boot中配置...
Spring Boot2集成AOPLog来记录接口访问日志
08-25
实现AOP日志功能有两种主流的配置方式：基于XML的配置和基于Java的配置。基于Java配置的示例如下： ```java @Configuration @ConditionalOnClass(AOPLogger.class) @ConditionalOnMissingBean(AOPLogger.class) ...
Spring Boot中使用AOP统一处理web层异常的方法
08-27
在Spring Boot中，AOP可以用来处理跨越多个模块的关注点，如日志记录、安全检查、异常处理等。 使用AOP处理web层异常 在Spring Boot中，默认情况下，系统会将错误跳转到error/错误页面中。但是，这种方式不能满足...
详解Spring Boot中使用AOP统一处理Web请求日志
08-30
Spring Boot 中使用 AOP统一处理 Web 请求日志 Spring Boot 中使用 AOP 统一处理 Web 请求日志是指在 Spring Boot 应用程序中使用Aspect Oriented Programming（面向 Aspect 编程）技术来实现统一的 Web 请求日志...
Springboot2 配置AOP日志的方法步骤
08-19
Spring Boot 2 配置 AOP 日志的方法步骤 在软件开发中，日志记录是一个非常重要的功能，它可以帮助开发者追踪应用程序的执行过程，诊断和解决问题。但是，在 Spring Boot 2 中，配置 AOP 日志可能是一个复杂的过程...
SpringAop操作日志配置
Xi_a_o_Yi的博客
05-07 276
一、添加Maven依赖 org.springframework.boot spring-boot-starter-aop 二、创建操作日志注解类OperLog.java package com.hyd.zcar.cms.common.utils.annotation; import java.lang.annotation.Documented; import java.lang.annotation.ElementType; import java.lang.annotation.
springboot aop日志
xc_oo0的博客
03-18 303
springboot aop日志
Springboot配置操作日志AOP
Pluto
10-22 256
pom.xml IpUtil.java MyLog.java SysLog.java SysLogAspect.java SysLogMapper.java SysLogService.java application.properties 1 pom.xml <!--spring切面aop依赖--> <dependency> <groupId>org.springframework.boot</groupId> .
springboot aop 记录日志
lovely960823的博客
09-24 244
肯定不用说，这篇又有抄的成分。自己稍微改善了一点，先看效果 上代码 @Table(name="syslog") @Data public class SysLog implements Serializable{ /** * */ private static final long serialVersionUID = 1L; private Integer id; private String username; //用户名 private String
spring aop 日志
美好清新
08-28 170
import org.aspectj.lang.annotation.AfterReturning; import org.aspectj.lang.annotation.AfterThrowing; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before; import org.a...
Spring aop日志
不积跬步无以至千里
07-23 501
spring aop 日志,采用aop进行动态代理
Springboot使用AOP操作日志
Echouuu的博客
06-11 350
Springboot使用AOP操作日志 有时候项目中会记到操作日志，使用aop来实现会提高效率。 导包 首先导入aop的jar包 <!--spring切面aop依赖--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency&gt
【SpringBoot】AOP-日志记录
HuHui_的博客
12-14 415
文章目录前言装备Core-CodeMAVEN配置Web日志切面作者 前言 每个controller的访问我们都可以记录一些日志信息和异常信息方便我们排查问题。 但是关键的日志信息，还是需要自己去手动添加。 装备 maven aop包的引入 AOP切面基础知识 Core-Code MAVEN配置 &amp;lt;dependency&amp;gt; &amp;lt;groupId&amp;gt;org.springframe...
Spring Boot-AOP日志管理
weixin_45977186的博客
03-18 1239
AOP Spring的两大核心之一的AOP(Aspect-Oriented Programming，面向切面编程)：是一种新的方法论，是对传统 OOP(Object-Oriented Programming，面向对象编程)的补充。是一种通过动态代理实现程序功能扩展和统一维护的一种技术。 本篇介绍通过使用AOP，在进行接口调用时根据其访问的控制层方法打印对应的请求日志，例如：调用接口，客户端浏览器型号，电脑系统型号， 方法执行时间，请求参数等等。 AOP的相关术语 横切关注点 从每个方法中抽取出来的同一类非
Spring Boot 2中配置AOP日志的完整方法与实践
资源摘要信息:"Spring Boot 2 配置 AOP 日志的方法步骤是一项在现代 Java 后端开发中极为重要的技术实践，尤其适用于提升系统可维护性、降低业务代码与日志记录之间的耦合度。AOP（Aspect-Oriented Programming，...
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值