一、日志框架

市面上的日志框架有JUL、JCL、Jboss-logging、logback、Log4j、log4j2、slf4j....

左邊選一個(gè)門面（抽象層）、右邊來選一個(gè)實(shí)現(xiàn)。其中jcl最后更新時(shí)間為2014年后面就沒再更新了，jboss-loggin使用場(chǎng)景很少。Log4j由于有性能問題，原作者寫了個(gè)新的框架Logback，考慮到以后可能會(huì)有更多的框架，于是作者寫了一個(gè)日志門面SLF4J。使用上日志門面使用 SLF4J，日志實(shí)現(xiàn)的話由于Log4j有了更好的替代者Logback，所以不考慮使用Log4j。JUL是Java為了搶占市場(chǎng)份額寫的一個(gè)日志框架，不考慮。log4j2是借log4j之名由Apache重新寫的日志框架，但是很多框架都還沒適配起來，不考慮。所以選擇使用Logback。
spring框架默認(rèn)使用JCL（抽象層，具體實(shí)現(xiàn)不同版本不一樣）。而SpringBoot由于底層是spring框架，springboot對(duì)日志進(jìn)行了一次包裝，選用SLF4j和logback

二、日志的使用

2.1 Log4j的使用

添加依賴：

<dependency>
  <groupId>log4j</groupId>
  <artifactId>log4j</artifactId>
  <version>1.2.17</version>
</dependency>

添加一個(gè)配置文件：

log4j.rootLogger=info,stdout
#輸出到控制臺(tái)
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %p [%t] %C.%M(%L) | %m%n

測(cè)試：

import org.apache.log4j.Logger;
public class Log4JTest {
    public static void main(String[] args) {
        Logger logger = Logger.getLogger("log4j");
        logger.info("log4j");
    }
}

2.2 JUL的使用

這是java自帶的日志框架，無需添加依賴即可直接使用：

import java.util.logging.Logger;
public class JULTest {
    public static void main(String[] args) {
        Logger logger = Logger.getLogger("jul");
        logger.info("jul");
    }
}

2.3 JCL的使用

jcl是一個(gè)抽象層的框架，不直接記錄日志，它是使用第三方實(shí)現(xiàn)（Log4j、JUL等等）記錄日志，框架中有誰(shuí)就用誰(shuí)，都有的時(shí)候會(huì)按照默認(rèn)順序選擇（下文會(huì)講到），添加JCL依賴：

<dependency>
  <groupId>commons-logging</groupId>
  <artifactId>commons-logging</artifactId>
  <version>1.2</version>
</dependency>

測(cè)試：

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
public class JCLTest {
    public static void main(String[] args) {
        Log log = LogFactory.getLog("jcl");
        log.info("jcl");
    }
}

可以看到此時(shí)JCL打印結(jié)果格式和JUL一樣。通過斷點(diǎn)我們看到log的類型，Jdk14Logger是JCL用來操作JUL的實(shí)現(xiàn)類：

如果加上Log4j的依賴，輸出格式變成了和Log4j一樣：

斷點(diǎn)看下log類型，其中Log4JLogger是JCL提供的用來操作Log4j日志的實(shí)現(xiàn)類：

JCL框架不直接記錄日志，提供了記錄日志的抽象方法即接口（info、debug、error等），底層通過一個(gè)數(shù)組存放具體的日志框架的類名，然后循環(huán)數(shù)組依次去匹配這些類名是否在app中被依賴了，如果找到被依賴的則直接使用,所以他有先后順序：

底層會(huì)循環(huán)該數(shù)組，通過class.forname的形式如果能找到某個(gè)類就會(huì)跳出循環(huán)去創(chuàng)建這個(gè)類。否則遍歷完這個(gè)數(shù)組?？梢岳斫鉃閖cl不提供日志實(shí)現(xiàn)，只是提供了一組記錄日志的抽象方法即接口，好處在于我們的上層調(diào)用代碼是JCL提供的，是固定的，不需要隨著日志的實(shí)現(xiàn)而修改這部分代碼，很好的解除了日志框架切換的耦合性，我們只需要選擇具體的日志版本實(shí)現(xiàn)：增加或刪除依賴即可實(shí)現(xiàn)日志框架切換。但是jcl已經(jīng)不更新，并且通過源碼我們知道這個(gè)框架對(duì)Logback、Log4j2是不支持的。我們有更好的替代者：slf4j

2.4 SLF4J的使用

項(xiàng)目里面導(dǎo)入門面slf4j的依賴：

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");
  }
}

此時(shí)運(yùn)行項(xiàng)目就會(huì)出現(xiàn)以下提示信息：

這并不是錯(cuò)誤信息，并不是日志框架出錯(cuò)，只是這樣不會(huì)有任何日志輸出，如果需要輸出日志我們需要綁定一個(gè)日志具體的實(shí)現(xiàn)框架，具體如下：

所有的應(yīng)用程序應(yīng)該面向SLF4J編程，導(dǎo)入具體的日志實(shí)現(xiàn)，最終SLF4J會(huì)調(diào)用具體的日志實(shí)現(xiàn)去記錄日志。
空實(shí)現(xiàn)：如上圖，如果項(xiàng)目中只導(dǎo)入了SLF4J那么不會(huì)有任何日志輸出。
使用logback：logback就是對(duì)slf4j的實(shí)現(xiàn)，只需要導(dǎo)入logback的jar（有兩個(gè)），底層調(diào)用logbackAPI去記錄日志。
log4j：由于log4j出現(xiàn)比較早，當(dāng)時(shí)還沒有SLF4J，因此log4j在設(shè)計(jì)的時(shí)候沒考慮到SLF4J，因此要使用就需要一個(gè)適配層（slf4j-log412：包含了log4j）：向上實(shí)現(xiàn)了SLF4J的具體方法，向下真正需要記錄日志的時(shí)候會(huì)去調(diào)用具體的日志實(shí)現(xiàn)的API
jul：同log4j
simple：slf4j默認(rèn)的簡(jiǎn)單的日志實(shí)現(xiàn)
no-operation：沒有什么操作的實(shí)現(xiàn)包
每一個(gè)日志的實(shí)現(xiàn)框架都有自己的配置文件。使用slf4j以后，配置文件還是做成日志實(shí)現(xiàn)框架自己本身的配置文件。
slf4j+logback的使用只需要在pom文件中添加logback的兩個(gè)依賴即可：

<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-api</artifactId>
  <version>1.7.26</version>
</dependency>
<dependency>
  <groupId>ch.qos.logback</groupId>
  <artifactId>logback-classic</artifactId>
  <version>1.2.3</version>
</dependency>
<dependency>
  <groupId>ch.qos.logback</groupId>
  <artifactId>logback-core</artifactId>
  <version>1.2.3</version>
</dependency>

項(xiàng)目開發(fā)中產(chǎn)生的日志遺留問題
比如有一個(gè)項(xiàng)目A開發(fā)的時(shí)候使用SLF4J+Logback，但是開發(fā)中需要使用的Spring(commons-logging)、Hibernate（jboss-logging）、MyBatis……不同的框架使用了不同的日志實(shí)現(xiàn)，如何實(shí)現(xiàn)統(tǒng)一日志記錄，即使是別的框架也使用slf4j進(jìn)行輸出？

如上圖所示，假設(shè)應(yīng)用程序使用的Slf4j+logback，引入的其它框架包含了Commons-logging、log4j、juc等日志實(shí)現(xiàn)，如果要實(shí)現(xiàn)日志統(tǒng)一，我們需要使用對(duì)應(yīng)的替換包（jcl-over-slf4j、log4j-over-slf4j、jul-to-slf4j）去取代原來的日志實(shí)現(xiàn)，這樣把原來的實(shí)現(xiàn)排除掉了，但是替換包的功能和原來的具體實(shí)現(xiàn)包一樣，原來的實(shí)現(xiàn)包中有什么類替換的包中也有，這樣可以保證在排除了框架中依賴的日志類的時(shí)候就不會(huì)報(bào)錯(cuò)，但是此時(shí)調(diào)用替換的類去記錄日志的時(shí)候，其實(shí)是這個(gè)類去調(diào)用slf4j，最后slf4j去調(diào)用我們應(yīng)用程序中的具體實(shí)現(xiàn)logback。說白了就是替換包模擬原來個(gè)框架依賴的日志的各個(gè)類，框架最終使用的就是這些模擬的類，模擬的類就可以去操作我們應(yīng)用程序的日志。
如果上面我們的應(yīng)用程序需要使用Slf4j+log4j/jcl，其它框架的轉(zhuǎn)換不變，但是應(yīng)用程序在使用的時(shí)候由于在slf4j和log4j之間需要加一個(gè)適配層。
總結(jié)：如何讓系統(tǒng)中所有的日志都統(tǒng)一到slf4j
1、將系統(tǒng)中其他日志框架先排除出去；
2、用中間包來替換原有的日志框架；
3、看情況導(dǎo)入slf4j其他的實(shí)現(xiàn)（logback）或適配層（比如slf4j-log412）

三、spring4與spring5日志的區(qū)別

1.spring4的日志

spring4默認(rèn)使用了jcl（commons-logging）作為抽象層，使用方式同上面介紹過的jcl使用方式一樣：

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>4.3.14.RELEASE</version>
</dependency>

spring4的日志結(jié)構(gòu)：

測(cè)試：

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
public class SpringLogTest {
    public static void main(String[] args) {
        Log log = LogFactory.getLog("spring");
        log.info("test spring");
    }
}

此時(shí)沒有添加其它日志實(shí)現(xiàn)框架，默認(rèn)使用的是jul框架去打印日志：

如果加上log4j依賴就會(huì)使用log4j去打印日志：

2.spring5的日志

spring5對(duì)commons-logging做了修改（spring-jcl），默認(rèn)使用jcl去綁定jul打印日志。如果要使用其他日志實(shí)現(xiàn)框架需要讓對(duì)應(yīng)的日志框架去綁定slf4j，即使用方式同slf4j一樣。

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.1.8.RELEASE</version>
</dependency>

spring5的日志結(jié)構(gòu)：

測(cè)試：

此時(shí)如果我們也加上log4j依賴:

可以看到此時(shí)不論我們的應(yīng)用中是否添加了其它日志實(shí)現(xiàn)框架，打印日志的log類型始終是LogAdapter$JavaUtilsLog。我們看一下spring5中這個(gè)獲取日志對(duì)象的源碼：

public static Log createLog(String name) {
    switch (logApi) {
        case LOG4J:
            return LogAdapter.Log4jAdapter.createLog(name);
        case SLF4J_LAL:
            return LogAdapter.Slf4jAdapter.createLocationAwareLog(name);
        case SLF4J:
            return LogAdapter.Slf4jAdapter.createLog(name);
        default:
            // Defensively use lazy-initializing adapter class here as well since the
            // java.logging module is not present by default on JDK 9. We are requiring
            // its presence if neither Log4j nor SLF4J is available; however, in the
            // case of Log4j or SLF4J, we are trying to prevent early initialization
            // of the JavaUtilLog adapter - e.g. by a JVM in debug mode - when eagerly
            // trying to parse the bytecode for all the cases of this switch clause.
            return LogAdapter.JavaUtilAdapter.createLog(name);
    }
}

其中l(wèi)ogApi的值在類加載的時(shí)候就會(huì)初始化：

private static final String LOG4J_SPI = "org.apache.logging.log4j.spi.ExtendedLogger";
private static final String LOG4J_SLF4J_PROVIDER = "org.apache.logging.slf4j.SLF4JProvider";
private static final String SLF4J_SPI = "org.slf4j.spi.LocationAwareLogger";
private static final String SLF4J_API = "org.slf4j.Logger";
private static final LogAdapter.LogApi logApi;
static {
    if (isPresent(LOG4J_SPI)) {
        if (isPresent(LOG4J_SLF4J_PROVIDER) && isPresent(SLF4J_SPI)) {
            // log4j-to-slf4j bridge -> we'll rather go with the SLF4J SPI;
            // however, we still prefer Log4j over the plain SLF4J API since
            // the latter does not have location awareness support.
            logApi = LogAdapter.LogApi.SLF4J_LAL;
        }
        else {
            // Use Log4j 2.x directly, including location awareness support
            logApi = LogAdapter.LogApi.LOG4J;
        }
    }
    else if (isPresent(SLF4J_SPI)) {
        // Full SLF4J SPI including location awareness support
        logApi = LogAdapter.LogApi.SLF4J_LAL;
    }
    else if (isPresent(SLF4J_API)) {
        // Minimal SLF4J API without location awareness support
        logApi = LogAdapter.LogApi.SLF4J;
    }
    else {
        // java.util.logging as default
        logApi = LogAdapter.LogApi.JUL;
    }
}

可以看到，靜態(tài)代碼塊中針對(duì)使用不同的日志框架做了一系列的判斷，定義的常量字符串代表的類都是各個(gè)日志實(shí)現(xiàn)框架中的類，會(huì)根據(jù)這個(gè)去查找是否引入了對(duì)應(yīng)的依賴。例如這里的“org.slf4j.spi.LocationAwareLogger”是slf4j中的類，我們?nèi)绻褂胠og4j框架和slf4j使用log4j一樣操作即可（在這個(gè)測(cè)試中我們不需要spring自帶的日志，可以剔除，但是需要注意，如果使用了AnnotationConfigApplicationContext剔除以后需要添加jcl的轉(zhuǎn)換包，否則會(huì)報(bào)錯(cuò)，使用在下面“4.2 MyBatis整合Spring時(shí)日志”介紹時(shí)pom.xml中會(huì)有說明）：

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.1.8.RELEASE</version>
  <exclusions>
    <exclusion>
      <artifactId>org.springframework</artifactId>
      <groupId>spring-jcl</groupId>
    </exclusion>
  </exclusions>
</dependency>
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-api</artifactId>
  <version>1.7.26</version>
</dependency>
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-log4j12</artifactId>
  <version>1.7.26</version>
</dependency>

此時(shí)“org.slf4j.spi.LocationAwareLogger”就會(huì)在項(xiàng)目中存在，在靜態(tài)代碼塊的判斷過程中l(wèi)ogApi的值就會(huì)變成“SLF4J_LAL”，創(chuàng)建log對(duì)象的時(shí)候就會(huì)創(chuàng)建log4j的：

此時(shí)控制臺(tái)輸出的日志就是通過log4j的框架去實(shí)現(xiàn)的：

spring5日志使用總結(jié)：
1、默認(rèn)使用jcl去依賴java自帶的jul
2、如果要使用其它日志框架實(shí)現(xiàn)需要通過對(duì)應(yīng)的日志實(shí)現(xiàn)去綁定slf4j（就是slf4j的使用方式）

四、MyBatis以及和Spring整合時(shí)的日志

4.1 MyBatis單獨(dú)使用時(shí)的日志操作

MyBatis自帶了日志抽象工廠，具體的實(shí)現(xiàn)由SLF4J、Apache Commons Logging、Log4j 2、Log4j、JDK logging完成。當(dāng)項(xiàng)目中存在多個(gè)實(shí)現(xiàn)時(shí)會(huì)根據(jù)上面的幾個(gè)框架從前到后這個(gè)順序依次查找，找到了就會(huì)優(yōu)先使用該日志實(shí)現(xiàn)?？匆幌翸yBatis中日志源碼即可知曉原因：

在org.apache.ibatis.logging.LogFactory的靜態(tài)代碼塊中，會(huì)根據(jù)上面說過的順序拿到指定的日志實(shí)現(xiàn)類的類字節(jié)碼創(chuàng)建對(duì)象，如果失敗則繼續(xù)嘗試，只要找到一個(gè)就不會(huì)再往下去創(chuàng)建。
在很多情況下項(xiàng)目中會(huì)自帶日志框架，比如Tomcat中自帶了Commons Logging，如果我們想要使用log4j作為日志框架，我們需要引入log4j的jar，并且還要指定使用的日志框架：
方式一：通過在 MyBatis 配置文件 mybatis-config.xml 里面添加一項(xiàng) setting 來選擇別的日志工具

<configuration>
  <settings>
    ...
    <setting name="logImpl" value="LOG4J"/>
    ...
  </settings>
</configuration>

其中l(wèi)ogImpl 可選的值有：SLF4J、LOG4J、LOG4J2、JDK_LOGGING、COMMONS_LOGGING、STDOUT_LOGGING、NO_LOGGING，或者是實(shí)現(xiàn)了接口 org.apache.ibatis.logging.Log 的，且構(gòu)造方法是以字符串為參數(shù)的類的完全限定名
方式二：調(diào)用如下任一方法來使用日志工具
org.apache.ibatis.logging.LogFactory.useSlf4jLogging();
org.apache.ibatis.logging.LogFactory.useLog4JLogging();
org.apache.ibatis.logging.LogFactory.useJdkLogging();
org.apache.ibatis.logging.LogFactory.useCommonsLogging();
org.apache.ibatis.logging.LogFactory.useStdOutLogging();
需要注意的是：要調(diào)用以上某個(gè)方法，必須在調(diào)用其它 MyBatis 方法之前調(diào)用它。另外，僅當(dāng)運(yùn)行時(shí)類路徑中存在該日志工具時(shí)，調(diào)用與該日志工具對(duì)應(yīng)的方法才會(huì)生效，否則 MyBatis 一概忽略。如你環(huán)境中并不存在 Log4J，你卻調(diào)用了相應(yīng)的方法，MyBatis 就會(huì)忽略這一調(diào)用，轉(zhuǎn)而以默認(rèn)的查找順序查找日志工具
使用示例之Log4J打印日志：
maven項(xiàng)目中添加以下依賴：

<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis</artifactId>
  <version>3.4.6</version>
</dependency>
<!--mysql jdbc驅(qū)動(dòng)-->
<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>5.1.46</version>
</dependency>
<dependency>
  <groupId>log4j</groupId>
  <artifactId>log4j</artifactId>
  <version>1.2.17</version>
</dependency>

創(chuàng)建Dao接口：

public interface UserMapper {
    List<Map<String, Object>> findAllUser();
    List<Map<String, Object>> findUserByCondition(String strId);
}

在resources目錄下創(chuàng)建同包名同類名的xml文件：

<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.mobei.dao.UserMapper">
    <select id="findAllUser" resultType="map">
        select * from user
    </select>
    <select id="findUserByCondition" resultType="map">
        select * from user where id = #{strId}
    </select>
</mapper>

核心配置文件mybatis-config.xml：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql:///test"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="com/mobei/dao/UserMapper.xml"/>
    </mappers>
</configuration>

log4j.properties：

log4j.rootLogger=debug,stdout
#這句控制輸出SQL語(yǔ)句
log4j.logger.com.mobei.dao=TRACE
#輸出到控制臺(tái)
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %p [%t] %C.%M(%L) | %m%n

測(cè)試類：

public static void main(String[] args) throws Exception {
    InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
    SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
    SqlSessionFactory sessionFactory = builder.build(is);
    SqlSession sqlSession = sessionFactory.openSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);

    List<Map<String, Object>> allUser = mapper.findAllUser();
    System.out.println(allUser);
    List<Map<String, Object>> conditionUser = mapper.findUserByCondition("1");
    System.out.println(conditionUser);
    
    sqlSession.close();
    is.close();
}

根據(jù)前面的分析我們知道，由于此時(shí)類路徑下包含了log4j日志和jdk自帶的jul日志，由于log4j優(yōu)先于jul所以肯定會(huì)使用log4j框架輸出日志：

public static void main(String[] args) throws Exception {
    InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
    SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();

    org.apache.ibatis.logging.LogFactory.useStdOutLogging();

    SqlSessionFactory sessionFactory = builder.build(is);
    SqlSession sqlSession = sessionFactory.openSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    List<Map<String, Object>> allUser = mapper.findAllUser();
    System.out.println(allUser);
    List<Map<String, Object>> conditionUser = mapper.findUserByCondition("1");
    System.out.println(conditionUser);
    sqlSession.close();
    is.close();
}

此時(shí)的日志：

使用JUL打印sql日志：
我們將pom.xml中的log4j日志去除掉，此時(shí)類路徑下就只有JDK自帶的JUL日志記錄包了，我們測(cè)試：

public static void main(String[] args) throws Exception {
    InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
    SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
    SqlSessionFactory sessionFactory = builder.build(is);
    SqlSession sqlSession = sessionFactory.openSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    List<Map<String, Object>> allUser = mapper.findAllUser();
    System.out.println(allUser);
    List<Map<String, Object>> conditionUser = mapper.findUserByCondition("1");
    System.out.println(conditionUser);
    sqlSession.close();
    is.close();
}

發(fā)現(xiàn)此時(shí)沒有任何sql相關(guān)的日志打印，經(jīng)過我們前面的分析，此時(shí)應(yīng)該默認(rèn)會(huì)使用了JUL去打印日志才對(duì)，為什么會(huì)沒有呢？這其實(shí)跟JUL默認(rèn)的日志級(jí)別有關(guān)，我們斷點(diǎn)調(diào)試即可知道JUL默認(rèn)的日志級(jí)別是FINE（500）：

這里的log對(duì)象類型是Jdk14LoggingImpl,我們找到該方法:

可以看到JUL底層默認(rèn)設(shè)置的日志級(jí)別為FINE（500），是小于INFO（800）的，所以不會(huì)輸出日志，如果我們想要修改這個(gè)日志級(jí)別，可以進(jìn)行擴(kuò)展：
自定義一個(gè)實(shí)現(xiàn)Log的類，在類中聲明JUL的logger字段（這個(gè)類在這里僅為了測(cè)試輸出log的，其它級(jí)別的日志如果需要還要繼續(xù)去完善）：

import org.apache.ibatis.logging.Log;
import java.util.logging.Logger;
public class MyLog implements Log {
    private Logger logger;
    public MyLog(String clazz) {
        logger = Logger.getLogger("my log");
    }
    @Override
    public boolean isDebugEnabled() {
        return true;
    }
    @Override
    public boolean isTraceEnabled() {
        return false;
    }
    @Override
    public void error(String s, Throwable e) {
    }
    @Override
    public void error(String s) {
    }
    @Override
    public void debug(String s) {
        logger.info(s);
    }
    @Override
    public void trace(String s) {
    }
    @Override
    public void warn(String s) {
    }
}

將該日志注冊(cè)到核心配置文件mybatis-config.xml中：

<settings>
    <setting name="logImpl" value="com.mobei.log.MyLog"/>
</settings>

此時(shí)測(cè)試即可看到sql日志打印：

log4j調(diào)整打印sql粒度：指定只打印某個(gè)方法對(duì)應(yīng)的sql
修改配置文件，只打印findAllUser方法的sql：log4j.logger.com.mobei.dao.UserMapper.findAllUser=TRACE，同樣可以指定某個(gè)類中所有方法和某個(gè)包下所有類中的所有方法，具體可以看官網(wǎng)

log4j.rootLogger=info,stdout
#輸出到控制臺(tái)
log4j.logger.com.mobei.dao.UserMapper.findAllUser=TRACE
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %p [%t] %C.%M(%L) | %m%n

輸出結(jié)果（記得切換成使用log4j日志），可以看到此時(shí)findUserByCondition方法的sql并沒有打?。?/p>

4.2 MyBatis整合Spring時(shí)日志

經(jīng)過前面那么多的分析， MyBatis整合Spring時(shí)日志的使用就變得異常簡(jiǎn)單了。以Spring5為例，Spring5默認(rèn)使用jcl+jul，這里我們指定為使用log4j打印日志（其他使用方式和Spring5中日志的使用一樣，都是相通的）：
pom.xml：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.1.8.RELEASE</version>
    <!--日志統(tǒng)一使用log4j,需要排除掉spring自帶的jcl-->
    <exclusions>
        <exclusion>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jcl</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<!--添加slf4j門面-->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.26</version>
</dependency>
<!--由于剔除了spring5自帶的jcl框架，需要使用轉(zhuǎn)換包去替換,否則spring類中依賴的其它類就會(huì)報(bào)錯(cuò)-->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>jcl-over-slf4j</artifactId>
    <version>1.7.26</version>
</dependency>
<!--綁定到log4j-->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.7.26</version>
</dependency>
<!--spring自帶的jdbc提供了連接池-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.1.8.RELEASE</version>
</dependency>
<!--mybatis核心-->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.4.6</version>
</dependency>
<!--mysql jdbc驅(qū)動(dòng)-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.46</version>
</dependency>
<!--mybatis整合spring-->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>2.0.1</version>
</dependency>

dao接口：

public interface UserMapper {
    @Select("select * from user")
    List<Map<String, Object>> findAllUser();
}

service:

@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;
    public List<Map<String, Object>> findAllUser(){
        return userMapper.findAllUser();
    }
}

log4j.proprerties：

log4j.rootLogger=info,stdout
#這句控制輸出SQL
log4j.logger.com.mobei.dao=TRACE
#輸出到控制臺(tái)
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %p [%t] %C.%M(%L) | %m%n

配置類：

@Configuration
@ComponentScan("com.mobei")
@MapperScan("com.mobei.dao")
public class AppConfig {
    @Bean
    public DataSource dataSource(){
        DriverManagerDataSource ds = new DriverManagerDataSource();
        ds.setUsername("root");
        ds.setPassword("123456");
        ds.setUrl("jdbc:mysql:///test");
        ds.setDriverClassName("com.mysql.jdbc.Driver");
        return ds;
    }
    @Bean
    public SqlSessionFactoryBean sqlSessionFactory() throws Exception {
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(dataSource());
        return factoryBean;
    }
}

測(cè)試：

public static void main(String[] args) {
    AnnotationConfigApplicationContext ac =
        new AnnotationConfigApplicationContext(AppConfig.class);
    UserService service = ac.getBean(UserService.class);
    List<Map<String, Object>> allUser = service.findAllUser();
    System.out.println(allUser);
}

驗(yàn)證log4j生效：

log4j.appender.stdout.target=System.err

PS： 默認(rèn)情況下的JUL日志級(jí)別配置
Spring5默認(rèn)使用JCL+JUL，如果不添加任何其它日志實(shí)現(xiàn)框架，就是使用JUL輸出日志，前面我們介紹的自定義JUL日志對(duì)象以修改日志級(jí)別，我們是將自定義的類配置在配置文件的setting標(biāo)簽中，對(duì)于這種配置類我們可以使用如下方式配置：

@Bean
public SqlSessionFactoryBean sqlSessionFactory() throws Exception {
    SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();

    org.apache.ibatis.session.Configuration cfg = 
        new org.apache.ibatis.session.Configuration();
    cfg.setLogImpl(MyLog.class);
    factoryBean.setConfiguration(cfg);

    factoryBean.setDataSource(dataSource());
    return factoryBean;
}

五、springboot中的日志

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    <version>2.1.6.RELEASE</version>
</dependency>

spring-boot-starter使用的日志：

    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-logging</artifactId>
      <version>2.1.6.RELEASE</version>
      <scope>compile</scope>
    </dependency>

總結(jié)：
1）、SpringBoot底層也是使用slf4j+logback的方式進(jìn)行日志記錄
2）、SpringBoot也把其他的日志都替換成了slf4j；
如果我們要引入其它框架，如果框架使用的日志不是logback或者版本不一致，一定要把這個(gè)框架的默認(rèn)日志依賴移除掉，否則可能會(huì)出現(xiàn)jar包沖突。SpringBoot能自動(dòng)適配所有的日志，而且底層使用slf4j+logback的方式記錄日志，引入其它框架的時(shí)候把這個(gè)框架依賴的日志框架排除掉。
SpringBoot默認(rèn)幫我們配置好了日志，啟動(dòng)應(yīng)用就可以看到控制臺(tái)的日志輸出。我們可以根據(jù)自己的需要來使用日志。

5.1 日志級(jí)別（這里應(yīng)該放到前面介紹的，懶得改了，湊合著看吧）

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@RunWith(SpringRunner.class)
@SpringBootTest
public class SbLog1ApplicationTests {
    Logger logger = LoggerFactory.getLogger(getClass());
    @Test
    public void contextLoads() {
        //日志的級(jí)別:
        //低->高 trace<debug<info<warn<error
        //可以調(diào)整輸出的日志級(jí)別:日志只會(huì)在這個(gè)級(jí)別及以后的高級(jí)別生效
        logger.trace("這是trace日志……");
        logger.debug("這是debug日志……");
        //SpringBoot默認(rèn)給我們使用的是info級(jí)別的
        logger.info("這是info日志……");
        logger.warn("這是warn日志……");
        logger.error("這是error日志……");
    }
}

由于SpringBoot默認(rèn)使用info級(jí)別（root級(jí)別），所以只會(huì)有高于info級(jí)別的日志輸出：

我們可以在properties文件中設(shè)置指定目錄下(或者類)的日志輸出級(jí)別，比如指定com.mobei.sb_log_1目錄下日志輸出級(jí)別為trace：

logging.level.com.mobei.sb_log_1=trace

5.2 SpringBoot修改日志的默認(rèn)配置

logging.file：
不指定路徑在當(dāng)前項(xiàng)目下生成xxx.log日志

logging.file=springboot.log

也可以指定完整的路徑：

logging.file=G:/springboot.log

# 在當(dāng)前磁盤的根路徑(當(dāng)前項(xiàng)目所在目錄的根目錄,例如這里項(xiàng)目在G盤下,根目錄就是G:\)
# 下創(chuàng)建spring文件夾和里面的log文件夾:使用 spring.log 作為默認(rèn)文件
logging.path=/spring/log

5.3 日志的格式

默認(rèn)格式：

%d表示日期時(shí)間，        
%thread表示線程名，        
%‐5level：級(jí)別從左顯示5個(gè)字符寬度        
%logger{50} 表示logger名字最長(zhǎng)50個(gè)字符，否則按照句點(diǎn)分割。         
%msg：日志消息，        
%n是換行符        

logging.pattern.console：在控制臺(tái)輸出的日志的格式
修改成我們自己指定格式的：

logging.pattern.console=%d{yyyy‐MM‐dd} [%thread] %‐5level %logger{50} ‐ %msg%n

logging.pattern.file：指定文件中日志輸出的格式

logging.pattern.file=%d{yyyy‐MM‐dd} === [%thread] === %-5level === %logger{50} ==== %msg%n

5.4 SpringBoot中日志的默認(rèn)值所在位置

5.5 指定配置（參考官網(wǎng)說明）

給類路徑下放上每個(gè)日志框架自己的配置文件即可，SpringBoot就不使用他默認(rèn)配置的了：

官網(wǎng)說明：使用標(biāo)準(zhǔn)的文件名logback.xml在應(yīng)用啟動(dòng)的時(shí)候被日志框架識(shí)別，繞過了SpringBoot，不能擴(kuò)展高級(jí)功能，如果需要擴(kuò)展，需要使用擴(kuò)展名比如logback-spring.xml，這樣日志框架無法識(shí)別，不會(huì)去加載，而是由SpringBoot去解析配置，可以使用到SpringBoot的高級(jí)Profile功能

比如我們指定某端配置只在某個(gè)環(huán)境下生效：

<layout class="ch.qos.logback.classic.PatternLayout">
    <springProfile name="dev">
        <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} ----> [%thread] ---> %-5level %logger{50} - %msg%n</pattern>
    </springProfile>
    <springProfile name="!dev">
        <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} ==== [%thread] ==== %-5level %logger{50} - %msg%n</pattern>
    </springProfile>
</layout>

非生產(chǎn)環(huán)境：

生產(chǎn)環(huán)境：
激活生產(chǎn)環(huán)境可以在配置文件中設(shè)置：

spring.profiles.active=dev

或者在啟動(dòng)的時(shí)候帶上命令參數(shù)：

運(yùn)行結(jié)果：

如果不使用擴(kuò)展名，直接使用logback.xml就會(huì)報(bào)錯(cuò)：

附上logback-spring.xml完整內(nèi)容：

<?xml version="1.0" encoding="UTF-8"?>
<!--
scan：當(dāng)此屬性設(shè)置為true時(shí)，配置文件如果發(fā)生改變，將會(huì)被重新加載，默認(rèn)值為true。
scanPeriod：設(shè)置監(jiān)測(cè)配置文件是否有修改的時(shí)間間隔，如果沒有給出時(shí)間單位，默認(rèn)單位是毫秒當(dāng)scan為true時(shí)，此屬性生效。默認(rèn)的時(shí)間間隔為1分鐘。
debug：當(dāng)此屬性設(shè)置為true時(shí)，將打印出logback內(nèi)部日志信息，實(shí)時(shí)查看logback運(yùn)行狀態(tài)。默認(rèn)值為false。
-->
<configuration scan="false" scanPeriod="60 seconds" debug="false">
    <!-- 定義日志的根目錄 -->
    <property name="LOG_HOME" value="/app/log" />
    <!-- 定義日志文件名稱 -->
    <property name="appName" value="mobei-springboot"></property>
    <!-- ch.qos.logback.core.ConsoleAppender 表示控制臺(tái)輸出 -->
    <appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
        <!--
        日志輸出格式：
            %d表示日期時(shí)間，
            %thread表示線程名，
            %-5level：級(jí)別從左顯示5個(gè)字符寬度
            %logger{50} 表示logger名字最長(zhǎng)50個(gè)字符，否則按照句點(diǎn)分割。 
            %msg：日志消息，
            %n是換行符
        -->
        <layout class="ch.qos.logback.classic.PatternLayout">
            <springProfile name="dev">
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} ----> [%thread] ---> %-5level %logger{50} - %msg%n</pattern>
            </springProfile>
            <springProfile name="!dev">
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} ==== [%thread] ==== %-5level %logger{50} - %msg%n</pattern>
            </springProfile>
        </layout>
    </appender>

    <!-- 滾動(dòng)記錄文件，先將日志記錄到指定文件，當(dāng)符合某個(gè)條件時(shí)，將日志記錄到其他文件 -->  
    <appender name="appLogAppender" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 指定日志文件的名稱 -->
        <file>${LOG_HOME}/${appName}.log</file>
        <!--
        當(dāng)發(fā)生滾動(dòng)時(shí)，決定 RollingFileAppender 的行為，涉及文件移動(dòng)和重命名
        TimeBasedRollingPolicy： 最常用的滾動(dòng)策略，它根據(jù)時(shí)間來制定滾動(dòng)策略，既負(fù)責(zé)滾動(dòng)也負(fù)責(zé)出發(fā)滾動(dòng)。
        -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!--
            滾動(dòng)時(shí)產(chǎn)生的文件的存放位置及文件名稱 %d{yyyy-MM-dd}：按天進(jìn)行日志滾動(dòng) 
            %i：當(dāng)文件大小超過maxFileSize時(shí)，按照i進(jìn)行文件滾動(dòng)
            -->
            <fileNamePattern>${LOG_HOME}/${appName}-%d{yyyy-MM-dd}-%i.log</fileNamePattern>
            <!-- 
            可選節(jié)點(diǎn)，控制保留的歸檔文件的最大數(shù)量，超出數(shù)量就刪除舊文件。假設(shè)設(shè)置每天滾動(dòng)，
            且maxHistory是365，則只保存最近365天的文件，刪除之前的舊文件。注意，刪除舊文件是，
            那些為了歸檔而創(chuàng)建的目錄也會(huì)被刪除。
            -->
            <MaxHistory>365</MaxHistory>
            <!-- 
            當(dāng)日志文件超過maxFileSize指定的大小是，根據(jù)上面提到的%i進(jìn)行日志文件滾動(dòng) 注意此處配置SizeBasedTriggeringPolicy是無法實(shí)現(xiàn)按文件大小進(jìn)行滾動(dòng)的，必須配置timeBasedFileNamingAndTriggeringPolicy
            -->
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
        </rollingPolicy>
        <!-- 日志輸出格式： -->     
        <layout class="ch.qos.logback.classic.PatternLayout">
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [ %thread ] - [ %-5level ] [ %logger{50} : %line ] - %msg%n</pattern>
        </layout>
    </appender>

    <!-- 
        logger主要用于存放日志對(duì)象，也可以定義日志類型、級(jí)別
        name：表示匹配的logger類型前綴，也就是包的前半部分
        level：要記錄的日志級(jí)別，包括 TRACE < DEBUG < INFO < WARN < ERROR
        additivity：作用在于children-logger是否使用 rootLogger配置的appender進(jìn)行輸出，
        false：表示只用當(dāng)前l(fā)ogger的appender-ref，true：
        表示當(dāng)前l(fā)ogger的appender-ref和rootLogger的appender-ref都有效
    -->
    <!-- hibernate logger -->
    <logger name="com.mobei" level="debug" />
    <!-- Spring framework logger -->
    <logger name="org.springframework" level="debug" additivity="false"></logger>

    <!-- 
    root與logger是父子關(guān)系，沒有特別定義則默認(rèn)為root，任何一個(gè)類只會(huì)和一個(gè)logger對(duì)應(yīng)，
    要么是定義的logger，要么是root，判斷的關(guān)鍵在于找到這個(gè)logger，然后判斷這個(gè)logger的appender和level。 
    -->
    <root level="info">
        <appender-ref ref="stdout" />
        <appender-ref ref="appLogAppender" />
    </root>
</configuration> 

5.6 切換日志框架

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