适配器模式

基本介绍

• 适配器模式（Adapter Pattern） 将某个类的接口转换成客户端期望的另一个接口表示，主要目的是兼容性，将原本接口不匹配不能一起工作的两个类可以协调工作，别名是包装器（Wrapper）
• 适配器模式属于结构型模式（没有产生新的对象）
• 主要有三类：类适配器模式，对象适配器模式，接口适配器模式

工作原理

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

类适配器模式

实例的UML类图

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

• java是单继承机制，所有类适配器需要继承src类，因为这要求dst必须是接口，有一定的局限性
• src类的方法在Adapter中都会暴露出来，也增加了使用成本
• 但是因为继承了src类，可以重写src类的方法，增加了灵活性
  代码演示：与对象适配器类似

对象适配器模式

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

实例UML类图

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

1、对象适配器和类适配器是同一种思想，只是实现不一样，根据合成复用原则，使用组合替代继承，解决了类适配器必须继承src的局限性问题，也不再需要dst必须是接口
2、成本更低，更加灵活
代码演示：
定义一个适配器接口，需要完成电压的转换

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

实现接口，对象适配器不继承被适配的类，而是使用组合的方式

	public class VoltageAdapter implements Voltage5V {
    private Voltage220V voltage220V;
    public VoltageAdapter(Voltage220V voltage220V){
        this.voltage220V = voltage220V;
    }
    @Override
    public int output5V() {
        int dstV = 0;
        if(null!=voltage220V){
            int srcV = voltage220V.output220V();
            System.out.println("使用对象适配器，进行适配~~");
            dstV = srcV/44;
            System.out.println("适配完成，输出电压为"+dstV);
        }
        return dstV;
    }
}

定义被适配的类

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

定义手机，包括充电操作

public class Phone {
    //传的是实现了输出五伏的接口，一般为实现类,依赖接口
    public void charging(Voltage5V v){
        if (v.output5V() == 5) {
            System.out.println("电压为五伏，开始充电");
        } else if (v.output5V() > 5) {
            System.out.println("电压大于五伏，不能充电");
        }
    }
    //测试
	public static void main(String[] args) {
        System.out.println("=======对象适配器===========");
        Phone phone = new Phone();
        phone.charging(new VoltageAdapter(new Voltage220V()));
	}
}

适配器模式在springMVC框架中的使用

通过重写springMVC的核心源码理解适配器模式
上图：

基本的思路就是：

1. 模拟请求request中的controller对象获取对应的HandlerAdapter适配器
2. 利用适配器的handler方法调用controller对象的方法，最后返回结果
   真正的SpringMVC工作流程
   
   代码实现

//定义handler接口
public interface Controller {

}
//实现接口的controller，在springMVC中一般添加注解@Controller
class HttpController implements Controller{
    public void doHttpHander(){
        System.out.println("http...");
    }
}
class  SimpleController implements Controller{
    public void doSimpleController(){
        System.out.println("simple...");
    }
}
class AnnotationController implements Controller{
    public void doAnnotationController(){
        System.out.println("annotation...");
    }
}

//定义Adapter接口
public interface HanderAdapter {
    public boolean supports(Object handler);//判断是否属于该适配器
    public void handler(Object handler);//执行handler方法
}
//适配器，每个适配器对应相应的controller
class SimpleHandlerAdapter implements  HanderAdapter{

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

    @Override
    public void handler(Object handler) {
        ((SimpleController)handler).doSimpleController();
    }
}
class HttpHandlerAdapter implements  HanderAdapter{

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

    @Override
    public void handler(Object handler) {
        ((HttpController)handler).doHttpHander();
    }
}
class AnnotationHandlerAdapter implements HanderAdapter{

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

    @Override
    public void handler(Object handler) {
        ((AnnotationController)handler).doAnnotationController();
    }
}

模拟DispatcherServlet对请求进行处理

public class DispatcherServlet {
    public static List<HanderAdapter> handerAdapters = new ArrayList<HanderAdapter>();
    //构造器
    public DispatcherServlet(){
        handerAdapters.add(new AnnotationHandlerAdapter());
        handerAdapters.add(new SimpleHandlerAdapter());
        handerAdapters.add(new HttpHandlerAdapter());
    }
    public void doDispach(){
        //此处模拟springMVC从Request 取handler的对象
        //适配器可以获取希望获取的Controller
        HttpController Controller = new HttpController();
//        SimpleController Controller = new SimpleController();
//        AnnotationController Controller = new AnnotationController();
        //得到对应的适配器
        HanderAdapter adapter =  getHandler(Controller);
        adapter.handler(Controller);
    }
    public HanderAdapter getHandler(Controller controller){
        for (HanderAdapter ha:handerAdapters
             ) {
            if(ha.supports(controller)){
                return ha;
            }
        }
        return null;
    }
    public static void main(String[] args) {
        new DispatcherServlet().doDispach();
    }
}

说明：

• Spring 定义一个适配器接口，使得每一中Controller有一种对应的适配器类
• 适配器代替Controller执行相应的方法
• 扩展Controller时，只需要增加一个适配器以及相应的controller就完成对SpringMVC的扩展