设计模式——ADAPTER

设计模式——ADAPTER

• 作者：DecaMinCow
• 博客：http://blog.csdn.net/m0_37567301
• 邮箱：decamincow#gmail.com (#->@)

使用场景

通过一个重复使用的类把没有关联的现有类（不用太关心具体实现）兼容起来

示例

对象适配器

public class Adapter {
    interface Phone {
        void readCard3G(Card3G card3G);
    }

    interface Card3G {
        void server();
    }

    static class Card3Gimpl implements Card3G {

        @Override
        public void server() {
            System.out.println("3G server");
        }
    }

    static class PhoneImpl implements Phone {

        @Override
        public void readCard3G(Card3G card3G) {
            card3G.server();
        }
    }

    /**
     * 搞个4G卡
     */
    static class Card4Gimpl implements Card3G {

        @Override
        public void server() {
            System.out.println("4G server");
        }
    }


    static class CardAdapter implements Card3G {

        Card3G card;

        CardAdapter(Card3G card) {
            this.card = card;
        }

        @Override
        public void server() {
            card.server();
        }
    }

    public static void main(String[] args) {

        /**
         * 只支持 3G 卡
         */
        Card3G card3G = new Card3Gimpl();
        Phone phone = new PhoneImpl();
        phone.readCard3G(card3G);

        /**
         * 以前的基础上适配一下 4G
         */
        Card3G card4G = new CardAdapter(new Card4Gimpl());
        phone.readCard3G(card4G);

    }

}

接口适配器主要是防止代码臃肿

    /**
     * 接口适配器
     */
    interface Functions {
        void a();
        void b();
        void c();
        void d();

    }

    abstract class FunctionABAdapter implements Functions {
        @Override
        public void a() {
        }

        @Override
        public void b() {
        }

    }
    
    class FunctionAB extends FunctionABAdapter {

        @Override
        public void c() {
            
        }

        @Override
        public void d() {

        }
    }

网上找的一段模拟 springmvc 中的适配器

由于 Controller 的类型不同，有多重实现方式，那么调用方式就不是确定的
这样假设如果我们增加一个 HardController,就要在代码中加入一行 if(mappedHandler.getHandler() instanceof HardController)
这种形式就使得程序难以维护，也违反了设计模式中的开闭原则 – 对扩展开放，对修改关闭。

因此 Spring 定义了一个适配接口，使得每一种 Controller 有一种对应的适配器实现类，
让适配器代替 Controller 执行相应的方法。这样在扩展 Controller 时，只需要增加一个适配器类就完成了 SpringMVC 的扩展了

//定义一个Adapter接口  
public interface HandlerAdapter {  
    public boolean supports(Object handler);  
    public void handle(Object handler);  
}  

//以下是三种Controller实现  
public interface Controller {  

}  

public class HttpController implements Controller{  
    public void doHttpHandler(){  
        System.out.println("http...");  
    }  
}  

public class SimpleController implements Controller{  
    public void doSimplerHandler(){  
        System.out.println("simple...");  
    }  
}  

public class AnnotationController implements Controller{  
    public void doAnnotationHandler(){  
        System.out.println("annotation...");  
    }  
}  


//下面编写适配器类  

public class SimpleHandlerAdapter implements HandlerAdapter {  


    public void handle(Object handler) {  
        ((SimpleController)handler).doSimplerHandler();  
    }  

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

}  


public class HttpHandlerAdapter implements HandlerAdapter {  

    public void handle(Object handler) {  
        ((HttpController)handler).doHttpHandler();  
    }  

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

}  



public class AnnotationHandlerAdapter implements HandlerAdapter {  

    public void handle(Object handler) {  
        ((AnnotationController)handler).doAnnotationHandler();  
    }  

    public boolean supports(Object handler) {  

        return (handler instanceof AnnotationController);  
    }  

}  


//模拟一个DispatcherServlet  
import java.util.ArrayList;  
import java.util.List;  


public class DispatchServlet {  

    public static List<HandlerAdapter> handlerAdapters = new ArrayList<HandlerAdapter>();   

    public DispatchServlet(){  
        handlerAdapters.add(new AnnotationHandlerAdapter());  
        handlerAdapters.add(new HttpHandlerAdapter());  
        handlerAdapters.add(new SimpleHandlerAdapter());  
    }  


    public void doDispatch(){  

        SimpleController controller = new SimpleController();  
        //得到对应适配器  
        HandlerAdapter adapter = getHandler(controller);  
        //通过适配器执行对应的controller对应方法  
        adapter.handle(controller);  

    }  

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

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

}