SpringBoot应用中使用AOP记录接口访问日志

最新推荐文章于 2023-08-10 15:36:32 发布
最新推荐文章于 2023-08-10 15:36:32 发布
阅读量523 收藏 4
点赞数
分类专栏： mall学习教程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhenghongcs/article/details/99311992
版权

本文主要讲述AOP在mall项目中的应用，通过在controller层建了一个切面来实现接口访问的统一日志记录。

AOP

AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

AOP的相关术语

通知（Advice）

通知描述了切面要完成的工作以及何时执行。比如我们的日志切面需要记录每个接口调用时长，就需要在接口调用前后分别记录当前时间，再取差值。

  • 前置通知（Before）：在目标方法调用前调用通知功能；

  • 后置通知（After）：在目标方法调用之后调用通知功能，不关心方法的返回结果；

  • 返回通知（AfterReturning）：在目标方法成功执行之后调用通知功能；

  • 异常通知（AfterThrowing）：在目标方法抛出异常后调用通知功能；

  • 环绕通知（Around）：通知包裹了目标方法，在目标方法调用之前和之后执行自定义的行为。

连接点（JoinPoint）

通知功能被应用的时机。比如接口方法被调用的时候就是日志切面的连接点。

切点（Pointcut）

切点定义了通知功能被应用的范围。比如日志切面的应用范围就是所有接口，即所有controller层的接口方法。

切面（Aspect）

切面是通知和切点的结合，定义了何时、何地应用通知功能。

引入（Introduction）

在无需修改现有类的情况下，向现有的类添加新方法或属性。

织入（Weaving）

把切面应用到目标对象并创建新的代理对象的过程。

Spring中使用注解创建切面

相关注解

  • @Aspect：用于定义切面

  • @Before：通知方法会在目标方法调用之前执行

  • @After：通知方法会在目标方法返回或抛出异常后执行

  • @AfterReturning：通知方法会在目标方法返回后执行

  • @AfterThrowing：通知方法会在目标方法抛出异常后执行

  • @Around：通知方法会将目标方法封装起来

  • @Pointcut：定义切点表达式

切点表达式

指定了通知被应用的范围，表达式格式：

execution(方法修饰符 返回类型 方法所属的包.类名.方法名称(方法参数)
//com.macro.mall.tiny.controller包中所有类的public方法都应用切面里的通知	
execution(public * com.macro.mall.tiny.controller.*.*(..))	
//com.macro.mall.tiny.service包及其子包下所有类中的所有方法都应用切面里的通知	
execution(* com.macro.mall.tiny.service..*.*(..))	
//com.macro.mall.tiny.service.PmsBrandService类中的所有方法都应用切面里的通知	
execution(* com.macro.mall.tiny.service.PmsBrandService.*(..))

添加AOP切面实现接口日志记录

添加日志信息封装类WebLog

用于封装需要记录的日志信息，包括操作的描述、时间、消耗时间、url、请求参数和返回结果等信息。

package com.macro.mall.tiny.dto;	
/**	
 * Controller层的日志封装类	
 * Created by macro on 2018/4/26.	
 */	
public class WebLog {	
    /**	
     * 操作描述	
     */	
    private String description;	
    /**	
     * 操作用户	
     */	
    private String username;	
    /**	
     * 操作时间	
     */	
    private Long startTime;	
    /**	
     * 消耗时间	
     */	
    private Integer spendTime;	
    /**	
     * 根路径	
     */	
    private String basePath;	
    /**	
     * URI	
     */	
    private String uri;	
    /**	
     * URL	
     */	
    private String url;	
    /**	
     * 请求类型	
     */	
    private String method;	
    /**	
     * IP地址	
     */	
    private String ip;	
    /**	
     * 请求参数	
     */	
    private Object parameter;	
    /**	
     * 请求返回的结果	
     */	
    private Object result;	
    //省略了getter,setter方法	
}

添加切面类WebLogAspect

定义了一个日志切面，在环绕通知中获取日志需要的信息，并应用到controller层中所有的public方法中去。

package com.macro.mall.tiny.component;	
import cn.hutool.core.util.StrUtil;	
import cn.hutool.core.util.URLUtil;	
import cn.hutool.json.JSONUtil;	
import com.macro.mall.tiny.dto.WebLog;	
import io.swagger.annotations.ApiOperation;	
import org.aspectj.lang.JoinPoint;	
import org.aspectj.lang.ProceedingJoinPoint;	
import org.aspectj.lang.Signature;	
import org.aspectj.lang.annotation.*;	
import org.aspectj.lang.reflect.MethodSignature;	
import org.slf4j.Logger;	
import org.slf4j.LoggerFactory;	
import org.springframework.core.annotation.Order;	
import org.springframework.stereotype.Component;	
import org.springframework.util.StringUtils;	
import org.springframework.web.bind.annotation.RequestBody;	
import org.springframework.web.bind.annotation.RequestParam;	
import org.springframework.web.context.request.RequestContextHolder;	
import org.springframework.web.context.request.ServletRequestAttributes;	
import javax.servlet.http.HttpServletRequest;	
import java.lang.reflect.Method;	
import java.lang.reflect.Parameter;	
import java.util.ArrayList;	
import java.util.HashMap;	
import java.util.List;	
import java.util.Map;	
/**	
 * 统一日志处理切面	
 * Created by macro on 2018/4/26.	
 */	
@Aspect	
@Component	
@Order(1)	
public class WebLogAspect {	
    private static final Logger LOGGER = LoggerFactory.getLogger(WebLogAspect.class);	
    @Pointcut("execution(public * com.macro.mall.tiny.controller.*.*(..))")	
    public void webLog() {	
    }	
    @Before("webLog()")	
    public void doBefore(JoinPoint joinPoint) throws Throwable {	
    }	
    @AfterReturning(value = "webLog()", returning = "ret")	
    public void doAfterReturning(Object ret) throws Throwable {	
    }	
    @Around("webLog()")	
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {	
        long startTime = System.currentTimeMillis();	
        //获取当前请求对象	
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();	
        HttpServletRequest request = attributes.getRequest();	
        //记录请求信息	
        WebLog webLog = new WebLog();	
        Object result = joinPoint.proceed();	
        Signature signature = joinPoint.getSignature();	
        MethodSignature methodSignature = (MethodSignature) signature;	
        Method method = methodSignature.getMethod();	
        if (method.isAnnotationPresent(ApiOperation.class)) {	
            ApiOperation apiOperation = method.getAnnotation(ApiOperation.class);	
            webLog.setDescription(apiOperation.value());	
        }	
        long endTime = System.currentTimeMillis();	
        String urlStr = request.getRequestURL().toString();	
        webLog.setBasePath(StrUtil.removeSuffix(urlStr, URLUtil.url(urlStr).getPath()));	
        webLog.setIp(request.getRemoteUser());	
        webLog.setMethod(request.getMethod());	
        webLog.setParameter(getParameter(method, joinPoint.getArgs()));	
        webLog.setResult(result);	
        webLog.setSpendTime((int) (endTime - startTime));	
        webLog.setStartTime(startTime);	
        webLog.setUri(request.getRequestURI());	
        webLog.setUrl(request.getRequestURL().toString());	
        LOGGER.info("{}", JSONUtil.parse(webLog));	
        return result;	
    }	
    /**	
     * 根据方法和传入的参数获取请求参数	
     */	
    private Object getParameter(Method method, Object[] args) {	
        List<Object> argList = new ArrayList<>();	
        Parameter[] parameters = method.getParameters();	
        for (int i = 0; i < parameters.length; i++) {	
            //将RequestBody注解修饰的参数作为请求参数	
            RequestBody requestBody = parameters[i].getAnnotation(RequestBody.class);	
            if (requestBody != null) {	
                argList.add(args[i]);	
            }	
            //将RequestParam注解修饰的参数作为请求参数	
            RequestParam requestParam = parameters[i].getAnnotation(RequestParam.class);	
            if (requestParam != null) {	
                Map<String, Object> map = new HashMap<>();	
                String key = parameters[i].getName();	
                if (!StringUtils.isEmpty(requestParam.value())) {	
                    key = requestParam.value();	
                }	
                map.put(key, args[i]);	
                argList.add(map);	
            }	
        }	
        if (argList.size() == 0) {	
            return null;	
        } else if (argList.size() == 1) {	
            return argList.get(0);	
        } else {	
            return argList;	
        }	
    }	
}

进行接口测试

运行项目并访问：http://localhost:8080/swagger-ui.html

640?wx_fmt=png

可以看到控制住台中会打印如下日志信息：

{	
    "result": {	
        "code": 200,	
        "data": {	
            "total": 11,	
            "totalPage": 11,	
            "pageSize": 1,	
            "list": [{	
                "productCommentCount": 100,	
                "name": "万和",	
                "bigPic": "",	
                "logo": "http://macro-oss.oss-cn-shenzhen.aliyuncs.com/mall/images/20180607/timg(5).jpg",	
                "showStatus": 1,	
                "id": 1,	
                "sort": 0,	
                "productCount": 100,	
                "firstLetter": "W",	
                "factoryStatus": 1	
            }],	
            "pageNum": 1	
        },	
        "message": "操作成功"	
    },	
    "basePath": "http://localhost:8080",	
    "method": "GET",	
    "parameter": [{	
        "pageNum": 1	
    }, {	
        "pageSize": 1	
    }],	
    "description": "分页查询品牌列表",	
    "startTime": 1561273191861,	
    "uri": "/brand/list",	
    "url": "http://localhost:8080/brand/list",	
    "spendTime": 101	
}

项目源码地址

https://github.com/macrozheng/mall-learning/tree/master/mall-tiny-aop

推荐阅读


640?wx_fmt=jpeg

欢迎关注，点个在看

macrozheng
关注
专栏目录
使用AOP记录Spring Boot接口操作日志
TechWhiz的博客
09-27 55
在Spring Boot应用程序中，我们经常需要记录接口的操作日志，以便进行监控和故障排查。一种常见的实现方式是使用面向切面编程（AOP）来拦截接口方法的调用，并在其执行前后记录相关日志信息。通过AOP，我们可以方便地在业务逻辑中插入日志记录的逻辑，而无需修改原有的接口方法。在Spring Boot应用程序中，我们可以使用不同的日志框架，如Log4j2、Logback等。现在我们已经完成了AOP切面的编写和日志框架的配置，可以进行测试了。），并进行相应的配置。方法的调用，并记录了相应的日志信息。
Spring Boot2集成AOPLog来记录接口访问日志
08-25
主要介绍了Spring Boot2集成AOPLog来记录接口访问日志,日志是一个Web项目中必不可少的部分，借助它我们可以做许多事情，比如问题排查、访问统计、监控告警等,需要的朋友可以参考下
SpringBoot使用AOP记录接口操作日志
热门推荐
何哥的博客
01-07 2万+
前言：我们项目中可能有这种需求，每个人请求了哪些接口？做了什么事情？参数是什么？重要的接口我们需要记日志以便查找。我们不可能在每个接口中去一一处理，可以借助Spring提供的AOP能力+自定义注解轻松应对。 ...
SpringBoot整合AOP记录接口访问日志
mikelv01的博客
03-13 1413
参考： SpringBoot整合AOP AOP AOP 为 Aspect Oriented Programming 的缩写，意为：面向切面编程，通过 预编译 方式和 运行期动态代理 实现程序功能的统一维护的一种技术。利用 AOP 可以对业务逻辑的个部分进行隔离，从而从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 AOP的相关术语 通知(Advice) 通知...
springboot aop记录接口访问日志例子
PurineKing之博客
01-27 416
springboot aop记录接口访问日志例子
SpringBoot项目使用AOP实现接口调用日志
m0_61136590的博客
09-18 1161
项目中，使用AOP是一种常见的设计方式，可以在不侵入业务代码的前提下，对业务进行增强，springboot中事务注解就是使用了AOP进行动态代理去实现事务，常见的AOP方式比如前置通知（增强）、后置通知、异常通知、环绕通知、最终通知，合适的AOP方式可以极大降低业务代码的冗余与侵入性，是开发中必不可少的一环。本文使用了AOP中的AROUND ADVICE（环绕通知）进行接口日志处理。
springBoot+aop+自定义注解+本地线程实现统一接口日志及接口响应时长
02-01
springboot+拦截器+aop+自定义注解+本地线程实现统一接口日志记录，记录下接口所在模块、接口描述、接口请求参数、接口返回参数、接口请求时间以及接口耗时用于接口优化，接口记录参数以及操作人防止使用人员误操作...
SpringBoot 使用 AOP 记录接口操作日志
qq_41128049的博客
04-20 1281
SpringBoot 使用 AOP 记录接口操作日志 一、AOP简介 1.什么是AOP AOP：Aspect Oriented Programming 面向切面编程 AOP关注不是某一个类或某些方法；控制大量资源，关注的是大量的类和方法。 2.AOP应用场景以及常用术语 权限控制、缓存控制、事务控制、分布式追踪、异常处理等 Target：目标类，即需要被代理的类。例如：UserService Joinpoint(连接点):所谓连接点是指那些可能被拦截到的方法。例如：所有的方法 PointCut 切
springboot拦截器记录接口日志信息
qq_37342720的博客
04-22 3123
继上一篇文章springboot 切点@Pointcut 过滤某个目录的类我又使用拦截器来记录日志信息。 spring拦截器 一般有两种 继承HandlerInterceptorAdapter 实现HandlerInterceptor 一般用作日志记录和登录校验使用。 主要有三种方法 preHandle：拦截于请求刚进入时，进行判断，需要boolean返回值，如果返回true将继续执行，如果返回false，将不进行执行。一般用于登录校验。 postHandle：拦截于方法成功返回后，视图渲..
springboot使用aop记录接口操作日志
weixin_43241706的博客
12-23 552
国际管理，添加依赖 我们先自定义一个注解，有关自定义注解的说明可自行百度。 @Target({ ElementType.PARAMETER, ElementType.METHOD }) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface Log { /** * 模块 */ String title() default ""; /** * 功能 */ .
SpringBoot 记录操作日志
最新发布
weixin_44133974的博客
08-10 837
ResponseBodyAdvice 是用于接收响应结果，并且假设抛出了一场，但是我们在之前的@RestControllerAdvice+@ExceptionHandler 处理了异常，但会的结果其实也是一个json，所以我们在这个都可以接收到，但是我们要注意，上面拦截器中我们已经记录了日志，这个地方直接将返回结果的一些信息写入那条数据集中就好了，所以我们这里用到了本地线程。至此，完整的适用于SpringBoot记录操作日志的代码就完成了！mapper 层 (SpringDataJpa)
超详细！AOP的实际场景，SpringBoot使用AOP记录接口访问日志
qq_34963264的博客
05-15 318
怎么理解这句话？例如：当用户请求过来的时候，我认为他没有权限或者其他的原因不能请求该方法，那么我就可以不执行目标方法。虽然，使用@before，@after也可以实现这样的逻辑，但是其他的不能决定是否执行目标方法，所以使用@Around有很大的灵活性，如果没有这个需求，也可以使用@before，@after这种搭配。
Spring Boot入门(23)：记录接口日志再也不难！用AOP和自定义注解给Spring Boot加上日志拦截器！
**My Coding Family**
09-01 3386
基于AOP实现自定义注解拦截接口日志并入库，一文教会你。
SpringBoot实战（六）自定义注解 + AOP 记录接口访问日志
ACGkaka的博客
04-01 3924
目录一、AOP的简单介绍1. AOP是什么2. AOP能做什么3. 切面执行顺序4. AOP注解二、实战代码1. 依赖引入2. AOP示例3. 定义接口，进行测试4. 源码地址 一、AOP的简单介绍 1. AOP是什么 AOP（Aspect Oriented Programming）–面向切面编程 通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。 实现方式：JDK动态代理、CGLIB代理。前者基于接口，后者基于子类。 2. AOP能做什么 统计接口
SpringBoot工具库:切面记录接口日志
拾一二的博客
11-01 1499
log4j是apache实现的一个开源日志组件logback同样是由log4j的作者设计完成的，拥有更好的特性，用来取代log4j的一个日志框架，是slf4j的原生实现Log4j2是log4j 1.x和logback的改进版，据说采用了一些新技术（无锁异步、等等），使得日志的吞吐量、性能比log4j 1.x提高10倍，并解决了一些死锁的bug，而且配置更加简单灵活。
SpringBoot中AOP的使用
05-12
在SpringBoot中使用AOP需要创建一个切面类，该类需要使用@Aspect注解进行标识。 ```java @Aspect @Component public class MyAspect { //切入点 @Pointcut("execution(public * com.example.demo.controller.*.*...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值