【图解设计模式系列】The Adapter Pattern: 适配器模式

适配器模式是将一个类的接口转换成客户希望的另一个接口，从而让那些接口不兼容的类可以一起工作。

converts the interface of a class into another interface the clients expect. Adapter lets classes works together that couldn’t otherwise because of incompatible interfaces.

适配器模式包含一下三个角色：

Target(目标抽象类)：目标抽象类定义客户所需的接口，可以是一个抽象类或接口，也可以是具体类。在类适配器中，由于C#语言不支持多重继承，所以它只能是接口。
Adapter(适配器类)：它可以调用另一个接口，作为一个转换器，对Adaptee和Target进行适配。它是适配器模式的核心。
Adaptee(适配者类)：适配者即被适配的角色，它定义了一个已经存在的接口，这个接口需要适配，适配者类包好了客户希望的业务方法。

实例中的实例

在SpringMVC中，DispatcherServlet类中的doDispatch方法在查找Controller时，就用到了适配器模式。
下面我们就来简单的应用一下该设计模式。
Controller

interface Controller {
     
    void handleRequest();
}

class HttpRequestHandler implements Controller {
     
    @Override
    public void handleRequest() {
     
        System.out.println("HttpRequestHandler正在处理请求");
    }
}

class RequestMappingHandler implements Controller {
     
    @Override
    public void handleRequest() {
     
        System.out.println("RequestMappingHandler正在处理请求");
    }
}

class SimpleHandler implements Controller {
     
    @Override
    public void handleRequest() {
     
        System.out.println("SimpleHandler正在处理请求");
    }
}

HandlerAdaptor

interface HandlerAdaptor {
     

    boolean supports(Object handler);

    void handle(Object handler);
}

class HttpRequestHandlerAdapter implements HandlerAdaptor{
     
    @Override
    public boolean supports(Object handler) {
     
        return (handler instanceof HttpRequestHandler);
    }

    @Override
    public void handle(Object handler) {
     
        ((HttpRequestHandler)handler).handleRequest();
    }
}

class RequestMappingHandlerAdapter implements HandlerAdaptor {
     
    @Override
    public boolean supports(Object handler) {
     
        return (handler instanceof RequestMappingHandler);
    }

    @Override
    public void handle(Object handler) {
     
        ((RequestMappingHandler)handler).handleRequest();
    }
}

class SimpleHandlerAdapter implements HandlerAdaptor {
     
    @Override
    public boolean supports(Object handler) {
     
        return (handler instanceof SimpleHandler);
    }

    @Override
    public void handle(Object handler) {
     
        ((SimpleHandler) handler).handleRequest();
    }
}

DispatcherServlet

public class DispatcherServlet {
     

    private List<HandlerAdaptor> handlerAdaptors = new ArrayList<HandlerAdaptor>();

    public DispatcherServlet() {
     
        handlerAdaptors.add(new RequestMappingHandlerAdapter());
        handlerAdaptors.add(new HttpRequestHandlerAdapter());
        handlerAdaptors.add(new SimpleHandlerAdapter());
    }

    public HandlerAdaptor getHandler(Controller controller) {
     
        for (HandlerAdaptor adapter : this.handlerAdaptors) {
     
            if (adapter.supports(controller)) {
     
                return adapter;
            }
        }
        return null;
    }

    /**
     * 请求分发
     */
    public void doDispatch() {
     
        // 模拟SpringMVC从request取handler的对象。
        //HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

        //Controller controller = new HttpRequestHandler();
        //Controller controller = new RequestMappingHandler();
        Controller controller = new SimpleHandler();
        // 不论何种类型Controller，总是通过获取对应的适配器。
        HandlerAdaptor ha = getHandler(controller);
        // Controller处理请求
        ha.handle(controller);
    }

    public static void main(String[] args) {
     
        // 实例化DisPatcherServlet
        DispatcherServlet dispatch = new DispatcherServlet();
        // 请求处理分发
        dispatch.doDispatch();
    }
}

由于Controller的类型不同，有多种实现方式，而且调用方式是不确定，如果直接调用Controller方法，则代码中就会出现较多的if-else。因此Spring定义了一个适配接口，使得每一种Controller有一种对应的适配器实现类，让适配器代替controller执行相应的方法。这样在扩展Controller 时，只需要增加一个适配器类就完成了SpringMVC的扩展了，这就是适配器模式的精妙之处！