slf4j+log4j与slf4j+logback的简单测试示例

来源：互联网发布：c语言|是什么编辑：程序博客网时间：2024/06/05 10:34

首先是整个目录结构：

1113211031 QQ截图20150313204715

1.slf4j+log4j

需求：让com.zero.log4j.log1包下的类的日志输出到log1.log中，也可以指定某些日志输出到指定的日志文件log3.log,其它未指明的默认输出到log2.log2。

log4j.xml配置日志：

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

   2: <!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">

   3: <log4j:configuration debug="true">

4:

   5:     <appender name="log1" class="org.apache.log4j.DailyRollingFileAppender">

   6:         <param name="File" value="logs/log1.log" />

   7:         <param name="Append" value="true" />

   8:         <!-- 如果是 true，日志被追加到文件结尾，如果是 false，清空现存文件，默认是true。 -->

   9:         <layout class="org.apache.log4j.PatternLayout">

  10:             <param name="ConversionPattern" value="%-5p %d{MM/dd  HH:mm}  %c  %m%n" />

  11:         </layout>

  12:     </appender>

13:

  14:     <appender name="log2" class="org.apache.log4j.DailyRollingFileAppender">

  15:         <param name="File" value="logs/log2.log" />

  16:         <param name="Append" value="true" />

  17:         <!-- 如果是 true，日志被追加到文件结尾，如果是 false，清空现存文件，默认是true。 -->

  18:         <layout class="org.apache.log4j.PatternLayout">

  19:             <param name="ConversionPattern" value="%-5p %d{MM/dd  HH:mm}  %C %m%n" />

  20:         </layout>

  21:     </appender>

22:

  23:     <appender name="log3" class="org.apache.log4j.DailyRollingFileAppender">

  24:         <param name="File" value="logs/log3.log" />

  25:         <param name="Append" value="true" />

  26:         <param name="encoding" value="UTF-8" />

  27:         <layout class="org.apache.log4j.PatternLayout">

  28:             <param name="ConversionPattern" value="%d{YYYY-MM-dd HH:mm:ss}  %-2p  [%-5C]  %m%n" />

  29:         </layout>

  30:     </appender>

31:

  32:     <!--可以将com.zero.log4j.log1包中的类日志输出指定到到log1.log日志文件中 -->

  33:     <category name="com.zero.log4j.log1" additivity="false">

  34:         <priority value="debug" />

  35:         <appender-ref ref="log1" />

  36:     </category>

37:

  38:     <!--zero的日志记录到log3日志文件中 ， Logger.getLogger("zero"); -->

  39:     <category name="zero" additivity="false">

  40:         <priority value="debug" />

  41:         <appender-ref ref="log3" />

  42:     </category>

43:

  44:     <!--默认输出到的log2日志文件 -->

  45:     <root>

  46:         <priority value="debug" />

  47:         <appender-ref ref="log2" />

  48:     </root>

49:

  50: </log4j:configuration>

java代码：

   1: package com.zero.log4j.log;

2:

   3: import org.apache.log4j.Logger;

4:

   5: public class LogUtils {

   6:     private static final Logger logger = Logger.getLogger("zero");

7:

   8:     public static void log(String logStr, String logType) {

   9:         Logger myLogger = Logger.getLogger(logType);

  10:         myLogger.info(logStr);

  11:         myLogger.warn(logStr);

  12:         logger.info("LogUtils, 我想记录在log3.log");

  13:     }

  14: }

   1: package com.zero.log4j.log1;

2:

   3: import org.apache.log4j.Logger;

4:

   5: public class Log1 {

   6:     private Logger logger = Logger.getLogger(Log1.class);

7:

   8:     public Log1() {

   9:         logger.debug("Log1,我想记录在log1.log");

  10:         logger.info("Log1,我想记录在log1.log");

  11:         logger.warn("Log1,我想记录在log1.log");

  12:         logger.error("Log1,我想记录在log1.log");

  13:     }

  14: }

   1: package com.zero.log4j.log2;

2:

   3: import org.apache.log4j.Logger;

4:

   5: public class Log2 {

   6:     private Logger logger = Logger.getLogger(Log2.class);

   7:     public Log2(){

   8:         logger.debug("Log2, 我默认记录到log2.log");

   9:         logger.info("Log2, 我默认记录到log2.log");

  10:         logger.warn("Log2, 我默认记录到log2.log");

  11:         logger.error("Log2, 我默认记录到log2.log");

  12:     }

  13: }

   1: package com.zero.log4j.log3;

2:

   3: import org.apache.log4j.Logger;

4:

   5: import com.zero.log4j.log.LogUtils;

6:

   7: public class Log3 {

   8:     private Logger logger = Logger.getLogger(Log3.class);

   9:     public Log3(){

  10:         logger.debug("Log3, 我默认记录到log2.log");

  11:         logger.info("Log3, 我默认记录到log2.log");

  12:         logger.warn("Log3, 我默认记录到log2.log");

  13:         logger.error("Log3, 我默认记录到log2.log");

  14:         LogUtils.log("Log3,"+" 我要记录到log3.log", "zero");;

  15:     }

  16: }

   1: package com.zero.test;

2:

   3: import java.io.File;

4:

   5: import org.apache.log4j.xml.DOMConfigurator;

   6: import org.slf4j.Logger;

   7: import org.slf4j.LoggerFactory;

8:

   9: import com.zero.log4j.log1.Log1;

  10: import com.zero.log4j.log2.Log2;

  11: import com.zero.log4j.log3.Log3;

12:

  13: public class Slf4j_Log4jTest {

  14:     static Logger logger = LoggerFactory.getLogger(Slf4j_Log4jTest.class);

15:

  16:     public static void main(String[] args) {

  17:         String path = new File("").getAbsolutePath() + File.separator

  18:                 + "config" + File.separator;

  19:         DOMConfigurator.configure(path + "log4j.xml");

  20:         // TODO Auto-generated method stub

  21:         logger.info("slf4j--log {}", 123456789);

  22:         new Log1();

  23:         new Log3();

  24:         new Log2();

  25:     }

  26: }

结果：

QQ截图20150313210221

2.slf4j+logback

需求大致同上，只不过logback提供可以配置的Filter机制，这里也试用仅输出INFO的日志到d.log。

logback.xml配置日志：

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

   2: <configuration>

3:

   4:     <appender name="a"

   5:         class="ch.qos.logback.core.rolling.RollingFileAppender">

   6:         <Encoding>UTF-8</Encoding>

   7:         <File>logs/a.log</File>

   8:         <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">

   9:             <fileNamePattern>logFile.%d{yyyy-MM-dd}.log</fileNamePattern>

  10:             <maxHistory>30</maxHistory>

  11:         </rollingPolicy>

  12:         <encoder>

  13:             <!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符 -->

  14:             <pattern>%date [%thread] %-5level %logger{80} - %msg%n</pattern>

  15:         </encoder>

  16:     </appender>

17:

  18:     <appender name="b"

  19:         class="ch.qos.logback.core.rolling.RollingFileAppender">

  20:         <File>logs/b.log</File>

  21:         <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">

  22:             <fileNamePattern>logFile.%d{yyyy-MM-dd}.log</fileNamePattern>

  23:             <maxHistory>30</maxHistory>

  24:         </rollingPolicy>

  25:         <encoder>

  26:             <pattern>%date [%thread] %-5level %logger{80} - %msg%n</pattern>

  27:         </encoder>

  28:     </appender>

29:

  30:     <appender name="c"

  31:         class="ch.qos.logback.core.rolling.RollingFileAppender">

  32:         <File>logs/c.log</File>

  33:         <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">

  34:             <fileNamePattern>logFile.%d{yyyy-MM-dd}.log</fileNamePattern>

  35:             <maxHistory>30</maxHistory>

  36:         </rollingPolicy>

  37:         <encoder>

  38:             <pattern>%date [%thread] %-5level %logger{80} - %msg%n</pattern>

  39:         </encoder>

  40:         <!-- 记录所有的info级别及以上的日志 -->

  41:         <filter class="ch.qos.logback.classic.filter.ThresholdFilter">

  42:             <level>INFO</level>

  43:         </filter>

  44:     </appender>

45:

  46:     <appender name="d"

  47:         class="ch.qos.logback.core.rolling.RollingFileAppender">

  48:         <File>logs/d.log</File>

  49:         <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">

  50:             <fileNamePattern>logFile.%d{yyyy-MM-dd}.log</fileNamePattern>

  51:             <maxHistory>30</maxHistory>

  52:         </rollingPolicy>

  53:         <encoder>

  54:             <pattern>%date [%thread] %-5level %logger{80} - %msg%n</pattern>

  55:         </encoder>

  56:         <filter class="ch.qos.logback.classic.filter.LevelFilter">

  57:             <level>INFO</level><!-- 只接收INFO级别的日志 -->

  58:             <onMatch>ACCEPT</onMatch> <!-- onMatch表示匹配如何处理，可以根据需求设置接受或拒绝 -->

  59:             <onMismatch>DENY</onMismatch><!-- onMismatch表示不匹配如何处理，具体自行可以设置。 -->

  60:         </filter>

  61:     </appender>

62:

  63:     <!-- additivity="false" 不加这个日志会再次写到root中去 -->

  64:     <!-- com.zero.logback.a包下的debug级别的日志全部记录到这个日志文件 -->

  65:     <logger name="com.zero.logback.a" level="WARN" additivity="false">

  66:         <appender-ref ref="a" />

  67:     </logger>

68:

  69:     <!-- b_log日志 -->

  70:     <logger name="b_log" level="DEBUG" additivity="false">

  71:         <appender-ref ref="b" />

  72:     </logger>

73:

  74:     <root>

  75:         <appender-ref ref="c" />

  76:         <appender-ref ref="d" />

  77:     </root>

78:

  79: </configuration>

80:

81:

  82: <!-- 详配见：http://www.cppblog.com/fwxjj/archive/2012/08/16/187345.html; http://blog.sina.com.cn/s/blog_9ed9ac7d01016ja1.html -->

java代码：

   1: package com.zero.logback.a;

2:

   3: import org.slf4j.Logger;

   4: import org.slf4j.LoggerFactory;

5:

   6: public class AA{

   7:     private static Logger logger = LoggerFactory.getLogger(AA.class);

   8:     public AA() {

   9:         logger.debug("AA---debug, 我想记录在a.log");

  10:         logger.info("AA---info, 我想记录在a.log");

  11:         logger.warn("AA---warn, 我想记录在a.log");

  12:         logger.error("AA---error, 我想记录在a.log");

  13:     }

  14: }

   1: package com.zero.logback.a;

2:

   3: import org.slf4j.Logger;

   4: import org.slf4j.LoggerFactory;

5:

6:

   7: public class AB {

   8:     private static Logger logger = LoggerFactory.getLogger(AB.class);

9:

  10:     public AB() {

  11:         logger.debug("AB---debug,我想记录在a.log");

  12:         logger.info("AB---info,我想记录在a.log");

  13:         logger.warn("AB---warn,我想记录在a.log");

  14:         logger.error("AB---error,我想记录在a.log");

  15:     }

  16: }

   1: package com.zero.logback.b;

2:

   3: import org.slf4j.Logger;

   4: import org.slf4j.LoggerFactory;

5:

   6: public class B {

   7:     private static Logger logger = LoggerFactory.getLogger("b_log");

8:

   9:     public B() {

  10:         logger.debug("B---debug,我想记录在b.log");

  11:         logger.info("B---info,我想记录在b.log");

  12:         logger.warn("B---warn,我想记录在b.log");

  13:         logger.error("B---error,我想记录在b.log");

  14:     }

  15: }

   1: package com.zero.logback.c;

2:

   3: import org.slf4j.Logger;

   4: import org.slf4j.LoggerFactory;

5:

   6: public class C {

   7:     private static Logger logger = LoggerFactory.getLogger(C.class);

8:

   9:     public C() {

  10:         logger.debug("C---debug，我按默认输出");

  11:         logger.info("C---info，我按默认输出");

  12:         logger.warn("C---warn，我按默认输出");

  13:         logger.error("C---error，我按默认输出");

  14:     }

  15: }

   1: package com.zero.test;

2:

   3: import java.io.File;

4:

   5: import org.slf4j.Logger;

   6: import org.slf4j.LoggerFactory;

7:

   8: import com.zero.logback.a.AB;

   9: import com.zero.logback.a.AA;

  10: import com.zero.logback.b.B;

  11: import com.zero.logback.c.C;

12:

  13: import ch.qos.logback.classic.LoggerContext;

  14: import ch.qos.logback.classic.joran.JoranConfigurator;

  15: import ch.qos.logback.core.joran.spi.JoranException;

16:

  17: public class Slf4j_logbackTest {

  18:     private static final Logger logger = LoggerFactory

  19:             .getLogger(Slf4j_logbackTest.class);

20:

  21:     public static void main(String[] args) throws JoranException {

  22:         String path = new File("").getAbsolutePath() + File.separator

  23:                 + "config" + File.separator;

  24:         LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();

  25:         JoranConfigurator configurator = new JoranConfigurator();

  26:         configurator.setContext(lc);

  27:         lc.reset();

  28:         try {

  29:             configurator.doConfigure(path + "logback.xml");

  30:         } catch (JoranException e) {

  31:             e.printStackTrace();

  32:         }

  33:         new B();

  34:         new AB();

  35:         new C();

  36:         new AA();

  37:     }

  41: }

结果：

111111111111111

0 0