聊一聊适配器模式

Posted 2023-05-17 知了一笑

适配器模式（Adapter），是23种设计模式中的结构型模式之一，它就像我们电脑上接口不够时，需要用到的拓展坞，起到转接的作用。

接口不能用？行，我帮你适配

一、概述

适配器模式（Adapter），是23种设计模式中的结构型模式之一；它就像我们电脑上接口不够时，需要用到的拓展坞，起到转接的作用。它可以将新的功能和原先的功能连接起来，使由于需求变动导致不能用的功能，重新利用起来。

上图的Mac上，只有两个typec接口，当我们需要用到USB、网线、HDMI等接口时，这就不够用了，所以我们需要一个拓展坞来增加电脑的接口

言归正传，下面来了解下适配器模式中的角色：请求者（client）、目标角色（Target）、源角色（Adaptee）、适配器角色（Adapter），这四个角色是保证这个设计模式运行的关键。

• client：需要使用适配器的对象，不需要关心适配器内部的实现，只对接目标角色。
• Target：目标角色，和client直接对接，定义了client需要用到的功能。
• Adaptee：需要被进行适配的对象。
• Adapter：适配器，负责将源对象转化，给client做适配。

二、入门案例

适配器模式也分两种：对象适配器、类适配器。其实两种方式的区别在于，适配器类中的实现，类适配器是通过继承源对象的类，对象适配器是引用源对象的类。

当然两种方式各有优缺点，咱分别来说下；

类适配器：由于采用继承模式，在适配器中可以重写Adaptee原有的方法，使得适配器可以更加灵活；但是有局限性，Java是单继承模式，所以适配器类只能继承Adaptee，不能在额外继承其他类，也导致Target类只能是接口。

对象适配器：这个模式规避了单继承的劣势，将Adaptee类用引用的方式传递给Adapter，这样可以传递的是Adaptee对象本身及其子类对象，相比类适配器更加的开放；但是也正是因为这种开放性，导致需要自己重新定义Adaptee，增加额外的操作。

类适配器UML图

对象适配器UML图

下面，是结合上面电脑的场景，写的一个入门案例，分别是四个类：Client、Adaptee、Adapter、Target，代表了适配器模式中的四种角色。

/**
 * @author 往事如风
 * @version 1.0
 * @date 2023/5/9 15:54
 * @description：源角色
 */
public class Adaptee 
    /**
     * 需要被适配的适配的功能
     * 以Mac笔记本的typec接口举例
     */
    public void typeC() 
        System.out.println("我只是一个typeC接口");
    

/**
 * @author 往事如风
 * @version 1.0
 * @date 2023/5/9 15:57
 * @description：目标接口
 */
public interface Target 

    /**
     * 定义一个转接功能的入口
     */
    void socket();

/**
 * @author 往事如风
 * @version 1.0
 * @date 2023/5/9 16:00
 * @description：适配器
 */
public class Adapter extends Adaptee implements Target 

    /**
     * 实现适配功能
     * 以Mac的拓展坞为例，拓展更多的接口：usb、typc、网线插口...
     */
    @Override
    public void socket() 
        typeC();
        System.out.println("新增usb插口。。。");
        System.out.println("新增网线插口。。。");
        System.out.println("新增typec插口。。。");
    

/**
 * @author 往事如风
 * @version 1.0
 * @date 2023/5/9 15:52
 * @description：请求者
 */
public class Client 

    public static void main(String[] args) 
        Target target = new Adapter();
        target.socket();
    

这个案例比较简单，仅仅是一个入门的demo，也是类适配器模式的案例，采用继承模式。在对象适配器模式中，区别就是Adapter这个适配器类，采用的是组合模式，下面是对象适配器模式中Adapter的代码；

/**
 * @author 往事如风
 * @version 1.0
 * @date 2023/5/9 16:00
 * @description：适配器
 */
public class Adapter implements Target 

    private Adaptee adaptee;

    public Adapter(Adaptee adaptee) 
        this.adaptee = adaptee;
    

    /**
     * 实现适配功能
     * 以Mac的拓展坞为例，拓展更多的接口：usb、typc、网线插口...
     */
    @Override
    public void socket() 
        adaptee.typeC();
        System.out.println("新增usb插口。。。");
        System.out.println("新增网线插口。。。");
        System.out.println("新增typec插口。。。");
    

三、运用场景

其实适配器模式为何会存在，全靠“烂代码”的衬托。在初期的设计上，一代目没有考虑到后期的兼容性问题，只顾自己一时爽，那后期接手的人就会感觉到头疼，就会有“还不如重写这段代码的想法”。但是这部分代码往往都是经过N代人的充分测试，稳定性比较高，一时半会还不能对它下手。这时候我们的适配器模式就孕育而生，可以在不动用老代码的前提下，实现新逻辑，并且能做二次封装。这种场景，我在之前的系统重构中深有体会，不说了，都是泪。

当然还存在一种情况，可以对不同的外部数据进行统一输出。例如，写一个获取一些信息的接口，你对前端暴露的都是统一的返回字段，但是需要调用不同的外部api获取不同的信息，不同的api返回给你的字段都是不同的，比如企业工商信息、用户账户信息、用户津贴信息等等。下面我对这种场景具体分析下；

首先，我定义一个接口，接收用户id和数据类型两个参数，定义统一的输出字段。

/**
 * @author 往事如风
 * @version 1.0
 * @date 2023/5/10 11:03
 * @description
 */
@RestController
@RequestMapping("/user")
@RequiredArgsConstructor
public class UserInfoController 

    private final UserInfoTargetService userInfoTargetService;

    @PostMapping("/info")
    public Result<DataInfoVo> queryInfo(@RequestParam Integer userId, @RequestParam String type) 
        return Result.success(userInfoTargetService.queryData(userId, type));
    

定义统一的输出的类DataInfoVo，这里定义的字段需要暴露给前端，具体业务意义跟前端商定。

/**
 * @author 往事如风
 * @version 1.0
 * @date 2023/5/10 14:40
 * @description
 */
@Data
public class DataInfoVo 
    /**
     * 名称
     */
    private String name;
    /**
     * 类型
     */
    private String type;
    /**
     * 预留字段：具体业务意义自行定义
     */
    private Object extInfo;

然后，定义Target接口（篇幅原因，这里不做展示），Adapter适配器类，这里采用的是对象适配器，由于单继承的限制，对象适配器也是最常用的适配器模式。

/**
 * @author 往事如风
 * @version 1.0
 * @date 2023/5/10 15:09
 * @description
 */
@Service
@RequiredArgsConstructor
public class UserInfoAdapter implements UserInfoTargetService 
    /**
     * 源数据类管理器
     */
    private final AdapteeManager adapteeManager;

    @Override
    public DataInfoVo queryData(Integer userId, String type) 
        // 根据类型，得到唯一的源数据类
        UserBaseAdaptee adaptee = adapteeManager.getAdaptee(type);
        if (Objects.nonNull(adaptee)) 
            Object data = adaptee.getData(userId, type);
            return adaptee.convert(data);
        
        return null;
    

这里定义了一个AdapteeManager类，表示管理Adaptee类，内部维护一个map，用于存储真实Adaptee类。

/**
 * @author 往事如风
 * @version 1.0
 * @date 2023/5/10 15:37
 * @description
 */
public class AdapteeManager 

    private Map<String, UserBaseAdaptee> baseAdapteeMap;

    public void setBaseAdapteeMap(List<UserBaseAdaptee> adaptees) 
        baseAdapteeMap = adaptees.stream()
                .collect(Collectors.toMap(handler -> AnnotationUtils.findAnnotation(handler.getClass(), Adapter.class).type(), v -> v, (v1, v2) -> v1));
    

    public UserBaseAdaptee getAdaptee(String type) 
        return baseAdapteeMap.get(type);
    

最后，按照数据类型，定义了三个Adaptee类：AllowanceServiceAdaptee（津贴）、BusinessServiceAdaptee（企业工商）、UserAccountServiceAdaptee（用户账户）。

/**
 * @author 往事如风
 * @version 1.0
 * @date 2023/5/10 15:00
 * @description
 */
@Adapter(type = "JT")
public class AllowanceServiceAdaptee implements UserBaseAdaptee 

    @Override
    public Object getData(Integer userId, String type) 
        // 模拟调用外部api，查询津贴信息
        AllowanceVo allowanceVo = new AllowanceVo();
        allowanceVo.setAllowanceType("管理津贴");
        allowanceVo.setAllowanceAccount("xwqeretry2345676");
        allowanceVo.setAmount(new BigDecimal(20000));
        return allowanceVo;
    

    @Override
    public DataInfoVo convert(Object data) 
        AllowanceVo preConvert = (AllowanceVo) data;
        DataInfoVo dataInfoVo = new DataInfoVo();
        dataInfoVo.setName(preConvert.getAllowanceAccount());
        dataInfoVo.setType(preConvert.getAllowanceType());
        dataInfoVo.setExtInfo(preConvert.getAmount());
        return dataInfoVo;
    

/**
 * @author 往事如风
 * @version 1.0
 * @date 2023/5/10 15:00
 * @description
 */
@Adapter(type = "QY")
public class BusinessServiceAdaptee implements UserBaseAdaptee 

    @Override
    public Object getData(Integer userId, String type) 
        // 模拟调用外部api，查询企业工商信息
        BusinessVo businessVo = new BusinessVo();
        businessVo.setBusName("xxx科技有限公司");
        businessVo.setBusCode("q24243Je54sdfd99");
        businessVo.setBusType("中大型企业");
        return businessVo;
    

    @Override
    public DataInfoVo convert(Object data) 
        BusinessVo preConvert = (BusinessVo) data;
        DataInfoVo dataInfoVo = new DataInfoVo();
        dataInfoVo.setName(preConvert.getBusName());
        dataInfoVo.setType(preConvert.getBusType());
        dataInfoVo.setExtInfo(preConvert.getBusCode());
        return dataInfoVo;
    

/**
 * @author 往事如风
 * @version 1.0
 * @date 2023/5/10 15:00
 * @description
 */
@Adapter(type = "YH")
public class UserAccountServiceAdaptee implements UserBaseAdaptee 

    @Override
    public Object getData(Integer userId, String type) 
        // 模拟调用外部api，查询企业工商信息
        UserAccountVo userAccountVo = new UserAccountVo();
        userAccountVo.setAccountNo("afsdfd1243567");
        userAccountVo.setAccountType("银行卡");
        userAccountVo.setName("中国农业银行");
        return userAccountVo;
    

    @Override
    public DataInfoVo convert(Object data) 
        UserAccountVo preConvert = (UserAccountVo) data;
        DataInfoVo dataInfoVo = new DataInfoVo();
        dataInfoVo.setName(preConvert.getName());
        dataInfoVo.setType(preConvert.getAccountType());
        dataInfoVo.setExtInfo(preConvert.getAccountNo());
        return dataInfoVo;
    

这三个类都实现一个接口UserBaseAdaptee，该接口定义了统一的规范

/**
 * @author 往事如风
 * @version 1.0
 * @date 2023/5/10 15:03
 * @description
 */

public interface UserBaseAdaptee 
    /**
     * 获取数据
     * @param userId
     * @param type
     * @return
     */
    Object getData(Integer userId, String type);

    /**
     * 数据转化为统一的实体
     * @param data
     * @return
     */
    DataInfoVo convert(Object data);

这些类中，其实重点看下UserInfoAdapter适配器类，这里做的操作是通过源数据类，拿到外部返回的数据，最后将不同的数据转化为统一的字段，返回出去。

这里我没有按照固定的模式，稍加了改变。将适配器类中引用源数据类的方式，改成将源数据类加入map中暂存，最后通过前端传输的type字段来获取源数据类，这也是对象适配器比较灵活的一种体现。

四、源码中的运用

在JDK的源码中，JUC下有个类FutureTask，其中它的一段构造方法如下：

public class FutureTask<V> implements RunnableFuture<V> 
    public FutureTask(Callable<V> callable) 
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // ensure visibility of callable
    
    
	public FutureTask(Runnable runnable, V result) 
        this.callable = Executors.callable(runnable, result);
        this.state = NEW;       // ensure visibility of callable
    

其中一个构造函数中，callable是通过Executors类的方法进行适配的，通过一个RunnableAdapter的适配器类，进行包装并返回

public static <T> Callable<T> callable(Runnable task, T result) 
        if (task == null)
            throw new NullPointerException();
        return new RunnableAdapter<T>(task, result);
    

static final class RunnableAdapter<T> implements Callable<T> 
        final Runnable task;
        final T result;
        RunnableAdapter(Runnable task, T result) 
            this.task = task;
            this.result = result;
        
        public T call() 
            task.run();
            return result;
        
    

这样的话，无论传入Runnable还是Callable都可以适配任务，虽然看着是调用了Callable的call方法，实际内部是调用了Runnable的run方法，并且将传入的返回数据返回给外部使用。

五、总结

适配器模式其实是一个比较好理解的设计模式，但是对于大多数初学者而言，就会很容易看一遍之后立马忘，这是缺少实际运用造成的。其实编程主要考察的还是我们的一种思维模式，就像这个适配器模式，理解它的运用场景最重要。如果给你一个业务场景，你能在脑海中有大致的设计思路或者解决方案，那你就已经掌握精髓了。至于具体的落地，有些细节忘记也是在所难免，翻翻资料就会立马回到脑海中。

最后，每次遇到问题，用心总结，你会离成功更近一步。

Gitee主页： https://gitee.com/cicadasmile/butte-java-note

聊一聊Docker网络通信

基于Docker run创建docker容器时，可以使用--net选项指定容器的网络模式，Docker默认有一下四种网络模式':

1）host模式：

默认docker容器运行会分配独立的networknamspace隔离子系统，基于host模式，容器将不会获得一个独立的networknamespace，而是和宿主机共用一个network namespace，容器将不会虚拟出自己的网卡等信息，而是使用宿主机的IP和端口

2）container模式

其实container模式，其实就是容器之间共享一个networknamespace，而不是和宿主机共享，也就是说新创建的容器不会创建自己的网卡，配置自己的IP，而是和一个指定的容器共享网络环境，同样，两个容器除了网络方面相同之外，其他的包括文件系统，进程列表等还是隔离的，

3）None模式：

None模式与其他模式都不同，这种模式docker容器会拥有自己独立的networknamespace,但是呢，并不会为docker容器进行任何网络配置，也就是说，该docker容器没有网络信息，需要手动自定义等，我们可以借助pipwork工具为docker容器指定IP信息等；

4）Bridge桥接模式

bridge模式是docker默认的网络模式，该模式宿主机会为每一个容器自动分配一个networknamespace，默认会将docker容器连接到一个虚拟网桥交换机docker0上，

PS:Docker Bridge创建创建过程:

1）首先宿主机上创建一对虚拟网卡veth pair设备，veth设备总是成对出现的，形成一个通信通道，数据传输就是基于这个链路的，veth设备常用来连接两个网络设备

2）Docker将veth pair设备的一端放在容器中，并命名为eth0,然后将另一端加入docker0网桥中，可以通过brctl show命令查看

3）从docker0字网卡中分配一个IP到给容器使用，并设置docker0的IP地址为容器默认网关

4）此时容器IP与宿主机是可以通信的，宿主机也可以访问容器中的ip地址，在bridge模式下，连接同一网桥的容器之间可以相互通信，同时容器可以访问外网，但是其他物理机不能访问docker容器IP，需要通过NAT将容器的IP的port映射为宿主机的IP和port；

【外部访问容器】

容器中可以运行一些网络应用，要让外部也可以访问这些应用，可以用过-P或-p参数指定端口映射。当使用-P标记时，docker会随机映射一个49000~49900的端口到内部容器开放的网络端口。使用docker ps可以看到，本地主机的49155被映射到了容器的500端口，此时访问本机的49155端口。即可访问容器内部web应用提供的界面

IP :主机端口:包含端口   |IP : :包含端口  | 主机端口:包含端口

#映射所有所有接口

使用[hostport:containport]格式本地的5000端口映射到容器的5000端口，此时默认会绑定本地所有接口上的所有地址

[[email protected] ~]# docker run -d -p 5000:5000  docker.io/centos /usr/sbin/init /bin/bash 

5b2bba28f744d661c33d1cb2d34292795204096b5d5264037d61a568ff91e37b

映射到指定地址的任意端口

使用[ip::containerport]绑定localhost的任意端口到容器的5000端口，本地主机会自动分配一个端口

# docker run -itd --name centosv1 -p 127.0.0.1::5000 e934aafc2206 /bin/bash 

#映射到指定地址的指定端口

使用[ip:hostport:containerport]格式指定映射使用一个特定的地址

# docker run -itd -p 127.0.0.1:1001:1002 6fae60ef3446 python app.py 

# docker ps -l 

CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                    NAMES

5b2bba28f744        docker.io/centos    "/usr/sbin/init /b..."   About an hour ago   Up About an hour    0.0.0.0:5000->5000/tcp   naughty_nightingale

# docker logs -f 5b2bba28f744     同样，可以通过docker logs -f 命令查看应用信息

Ps:我们可以通过使用docker port来查看当前映射的端口配置，也可以查看绑定的地址

这里需要注意的是，容器有自己的内部网络和IP地址（使用doker inspect可以获取所有的变量，docker还可以有一个可变的网络配置）

-p标记可以多次使用来绑定多个端口

例如：

docker run -d -p 5000:5000 -p 3000:80 training/webapp python app.py

【容器互联】

我们称之为容器互联是指容器之间的连接，除了映射之外，另一种跟容器中应用交互的方式，该系统会在源和接受容器之间创建一个隧道，接受容器可以看到源容器指定的信息

在这里，我们互涉及到自定义容器命名，因为连接系统一句容器的名称来执行，因此首先要自定义好记得容器命名。虽然当创建容器的时候，系统默认会分配一个名字，自定义命名容器好处一下两点：

自定义命名，比较好几，比如web应用容器我们可以给取名为web

当要连接其他容器 的时候，可以作为一个有用的参考点，比如连接web容器到db容器

使用--name标记为容器自定义命名，上述提到，在此不需要在详细讲述

#使用--link参数可以实现容器之间安全的进行交互

下面创建一个新的数据库容器举例：

# docker run -d --name dbserver training/postgres 

创建一个web容器，并将它连接到dbserver容器

# docker run -d -P --name web --link dbserver:db training/webapp  python app.py   

docker 在两个互联容器之间创建了一个安全的隧道，而且不用映射它们的端口到宿主机主机上，在启动dbserver容器的时候并没有使用-p和-P标记，从而避免暴露数据库端口到外部网络上

此时，db 容器和 web 容器建立互联关系。 --link 参数的格式为 --link name:alias ，其中 name 是要链接的容器的名称， alias 是这个连接的 别名。 使用 docker ps 来查看容器的连接

我们进入webserver容器看看，查看hosts文件，127.17.0.2是dbserver的IP；172.17.0.3是本机的ip；这里有两个hosts,都存在着各自的解析IP和主机名信息

# docker exec -it 99a1e9ad54da  /bin/bash 

可以在webserver容器中安装ping命令来测试与dbserver容器的连通性

Ps:用户可以链接多个父容器到子容器，比如可以链接 多个web到dbserver容器上

【docker网络配置参数】

下面是一个跟 Docker 网络相关的命令列表。 其中有些命令选项只有在 Docker 服务启动的时候才能配置，而且不能马上生效。

 -b BRIDGE or --bridge=BRIDGE --指定容器挂载的网桥 

--bip=CIDR --定制 docker0 的掩码 

-H SOCKET... or --host=SOCKET... --Docker 服务端接收命令的通道 

--icc=true|false --是否支持容器之间进行通信 

--ip-forward=true|false --请看下文容器之间的通信 

--iptables=true|false --禁止 Docker 添加 iptables 规则 

--mtu=BYTES --容器网络中的 MTU 

下面2个命令选项既可以在启动服务时指定，也可以 Docker 容器启动（ docker run ）时候指定。在 Docker 服务启动的时候指定则会成为默认值，后面执行 docker run 时可以覆盖设置的默认值。 

--dns=IP_ADDRESS... --使用指定的DNS服务器 

--dns-search=DOMAIN... --指定DNS搜索域 最后这些选项只有在 docker run 执行时使用，因为它是针对容器的特性内容。 

-h HOSTNAME or --hostname=HOSTNAME --配置容器主机名 

--link=CONTAINER_NAME:ALIAS --添加到另一个容器的连接 

--net=bridge|none|container:NAME_or_ID|host --配置容器的桥接模式 

-p SPEC or --publish=SPEC --映射容器端口到宿主主机 

-P or --publish-all=true|false --映射容器所有端口到宿主主机