之前在项目中用的日志记录器都是log4j的日志记录器，可是到了公司发现项目要求使用slf4j，于是想着研究一下slf4j的用法。

　　注意:每次引入Logger的时候注意引入的jar包，因为有Logger的包太多了。。。。。。

　　　　Logger必须作为类的静态变量使用。原因如下:

  1. 1 使用static修饰的属性是归这个类使用的
    2 也就是说不论这个类实例化多少个，大家用的都是同一个static属性
    3 log4j记录的是当前类的日志，不是每个实例的日志
    4 所以只要有一个记录就可以了
  2.  
  3. 创建日志记录器方法:(最好声明加final关键字)
  1.     //private static final Logger logger = LoggerFactory.getLogger(Slf4jTest.class);// slf4j日志记录器
  2.     private static final Logger logger = LoggerFactory.getLogger(Slf4jTest.class.getName());// slf4j日志记录器
  1. 简要记录一下日志级别:
  1. 每个Logger都被了一个日志级别（log level），用来控制日志信息的输出。日志级别从高到低分为：
  2. A：off         最高等级，用于关闭所有日志记录。
  3. B：fatal       指出每个严重的错误事件将会导致应用程序的退出。
  4. C：error      指出虽然发生错误事件，但仍然不影响系统的继续运行。
  5. D：warm     表明会出现潜在的错误情形。
  6. E：info         一般和在粗粒度级别上，强调应用程序的运行全程。
  7. F：debug     一般用于细粒度级别上，对调试应用程序非常有帮助。
  8. G：all           最低等级，用于打开所有日志记录。
  1.  
  2. 其实对于不同的版本有不同的级别，不过最常用的就是debug\info\warn\error.下面是摘自log4j-1.2.17.jar中的级别:
    可以看出:all\TRACE\debug    同级别。off与fatal同级别。
  1. package org.apache.log4j;
  2. import java.io.IOException;
  3. import java.io.ObjectInputStream;
  4. import java.io.ObjectOutputStream;
  5. import java.io.ObjectStreamException;
  6. import java.io.Serializable;
  7.  
  8. public class Level extends Priority implements Serializable {
  9.  
  10.    /**
  11.     * TRACE level integer value.
  12.     * @since 1.2.12
  13.     */
  14.   public static final int TRACE_INT = 5000;
  15.  
  16.   final static public Level OFF = new Level(OFF_INT, "OFF", 0);
  17.  
  18.   final static public Level FATAL = new Level(FATAL_INT, "FATAL", 0);
  19.  
  20.   final static public Level ERROR = new Level(ERROR_INT, "ERROR", 3);
  21.  
  22.   final static public Level WARN  = new Level(WARN_INT, "WARN",  4);
  23.  
  24.   final static public Level INFO  = new Level(INFO_INT, "INFO",  6);
  25.  
  26.   final static public Level DEBUG = new Level(DEBUG_INT, "DEBUG", 7);
  27.  
  28.   public static final Level TRACE = new Level(TRACE_INT, "TRACE", 7);
  29.  
  30.   final static public Level ALL = new Level(ALL_INT, "ALL", 7);
  31.  
  32.   static final long serialVersionUID = 3491141966387921974L;
  33.  
  34.   protected
  35.   Level(int level, String levelStr, int syslogEquivalent) {
  36.     super(level, levelStr, syslogEquivalent);
  37.   }
  38.  
  39.   public
  40.   static
  41.   Level toLevel(int val, Level defaultLevel) {
  42.     switch(val) {
  43.     case ALL_INT: return ALL;
  44.     case DEBUG_INT: return Level.DEBUG;
  45.     case INFO_INT: return Level.INFO;
  46.     case WARN_INT: return Level.WARN;
  47.     case ERROR_INT: return Level.ERROR;
  48.     case FATAL_INT: return Level.FATAL;
  49.     case OFF_INT: return OFF;
  50.     case TRACE_INT: return Level.TRACE;
  51.     default: return defaultLevel;
  52.     }
  53.   }
  54. 。。。。。
  1.  
  2. 0.依赖的Jar包
  1.         <!-- slf4j 依赖包 -->
  2.         <dependency>
  3.             <groupId>org.slf4j</groupId>
  4.             <artifactId>slf4j-api</artifactId>
  5.             <version>1.7.25</version>
  6.         </dependency>
  7.         <dependency>
  8.             <groupId>org.slf4j</groupId>
  9.             <artifactId>slf4j-log4j12</artifactId>
  10.             <version>1.7.5</version>
  11.         </dependency>
  12.         <dependency>
  13.             <groupId>org.apache.logging.log4j</groupId>
  14.             <artifactId>log4j-api</artifactId>
  15.             <version>2.0-rc1</version>
  16.         </dependency>
  17.         <dependency>
  18.             <groupId>org.apache.logging.log4j</groupId>
  19.             <artifactId>log4j-core</artifactId>
  20.             <version>2.0-rc1</version>
  21.         </dependency>

或者手动导入下面的包:

介绍:slf4j-api提供接口，slf4j-log4j提供具体的实现。也就是 slf4j只是一个日志标准，并不是日志系统的具体实现，如果项目只有slf4j的包是没有办法实现日志功能的。

1 基本介绍

　　SLF4J不同于其他日志类库，与其它日志类库有很大的不同。SLF4J(Simple logging Facade for Java)不是一个真正的日志实现，而是一个抽象层（ abstraction layer），它允许你在后台使用任意一个日志类库。如果是在编写供内外部都可以使用的API或者通用类库，那么你真不会希望使用你类库的客户端必须使用你选择的日志类库。

　　如果一个项目已经使用了log4j，而你加载了一个类库，比方说 Apache Active MQ——它依赖于于另外一个日志类库logback，那么你就需要把它也加载进去。但如果Apache Active MQ使用了SLF4J，你可以继续使用你的日志类库而无需忍受加载和维护一个新的日志框架的痛苦。

　　总的来说，SLF4J使你的代码独立于任意一个特定的日志API，这是对于API开发者的很好的思想。虽然抽象日志类库的思想已经不是新鲜的事物，而且Apache commons logging也已经在使用这种思想了，但SLF4J正迅速成为Java世界的日志标准。让我们再看几个使用SLF4J而不是log4j、logback或者java.util.logging的理由。

2 SLF4J对比Log4J，logback和java.util.Logging的优势

正如我之前说的，在你的代码中使用SLF4J写日志语句的主要出发点是使得你的程序独立于任何特定的日志类库，依赖于特定类库可能需要使用不同于你已有的配置，并且导致更多维护的麻烦。除此之外，还有一个SLF4J API的特性是使得我坚持使用SLF4J而抛弃我长期间钟爱的Log4j的理由，是被称为占位符(place holder)，在代码中表示为“{}”的特性。占位符是一个非常类似于在String的format()方法中的%s，因为它会在运行时被某个提供的实际字符串所替换。这不仅降低了你代码中字符串连接次数，而且还节省了新建的String对象。通过使用SLF4J，你可以在运行时延迟字符串的建立，这意味着只有需要的String对象才被建立。而如果你已经使用log4j，那么你已经对于在if条件中使用debug语句这种变通方案十分熟悉了，但SLF4J的占位符就比这个好用得多。

3.slf4j的简单用法

1.简单使用

1.配置文件(log4j.properties)

  1. log4j.rootLogger=debug, C
  2.  
  3. log4j.appender.A=org.apache.log4j.ConsoleAppender
  4. log4j.appender.A.layout=org.apache.log4j.PatternLayout
  5. log4j.appender.A.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%c]-[%p] %m%n
  6.  
  7. log4j.appender.B=org.apache.log4j.FileAppender
  8. log4j.appender.B.File=E:\\log.log
  9. log4j.appender.B.layout=org.apache.log4j.SimpleLayout
  10.  
  11. log4j.appender.C=org.apache.log4j.RollingFileAppender
  12. log4j.appender.C.File=E:\\log.html
  13. log4j.appender.C.MaxFileSize=1000KB
  14. log4j.appender.C.MaxBackupIndex=10
  15. log4j.appender.C.layout=org.apache.log4j.HTMLLayout
  16. log4j.appender.C.encoding=gbk
  17.  
  18. log4j.appender.D=org.apache.log4j.DailyRollingFileAppender
  19. log4j.appender.D.File=E:\\log.log
  20. log4j.appender.D.layout=org.apache.log4j.TTCCLayout

注意:　　

　　1.如果需要输出到多个位置的时候可以逗号隔开，比如:   log4j.rootLogger=info, A, B

　　2.    log4j.appender.C.encoding=gbk 的配置是为了解决中文乱码，有时候也可以设置为UTF-8试试

关于pattern的设置如下:

  1. %p: 输出日志信息优先级，即DEBUG，INFO，WARN，ERROR，FATAL,%d: 输出日志时间点的日期或时间，默认格式为ISO8601，也可以在其后指定格式，比如：%d{yyyy-MM-dd HH:mm:ss,SSS}，输出类似：-- ::,
  2. %r: 输出自应用启动到输出该log信息耗费的毫秒数
  3. %c: 输出日志信息所属的类目，通常就是所在类的全名
  4. %t: 输出产生该日志事件的线程名
  5. %l: 输出日志事件的发生位置，相当于%C.%M(%F:%L)的组合,包括类目名、发生的线程，以及在代码中的行数。
  6. %x: 输出和当前线程相关联的NDC(嵌套诊断环境),尤其用到像java servlets这样的多客户多线程的应用中。
  7. %%: 输出一个"%"字符
  8. %F: 输出日志消息产生时所在的文件名称
  9. %L: 输出代码中的行号
  10. %m: 输出代码中指定的消息,产生的日志具体信息
  11. %n: 输出一个回车换行符，Windows平台为"\r\n"，Unix平台为"\n"输出日志信息换行

2.测试代码:

  1. package cn.xm.exam.test;
  2.  
  3. import org.slf4j.Logger;
  4. import org.slf4j.LoggerFactory;
  5.  
  6. public class Slf4jTest {
  7.     private static Logger logger = LoggerFactory.getLogger(Slf4jTest.class);// slf4j日志记录器
  8.  
  9.     public static void main(String[] args) {
  10.  
  11.         // 普通的日志记录
  12.         logger.debug("普通的日志记录");
  13.  
  14.         // {}占位符记录日志
  15.         for (int i = 0; i < 3; i++) {
  16.             logger.debug("这是第{}条记录", i);
  17.         }
  18.  
  19.         // 用\转义{}
  20.         logger.debug("Set \\{} differs from {}", "3"); // output:Set {} differs
  21.                                                         // from 3
  22.  
  23.         // 两个参数
  24.         logger.debug("两个占位符，可以传两个参数{}----{}", 1, 2);
  25.  
  26.         // 多个参数(可变参数)
  27.         logger.debug("debug:多个占位符，{},{},{},{}", 1, 2, 3, 4);
  28.  
  29.         // 多个参数(可变参数)
  30.         logger.info("info:多个占位符，{},{},{},{}", 1, 2, 3, 4);
  31.  
  32.         // 多个参数(可变参数)
  33.         logger.error("error:多个占位符，{},{},{},{}", 1, 2, 3, 4);
  34.  
  35.     }
  36.  
  37. }

结果:

2018-08-18 10:58:38 [cn.xm.exam.test.Slf4jTest]-[DEBUG] 普通的日志记录
2018-08-18 10:58:38 [cn.xm.exam.test.Slf4jTest]-[DEBUG] 这是第0条记录
2018-08-18 10:58:38 [cn.xm.exam.test.Slf4jTest]-[DEBUG] 这是第1条记录
2018-08-18 10:58:38 [cn.xm.exam.test.Slf4jTest]-[DEBUG] 这是第2条记录
2018-08-18 10:58:38 [cn.xm.exam.test.Slf4jTest]-[DEBUG] Set {} differs from 3
2018-08-18 10:58:38 [cn.xm.exam.test.Slf4jTest]-[DEBUG] 两个占位符，可以传两个参数1----2
2018-08-18 10:58:38 [cn.xm.exam.test.Slf4jTest]-[DEBUG] debug:多个占位符，1,2,3,4
2018-08-18 10:58:38 [cn.xm.exam.test.Slf4jTest]-[INFO] info:多个占位符，1,2,3,4
2018-08-18 10:58:38 [cn.xm.exam.test.Slf4jTest]-[ERROR] error:多个占位符，1,2,3,4

注意:debug,info,error,等各个级别的方法都可以传入多个可变参数:

至于详细的日志级别的介绍参考我的另一篇博客:http://www.cnblogs.com/qlqwjy/p/7192947.html

2.关于正式开发中的日记记录的方法:(重要)

　　项目中日志记录还是有很多说法的，比如保存日志级别，日志应该打印的信息，日志参数的设置等:

1.一般是将捕捉到的Exception对象作为日志记录的最后一个参数（会显示具体的出错信息以及出错位置），而且要放在{}可以格式化的参数之外，防止被{}转为e.toString()

例如一个标准的日记记录的方法:

  1. package cn.xm.exam.test;
  2.  
  3. import java.io.File;
  4. import java.io.FileInputStream;
  5. import java.io.FileNotFoundException;
  6. import java.io.InputStream;
  7.  
  8. import org.slf4j.Logger;
  9. import org.slf4j.LoggerFactory;
  10.  
  11. public class Slf4jTest {
  12.  
  13.     private static Logger log = LoggerFactory.getLogger(Slf4jTest.class);
  14.  
  15.     public static void main(String[] args) {
  16.         openFile("xxxxxx");
  17.     }
  18.  
  19.     public static void openFile(String filePath) {
  20.         File file = new File(filePath);
  21.         try {
  22.             InputStream in = new FileInputStream(file);
  23.         } catch (FileNotFoundException e) {
  24.             log.error("can found file [{}]", filePath, e);
  25.         }
  26.     }
  27.  
  28. }

结果:

  1. 2018-08-18 10:50:03 [cn.xm.exam.test.Slf4jTest]-[ERROR] can found file [xxxxxx]
  2. java.io.FileNotFoundException: xxxxxx (系统找不到指定的文件。)
  3.     at java.io.FileInputStream.open(Native Method)
  4.     at java.io.FileInputStream.<init>(FileInputStream.java:146)
  5.     at cn.xm.exam.test.Slf4jTest.openFile(Slf4jTest.java:22)
  6.     at cn.xm.exam.test.Slf4jTest.main(Slf4jTest.java:16)

注意: {}的作用是调用对应参数的toString()方法格式化日志，如果exception放在对应参数的位置上也会被格式化。所以，e要放在{}参数之外,而且只能放在最后一个。如果放在中间也不会被打印错误信息:

例如:

  • 只要放到{}之外的最后一个参数可以打印错误信息(包括信息和位置)
  1.     public static void openFile(String filePath) {
  2.         File file = new File(filePath);
  3.         try {
  4.             InputStream in = new FileInputStream(file);
  5.         } catch (FileNotFoundException e) {
  6.             log.error("error:can found file [{}]", filePath, 3, e);
  7.         }
  8.     }

结果:

  1. 2018-08-18 11:11:18 [cn.xm.exam.test.Slf4jTest]-[ERROR] error:can found file [xxxxxx]
  2. java.io.FileNotFoundException: xxxxxx (系统找不到指定的文件。)
  3.     at java.io.FileInputStream.open(Native Method)
  4.     at java.io.FileInputStream.<init>(FileInputStream.java:146)
  5.     at cn.xm.exam.test.Slf4jTest.openFile(Slf4jTest.java:22)
  6.     at cn.xm.exam.test.Slf4jTest.main(Slf4jTest.java:16)
  • 放到{}之外的非最后一个参数不会打印错误信息
  1.     public static void openFile(String filePath) {
  2.         File file = new File(filePath);
  3.         try {
  4.             InputStream in = new FileInputStream(file);
  5.         } catch (FileNotFoundException e) {
  6.             log.error("error:can found file [{}]", filePath,e,3);
  7.         }
  8.     }

结果:

  1. 2018-08-18 11:10:38 [cn.xm.exam.test.Slf4jTest]-[ERROR] error:can found file [xxxxxx]

2.尽量不使用e.getMessage(),因为有的异常不一定有message,可以使用e.toString只会显示信息，不会显示出错的位置信息(不建议这种)

例如:

  1. package cn.xm.exam.test;
  2.  
  3. import java.io.File;
  4. import java.io.FileInputStream;
  5. import java.io.FileNotFoundException;
  6. import java.io.InputStream;
  7.  
  8. import org.slf4j.Logger;
  9. import org.slf4j.LoggerFactory;
  10.  
  11. public class Slf4jTest {
  12.  
  13.     private static Logger log = LoggerFactory.getLogger(Slf4jTest.class);
  14.  
  15.     public static void main(String[] args) {
  16.         openFile("xxxxxx");
  17.     }
  18.  
  19.     public static void openFile(String filePath) {
  20.         File file = new File(filePath);
  21.         try {
  22.             InputStream in = new FileInputStream(file);
  23.         } catch (FileNotFoundException e) {
  24.             //下面两句的效果一样
  25.             log.error("can found file [{}],cause:{}", filePath, e.toString());
  26.             log.error("can found file [{}],cause:{}", filePath, e);
  27.         }
  28.     }
  29.  
  30. }

结果:

  1. 2018-08-18 10:53:31 [cn.xm.exam.test.Slf4jTest]-[ERROR] can found file [xxxxxx],cause:java.io.FileNotFoundException: xxxxxx (系统找不到指定的文件。)
  2. 2018-08-18 10:53:31 [cn.xm.exam.test.Slf4jTest]-[ERROR] can found file [xxxxxx],cause:java.io.FileNotFoundException: xxxxxx (系统找不到指定的文件。)

补充:一份上线系统使用的log4j.properties配置:

  1. log4j.rootLogger=info,B
  2.  
  3. log4j.appender.A=org.apache.log4j.ConsoleAppender
  4. log4j.appender.A.layout=org.apache.log4j.PatternLayout
  5. log4j.appender.A.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%c]-[%p] %m%n
  6.  
  7. log4j.appender.B=org.apache.log4j.RollingFileAppender
  8. log4j.appender.B.File=E:\\test.log
  9. log4j.appender.B.MaxFileSize=10MB
  10. log4j.appender.B.MaxBackupIndex=5
  11. log4j.appender.B.layout=org.apache.log4j.PatternLayout
  12. log4j.appender.B.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%c]-[%p] %m%n

%d{yyyy-MM-dd HH:mm:ss} 也可以改为%d{yyyy-MM-dd HH:mm:ss,SSS} SSS代表至少输出3位数字的毫秒。如果4个S的话不足位补0。

解释:org.apache.log4j.RollingFileAppender是log4j的一个类，下面的配置都是它的属性的配置:(其中还有好多属性来自其父类，需要的时候我们可以去查阅)

log4j.appender.B.File    指定输出的日志的文件名称以及路径

log4j.appender.B.MaxFileSize   指定每个文件的最大大小

log4j.appender.B.MaxBackupIndex　　指定文件达到文件大小之后最多重命名的文件数量

log4j.appender.B.layout　　指定采用的样式

log4j.appender.B.layout.ConversionPattern  指定样式的格式(值一般固定)

测试代码:

  1. package cn.qlq.slf4jTest;
  2.  
  3. import org.slf4j.Logger;
  4. import org.slf4j.LoggerFactory;
  5.  
  6. public class Slf4jTest {
  7.     private static Logger logger = LoggerFactory.getLogger(Slf4jTest.class);// slf4j日志记录器
  8.  
  9.     public static void main(String[] args) {
  10.  
  11.         while (true) {
  12.  
  13.             // 普通的日志记录
  14.             logger.error("普通的日志记录");
  15.  
  16.             // {}占位符记录日志
  17.             for (int i = 0; i < 3; i++) {
  18.                 logger.info("这是第{}条记录", i);
  19.             }
  20.  
  21.             // 用\转义{}
  22.             logger.info("Set \\{} differs from {}", "3"); // output:Set {} differs from 3
  23.  
  24.             // 两个参数
  25.             logger.info("两个占位符，可以传两个参数{}----{}", 1, 2);
  26.  
  27.         }
  28.  
  29.     }
  30.  
  31. }

结果:(会产生对应的文件，test.log永远保存最新的日志，达到10M后会重命名文件为test.log.1,并将原来test.log.1命名为test.log.2....)

log内容如下:

补充:Threshold还可以指定输出的日志级别: (如果设置不起作用查看项目是不是用的log4j的包，有可能有多个log4j包，造成冲突)

　　有时候我们需要把一些报错ERROR日志单独存到指定文件 ，这时候，Threshold属性就派上用场了,比如:

  1. log4j.rootLogger=info,B,C
  2.  
  3. log4j.appender.B=org.apache.log4j.RollingFileAppender
  4. log4j.appender.B.Threshold=info
  5. log4j.appender.B.File=E:\\info.log
  6. log4j.appender.B.MaxFileSize=10MB
  7. log4j.appender.B.MaxBackupIndex=5
  8. log4j.appender.B.layout=org.apache.log4j.PatternLayout
  9. log4j.appender.B.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%c]-[%p] %m%n
  10.  
  11. log4j.appender.C=org.apache.log4j.RollingFileAppender
  12. log4j.appender.C.Threshold=error
  13. log4j.appender.C.File=E:\\error.log
  14. log4j.appender.C.MaxFileSize=10MB
  15. log4j.appender.C.MaxBackupIndex=5
  16. log4j.appender.C.layout=org.apache.log4j.PatternLayout
  17. log4j.appender.C.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%c]-[%p] %m%n

上面B格式的就是info级别以上的日志，包括error信息

　　C格式的就是error级别以上的信息。

　　当然这里有个提前  rootLogger里配置的level必须小于Threshold等级，否则无效 还是按照总的rootLogger里的level来输出，一般我们实际实用的话 rootLogger里配置DEBUG，然后某个文件专门存储ERRO日志，就配置下Threshold为ERROR

代码还是上面的测试代码:

结果:

error.log内容:全是error级别以上的日志

info.log内容(info级别以上，包括error)

补充:log4j也可以对不同的包进行不同的配置，也就是针对不同的包采用不同的日志级别与日志控制器

　　有时候我们也希望对不同的包采用不通的日志记录级别以及不同的日志记录方式。log4j完全可以做到这点，例如下面

默认包采用rootLogger的配置，info级别、在控制台与文件中进行显示;同时又修改了cn下面的a、b、c包的日志级别:

　　cn.a只降低了级别为debug，输出方式还是console与file两种。(一般我们采用这种方式修改级别即可，如果再设置输出方式会在原来的基础上增加方式)

　　cn.b级别设为info，方式设为console，实际是加了第三种方式

　　cn.c级别设置为error，方式设为file，实际也是在rootLogger基础上增加第三种方式

　　级别会以log4j.logger.XX级别为准，不管rootLogger级别高于对具体包的设置还是低于具体包的设置;输出方式会在rootLogger的基础上增加新的方式，如果没有额外的方式采用rootLogger的方式。

例如:(注意标红地方)

  1. log4j.rootLogger=info,console,file
  2.  
  3. log4j.logger.cn.a=debug
  4. log4j.logger.cn.b=info,console
  5. log4j.logger.cn.c=error,file
  6.  
  7. log4j.appender.console=org.apache.log4j.ConsoleAppender
  8. log4j.appender.console.layout=org.apache.log4j.PatternLayout
  9. log4j.appender.console.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%c]-[%p] %m%n
  10.  
  11. log4j.appender.file=org.apache.log4j.RollingFileAppender
  12. log4j.appender.file.File=E:\\test.log
  13. log4j.appender.file.MaxFileSize=10MB
  14. log4j.appender.file.MaxBackupIndex=5
  15. log4j.appender.file.layout=org.apache.log4j.PatternLayout
  16. log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%c]-[%p] %m%n

测试:

包结构:

Root

  1. package cn;
  2.  
  3. import org.slf4j.Logger;
  4. import org.slf4j.LoggerFactory;
  5.  
  6. public class RootClass {
  7.     private static final Logger LOGGER = LoggerFactory.getLogger(RootClass.class);
  8.  
  9.     public static void main(String[] args) {
  10.         LOGGER.debug("RootClass");
  11.         LOGGER.info("RootClass");
  12.         LOGGER.error("RootClass");
  13.     }
  14. }

运行结果:

2018-10-23 19:38:04 [cn.RootClass]-[INFO] RootClass
2018-10-23 19:38:04 [cn.RootClass]-[ERROR] RootClass

AC1

  1. package cn.a;
  2.  
  3. import org.slf4j.Logger;
  4. import org.slf4j.LoggerFactory;
  5.  
  6. public class AC1 {
  7.     private static final Logger LOGGER = LoggerFactory.getLogger(AC1.class);
  8.  
  9.     public static void main(String[] args) {
  10.         LOGGER.debug("AC1");
  11.         LOGGER.info("AC1");
  12.         LOGGER.error("AC1");
  13.     }
  14. }

运行结果:

2018-10-23 19:38:31 [cn.a.AC1]-[DEBUG] AC1
2018-10-23 19:38:31 [cn.a.AC1]-[INFO] AC1
2018-10-23 19:38:31 [cn.a.AC1]-[ERROR] AC1

BC1:

  1. package cn.b;
  2.  
  3. import org.slf4j.Logger;
  4. import org.slf4j.LoggerFactory;
  5.  
  6. public class BC1 {
  7.     private static final Logger LOGGER = LoggerFactory.getLogger(BC1.class);
  8.  
  9.     public static void main(String[] args) {
  10.         LOGGER.debug("BC1");
  11.         LOGGER.info("BC1");
  12.         LOGGER.error("BC1");
  13.     }
  14. }

运行结果:

2018-10-23 19:39:04 [cn.b.BC1]-[INFO] BC1
2018-10-23 19:39:04 [cn.b.BC1]-[INFO] BC1
2018-10-23 19:39:04 [cn.b.BC1]-[ERROR] BC1
2018-10-23 19:39:04 [cn.b.BC1]-[ERROR] BC1

CC1:

  1. package cn.c;
  2.  
  3. import org.slf4j.Logger;
  4. import org.slf4j.LoggerFactory;
  5.  
  6. public class CC1 {
  7.     private static final Logger LOGGER = LoggerFactory.getLogger(CC1.class);
  8.     public static void main(String[] args) {
  9.         LOGGER.debug("CC1");
  10.         LOGGER.info("CC1");
  11.         LOGGER.error("CC1");
  12.     }
  13. }

运行结果:

2018-10-23 19:39:28 [cn.c.CC1]-[ERROR] CC1

最后查看E:/test.log

  1. 2018-10-23 19:38:04 [cn.RootClass]-[INFO] RootClass
  2. 2018-10-23 19:38:04 [cn.RootClass]-[ERROR] RootClass
  3. 2018-10-23 19:38:31 [cn.a.AC1]-[DEBUG] AC1
  4. 2018-10-23 19:38:31 [cn.a.AC1]-[INFO] AC1
  5. 2018-10-23 19:38:31 [cn.a.AC1]-[ERROR] AC1
  6. 2018-10-23 19:39:04 [cn.b.BC1]-[INFO] BC1
  7. 2018-10-23 19:39:04 [cn.b.BC1]-[ERROR] BC1
  8. 2018-10-23 19:39:28 [cn.c.CC1]-[ERROR] CC1
  9. 2018-10-23 19:39:28 [cn.c.CC1]-[ERROR] CC1

补充:对父包设置日志级别，如果子包没有设置默认采用父包的设置，如果子包设置了会采用单独的设置

配置修改cn包设置以及对b包单独进行设置:

  1. log4j.logger.cn=error
  2. log4j.logger.cn.b=info,console

测试cn.d包默认采用cn包的error级别:

  1. package cn.d;
  2.  
  3. import org.slf4j.Logger;
  4. import org.slf4j.LoggerFactory;
  5.  
  6. public class DC1 {
  7.     private static final Logger LOGGER = LoggerFactory.getLogger(DC1.class);
  8.  
  9.     public static void main(String[] args) {
  10.         LOGGER.debug("D");
  11.         LOGGER.info("D");
  12.         LOGGER.error("D");
  13.     }
  14. }

结果：

2018-12-29 13:30:09 [cn.d.DC1]-[ERROR] D

测试cn.b采用单独对cn.b包的配置

  1. package cn.b;
  2.  
  3. import org.slf4j.Logger;
  4. import org.slf4j.LoggerFactory;
  5.  
  6. public class BC1 {
  7.     private static final Logger LOGGER = LoggerFactory.getLogger(BC1.class);
  8.  
  9.     public static void main(String[] args) {
  10.         LOGGER.debug("BC1");
  11.         LOGGER.info("BC1");
  12.         LOGGER.error("BC1");
  13.     }
  14. }

结果:

2018-12-29 13:31:27 [cn.b.BC1]-[INFO] BC1
2018-12-29 13:31:27 [cn.b.BC1]-[INFO] BC1
2018-12-29 13:31:27 [cn.b.BC1]-[ERROR] BC1
2018-12-29 13:31:27 [cn.b.BC1]-[ERROR] BC1

补充:上面的对包的具体设置日志级别虽然不受总的log4j.rootLogger的日志级别的限制，但是却受特殊的日志的Threshold属性的限制,也就是对具体包的设置必须高于其记录器的Threshold属性，否则以其记录器的Threshold属性为准

例如:修改上面的日志配置(每个日志记录器增加Threshold属性)

  1. log4j.rootLogger=info,console,file
  2.  
  3. log4j.logger.cn.a=debug
  4. log4j.logger.cn.b=info,console
  5. log4j.logger.cn.c=error,file
  6.  
  7. log4j.appender.console=org.apache.log4j.ConsoleAppender
  8. log4j.appender.console.Threshold=info
  9. log4j.appender.console.layout=org.apache.log4j.PatternLayout
  10. log4j.appender.console.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%c]-[%p] %m%n
  11.  
  12. log4j.appender.file=org.apache.log4j.RollingFileAppender
  13. log4j.appender.file.Threshold=error
  14. log4j.appender.file.File=E:\\test.log
  15. log4j.appender.file.MaxFileSize=10MB
  16. log4j.appender.file.MaxBackupIndex=5
  17. log4j.appender.file.layout=org.apache.log4j.PatternLayout
  18. log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%c]-[%p] %m%n

运行RootClass:

2018-11-12 23:02:44 [cn.RootClass]-[INFO] RootClass
2018-11-12 23:02:44 [cn.RootClass]-[ERROR] RootClass

运行AC1:

2018-11-12 23:03:08 [cn.a.AC1]-[INFO] AC1
2018-11-12 23:03:08 [cn.a.AC1]-[ERROR] AC1

运行BC1：

2018-11-12 23:03:33 [cn.b.BC1]-[INFO] BC1
2018-11-12 23:03:33 [cn.b.BC1]-[INFO] BC1
2018-11-12 23:03:33 [cn.b.BC1]-[ERROR] BC1
2018-11-12 23:03:33 [cn.b.BC1]-[ERROR] BC1

运行CC1:

2018-11-12 23:04:25 [cn.c.CC1]-[ERROR] CC1

查看test.log:

2018-11-12 23:02:44 [cn.RootClass]-[ERROR] RootClass
2018-11-12 23:03:08 [cn.a.AC1]-[ERROR] AC1
2018-11-12 23:03:33 [cn.b.BC1]-[ERROR] BC1
2018-11-12 23:04:25 [cn.c.CC1]-[ERROR] CC1
2018-11-12 23:04:25 [cn.c.CC1]-[ERROR] CC1

所以总结上面的日记记录级别的设置优先级可以总结为:Threshold  > 具体包的设置  >  rootLogger的全局配置

log4j和slf4j的区别的更多相关文章

  1. 拨云见日，彻底弄清楚Java日志框架 log4j, logback, slf4j的区别与联系

    log4j 以及 logback, slf4j 官网 日志框架的困惑 作为一个正常的项目,是必须有日志框架的存在的,没有日志,很难追踪一些奇奇怪怪的系统问题. 但是,我们经常在项目的依赖中,见到奇奇怪 ...

  2. SpringBoot日志logback-spring.xml分环境log4j logback slf4j区别 springboot日志设置

    转载. https://blog.csdn.net/qianyiyiding/article/details/76565810 springboot按照profile进行打印日志log4j logba ...

  3. JavaEE SSH框架整合(四) 日志处理Spring结合 log4j、slf4j [转]

    1. 加入log4j和slf4j的jar包 2. web.xml: <context-param> <!--log4j配置地址 --> <param-name>lo ...

  4. log4j+logback+slf4j+commons-logging的关系与调试(转)

    log4j+logback+slf4j+commons-logging的关系与调试 从Log4j迁移到LogBack的理由 http://www.tuicool.com/articles/beeeYv ...

  5. java日志，(commons-loging 、log4j 、slf4j 、LogBack介绍)

    如果对于commons-loging .log4j .slf4j .LogBack 等都已经非常清楚了,可以忽略本文.几次解决日志冲突问题时对这几个概念的简单总结,希望对这块基础没有理解透的同学能有所 ...

  6. SSH框架整合 日志处理Spring结合 log4j、slf4j

    1. 加入log4j和slf4j的jar包 2. web.xml: <context-param> <!--log4j配置地址 --> <param-name>lo ...

  7. log4j 和slf4j的比较

    log4j 和slf4j的比较 slf4j 官网:https://www.slf4j.org/manual.html slf4j(simple logging facade for java)是Jav ...

  8. SSM框架下结合 log4j、slf4j打印日志

    首先加入log4j和slf4j的jar包 <!-- 日志处理 <!-- slf4j日志包--> <dependency> <groupId>org.slf4j ...

  9. 日志管理-log4j与slf4j的使用

    一.概述 1.log4j: Log4j是Apache的一个开源项目,通过使用Log4j,我们可以控制日志信息输送的目的地是控制台.文件.GUI组件,甚至是套接口服务器.NT的事件记录器.UNIX Sy ...

随机推荐

  1. 【2019.7.15 NOIP模拟赛 T2】与非树（nand）（树形DP）

    树形\(DP\) 实际上,这道题应该不是很难. 我们设\(f_{x,i,j}\)表示在以\(x\)为根的子树内,原本应输出\(i\),结果输出了\(j\)的情况数. 转移时,为了方便,我们先考虑与,再 ...

  2. 洛谷 题解 P4198 【楼房重建】

    首先明确问题,对于每栋楼房的斜率K=H/X,问题就是问有多少个楼房的K比前面所有楼房的K都要大. 这题树套树当然可以,但是挺麻烦的,本渣觉得最简单就是分块…… 将N个楼房分成T块,不断维护每个块内楼房 ...

  3. [TJOI2019]唱，跳，rap，篮球（生成函数，组合数学，NTT）

    算是补了个万年大坑了吧. 根据 wwj 的题解(最准确),设一个方案 \(S\)(不一定合法)的鸡你太美组数为 \(w(S)\). 答案就是 \(\sum\limits_{S}[w(S)=0]\). ...

  4. CF1136E Nastya Hasn't Written a Legend（线段树）

    还能说什么呢,简直太妙了. $$a_{i+1}<a_i+k_i$$ $$a_{i+1}-k_i-k_{i-1}-\cdots-k_1<a_i+k_i-k_i-k_{i-1}-\cdots- ...

  5. Ubuntu16LTS使用笔记(Server版）

    环境测试:Ubuntu Server 16.04.06 x64 虚拟机 以下均需要root权限,请sudo 或 su root 解决只有先启动Windows再重启到Linux才能使用usb网卡的问题: ...

  6. python运维开发常用模块（二）IPy

    1.安装 IP地址规划是网络设计中非常重要的一个环节,规划的好坏会直 接影响路由协议算法的效率,包括网络性能.可扩展性等方面,在这个 过程当中,免不了要计算大量的IP地址,包括网段.网络掩码.广播地 ...

  7. ng 使用阿里巴巴矢量图

    1.进入阿里巴巴矢量图标库中,选择需要下载的图标,添加进项目中 2.进去项目选择Font class 模式,然后下载到本地 3.解压下载的压缩包,把.css/.svg/.ttf/.woff/.woff ...

  8. 前端与算法 leetcode 387. 字符串中的第一个唯一字符

    目录 # 前端与算法 leetcode 387. 字符串中的第一个唯一字符 题目描述 概要 提示 解析 解法一:双循环 解法二:Set法单循环 算法 传入测试用例的运行结果 执行结果 GitHub仓库 ...

  9. Spring Security简介与入门Demo

    1:Spring Security简介 Spring Security是一个能够为基于Spring的企业应用系统提供声明式的安全访问控制解决方案的安全框架.它提供了一组可以在Spring应用上下文中配 ...

  10. iOS组件化实现方案

    作者原文iOS组件化 - 路由架构从0到1实战  合伙呀 1.CTMediator作为路由中间件 2.基础UI组件以pod形式引入,并且能够独立运行调试 3.基础工具组件以pod形式引入,并且能够独立 ...