在講設計模式之前，得先知道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類這裡只分析其中一個實現類，感興趣的可以去看其它的實現類，基本一致所以這裡就不做講解了