日志套餐篇 - log4j2 logback全量套餐

前情提要：

Log4j Log4j2 logback是当下主流的日志框架

slf4j则是新一代的日志框架接口，logback直接实现了slf4j接口，另外logback是SpringBoot最新的默认日志框架

综合来看性能上依然推荐：log4j2（拥有logback全部特性）

**注：**鉴于log4j已经跟不上时代的要求，因此不做特别的介绍，其实log4j的配置，完全可以在log4j2上使用

普通工程 - 建议集成log4j2

普通工程即：普通的java项目, 如个人的代码Demo或者准备打成jar使用的，推荐使用log4j2

必要依赖如下：

  1. <!-- log4j2 必要依赖 -->
  2. <dependency>
  3.     <groupId>org.apache.logging.log4j</groupId>
  4.     <artifactId>log4j-api</artifactId>
  5.     <version>2.10.0</version>
  6. </dependency>
  8. <!-- log4j2 必要依赖 -->
  9. <dependency>
  10.     <groupId>org.apache.logging.log4j</groupId>
  11.     <artifactId>log4j-core</artifactId>
  12.     <version>2.10.0</version>
  13. </dependency>
  15. <!-- slf4j核心包 -->
  16. <dependency>
  17.     <groupId>org.slf4j</groupId>
  18.     <artifactId>slf4j-api</artifactId>
  19.     <version>1.7.25</version>
  20. </dependency>
  22. <!--用于与slf4j保持桥接-->
  23. <dependency>
  24.     <groupId>org.apache.logging.log4j</groupId>
  25.     <artifactId>log4j-slf4j-impl</artifactId>
  26.     <version>2.10.0</version>
  27. </dependency>

配置如下：

Maven项目只需要在resource里面加入log4j2.xml配置文件即可

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!--日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL -->
  3. <!--Configuration后面的status，这个用于设置log4j2自身内部的信息输出，可以不设置，当设置成trace时，你会看到log4j2内部各种详细输出-->
  4. <!--monitorInterval：Log4j能够自动检测修改配置 文件和重新配置本身，设置间隔秒数-->
  5. <Configuration status="WARN" monitorInterval="30">
  7.     <!--全局属性-->
  8.     <Properties>
  9.         <Property name="APP_NAME">kerwinTools</Property>
  10.         <Property name="LOG_FILE_PATH">/log/${APP_NAME}</Property>
  11.         <Property name="PATTERN_FORMAT">%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level [%t] %class{36} (%L) %M - %msg%xEx%n</Property>
  12.     </Properties>
  14.     <Appenders>
  15.         <!--输出到控制台-->
  16.         <Console name="Console" target="SYSTEM_OUT">
  17.             <PatternLayout pattern="${PATTERN_FORMAT}"/>
  18.         </Console>
  20.         <!-- INFO_LOG -->
  21.         <RollingFile name="INFO_LOG" fileName="${LOG_FILE_PATH}/info.log" filePattern="${LOG_HOME}/info.log_%d{yyyy-MM-dd}.log">
  22.             <!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
  23.             <Filters>
  24.                 <ThresholdFilter level="warn" onMatch="DENY" onMismatch="NEUTRAL"/>
  25.                 <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
  26.             </Filters>
  27.             <PatternLayout>
  28.                 <pattern>${PATTERN_FORMAT}</pattern>
  29.             </PatternLayout>
  30.             <Policies>
  31.                 <TimeBasedTriggeringPolicy interval="1" modulate="true" />
  32.             </Policies>
  33.             <DefaultRolloverStrategy>
  34.                 <Delete basePath="${LOG_FILE_PATH}" maxDepth="1">
  35.                     <IfFileName glob="info.log_*" />
  36.                     <IfLastModified age="5d" />
  37.                 </Delete>
  38.             </DefaultRolloverStrategy>
  39.         </RollingFile>
  41.         <!-- DEBUG_LOG -->
  42.         <RollingFile name="DEBUG_LOG" fileName="${LOG_FILE_PATH}/debug.log" filePattern="${LOG_HOME}/debug.log_%d{yyyy-MM-dd}.log">
  43.             <!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
  44.             <Filters>
  45.                 <ThresholdFilter level="error" onMatch="DENY" onMismatch="NEUTRAL"/>
  46.                 <ThresholdFilter level="debug" onMatch="ACCEPT" onMismatch="DENY"/>
  47.             </Filters>
  48.             <PatternLayout>
  49.                 <pattern>${PATTERN_FORMAT}</pattern>
  50.             </PatternLayout>
  51.             <Policies>
  52.                 <TimeBasedTriggeringPolicy interval="1" modulate="true" />
  53.             </Policies>
  54.             <DefaultRolloverStrategy>
  55.                 <Delete basePath="${LOG_FILE_PATH}" maxDepth="1">
  56.                     <IfFileName glob="debug.log_*" />
  57.                     <IfLastModified age="5d" />
  58.                 </Delete>
  59.             </DefaultRolloverStrategy>
  60.         </RollingFile>
  62.         <!-- ERROR_LOG -->
  63.         <RollingFile name="ERROR_LOG" fileName="${LOG_FILE_PATH}/error.log" filePattern="${LOG_HOME}/error.log_%d{yyyy-MM-dd}.log">
  64.             <!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
  65.             <ThresholdFilter level="error" onMatch="ACCEPT" onMismatch="DENY"/>
  66.             <PatternLayout>
  67.                 <pattern>${PATTERN_FORMAT}</pattern>
  68.             </PatternLayout>
  69.             <Policies>
  70.                 <TimeBasedTriggeringPolicy interval="1" modulate="true" />
  71.             </Policies>
  72.             <DefaultRolloverStrategy>
  73.                 <Delete basePath="${LOG_FILE_PATH}" maxDepth="1">
  74.                     <IfFileName glob="error.log_*" />
  75.                     <IfLastModified age="5d" />
  76.                 </Delete>
  77.             </DefaultRolloverStrategy>
  78.         </RollingFile>
  79.     </Appenders>
  81.     <Loggers>
  82.         <!-- LOG everything at DEBUG level 默认级别为DEBUG -->
  83.         <Root level="DEBUG">
  84.             <AppenderRef ref="Console"/>
  85.             <AppenderRef ref="INFO_LOG"/>
  86.             <AppenderRef ref="DEBUG_LOG"/>
  87.             <AppenderRef ref="ERROR_LOG"/>
  88.         </Root>
  89.     </Loggers>
  90. </Configuration>

**注：**日志打印的位置我并没用做特别的约束，所以它会在项目所存储的盘符自动建立${APP_NAME} 文件夹

效果如图所示：

SpringBoot项目 - 个人练习建议集成logback

  1. // 由于springboot默认支持logbak  因此无需任何依赖即可使用,当然需要一些默认的必备依赖 如 web等...

application配置如下：

  1. # 约束mybis-dao级别为dao层
  2. logging.level.com.cat.dao=DEBUG
  3. logging.config=classpath:logback-spring.xml
  4. # 文件输出位置即文件夹名称
  5. logging.file=/log/volcat-server

配置文件如下：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!-- 日志级别从低到高分为TRACE < DEBUG < INFO < WARN < ERROR < FATAL，如果设置为WARN，则低于WARN的信息都不会输出 -->
  3. <!-- scan:当此属性设置为true时，配置文件如果发生改变，将会被重新加载，默认值为true -->
  4. <!-- scanPeriod:设置监测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒。当scan为true时，此属性生效。默认的时间间隔为1分钟。 -->
  5. <!-- debug:当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。 -->
  6. <configuration  scan="true" scanPeriod="10 seconds">
  8.     <contextName>logback</contextName>
  10.     <!-- 命名为logback-spring 可以读取spring中的配置信息, 以下即为读取spring的日志输出地址 -->
  11.     <springProperty scope="context" name="log.path" source="logging.file"/>
  13.     <!-- 在当前文件中约束配置地址 -->
  14.     <!--<property name="log.path" value="/log/demo_test_nginx" />-->
  16.     <!--
  17.        <logger>用来设置某一个包或者具体的某一个类的日志打印级别、
  18.        以及指定<appender>。<logger>仅有一个name属性，
  19.        一个可选的level和一个可选的addtivity属性。
  20.        name:用来指定受此logger约束的某一个包或者具体的某一个类。
  21.        level:用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF，
  22.              还有一个特俗值INHERITED或者同义词NULL，代表强制执行上级的级别。
  23.              如果未设置此属性，那么当前logger将会继承上级的级别。
  24.        addtivity:是否向上级logger传递打印信息。默认是true
  25.    -->
  27.     <!-- 彩色日志 -->
  28.     <!-- 彩色日志依赖的渲染类 -->
  29.     <conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter" />
  30.     <conversionRule conversionWord="wex" converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter" />
  31.     <conversionRule conversionWord="wEx" converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter" />
  33.     <!-- 彩色日志格式 -->
  34.     <property name="CONSOLE_LOG_PATTERN" value="${CONSOLE_LOG_PATTERN:-%clr(%d{yyyy-MM-dd HH:mm:ss}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39} %line){cyan} %clr(:) %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}"/>
  36.     <!--输出到控制台-->
  37.     <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
  38.         <!--此日志appender是为开发使用，配置为DEBUG级别, 控制台输出的日志级别是大于或等于此级别的日志信息-->
  39.         <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
  40.             <level>debug</level>
  41.         </filter>
  42.         <encoder>
  43.             <Pattern>${CONSOLE_LOG_PATTERN}</Pattern>
  44.             <!-- 设置字符集 -->
  45.             <charset>UTF-8</charset>
  46.         </encoder>
  47.     </appender>
  49.     <!--输出到文件-->
  50.     <!-- 时间滚动输出 level为 DEBUG 日志 -->
  51.     <appender name="DEBUG_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
  52.         <!-- 正在记录的日志文件的路径及文件名 -->
  53.         <file>${log.path}/debug.log</file>
  54.         <!--日志文件输出格式-->
  55.         <encoder>
  56.             <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
  57.             <charset>UTF-8</charset> <!-- 设置字符集 -->
  58.         </encoder>
  59.         <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
  60.         <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
  61.             <!-- 日志归档 -->
  62.             <fileNamePattern>${log.path}/debug/debug-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
  63.             <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
  64.                 <maxFileSize>100MB</maxFileSize>
  65.             </timeBasedFileNamingAndTriggeringPolicy>
  66.             <!--日志文件保留天数-->
  67.             <maxHistory>15</maxHistory>
  68.         </rollingPolicy>
  69.         <!-- 此日志文件只记录debug级别的 -->
  70.         <filter class="ch.qos.logback.classic.filter.LevelFilter">
  71.             <level>debug</level>
  72.             <onMatch>ACCEPT</onMatch>
  73.             <onMismatch>DENY</onMismatch>
  74.         </filter>
  75.     </appender>
  77.     <!-- 时间滚动输出 level为 INFO 日志 -->
  78.     <appender name="INFO_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
  79.         <!-- 正在记录的日志文件的路径及文件名 -->
  80.         <file>${log.path}/info.log</file>
  81.         <!--日志文件输出格式-->
  82.         <encoder>
  83.             <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
  84.             <charset>UTF-8</charset>
  85.         </encoder>
  86.         <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
  87.         <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
  88.             <!-- 每天日志归档路径以及格式 -->
  89.             <fileNamePattern>${log.path}/info/info-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
  90.             <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
  91.                 <maxFileSize>100MB</maxFileSize>
  92.             </timeBasedFileNamingAndTriggeringPolicy>
  93.             <!--日志文件保留天数-->
  94.             <maxHistory>15</maxHistory>
  95.         </rollingPolicy>
  96.         <!-- 此日志文件只记录info级别的 -->
  97.         <filter class="ch.qos.logback.classic.filter.LevelFilter">
  98.             <level>info</level>
  99.             <onMatch>ACCEPT</onMatch>
  100.             <onMismatch>DENY</onMismatch>
  101.         </filter>
  102.     </appender>
  104.     <!-- 时间滚动输出 level为 WARN 日志 -->
  105.     <appender name="WARN_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
  106.         <!-- 正在记录的日志文件的路径及文件名 -->
  107.         <file>${log.path}/warn.log</file>
  108.         <!--日志文件输出格式-->
  109.         <encoder>
  110.             <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
  111.             <charset>UTF-8</charset> <!-- 此处设置字符集 -->
  112.         </encoder>
  113.         <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
  114.         <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
  115.             <fileNamePattern>${log.path}/warn/warn-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
  116.             <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
  117.                 <maxFileSize>100MB</maxFileSize>
  118.             </timeBasedFileNamingAndTriggeringPolicy>
  119.             <!--日志文件保留天数-->
  120.             <maxHistory>15</maxHistory>
  121.         </rollingPolicy>
  122.         <!-- 此日志文件只记录warn级别的 -->
  123.         <filter class="ch.qos.logback.classic.filter.LevelFilter">
  124.             <level>warn</level>
  125.             <onMatch>ACCEPT</onMatch>
  126.             <onMismatch>DENY</onMismatch>
  127.         </filter>
  128.     </appender>
  130.     <!-- 时间滚动输出 level为 ERROR 日志 -->
  131.     <appender name="ERROR_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
  132.         <!-- 正在记录的日志文件的路径及文件名 -->
  133.         <file>${log.path}/error.log</file>
  134.         <!--日志文件输出格式-->
  135.         <encoder>
  136.             <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
  137.             <charset>UTF-8</charset> <!-- 此处设置字符集 -->
  138.         </encoder>
  139.         <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
  140.         <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
  141.             <fileNamePattern>${log.path}/error/error-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
  142.             <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
  143.                 <maxFileSize>100MB</maxFileSize>
  144.             </timeBasedFileNamingAndTriggeringPolicy>
  145.             <!--日志文件保留天数-->
  146.             <maxHistory>15</maxHistory>
  147.         </rollingPolicy>
  148.         <!-- 此日志文件只记录ERROR级别的 -->
  149.         <filter class="ch.qos.logback.classic.filter.LevelFilter">
  150.             <level>ERROR</level>
  151.             <onMatch>ACCEPT</onMatch>
  152.             <onMismatch>DENY</onMismatch>
  153.         </filter>
  154.     </appender>
  156.     <!--
  157.         root节点是必选节点，用来指定最基础的日志输出级别，只有一个level属性
  158.         level:用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF，
  159.         不能设置为INHERITED或者同义词NULL。默认是DEBUG
  160.         可以包含零个或多个元素，标识这个appender将会添加到这个logger。
  161.     -->
  162.     <root level="info">
  163.         <appender-ref ref="CONSOLE" />
  164.         <appender-ref ref="DEBUG_FILE" />
  165.         <appender-ref ref="INFO_FILE" />
  166.         <appender-ref ref="WARN_FILE" />
  167.         <appender-ref ref="ERROR_FILE" />
  168.     </root>
  169. </configuration>

SpringBoot项目 - 集成log4j2

必备依赖 - 既然是SpringBoot项目,那用官方的starter是最好的，版本什么的都不用管

  1. <dependency>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-web</artifactId>
  4.     <exclusions>
  5.         <!-- 去除logback日志依赖 -->
  6.         <exclusion>
  7.             <groupId>org.springframework.boot</groupId>
  8.             <artifactId>spring-boot-starter-logging</artifactId>
  9.         </exclusion>
  10.     </exclusions>
  11. </dependency>
  13. <!-- 导入log4j2-starter -->
  14. <dependency>
  15.     <groupId>org.springframework.boot</groupId>
  16.     <artifactId>spring-boot-starter-log4j2</artifactId>
  17. </dependency>
  19. <!-- log4j2 异步打印必要依赖 -->
  20. <dependency>
  21.     <groupId>com.lmax</groupId>
  22.     <artifactId>disruptor</artifactId>
  23.     <version>3.3.4</version>
  24. </dependency>

applications配置

  1. # mybatis-dao相关的操作为DEBUG级别, 数据库日志会打印到debug文件中
  2. logging.level.com.cat.dao=DEBUG
  3. logging.config=classpath:log4j2.xml

配置文件 - 沿用上面的配置文件即可，必要情况可以修改打印的日志级别，如

  1. .....
  2. <Loggers>
  3.     <!--过滤掉spring和mybatis的一些无用的DEBUG信息-->
  4.     <Logger name="org.springframework" level="INFO"/>
  5.     <Logger name="org.mybatis" level="INFO"/>
  7.     <!-- LOG everything at INFO level -->
  8.     <Root level="INFO">
  9.         <AppenderRef ref="Console"/>
  10.         <AppenderRef ref="INFO_LOG"/>
  11.         <AppenderRef ref="DEBUG_LOG"/>
  12.         <AppenderRef ref="ERROR_LOG"/>
  13.     </Root>
  14. </Loggers>

SpringBoot - log4j2 企业级方案

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <Configuration>
  3.     <properties>
  4.         <property name="LOG_HOME">/log/volcat-server</property>
  5.     </properties>
  6.     <Appenders>
  7.         <!-- 輸出到監視器 -->
  8.         <Console name="Console" target="SYSTEM_OUT">
  9.             <PatternLayout charset="UTF-8" pattern="%date{yyyy-MM-dd HH:mm:ss,SSS} [%thread][%level] - %msg%n" />
  10.         </Console>
  12.         <RollingFile name="error.log" fileName="${LOG_HOME}/error.log" filePattern="${LOG_HOME}/error.log_%d{yyyy-MM-dd}.log">
  13.             <PatternLayout charset="UTF-8" pattern="%date{yyyy-MM-dd HH:mm:ss,SSS} [%thread][%level] - %msg%n" />
  14.             <Policies>
  15.                 <TimeBasedTriggeringPolicy interval="1" modulate="true" />
  16.             </Policies>
  17.          	<DefaultRolloverStrategy>
  18.         		<Delete basePath="${LOG_HOME}" maxDepth="1">
  19.                      <IfFileName glob="error.log_*" />
  20.                      <IfLastModified age="5d" />
  21.             	</Delete>
  22.             </DefaultRolloverStrategy>
  23.         </RollingFile>
  25.         <RollingFile name="debug.log" fileName="${LOG_HOME}/debug.log" filePattern="${LOG_HOME}/debug.log_%d{yyyy-MM-dd}.log">
  26.             <PatternLayout charset="UTF-8" pattern="%date{yyyy-MM-dd HH:mm:ss,SSS} [%thread][%level] - %msg%n" />
  27.             <Policies>
  28.                 <TimeBasedTriggeringPolicy interval="1" modulate="true" />
  29.             </Policies>
  30.          	<DefaultRolloverStrategy>
  31.         		<Delete basePath="${LOG_HOME}" maxDepth="1">
  32.                      <IfFileName glob="debug.log_*" />
  33.                      <IfLastModified age="5d" />
  34.             	</Delete>
  35.             </DefaultRolloverStrategy>
  36.         </RollingFile>
  38.         <RollingFile name="message.log" fileName="${LOG_HOME}/message.log" filePattern="${LOG_HOME}/message.log_%d{yyyy-MM-dd}.log">
  39.             <PatternLayout charset="UTF-8" pattern="%date{yyyy-MM-dd HH:mm:ss,SSS} [%thread][%level] - %msg%n" />
  40.             <Policies>
  41.                 <TimeBasedTriggeringPolicy interval="1" modulate="true" />
  42.             </Policies>
  43.          	<DefaultRolloverStrategy>
  44.         		<Delete basePath="${LOG_HOME}" maxDepth="1">
  45.                      <IfFileName glob="message.log_*" />
  46.                      <IfLastModified age="5d" />
  47.             	</Delete>
  48.             </DefaultRolloverStrategy>
  49.         </RollingFile>
  51.         <RollingFile name="access.log" fileName="${LOG_HOME}/access.log" filePattern="${LOG_HOME}/access.log_%d{yyyy-MM-dd}.log">
  52.             <PatternLayout charset="UTF-8" pattern="%date{yyyy-MM-dd HH:mm:ss,SSS} [%thread][%level] - %msg%n" />
  53.             <Policies>
  54.                 <TimeBasedTriggeringPolicy interval="1" modulate="true" />
  55.             </Policies>
  56.             <DefaultRolloverStrategy>
  57.                 <Delete basePath="${LOG_HOME}" maxDepth="1">
  58.                     <IfFileName glob="access.log_*" />
  59.                     <IfLastModified age="5d" />
  60.                 </Delete>
  61.             </DefaultRolloverStrategy>
  62.         </RollingFile>
  63.     </Appenders>
  64.     <Loggers>
  65.         <Logger name="sys.error" level="ERROR">
  66.             <AppenderRef ref="error.log" />
  67.         </Logger>
  68.         <Logger name="sys.debug" level="DEBUG">
  69.             <AppenderRef ref="debug.log" />
  70.         </Logger>
  71.         <Logger name="sys.message" level="INFO">
  72.             <AppenderRef ref="message.log" />
  73.         </Logger>
  74.         <Logger name="sys.access" level="INFO">
  75.             <AppenderRef ref="access.log" />
  76.         </Logger>
  77.     </Loggers>
  78. </Configuration>

Logit工具类

  1. package com.mine.log;
  3. import org.slf4j.Logger;
  4. import org.slf4j.LoggerFactory;
  6. public class Logit {
  8.     private static final Logger DEBUG_LOG = LoggerFactory.getLogger("sys.debug");
  9.     private static final Logger WARN_LOG = LoggerFactory.getLogger("sys.warn");
  10.     private static final Logger MESSAGE_LOG = LoggerFactory.getLogger("sys.message");
  11.     private static final Logger ACCESS_LOG = LoggerFactory.getLogger("sys.access");
  12.     private static final Logger ERROR_LOG = LoggerFactory.getLogger("sys.error");
  13.     private static final Logger DB_LOG = LoggerFactory.getLogger("db.sql");
  15.     public Logit() {}
  17.     public static void accessLog(String log) {
  18.         ACCESS_LOG.info(log);
  19.     }
  21.     public static void messageLog(String log) {
  22.         StackTraceElement[] stacks = (new Throwable()).getStackTrace();
  23.         StringBuffer sb = new StringBuffer(stacks[1].getClassName());
  24.         sb.append(".");
  25.         sb.append(stacks[1].getMethodName());
  26.         sb.append("---");
  27.         sb.append(log);
  28.         MESSAGE_LOG.info(sb.toString());
  29.     }
  31.     public static void messageLog(String log, String loglevel) {
  32.         StackTraceElement[] stacks = (new Throwable()).getStackTrace();
  33.         StringBuffer sb = new StringBuffer(stacks[1].getClassName());
  34.         sb.append(".");
  35.         sb.append(stacks[1].getMethodName());
  36.         sb.append("---");
  37.         sb.append(log);
  38.         if ("debug".equalsIgnoreCase(loglevel)) {
  39.             MESSAGE_LOG.debug(log);
  40.         } else if ("info".equalsIgnoreCase(loglevel)) {
  41.             MESSAGE_LOG.info(log);
  42.         } else if ("warn".equalsIgnoreCase(loglevel)) {
  43.             MESSAGE_LOG.warn(log);
  44.         } else if ("error".equalsIgnoreCase(loglevel)) {
  45.             MESSAGE_LOG.error(log);
  46.         } else {
  47.             MESSAGE_LOG.info(log);
  48.         }
  50.     }
  52.     public static void debugLog(String log) {
  53.         StackTraceElement[] stacks = (new Throwable()).getStackTrace();
  54.         StringBuffer sb = new StringBuffer(stacks[1].getClassName());
  55.         sb.append(".");
  56.         sb.append(stacks[1].getMethodName());
  57.         sb.append("---");
  58.         sb.append(log);
  59.         debugPlog(sb.toString(), "debug");
  60.     }
  62.     public static void debugLog(String log, String loglevel) {
  63.         StackTraceElement[] stacks = (new Throwable()).getStackTrace();
  64.         StringBuffer sb = new StringBuffer(stacks[1].getClassName());
  65.         sb.append(".");
  66.         sb.append(stacks[1].getMethodName());
  67.         sb.append("---");
  68.         sb.append(log);
  69.         debugPlog(sb.toString(), loglevel);
  70.     }
  72.     private static void debugPlog(String log, String loglevel) {
  73.         if ("debug".equalsIgnoreCase(loglevel)) {
  74.             DEBUG_LOG.debug(log);
  75.         } else if ("info".equalsIgnoreCase(loglevel)) {
  76.             DEBUG_LOG.info(log);
  77.         } else if ("warn".equalsIgnoreCase(loglevel)) {
  78.             DEBUG_LOG.warn(log);
  79.         } else if ("error".equalsIgnoreCase(loglevel)) {
  80.             DEBUG_LOG.error(log);
  81.         } else {
  82.             DEBUG_LOG.debug(log);
  83.         }
  84.     }
  86.     public static void warnLog(String log) {
  87.         StackTraceElement[] stacks = (new Throwable()).getStackTrace();
  88.         StringBuffer sb = new StringBuffer(stacks[1].getClassName());
  89.         sb.append(".");
  90.         sb.append(stacks[1].getMethodName());
  91.         sb.append("---");
  92.         sb.append(log);
  93.         WARN_LOG.error(sb.toString());
  94.     }
  96.     public static void errorLog(String log) {
  97.         StackTraceElement[] stacks = (new Throwable()).getStackTrace();
  98.         StringBuffer sb = new StringBuffer(stacks[1].getClassName());
  99.         sb.append(".");
  100.         sb.append(stacks[1].getMethodName());
  101.         sb.append("---");
  102.         sb.append(log);
  103.         errorPLog(sb.toString(), (Throwable)null);
  104.     }
  106.     public static void errorLog(String log, Throwable throwable) {
  107.         StackTraceElement[] stacks = (new Throwable()).getStackTrace();
  108.         StringBuffer sb = new StringBuffer(stacks[1].getClassName());
  109.         sb.append(".");
  110.         sb.append(stacks[1].getMethodName());
  111.         sb.append("---");
  112.         sb.append(log);
  113.         errorPLog(sb.toString(), throwable);
  114.     }
  116.     public static void dbLog(String log, Object... objects) {
  117.         StackTraceElement[] stacks = (new Throwable()).getStackTrace();
  118.         StringBuffer sb = new StringBuffer(stacks[1].getClassName());
  119.         sb.append(".");
  120.         sb.append(stacks[1].getMethodName());
  121.         sb.append("---");
  122.         sb.append(log);
  123.         if (objects != null && objects.length > 0) {
  124.             sb.append("; parameter[");
  125.             Object[] var4 = objects;
  126.             int var5 = objects.length;
  128.             for(int var6 = 0; var6 < var5; ++var6) {
  129.                 Object obj = var4[var6];
  130.                 sb.append(obj);
  131.                 sb.append(",");
  132.             }
  134.             sb.delete(sb.length() - 1, sb.length());
  135.             sb.append("]");
  136.         }
  138.         DB_LOG.debug(sb.toString());
  139.     }
  141.     private static void errorPLog(String log, Throwable throwable) {
  142.         if (throwable == null) {
  143.             ERROR_LOG.error(log);
  144.         } else {
  145.             ERROR_LOG.error(log, throwable);
  146.         }
  147.     }
  149.     public static void log(String name, String log) {
  150.         StackTraceElement[] stacks = (new Throwable()).getStackTrace();
  151.         StringBuffer sb = new StringBuffer(stacks[1].getClassName());
  152.         sb.append(".");
  153.         sb.append(stacks[1].getMethodName());
  154.         sb.append("---");
  155.         sb.append(log);
  156.         logByName(name, sb.toString(), "debug", (Throwable)null);
  157.     }
  159.     public static void log(String name, String log, String loglevel) {
  160.         StackTraceElement[] stacks = (new Throwable()).getStackTrace();
  161.         StringBuffer sb = new StringBuffer(stacks[1].getClassName());
  162.         sb.append(".");
  163.         sb.append(stacks[1].getMethodName());
  164.         sb.append("---");
  165.         sb.append(log);
  166.         logByName(name, sb.toString(), loglevel, (Throwable)null);
  167.     }
  169.     public static void log(String name, String log, String loglevel, Throwable throwable) {
  170.         StackTraceElement[] stacks = (new Throwable()).getStackTrace();
  171.         StringBuffer sb = new StringBuffer(stacks[1].getClassName());
  172.         sb.append(".");
  173.         sb.append(stacks[1].getMethodName());
  174.         sb.append("---");
  175.         sb.append(log);
  176.         logByName(name, sb.toString(), loglevel, throwable);
  177.     }
  179.     private static void logByName(String name, String log, String loglevel, Throwable throwable) {
  180.         if (name != null) {
  181.             StackTraceElement[] stacks = (new Throwable()).getStackTrace();
  182.             StringBuffer sb = new StringBuffer(stacks[1].getClassName());
  183.             sb.append(".");
  184.             sb.append(stacks[1].getMethodName());
  185.             sb.append("---");
  186.             sb.append(log);
  187.             Logger logger = LoggerFactory.getLogger(name);
  188.             try {
  189.                 if (throwable == null) {
  190.                     if ("debug".equalsIgnoreCase(loglevel)) {
  191.                         logger.debug(log);
  192.                     } else if ("info".equalsIgnoreCase(loglevel)) {
  193.                         logger.info(log);
  194.                     } else if ("warn".equalsIgnoreCase(loglevel)) {
  195.                         logger.warn(log);
  196.                     } else if ("error".equalsIgnoreCase(loglevel)) {
  197.                         logger.error(log);
  198.                     } else {
  199.                         logger.debug(log);
  200.                     }
  201.                 } else if ("debug".equalsIgnoreCase(loglevel)) {
  202.                     logger.debug(log, throwable);
  203.                 } else if ("info".equalsIgnoreCase(loglevel)) {
  204.                     logger.info(log, throwable);
  205.                 } else if ("warn".equalsIgnoreCase(loglevel)) {
  206.                     logger.warn(log, throwable);
  207.                 } else if ("error".equalsIgnoreCase(loglevel)) {
  208.                     logger.error(log, throwable);
  209.                 } else {
  210.                     logger.debug(log, throwable);
  211.                 }
  212.             } catch (Exception var8) {
  213.                 ;
  214.             }
  215.         }
  216.     }
  217. }

使用说明 :

  1. // 由于该方案配置的Logger 为 sys.error...等开头，因此  直接使用loger的方式会在控制台输出，但不会被记录到日志文件之中,有且仅有通过Logit打印的日志才会被记录到文件中，此方案减少了每个类都创建loger的尴尬，非常方便
  2. Logit.errorLog("在线用户插入失败" + " parms: " + userOnline, new Throwable(e));

GITHUB链接：https://github.com/kkzhilu/volcat-server (不同分支即对应不同日志框架)

项目暂时为私有, 如果需要参考请联系我

日志套餐篇 - log4j2 logback全量套餐的更多相关文章

  1. Log4j,Log4j2,logback,slf4j日志学习

    日志学习笔记 Log4j Log4j是Apache的一个开放源代码项目,通过使用Log4j,我们可以控制日志信息输送的目的地是控制台.文件.数据库等:我们也可以控制每一条日志的输出格式:通过定义每一条 ...

  2. Log4j,Log4j2,logback,slf4j日志学习（转）

    日志学习笔记Log4jLog4j是Apache的一个开放源代码项目,通过使用Log4j,我们可以控制日志信息输送的目的地是控制台.文件.数据库等:我们也可以控制每一条日志的输出格式:通过定义每一条日志 ...

  3. 免费申请使用IBM Cloud Lite(轻量套餐) 续

    之前尝试申请了IBM的轻量套餐,过程很简单,操作起来也比较方便,就是能够用到的地方不多,虽说几乎是无限流量且永久免费,我能做的也只是做个小网站 免费用户默认的是轻量应用服务,如果需要功能更多更全的应用 ...

  4. 54. spring boot日志升级篇—logback【从零开始学Spring Boot】

    在<44. Spring Boot日志记录SLF4J>章节中有关相关的介绍,这里我们在深入的了解下logback框架. 为什么要使用logback ? --在开发中不建议使用System. ...

  5. SpringBoot系列之集成logback实现日志打印(篇二)

    SpringBoot系列之集成logback实现日志打印(篇二) 基于上篇博客SpringBoot系列之集成logback实现日志打印(篇一)之后,再写一篇博客进行补充 logback是一款开源的日志 ...

  6. 免费申请使用IBM Cloud Lite(轻量套餐) 详细教程指南

    注册轻量帐户可在 IBM CLOUD控制台中使用所选的显示有轻量标记的免费轻量套餐来构建应用程序和探索服务.轻量帐户不会到期,也无需信用卡. 本文详细的介绍了一下,免费云服务的申请以及使用!这次使用I ...

  7. 全量日志 requestId

    常量参数和系统参数 API 的请求者不可见,由网关在请求后端服务时添加上. 常量参数.比如您的后端需要接收一个常量,但是这个常量您不希望被您的客户看见,那么就设置一个常量参数,可以在 Header 或 ...

  8. iOS开发中全量日志的获取

    我们在app中对崩溃.卡顿.内存问题进行监控.一旦监控到问题,我们就需要记录下来,但是,很多问题的定位仅靠问题发生的那一刹那记录的信息是不够的,我们需要记录app的全量日志来获取更多的信息. 一,使用 ...

  9. Mysql备份系列（2）--mysqldump备份（全量+增量）方案操作记录

    在日常运维工作中,对mysql数据库的备份是万分重要的,以防在数据库表丢失或损坏情况出现,可以及时恢复数据. 线上数据库备份场景:每周日执行一次全量备份,然后每天下午1点执行MySQLdump增量备份 ...

随机推荐

  1. Elasticsearch原理入门

    这是一篇拼接贴,我是缝合怪 项目中用到了es,使用方法是挺简单的,封装了基本api以后,把查询条件封装一下传给client执行就可,但是光使用比较肤浅,研究一下原理和本质,更利于以后开发使用 扫盲贴 ...

  2. 机器学习——打开集成方法的大门，手把手带你实现AdaBoost模型

    本文始发于个人公众号:TechFlow,原创不易,求个关注 今天是机器学习专题的第25篇文章,我们一起来聊聊AdaBoost. 我们目前为止已经学过了好几个模型,光决策树的生成算法就有三种.但是我们每 ...

  3. ORA-12514:监听程序无法识别

    使用plsql远程登录oracle数据库时,出现无法识别监听程序的错误.很大机率是配置文件出错. 配置文件如下: listener.ora是服务器端用的,oracle监听程序,就是读的这个文件,里面有 ...

  4. SpringBoot读取application.properties中文乱码

    [本文版权归微信公众号"代码艺术"(ID:onblog)所有,若是转载请务必保留本段原创声明,违者必究.若是文章有不足之处,欢迎关注微信公众号私信与我进行交流!] 解决方案 在ID ...

  5. ElasticSearch--validate验证搜索语句是否合法或者存在语法错误

    GET /accounts/person/_validate/query?explain { "query":{ "match": { "user&q ...

  6. JavaWeb网上图书商城完整项目--day02-10.提交注册表单功能之页面实现

    1.当从服务器返回的注册错误信息的时候,我们在注册界面需要将错误信息显示出来 我们需要修改regist.jsp页面的代码:其中error是一个haspmap,c标签对map的属性可以直接使用 ${er ...

  7. android自定义控件onMeasure方法

    1.自定义控件首先定义一个类继承View 有时,Android系统控件无法满足我们的需求,因此有必要自定义View.具体方法参见官方开发文档:http://developer.android.com/ ...

  8. Python3-pymysql模块-数据库操作之MySQL

    博客转载 http://www.cnblogs.com/alex3714/articles/5950372.html 代码示例 import pymysql conn = None cursor = ...

  9. activiti学习笔记一

    activiti学习笔记 在讲activiti之前我们必须先了解一下什么是工作流,什么是工作流引擎. 在我们的日常工作中,我们会碰到很多流程化的东西,什么是流程化呢,其实通俗来讲就是有一系列固定的步骤 ...

  10. 入门大数据---Hadoop是什么？

    简单概括:Hadoop是由Apache组织使用Java语言开发的一款应对大数据存储和计算的分布式开源框架. Hadoop的起源 2003-2004年,Google公布了部分GFS和MapReduce思 ...