经典设计模式之适配器模式【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作为一个接口，实现。