Java设计模式之 [5] 结构型模式 - 适配器模式

简介

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

适配器模式工作原理

1.适配器模式:将一个类的接口转换为另外一个接口,让原本接口不兼容的类可以兼容
2.从用户的角度看不到适配者,是解耦和的
3.用户调用适配器转换出来的目标接口方法,适配器再调用被适配者的相关接口方法
4.用户收到反馈结果,感觉只是和目标接口交互,如图

适配器

现实生活中旅游使用插座的问题

泰国使用的是两孔(欧标)的,可以买个多功能转换插头(适配器),这样就可以使用了.

类适配器模式

基本介绍

Adapter 类,通过继承 src 类,实现 dst 接口,完成 src -> dst 的适配

类适配器模式应用实例

1.应用实例说明
以生活中充电器的例子讲解适配器.充电器本身相当于 Adapter ,220V交流电相当于适配者(src),我们的目的是5V直流电(dst)
2.思路分解图解(类图)

类图

3.代码实现

//被适配的类
public class Voltage220V {
    public int output220V() {
        int src = 220;
        System.out.println("现在电压是 : " + src + " V");
        return src;
    }
}

//适配的的接口
public interface IVoltage5V {
    public int output5V();
}

public class VoltageAdapter extends Voltage220V implements IVoltage5V {

    @Override
    public int output5V() {
        int src = output220V();
        int dstV = src / 44; //转成 5 V
        return dstV;
    }
    
}

public class Phone {
    // 充电
    public void charging(IVoltage5V iVoltage5V) {
        if (iVoltage5V.output5V() == 5) {
            System.out.println("可以充电");
        } else if (iVoltage5V.output5V() > 5) {
            System.out.println("电压大于5V B不能充电");
        }
    }
}

测试类

public class Client {
    public static void main(String[] args) {
        System.out.println("适配器模式");
        Phone phone = new Phone();
        phone.charging(new VoltageAdapter());
    }
}

打印

适配器模式
现在电压是 : 220 V
可以充电

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

1.Java是单继承机制,所以类适配器需要继承src类这一点是一个缺点.因为这要求dst必须是接口,有一定的局限性
2.src类的方法再Adapter中都会暴漏出来,也增加了使用的成本
3.由于其继承src类,所以它可以根据需求重写src类的方法,使得Adapter的灵活性增强了

对象适配器模式

基本介绍

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

应用案例

1.类图

类图

2.代码实现 因为代码和之前的大部分类似 所以我这里是添加修改部分的代码

public class VoltageAdapter extends Voltage220V implements IVoltage5V {

    private Voltage220V voltage220v; // 关联关系

    // 通过构造器 ,传入一个 Voltage220V 实例
    public VoltageAdapter(Voltage220V voltage220v) {
        this.voltage220v = voltage220v;
    }

    @Override
    public int output5V() {
        int dst = 0;
        if (null != voltage220v) {
            int src = voltage220v.output220V();
            System.out.println("使用对象适配器,进行适配");
            dst = src / 44;
            System.out.println("适配成功,输出电压为:" + dst);
        }
        return dst;
    }

}

测试

public class Client {
    public static void main(String[] args) {
        System.out.println("适配器模式");
        Phone phone = new Phone();
        phone.charging(new VoltageAdapter(new Voltage220V()));
    }
}

打印结果

适配器模式
现在电压是 : 220 V
使用对象适配器,进行适配
适配成功,输出电压为:5
可以充电

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

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

接口适配器模式

介绍

1.一些书籍称为:适配器模式或者缺省适配器模式
2.当不需要全部实现接口提供的方法时候,可先设计一个抽象类实现接口.并为该接口中每个方法提供一个默认方法(空方法),那么抽象类的子类可有选择的覆盖父类的某些方法来实现需求
3.适用于一个接口不想使用其所有的方法的情况
代码实现

public interface Interface4 {
    public void m1();
    public void m2();
    public void m3();
    public void m4();
}

//在 AbsA 空实现
public abstract class AbsA implements Interface4 {
    public void m1() {

    }

    public void m2() {

    }

    public void m3() {

    }

    public void m4() {

    }
}

public class Client {
    public static void main(String[] args) {
        AbsA a = new AbsA() {
            @Override
            public void m1() {
                super.m1();
                System.out.println("使用了m1的方法");
            }
        };
        a.m1();
    }
}

打印结果

使用了m1的方法

适配器设计模式在SpringMVC框架应用的源码分析

1.SpringMVC中的HandlerAdapter,就是使用了适配器模式
2.SpringMVC处理请求的流程回顾
3.使用HandlerAdapter的原因分析
可以看到处理器的类型不同,有多重实现方式,那么调用方式就不是确定的,如果需要直接调用Controller方法,需要调用的时候就得不断使用if else 来进行判断哪一种子类然后执行,那么后面要拓展Controller,就要修改原来的代码,这样就违背了OCP原则
4.手写SpringMVC通过适配器模式获取到对应的Controller的源码
类图

类图

代码

//多种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...");
    }
}

///定义一个Adapter接口 
public interface HandlerAdapter {
    public boolean supports(Object 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);
    }
}

public class DispatchServlet {

    public static List handlerAdapters = new ArrayList();

    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;
    }

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

}

打印结果

http...

说明:

1.Spring定义了一个接口,使得每一种Controller有一种对应的适配器实现类
2.适配器代替Controller执行响应的方法
3.拓展Controller时候,只需要增加一个适配器类就完成对SpringMVC的拓展了
4.这就是设计模式的力量

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

1.三种命名方式,是根据src是以怎样的形式给Adapter(在Adapter里面的形式)来命名的
2.类适配器:以类给到.在Adapter;里,就是将src作为类,继承
对象适配器:以对象给到,在Adapter里面,将src作为一个对象,持有
接口适配器:以接口给到,在Adapter里面,将src作为一个接口,实现
3.Adaoter模式最大的作用是将原本不兼容的接口融合在一起工作
4.实际开发中,实现起来不拘泥与现在所说的三种经典方式