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

  沒有英漢互譯結果
   請嘗試網頁搜索