关于java:聊一聊适配器模式

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

一、概述

适配器模式（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 办法，并且将传入的返回数据返回给内部应用。

五、总结

适配器模式其实是一个比拟好了解的设计模式，然而对于大多数初学者而言，就会很容易看一遍之后立马忘，这是短少理论使用造成的。其实编程次要考查的还是咱们的一种思维模式，就像这个适配器模式，了解它的使用场景最重要。如果给你一个业务场景，你能在脑海中有大抵的设计思路或者解决方案，那你就曾经把握精华了。至于具体的落地，有些细节遗记也是在劫难逃，翻翻材料就会立马回到脑海中。

最初，每次遇到问题，用心总结，你会离胜利更近一步。

六、参考源码

编程文档：https://gitee.com/cicadasmile/butte-java-note

利用仓库：https://gitee.com/cicadasmile/butte-flyer-parent