SpringMvc中使用到的适配器模式

此处采用了适配器模式， 由于Controller的类型不同，有多重实现方式，那么调用方式就不是确定的，如果需要直接调用Controller方法，需要在代码中写成如下形式： 

 if(mappedHandler.getHandler() instanceof MultiActionController){
    ((MultiActionController)mappedHandler.getHandler()).xxx
 }else if(mappedHandler.getHandler() instanceof XXX){
     ...
 }else if(...){
    ...
 }
 ...

这样假设如果我们增加一个HardController,就要在代码中加入一行 if(mappedHandler.getHandler() instanceof  HardController) 
这种形式就使得程序难以维护，也违反了设计模式中的开闭原则 --  对扩展开放，对修改关闭。 

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

废话不多说还是上代码吧，为了看得清楚，就自己实现一套代码来模拟springMVC， 直接贴Spring源码容易降低关注点。 

 //定义一个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 handlerAdapters = new ArrayList();

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


     public void doDispatch(){

         //此处模拟SpringMVC从request取handler的对象，仅仅new出，可以出，
                      //不论实现何种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){
         for(HandlerAdapter adapter: this.handlerAdapters){
             if(adapter.supports(controller)){
                 return adapter;
             }
         }
         return null;
     }

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

 }

通过这个模式可以看出 开源代码 中的精妙， 我们在看框架源码时需要有目标的看，这样会找到很多自己需要学习的东西， 目前很多分析源码的帖子大部分是讲解what，how， 
以此来抛砖引玉，希望各位能够一起来讨论 “why ”

转载自：http://blog.csdn.net/w1033162186/article/details/50635348