9.设计模式之适配器模式

前言

适配器模式是我们在很多框架中会见到的设计模式。它主要解决的是两种接口不兼容而不能一起使用的问题。通过适配器，将原来的接口适配成目标接口，在不改动老代码的同时，实现两者同时使用。生活中常见的例子比如手机电源充电适配器。

本节，我们就适配器模式，做详细介绍。

1. 适配器中的角色：

1.1 目标（Target）接口：

当前系统业务所期待的接口，它可以是抽象类或接口。

1.2 适配者（Adaptee）类：

它是被访问和适配的现存组件库中的组件接口。

1.3 适配器（Adapter）类：

它是一个转换器，通过继承或引用适配者的对象，把适配者接口转换成目标接口，让客户按目标接口的格式访问适配者。

2. 代码示例

在适配器设计模式讲解中，最常见的案例是电压转换的案例，即我们国家电网常用电压是220V,但是我们手机可接收的电压一般是5V,那么如果想要充电，就需要将220V电压转换为5V。我们手机的电源适配器就承担了这个角色。下面，我们同样以这个案例，看看在java中怎么实现电压适配充电。

2.1 类适配器

2.1.1 定义目标接口

package com.wanlong.design_pattern.structure.adpter;

/**
 * @author wanlong
 * @version 1.0
 * @description: 目标接口，手机能接收的是5V
 * @date 2022/9/15 11:09
 */
public interface IVoltage5V {

    int output5V();

}

2.1.2 定义适配者类

package com.wanlong.design_pattern.structure.adpter;
/**
 * @author wanlong
 * @version 1.0
 * @description: 适配者类
 * @date 2022/9/15 11:08
 */
public class Voltage220V {

    public int output220V() {
        int src = 220;
        System.out.println("电压为" + src + "伏");
        return src;
    }
}

2.1.3 定义适配器

package com.wanlong.design_pattern.structure.adpter;

/**
 * @author wanlong
 * @version 1.0
 * @description:
 * @date 2022/9/15 11:10
 */
public class VoltageAdapter extends Voltage220V implements IVoltage5V {

    @Override
    public int output5V() {
        //调用Voltage220V里的方法得到220V
        int srcV = output220V();
        //把220V转换成5V并输出
        int dstV = srcV / 44;
        return dstV;
    }
}

2.1.4 定义手机类

package com.wanlong.design_pattern.structure.adpter;

/**
 * @author wanlong
 * @version 1.0
 * @description:
 * @date 2022/9/15 11:11
 */
public class Phone {

    public void charging(IVoltage5V iVoltage5V) {
        if (iVoltage5V.output5V() == 5) {
            System.out.println("适配后的电压5V，可以充电");
        } else {
            System.out.println("适配后的电压异常，不能充电");
        }
    }
}

2.1.5 客户端调用模拟充电

@Test
public void testClazzAdapter() {
    System.out.println("测试类适配器模式：");
    Phone phone = new Phone();
    phone.charging(new VoltageAdapter());
}

代码输出结果：
测试类适配器模式：
电压为220伏
适配后的电压5V，可以充电

2.1.6 注意事项

1. Java是单继承机制，所以类适配器需要继承适配者类这一点算是一个缺点，因为这要求目标必须是接口(继承了适配者，就不能继承目标，所以目标必须是接口)，有一定局限性;
2. 适配者类的方法在Adapter（适配器）中都会暴露出来，也增加了使用的成本。
3. 由于其继承了适配者类，所以它可以根据需求重写适配者类的方法，使得Adapter（适配器）的灵活性增强了。

2.2 对象适配器

2.2.1 定义对象适配器

package com.wanlong.design_pattern.structure.adpter;

/**
 * @author wanlong
 * @version 1.0
 * @description: 对象适配器
 * 1、对象适配器和类适配器其实算是同一种思想，只不过实现方式不同。
 * 根据合成复用原则，使用组合替代继承，所以它解决了类适配器必须继承适配者的局限性问题，也不再要求目标必须是接口。
 * 2、使用成本更低，更灵活。
 * @date 2022/9/15 11:10
 */
public class VoltageObjectAdapter implements IVoltage5V {

    private Voltage220V voltage220V;

    @Override
    public int output5V() {
        int dstV = 0;
        if (voltage220V != null) {
            //调用Voltage220V里的方法得到220V
            int srcV = voltage220V.output220V();
            //把220V转换成5V并输出
            dstV = srcV / 44;
        }
        return dstV;
    }

    public Voltage220V getVoltage220V() {
        return voltage220V;
    }

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

2.2.2 客户端调用模拟充电

@Test
public void testObjectAdapter() {
    System.out.println("测试对象适配器模式：");
    Phone phone = new Phone();
    VoltageObjectAdapter voltageObjectAdapter = new VoltageObjectAdapter();
    voltageObjectAdapter.setVoltage220V(new Voltage220V());
    phone.charging(voltageObjectAdapter);
}

代码运行结果：
测试对象适配器模式：
电压为220伏
适配后的电压5V，可以充电

2.2.3 注意事项

1. 基本思路和类的适配器模式相同，只是将Adapter类作修改，不是继承适配者类，而是持有适配者类的实例，以解决兼容性的问题。即：持有适配者类，实现目标接口，完成适配者->目标接口的适配
2. 根据“合成复用原则”，在系统中尽量使用关联关系来替代继承关系。
3. 对象适配器模式是适配器模式常用的一种

2.3 接口适配器

当我们目标接口定义多个方法，但是我们只想实现其中部分方法的时候。可以使用接口适配器这种模式。

2.3.1 定义目标接口

package com.wanlong.design_pattern.structure.adpter;

/**
 * @author wanlong
 * @version 1.0
 * @description: 定义目标接口，假设包含四个方法
 * @date 2022/9/15 11:20
 */
public interface InterFace4 {

    void m1();

    void m2();

    void m3();

    void m4();
}

2.3.2 定义适配器

package com.wanlong.design_pattern.structure.adpter;

/**
 * @author wanlong
 * @version 1.0
 * @description: 定义抽象类，实现接口所有方法，但是方法置空，具体要实现哪个方法，交给子类实现
 * @date 2022/9/15 11:20
 */
public abstract class AbstractClazz implements InterFace4 {

    @Override
    public void m1() {

    }

    @Override
    public void m2() {

    }

    @Override
    public void m3() {

    }

    @Override
    public void m4() {

    }
}

2.3.3 定义具体实现类

package com.wanlong.design_pattern.structure.adpter;

/**
 * @author wanlong
 * @version 1.0
 * @description: 子类决定实现哪些方法
 * @date 2022/9/15 11:21
 */
public class BaseClazz extends AbstractClazz {

    @Override
    public void m1() {
        System.out.println("重写了m1方法");
    }
}

2.3.4 客户端模拟调用

@Test
public void testInterFaceAdapter() {
    System.out.println("测试接口适配器模式：");
    BaseClazz baseClazz = new BaseClazz();
    baseClazz.m1();
}

代码运行结果：

测试接口适配器模式：
重写了m1方法

2.3.5 注意事项

1. 一些书籍称为：适配器模式(Default Adapter Pattern)或缺省适配器模式。
2. 当不需要全部实现接口提供的方法时，这时我们可以使用一个抽象类作为中间件，即适配器，用这个抽象类实现接口，而在抽象类中所有的方法都进行置空，那么我们再创建抽象类的继承类，而且重写我们需要使用的那几个方法即可。
3. 接口适配器适用于一个接口不想使用其所有的方法的情况。

3. 总结

3.1优缺点

3.1.1 优点：

1. 客户端通过适配器可以透明地调用目标接口。
2. 复用了现存的类，程序员不需要修改原有代码而重用现有的适配者类。
3. 将目标类和适配者类解耦，解决了目标类和适配者类接口不一致的问题。
4. 在很多业务场景中符合开闭原则。

3.1.2 缺点：

1. 适配器编写过程需要结合业务场景全面考虑，可能会增加系统的复杂性。
2. 增加代码阅读难度，降低代码可读性，过多使用适配器会使系统代码变得凌乱。

3.2 使用场景

1. 经常用来做旧系统改造和升级，如果我们的系统开发之后再也不需要维护，那么很多模式都是没必要的，但是不幸的是，事实却是维护一个系统的代价往往是开发一个系统的数倍。
2. jdk类库中的java.io.InputStreamReader(InputStream)，java.io.OutputStreamWriter(OutputStream)
3. springMVC的handlerAdapter
4. mybatis的日志打印Log

以上，本人菜鸟一枚，如有问题，请不吝指正。