Spring boot 官網學習筆記 - logging

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{50} - %msg%n
       # 指定文件中日志輸出的格式 logging.pattern.file=%d{yyyy-MM-dd} === [%thread] === %-5level === %logger{50} === - %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.
    4. 

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