Jetty之HandlerWrapper与链式调用的实现

在以前读netty的代码的时候,有一个很重要的东西,那就是pipeline,在上面通过对参数的传递实现了handler的链式调用,在jetty中也涉及到链式的调用,不过它是基于装饰器模式来实现的…与netty的不一样…不过个人觉得还是netty的pipeline更加直观简洁吧…..

HanlderWrapper从类型的名字就大概知道了它是对handler的一种包装….它是jetty实现handler的链式调用的关键环节..

还是先来看看它的继承体系吧:

这里还是先从最开始的接口开始吧,abstractHandler以前已经说过了，这里就不说了。。。

那么直接来看看HandlerContainer的定义吧：

[java] view plaincopy

1. //handler的容器，用于添加以及移除handler  
2. public interface HandlerContainer extends LifeCycle  
3. {  
4.     public void addHandler(Handler handler);  //添加handler  
5.     public void removeHandler(Handler handler);  //移除handler  
6.   
7.     public Handler[] getChildHandlers();   //获取所有额handler  
8.     public Handler[] getChildHandlersByClass(Class byclass);  //获取某种类型的handler  
9.     public Handler getChildHandlerByClass(Class byclass);   //一个  
10. }  

接口的实现还是比较的简单，无非就是一些添加，移除和获取handler的方法的定义。。。

这里abstractHnalderContainer没啥用。。就不看他了。。直接来看HandlerWrapper的定义吧：

[java] view plaincopy

1. //其实这是一张装饰器模式的实现，其实这里最终也是为了实现handler的链式调用，感觉还是netty的pipeline实现更为直观简洁  
2. public class HandlerWrapper extends AbstractHandlerContainer  
3. {  
4.     private Handler _handler;  //用于内装饰的handler  
5.   
6.     public HandlerWrapper() {  
7.         super();  
8.     }  
9.   
10.     //返回内部的handler  
11.     public Handler getHandler() {  
12.         return _handler;  
13.     }  
14.     //设置handler，这里还需要在server上面激活一些事件  
15.     public void setHandler(Handler handler) {  
16.         try {  
17.             Handler old_handler = _handler;  //这里保存以前的handler  
18.               
19.             if (getServer()!=null)  
20.                 getServer().getContainer().update(this, old_handler, handler, “handler”); //这里其实相当于是激活事件  
21.               
22.             if (handler!=null) {  //设置handler所属的server  
23.                 handler.setServer(getServer());  
24.             }  
25.             _handler = handler;  //保存新设置的handler  
26.               
27.             if (old_handler!=null) {  
28.                 if (old_handler.isStarted()) //如果以前的handler是开启的，那么需要将其停止  
29.                     old_handler.stop();  
30.             }  
31.         } catch(Exception e) {  
32.             IllegalStateException ise= new IllegalStateException();  
33.             ise.initCause(e);  
34.             throw ise;  
35.         }  
36.     }  
37.   
38.     //添加一个handler，如果以前已经有handler了，那么将原来那个handler加入到这个新的handler中，类似于形成一条链  
39.     public void addHandler(Handler handler) {  
40.         Handler old = getHandler();  
41.         if (old!=null && !(handler instanceof HandlerContainer))  
42.             throw new IllegalArgumentException(“Cannot add”);  
43.         setHandler(handler);  
44.         if (old!=null) {  //如果原来的handler不是空，那么将其放到新的handler当中，让其形成一条链  
45.             ((HandlerContainer)handler).addHandler(old);  
46.         }  
47.     }  
48.       
49.     //移除handler  
50.     public void removeHandler (Handler handler) {  
51.         Handler old = getHandler();  
52.         if (old!=null && (old instanceof HandlerContainer)) {  
53.             ((HandlerContainer)old).removeHandler(handler);  
54.         } else if (old!=null && handler.equals(old)) {  
55.             setHandler(null);   
56.         } else {  
57.             throw new IllegalStateException(“Cannot remove”);  
58.         }  
59.     }  
60.       
61.       
62.     //当前组件的启动，说白了就是handler的启动  
63.     protected void doStart() throws Exception {  
64.         if (_handler!=null)  
65.             _handler.start();  
66.         super.doStart();  
67.     }  
68.       
69.    //停止当前的组件  
70.     protected void doStop() throws Exception {  
71.         super.doStop();  
72.         if (_handler!=null)  
73.             _handler.stop();  
74.     }  
75.       
76.     //处理http请求，第一个参数其实就是http请求的path，然后后面是转发类型，这个方法在子类中一般都会重载  
77.     public void handle(String target, HttpServletRequest request, HttpServletResponse response, int dispatch) throws IOException, ServletException {  
78.         if (_handler!=null && isStarted())  
79.             _handler.handle(target,request, response, dispatch);  
80.     }  
81.       
82.   
83.     //设置当前的server对象  
84.     public void setServer(Server server)  {  
85.         Server old_server=getServer();  
86.         super.setServer(server);  
87.         Handler h=getHandler();  
88.         if (h!=null)  
89.             h.setServer(server);  
90.           
91.         if (server!=null && server!=old_server)  
92.             server.getContainer().update(this, null,_handler, “handler”);  
93.     }  
94.       
95.   
96.     /* ———————————————————— */  
97.     protected Object expandChildren(Object list, Class byClass)  
98.     {  
99.         return expandHandler(_handler,list,byClass);  
100.     }  
101.   
102.      
103. }  

其实看到这里就能够看出来这就是装饰器模式的典型实现而已，，，，通过将handler一层又一层的包起来，调用的时候从外向里一层一层的调用。。。这样也就实现了handler的链式调用。。。

好了，对jetty的handler部分的一些调用有了基本的了解了，算是为以后进入更重要的内容打下了基础。。。