暂无图片
暂无图片
暂无图片
暂无图片
暂无图片
首页 / Log日志规范以及打印方法

Log日志规范以及打印方法

荒凉 技术路 2020-06-16
2529

1、日志规范

1.1、背景

用户行为留痕、调用链追踪，大数据分析，线上问题定位和解决都离不开合理的日志规范，所有应用按同样的规范打印日志可为后续的工作带来极大的便利性。

1.2、日志框架选择

Slf4j 是为 Java 提供的简单日志门面。它允许用户以自己的喜好，在工程中通过 Slf4j 接入不同的日志系统。

现在常用的是logback和log4j2，其中logback是slf4j的原生实现框架，与log4j相比性能更加出众，

spring boot默认是支持logback的；log4j2出生更晚，已经不仅仅是log4j的升级，它还参考了logback的设计，并且据说在异步方面性能更加出众。如果需要用log4j2，需要在相关的spring包里剔除log相关的依赖。

  1. <!-- Web -->
  2. <dependency>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-starter-web</artifactId>
  5.     <!-- 如果在使用自带tomcat请注释下面，如果使用第三方tomcat不要注释下面 -->
  6.     <exclusions>
  7.         <exclusion>
  8.             <groupId>org.springframework.boot</groupId>
  9.             <artifactId>spring-boot-starter-logging</artifactId>
  10.         </exclusion>
  11.         <exclusion>
  12.             <artifactId>logback-classic</artifactId>
  13.             <groupId>ch.qos.logback</groupId>
  14.         </exclusion>
  15.     </exclusions>
  16. </dependency>

1.3、打印时机

1、 系统完成初始化，比如加载必要的配置信息完成时；

2、 接口的入口和出口，入口需要打印参数信息；

3、 业务流程中不应该出现的地方，暗示数据或逻辑可能有错误的地方；

4、 数据库存储过程中出现异常，比如唯一索引冲突，列格式不正确，事务需要回滚等；

5、 需要保留痕迹的地方，比如用户行为留痕，为合规或审计留痕等；

6、 重要的业务流程状态变化，以及对应的分支处。

1.4、日志级别

我们使用常用的日志级别：error、info、warn、debug，其他级别不建议使用。

1、 error级别应该在业务逻辑出现异常、数据持久化出现异常、数据不匹配等场景下使用，打印该日志意味着系统出现潜在问题，需要报警，并且需要相关人员马上介入解决。error日志需要包含问题出现时必要的信息，比如用户信息，调用栈信息等。error级别的日志文件可以独立，以便报警处理。

2、 info级别用于用户行为留痕、调用链跟踪以及问题定位方面，一般在核心或者重要的方法入口需要打印，还有一些重要的代码分支也需要打印。

3、 warn级别在产生不符合预期的结果，但业务并未受损的情况下可以使用，warn级别的日志可不产生短信报警，可与公司及时消息打通报警或者邮件报警，解决的时效性要求低，但需要关注。

4、 debug是在测试和本地环境使用的。为了方便定位问题，我们可以在非线上环境使用debug这个日志级别，这样可以减少线上不必要的日志。

1.5、注意事项

1、 禁止直接使用日志系统的API（比如log4j日志系统），应该使用门面模式提供的接口。可以安装lombok插件，类上使用@Slf4j注解，然后代码中直接使用log.info(“message：{}”, msg);

2、 异常日志的打印不能丢失调用栈信息，可使用：log.error("Exception message:{}",msg, ex);

3、 日志打印使用debug时应该注意，生产环境是不打印出来的，考虑效率应该加入判断：

  1.  if(log.isDebugEnabled()){
  2.      log.debug("message: {}", object);
  3.  }

4、 测试环境和线上环境禁止使用禁用 System.out.println 和 System.err.println；

5、 日志打印的上下文中如果有用户ID、业务ID或者流水号的，一定要打印出来，方便追踪。

2、sfl4j和log4j和lobback有什么区别

我在多点的时候用的是logback，并且将日志输出到额graylog中，小米的时候使用的是log4j2

slf4j
是打日志的。可以使用各种日志系统存储。Log4j
和 logback
就是那个日志存储系统(Log4j它自带打日志，因为自己本身就是一个日志系统。所以不能够切换日志系统)。但是slf4j 是可以随时切换到任何日志系统，所以一般我们打日志都用SLF4J进行打日志吧！！！

SLF4J
：即简单日志门面（Simple Logging Facade for Java），不是具体的日志解决方案，它只服务于各种各样的日志系统。SLF4J是一个用于日志系统的简单Facade，允许最终用户在部署其应用时使用其所希望的日志系统(Log4j logback)。 在使用SLF4J的时候，不需要在代码中或配置文件中指定你打算使用那个具体的日志系统，SLF4J提供了统一的记录日志的接口，只要按照其提供的方法记录即可，最终日志的格式、记录级别、输出方式等通过具体日志系统的配置来实现，因此可以在应用中灵活切换日志系统。

log4j
：日志系统

logback
：logback
和 log4j
非常相似， Logback
的内核重写了，在一些关键执行路径上性能提升10倍以上。而且 logback
不仅性能提升了，初始化内存加载也更小。但是说白了也是个日志系统

3、获取日志错误的行号，方法，报错信息

  1.  StackTraceElement s= e.getStackTrace()[0];

记录报错的文件：s.getFileName()

记录报错的方法：s.getMethodName()

记录报错的行号：s.getLineNumber()

记录报错的信息（不全面）“ e.getMessage()

互利报错的类名字：e.getClassName()

打印详细的堆栈信息：logger.error("错误堆栈",e);

3.1、 StackTraceElements=e.getStackTrace()[0];

  1. public static void main(String[] args) {

  3.     try {
  4.         int i =1/0 ;
  5.     }catch (Exception e){
  6.         log(e,ExceptionLogUtils.class );
  7.     }


  10. }


  13. public static void log(Throwable e,Class c){
  14.     Logger logger = LoggerFactory.getLogger(c);

  16.     StackTraceElement s= e.getStackTrace()[0];//数组长度为 1
  17.     logger.error("\n\n-----------------"+
  18.                  "\n报错文件名:"+s.getFileName()+
  19.                  "\n报错的类："+s.getClassName()+
  20.                  "\n报错方法：："+s.getMethodName()+
  21.                  "\n报错的行："+ s.getLineNumber()+
  22.                  "\n报错的message："+ e.getMessage()+
  23.                  "\n错误堆栈：\n"+getStackTrace(e)+
  24.                  "\n------------------\n\n");
  25. }



  29. //获取堆栈信息
  30. public static String getStackTrace(Throwable throwable){
  31.     StringWriter sw = new StringWriter();
  32.     PrintWriter pw = new PrintWriter(sw);
  33.     try
  34.     {
  35.         throwable.printStackTrace(pw);
  36.         return sw.toString();
  37.     } finally
  38.     {
  39.         pw.close();
  40.     }
  41. }





  47. 11:40:53.732 [main] ERROR com.duodian.youhui.admin.utils.ExceptionLogUtils - 

  49. -----------------
  50. 报错文件名:ExceptionLogUtils.java
  51. 报错的类：com.duodian.youhui.admin.utils.ExceptionLogUtils
  52. 报错方法：：main
  53. 报错的行：68
  54. 报错的message：/ by zero
  55. 错误堆栈：
  56. java.lang.ArithmeticException: / by zero
  57.     at com.duodian.youhui.admin.utils.ExceptionLogUtils.main(ExceptionLogUtils.java:68)

  59. ------------------

3.2、 Thread.currentThread().getStackTrace()

  1. public static void main(String[] args) {
  2.     logInfo("HealerJean",ExceptionLogUtils.class);
  3. }


  6. public static void logInfo(String msg,Class c){
  7.     Logger logger = LoggerFactory.getLogger(c);
  8.     String location="";
  9.     StackTraceElement[] stacks = Thread.currentThread().getStackTrace();
  10.     System.out.println(stacks.length); //长度为3
  11.     for(StackTraceElement stackTraceElement:stacks){
  12.         logger.info("\n\n**************"+
  13.                     "\n打印文件名："+stackTraceElement.getFileName() +
  14.                     "\n打印类名："+ stackTraceElement.getClassName() +
  15.                     "\n方法名：" +  stackTraceElement.getMethodName() +
  16.                     "\n行号："  +  stackTraceElement.getLineNumber() +
  17.                     "\n打印内容:"+msg+
  18.                     "\n**************\n\n");
  19.         System.out.println(location);
  20.     }

  22. }





  28. 11:44:47.685 [main] INFO com.duodian.youhui.admin.utils.ExceptionLogUtils - 

  30. **************
  31. 打印文件名：Thread.java
  32. 打印类名：java.lang.Thread
  33. 方法名：getStackTrace
  34. 行号：1559
  35. 打印内容:HealerJean
  36. **************



  40. 11:44:47.689 [main] INFO com.duodian.youhui.admin.utils.ExceptionLogUtils - 

  42. **************
  43. 打印文件名：ExceptionLogUtils.java
  44. 打印类名：com.duodian.youhui.admin.utils.ExceptionLogUtils
  45. 方法名：logInfo
  46. 行号：31
  47. 打印内容:HealerJean
  48. **************



  52. 11:44:47.689 [main] INFO com.duodian.youhui.admin.utils.ExceptionLogUtils - 

  54. **************
  55. 打印文件名：ExceptionLogUtils.java
  56. 打印类名：com.duodian.youhui.admin.utils.ExceptionLogUtils
  57. 方法名：main
  58. 行号：49
  59. 打印内容:HealerJean
  60. **************

4、Throwable、Exception、Error

Throwable是java.lang包中一个专门用来处理异常的类。它有两个子类，即Error 和Exception，它们分别用来处理两组异常。

4.1、Error

*用来处理程序运行环境方面的异常,Error无法预期的错误因此，这是不可捕捉的，无法采取任何恢复的操作，一般只能显示错误的信息 *

比如，虚拟机错误、装载错误和连接错误，这类异常主要是和硬件有关的，而不是由程序本身抛出的。

比如 OutOfMemoryError，试多少次很大概率出错的。

4.2、Exception

java提供了两类主要的异常:运行时异常runtime exception和一般异常checked exception。

但是在逻辑上又科分成检查异常和非检查异常

4.2.1、正常分类

4.2.1.1、运行时异常

Java
程序运行时常常遇到的各种异常的处理，其中包括隐式异常。比如，程序中除数为0引起的错误、数组下标越界错误等，这类异常也称为运行时异常，,因为它们虽然是由程序本身引起的异常，但不是程序主动抛出的，而是在程序运行中产生的。

运行时异常我们可以不处理。这样的异常由虚拟机接管。出现运行时异常后，系统会把异常一直往上层抛，一直遇到处理代码。如果不对运行时异常进行处理，那么出现运行时异常之后，要么是线程中止，要么是主程序终

4.2.1.2、一般异常

这些异常也称为显式异常。它们都是在程序中用语句抛出、并且也是用语句进行捕获的，比如，文件没找到引起的异常、类没找到引起的异常等。

JAVA要求程序员对其进行catch。所以，面对这种异常不管我们是否愿意，只能 catch捕获，要么用throws字句声明抛出，交给它的父类处理，否则编译不会通过。

4.2.1、逻辑分类：

逻辑分类：checked检查异常和unchecked非检查异常。

checkedException
就是在写代码的时候，IDE(比如Eclipse)会要求你写try catch的那种Exception，比如IOException。这种Exception是Java的设计者要求你的程序去处理的。这种异常一般不会影响程序的主体，容易手动诊断修复，所以Java要求你在catch下面写出处理的代码，以保证程序遇到此类exception之后还可以正常运行

unchecked
这一类就是你在代码处理了checked exception之后，你在运行时候依然会遇到的exception，所以又叫做RunTimeException，比如NullPointerException, IndexOutOfBoundsException。此类exception相较于前面那种更容易影响程序运行，从设计者角度不提倡从程序中catch出来并处理，当然你也可以这么做。

  1. /**
  2. * 将CheckedException转换为UncheckedException
  3. */
  4. public static RuntimeException toUncheckedException(Exception e) {
  5.     if (e instanceof RuntimeException) {
  6.         return (RuntimeException) e;
  7.     } else {
  8.         return new RuntimeException(e);
  9.     }
  10. }

5、Logback

5.1、logback.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <configuration>
  3.     <!--学习 https://blog.csdn.net/ZYC88888/article/details/85060315-->

  5.     <!--
  6.      格式化输出：%d表示日期，
  7.      %thread表示线程名，
  8.      %-5level：级别从左显示5个字符宽度,
  9.      %logger{50} 表示 Logger 名字最长36个字符,
  10.      %msg：日志消息，
  11.      %M : 日志输出所在方法名
  12.      %L : 日志输出所在行数
  13.      %n是换行符 -->
  14.     -->
  15.     <property name="LOG_PATTERN" value="%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level -[%-32X{REQ_UID}] - %msg  -%logger{50}.%M[%L]%n "/>



  19.     <property name="LOG_PATH" value="/Users/healerjean/Desktop/logs"/>
  20.     <property name="FILE_PATH_INFO"  value="${LOG_PATH}/hlj-logback.log"/>
  21.     <property name="FILE_PATH_ERROR" value="${LOG_PATH}/hlj-logback-error.log"/>

  23.     <!--控制台-->
  24.     <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
  25.         <filter class="com.hlj.proj.controller.config.LogbackJsonFilter"/>
  26.         <encoder charset="UTF-8"  >
  27.             <pattern>${LOG_PATTERN}</pattern>
  28.         </encoder>
  29.     </appender>


  32.     <appender name="FILE-INFO" class="ch.qos.logback.core.rolling.RollingFileAppender">
  33.         <!--日志文件输出的文件名 -->
  34.         <File>${FILE_PATH_INFO}</File>
  35.         <!--滚动日志 基于时间和文件大小-->
  36.         <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
  37.             <!-- 滚动日志文件保存格式 i是超出文件大小MaxFileSize 讲历史日志后缀名从0开始起步，
  38.             如果超过了最大的totalSizeCap，就会全部删除，重新开始-->
  39.             <FileNamePattern>${FILE_PATH_INFO}.%d{yyyy-MM-dd}.%i.log</FileNamePattern>
  40.             <MaxFileSize>1MB</MaxFileSize>
  41.             <totalSizeCap>5GB</totalSizeCap>
  42.             <!--日志最大的历史 10天 -->
  43.             <MaxHistory>10</MaxHistory>
  44.         </rollingPolicy>
  45.         <!-- 按临界值过滤日志：低于INFO以下级别被抛弃 -->
  46.         <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
  47.             <level>INFO</level>
  48.         </filter>
  49.         <encoder>
  50.             <!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符 -->
  51.             <pattern>${LOG_PATTERN}</pattern>
  52.         </encoder>
  53.     </appender>


  56.     <appender name="FILE-ERROR" class="ch.qos.logback.core.rolling.RollingFileAppender">
  57.         <File>${FILE_PATH_ERROR}</File>
  58.         <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
  59.             <FileNamePattern>${FILE_PATH_ERROR}.%d{yyyy-MM-dd}.%i.log</FileNamePattern>
  60.             <MaxFileSize>60MB</MaxFileSize>
  61.             <totalSizeCap>5GB</totalSizeCap>
  62.             <MaxHistory>10</MaxHistory>
  63.         </rollingPolicy>
  64.         <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
  65.             <level>ERROR</level>
  66.         </filter>
  67.         <encoder>
  68.             <pattern>${LOG_PATTERN}</pattern>
  69.         </encoder>
  70.     </appender>



  74.     <!--以配置文件application.properties 中为主，如果配置文件中不存在以它为主-->
  75.     <root level="info">
  76.         <appender-ref ref="STDOUT" />
  77.         <appender-ref ref="FILE-ERROR"/>
  78.         <appender-ref ref="FILE-INFO"/>
  79.     </root>
  80. </configuration>

5.2、Logback日志到数据库

5.2.1、创建数据库表

  1. DROP TABLE IF EXISTS logging_event_property;
  2. DROP TABLE IF EXISTS logging_event_exception;
  3. DROP TABLE IF EXISTS logging_event;


  6. CREATE TABLE logging_event
  7. (
  8.   timestmp          BIGINT       NOT NULL,
  9.   formatted_message TEXT         NOT NULL,
  10.   logger_name       VARCHAR(254) NOT NULL,
  11.   level_string      VARCHAR(254) NOT NULL,
  12.   thread_name       VARCHAR(254),
  13.   reference_flag    SMALLINT,
  14.   arg0              VARCHAR(254),
  15.   arg1              VARCHAR(254),
  16.   arg2              VARCHAR(254),
  17.   arg3              VARCHAR(254),
  18.   caller_filename   VARCHAR(254) NOT NULL,
  19.   caller_class      VARCHAR(254) NOT NULL,
  20.   caller_method     VARCHAR(254) NOT NULL,
  21.   caller_line       CHAR(4)      NOT NULL,
  22.   event_id          BIGINT       NOT NULL AUTO_INCREMENT PRIMARY KEY
  23. )


  26. CREATE TABLE logging_event_property
  27. (
  28. event_id          BIGINT NOT NULL,
  29. mapped_key        VARCHAR(150) NOT NULL,
  30. mapped_value      TEXT,
  31. PRIMARY KEY(event_id, mapped_key),
  32. FOREIGN KEY (event_id) REFERENCES logging_event(event_id)
  33. );

  35. CREATE TABLE logging_event_exception
  36. (
  37. event_id         BIGINT NOT NULL,
  38. i                SMALLINT NOT NULL,
  39. trace_line       VARCHAR(254) NOT NULL,
  40. PRIMARY KEY(event_id, i),
  41. FOREIGN KEY (event_id) REFERENCES logging_event(event_id)
  42. );

5.2.3、日志配置

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <configuration>
  3.     <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
  4.         <encoder>
  5.             <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
  6.         </encoder>
  7.     </appender>



  11.  <!--日志异步到数据库 -->
  12.     <appender name="DB" class="ch.qos.logback.classic.db.DBAppender">
  13.         <!--日志异步到数据库-->
  14.         <connectionSource class="ch.qos.logback.core.db.DriverManagerConnectionSource">
  15.             <driverClass>com.mysql.jdbc.Driver</driverClass>
  16.             <url>jdbc:mysql://localhost:3306/healerjean?useUnicode=true&amp;allowMultiQueries=true&amp;characterEncoding=utf8&amp;zeroDateTimeBehavior=convertToNull&amp;useSSL=false</url>
  17.             <user>healerjean</user>
  18.             <password>healerjean</password>
  19.         </connectionSource>
  20.     </appender>



  24.     <root level="info">
  25.         <appender-ref ref="STDOUT" />
  26.         <appender-ref ref="DB"/>
  27.     </root>
  28. </configuration>

5.2.3、查看日志

  1. SELECT * from logging_event;

5.3、LogBack打印Json数据

  1. <!--控制台-->
  2. <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
  3.     <filter class="com.hlj.proj.controller.config.LogbackJsonFilter"/>
  4.     <encoder charset="UTF-8"  >
  5.         <pattern>${LOG_PATTERN}</pattern>
  6.     </encoder>
  7. </appender>
  1. package com.hlj.proj.controller.config;

  3. import ch.qos.logback.classic.spi.ILoggingEvent;
  4. import ch.qos.logback.core.filter.Filter;
  5. import ch.qos.logback.core.spi.FilterReply;
  6. import com.hlj.proj.controller.utils.JsonUtils;



  10. public class LogbackJsonFilter extends Filter<ILoggingEvent> {
  11.     @Override
  12.     public FilterReply decide(ILoggingEvent event) {
  13.         if (event.getLoggerName().startsWith("com.hlj")) {
  14.             Object[] params = event.getArgumentArray();
  15.             for (int index = 0; index < params.length; index++) {
  16.                 Object param = params[index];
  17.                 // class.isPrimitive() 8种基本类型的时候为 true，其他为false
  18.                 if (!param.getClass().isPrimitive()) {
  19.                     params[index] = JsonUtils.toJsonString(param);
  20.                 }
  21.             }
  22.         }
  23.         return FilterReply.ACCEPT;
  24.     }
  25. }

6、Log4j

6.1、 log4j.properties

  1. ## 必填内容，info/all/.., stdout 为必填，后面的根据log4j.appender.内容进行填写，如果下面有内容则，这里必须加上，
  2. #  level 是日志记录的优先级，分为OFF、FATAL、ERROR、WARN、INFO、DEBUG、ALL或者自定义的级别。
  3. log4j.rootLogger=info, stdout, log, errorlog,proj



  7. #%d: 输出日志时间点的日期或时间，默认格式为ISO8601，也可以在其后指定格式，比如：%d{yyy MMM dd HH:mm:ss,SSS}，输出类似：2002年10月18日 22：10：28，921
  8. #%p: 输出日志信息优先级，即DEBUG，INFO，WARN，ERROR，FATAL,
  9. #%t: 输出产生该日志事件的线程名
  10. #%C: 输出日志信息所属的类目，通常就是所在类的全名
  11. #%M: 输出代码中指定的消息,产生的日志具体信息
  12. #%F: 输出日志消息产生时所在的文件名称
  13. #%L: 输出代码中的行号
  14. #%l: 输出日志事件的发生位置，相当于%C.%M(%F:%L)的组合,包括类目名、发生的线程，以及在代码中的行数。举例：Testlog4.main(TestLog4.java:10)
  15. #%r: 输出自应用启动到输出该log信息耗费的毫秒数
  16. #%x: 输出和当前线程相关联的NDC(嵌套诊断环境),尤其用到像java servlets这样的多客户多线程的应用中。
  17. #%%: 输出一个”%”字符
  18. #%n: 输出一个回车换行符，Windows平台为”\r\n”，Unix平台为”\n”输出日志信息换行
  19. #%hostName : 本地机器名
  20. #%hostAddress : 本地ip地址-->
  21. #可以在%与模式字符之间加上修饰符来控制其最小宽度、最大宽度、和文本的对齐方式。如：
  22. #1) c：指定输出category的名称，最小的宽度是20，如果category的名称小于20的话，默认的情况下右对齐。
  23. #2)%-20c:指定输出category的名称，最小的宽度是20，如果category的名称小于20的话，”-”号指定左对齐。
  24. #3)%.30c:指定输出category的名称，最大的宽度是30，如果category的名称大于30的话，就会将左边多出的字符截掉，但小于30的话也不会有空格。
  25. #4) .30c:如果category的名称小于20就补空格，并且右对齐，如果其名称长于30字符，就从左边交远销出的字符截掉


  28. # RollingFileAppender按log文件最大长度限度生成新文件
  29. # DailyRollingFileAppender按日期生成新文件,不能根据大小清除历史日志，但是我们可以自定义来实现

  31. # %d{yyyy-MM-dd HH:mm:ss,SSS}日期    %p級別 %t当前线程名称   %m日志信息   [%C.%M]类名加方法    %L行数 %n换行
  32. # 举例 # 2019-07-13 09:05:14,674  [INFO]-[http-nio-8888-exec-1] info日志==================  com.hlj.proj.controler.Log4jController.log4j][25]



  36. # 控制台输出
  37. log4j.appender.stdout=org.apache.log4j.ConsoleAppender
  38. log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
  39. log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS}  [%p]-[%t] %m  %C.%M][%L] %n




  44. ## 根据日期生成配置文件当前log.log 如果时间超过了设置的格式的时间DatePattern 则会在后面加上    log.log.2019-07-12.log
  45. #  解释：也就是说log文件会暂存每天的日志，到第二天时会再加上yyyy-MM，产生当天的完整日志文件
  46. ### Log info
  47. log4j.appender.log = org.apache.log4j.DailyRollingFileAppender
  48. log4j.appender.log.File = /Users/healerjean/Desktop/logs/hlj-log4j.log
  49. log4j.appender.log.Append = true
  50. log4j.appender.log.Threshold = INFO
  51. #超过日期则讲历史日志加上后缀日期用于区分
  52. log4j.appender.log.DatePattern='.'yyyy-MM-dd'.log'
  53. log4j.appender.log.layout = org.apache.log4j.PatternLayout
  54. log4j.appender.log.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS}  [%p]-[%t] %m  %C.%M][%L] %n





  60. ## 5  按照文件大小进行日志切分 文件历史日志依次 error.log.1 error.log.2
  61. log4j.appender.errorlog=org.apache.log4j.RollingFileAppender
  62. log4j.appender.errorlog.File=/Users/healerjean/Desktop/logs/error.log
  63. log4j.appender.errorlog.Append=true
  64. log4j.appender.errorlog.Threshold=error
  65. #设置日志文件的大小
  66. log4j.appender.errorlog.MaxFileSize=2000KB
  67. #保存200个备份文件
  68. log4j.appender.errorlog.MaxBackupIndex=200
  69. log4j.appender.errorlog.layout=org.apache.log4j.PatternLayout
  70. log4j.appender.errorlog.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS}   [%p]-[%t] %m  %C.%M][%L %n



  74. log4j.appender.proj=com.hlj.proj.utils.RoolingAndDateFileAppender
  75. log4j.appender.proj.file=/Users/healerjean/Desktop/logs/logRecoed.log
  76. log4j.appender.proj.Append=true
  77. log4j.appender.proj.DatePattern='.'yyyy-MM-dd'.log'
  78. log4j.appender.proj.Threshold=error
  79. #设置日志文件的大小
  80. log4j.appender.proj.MaxFileSize=5KB
  81. #最大保留多少个文件，超过之后会进行重新命名，所以尽量不要超过
  82. log4j.appender.proj.maxIndex=10
  83. #只保留多长时间的
  84. log4j.appender.proj.expirDays=1
  85. log4j.appender.proj.layout=org.apache.log4j.PatternLayout
  86. log4j.appender.proj.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS}  [%p]-[%t] %m  %C.%M][%L] %n

7、Log4j2

log4j一直存在两个问题，一是打日志影响到系统性能效率，二是有多线程的时候，日志会比较乱

log4j2是log4j 1.x 的升级版，参考了logback的一些优秀的设计，并且修复了一些问题，因此带来了一些重大的提升，主要有：

  1. 异常处理，在logback中，Appender中的异常不会被应用感知到，但是在log4j2中，提供了一些异常处理机制。

  3. 性能提升， log4j2相较于log4j 1和logback都具有很明显的性能提升，后面会有官方测试的数据。

  5. 自动重载配置，参考了logback的设计，当然会提供自动刷新参数配置，最实用的就是我们在生产上可以动态的修改日志的级别而不需要重启应用——那对监控来说，是非常敏感的。

  7. 无垃圾机制，log4j2在大部分情况下，都可以使用其设计的一套无垃圾机制，避免频繁的日志收集导致的jvm gc。

7.1、 log4j2.xml

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


  4. <!--status  Configuration后面的status，这个用于设置log4j2自身内部的信息输出，可以不设置，当设置成trace时，
  5.  你会看到log4j2内部各种详细输出。可以设置成OFF(关闭)或Error(只输出错误信息)-->
  6. <!--monitorInterval：Log4j能够自动检测修改配置 文件和重新配置本身，设置间隔秒数-->
  7. <configuration status="error" monitorInterval="30">
  8.     <!--    %d{yyyy-MM-dd HH:mm:ss, SSS} : 日志生产时间-->
  9.     <!--    %p : 日志输出格式-->
  10.     <!--    %thread表示线程名，-->
  11.     <!--    %c : logger的名称-->
  12.     <!--    %m : 日志内容，即 logger.info("message")-->
  13.     <!--    %n : 换行符-->
  14.     <!--    %C : Java类名-->
  15.     <!--    %L : 日志输出所在行数-->
  16.     <!--    %M : 日志输出所在方法名-->
  17.     <!--    hostName : 本地机器名-->
  18.     <!--    hostAddress : 本地ip地-->

  20.     <!-- 日志文件目录和压缩文件目录配置 -->
  21.     <Properties>
  22.         <Property name="level">info</Property>
  23.         <Property name="LOG_PATTERN">
  24.             %d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level -[%-32X{REQ_UID}]- %msg%xEx %logger{36}.%M[%L]%n
  25.         </Property>

  27.         <Property name="logDri">/Users/healerjean/Desktop/logs</Property>
  28.         <Property name="logFileName">hlj-client</Property>

  30.         <Property name="infoLogDri">${logDri}/info</Property>
  31.         <Property name="infoLogGz">${infoLogDri}/gz</Property>
  32.         <Property name="infoLogFileName">${logFileName}.log</Property>

  34.         <Property name="errorLogDri">${logDri}/error</Property>
  35.         <Property name="errorLogGz">${errorLogDri}/gz</Property>
  36.         <Property name="errorLogFileName">${logFileName}.error</Property>

  38.     </Properties>

  40.     <appenders>
  41.         <console name="Console" target="SYSTEM_OUT">
  42.             <!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
  43.             <ThresholdFilter level="${level}" onMatch="ACCEPT" onMismatch="NEUTRAL"/>
  44.             <!--输出日志的格式-->
  45.             <PatternLayout pattern="${LOG_PATTERN}"/>
  46.         </console>


  49.         <!-- 这个会打印出所有的info及以下级别的信息，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档-->
  50.         <RollingRandomAccessFile name="infoFile" fileName="${infoLogDri}/${infoLogFileName}"
  51.                                  filePattern="${infoLogGz}/$${date:yyyy-MM}/%d{yyyy-MM-dd}-%i.${infoLogFileName}.gz">
  52.             <PatternLayout pattern="${LOG_PATTERN}"/>
  53.             <Policies>
  54.                 <!-- 基于指定文件大小的滚动策略，size属性用来定义每个日志文件的大小 -->
  55.                 <SizeBasedTriggeringPolicy size="500 MB"/>
  56.                 <!-- 基于时间的滚动策略，interval属性用来指定多久滚动一次，默认是1 hour -->
  57.                 <TimeBasedTriggeringPolicy interval="6" modulate="true"/>
  58.             </Policies>
  59.             <Filters>
  60.                 <!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch）
  61.                 onMatch属性设置为DENY，过滤掉高等级的日志；onMismatch设置为NEUTRAL，把低等级的日志放行，
  62.                 -->
  63.                 <ThresholdFilter level="error" onMatch="ACCEPT" onMismatch="NEUTRAL"/>
  64.                 <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
  65.             </Filters>
  66.             <!-- 指定每天(文件夹是以天的，看上面的)的最大压缩包个数，默认7个，超过了会覆盖之前的(用来指定同一个文件夹下最多有几个日志文件时开始删除最旧的，创建新的(通过max属性)) -->
  67.             <DefaultRolloverStrategy max="2000"/>
  68.         </RollingRandomAccessFile>


  71.         <!-- 这个会打印出所有的info及以下级别的信息，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档-->
  72.         <RollingRandomAccessFile name="errorFile" fileName="${errorLogDri}/${errorLogFileName}"
  73.                                  filePattern="${errorLogGz}/$${date:yyyy-MM}/%d{yyyy-MM-dd}-%i.${errorLogFileName}.gz">
  74.             <PatternLayout pattern="${LOG_PATTERN}"/>
  75.             <Policies>
  76.                 <!-- 基于指定文件大小的滚动策略，size属性用来定义每个日志文件的大小 -->
  77.                 <SizeBasedTriggeringPolicy size="500 MB"/>
  78.                 <!-- 基于时间的滚动策略，interval属性用来指定多久滚动一次，默认是1 hour -->
  79.                 <TimeBasedTriggeringPolicy interval="6" modulate="true"/>
  80.             </Policies>
  81.             <Filters>
  82.                 <!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch）
  83.                 onMatch属性设置为DENY，过滤掉高等级的日志；onMismatch设置为NEUTRAL，把低等级的日志放行，
  84.                 -->
  85.                 <ThresholdFilter level="error" onMatch="ACCEPT" onMismatch="DENY"/>
  86.             </Filters>
  87.             <!-- 指定每天(文件夹是以天的，看上面的)的最大压缩包个数，默认7个，超过了会覆盖之前的(用来指定同一个文件夹下最多有几个日志文件时开始删除最旧的，创建新的(通过max属性)) -->
  88.             <DefaultRolloverStrategy max="2000"/>
  89.         </RollingRandomAccessFile>


  92.     </appenders>


  95.     <!--然后定义logger，只有定义了logger并引入的appender，appender才会生效-->
  96.     <loggers>
  97.         <!-- AsyncRoot - 异步记录日志 - 需要LMAX Disruptor的支持 -->
  98.         <!-- additivity如果设置为true将会输出两次日志，意思和log4j里面意思是否追加 -->
  99.         <AsyncRoot level="${level}" additivity="false" includeLocation="true">
  100.             <AppenderRef ref="Console"/>
  101.             <AppenderRef ref="infoFile"/>
  102.             <AppenderRef ref="errorFile"/>
  103.         </AsyncRoot>
  104.     </loggers>


  107. </configuration>

7.1.1、日志打印位置

main方法和服务器日志都在一起

8、日志唯一标识追踪

1、Controll入参和出参打印

2、唯一标识

8.1、日志格式

8.1.1、log4j

  1. %d{yyyy-MM-dd HH:mm:ss} %-5level -[%-32X{REQ_UID}]- %msg%xEx %logger{36}.%M[%L]%n

8.1.1、logback

  1. %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level -[%-32X{REQ_UID}] - %msg  -%logger{50}.%M[%L]%n

8.2、过滤器 Log4j2ReqUidFilter

  1. package com.healerjean.proj.config.filter;


  4. import org.slf4j.MDC;

  6. import javax.servlet.*;
  7. import java.io.IOException;
  8. import java.util.UUID;

  10. /**
  11.  * @author HealerJean
  12.  * @ClassName Log4j2Filter
  13.  * @date 2020/6/15  20:12.
  14.  * @Description
  15.  */
  16. public class Log4j2ReqUidFilter implements Filter {

  18.     private static final String REQ_UID = "REQ_UID";
  19.     private FilterConfig filterConfig;


  22.     @Override
  23.     public void init(FilterConfig filterConfig) throws ServletException {
  24.         this.filterConfig = filterConfig;
  25.     }

  27.     @Override
  28.     public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
  29.         MDC.put(REQ_UID, UUID.randomUUID().toString().replace("-", ""));
  30.         filterChain.doFilter(servletRequest, servletResponse);
  31.         MDC.remove(REQ_UID);
  32.     }

  34.     @Override
  35.     public void destroy() {
  36.         this.filterConfig = null;
  37.     }



  41. }
  1. @Bean
  2. public FilterRegistrationBean log4j2Fiter() {
  3.     FilterRegistrationBean fitler = new FilterRegistrationBean();
  4.     fitler.setFilter(new Log4j2Filter());
  5.     fitler.addUrlPatterns("/*");
  6.     fitler.setName("log4j2Fiter");
  7.     fitler.setDispatcherTypes(DispatcherType.REQUEST);
  8.     return fitler;
  9. }

9、日志Controller出参入参打印

9.1、pom依赖

  1. <!-- aop 切面 -->
  2. <dependency>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-starter-aop</artifactId>
  5. </dependency>

9.2、自定义注解标识方法名字

  1. @Documented
  2. @Target(ElementType.METHOD)
  3. @Retention(RetentionPolicy.RUNTIME)
  4. public @interface InterfaceName {

  6.     String value() default "";
  7. }
  1. @InterfaceName("demo控制器--------demo实体")
  2. @ApiOperation(value = "demo实体",
  3.               notes = "demo实体",
  4.               consumes = MediaType.APPLICATION_FORM_URLENCODED_VALUE,
  5.               produces = MediaType.APPLICATION_JSON_UTF8_VALUE,
  6.               response = DemoDTO.class)
  7. @GetMapping(value = "demo/get", produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
  8. @ResponseBody
  9. public ResponseBean get(DemoDTO demoDTO) {
  10.     String validate = ValidateUtils.validate(demoDTO, ValidateGroup.HealerJean.class);
  11.     if (!validate.equals(CommonConstants.COMMON_SUCCESS)) {
  12.         throw new BusinessException(ResponseEnum.参数错误, validate);
  13.     }
  14.     return ResponseBean.buildSuccess(demoEntityService.getMmethod(demoDTO));
  15. }

9.3、AOP拦截

  1. package com.healerjean.proj.config.aspect;

  3. import com.healerjean.proj.annotation.InterfaceName;
  4. import lombok.extern.slf4j.Slf4j;
  5. import org.aspectj.lang.ProceedingJoinPoint;
  6. import org.aspectj.lang.Signature;
  7. import org.aspectj.lang.annotation.Around;
  8. import org.aspectj.lang.annotation.Aspect;
  9. import org.aspectj.lang.reflect.MethodSignature;
  10. import org.springframework.core.annotation.Order;
  11. import org.springframework.stereotype.Component;

  13. import java.lang.reflect.Method;

  15. @Aspect
  16. @Component
  17. @Slf4j
  18. @Order(1)
  19. public class ControllerLogAspect {



  23.     @Around("execution(* com.healerjean.proj.controller.*Controller.*(..))")
  24.     public Object handleControllerLog(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
  25.         Signature signature = proceedingJoinPoint.getSignature();
  26.         String className = signature.getDeclaringTypeName();
  27.         String methodName = signature.getName();
  28.         Object[] args = proceedingJoinPoint.getArgs();

  30.         String value = "";
  31.         Method method = ((MethodSignature) signature).getMethod();
  32.         if (method.isAnnotationPresent(InterfaceName.class)) {
  33.             value = "请求接口：【" + method.getAnnotation(InterfaceName.class).value() + "】，";
  34.         }

  36.         long start = System.currentTimeMillis();
  37.         try {
  38.             log.info("请求开始：{}类名：【{}】，方法名:【{}】, 参数:【{}】", value, className, methodName, args);
  39.             Object result = proceedingJoinPoint.proceed();
  40.             long timeCost = System.currentTimeMillis() - start;
  41.             log.info("请求结束：{}类名：【{}】， 方法名:【{}】, 参数:【{}】, 返回值:{}, 耗时:{}ms。", value, className, methodName, args, result, timeCost);
  42.             return result;
  43.         } catch (Exception e) {
  44.             long timeCost = System.currentTimeMillis() - start;
  45.             log.info("请求出错：{}类名：【{}】，方法名:【{}】, 参数:【{}】, 耗时:【{}】ms。", value, className, methodName, args, timeCost);
  46.             throw e;
  47.         }
  48.     }
  49. }

10、dubbo日志追踪

10.1、服务提供者

10.1.1、aop切面pom依赖

  1. <!-- aop 切面 -->
  2. <dependency>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-starter-aop</artifactId>
  5. </dependency>

10.1.2、 ServiceLogAspect
接口出入参日志打印

  1. package com.healerjean.proj.config.aspect;

  3. import lombok.extern.slf4j.Slf4j;
  4. import org.aspectj.lang.ProceedingJoinPoint;
  5. import org.aspectj.lang.Signature;
  6. import org.aspectj.lang.annotation.Around;
  7. import org.aspectj.lang.annotation.Aspect;
  8. import org.springframework.core.annotation.Order;
  9. import org.springframework.stereotype.Component;


  12. @Aspect
  13. @Component
  14. @Slf4j
  15. @Order(1)
  16. public class ServiceLogAspect {

  18.     @Around("execution(* com.healerjean.proj.service.*Service.*(..))")
  19.     public Object handleControllerLog(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
  20.         Signature signature = proceedingJoinPoint.getSignature();
  21.         String className = signature.getDeclaringTypeName();
  22.         String methodName = signature.getName();
  23.         Object[] args = proceedingJoinPoint.getArgs();
  24.         long start = System.currentTimeMillis();
  25.         try {
  26.             log.info("请求开始：类名：【{}】，方法名:【{}】, 参数:【{}】", className, methodName, args);
  27.             Object result = proceedingJoinPoint.proceed();
  28.             long timeCost = System.currentTimeMillis() - start;
  29.             log.info("请求结束：类名：【{}】， 方法名:【{}】, 参数:【{}】, 返回值:{}, 耗时:{}ms。", className, methodName, args, result, timeCost);
  30.             return result;
  31.         } catch (Exception e) {
  32.             long timeCost = System.currentTimeMillis() - start;
  33.             log.info("请求出错：类名：【{}】，方法名:【{}】, 参数:【{}】, 耗时:【{}】ms。", className, methodName, args, timeCost);
  34.             throw e;
  35.         }
  36.     }
  37. }

10.1.3、 ProviderRpcTraceFilter
dubbo日志追踪过滤器

  1. package com.healerjean.proj.config.dubbo;

  3. import com.alibaba.dubbo.common.Constants;
  4. import com.alibaba.dubbo.common.extension.Activate;
  5. import com.alibaba.dubbo.rpc.*;
  6. import com.alibaba.dubbo.rpc.protocol.dubbo.filter.FutureFilter;
  7. import org.apache.commons.lang3.StringUtils;
  8. import org.slf4j.MDC;

  10. import java.util.UUID;

  12. @Activate(group = Constants.PROVIDER, order = 1)
  13. public class ProviderRpcTraceFilter extends FutureFilter {


  16.     private static final String DUBBO_REQ_UID = "REQ_UID";

  18.     @Override
  19.     public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
  20.         String reqUid = RpcContext.getContext().getAttachment(DUBBO_REQ_UID);
  21.         if (StringUtils.isBlank(reqUid)) {
  22.             //传递丢失
  23.             reqUid = "CUSTOM:" + UUID.randomUUID().toString().replace("-", "");
  24.         }
  25.         MDC.put(DUBBO_REQ_UID, reqUid);
  26.         RpcContext.getContext().setAttachment(DUBBO_REQ_UID, reqUid);
  27.         try {
  28.             return invoker.invoke(invocation);
  29.         } finally {
  30.             MDC.remove(DUBBO_REQ_UID);
  31.         }
  32.     }
  33. }

10.1.4、配置dubbo过滤器

com.alibaba.dubbo.rpc.Filter

  1. ProviderRpcTraceFilter=com.healerjean.proj.config.dubbo.ProviderRpcTraceFilter

10.2、服务消费者

10.2.1、aop切面pom依赖

  1. <!-- aop 切面 -->
  2. <dependency>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-starter-aop</artifactId>
  5. </dependency>

10.2.2、 ControllerLogAspect
controller出入参打印

  1. package com.healerjean.proj.config.aspect;

  3. import lombok.extern.slf4j.Slf4j;
  4. import org.aspectj.lang.ProceedingJoinPoint;
  5. import org.aspectj.lang.Signature;
  6. import org.aspectj.lang.annotation.Around;
  7. import org.aspectj.lang.annotation.Aspect;
  8. import org.springframework.core.annotation.Order;
  9. import org.springframework.stereotype.Component;


  12. @Aspect
  13. @Component
  14. @Slf4j
  15. @Order(1)
  16. public class ControllerLogAspect {

  18.     @Around("execution(* com.healerjean.proj.controller.*Controller.*(..))")
  19.     public Object handleControllerLog(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
  20.         Signature signature = proceedingJoinPoint.getSignature();
  21.         String className = signature.getDeclaringTypeName();
  22.         String methodName = signature.getName();
  23.         Object[] args = proceedingJoinPoint.getArgs();
  24.         long start = System.currentTimeMillis();
  25.         try {
  26.             log.info("请求开始：类名：【{}】，方法名:【{}】, 参数:【{}】", className, methodName, args);
  27.             Object result = proceedingJoinPoint.proceed();
  28.             long timeCost = System.currentTimeMillis() - start;
  29.             log.info("请求结束：类名：【{}】， 方法名:【{}】, 参数:【{}】, 返回值:{}, 耗时:{}ms。", className, methodName, args, result, timeCost);
  30.             return result;
  31.         } catch (Exception e) {
  32.             long timeCost = System.currentTimeMillis() - start;
  33.             log.info("请求出错：类名：【{}】，方法名:【{}】, 参数:【{}】, 耗时:【{}】ms。", className, methodName, args, timeCost);
  34.             throw e;
  35.         }
  36.     }
  37. }

10.2.3、日志追踪过滤器

  1. package com.healerjean.proj.config.filter;


  4. import org.slf4j.MDC;

  6. import javax.servlet.*;
  7. import java.io.IOException;
  8. import java.util.UUID;

  10. /**
  11.  * @author HealerJean
  12.  * @ClassName Log4j2Filter
  13.  * @date 2020/6/15  20:12.
  14.  * @Description
  15.  */
  16. public class Log4j2ReqUidFilter implements Filter {

  18.     private static final String REQ_UID = "REQ_UID";
  19.     private FilterConfig filterConfig;


  22.     @Override
  23.     public void init(FilterConfig filterConfig) throws ServletException {
  24.         this.filterConfig = filterConfig;
  25.     }

  27.     @Override
  28.     public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
  29.         MDC.put(REQ_UID, UUID.randomUUID().toString().replace("-", ""));
  30.         filterChain.doFilter(servletRequest, servletResponse);
  31.         MDC.remove(REQ_UID);
  32.     }

  34.     @Override
  35.     public void destroy() {
  36.         this.filterConfig = null;
  37.     }



  41. }
  1. @Configuration
  2. public class InterceptorConfig extends WebMvcConfigurerAdapter {

  4.     @Bean
  5.     public FilterRegistrationBean log4j2ReqUidFilter() {
  6.         FilterRegistrationBean fitler = new FilterRegistrationBean();
  7.         fitler.setFilter(new Log4j2ReqUidFilter());
  8.         fitler.addUrlPatterns("/*");
  9.         fitler.setName("Log4j2ReqUidFilter");
  10.         fitler.setDispatcherTypes(DispatcherType.REQUEST);
  11.         return fitler;
  12.     }
  13. }

10.2.4、 ConsumerRpcTraceFilter
dubbo日志追踪过滤器

  1. package com.healerjean.proj.config.dubbo;

  3. import com.alibaba.dubbo.common.Constants;
  4. import com.alibaba.dubbo.common.extension.Activate;
  5. import com.alibaba.dubbo.rpc.*;
  6. import com.alibaba.dubbo.rpc.protocol.dubbo.filter.FutureFilter;
  7. import org.apache.commons.lang3.StringUtils;
  8. import org.slf4j.MDC;

  10. import java.util.UUID;

  12. @Activate(group = Constants.CONSUMER, order = 1)
  13. public class ConsumerRpcTraceFilter extends FutureFilter {


  16.     private static final String DUBBO_REQ_UID = "REQ_UID";

  18.     @Override
  19.     public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
  20.         RpcContext.getContext().setAttachment(DUBBO_REQ_UID, MDC.get(DUBBO_REQ_UID));
  21.         return invoker.invoke(invocation);
  22.     }
  23. }

10.2.5、配置dubbo过滤器

com.alibaba.dubbo.rpc.Filter

  1. ConsumerRpcTraceFilter=com.healerjean.proj.config.dubbo.ConsumerRpcTraceFilter


数据库
文章转载自荒凉 技术路，如果涉嫌侵权，请发送邮件至：contact@modb.pro进行举报，并提供相关证据，一经查实，墨天轮将立刻删除相关内容。

评论