设计模式——适配器模式

结构型设计模式

结构型模式(structural pattern)描述如何将类或者对象结合在一起形成更大的结构，就像搭积木，可以通过简单积木的组合形成复杂的、功能更为强大的结构。

结构型模式可以分为类结构型模式和对象结构型模式：

类结构型模式关心类的组合，由多个类可以组合成一个更大的 系统，在类结构型模式中一般只存在继承关系和实现关系。

对象结构型模式关心类与对象的组合，通过关联关系使得在一 个类中定义另一个类的实例对象，然后通过该对象调用其方法。 根据“合成复用原则”，在系统中尽量使用关联关系来替代继 承关系，因此大部分结构型模式都是对象结构型模式。

概念

gof是这样给适配器模式(adapter)定义的：将一个类的接口转化成用户需要的另外一个接口。adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。（类比旅行插座转换器）

因此，当一个接口不满足现在的代用规则时，我们可以考虑使用适配器模式，添加一个适配器类来兼容接口调用。

适配器模式结构图

适配器模式包含如下角色：

target：目标抽象类

adapter：适配器类

adaptee：适配者类

client：客户类

　如图所示，client不能直接访问adaptee。adapter是适配器，它将adaptee转换成client能访问的接口。所以通过适配器adapter，用户端就可以访问adaptee。target是提供出去的接口类。

ps：对比适配器系统的话，target就是提供出去的adapterx.routerx.servicex这个接口，adapter就是配置的各种sql转换，adaptee就是各种被调系统。

代码示例

下面用具体代码来体验下适配器模式的具体写法。这里采用手机充电的列子，我们定义一个适配器，该适配器的功能就是使用安卓充电器给苹果设备充电。

先定义接口：

/**
 * microusb充电器接口
 */
public interface microusbinterface {
    public void chargewithmicrousb();
}

/**
 * lightning充电器接口
 */
public interface lightninginterface {
    public void chargewithlightning();
}

定义具体的实现类

/**
 * 安卓设备的充电器
 */
public class androidcharger implements microusbinterface {
    @override
    public void chargewithmicrousb() {
        system.out.println("使用microusb型号的充电器充电...");
    }
}

/**
 * 苹果设备的充电器
 */
public class applecharger implements lightninginterface {
    @override
    public void chargewithlightning() {
        system.out.println("使用lightning型号的充电器充电...");
    }
}

因为我们要使用适配器模式将microusb转成lightning，所以这里的applecharger是本来不需要定义的。因为我们使用适配器的目的就是代替新建一个他。这里定义出来是为了使例子更加完整。

定义两个手机

public class iphone6plus {

    private lightninginterface lightninginterface;

    public iphone6plus() {
    }

    public iphone6plus(lightninginterface lightninginterface) {
        this.lightninginterface = lightninginterface;
    }

    public void charge() {
        system.out.println("开始给我的iphone6plus手机充电...");
        lightninginterface.chargewithlightning();
        system.out.println("结束给我的iphone6plus手机充电...");
    }

    public lightninginterface getlightninginterface() {
        return lightninginterface;
    }

    public void setlightninginterface(lightninginterface lightninginterface) {
        this.lightninginterface = lightninginterface;
    }
}

public class galaxys7 {

    private microusbinterface microusbinterface;

    public galaxys7() {
    }

    public galaxys7(microusbinterface microusbinterface) {
        this.microusbinterface = microusbinterface;
    }

    public void charge(){
        system.out.println("开始给我的galaxys7手机充电...");
        microusbinterface.chargewithmicrousb();
        system.out.println("开始给我的galaxys7手机充电...");
    }

    public microusbinterface getmicrousbinterface() {
        return microusbinterface;
    }

    public void setmicrousbinterface(microusbinterface microusbinterface) {
        this.microusbinterface = microusbinterface;
    }
}

这里定义手机的作用是为了更方便的理解适配器模式，在该模式中他不扮演任何角色。

定义适配器

/**
 * 适配器,将microusb接口转成lightning接口
 */
public class adapter implements lightninginterface {
    private microusbinterface microusbinterface;

    public adapter() {
    }

    public adapter(microusbinterface microusbinterface) {
        this.microusbinterface = microusbinterface;
    }

    @override
    public void chargewithlightning() {
        microusbinterface.chargewithmicrousb();
    }

    public microusbinterface getmicrousbinterface() {
        return microusbinterface;
    }

    public void setmicrousbinterface(microusbinterface microusbinterface) {
        this.microusbinterface = microusbinterface;
    }
}

该适配器的功能是把一个microusb转换成lightning。实现方式是实现目标类的接口（lightninginterface），然后使用组合的方式，在该适配器中定义microusb。然后在重写的chargewithlightning（）方法中，采用microusb的方法来实现具体细节。

定义客户端

public class main {

    public static void main(string[] args) {
        iphone6plus iphone6plus = new iphone6plus(new applecharger());
        iphone6plus.charge();

        system.out.println("==============================");

        galaxys7 galaxys7 = new galaxys7(new androidcharger());
        galaxys7.charge();

        system.out.println("==============================");

        adapter adapter  = new adapter(new androidcharger());
        iphone6plus newiphone = new iphone6plus();
        newiphone.setlightninginterface(adapter);
        newiphone.charge();
    }
}

输出结果：

开始给我的iphone6plus手机充电...
使用lightning型号的充电器充电...
结束给我的iphone6plus手机充电...
==============================
开始给我的galaxys7手机充电...
使用microusb型号的充电器充电...
开始给我的galaxys7手机充电...
==============================
开始给我的iphone6plus手机充电...
使用microusb型号的充电器充电...
结束给我的iphone6plus手机充电...

上面的例子通过适配器，把一个microusb型号的充电器用来给iphone充电。从代码层面，就是通过适配器复用了microusb接口及其实现类。在很大程度上福永了已有的代码。

具体实现

• inputstreamreader
• outputstreamwriter

优缺点

优点

将目标类和适配者类解耦，通过引入一个适配器类来重用现有的适配者类，而无须修改原有代码。

增加了类的透明性和复用性，将具体的实现封装在适配者类中，对于客户端类来说是透明的，而且提高了适配者的复用性。

灵活性和扩展性都非常好，通过使用配置文件，可以很方便地更换适配器，也可以在不修改原有代码的基础上增加新的适配器类，完全符合“开闭原则”。

缺点

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

对于类适配器而言，由于 java 至多继承一个类，所以至多只能适配一个适配者类，而且目标类必须是抽象类

总结

结构型模式描述如何将类或者对象结合在一起形成更大的结构。

适配器模式用于将一个接口转换成客户希望的另一个接口，适配器模式使接口不兼容的那些类可以一起工作，其别名为包装器。适配器模式既可以作为类结构型模式，也可以作为对象结构型模式。

适配器模式包含四个角色：

目标抽象类定义客户要用的特定领域的接口；

适配器类可以调用另一个接口，作为一个转换器，对适配者和抽象目标类进行适配，它是适配器模式的核心；

适配者类是被适配的角色，它定义了一个已经存在的接口，这个接口需要适配；

在客户类中针对目标抽象类进行编程，调用在目标抽象类中定义的业务方法。

在对象适配器模式中，适配器类继承了目标抽象类(或实现接口)并定义了一个适配者类的对象实例，在所继承的目标抽象类方法中调用适配者类的相应业务方法。

适配器模式的主要优点是将目标类和适配者类解耦，增加了类的透明性和复用性，同时系统的灵活性和扩展性都非常好，更换适配器或者增加新的适配器都非常方便，符合“”；类适配器模式的缺点是适配器类在很多编程语言中不能同时适配多个适配者类，对象适配器模式的缺点是很难置换适配者类的方法。

适配器模式适用情况包括：系统需要使用现有的类，而这些类的接口不符合系统的需要；想要建立一个可以重复使用的类，用于与一些彼此之间没有太大关联的一些类一起工作。

参考资料

• 适配器模式