場景復(fù)現(xiàn)

你知道MyBatis是怎么實(shí)現(xiàn)日志的?額,這個簡單,我知道啊!不就是在mybatis-config.xml文件中配置一下嗎?

<!DOCTYPE configuration
    PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <settings>
        <setting name="logImpl" value="SLF4J"/>
    </settings>
</configuration>

看,就是上面這么配置就行了,這樣還可以實(shí)現(xiàn)日志切換呢!
看官方文檔介紹,有如下日志實(shí)現(xiàn)可以切換:

mybatis支持的日志實(shí)現(xiàn)

你知道具體的原理嗎?MyBatis是怎樣實(shí)現(xiàn)日志切換的呢?
額,這個,這個...(撓頭,源碼還沒看過呢,??)

源碼擼起來~

對于這個不確定的事,作為程序員的我,怎能輕易說不知道呢?!源碼走起來~

找到一個入口

首先,先從GitHub上將MyBatis的源碼給clone到本地.老大們擼了那么多行代碼,從哪開始下手呢???
大佬們,也是很規(guī)范的,寫完代碼有不少的Junit測試類,從test/java中找到了logging包.那就從這開始吧~

logging測試類

@Test
public void shouldReadLogImplFromSettings() throws Exception {
//try-with-resources語句,目的就是為了讀取配置文件IO
//mybatis-config.xml配置文件內(nèi)容如上,<setting name="logImpl" value="SLF4J"/>
try (Reader reader = Resources.getResourceAsReader("org/apache/ibatis/logging/mybatis-config.xml")) {
  //解析配置文件,解析配置文件的代碼就在這了~
  new SqlSessionFactoryBuilder().build(reader);
}

Log log = LogFactory.getLog(Object.class);
log.debug("Debug message.");
assertEquals(log.getClass().getName(), NoLoggingImpl.class.getName());
}

SqlSessionFactoryBuilder類

//根據(jù)配置文件IO構(gòu)建SqlSessionFactory
public SqlSessionFactory build(Reader reader) {
    return build(reader, null, null);
}


public SqlSessionFactory build(Reader reader, String environment, Properties properties) {
    try {
        //構(gòu)建XML配置構(gòu)建器
        XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);
        //解析XML配置文件
        return build(parser.parse());
    } catch (Exception e) {
        throw ExceptionFactory.wrapException("Error building SqlSession.", e);
    } finally {
        ErrorContext.instance().reset();
        try {
            reader.close();
        } catch (IOException e) {
            // Intentionally ignore. Prefer previous error.
        }
    }
}

XMLConfigBuilder XML配置構(gòu)建器

構(gòu)造函數(shù)

//reader是XML配置文件IO
public XMLConfigBuilder(Reader reader, String environment, Properties props) {
    this(new XPathParser(reader, true, props, new XMLMapperEntityResolver()), environment, props);
}

//實(shí)際調(diào)用的XML配置文件構(gòu)建器構(gòu)建函數(shù)
private XMLConfigBuilder(XPathParser parser, String environment, Properties props) {
    //注意了,這是重點(diǎn),在這地方調(diào)用了父類的構(gòu)造函數(shù),新建了一個Configuration對象,下面看看Configuration構(gòu)造函數(shù)做了什么
    super(new Configuration());
    ErrorContext.instance().resource("SQL Mapper Configuration");
    this.configuration.setVariables(props);
    this.parsed = false;
    this.environment = environment;
    this.parser = parser;
}

parse解析方法

/**
 * 解析 mybatis-config.xml
 * @return
 */
public Configuration parse() {
    // 只能解析一次
    if (parsed) {
        throw new BuilderException("Each XMLConfigBuilder can only be used once.");
    }
    parsed = true;
    //根據(jù)XPATH獲取configuration節(jié)點(diǎn)
    parseConfiguration(parser.evalNode("/configuration"));
    return configuration;
}

parseConfiguration 解析配置方法

private void parseConfiguration(XNode root) {
    try {
        //issue #117 read properties first
        // 解析 properties 節(jié)點(diǎn)
        propertiesElement(root.evalNode("properties"));
        // 解析 settings 節(jié)點(diǎn)
        Properties settings = settingsAsProperties(root.evalNode("settings"));
        loadCustomVfs(settings);
        // 解析 typeAliases 節(jié)點(diǎn)
        typeAliasesElement(root.evalNode("typeAliases"));
        // 解析 plugins 節(jié)點(diǎn)
        pluginElement(root.evalNode("plugins"));
        // 解析 objectFactory 節(jié)點(diǎn)
        objectFactoryElement(root.evalNode("objectFactory"));
        // 解析 objectWrapperFactory 節(jié)點(diǎn)
        objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
        // 解析 reflectorFactory 節(jié)點(diǎn)
        reflectorFactoryElement(root.evalNode("reflectorFactory"));
        settingsElement(settings);
        // 解析 environments 節(jié)點(diǎn)蚀同， 需要在 objectFactory 和 objectWrapperFactory才能讀取
        environmentsElement(root.evalNode("environments"));
        // 解析 databaseIdProvider 節(jié)點(diǎn)
        databaseIdProviderElement(root.evalNode("databaseIdProvider"));
        // 解析 typeHandlers 節(jié)點(diǎn)
        typeHandlerElement(root.evalNode("typeHandlers"));
        // 解析 mappers 節(jié)點(diǎn)
        mapperElement(root.evalNode("mappers"));
    } catch (Exception e) {
        throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
    }
}

其中Properties settings = settingsAsProperties(root.evalNode("settings"));是解析setttings節(jié)點(diǎn),將settings節(jié)點(diǎn)的內(nèi)容解析到 Properties 對象,其中涉及到很多操作,不在本文分析之列.
settingsElement(settings);將settings中的配置設(shè)置到Configuration對象.

settingsElement settings節(jié)點(diǎn)的配置

private void settingsElement(Properties props) throws Exception {
    ...
    configuration.setLogPrefix(props.getProperty("logPrefix"));
    @SuppressWarnings("unchecked")
    // 這個不就是從settings中解析日志的實(shí)現(xiàn)嗎?快看看~
    // resovleClass是父類BaseBuilder中的方法
    Class<? extends Log> logImpl = (Class<? extends Log>) resolveClass(props.getProperty("logImpl"));
    //將日志的實(shí)現(xiàn)類設(shè)置到configuration配置類中
    configuration.setLogImpl(logImpl);
    configuration.setConfigurationFactory(resolveClass(props.getProperty("configurationFactory")));
}

Configuration 配置類

public class Configuration {
    ...
    protected final TypeAliasRegistry typeAliasRegistry = new TypeAliasRegistry();
    ...
    public Configuration() {
        ...
    
        //日志類型別名
        typeAliasRegistry.registerAlias("SLF4J", Slf4jImpl.class);
        typeAliasRegistry.registerAlias("COMMONS_LOGGING", JakartaCommonsLoggingImpl.class);
        typeAliasRegistry.registerAlias("LOG4J", Log4jImpl.class);
        typeAliasRegistry.registerAlias("LOG4J2", Log4j2Impl.class);
        typeAliasRegistry.registerAlias("JDK_LOGGING", Jdk14LoggingImpl.class);
        typeAliasRegistry.registerAlias("STDOUT_LOGGING", StdOutImpl.class);
        typeAliasRegistry.registerAlias("NO_LOGGING", NoLoggingImpl.class);
    
        typeAliasRegistry.registerAlias("CGLIB", CglibProxyFactory.class);
        typeAliasRegistry.registerAlias("JAVASSIST", JavassistProxyFactory.class);
    
        languageRegistry.setDefaultDriverClass(XMLLanguageDriver.class);
        languageRegistry.register(RawLanguageDriver.class);
    }
}

從上面的Configuration構(gòu)造函數(shù)中可以看到,類型別名中定義了日志實(shí)現(xiàn)的名稱與,實(shí)現(xiàn)類.class(這些實(shí)現(xiàn)類都是MyBatis實(shí)現(xiàn)的,稍后再說)

//設(shè)置日志實(shí)現(xiàn)類
public void setLogImpl(Class<? extends Log> logImpl) {
    if (logImpl != null) {
        this.logImpl = logImpl;
        //調(diào)用日志工廠,設(shè)置日志實(shí)現(xiàn)
        LogFactory.useCustomLogging(this.logImpl);
    }
}

BaseBuilder

構(gòu)造函數(shù)

public BaseBuilder(Configuration configuration) {
    this.configuration = configuration;
    //可以看到這個地方的類型別名是從configuration中獲取的
    this.typeAliasRegistry = this.configuration.getTypeAliasRegistry();
    this.typeHandlerRegistry = this.configuration.getTypeHandlerRegistry();
}

protected <T> Class<? extends T> resolveClass(String alias) {
    if (alias == null) {
      return null;
    }
    try {
      //解析別名
      return resolveAlias(alias);
    } catch (Exception e) {
      throw new BuilderException("Error resolving class. Cause: " + e, e);
    }
}

//這個不就是從別名中獲取對應(yīng)的實(shí)現(xiàn)嗎??!
//配置SLF4J,返回Slf4jImpl.class
protected <T> Class<? extends T> resolveAlias(String alias) {
    //這個地方的typeAliasRegistry是從configuration中獲取的
    return typeAliasRegistry.resolveAlias(alias);
}

TypeAliasRegistry 類型別名

類型別名注冊

//就是將key轉(zhuǎn)換位小寫,存入HashMap中,key是別名,value是Class類對象
public void registerAlias(String alias, Class<?> value) {
    if (alias == null) {
        throw new TypeException("The parameter alias cannot be null");
    }
    // issue #748
    String key = alias.toLowerCase(Locale.ENGLISH);
    if (TYPE_ALIASES.containsKey(key) && TYPE_ALIASES.get(key) != null && !TYPE_ALIASES.get(key).equals(value)) {
        throw new TypeException("The alias '" + alias + "' is already mapped to the value '" + TYPE_ALIASES.get(key).getName() + "'.");
    }
    TYPE_ALIASES.put(key, value);
}

//根據(jù)對應(yīng)的別名key,獲取實(shí)現(xiàn)類class
public <T> Class<T> resolveAlias(String string) {
    try {
        if (string == null) {
            return null;
        }
        // issue #748
        String key = string.toLowerCase(Locale.ENGLISH);
        Class<T> value;
        if (TYPE_ALIASES.containsKey(key)) {
            value = (Class<T>) TYPE_ALIASES.get(key);
        } else {
            value = (Class<T>) Resources.classForName(string);
        }
        return value;
    } catch (ClassNotFoundException e) {
        throw new TypeException("Could not resolve type alias '" + string + "'.  Cause: " + e, e);
    }
}

Slf4jImpl Slf4j實(shí)現(xiàn)類

public class Slf4jImpl implements Log {

  private Log log;

  public Slf4jImpl(String clazz) {
    //使用Slf4j的API獲取日志器
    Logger logger = LoggerFactory.getLogger(clazz);

    if (logger instanceof LocationAwareLogger) {
      try {
        // check for slf4j >= 1.6 method signature
        logger.getClass().getMethod("log", Marker.class, String.class, int.class, String.class, Object[].class, Throwable.class);
        log = new Slf4jLocationAwareLoggerImpl((LocationAwareLogger) logger);
        return;
      } catch (SecurityException e) {
        // fail-back to Slf4jLoggerImpl
      } catch (NoSuchMethodException e) {
        // fail-back to Slf4jLoggerImpl
      }
    }

    // Logger is not LocationAwareLogger or slf4j version < 1.6
    log = new Slf4jLoggerImpl(logger);
  }

  ...
}

可見,最終還是調(diào)用具體的日志API實(shí)現(xiàn)!

LogFactory 日志工廠

package org.apache.ibatis.logging;

import java.lang.reflect.Constructor;

/**
 * 日志工廠
 */
public final class LogFactory {

  /**
   * Marker to be used by logging implementations that support markers
   */
  public static final String MARKER = "MYBATIS";

  // 記錄當(dāng)前使用的第三方日志庫組件所對應(yīng)的適配器的方法
  private static Constructor<? extends Log> logConstructor;

  // tryImplementation 進(jìn)行嘗試加載
  static {
    tryImplementation(LogFactory::useSlf4jLogging);
    tryImplementation(LogFactory::useCommonsLogging);
    tryImplementation(LogFactory::useLog4J2Logging);
    tryImplementation(LogFactory::useLog4JLogging);
    tryImplementation(LogFactory::useJdkLogging);
    tryImplementation(LogFactory::useNoLogging);
  }

  // 私有化
  private LogFactory() {
    // disable construction
  }

  public static Log getLog(Class<?> aClass) {
    return getLog(aClass.getName());
  }

  public static Log getLog(String logger) {
    try {
      return logConstructor.newInstance(logger);
    } catch (Throwable t) {
      throw new LogException("Error creating logger for logger " + logger + ".  Cause: " + t, t);
    }
  }

  /**
   * 以下的 useXXXogging 的方法都是嘗試加載日志的實(shí)現(xiàn)
   * 最終的實(shí)現(xiàn)都是 setImplementation
   */


  public static synchronized void useCustomLogging(Class<? extends Log> clazz) {
    setImplementation(clazz);
  }

  public static synchronized void useSlf4jLogging() {
    setImplementation(org.apache.ibatis.logging.slf4j.Slf4jImpl.class);
  }

  public static synchronized void useCommonsLogging() {
    setImplementation(org.apache.ibatis.logging.commons.JakartaCommonsLoggingImpl.class);
  }

  public static synchronized void useLog4JLogging() {
    setImplementation(org.apache.ibatis.logging.log4j.Log4jImpl.class);
  }

  public static synchronized void useLog4J2Logging() {
    setImplementation(org.apache.ibatis.logging.log4j2.Log4j2Impl.class);
  }

  public static synchronized void useJdkLogging() {
    setImplementation(org.apache.ibatis.logging.jdk14.Jdk14LoggingImpl.class);
  }

  public static synchronized void useStdOutLogging() {
    setImplementation(org.apache.ibatis.logging.stdout.StdOutImpl.class);
  }

  public static synchronized void useNoLogging() {
    setImplementation(org.apache.ibatis.logging.nologging.NoLoggingImpl.class);
  }

  /**
   * 嘗試加載
   * @param runnable
   */
  private static void tryImplementation(Runnable runnable) {
    if (logConstructor == null) {
      try {
        // 會調(diào)用 useSlf4jLogging 類似的方法
        runnable.run();
      } catch (Throwable t) {
        // ignore
      }
    }
  }

  /**
   * 設(shè)計日志的實(shí)現(xiàn)類
   * @param implClass Log 的子類
   */
  private static void setImplementation(Class<? extends Log> implClass) {
    try {
      // 通過反射獲取構(gòu)造方法
      Constructor<? extends Log> candidate = implClass.getConstructor(String.class);
      Log log = candidate.newInstance(LogFactory.class.getName());
      if (log.isDebugEnabled()) {
        log.debug("Logging initialized using '" + implClass + "' adapter.");
      }
      //設(shè)置日志實(shí)現(xiàn)的有參構(gòu)造函數(shù)
      logConstructor = candidate;
    } catch (Throwable t) {
      throw new LogException("Error setting Log implementation.  Cause: " + t, t);
    }
  }

}

可以看到其中有靜態(tài)代碼塊,隨著類的加載,嘗試加載日志的實(shí)現(xiàn)!

總結(jié)

通過以上的一步一步分析,可以看到MyBatis是分別通過對日志實(shí)現(xiàn)進(jìn)行包裝,最終還是調(diào)用具體的日志API實(shí)現(xiàn).