1. commons-logging和slf4j是java中的日志门面,即它们提供了一套通用的接口,具体的实现可以由开发者自由选择。log4j和logback则是具体的日志实现方案。
  2. 比较常用的搭配是commons-logging+log4j,slf4j+logback
  3. 为什么要用SLF4J+Logback 替换commons-logging+log4j?

    1. SLF4J是编译时绑定到具体的日志框架,性能优于采用运行时搜寻的方式的commons-logging
    2. 不需要使用logger.isDebugEnabled()来解决日志因为字符拼接产生的性能问题
      1. logger.info("my name is {}", "medusar");
        logger.info("my name is " + "medusar");
      2. 
        

        在效率上,第一行比第二行更高,因为如果当前日志级别是ERROR,第一行不会进行字符串拼接,而第二行,无论日志级别是什么,都会先进行字符串拼接。

      3. 所以为了解决这个问题,commons-logging等框架提供了下面的方式:
        if (log.isDebugEnabled()){
        log.debug("dddd"+"eee");
        }
  4. 基于commons-logging的日志使用
    1. import org.apache.commons.logging.Log;
      import org.apache.commons.logging.LogFactory;
      public class XXXService {
      private static final Log log = LogFactory.getLog(XXXService.class);
      public void doSomething(){
      log.info("begin dosomething....");
      }
      }
  5. 基于slf4j的日志使用

    1. import org.slf4j.Logger;
      import org.slf4j.LoggerFactory;
      public class XXXService {
      private static final Logger logger = LoggerFactory.getLogger(XXXService.class);
      public void doSomething() {
      logger.info("begin dosomething...");
      }
      }
  6. SpringBoot底层也是使用slf4j+logback的方式进行日志记录;
  7. SpringBoot也把其他的日志都替换成了slf4j;
  8. Spring Boot能自动适配所有的日志,而且底层使用slf4j+logback的方式记录日志,引入其他框架的时候,只需要把这个框架依赖的日志框架排除掉。
    1.  <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <exclusions>
      <exclusion>
      <groupId>commons-logging</groupId>
      <artifactId>commons-logging</artifactId>
      </exclusion>
      </exclusions>
      </dependency>
    2. 以后开发的时候,日志记录方法的调用,不应该直接调用日志的实现类,而是调用日志抽象层里面的方法;给系统里面导入slf4j的jar和logback的实现jar
    3. import org.slf4j.Logger;
      import org.slf4j.LoggerFactory;
      public class HelloWorld {
      public static void main(String[] args) {
      Logger logger = LoggerFactory.getLogger(HelloWorld.class);
      logger.info("Hello World"); }
      }
  9. 指定文件中日志输出的格式
    1. # 在控制台输出的日志格式 logging.pattern.console=%d{yyyy-MM-dd} [%thread] %-5level %logger{} - %msg%n
      # 指定文件中日志输出的格式 logging.pattern.file=%d{yyyy-MM-dd} === [%thread] === %-5level === %logger{} === - %msg%n
    2. <!-- 日志输出格式:            
      1. %d表示日期时间,
      2. %thread表示线程名,
      3. %-5level:级别从左显示5个字符宽度
      4. %logger{50} 表示logger名字最长50个字符,否则按照句点分割。
      5. %msg:日志消息,
      6. %n是换行符-->
  10. 切换日志框架(无意义,slf4j+logback已经是最佳实现)

    1. <dependencies>
      <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
      <!--排除转换包-->
      <exclusions>
      <exclusion>
      <artifactId>logback-classic</artifactId>
      <groupId>ch.qos.logback</groupId>
      </exclusion>
      <exclusion>
      <artifactId>log4j-over-slf4j</artifactId>
      <groupId>org.slf4j</groupId> </exclusion>
      </exclusions>
      </dependency>
      <!--添加slf4j依赖-->
      <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      </dependency>
      <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
      </dependency>
      </dependencies>
  11. 调整日志级别
    1. Log Level: ERROR, WARN, INFO, DEBUG, or TRACE.
    2. Logback does not have a FATAL level. It is mapped to ERROR.
    3. The default log configuration echoes messages to the console as they are written. By default, ERROR-level, WARN-level, and INFO-level messages are logged. You can also enable a “debug” mode by starting your application with a --debug flag.
    4. $ java -jar myapp.jar --debug
    5. Alternatively, you can enable a “trace” mode by starting your application with a --trace flag (or trace=true in your application.properties).
    6. All the supported logging systems can have the logger levels set in the Spring Environment (for example, in application.properties) by using logging.level.<logger-name>=<level> where level is one of TRACE, DEBUG, INFO, WARN, ERROR, FATAL, or OFF. The root logger can be configured by using logging.level.root.

      The following example shows potential logging settings in application.properties:

    7. logging.level.root=WARN
      logging.level.org.springframework.web=DEBUG
      logging.level.org.hibernate=ERROR
  12. 日志文件
    1. By default, Spring Boot logs only to the console and does not write log files. If you want to write log files in addition to the console output, you need to set a logging.file or logging.path property (for example, in your application.properties).
    2. Log files rotate when they reach 10 MB and, as with console output, ERROR-level, WARN-level, and INFO-level messages are logged by default. Size limits can be changed using the logging.file.max-size property. Previously rotated files are archived indefinitely unless the logging.file.max-history property has been set.
    3. Logging properties are independent of the actual logging infrastructure. As a result, specific configuration keys (such as logback.configurationFile for Logback) are not managed by spring Boot.
  13. Log Groups

    1. It’s often useful to be able to group related loggers together so that they can all be configured at the same time. For example, you might commonly change the logging levels for all Tomcat related loggers, but you can’t easily remember top level packages.

      To help with this, Spring Boot allows you to define logging groups in your Spring Environment. For example, here’s how you could define a “tomcat” group by adding it to your application.properties:

      logging.group.tomcat=org.apache.catalina, org.apache.coyote, org.apache.tomcat

      Once defined, you can change the level for all the loggers in the group with a single line:

      logging.level.tomcat=TRACE

      Spring Boot includes the following pre-defined logging groups that can be used out-of-the-box:

      Name Loggers

      web

      org.springframework.core.codec, org.springframework.http, org.springframework.web

      sql

      org.springframework.jdbc.core, org.hibernate.SQL

  14. Custom Log Configuration

    1. The various logging systems can be activated by including the appropriate libraries on the classpath and can be further customized by providing a suitable configuration file in the root of the classpath or in a location specified by the following Spring Environment property: logging.config.
    2. Since logging is initialized before the ApplicationContext is created, it is not possible to control logging from @PropertySources in Spring @Configuration files. The only way to change the logging system or disable it entirely is via System properties.
    3. Depending on your logging system, the following files are loaded:
    4. Logging System Customization

      Logback

      logback-spring.xml, logback-spring.groovy, logback.xml, or logback.groovy

      Log4j2

      log4j2-spring.xml or log4j2.xml

      JDK (Java Util Logging)

      logging.properties

    5. When possible, we recommend that you use the -spring variants for your logging configuration (for example, logback-spring.xml rather than logback.xml). If you use standard configuration locations, Spring cannot completely control log initialization.
    6. To help with the customization, some other properties are transferred from the Spring Environment to System properties, as described in the following table:

      1. Spring Environment System Property Comments

        logging.exception-conversion-word

        LOG_EXCEPTION_CONVERSION_WORD

        The conversion word used when logging exceptions.

        logging.file

        LOG_FILE

        If defined, it is used in the default log configuration.

        logging.file.max-size

        LOG_FILE_MAX_SIZE

        Maximum log file size (if LOG_FILE enabled). (Only supported with the default Logback setup.)

        logging.file.max-history

        LOG_FILE_MAX_HISTORY

        Maximum number of archive log files to keep (if LOG_FILE enabled). (Only supported with the default Logback setup.)

        logging.path

        LOG_PATH

        If defined, it is used in the default log configuration.

        logging.pattern.console

        CONSOLE_LOG_PATTERN

        The log pattern to use on the console (stdout). (Only supported with the default Logback setup.)

        logging.pattern.dateformat

        LOG_DATEFORMAT_PATTERN

        Appender pattern for log date format. (Only supported with the default Logback setup.)

        logging.pattern.file

        FILE_LOG_PATTERN

        The log pattern to use in a file (if LOG_FILE is enabled). (Only supported with the default Logback setup.)

        logging.pattern.level

        LOG_LEVEL_PATTERN

        The format to use when rendering the log level (default %5p). (Only supported with the default Logback setup.)

        PID

        PID

        The current process ID (discovered if possible and when not already defined as an OS environment variable).

  15. xx

Spring boot 官网学习笔记 - logging的更多相关文章

  1. Spring boot 官网学习笔记 - Spring Boot 属性配置和使用(转)-application.properties

    Spring Boot uses a very particular PropertySource order that is designed to allow sensible overridin ...

  2. Spring boot 官网学习笔记 - Spring DevTools 介绍

    想要使用devtools支持,只需使用dependencies将模块依赖关系添加到你的构建中 运行打包的应用程序时,开发人员工具会自动禁用.如果你通过 java -jar或者其他特殊的类加载器进行启动 ...

  3. Spring boot 官网学习笔记 - Auto-configuration(@SpringBootApplication、@EnableAutoConfiguration、@Configuration)

    Spring Boot auto-configuration attempts to automatically configure your Spring application based on ...

  4. Spring boot 官网学习笔记 - Using Spring Boot without the Parent POM,但是还要使用Parent POM提供的便利

    If you do not want to use the spring-boot-starter-parent, you can still keep the benefit of the depe ...

  5. Spring boot 官网学习笔记 - 开发第一个Spring boot web应用程序(使用mvn执行、使用jar执行)

    Creating the POM <?xml version="1.0" encoding="UTF-8"?> <project xmlns= ...

  6. Spring boot 官网学习笔记 - Spring Boot CLI 入门案例

    安装CLI https://repo.spring.io/release/org/springframework/boot/spring-boot-cli/2.1.1.RELEASE/spring-b ...

  7. Spring boot 官网学习笔记 - Configuration Class(@import)

    推荐使用 Java-based configuration ,也可以使用xml we generally recommend that your primary source be a single ...

  8. Spring Boot的学习之路(02):和你一起阅读Spring Boot官网

    官网是我们学习的第一手资料,我们不能忽视它.却往往因为是英文版的,我们选择了逃避它,打开了又关闭. 我们平常开发学习中,很少去官网上看.也许学完以后,我们连官网长什么样子,都不是很清楚.所以,我们在开 ...

  9. (五)Spring Boot官网文档学习

    文章目录 SpringApplication SpringApplication 事件 `ApplicationContext ` 类型 访问传递给 `SpringApplication` 的参数 A ...

随机推荐

  1. python学习——高阶函数

    递归函数 在函数内部,可以调用其他函数.如果一个函数在内部调用自身本身,这个函数就是递归函数.使用递归函数的优点是逻辑简单清晰,缺点就是过深的调用会导致栈溢出.但是针对尾递归优化的语言可以通过尾递归防 ...

  2. ‎CocosBuilder 学习笔记(1) CCBReader 解析.ccbi文件流程

    1. 简介 CocosBuilder是免费开源的Cocos2d UI编辑器. .ccb文件是CCB项目的原始文件. .ccbi文件是CCB项目发布后的生成的二进制文件.CCBReader可以快速通过该 ...

  3. 使用synchronized获取互斥锁的几点说明

    在并发编程中,多线程同时并发访问的资源叫做临界资源,当多个线程同时访问对象并要求操作相同资源时,分割了原子操作就有可能出现数据的不一致或数据不完整的情况,为避免这种情况的发生,我们会采取同步机制,以确 ...

  4. C++ 并发编程之互斥锁和条件变量的性能比较

    介绍 本文以最简单生产者消费者模型,通过运行程序,观察该进程的cpu使用率,来对比使用互斥锁 和 互斥锁+条件变量的性能比较. 本例子的生产者消费者模型,1个生产者,5个消费者. 生产者线程往队列里放 ...

  5. Python--编码与字符串

    为什么字符串要编码呢? 因为计算机只能处理数字,最底层的CPU只能识别0和1.所以字符串就需要编码成对应的数字. 在计算机中,最开始只有ASCII,我们开始接触计算机编程时就学了ASCII码.最早只有 ...

  6. hdu 6092 Rikka with Subset(多重背包)

    题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=6092 #include <cstdio> #include <iostream> ...

  7. 牛客OI测试赛 F 子序列 组合数学 欧拉降幂公式模板

    链接:https://www.nowcoder.com/acm/contest/181/F来源:牛客网 题目描述 给出一个长度为n的序列,你需要计算出所有长度为k的子序列中,除最大最小数之外所有数的乘 ...

  8. C++数据类型(data type)介绍

    在编写程序时,数据类型(data type)定义了使用存储空间的(内存)的方式. 程序员通过定义数据类型(data type),告诉特定存储空间这里要存储的数据类型是什么,以及你即将操作他的方式.(注 ...

  9. 漫谈Spring Security 在Spring Boot 2.x endpoints中的应用(一)

    Spring Boot 2.x极大简化了默认的安全配置,并不是说有很多安全相关的配置,现在你只需要提供一个WebSecurityConfigurerAdapter继承类这样一个简单的操作,Spring ...

  10. 深入理解SQL Server数据库Select查询原理(一)

    使用SQL Server十年有余,但是一直对其Select查询机制原理一致不明,直到最近有个通讯录表,很简单的一张表(但因简单,所以当时并没有考虑按部门排序问题),结果想查询某个单位所有部门(不重复) ...