經典設計模式之適配器模式【Mybatis日誌框架源碼分析】

一、什麼是適配器模式

適配器模式就是將一個系統的接口轉換成另外一種形式，從而使原來不能直接調用的接口變得可以調用。

二、設計模式角色劃分

設計模式涉及三個角色：
源(Adaptee)：需要被適配的對象或類型，這裏相當於插頭。
適配器(Adapter)：連接目標和源的中間對象，相當於插頭轉換器，新版本與老版本能夠實現兼容。這裏相當於插頭轉換器。
目標(Target)：期待得到的目標。這裏相當於插座。
適配器模式包括三種形式：類適配器模式、對象適配器模式、接口適配器模式（或又稱作缺省適配器模式）。

三、設計模式應用場景

1. 新老版本接口的兼容
2. MyBatis多種日誌框架的整合

四、適配器創建的方式

對象適配器(組合模式)
類適配器(繼承模式)

五、適配器快速入門例子

比如早期的時候V1版本訂單接口的入參爲Map類型，隨着業務的更新和迭代在V2版本的時候該訂單接口的入參需要支持List的類型？ 請問不改變的該接口代碼的情況下，如何支持List類型。

1.源（Adaptee）：需要被適配的對象或類型，相當於插頭。

public class OrderService {
    /**
     * V1版本提供的接口，入參是map類型
     *
     * @param map
     */
    public void forMap(Map<String, String> map) {
        for (int i = 0; i < map.size(); i++) {
            String value = map.get(i);
            System.out.println("value:" + value);
        }
    }
}

2.目標（Target）：期待得到的目標，相當於插座。

public interface List<E> extends Collection<E> {
    ......
    int size();
    E get(int index);
    E set(int index, E element);
}

3.適配器（Adapter）：連接目標和源的中間對象，相當於插頭轉換器

public class ListAdapter extends HashMap {
    //目標對象新版本
    private List<String> list;

    public ListAdapter(List<String> list) {
        this.list = list;
    }

    @Override
    public Object get(Object key) {
        return list.get(Integer.valueOf(key.toString()).intValue());
    }

    @Override
    public int size() {
        return list.size();
    }
}

測試類：

public class Test001 {
    public static void main(String[] args) {
        //定義源 老版本
        OrderService orderService = new OrderService();
        List<String> list = new ArrayList<>();
        list.add("james");
        list.add("mark");
        list.add("rose");
        //使用適配器實現轉換
        ListAdapter listAdapter = new ListAdapter(list);
        //可以支持List類型
        orderService.forMap(listAdapter);
    }
}

六、使用適配器模式實現日誌收集

比如設計一個日誌收集系統，可能會考慮文件寫入、也有可能寫入MQ、還有可能考慮寫入數據庫等

對象適配器方式實現

定義基本實體類

public class LogBean {
    /* 日誌ID */
    private String logId;
    /* 日誌內容 */
    private String logText;

    public String getLogId() {
        return logId;
    }

    public void setLogId(String logId) {
        this.logId = logId;
    }

    public String getLogText() {
        return logText;
    }

    public void setLogText(String logText) {
        this.logText = logText;
    }
}

源接口

public interface LogWriteFileService {
    /**
     * 寫入日誌到本地文件
     */
    void logWriteFile();

    /**
     * 讀取本地文件
     * @return
     */
    List<LogBean> readLogFile();
}

源接口實現類

public class LogWriteFileServiceImpl implements LogWriteFileService {
    @Override
    public void logWriteFile() {
        System.out.println(">> 將日誌寫入到本地文件中...");
    }

    @Override
    public List<LogBean> readLogFile() {
        LogBean log1 = new LogBean();
        log1.setLogId("0001");
        log1.setLogText("Tomcat啓動成功！");
        LogBean log2 = new LogBean();
        log2.setLogId("0002");
        log2.setLogText("Jetty啓動成功！");
        List<LogBean> list = new ArrayList<>();
        list.add(log1);
        list.add(log2);
        return list;
    }
}

目標接口

public interface LogWriteDbService {
    /**
     * 將本地文件寫入到數據庫
     */
    void logWriteDb(LogBean logBean);
}

適配器

public class LogAdatper implements LogWriteDbService {

    private LogWriteFileService logWriteFileService;

    public LogAdatper(LogWriteFileService logWriteFileService){
        this.logWriteFileService = logWriteFileService;
    }
    @Override
    public void logWriteDb(LogBean logBean) {
        //1、從文件中讀取日誌
        List<LogBean> logBeans = logWriteFileService.readLogFile();
        logBeans.add(logBean);
        //2、寫入到數據庫中
        System.out.println(">> 將日誌文件寫入到數據庫中...");
        //3、寫書到本地文件
        logWriteFileService.logWriteFile();
    }
}

測試類

public class Test002 {
    public static void main(String[] args) {
        new LogAdatper(new LogWriteFileServiceImpl()).logWriteDb(null);
    }
}

測試結果

>> 日誌文件寫入到數據庫中...
>> 將日誌寫入到本地文件中...

七、適配器模式優缺點

優點：
更好的複用性
系統需要使用現有的類，而此類的接口不符合系統的需要。那麼通過適配器模式就可以讓這些功能得到更好的複用。
更好的擴展性
在實現適配器功能的時候，可以調用自己開發的功能，從而自然地擴展系統的功能。

缺點：
過多的使用適配器，會讓系統非常零亂，不易整體進行把握。比如，明明看到調用的是A接口，其實內部被適配成了B接口的實現，一個系統如果太多出現這種情況，無異於一場災難。因此如果不是很有必要，可以不使用適配器，而是直接對系統進行重構。

八、Mybatis日誌收集分析

Java開發中用到到日誌框架有很多，Log4j、Log4j2、slf4j等，Mybatis定義了一套統一的日誌接口供上層使用，併爲上述常用的日誌框架提供了相應的適配器。

在Mybatis的日誌模塊中就是使用了適配器模式。Mybatis內部在使用日誌模塊時，使用了其內部接口 org.apache.ibatis.logging.Log,但是常用的日誌框架的對外接口各不相同，Mybatis爲了複用和集成這些第三方日誌組件，在其日誌模塊中，提供了多種Adapter,將這些第三方日誌組件對外接口適配成org.apache.ibatis.logging.Log，這樣Myabtis 就可以通過Log接口調用第三方日誌了。

Mybatis Log接口

public interface Log {
    boolean isDebugEnabled();
    boolean isTraceEnabled();
    void error(String var1, Throwable var2);
    void error(String var1);
    void debug(String var1);
    void trace(String var1);
    void warn(String var1);
}

Log接口實現類

第一種

1. 接口Log就是要轉化的目標接口：Target 
2. 各個子包下的實現類，就是適配器：Adapter 
3. 各個日誌框架的日誌類，比如org.apache.log4j.Logger就是需要適配的類：Adaptee
public class Log4jImpl implements Log {
    private static final String FQCN = Log4jImpl.class.getName();
    //源
    private Logger log;

    public Log4jImpl(String clazz) {
        this.log = Logger.getLogger(clazz);
    }

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

第二種

package org.apache.ibatis.logging.log4j2;

import org.apache.ibatis.logging.Log;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.spi.AbstractLogger;
//Log4j2Impl ：相當於適配器
//Log ：相當於目標接口
public class Log4j2Impl implements Log {
  private 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);
    }
  }

九、總結

我個人理解，三種命名方式，是根據 src是以怎樣的形式給到Adapter（在Adapter裏的形式）來命名的。
類適配器，以類給到，在Adapter裏，就是將src當做類，繼承，
對象適配器，以對象給到，在Adapter裏，將src作爲一個對象，持有。
接口適配器，以接口給到，在Adapter裏，將src作爲一個接口，實現。