slf4j+log4j与slf4j+logback的简单测试示例
首先是整个目录结构：
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: }
结果：
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: }
结果：