适配器模式在 MyBatis 中的妙用，面试可以拿来吹了！

作者：须臾之余
地址：https://my.oschina.net/u/3995125
写在前面：设计模式源于生活，而又高于生活！
什么是适配器模式

定义：将一个系统的接口转换成另外一种形式，从而使原来不能直接调用的接口变得可以调用。

适配器模式角色划分

1. 适配器模式涉及3个角色：
2. 1.源（Adaptee）：需要被适配的对象或类型，相当于插头。
3. 2.适配器（Adapter）：连接目标和源的中间对象，相当于插头转换器。
4. 3.目标（Target）：期待得到的目标，相当于插座。
5. 适配器模式包括3种形式：类适配器模式、对象适配器模式、接口适配器模式（或又称作缺省适配器模式）。

复制代码

适配器模式应用场景

1. 1、新老版本接口的兼容
2. 2、Mybatis多种日志框架的整合

复制代码

适配器创建的方式

1. 1.对象适配器(组合模式)
2. 2.类适配器(继承模式)

复制代码

适配器快速入门例子

比如早期的时候 V1 版本订单接口的入参为 Map 类型，随着业务的更新和迭代在 V2 版本的时候该订单接口的入参需要支持 List 的类型？ 请问不改变的该接口代码的情况下，如何支持 List 类型。

1. 源（Adaptee）：需要被适配的对象或类型，相当于插头。

1. public void froOrderMap(Map map) {
2.     for (int i = 0; i < map.size(); i++) {
3.         // 使用I作为MapKey获取数据
4.         String value = (String) map.get(i);
5.         System.out.println("value:" + value);
6.     }
7. }

复制代码

2. 目标（Target）：期待得到的目标，相当于插座。

1. public interface List<E> extends Collection<E> {
2.     ......
3.     int size();
4.     E get(int index);
5.     E set(int index, E element);
6. }

复制代码

3. 适配器（Adapter）：连接目标和源的中间对象，相当于插头转换器

1. public class ListAdapter extends HashMap {
3.     private List list;
4.     public ListAdapter(List list) {
5.         this.list = list;
6.     }
7.     @Override
8.     public int size() {
9.         return list.size();
10.     }
11.     @Override
12.     public Object get(Object key) {
13.         return list.get(Integer.valueOf(key.toString()).intValue());
14.     }
15. }

复制代码

测试运行效果

1. public class Test {
2.     public static void main(String[] args) {
3.         // 1.获取集合类型用户
4.         List member = new MemberService().getMember();
5.         //new OrderService().froOrderMap(member);
6.         ListAdapter listAdapter = new ListAdapter(member);
7.         new OrderService().froOrderMap(listAdapter);
8.     }
9. }

复制代码

使用适配器模式实现日志收集

比如设计一个日志收集系统，可能会考虑文件写入、也可能考虑写入 MQ、也可能考虑写入数据库等。

对象适配器方式实现

定义基本实体类

1. @Data
2. public class LogBean {
3.     /**
4.      * 日志ID
5.      */
6.     private String logId;
7.     /**
8.      * 日志内容
9.      */
10.     private String logText;
11. }

复制代码

1. 源目标接口

1. public interface LogWriteFileService {
3.     /**
4.      * 将日志写入到文件中
5.      */
6.     void logWriteFile();
7.     /**
8.      * 从本地文件中读取日志
9.      *
10.      * @return
11.      */
12.     List<LogBean> readLogFile();
13. }

复制代码

1. 源目标接口实现类

1. public class LogWriteFileServiceImpl implements LogWriteFileService {
2.     @Override
3.     public void logWriteFile() {
4.         System.out.println(">>>将日志写入文件中...");
5.     }
6.   @Override
7.     public List<LogBean> readLogFile() {
8.         LogBean log1 = new LogBean();
9.         log1.setLogId("0001");
10.         log1.setLogText("Tomcat启动成功..");
12.         LogBean log2 = new LogBean();
13.         log2.setLogId("0002");
14.         log2.setLogText("Jetty启动成功..");
15.         List<LogBean> listArrayList = new ArrayList<LogBean>();
16.         listArrayList.add(log1);
17.         listArrayList.add(log2);
18.         return listArrayList;
19.     }
20. }

复制代码

2. 目标接口

1. public interface LogWriteDbService {
3.     /**
4.      * 将日志写入到数据库中
5.      */
6.    public void writeDbFile(LogBean logBean);
7. }

复制代码

2. 适配器

1. //LogAdapter ：适配器
2. //LogWriteDbService：目标
3. public class LogAdapter implements LogWriteDbService {
4.     //源接口
5.     private LogWriteFileService logWriteFileService;
7.     public LogAdapter(LogWriteFileService logWriteFileService) {
8.         this.logWriteFileService = logWriteFileService;
9.     }
11.     @Override
12.     public void writeDbFile(LogBean logBean) {
13.         // 1.从文件中读取日志文件
14.         List<LogBean> logBeans = logWriteFileService.readLogFile();
15.         //目标
16.         // 2.写入到数据库中
17.         logBeans.add(logBean);
18.         System.out.println(">>>将数据写入到数据库中..");
19.         // 3.写入到本地文件中
20.         logWriteFileService.logWriteFile();
21.     }
22. }

复制代码

适配器模式优缺点

1. 适配器模式的优点
2. 　　更好的复用性
3. 系统需要使用现有的类，而此类的接口不符合系统的需要。那么通过适配器模式就可以让这些功能得到更好的复用。
4. 更好的扩展性
5. 在实现适配器功能的时候，可以调用自己开发的功能，从而自然地扩展系统的功能。
7. 适配器模式的缺点
8. 　　过多的使用适配器，会让系统非常零乱，不易整体进行把握。比如，明明看到调用的是A接口，其实内部被适配成了B接口的实现，一个系统如果太多出现这种情况，无异于一场灾难。因此如果不是很有必要，可以不使用适配器，而是直接对系统进行重构。

复制代码

Mbatis 日志收集分析

1. Java开发中经常用到的日志框架有很多，Log4j、Log4j2、slf4j等等，Mybatis定义了一套统一的日志接口供上层使用，并为上述常用的日志框架提供了相应的适配器
3. 在Mybatis的日志模块中就是使用了适配器模式。Mybatis内部在使用日志模块时，使用了其内部接口 org.apache.ibatis.logging.Log,但是常用的日志框架的对外接口各不相同，Mybatis为了复用和集成这些第三方日志组件，在其日志模块中，提供了多种Adapter,将这些第三方日志组件对外接口适配成org.apache.ibatis.logging.Log，这样Myabtis 就可以通过Log接口调用第三方日志了

复制代码

源码分析图

源码剖析
Mybatis Log 接口：相当于源接口

1. package org.apache.ibatis.logging;
3. public interface Log {
4.   boolean isDebugEnabled();
5.   boolean isTraceEnabled();
6.   void error(String s, Throwable e);
7.   void error(String s);
8.   void debug(String s);
9.   void trace(String s);
10.   void warn(String s);
11. }

复制代码

Mybatis 源接口实现类

适配器第一种

1. package org.apache.ibatis.logging.slf4j;
3. import org.apache.ibatis.logging.Log;
4. import org.slf4j.Logger;
6. //Slf4jLoggerImpl ：相当于适配器
7. //Log ：相当于源接口
8. class Slf4jLoggerImpl implements Log {
10.   //Logger：相当于目标接口
11.   private Logger log;
13.   public Slf4jLoggerImpl(Logger logger) {
14.     //源=目标
15.     log = logger;
16.   }

复制代码

适配器第二种

1. package org.apache.ibatis.logging.log4j2;
3. import org.apache.ibatis.logging.Log;
4. import org.apache.logging.log4j.LogManager;
5. import org.apache.logging.log4j.Logger;
6. import org.apache.logging.log4j.spi.AbstractLogger;
7. //Log4j2Impl ：相当于适配器
8. //Log ：相当于源接口
9. public class Log4j2Impl implements Log {
11.   private Log log;
12.   //构造器
13.   public Log4j2Impl(String clazz) {
14.     //目标接口
15.     Logger logger = LogManager.getLogger(clazz);
16.     //判断类型去实现：相当于目标
17.     if (logger instanceof AbstractLogger) {
18.       log = new Log4j2AbstractLoggerImpl((AbstractLogger) logger);
19.     } else {
20.       //源=目标
21.       log = new Log4j2LoggerImpl(logger);
22.     }
23.   }

复制代码

目标接口：Logger

近期热文推荐：
1.1,000+ 道 Java面试题及答案整理(2022最新版)
2.劲爆！Java 协程要来了。。。
3.Spring Boot 2.x 教程，太全了！
4.别再写满屏的爆爆爆炸类了，试试装饰器模式，这才是优雅的方式！！
5.《Java开发手册（嵩山版）》最新发布，速速下载！
觉得不错，别忘了随手点赞+转发哦！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！