7.适配器模式

Posted 2021-08-04 客官不爱喝酒

适配器模式

• • 1. 适配器模式基本介绍
  • 2.类适配器模式
  • 3.对象适配器模式
  • 5.接口适配器模式
  • 6.SpringMVC 源码
  • 7.适配器模式的注意事项

1. 适配器模式基本介绍

• 适配器模式(Adapter Pattern)将某个类的接口转换成客户端期望的另一个接口表示，主的目的是兼容性，让原本因接口不匹配不能一起工作的两个类可以协同工作。
• 适配器的别名为包装器(Wrapper)，适配器模式属于结构型模式
  主要分为三类：类适配器模式、对象适配器模式、接口适配器模式

适配器模式工作原理：

• 适配器模式：将一个类的接口转换成另一种接口，让原本接口不兼容的类可以兼容
  从用户的角度看不到被适配者，用户与被适配者是解耦的
• 用户调用适配器转化出来的目标接口方法， 适配器再调用被适配者的相关接口方法
• 用户收到反馈结果，感觉只是和目标接口交互， 如图

2.类适配器模式

类适配器模式介绍

基本介绍： 核心模块是 Adapter 类，Adapter 类，通过继承 src 类（被适配者），实现 dst 类接口（目标类），完成 src --> dst 的适配

应用实例说明

以生活中充电器的例子来讲解适配器，充电器本身相当于Adapter， 220V交流电相当于src (即被适配者)， 我们的dst(即目标)是5V直流电

代码实现：

Voltage220V：src类，输出 220V 的电压

/**
 * @author compass
 * @version 1.0
 * @date 2021-07-07 19:13
 */
public class Voltage220V {

    public int outPut220V(){

        int src=220;
        return src;
    }
}

Voltage5V：适配器接口（dst 接口），规定适配器的规范

/**
 * @author compass
 * @version 1.0
 * @date 2021-07-07 19:13
 */
public interface Voltage5V {

      int outPut5v();

}

VoltageAdapter：适配器，继承了 Voltage220V 并实现了 Voltage5V 接口

/**
 * @author compass
 * @version 1.0
 * @date 2021-07-07 19:14
 */
public class VoltageAdapter extends Voltage220V implements Voltage5V{
    @Override
    public int outPut5v() {
        // 调用父类的方法并且进行改进然后再返回供其他调用者使用
        return  outPut220V()/44;
    }
}

Phone：使用 5V 适配器进行充电

/**
 * @author compass
 * @version 1.0
 * @date 2021-07-07 19:14
 */
public class Phone {

    public void charging(Voltage5V v){

        if (v.outPut5v()==5){
            System.out.println("电压为5V, 可以充电");
        }else if (v.outPut5v()>5){
            System.out.println("电压大于5V, 不可以充电");
        }


    }
}

Client：客户端，进行代码测试

/** 类适配器模式：
 * @author compass
 * @version 1.0
 * @date 2021-07-07 19:12
 */
public class Client {

    public static void main(String[] args) {
        Phone phone = new Phone();
        VoltageAdapter adapter = new VoltageAdapter();
        phone.charging(adapter);
    }
}

Voltage220V 只能输出 220V的电压，我们定义一个抽象的适配器规范：Voltage5V 接口，该接口里面有一个抽象方法 int output5V();，适配器 VoltageAdapter 继承 Voltage220V 并实现 IVoltage5V 接口，可以将 220V 的电压转为 5V 电压

缺点

• Java是单继承机制，所以类适配器需要继承src类这一点算是一个缺点，因为Adapter已经继承了src类，这要求dst必须是接口，有一定局限性

• src类的方法在Adapter中都会暴露出来，也增加了使用的成本，因为src类中的方法可能很多

优点：

由于其继承了src类，所以它可以根据需求重写src类的方法，使得Adapter的灵活性增强了

3.对象适配器模式

• 基本思路和类的适配器模式相同，只是将Adapter类作修改，不是继承src类，而是持有src类的实例，以解决兼容性的问题。
• 对象适配器模式的核心思想：适配器持有src类，实现dst类接口，完成src --> dst的适配
• 根据“合成复用原则”，在系统中尽量使用关联关系（聚合、组合）来替代继承关系。
• 对象适配器模式是适配器模式常用的一种

应用实例说明

以生活中充电器的例子来讲解适配器，充电器本身相当于Adapter， 220V交流电相当于src (即被适配者)， 我们的dst(即目标)是5V直流电， 使用对象适配器模式完成
跟上面的差不多，只是把继承改为了其他的实现方式。,只修改VoltageAdapter和Client即可

VoltageAdapter：适配器，VoltageAdapter 中聚合了一个 Voltage220V 类的对象，并实现了 IVoltage5V 接口

/**
 * @author compass
 * @version 1.0
 * @date 2021-07-07 19:14
 */
public class VoltageAdapter   implements Voltage5V {

    private  Voltage220V v=null;

    // 不用继承改用构造方法和setter方法进行完成
    public VoltageAdapter(Voltage220V voltage220V) {
        this.v = voltage220V;
    }

    public void setVoltage220V(Voltage220V voltage220V) {
        this.v = voltage220V;
    }

    @Override
    public int outPut5v() {
        // 调用父类的方法并且进行改进然后再返回供其他调用者使用
        return  v.outPut220V()/44;
    }
}

Client：客户端，进行代码测试，创建适配器 VoltageAdapter 时，注入 src 类实例：new Voltage220V()

/** 对象适配器模式：
 * @author compass
 * @version 1.0
 * @date 2021-07-07 19:12
 */
public class Client {

    public static void main(String[] args) {
        Phone phone = new Phone();
        VoltageAdapter adapter = new VoltageAdapter(new Voltage220V());
        phone.charging(adapter);
    }
}

总结

• 与类适配器模式相比，对象适配器模式中，适配器 Adapter 没有使用继承关系，而是使用聚合关系，在适配器 Adapter 中聚合了一个 src 类实例，相同的是 Adapter 实现适配器接口（dst接口），在 Adapter 中实现 dst 接口中的抽象方法，然后使用 src 类实例和完成适配（转换）

• 对象适配器模式注意事项和细节

• 对象适配器和类适配器其实算是同一种思想，只不过实现方式不同。根据合成复用原则， 使用组合替代继承， 所以它解决了类适配器必须继承src的局限性问题，也不再要求dst必须是接口。对象适配器的使用成本更低，更灵活

5.接口适配器模式

• 一些书籍称为：适配器模式(Default Adapter Pattern)或缺省适配器模式
• 核心思想：当不需要全部实现接口提供的方法时，可先设计一个抽象类实现接口，并为该接口中每个方法提供一个默认实现（空方法），那么该抽象类的子类可有选择地覆盖父类的某些方法来实现需求
• 适用于一个接口的实现类不想使用其所有的方法的情况

userDao：提供一些方法。由实现类去实现

/**
 * @author compass
 * @version 1.0
 * @date 2021-07-07 20:07
 */
public interface UserDao {

    Object select();

    int delete(int id);

    int add(Object object);
}

AbstractUserDao: 实现UserDao中的所有方法，但是不做任何逻辑，空实现

/**
 * @author compass
 * @version 1.0
 * @date 2021-07-07 20:08
 */
public abstract class AbstractUserDao implements UserDao {
    @Override
    public Object select() {
        return null;
    }

    @Override
    public int delete(int id) {
        return 0;
    }

    @Override
    public int add(Object object) {
        return 0;
    }
}

Client： 使用AbstractUserDao这个对象，使用匿名内部类的方式进行重写里面想使用的方法，加入这里我下使用add( Object obj)方法

/** 接口适配器模式
 * @author compass
 * @version 1.0
 * @date 2021-07-07 20:10
 */
public class Client {
    public static void main(String[] args) {
        AbstractUserDao userDao=  new AbstractUserDao(){
            @Override
            public int add(Object object) {
                System.out.println("执行add（）方法-->"+object);
                return 0;
            }
        };

        userDao.add("user");
    }


}

6.SpringMVC 源码

SpringMVC中的HandlerAdapter，就使用了适配器模式，SpringMVC处理请求的流程回顾：

1. 首先用户请求到达前端控制器 dispatcherServlet 的 doDispatch() 方法
2. 在 doDispatch() 中，通过 HandlerMapping 找到用户请求的 Handler（处理器）
3. 通过 Handler 执行目标方法，获得本次访问结果：ModelAndView 对象
4. 接着调用 InternalResourceViewResolve 对返回的 ModelAndView 对象进行解析，找到指定的资源
5. 目标资源（JSP 页面或者 JSON 字符串）最终都会以 JSON 字符串的形式返回给 Tomcat
6. Tomcat 将字符串 以 HTTP 协议的方式返回给浏览器

springMVC源码模拟：

• Controller:接口及其实现类

/**
 * @author compass
 * @version 1.0
 * @date 2021-07-07 21:40
 */
//多种Controller实现
public interface Controller {

}

class HttpController implements Controller {
    public void doHttpHandler() {
        System.out.println("http...");
    }
}

class SimpleController implements Controller {
    public void doSimplerHandler() {
        System.out.println("simple...");
    }
}

class AnnotationController implements Controller {
    public void doAnnotationHandler() {
        System.out.println("annotation...");
    }
}

• HandlerAdapter: 接口及其实现类

/**
 * @author compass
 * @version 1.0
 * @date 2021-07-07 21:40
 */
//定义一个Adapter接口
public interface HandlerAdapter {
    // 当前 HandlerAdapter 对象是否支持 handler（判断 handler 的类型是否为具体的子类类型）
    public boolean supports(Object handler);

    // 执行目标方法（将 handler 对象强转后，调用对应的方法）
    public void handle(Object handler);
}

// 多种适配器类
class SimpleHandlerAdapter implements HandlerAdapter {

    public void handle(Object handler) {
        ((SimpleController) handler).doSimplerHandler();
    }

    public boolean supports(Object handler) {
        return (handler instanceof SimpleController);
    }

}

class HttpHandlerAdapter implements HandlerAdapter {

    public void handle(Object handler) {
        ((HttpController) handler).doHttpHandler();
    }

    public boolean supports(Object handler) {
        return (handler instanceof HttpController);
    }

}

class AnnotationHandlerAdapter implements HandlerAdapter {

    public void handle(Object handler) {
        ((AnnotationController) handler).doAnnotationHandler();
    }

    public boolean supports(Object handler) {
        return (handler instanceof AnnotationController);
    }

}

-DispatchServlet：模拟 doDispatch() 方法中获取适配器的流程

/**
 * @author compass
 * @version 1.0
 * @date 2021-07-07 21:41
 */
public class DispatchServlet {

    public static void main(String[] args) {
        // http...
        new DispatchServlet().doDispatch();
    }


    public static List<HandlerAdapter> handlerAdapters = new ArrayList<HandlerAdapter>();

    // 组合了多个 HandlerAdapter 的实现类
    public DispatchServlet() {
        handlerAdapters.add(new AnnotationHandlerAdapter());
        handlerAdapters.add(new HttpHandlerAdapter());
        handlerAdapters.add(new SimpleHandlerAdapter());
    }

    public void doDispatch() {

        // 此处模拟SpringMVC从request取handler的对象，
        // 适配器可以获取到希望的Controller
        HttpController controller = new HttpController();

        // AnnotationController controller = new AnnotationController();
        // SimpleController controller = new SimpleController();

        // 得到对应适配器
        HandlerAdapter adapter = getHandler(controller);
        // 通过适配器执行对应的controller对应方法
        adapter.handle(controller);

    }

    public HandlerAdapter getHandler(Controller controller) {
        // 遍历：根据得到的controller(handler), 返回对应适配器
        for (HandlerAdapter adapter : this.handlerAdapters) {
            if (adapter.supports(controller)) {
                return adapter;
            }
        }
        return null;
    }


}

• 使用 HandlerAdapter 的原因分析:

1. 可以看到处理器的类型不同，有多种实现方式，那么调用方式就不是确定的，如果需要直接调用
2. Controller方法，需要调用的时候就得不断是使用if else来进行判断是哪一种子类然后执行。那么如果后面要扩展Controller，就得修改原来的代码，这样违背了OCP 原则

7.适配器模式的注意事项

适配器模式的注意事项和细节

三种命名方式，是根据src是以怎样的形式给到Adapter（在Adapter里的形式）来命名的。

• 类适配器：以类给到，在Adapter里，就是将src当做类，继承

• 对象适配器：以对象给到，在Adapter里，将src作为一个对象，持有

• 接口适配器：以接口给到，在Adapter里，将src作为一个接口，实现

• Adapter模式最大的作用还是将原本不兼容的接口融合在一起工作，相当于是个中转封装站

实际开发中，实现起来不拘泥于我们讲解的三种经典形式