适配器模式在Mybatis中的妙用

开发 后端
本文介绍了适配器模式在Mybatis中的用法。一起来看看吧。

写在前面:设计模式源于生活,而又高于生活!

什么是适配器模式

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

适配器模式角色划分

适配器模式涉及3个角色:

  1.  源(Adaptee):需要被适配的对象或类型,相当于插头。
  2.  适配器(Adapter):连接目标和源的中间对象,相当于插头转换器。
  3.  目标(Target):期待得到的目标,相当于插座。

适配器模式包括3种形式:类适配器模式、对象适配器模式、接口适配器模式(或又称作缺省适配器模式)。

适配器模式应用场景

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

适配器创建的方式

  1.  对象适配器(组合模式)
  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.     }  

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);  

3.适配器(Adapter):连接目标和源的中间对象,相当于插头转换器 

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

测试运行效果 

  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.     }  

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

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

对象适配器方式实现

定义基本实体类 

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

1.源目标接口 

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

2.源目标接口实现类 

  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启动成功.."); 
  11.         LogBean log2 = new LogBean();  
  12.         log2.setLogId("0002");  
  13.         log2.setLogText("Jetty启动成功..");  
  14.         List<LogBean> listArrayList = new ArrayList<LogBean>();  
  15.         listArrayList.add(log1);  
  16.         listArrayList.add(log2);  
  17.         return listArrayList;  
  18.     }  

3.目标接口 

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

4.适配器 

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

适配器模式优缺点

适配器模式的优点

  •  更好的复用性
  •  系统需要使用现有的类,而此类的接口不符合系统的需要。那么通过适配器模式就可以让这些功能得到更好的复用。
  •  更好的扩展性
  •  在实现适配器功能的时候,可以调用自己开发的功能,从而自然地扩展系统的功能。

适配器模式的缺点

  •  过多的使用适配器,会让系统非常零乱,不易整体进行把握。比如,明明看到调用的是A接口,其实内部被适配成了B接口的实现,一个系统如果太多出现这种情况,无异于一场灾难。因此如果不是很有必要,可以不使用适配器,而是直接对系统进行重构。

Mbatis 日志收集分析

Java开发中经常用到的日志框架有很多,Log4j、Log4j2、slf4j等等,Mybatis定义了一套统一的日志接口供上层使用,并为上述常用的日志框架提供了相应的适配器

在Mybatis的日志模块中就是使用了适配器模式。Mybatis内部在使用日志模块时,使用了其内部接口 org.apache.ibatis.logging.Log,但是常用的日志框架的对外接口各不相同,Mybatis为了复用和集成这些第三方日志组件,在其日志模块中,提供了多种Adapter,将这些第三方日志组件对外接口适配成org.apache.ibatis.logging.Log,这样Myabtis 就可以通过Log接口调用第三方日志了

源码分析图

源码剖析

Mybatis Log接口:相当于源接口 

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

Mybatis源接口实现类

适配器第一种 

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

适配器第二种 

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

目标接口:Logger

 

 

责任编辑:庞桂玉 来源: Java知音
相关推荐

2018-10-11 10:38:31

前端JavaScript编程语言

2020-10-25 08:56:21

适配器模式

2022-02-13 23:33:24

设计模式Java

2012-05-16 17:22:11

Java设计模式

2021-02-18 08:39:28

设计模式场景

2013-11-26 16:39:21

Android设计模式

2022-02-18 17:21:29

适配器模式客户端

2012-09-19 15:29:26

Worklight适配器

2012-08-02 10:46:34

JavaAdapter模式

2009-11-18 18:08:20

PHP适配器模式

2012-12-10 10:53:04

IBMdW

2024-07-31 10:41:16

C#设计模式

2024-02-22 12:13:49

适配器模式代码

2024-04-10 12:27:43

Python设计模式开发

2013-02-26 10:55:47

C#适配器设计模式

2012-04-12 09:33:02

JavaScript

2022-05-29 22:55:00

适配器设计模式

2022-12-12 09:20:59

适配器模式接口

2023-09-06 13:20:00

适配器模式兼容性

2015-08-07 10:05:37

recyclervie超省写法
点赞
收藏

51CTO技术栈公众号