个人在 Spring 应用下切面日志实践分享

最新推荐文章于 2024-02-24 13:33:38 发布
最新推荐文章于 2024-02-24 13:33:38 发布
阅读量405 收藏
点赞数
分类专栏： Spring 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42189048/article/details/122473766
版权

个人在 Spring 应用下切面日志实践分享

前言

最近参与了几个项目的开发，感觉日志系统有点杂乱无章：有用 info 的有用 error 的，也有所有信息输出在单一文件里的

也可能是每个人排查错误的方式有差异，我个人比较习惯的一套日志记录的最佳实践原则大体如下：

  • info 级别我理解是 提示，标记，通常我习惯拿来输出一些调试过程中的参数、结果、提示语信息，更严格的情况下上述信息也可以调整为 debug 级别
  • warn 级别习惯拿来输出一些不影响程序运行但可能有风险或者可能与预期业务运行不同的信息
  • error 级别输出确实阻碍系统运行或者业务上错误的结果，比如抛出的异常信息
  • 一个全局 info 级别的文件（比如 application.log）来记录程序运行中所有的 info （及以上）信息，该文件的主要用途是个人在非本地环境下调试时，在全局文件下方便查看自己的输出标识（一般调试完后会移除相关输出代码）
  • 一个全局 error 级别的文件（比如 error.log）来记录所有程序中的 error 信息，该文件主要是总览所有报错信息，方便快速定位异常、做相关预警操作等
  • 个人习惯以层级维度划分日志文件来记录该层级下所有的 info （及以上）信息，比如 controller（web） service 层，这样排查错误更具有针对性，可以层层递推排查问题，该部分的实现通常依托于 Spring AOP

分享一份个人 demo，该 demo 基于 SpringBoot + Logback（默认） 实现，通过 Logback 配置 + Spring AOP 完成日志的记录

logback-spring.xml

先贴一份 logback 配置，相对通用可用作参考，定义了最佳实践中提到一些常规的 Logger 比如 CONSOLE application error controller service，详情如下

<?xml version="1.0" encoding="UTF-8"?>
<configuration>

    <include resource="org/springframework/boot/logging/logback/defaults.xml"/>
    <springProperty scope="context" name="springAppName" source="spring.application.name"/>

    <!-- spring cloud sleuth 下适用 -->
    <property name="PATTERN"
              value="%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}"/>

    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>${PATTERN}</pattern>
            <charset>utf8</charset>
        </encoder>
    </appender>

    <appender name="application"
              class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>application.log</file>
        <encoder>
            <pattern>${PATTERN}</pattern>
        </encoder>
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>application.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <maxHistory>7</maxHistory>
            <maxFileSize>50MB</maxFileSize>
            <totalSizeCap>10GB</totalSizeCap>
        </rollingPolicy>

        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>info</level>
        </filter>
    </appender>

    <appender name="controller"
              class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>controller.log</file>
        <encoder>
            <pattern>${PATTERN}</pattern>
        </encoder>
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>controller.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <maxHistory>7</maxHistory>
            <maxFileSize>50MB</maxFileSize>
            <totalSizeCap>10GB</totalSizeCap>
        </rollingPolicy>

        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>info</level>
        </filter>
    </appender>

    <appender name="service"
              class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>service.log</file>
        <encoder>
            <pattern>${PATTERN}</pattern>
        </encoder>
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>service.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <maxHistory>7</maxHistory>
            <maxFileSize>50MB</maxFileSize>
            <totalSizeCap>10GB</totalSizeCap>
        </rollingPolicy>

        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>info</level>
        </filter>
    </appender>

    <appender name="error"
              class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>error.log</file>
        <encoder>
            <pattern>${PATTERN}</pattern>
        </encoder>
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>error.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <maxHistory>7</maxHistory>
            <maxFileSize>50MB</maxFileSize>
            <totalSizeCap>10GB</totalSizeCap>
        </rollingPolicy>

        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>error</level>
        </filter>
    </appender>

    <root level="info">
        <appender-ref ref="CONSOLE" />
        <appender-ref ref="application"/>
        <appender-ref ref="error"/>
    </root>

    <logger name="application" level="info" additivity="false">
        <appender-ref ref="application"/>
        <appender-ref ref="error"/>
    </logger>
    <logger name="controller" level="info" additivity="false">
        <appender-ref ref="controller"/>
        <appender-ref ref="error"/>
    </logger>
    <logger name="service" level="info" additivity="false">
        <appender-ref ref="service"/>
        <appender-ref ref="error"/>
    </logger>
</configuration>
  • PATTERN 适用于引入 spring-cloud-sleuth 的项目，否则日志格式会有点怪异但不影响查看
  • application 是默认 Logger，error 记录全局 ERROR 级别信息

LogRecorder

public interface LogRecorder {

    // 获取适合的 logger
    Logger getLogger();

    default void warn(String message) {
        Optional.ofNullable(getLogger())
                .ifPresent(logger -> logger.warn(message));
    }

    default void info(String message) {
        Optional.ofNullable(getLogger())
                .ifPresent(logger -> logger.info(message));
    }

    default void error(String message) {
        Optional.ofNullable(getLogger())
                .ifPresent(logger -> logger.error(message));
    }
}
  • 顶层接口，主要提供了 info warn error 方法的常规实现
  • getLogger 方法获取适合的 Logger 对象由子类复写

SimpleLogRecorder

@Component
public class SimpleLogRecorder implements LogRecorder {

    public static final String APPLICATION_LOGGER_NAME = "application";

    @Override
    public Logger getLogger() {

        return LoggerFactory.getLogger(APPLICATION_LOGGER_NAME);
    }
}
  • 一个通用实现，该类实际就是用来记录全局 info 文件的，默认由 application 记录
  • 该类是一个 bean 组件，可直接注入使用

CommonPointcuts

public class CommonPointcuts {

	// web 层，通常为 controller 层
    @Pointcut("execution(* com.example.logapp.controller.*.*(..))")
    public void webLayerPointcut() {

    }

	// 逻辑层，通常即 service 层
    @Pointcut("execution(* com.example.logapp.service.*.*(..))")
    public void serviceLayerPointcut() {

    }
}

切面层基类，维护切面的最佳实践，可用于具体切面通知的 Pointcut 声明

AopLogRecorder

public interface AopLogRecorder extends LogRecorder {

    /**
     * Before 切面，默认记录参数信息
     * @param jp
     */
    default void before(JoinPoint jp) {
        String className = jp.getSignature().getDeclaringTypeName();
        String methodName = jp.getSignature().getName();
        Object[] args = jp.getArgs();
        info(MessageFormat.format(
                "开始调用目标方法 - {0}#{1}，参数为: {2}"
                , className, methodName, JSONObject.toJSONString(args)
        ));
    }

    /**
     * AfterReturning 切面，默认描述返回结果，仅处理 ResponseEntity
     * @param jp
     * @param retVal
     */
    default void afterReturning(JoinPoint jp, ResponseEntity retVal) {
        String className = jp.getSignature().getDeclaringTypeName();
        String methodName = jp.getSignature().getName();
        info(MessageFormat.format(
                "调用目标方法{3} - {0}#{1}，结果为: {2}"
                , className, methodName, JSONObject.toJSONString(retVal)
                , retVal.getSuccessFlag() ? "成功" : "失败"
        ));
    }

    /**
     * AfterThrow 切面，默认记录报错信息
     * @param jp
     * @param e
     */
    default void afterThrow(JoinPoint jp, Throwable e) {
        String className = jp.getSignature().getDeclaringTypeName();
        String methodName = jp.getSignature().getName();
        error(MessageFormat.format(
                "调用目标方法异常 - {0}#{1}，异常信息: {2}"
                , className, methodName, e.getMessage()
        ));
    }

    /**
     * Around 通知，这里会捕获掉异常进行处理，适合 web layer
     * @param pjp
     */
    default Object around(ProceedingJoinPoint pjp) {
        String className = pjp.getSignature().getDeclaringTypeName();
        String methodName = pjp.getSignature().getName();
        Object[] args = pjp.getArgs();

        info(MessageFormat.format(
                "调用目标方法 - {0}#{1}，参数为: {2}"
                , className, methodName, JSONObject.toJSONString(args)
        ));

        Object retVal = null;
        try {
            retVal = pjp.proceed();
        } catch (Throwable e) {
            error(MessageFormat.format(
                    "调用目标方法异常 - {0}#{1}，异常信息: {2}"
                    , className, methodName, e.getMessage()
            ));
            return ResponseEntity.error();
        }

        Optional.ofNullable(retVal)
                .filter(result -> result instanceof ResponseEntity)
                .map(result -> (ResponseEntity) result)
                .ifPresent(t -> info(MessageFormat.format(
                        "调用目标方法{3} - {0}#{1}，结果为: {2}"
                        , className, methodName, JSONObject.toJSONString(t)
                        , t.getSuccessFlag() ? "成功" : "失败"
                )));
        return retVal;
    }
}
  • 切面日志基类
  • 提供 before afterReturning afterThrow 的默认实现：before 通常记录参数信息、afterReturning 提供记录结果信息、afterThrow 记录报错的异常信息，可由子类选择性的使用，比如 service 层的日志处理
  • 提供 around 默认实现，一站式的通用日志处理，同时会包装处理方法执行异常的情况，比如 web 层的日志处理
  • 子类可进行选择性的覆盖以实现对应场景功能

WebLayerAopLogRecorder

@Aspect
@Component
public class WebLayerAopLogRecorder implements AopLogRecorder {

    private static final String WEB_LAYER_LOGGER_NAME = "controller";

    @Override
    @Around("com.example.logapp.log.CommonPointcuts.webLayerPointcut()")
    public Object around(ProceedingJoinPoint pjp) {
        return AopLogRecorder.super.around(pjp);
    }

    @Override
    public Logger getLogger() {

        return LoggerFactory.getLogger(WEB_LAYER_LOGGER_NAME);
    }
}
  • 最终的日志切面层实现
  • 此处是 controller 层的切面，沿用父类定义的 around 切面通知，指定对应的 Pointcut
  • getLogger() 方法指定对应的 Logger 为 controller

ServiceLayerAopLogRecorder

@Aspect
@Component
public class ServiceLayerAopLogRecorder implements AopLogRecorder {

    private static final String SERVICE_LAYER_LOGGER_NAME = "service";

    @Override
    @Before("com.example.logapp.log.CommonPointcuts.serviceLayerPointcut()")
    public void before(JoinPoint jp) {
        AopLogRecorder.super.before(jp);
    }

    @Override
    @AfterReturning(
            pointcut = "com.example.logapp.log.CommonPointcuts.serviceLayerPointcut()"
            , returning = "retVal"
    )
    public void afterReturning(JoinPoint jp, ResponseEntity retVal) {
        AopLogRecorder.super.afterReturning(jp, retVal);
    }

    @Override
    @AfterThrowing(
            pointcut = "com.example.logapp.log.CommonPointcuts.serviceLayerPointcut()"
            , throwing = "e"
    )
    public void afterThrow(JoinPoint jp, Throwable e) {
        AopLogRecorder.super.afterThrow(jp, e);
    }

    @Override
    public Logger getLogger() {

        return LoggerFactory.getLogger(SERVICE_LAYER_LOGGER_NAME);
    }
}
  • 同上，此处是 service 层的切面日志处理，采用细粒度的切面逻辑分别处理方法执行前后的记录操作
  • getLogger() 方法指定对应的 Logger 为 service

SimpleLogRecorder 使用

@Component
public class TestApp {

    @Autowired
    SimpleLogRecorder simpleLogRecorder;

    public String hello(String name) {

        simpleLogRecorder.info(name);
        return "hello " + name;
    }
}
  • 上述的场景一般都维护固定的日志信息：比如 入参、返回值 等，但在具体的调试场景中往往需要一些赋值信息的输出才能更好的定位问题
  • 此时使用全局的 info 记录即可，在此 demo 中直接注入 SimpleLogRecorder 组件使用即可

总结

本文分享了个人在 Spring 应用下切面日志最佳实践，整合 Spring Cloud Sleuth 后有了 traceId 的协助，更是能在多链路调用中快速定位问题，加快前后端沟通效率

关于整合 Spring Cloud Sleuth，可以参考

【Spring Cloud】Spring Cloud Sleuth 使用记录

小水牛...
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
日志记录（使用切面方式记录）
12-22
spring日志记录（使用切面方式记录） 1. 创建pojo类 @Data @Table(name = "tb_operate_record") public class OperateRecord { @Id private String id; //记录请求时间 @Column(name = "record_time") private Date recordTime; //操作者 private String username; //请求IP @Column(name = "request_ip") priv
SpringBoot实现切面AOP简单记录日志
qq_39853669的博客
05-07 1944
简述：该方式用于简单记录操作日志等，其实有很多第三方的日志框架，每一个公司也有自己的日志跟踪记录等，需要的童鞋可以自己搜寻。以下代码在灵活用于项目中，可自行决定。 下面可单独建立一个springboot单体应用，供其它module调用，作为依赖的方式；也可直接嵌入到其它moudle中，但这样有点繁琐，建议作为单独功能提取出来，类似于公共工具。 1、日志实体 @Entity @Getter @Setter @Table(name = "sys_log") @NoArgsConstructor public c
SpringBoot AOP切面编程 记录操作日志、异常日志
最新发布
javasan的博客
02-24 617
Spring AOP（面向切面编程）提供了一种优雅的解决方案，用于处理这种跨多个方法或类的常见任务，如日志记录、性能统计、安全控制和事务管理等。通过AOP，我们可以将这些横切关注点（Cross-cutting Concerns）从业务逻辑中分离出来，使业务代码更加清晰和专注。在Spring Boot应用中，我们可以利用AOP来简化日志记录和异常处理的过程。通过定义切面（Aspect）和切入点（Pointcut），我们可以指定哪些方法或类的操作应该被拦截，并自动执行日志记录或异常处理逻辑。
Spring Boot 使用切面记录日志
雨陆聪辰的博客
10-24 2669
Spring Boot 使用切面记录日志
spring AOP切面及日志记录实现
q495673918的博客
02-22 2964
1.什么是AOP切面 AOP（Aspect Oriented Programming），面向切面思想，是Spring的三大核心思想之一。 在项目中经常会有些系统性的需求，例如权限校验，日志记录，统计等，这时我们就可以通过AOP切面去实现。 有多少业务代码就需要写多少重复校验和日志记录，这显然是不合理的，我们可以把这些重复操作抽离出来，写成公共的方法。 这样，代码冗余解决了，但是每个地方都要手动去调用还是很麻烦，有没有更好的方式呢？这就要用到我们的AOP（面向切面编程），AOP将权限校验，
微服务框架（八）Spring Boot AOP 日志切面实现
若明天不见
08-10 5971
　　此系列文章将会描述Java框架Spring Boot、服务治理框架Dubbo、应用容器引擎Docker，及使用Spring Boot集成Dubbo、Mybatis等开源框架，其中穿插着Spring Boot中日志切面等技术的实现，然后通过gitlab-CI以持续集成为Docker镜像。 　　本文为使用Spring Boot AOP 实现日志切面、分离INFO和ERROR级别日志 本系...
SpringAOP切面实例讲解及应用场景（通俗易懂）
12-21
下面是一个在spring mvc中关于切面如何使用的例子，可以指直观的理解切面到底有什么作用 1、引用 AspectJ jar 包依赖 pom.xml 文件添加依赖 org.aspectj aspectjrt 1.9.2 2、创建两个新的包 ...
spring aop切面拦截指定类和方法实现流程日志跟踪
10-26
spring aop切面拦截指定类和方法实现流程日志跟踪 一般情况下，在不侵入业务代码的情况下，需要做流程日志跟踪是比较合理的 采用springaop切面思想
spring AOP 切面日志 分层打日志
12-04
spring AOP 切面日志 分层打日志
Spring AOP日志切面
06-28
结合logback和切面对参数名和参数值，方法运行时间，方法返回值记录日志，pom中需要添加ogback和切面依赖。
spring aop 切面添加日志
06-22
此工程为使用eclipse创建java project，使用jdk1.8，项目中包含完整的代码和jar包，导入eclipse即可运行
Spring AOP面向切面详解，记录操作日志
一只程序猿
03-07 1899
最近又用到AOP记录操作日志，虽然很多年以前就已经用过了。但是那时候多数是百度的来的，并没有去深入研究。说白了，只是实现了功能，可能睡一觉又忘了。 AOP（Aspect-OrientedProgramming)面向切面，切开封装的对象内部，并将那些影响了多个类并且与具体业务无关的公共行为封装成一个独立的模块（称为切面）。更重要的是它又能巧妙将这些切面复原，不留痕迹的融入核心业务逻辑中。这样，...
Spring实现日志切面
zzchances的博客
03-16 676
AOP相关注解介绍 @Aspect:作用是把当前类标识为一个切面供容器读取 @Pointcut：Pointcut是植入Advice的触发条件。每个Pointcut的定义包括2部分，一是表达式，二是方法签名。方法签名必须是 public及void型。可以将Pointcut中的方法看作是一个被Advice引用的助记符，因为表达式不直观，因此我们可以通过方法签名的方式为 此表达式命名。因此Point...
SpringBoot实际项目中 如何基于切面的方式对业务操作日志进行记录
zhanghailang1的博客
02-15 1267
Spring boot 如何在项目中简单的对业务操作日志进行记录
springboot——日志的切面处理
weixin_45625874的博客
10-28 4001
在外界访问资源的时候，需要作日志记录 但不可能在每个controller上面都写一遍日志记录的函数 因此需要使用AOP对controller进行一个日志方法的增强 步骤： 1、编写日志方法类 2、编写好切面，设置好切点表达式和注解 3、编写需要记录的日志内容 ...
Spring切面实现日志记录
qq_44484552的博客
01-21 261
关于切面拦截以及配置请移步本人博客： https://blog.csdn.net/qq_44484552?spm=1010.2135.3001.5343 由于本人用的是登陆方法试验，session内容为空，所以特在前端设置一个session演示切面内获取session 在请求发起前设置session：<%session.setAttribute(“wname”, “移动端,MOVE”);%> 请求方法 / /登陆请求 function login() { log();<%sessi
spring 使用aop切面实现系统操作日志记录
weixin_43190879的博客
02-15 563
使用aop切面编程实现系统操作日志记录实现
spring 日志切面
u011500419的专栏
09-03 341
package com.atguigu.spring.aspectJ.annotation; 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 o.
Java AOP切面日志处理
qq_36636312的博客
12-06 3135
1，引入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> 2，配置日志切面 @Aspect @Component @Slf4j @Order(1) public class LogOperatio
详细介绍下Spring，并给出对应文献说明
07-14
2. 面向切面编程（AOP）：Spring支持AOP编程，可以通过配置方式实现横切关注点的模块化。它可以帮助开发人员将与业务逻辑无关的功能（如日志记录、安全性、事务处理等）从核心业务逻辑中分离出来，提高代码的可读性...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值