一、Log4j

Log4j是Apache的一個開放原始碼專案，通過使用Log4j，我們可以控制日誌資訊輸送的目的地是控制檯、檔案、資料庫等；我們也可以控制每一條日誌的輸出格式；通過定義每一條日誌資訊的級別，我們能夠更加細緻地控制日誌的生成過程。 
Log4j有7種不同的log級別，按照等級從低到高依次為：TRACE、DEBUG、INFO、WARN、ERROR、FATAL、OFF。如果配置為OFF級別，表示關閉log。 
Log4j支援兩種格式的配置檔案：properties和xml。包含三個主要的元件：Logger、appender、Layout。

（1）控制檯輸出

    # LOG4J配置
    log4j.rootLogger=INFO,stdout
    # 控制檯輸出
    log4j.appender.stdout=org.apache.log4j.ConsoleAppender 
    log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 
    log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS} %5p %c{1}:%L - %m%n
 

（2）輸出到檔案 
在開發環境，我們只是輸出到控制檯沒有問題，但是到了生產或測試環境，或許持久化日誌內容，方便追溯問題原因。可以通過新增如下的appender內容，按天輸出到不同的檔案中去，同時還需要為log4j.rootLogger新增名為file的appender，這樣root日誌就可以輸出到logs/springboot.log檔案中了。輸出到檔案和輸出到控制檯是可以並行存在的。

# LOG4J配置
log4j.rootLogger=INFO,stdout,file
# 日誌輸出到檔案
log4j.appender.file=org.apache.log4j.DailyRollingFileAppender 
log4j.appender.file.file=logs/springboot.log 
log4j.appender.file.DatePattern='.'yyyy-MM-dd 
log4j.appender.file.layout=org.apache.log4j.PatternLayout 
log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS} %5p %c{1}:%L - %m%n 
 

（3）分類輸出 
當我們日誌量較多的時候，查詢問題會非常困難，常用的手段就是對日誌進行分類，比如： 
可以按不同package進行輸出。通過定義輸出到logs/my.log的appender，並對com.test包下的日誌級別設定為DEBUG級別、appender設定為輸出到logs/my.log的名為testlog的appender。

# com.test包下的日誌配置
log4j.logger.com.test=DEBUG, testlog
# com.test下的日誌輸出
log4j.appender.testlog=org.apache.log4j.DailyRollingFileAppender 
log4j.appender.testlog.file=logs/my.log 
log4j.appender.testlog.DatePattern='.'yyyy-MM-dd 
log4j.appender.testlog.layout=org.apache.log4j.PatternLayout 
log4j.appender.testlog.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS} %5p %c{1}:%L ---- %m%n

可以對不同級別進行分類，比如對ERROR級別輸出到特定的日誌檔案中，具體配置可以如下：

# LOG4J配置
log4j.rootCategory=INFO, stdout,errorfile
log4j.logger.error=errorfile
 
# error日誌輸出
log4j.appender.errorfile=org.apache.log4j.DailyRollingFileAppender
log4j.appender.errorfile.file=logs/error.log
log4j.appender.errorfile.DatePattern='.'yyyy-MM-dd
log4j.appender.errorfile.Threshold = ERROR
log4j.appender.errorfile.layout=org.apache.log4j.PatternLayout
log4j.appender.errorfile.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS} %5p %c{1}:%L - %m%n %5p %c{1}:%L - %m%n

（4）輸出到資料庫 
將日誌檔案輸出到資料庫配置：

\# LOG4J配置
log4j.rootCategory=INFO,stdout,jdbc
 
\# 資料庫輸出
log4j.appender.jdbc=org.apache.log4j.jdbc.JDBCAppender
log4j.appender.jdbc.driver=com.mysql.jdbc.Driver
log4j.appender.jdbc.URL=jdbc:mysql://127.0.0.1:3306/test?characterEncoding=utf8&useSSL=true
log4j.appender.jdbc.user=root
log4j.appender.jdbc.password=root
log4j.appender.jdbc.sql=insert into log_icecoldmonitor(level,category,thread,time,location,note) values('%p','%c','%t','%d{yyyy-MM-dd HH:mm:ss:SSS}','%l','%m')

引入資料庫驅動：

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

建立表：

CREATE TABLE `log_icecoldmonitor` (
  `Id` int(11) NOT NULL AUTO_INCREMENT,
  `level` varchar(255) NOT NULL DEFAULT '' COMMENT '優先順序',
  `category` varchar(255) NOT NULL DEFAULT '' COMMENT '類目',
  `thread` varchar(255) NOT NULL DEFAULT '' COMMENT '程序',
  `time` varchar(30) NOT NULL DEFAULT '' COMMENT '時間',
  `location` varchar(255) NOT NULL DEFAULT '' COMMENT '位置',
  `note` text COMMENT '日誌資訊',
  PRIMARY KEY (`Id`)
)

這樣就可以儲存到日誌到資料庫了，可能會出現如下異常資訊： 
Java連線Mysql資料庫警告：Establishing SSL connection 
原因是MySQL在高版本需要指明是否進行SSL連線。解決方案如下： 
在mysql連線字串url中加入ssl=true或者false即可，如下所示。 
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/test?characterEncoding=utf8&useSSL=true

應用

• 引入log4j依賴 
  在建立Spring Boot工程時，我們引入了spring-boot-starter，其中包含了spring-boot-starter-logging，該依賴內容就是Spring Boot預設的日誌框架Logback，所以我們在引入log4j之前，需要先排除該包的依賴，再引入log4j的依賴。

  <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter</artifactId>
      <exclusions>
          <exclusion>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-starter-logging</artifactId>
          </exclusion>
      </exclusions>
  </dependency>
  <dependency> 
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-log4j</artifactId>
  </dependency>

  值得注意的是，spring boot 1.3版本支援log4j，在spring boot 1.4的版本中，就需要使用log4j2，否則會出現如下錯誤：Project build error: 'dependencies.dependency.version' for org.springframework.boot:spring-boot-starter-log4j:jar is missing.

• 配置log4j-spring.properties 

在引入了log4j依賴之後，只需要在src/main/resources目錄下加入log4j.properties（或log4j-spring.properties）配置檔案，就可以開始對應用的日誌進行配置使用。測試配置內容如下：

# DEBUG INFO WARN ERROR FATAL
log4j.rootLogger = info,stdout,errorlogfile
 
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Threshold = info
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern =%-d{yyyy-MM-dd HH:mm:ss} [%c]-[%p] - %m%n
log4j.appender.stdout.ImmediateFlush = true
 
log4j.appender.errorlogfile = org.apache.log4j.DailyRollingFileAppender
log4j.appender.errorlogfile.Threshold = INFO
log4j.appender.errorlogfile.layout = org.apache.log4j.PatternLayout
log4j.appender.errorlogfile.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss} [%c]-[%p] - %m%n
log4j.appender.errorlogfile.File = ../logs/testlog4j.log
log4j.appender.errorlogfile.Append = true
log4j.appender.errorlogfile.ImmediateFlush = true

• 配置application.properties 

指定log配置檔案

logging.config= classpath:log4j.properties

• 在啟動類中進行測試

  private static Logger logger = Logger.getLogger(TestLog4jApplication.class);
   
  public static void main(String[] args) {
          logger.info("log4j----------------\n");
          SpringApplication.run(TestLog4jApplication.class, args);
  }

  執行專案，即可看到控制檯打印出的日誌資訊，同時在專案同級目錄下的logs/testlog4j.log中也會打印出比較詳盡的日誌資訊。

二、Log4j2

Spring Boot1.4以及之後的版本已經不支援log4j，log4j也很久沒有更新了，現在已經有很多其他的日誌框架對Log4j進行了改良，比如說SLF4J、Logback等。而且Log4j 2在各個方面都與Logback非常相似，那麼為什麼我們還需要Log4j 2呢？ 
　　1. 外掛式結構。Log4j 2支援外掛式結構。我們可以根據自己的需要自行擴充套件Log4j 2. 我們可以實現自己的appender、logger、filter。 
　　2. 配置檔案優化。在配置檔案中可以引用屬性，還可以直接替代或傳遞到元件。而且支援json格式的配置檔案。不像其他的日誌框架，它在重新配置的時候不會丟失之前的日誌檔案。 
　　3. Java 5的併發性。Log4j 2利用Java 5中的併發特性支援，儘可能地執行最低層次的加鎖。解決了在log4j 1.x中存留的死鎖的問題。 
　　4. 非同步logger。Log4j 2是基於LMAX Disruptor庫的。在多執行緒的場景下，和已有的日誌框架相比，非同步的logger擁有10倍左右的效率提升。 
　　 
官方建議一般程式設計師檢視的日誌改成非同步方式，一些運營日誌改成同步。日誌非同步輸出的好處在於，使用單獨的程序來執行日誌列印的功能，可以提高日誌執行效率，減少日誌功能對正常業務的影響。非同步日誌在程式的classpath需要載入disruptor-3.0.0.jar或者更高的版本。

 <!-- log4j2非同步日誌需要載入disruptor-3.0.0.jar或者更高的版本 -->
        <dependency>
            <groupId>com.lmax</groupId>
            <artifactId>disruptor</artifactId>
            <version>3.3.6</version>
        </dependency>

非同步日誌分為兩種： 
a.全非同步模式 
這種非同步日誌方式，不需要修改修改原理的配置檔案，Logger仍然使用<root> and <logger> 
只需要在主程式程式碼開頭，加一句系統屬性的程式碼：

System.setProperty("Log4jContextSelector", "org.apache.logging.log4j.core.async.AsyncLoggerContextSelector");  

b.非同步和非非同步混合輸出模式 
在配置檔案中Logger使用<asyncRoot> or <asyncLogger>

<loggers>  
     <AsyncLogger name="AsyncLogger" level="trace" includeLocation="true">  
        <appender-ref ref="Console" />  
        <appender-ref ref="debugLog" />  
        <appender-ref ref="errorLog" />  
    </AsyncLogger>  
 
    <asyncRoot level="trace" includeLocation="true">  
        <appender-ref ref="Console" />  
    </asyncRoot>   
</loggers>  

應用

• 引入log4j2依賴 

在建立Spring Boot工程時，我們引入了spring-boot-starter，其中包含了spring-boot-starter-logging，該依賴內容就是Spring Boot預設的日誌框架Logback，所以我們在引入log4j2之前，需要先排除該包的依賴，再引入log4j2的依賴。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-logging</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency> 
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-log4j2</artifactId>
</dependency>

• log4j2.xml配置 

有一點需要注意的是，假如想要在application.properties中指定日誌檔案存放路徑或日誌檔名，在log4j2.xml中使用${LOG_PATH}或者${LOG_FILE}來引用，是無法獲取到的（在logback中可以盡情使用）。log4j2支援xml、json、yaml等格式的配置檔案。

<?xml version="1.0" encoding="UTF-8"?>  
<Configuration status="WARN">  
    <Properties>
        <property name="LOG_PATH">../logs/</property>
        <property name="LOG_FILE">testlog4j2</property>
    </Properties>
    <Appenders>  
        <Console name="Console" target="SYSTEM_OUT">  
            <PatternLayout>  
                <pattern>%-d{yyyy-MM-dd HH:mm:ss} [%c]-[%p] - %m%n</pattern>  
            </PatternLayout>  
        </Console>  
        <RollingFile name="errorlogfile" fileName="${LOG_PATH}/${LOG_FILE}.log"
                  filePattern="${LOG_PATH}/$${date:yyyy-MM}/${LOG_FILE}-%d{yyyy-MM-dd HH-mm}-%i.log">
          <PatternLayout> 
            <pattern>%-d{yyyy-MM-dd HH:mm:ss} [%c]-[%p] - %m%n</pattern>
          </PatternLayout>  
          <Policies>  
                <TimeBasedTriggeringPolicy />  
                <SizeBasedTriggeringPolicy size="50 MB" />  
          </Policies>  
          <DefaultRolloverStrategy max="20" />  
        </RollingFile>  
    </Appenders>  
    <Loggers> 
        <root level="info">    
          <AppenderRef ref="Console"/>  
          <AppenderRef ref="errorlogfile" /> 
        </root>    
    </Loggers>  
</Configuration>  

• application.properties配置 

指定log配置檔案

logging.config= classpath:log4j2.xml

• 在啟動類中進行測試

  private static Logger logger = LogManager.getLogger(TestLog4j2Application.class);
   
  public static void main(String[] args) {
      logger.error("log4j2----------------\n");
      SpringApplication.run(TestLog4j2Application.class, args);
  }

  執行專案，即可看到控制檯打印出的日誌資訊，同時在專案同級目錄下的logs/testlog4j2.log中也會打印出比較詳盡的日誌資訊。

  三、SLF4J

  SLF4J，即簡單日誌門面（Simple Logging Facade for Java），不是具體的日誌解決方案，而是通過Facade Pattern提供一些Java logging API，它只服務於各種各樣的日誌系統。按照官方的說法，SLF4J是一個用於日誌系統的簡單Facade，允許終端使用者在部署其應用時使用其所希望的日誌系統。作者建立SLF4J的目的是為了替代Jakarta Commons-Logging。 
  實際上，SLF4J所提供的核心API是一些介面以及一個LoggerFactory的工廠類。在使用SLF4J的時候，不需要在程式碼中或配置檔案中指定你打算使用那個具體的日誌系統。類似於Apache Common-Logging，SLF4J是對不同日誌框架提供的一個門面封裝，可以在部署的時候不修改任何配置即可接入一種日誌實現方案。但是，他在編譯時靜態繫結真正的Log庫。使用SLF4J時，如果你需要使用某一種日誌實現，那麼你必須選擇正確的SLF4J的jar包的集合（各種橋接包）。SLF4J提供了統一的記錄日誌的介面，只要按照其提供的方法記錄即可，最終日誌的格式、記錄級別、輸出方式等通過具體日誌系統的配置來實現，因此可以在應用中靈活切換日誌系統。

  

  那麼什麼時候使用SLF4J比較合適呢？ 
  如果你開發的是類庫或者嵌入式元件，那麼就應該考慮採用SLF4J，因為不可能影響終端使用者選擇哪種日誌系統。在另一方面，如果是一個簡單或者獨立的應用，確定只有一種日誌系統，那麼就沒有使用SLF4J的必要。假設你打算將你使用log4j的產品賣給要求使用JDK 1.8 Logging的使用者時，面對成千上萬的log4j呼叫的修改，相信這絕對不是一件輕鬆的事情。但是如果開始便使用SLF4J，那麼這種轉換將是非常輕鬆的事情。

  應用

  例如上述內容中，log4j測試，使用

  import org.apache.log4j.Logger;
  
  private static Logger logger = Logger.getLogger(TestLog4jApplication.class);

  而在log4j2測試使用

  import org.apache.logging.log4j.LogManager;
  import org.apache.logging.log4j.Logger;
  
  private static Logger logger = LogManager.getLogger(TestLog4j2Application.class);

  假如後期改變log實現系統，所有呼叫log4j的程式碼都需要進行修改，假如一開始都使用slf4j.Logger，後期將無需修改程式碼。

  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  
  private static Logger logger = LoggerFactory.getLogger(TestLog4jApplication.class);
  
  private static Logger logger = LoggerFactory.getLogger(TestLog4j2Application.class); 

  假如遇到SLF4J: Class path contains multiple SLF4J bindings相關的錯誤提示，則是因為引入了多個日誌系統，需要排除多餘的依賴。

  slf4j-simple是slf4j的一種日誌系統實現，目前最新版本是1.7.7。

  <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-simple</artifactId>
      <version>1.7.7</version>
  </dependency>

  四、Logback

  Logback，一個“可靠、通用、快速而又靈活的Java日誌框架”。logback當前分成三個模組：logback-core，logback- classic和logback-access。logback-core是其它兩個模組的基礎模組。logback-classic是log4j的一個改良版本。此外logback-classic完整實現SLF4J API使你可以很方便地更換成其它日誌系統如log4j或JDK Logging。logback-access訪問模組與Servlet容器整合提供通過Http來訪問日誌的功能。 
  1. logback-core: Joran, Status, context, pattern parsing 
  2. logback-classic: developer logging 
  3. logback-access: The log generated when a user accesses a web-page on a web server. Integrates seamlessly with Jetty and Tomcat.

  選擇logback的理由： 
  1. logback比log4j要快大約10倍，而且消耗更少的記憶體。 
  2. logback-classic模組直接實現了SLF4J的介面，所以我們遷移到logback幾乎是零開銷的。 
  3. logback不僅支援xml格式的配置檔案，還支援groovy格式的配置檔案。相比之下，Groovy風格的配置檔案更加直觀，簡潔。 
  4. logback-classic能夠檢測到配置檔案的更新，並且自動重新載入配置檔案。 
  5. logback能夠優雅的從I/O異常中恢復，從而我們不用重新啟動應用程式來恢復logger。 
  6. logback能夠根據配置檔案中設定的上限值，自動刪除舊的日誌檔案。 
  7. logback能夠自動壓縮日誌檔案。 
  8. logback能夠在配置檔案中加入條件判斷（if-then-else)。可以避免不同的開發環境（dev、test、uat…）的配置檔案的重複。 
  9. logback帶來更多的filter。 
  10. logback的stack trace中會包含詳細的包資訊。 
  11. logback-access和Jetty、Tomcat整合提供了功能強大的HTTP-access日誌。 
  配置檔案：需要在專案的src目錄下建立一個logback.xml。 
  注：（1）logback首先會試著查詢logback.groovy檔案； 
  （2）當沒有找到時，繼續試著查詢logback-test.xml檔案； 
  （3）當沒有找到時，繼續試著查詢logback.xml檔案； 
  （4）如果仍然沒有找到，則使用預設配置（列印到控制檯）。

  logback的一些配置介紹： 
  * 控制檯輸出 
  在Spring Boot中預設配置了ERROR、WARN和INFO級別的日誌輸出到控制檯。我們可以通過兩種方式切換至DEBUG級別： 
  在執行命令後加入–debug標誌，如：$ java -jar test.jar --debug 
  在application.properties中配置debug=true，該屬性置為true的時候，核心Logger（包含嵌入式容器、hibernate、spring）會輸出更多內容，但是你自己應用的日誌並不會輸出為DEBUG級別。

• 多彩輸出 
  如果你的終端支援ANSI，設定彩色輸出會讓日誌更具可讀性。通過在application.properties中設定spring.output.ansi.enabled引數來支援。 
  NEVER：禁用ANSI-colored輸出（預設項） 
  DETECT：會檢查終端是否支援ANSI，是的話就採用彩色輸出（推薦項） 
  ALWAYS：總是使用ANSI-colored格式輸出，若終端不支援的時候，會有很多幹擾資訊，不推薦使用

• 檔案輸出 
  Spring Boot預設配置只會輸出到控制檯，並不會記錄到檔案中，但是我們通常生產環境使用時都需要以檔案方式記錄。 
  若要增加檔案輸出，需要在application.properties中配置logging.file或logging.path屬性。 
  logging.file，設定檔案，可以是絕對路徑，也可以是相對路徑。如：logging.file=my.log 
  logging.path，設定目錄，會在該目錄下建立spring.log檔案，並寫入日誌內容，如：logging.path=../logs 
  日誌檔案會在10Mb大小的時候被截斷，產生新的日誌檔案，預設級別為：ERROR、WARN、INFO

• 級別控制 
  在Spring Boot中只需要在application.properties中進行配置完成日誌記錄的級別控制。 
  配置格式：logging.level.*=LEVEL 
  logging.level：日誌級別控制字首，*為包名或Logger名 
  LEVEL：選項TRACE, DEBUG, INFO, WARN, ERROR, FATAL, OFF 
  舉例： 
  logging.level.com.test=DEBUG：com.test包下所有class以DEBUG級別輸出 
  logging.level.root=WARN：root日誌以WARN級別輸出

• 自定義輸出格式 
  在Spring Boot中可以通過在application.properties配置如下引數控制輸出格式： 
  logging.pattern.console：定義輸出到控制檯的樣式（不支援JDK Logger） 
  logging.pattern.file：定義輸出到檔案的樣式（不支援JDK Logger）

應用

logback是Spring Boot預設的日誌系統，假如對日誌沒有特殊要求，可以完全零配置使用 SLF4J（Simple Logging Facade For Java）的logback來輸出日誌。

package com.jianeye.test;
 
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
 
SpringBootApplication
public class TestApplication {
 
    private static Logger logger = LoggerFactory.getLogger(TestApplication.class);
 
    public static void main(String[] args) {
        logger.warn("logback --------------------------------\n");  
        SpringApplication.run(TestApplication.class, args);
        logger.info("default log system *************************\n");  
    }
}

Spring Boot也支援自定義日誌配置，有以下兩種方式。 
1. 在 src/main/resources 下面建立logback.xml （根據不同環境來定義不同的日誌輸出，那麼取名為logback-spring.xml 即可）檔案，並按需求進行配置。

logback-spring.xml 檔案：

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <include resource="org/springframework/boot/logging/logback/base.xml" />
    <logger name="org.springframework.web" level="INFO"/>
    <logger name="org.springboot.sample" level="TRACE" />
 
    <springProfile name="dev">
        <logger name="org.springboot.sample" level="DEBUG" />
    </springProfile>
 
    <springProfile name="staging">
        <logger name="org.springboot.sample" level="INFO" />
    </springProfile>
</configuration>

使用最簡單的方法，在 application 配置檔案中配置。

logging:
    config: classpath:logback-spring.xml
    file: cuckoo3
    path: /cuckoo3-log/logs
    level:       
        com.jianeye.cuckoo3.webside:  DEBUG

需要注意幾點： 
1. 這裡若不配置具體的包的日誌級別，日誌檔案資訊將為空 
2. 若只配置logging.path，那麼將會在E:\logs資料夾生成一個日誌檔案為spring.log 
3. 若只配置logging.file，那將會在專案的當前路徑下生成一個demo.log日誌檔案 
4. logging.path和logging.file同時配置，不會有在這個路徑有E:\logs\demo.log日誌生成，logging.path和logging.file不會進行疊加 
5. logging.path和logging.file的value都可以是相對路徑或者絕對路徑

五、Apache Commons Logging

Apache Commons Logging ，之前叫 Jakarta Commons Logging（JCL）提供的是一個日誌(Log)介面(interface)，同時兼顧輕量級和不依賴於具體的日誌實現工具。它提供給中介軟體/日誌工具開發者一個簡單的日誌操作抽象，允許程式開發人員使用不同的具體日誌實現工具。使用者被假定已熟悉某種日誌實現工具的更高級別的細節。JCL提供的介面，對其它一些日誌工具，包括Log4J, Avalon LogKit, and JDK 1.4+等，進行了簡單的包裝，此介面更接近於Log4J和LogKit的實現。 
common-logging是apache提供的一個通用的日誌介面。使用者可以自由選擇第三方的日誌元件作為具體實現，像log4j，或者jdk自帶的logging， common-logging會通過動態查詢的機制，在程式執行時自動找出真正使用的日誌庫。當然，common-logging內部有一個Simple logger的簡單實現，但是功能很弱。所以使用common-logging，通常都是配合著log4j來使用。使用它的好處就是，程式碼依賴是common-logging而非log4j， 避免了和具體的日誌方案直接耦合，在有必要時，可以更改日誌實現的第三方庫。 
使用common-logging的常見程式碼：

import org.apache.commons.logging.Log;  
import org.apache.commons.logging.LogFactory;  
 
public class A {  
    private static Log logger = LogFactory.getLog(this.getClass());  
}  

slf4j 與 common-logging 比較 
common-logging通過動態查詢的機制，在程式執行時自動找出真正使用的日誌庫； 
slf4j在編譯時靜態繫結真正的Log庫。

六、java.util.logging.Logger

java.util.logging.Logger（JUL），JDK自帶的日誌系統，從JDK1.4就有了。關鍵元素包括： 
Logger：應用程式進行logging呼叫的主要實體。Logger 物件用來記錄特定系統或應用程式元件的日誌訊息。 
LogRecord：用於在 logging 框架和單獨的日誌處理程式之間傳遞 logging 請求。 
Handler：將 LogRecord 物件匯出到各種目的地，包括記憶體、輸出流、控制檯、檔案和套接字。為此有各種的 Handler 子類。其他 Handler 可能由第三方開發並在核心平臺的頂層實現。 
Level：定義一組可以用來控制 logging 輸出的標準 logging 級別。可以配置程式為某些級別輸出 logging，而同時忽略其他輸出。 
Filter：為所記錄的日誌提供日誌級別控制以外的細粒度控制。Logging API 支援通用的過濾器機制，該機制允許應用程式程式碼附加任意的過濾器以控制 logging 輸出。 
Formatter：為格式化 LogRecord 物件提供支援。此包包括的兩個格式化程式 SimpleFormatter 和 XMLFormatter 分別用於格式化純文字或 XML 中的日誌記錄。與 Handler 一樣，其他 Formatter 可能由第三方開發。

整個JVM內部所有logger的管理，logger的生成、獲取等操作都依賴於LogManager，也包括配置檔案的讀取，LogManager與logger是1對多關係，整個JVM執行時只有一個LogManager，且所有的logger均在LogManager中。 
logger與handler是多對多關係，logger在進行日誌輸出的時候會呼叫所有的hanlder進行日誌的處理。 
handler與formatter是一對一關係，一個handler有一個formatter進行日誌的格式化處理。 
logger與level是一對一關係，hanlder與level也是一對一關係 。 
JDK預設的logging配置檔案為：$JAVA_HOME/jre/lib/logging.properties，可以使用系統屬性java.util.logging.config.file指定相應的配置檔案對預設的配置檔案進行覆蓋。

小結

從下圖中，我們可以看到4部分。

介面：將所有日誌實現適配到了一起，用統一的介面呼叫。 
實現：目前主流的日誌實現 
舊日誌到slf4j的介面卡：如果使用了slf4j，但是隻想用一種實現，想把log4j的日誌體系也從logback輸出，這個是很有用的。 
slf4j到實現的介面卡：如果想制定slf4j的具體實現，需要這些包。

slf4j跟commons-logging類似，是各種日誌實現的通用入口，log4j、log4j2、logback、slf4j-simple和java.util.logging是比較常見的日誌實現系統，目前應用比較廣泛的是Log4j和logback，而logback作為後起之秀，以替代log4j為目的，整體效能比log4j較佳，log4j的升級版log4j2也是有諸多亮點，使用者可以根據專案需求和個人習慣，選擇合適的日誌實現。

注：學習所用，大部分內容摘抄自網路各種大師總結，在此感謝！