深入理解Java设计模式——适配器模式

浅浅的花香味﹌ 2023-09-29 10:57 7阅读 0赞

#### 目录 ####

*  一、什么是适配器模式
 *  二、适配器模式角色划分
 *  三、适配器模式应用场景
 *  四、适配器创建的方式
 *  五、适配器快速入门例子
 *  六、使用适配器模式实现日志收集
 *   *  1. 对象适配器方式实现
     *  2. 适配器模式优缺点

--------------------

## 一、什么是适配器模式 ##

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

--------------------

## 二、适配器模式角色划分 ##

适配器模式涉及3个角色：  
源（Adaptee）：需要被适配的对象或类型， 旧版本  
适配器（Adapter）：连接目标和源的中间对象，相当于插头转换器，新版本与老版本能够实现兼容  
目标（Target）：期待得到的目标， 新版本  
适配器模式包括3种形式：类适配器模式、对象适配器模式、接口适配器模式（或又称作缺省适配器模式）。  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bC85Y-k5ouJ5pav54uX6JuL5YS_size_20_color_FFFFFF_t_70_g_se_x_16]

--------------------

## 三、适配器模式应用场景 ##

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

--------------------

## 四、适配器创建的方式 ##

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

--------------------

## 五、适配器快速入门例子 ##

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

package com.demo.service;
    
    import java.util.Map;
    
    public class OrderService {
        
        /**
         * V1 版本的时候提供了一个接口，入参是为Map类型
         * V2 版本能够支持List类型
         * @param map
         */
        public void forMap(Map map) {
        
            for (int i = 0; i < map.size(); i++) {
        
                String value = (String) map.get(i);
                System.out.println("value:" + value);
            }
        }
    }

创建Adapter适配器能够支持List类型

package com.demo.adapter;
    
    import java.util.HashMap;
    import java.util.List;
    
    public class ListAdapter extends HashMap {
        
        // 目标对象新版本
        private List list;
    
        public ListAdapter(List list) {
        
            this.list = list;
        }
    
        @Override
        public int size() {
        
            return list.size();
        }
    
        @Override
        public Object get(Object key) {
        
            return list.get(Integer.valueOf(key.toString()).intValue());
        }
    }

测试运行效果

package com.demo;
    
    import com.demo.adapter.ListAdapter;
    import com.demo.service.OrderService;
    
    import java.util.ArrayList;
    
    public class Test {
        
        public static void main(String[] args) {
        
            // 1. 定义源 老版本
            OrderService orderService = new OrderService();
            ArrayList arrayList = new ArrayList();
            arrayList.add("小王");
            arrayList.add("小超");
            arrayList.add("小丹");
            // 2. 使用适配器实现转换
            ListAdapter listAdapter = new ListAdapter(arrayList);
            // 3. 可以支持list类型
            orderService.forMap(listAdapter);
        }
    }

运行程序  
![在这里插入图片描述][9d946be4df6b425f83c21bbfd7f49ec5.png]

--------------------

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

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

### 1. 对象适配器方式实现 ###

package com.demo.file.entity;
    
    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;
        }
    }

package com.demo.file.service;
    
    import com.demo.file.entity.LogBean;
    
    import java.util.List;
    
    public interface LogWriteFileService {
        
        /**
         * 讲日志写入到本地文件
         */
        void logWriteFile();
    
        /**
         * 从本地文件中读取日志
         * @return
         */
        List<LogBean> readLogFile();
    }

package com.demo.file.service.impl;
    
    import com.demo.file.entity.LogBean;
    import com.demo.file.service.LogWriteFileService;
    
    import java.util.ArrayList;
    import java.util.List;
    
    public class LogWriteFileServiceImpl implements LogWriteFileService {
        
        @Override
        public void logWriteFile() {
        
    
            System.out.println(">>将日志写入到本地文件中...");
        }
    
        public List<LogBean> readLogFile() {
        
            LogBean log1 = new LogBean();
            log1.setLogId("0001");
            log1.setLogText("Tomcat启动成功...");
    
            LogBean log2 = new LogBean();
            log2.setLogText("0002");
            log2.setLogText("Jetty启动成功..");
            List<LogBean> listArrayList = new ArrayList<LogBean>();
            listArrayList.add(log1);
            listArrayList.add(log2);
            return listArrayList;
        }
    }

package com.demo.file.service;
    
    import com.demo.file.entity.LogBean;
    
    public interface LogWriteDbService {
        
        /**
         * 将本地文件写入到数据库中 新的目标
         */
        void logWriteDb(LogBean logBean);
    }

package com.demo.file.service.adapter;
    
    import com.demo.file.entity.LogBean;
    import com.demo.file.service.LogWriteDbService;
    import com.demo.file.service.impl.LogWriteFileServiceImpl;
    
    import java.util.List;
    
    //public class LogAdapter extends LogWriteFileServiceImpl implements LogWriteDbService { // 类适配器模式(记成模式)
    public class LogAdapter implements LogWriteDbService {
         // 对象适配器(组合模式)
        // 源 Adaptee
        private LogWriteFileServiceImpl logWriteFileServiceImpl;
    
        public LogAdapter(LogWriteFileServiceImpl logWriteFileServiceImpl) {
        
            this .logWriteFileServiceImpl = logWriteFileServiceImpl;
        }
    
        // 新增的扩展功能 既能够支持写入本地文件，也能支持写入数据库
        @Override
        public void logWriteDb(LogBean logBean) {
        
            // 1. 读取本地文件
    //        List<LogBean> logBeans = this.readLogFile(); // 类适配器模式(记成模式)
            List<LogBean> logBeans = logWriteFileServiceImpl.readLogFile(); // 对象适配器(组合模式)
            logBeans.add(logBean);
            // 2. 将数据写入到数据库中..
            System.out.println(">>>写入到数据库中..");
            // 2. 写入本地文件
    //        this.logWriteFile(); // 类适配器模式(记成模式)
            logWriteFileServiceImpl.logWriteFile(); // 对象适配器(组合模式)
        }
    }

package com.demo.file.service;
    
    import com.demo.file.service.adapter.LogAdapter;
    import com.demo.file.service.impl.LogWriteFileServiceImpl;
    
    public class Test {
        
        public static void main(String[] args) {
        
    //        new LogAdapter().logWriteDb(null); // 类适配器模式(记成模式)
            new LogAdapter(new LogWriteFileServiceImpl()).logWriteDb(null); // 对象适配器(组合模式)
        }
    }

运行程序：  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bC85Y-k5ouJ5pav54uX6JuL5YS_size_19_color_FFFFFF_t_70_g_se_x_16]

### 2. 适配器模式优缺点 ###

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

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

[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bC85Y-k5ouJ5pav54uX6JuL5YS_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/75b591afd7cf4f178cd159b56ff2b87f.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5bC85Y-k5ouJ5pav54uX6JuL5YS_,size_20,color_FFFFFF,t_70,g_se,x_16
[9d946be4df6b425f83c21bbfd7f49ec5.png]: https://img-blog.csdnimg.cn/9d946be4df6b425f83c21bbfd7f49ec5.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bC85Y-k5ouJ5pav54uX6JuL5YS_size_19_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/9ecbdabe186841a0bd7d2a49f92d61aa.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5bC85Y-k5ouJ5pav54uX6JuL5YS_,size_19,color_FFFFFF,t_70,g_se,x_16