mybatis源码-日志模块-logging

1.包结构

image.png

2.日志模块类图

image.png

3.适配器模式

1.mybatis 没有本身的日志实现，使用的都是比较流行的第三方组件 比如 log4j ，commonlog 等

2.mybatis 实现了自己的log 接口，自己的一套，那么如何和市面上面 流行的日志框架做整合呢？这个时候 就需要用到适配器模式

什么是适配器模式：举个简单的例子就是 你有两孔插头，墙上只有三孔插座，那么这个时候如何接到电呢？所以你就从淘宝上面买了一个两孔转三孔的转换器，这个玩意就是适配器。

类适配器:适配器使用继承，实现接口的方式

image.png

对象适配器:适配器使用私有化对象的方式

image.png

在对象适配器模式结构图中包含如下几个角色：

Target（目标抽象类）：目标抽象类定义客户所需接口，可以是一个抽象类或接口，也可以是具体类。

Adapter（适配器类）：适配器可以调用另一个接口，作为一个转换器，对Adaptee和Target进行适配，适配器类是适配器模式的核心，在对象适配器中，它通过继承Target并关联一个Adaptee对象使二者产生联系。

Adaptee（适配者类）：适配者即被适配的角色，它定义了一个已经存在的接口，这个接口需要适配，适配者类一般是一个具体类，包含了客户希望使用的业务方法，在某些情况下可能没有适配者类的源代码

Target = 墙上三孔插座
Adapter = 淘宝购买的转换器
Adaptee = 两孔转换为三孔的需求

而对于mybatis来说，有自己的一套log接口，那么第三方的日志模块，都会写一个类，去适转化

适用场景：当调用双方都不太容易修改的时候，为了复用现有组件可以使用适配器模式；在系统中接入第三方组 件的时候经常被使用到；

注意：如果系统中存在过多的适配器，会增加系统的复杂性，设计人员应考虑对系统进行重构；

4.源码研究

==org.apache.ibatis.logging.Log==

• 1.mybatis 的日志级别分为 debug trace error warn 等
• 2.所有mybatis的日志实现类都需要实现这个接口

/**
 * @author Clinton Begin
 */
public interface Log {

  boolean isDebugEnabled();

  boolean isTraceEnabled();

  void error(String s, Throwable e);

  void error(String s);

  void debug(String s);

  void trace(String s);

  void warn(String s);
}

==org.apache.ibatis.logging.LogFactory== 日志工厂

• LogFactory 主要用来生产，以及实例化日志，判断使用哪些日志，使用日志优先级
• mybatis 没有自己本身的日志实现

/**
 * @author Clinton Begin
 * @author Eduardo Macarron
 */
public final class LogFactory {

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

  //第三方日志组件构造器，默认为空
  private static Constructor<? extends Log> logConstructor;

  
  //举例说明：slf4j
  /**
   * 1.类加载器加载LogFactory 当前类 执行static 静态代码块
   * 加载顺序:slf4J → commonsLoging → Log4J2 → Log4J → JdkLog        
   * 2.执行
   
   * tryImplementation(new Runnable() {
   *   @Override
   *  public void run() {
   *     useSlf4jLogging();
   *  }
   *});  
   
   * 3.先运行useSlf4jLogging();
   * 4.setImplementation(org.apache.ibatis.logging.slf4j.Slf4jImpl.class);
   * 5.执行
   *  Constructor<? extends Log> candidate = implClass.getConstructor(String.class);
   *  Log log = candidate.newInstance(LogFactory.class.getName());
   *  Slf4jImpl.class 获取构造器
   *  candidate.newInstance() 调用 Slf4jImpl构造方法进行日志对象实例化
   * 6.mybatis pom.xml里面所有关于日志的jar包都会写 <optional>false</optional>，所以 你当前项目依赖mybatis并不会加载相应的日志jar包
   *   当系统里面找不到Slf4j的日志jar包，那么就会报ClassNotFoundException 并且会被tryImplementation 捕获住，并且ignore 不做任何处理
   *   一层一层往下找，最后找到useNoLogging
   */
  static {
    tryImplementation(new Runnable() {
      @Override
      public void run() {
        useSlf4jLogging();
      }
    });
    tryImplementation(new Runnable() {
      @Override
      public void run() {
        useCommonsLogging();
      }
    });
    tryImplementation(new Runnable() {
      @Override
      public void run() {
        useLog4J2Logging();
      }
    });
    tryImplementation(new Runnable() {
      @Override
      public void run() {
        useLog4JLogging();
      }
    });
    tryImplementation(new Runnable() {
      @Override
      public void run() {
        useJdkLogging();
      }
    });
    tryImplementation(new Runnable() {
      @Override
      public void run() {
        useNoLogging();
      }
    });
  }

  //私有化，不可以自己创建Mybatis 的日志工厂，只能在static静态代码块初始化
  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);
    }
  }

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

  private static void tryImplementation(Runnable runnable) {
    if (logConstructor == null) {
      try {
        runnable.run();
      } catch (Throwable t) {
        // ignore
      }
    }
  }

  //实例化第三方日志组件，调用构造方法
  private static void setImplementation(Class<? extends Log> implClass) {
    try {
      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.");
      }
      logConstructor = candidate;
    } catch (Throwable t) {
      throw new LogException("Error setting Log implementation.  Cause: " + t, t);
    }
  }

}

==org.apache.ibatis.logging.Log.Log4j2Impl==

1.log4j 实现 Log 接口，每个方法使用log4j实现进行适配，其他日志实现类基本都是差不多
2.构造方法Log4j2Impl进行实例化log4j


public class Log4j2Impl implements Log {

  private final Log log;

  public Log4j2Impl(String clazz) {
    Logger logger = LogManager.getLogger(clazz);

    if (logger instanceof AbstractLogger) {
      log = new Log4j2AbstractLoggerImpl((AbstractLogger) logger);
    } else {
      log = new Log4j2LoggerImpl(logger);
    }
  }

  @Override
  public boolean isDebugEnabled() {
    return log.isDebugEnabled();
  }

  @Override
  public boolean isTraceEnabled() {
    return log.isTraceEnabled();
  }

  @Override
  public void error(String s, Throwable e) {
    log.error(s, e);
  }

  @Override
  public void error(String s) {
    log.error(s);
  }

  @Override
  public void debug(String s) {
    log.debug(s);
  }

  @Override
  public void trace(String s) {
    log.trace(s);
  }

  @Override
  public void warn(String s) {
    log.warn(s);
  }

1.类加载器加载LogFactory 当前类 执行static 静态代码块，优先级加载顺序:slf4J →
commonsLoging → Log4J2 → Log4J → JdkLog
2.执行
tryImplementation(new Runnable() {
@Override
public void run() {
useSlf4jLogging();
}
});
3.先运行useSlf4jLogging();
4.setImplementation(org.apache.ibatis.logging.slf4j.Slf4jImpl.class);
5.执行
Constructor<? extends Log> candidate = implClass.getConstructor(String.class);
Log log = candidate.newInstance(LogFactory.class.getName());
Slf4jImpl.class 获取构造器
candidate.newInstance() 调用 Slf4jImpl构造方法进行日志对象实例化
6.mybatis pom.xml里面所有关于日志的jar包都会写 <optional>false</optional> （mybatis源码是都这些日志框架），所以 你当前项目依赖mybatis并不会加载相应的日志jar包
当系统里面找不到Slf4j的日志jar包，那么就会报ClassNotFoundException 并且会被tryImplementation 捕获住，并且ignore 不做任何处理
一层一层往下找，最后找到useNoLogging

总结:
1.mybatis 利用maven依赖传递的关系，设置optional = false ，不会加载任何第三方的日志框架，而是根据用户自己加载的日志框架，进行使用。
2.技术上面使用适配器模式将流行的日志框架转换为自己的日志格式。使用工厂模式生产想要的日志。使用反射实例化对象。