mybatis原理与设计模式-日志模块- 适配器模式

 在讲设计模式之前，得先知道java程序设计中得六大原则，才能更好得理解我们得系统为什么需要设计模式

1 单一职责原则

　　一个类只负责一种职责，只有这种职责的改变会导致这个类的变更。绕口一点的正统说法：不要存在多于一个原因导致类变更

　　假如：类T 负责有两种职责 P1，P2；当P1发生改变时，需要修改类T，这时候可能会对P2造成影响。

　　所以不要为了图代码量少，二将不同职责放入到一个类里面。

2 里氏替换原则

　　只要父类出现的地方，都可以用子类替换，并且不会对程序造成影响，在实现上来说就是子类不要覆盖父类的非抽象方法，但可以重载。

　　重载时需要注意，入参的要求要比父类宽松（保证可以进入），返回要比父类更加严格（保证出去不会有问题），这也正是实现里氏替换的基础。

3 依赖倒置原则

　　高层模块不应该依赖低层模块，二者都应该依赖其抽象，翻译一下就是面向接口编程；接口一般是行为的集合，也就是尽可能的对行为抽象。

　　抽象不应该依赖细节，细节应该依赖抽象。

4 接口隔离原则

　　翻译一下就是接口的功能尽可能单一，接口本质上是两个类之间关系的纽带，关系中不需要有的，在接口中不应该体现。如：A 通过接口I依赖B，假如接口I中有A 不需要的方法，那么这个接口就是不合理的，B必须要实现这个不需要的方法，徒劳无功。

5 迪米特法则（最少知道原则）

　　也就是说一个对象要对其他对象保持尽可能少的了解，即低耦合性，低耦合可以最大限度的保证代码的可复用性。这个实际上是针对被依赖的类来说的，对于被依赖的类，尽可能的将复杂的逻辑封装起来，对外只提供public方法，外部不需要知道内部的逻辑。

6 开闭原则

　　尽量通过扩展来面对需求的更改或者系统的变化，尽量不要对原有内容修改。

在这六大原则中，开闭原则应该是最基础得原则

适配器模式

在适配器模式中，我们通过增加一个新的适配器类来解决接口不兼容的问题，使得原本没有任何关系的类可以协同工作。根据适配器类与适配者类的关系不同，适配器模式可分为对象适配器和类适配器两种，在对象适配器模式中，适配器与适配者之间是关联关系；在类适配器模式中，适配器与适配者之间是继承（或实现）关系。在实际开发中，对象适配器的使用频率更高

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

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

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

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

MyBatis的日志功能源码包logging就是适配器模式的应用，主要是为了将市场的各种日志插件，转换为MyBatis的日志接口，统一使用，下面是日志包的包结构

 其中我们可以重点关注下LogFactory这个工厂类

package org.apache.ibatis.logging;

import java.lang.reflect.Constructor;

/**
 * @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;

  static {
    tryImplementation(new Runnable() {
      public void run() {
        useSlf4jLogging();
      }
    });
    tryImplementation(new Runnable() {
      public void run() {
        useCommonsLogging();
      }
    });
    tryImplementation(new Runnable() {
      public void run() {
        useLog4J2Logging();
      }
    });
    tryImplementation(new Runnable() {
      public void run() {
        useLog4JLogging();
      }
    });
    tryImplementation(new Runnable() {
      public void run() {
        useJdkLogging();
      }
    });
    tryImplementation(new Runnable() {
      public void run() {
        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(new Object[] { 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
      }
    }
  }

 

}

在LogFactory类加载的时候会执行静态代码块，其逻辑是按序加载并实例化对应的日志组件的适配器，然后使用Logfactory.logConstructor这个静态字段，记录当前使用的的第三方日志组件的适配器

tryImplementation(new Runnable() {
      public void run() {
        useLog4JLogging();
      }
    });

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(new Class[] { String.class });
      Log log = candidate.newInstance(new Object[] { LogFactory.class.getName() });
      log.debug("Logging initialized using '" + implClass + "' adapter.");
      logConstructor = candidate;
    } catch (Throwable t) {
      throw new LogException("Error setting Log implementation.  Cause: " + t, t);
    }
  }

这个方法首先会检查logConstructor这个是不是空，如果为空则调用runnable.run方法，（注意不是start方法）


接下来我们一起看一个其中的适配器类

import org.apache.ibatis.logging.Log;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.Marker;
import org.slf4j.spi.LocationAwareLogger;

public class Slf4jImpl implements Log {

  private Log log;

  public Slf4jImpl(String clazz) {
    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);
  }

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

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

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

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

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

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

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

}

Slf4jImpl实现了Log接口
并在类中使用组合的方式引入Log的引入

结合上面的适配模式可以分析，Slf4jImpl就是Apdater类，Log接口就是Target

LoggerFactory.getLogger(clazz)这个操作就是获取  org.slf4j.Logger 他就是Adaptee类
这里只分析其中一个实现类，感兴趣的可以去看其它的实现类，基本一致所以这里就不做讲解了

tryImplementation 详细X

  没有英汉互译结果
  请尝试网页搜索