Mybatis内部提供了日志模块，用于记录框架内部异常与调试信息；日志实现使用了经典的适配器模式，mybatis自己本身不提供日志功能，而是依赖其他的日志框架来实现；内部支持的优先级是：

SLF4J | LOG4J | LOG4J2 | JDK_LOGGING | COMMONS_LOGGING | STDOUT_LOGGING | NO_LOGGING

由于各个厂商提供的日志api，日志级别等都不尽相同，所以mybatis对所有支持的日志框架做了封装，自定义了日志打印级别：

error (错误) > warn (警告) > debug(调试信息)>trace

mybatis 里定了了统一的日志接口，Log接口并定义了一系列的接口（目标接口）

  1. /**
  2.  * @author Clinton Begin
  3.  */
  4. public interface Log {
  6.   boolean isDebugEnabled();
  8.   boolean isTraceEnabled();
  10.   void error(String s, Throwable e);
  12.   void error(String s);
  14.   void debug(String s);
  16.   void trace(String s);
  18.   void warn(String s);
  20. }

提供的实现类(适配器):
image.png
日志集成核心类 org.apache.ibatis.logging.LogFactory

  1. public final class LogFactory {
  3.   /**
  4.    * Marker to be used by logging implementations that support markers.
  5.    */
  6.   public static final String MARKER = "MYBATIS";
  8.   private static Constructor<? extends Log> logConstructor;
  10.   static {
  11.     // 在LogFactory的静态方法里按照特定的顺序，寻找并加载对于的第三方日志组件，
  12.     tryImplementation(LogFactory::useSlf4jLogging);
  13.     tryImplementation(LogFactory::useCommonsLogging);
  14.     tryImplementation(LogFactory::useLog4J2Logging);
  15.     tryImplementation(LogFactory::useLog4JLogging);
  16.     tryImplementation(LogFactory::useJdkLogging);
  17.     tryImplementation(LogFactory::useNoLogging);
  18.   }
  20.   private LogFactory() {
  21.     // disable construction
  22.   }
  24.   /*
  25.   * 获取Log类对象。这个是为了实例化一个Log对象
  26.   */
  27.   public static Log getLog(Class<?> aClass) {
  28.     return getLog(aClass.getName());
  29.   }
  31.   public static Log getLog(String logger) {
  32.     try {
  33.       return logConstructor.newInstance(logger);
  34.     } catch (Throwable t) {
  35.       throw new LogException("Error creating logger for logger " + logger + ".  Cause: " + t, t);
  36.     }
  37.   }
  39.  /*
  40.   * tryImplementation 方法里会先判断是否已经加载了日志组件，如果已经加载了则不会继续处理；
  41.   * 并且这个方法做了异常的吞没，如果没有对于的日志组件也不会影响下一个组件的加载流程；
  42.   */
  43.   private static void tryImplementation(Runnable runnable) {
  44.     if (logConstructor == null) {
  45.       try {
  46.         runnable.run();
  47.       } catch (Throwable t) {
  48.         // ignore
  49.       }
  50.     }
  51.   }
  53.   public static synchronized void useSlf4jLogging() {
  54.     setImplementation(org.apache.ibatis.logging.slf4j.Slf4jImpl.class);
  55.   }
  57.   /* 
  58.   * 这个方法主要功能是去加载提供的实现类，这些实现类里引用了第三方的类，
  59.   * 如果项目中没有提供对于的jar包则该方法会抛错，然后异常会传递到 tryImplementation方法；
  60.   * 如果实例化特制类成功，则会将对于的类构造器赋值给 logConstructor，以便后续实例化 
  61.   */
  62.   private static void setImplementation(Class<? extends Log> implClass) {
  63.     try {
  64.       // 创建日志对象
  65.       Constructor<? extends Log> candidate = implClass.getConstructor(String.class);
  66.       Log log = candidate.newInstance(LogFactory.class.getName());
  67.       if (log.isDebugEnabled()) {
  68.         log.debug("Logging initialized using '" + implClass + "' adapter.");
  69.       }
  70.       // 报存构造器
  71.       logConstructor = candidate;
  72.     } catch (Throwable t) {
  73.       throw new LogException("Error setting Log implementation.  Cause: " + t, t);
  74.     }
  75.   }
  77. }

下面以 org.apache.ibatis.logging.log4j.Log4jImpl 为例做分析

  1. public class Log4jImpl implements Log {
  3.   private static final String FQCN = Log4jImpl.class.getName();
  5.   private final Logger log;
  7.   public Log4jImpl(String clazz) {
  8.     log = Logger.getLogger(clazz);
  9.   }
  11.   @Override
  12.   public boolean isDebugEnabled() {
  13.     return log.isDebugEnabled();
  14.   }
  16.   @Override
  17.   public boolean isTraceEnabled() {
  18.     return log.isTraceEnabled();
  19.   }
  21.   @Override
  22.   public void error(String s, Throwable e) {
  23.     log.log(FQCN, Level.ERROR, s, e);
  24.   }
  26.   @Override
  27.   public void error(String s) {
  28.     log.log(FQCN, Level.ERROR, s, null);
  29.   }
  31.   @Override
  32.   public void debug(String s) {
  33.     log.log(FQCN, Level.DEBUG, s, null);
  34.   }
  36.   @Override
  37.   public void trace(String s) {
  38.     log.log(FQCN, Level.TRACE, s, null);
  39.   }
  41.   @Override
  42.   public void warn(String s) {
  43.     log.log(FQCN, Level.WARN, s, null);
  44.   }
  46. }

这个类适配的 org.apache.log4j日志组件，在类里有一个成员变量。相当于适配器模式里面对象的适配器模式。Log4jImpl这个类相当于是将log4j的功能翻译成了Mybatis的功能，做了api的适配

拓展：Mybatis是如何做到日志可以自定义扩展的呢？

从上面的源码分析我们已经看出了，Mybatis内置了

  • SLF4J
  • Apache Commons Logging
  • Log4j2
  • Log4j2
  • JDK Logging

几种开源的实现作为日志扩展。默认使用的是 “Slf4j ” 如果我们需要自己指定也是可以的，我们只需要在配置文件中加上：

  1. <configuration>
  2.     <settings>
  3.         <setting name="logImpl" value="SLF4J"/>
  4.     </settings>
  5. </configuration>

mybatis的启动加载的源码中会自动的加载，解析配置文件，

  1.  private void parseConfiguration(XNode root) {
  2.     try {
  3.       propertiesElement(root.evalNode("properties"));
  4.       Properties settings = settingsAsProperties(root.evalNode("settings"));
  5.       loadCustomVfs(settings);
  6.       // 4、根据<logImpl>标签获取日志的实现类，我们可以用到很多的日志的方案，包括LOG4J，LOG4J2
  7.       loadCustomLogImpl(settings);
  8.       ...
  9.        }
  10.  }
  12. /**
  13.    * 在这里我们可以指定日志的实现方式
  14.    * @param props mybatis-config.xml中setting的properties的配置文件中logImpl实现方式
  15.    */
  16.   private void loadCustomLogImpl(Properties props) {
  17.     // 根据配置文件中的配置的日志的名称，解析出使用日志的实现类
  18.     Class<? extends Log> logImpl = resolveClass(props.getProperty("logImpl"));
  19.     // 方法设置为我们自定义的类，跟踪此方法，找到最后的实现为
  20.     configuration.setLogImpl(logImpl);
  21.   }
  23. public void setLogImpl(Class<? extends Log> logImpl) {
  24.     if (logImpl != null) {
  25.       this.logImpl = logImpl;
  26.       // 查找字符串参数的构造器
  27.       LogFactory.useCustomLogging(this.logImpl);
  28.     }
  29.   }
  31. // 最后到了最关键的 LogFactory# useCustomLogging方法，这个方法如果在加载配置文件阶段就指定了
  32. // 那么我们自定义的日志实现类就会生效
  33. public static synchronized void useCustomLogging(Class<? extends Log> clazz) {
  34.     setImplementation(clazz);
  35.   }

https://juejin.cn/post/7022138295177969694