tomcat 7 源码分析-13 处理request的Valve和Valve的链表Pipeline

tomcat 7 源码分析-13 处理request的Valve和Valve的链表Pipeline

 

tomcat打开endpoint的监听对通过某种协议，通常下是http的信息进行解析，组装成request，接着给Http11Protocol（ProtocolHandler）和Http11Processor处理。

Java代码  

1. adapter.service(request, response);  

adapter.service(request, response);

 

Java代码  

1. connector.getService().getContainer().getPipeline().getFirst().invoke(request, response);  

connector.getService().getContainer().getPipeline().getFirst().invoke(request, response);

 最终选择具体的Valve类处理request并生成response。

Valve和Pipeline的关系：Pipeline是valve的链表，表头是first，表尾是basic，具体的实现是StandardPipeline。

valve的实现是ValveBase及其子类。

先看ValveBase的定义

Java代码  

1. public   abstract   class  ValveBase  extends  LifecycleMBeanBase  
2.     implements  Contained, Valve {  
3.   
4.     //------------------------------------------------------ Constructor   
5.       
6.     public  ValveBase() {  
7.         this ( false );  
8.     }  
9.       
10.     public  ValveBase( boolean  asyncSupported) {  
11.         this .asyncSupported = asyncSupported;  
12.     }  
13.   
14.    ........  
15.   
16.   
17.     /**  
18.      * The next Valve in the pipeline this Valve is a component of.  
19.      */   
20.     protected  Valve next =  null ;  

public abstract class ValveBase extends LifecycleMBeanBase
    implements Contained, Valve {

    //------------------------------------------------------ Constructor
    
    public ValveBase() {
        this(false);
    }
    
    public ValveBase(boolean asyncSupported) {
        this.asyncSupported = asyncSupported;
    }

   ........


    /**
     * The next Valve in the pipeline this Valve is a component of.
     */
    protected Valve next = null;

 next就如同C和C++数据结构描述的指针，形如

Cpp代码  

1. struct  valve{  
2.   
3. valve * next  
4. };  

struct valve{

valve * next
};

 StandardPipeline的具体实现

Java代码  

1. public   class  StandardPipeline  extends  LifecycleBase  
2.         implements  Pipeline, Contained {  
3.   
4. ...............................  
5.   
6.     /**  
7.      * The basic Valve (if any) associated with this Pipeline.  
8.      */   
9.     protected  Valve basic =  null ;  
10.   
11.   
12.     /**  
13.      * The first valve associated with this Pipeline.  
14.      */   
15.     protected  Valve first =  null ;  

public class StandardPipeline extends LifecycleBase
        implements Pipeline, Contained {

...............................

    /**
     * The basic Valve (if any) associated with this Pipeline.
     */
    protected Valve basic = null;


    /**
     * The first valve associated with this Pipeline.
     */
    protected Valve first = null;

 StandardPipeline设置了两个哨兵，一个basic，一个是first。对链表的操作增加删除等，对哨兵有特殊处理的。

看个add的例子

Java代码  

1. public   void  addValve(Valve valve) {  
2.   
3.     // Validate that we can add this Valve   
4.     if  (valve  instanceof  Contained)  
5.         ((Contained) valve).setContainer(this .container);  
6.   
7.     // Start the new component if necessary   
8.     if  (getState().isAvailable()) {  
9.         if  (valve  instanceof  Lifecycle) {  
10.             try  {  
11.                 ((Lifecycle) valve).start();  
12.             } catch  (LifecycleException e) {  
13.                 log.error("StandardPipeline.addValve: start: " , e);  
14.             }  
15.         }  
16.     }  
17.   
18.     // Add this Valve to the set associated with this Pipeline   
19.     if  (first ==  null ) {  
20.         first = valve;  
21.         valve.setNext(basic);  
22.     } else  {  
23.         Valve current = first;  
24.         while  (current !=  null ) {  
25. if  (current.getNext() == basic) {  
26.     current.setNext(valve);  
27.     valve.setNext(basic);  
28.     break ;  
29. }  
30. current = current.getNext();  
31.   
32.     }  
33.       
34.     container.fireContainerEvent(Container.ADD_VALVE_EVENT, valve);  
35. }  

    public void addValve(Valve valve) {
    
        // Validate that we can add this Valve
        if (valve instanceof Contained)
            ((Contained) valve).setContainer(this.container);

        // Start the new component if necessary
        if (getState().isAvailable()) {
            if (valve instanceof Lifecycle) {
                try {
                    ((Lifecycle) valve).start();
                } catch (LifecycleException e) {
                    log.error("StandardPipeline.addValve: start: ", e);
                }
            }
        }

        // Add this Valve to the set associated with this Pipeline
        if (first == null) {
        	first = valve;
        	valve.setNext(basic);
        } else {
            Valve current = first;
            while (current != null) {
				if (current.getNext() == basic) {
					current.setNext(valve);
					valve.setNext(basic);
					break;
				}
				current = current.getNext();
			}
        }
        
        container.fireContainerEvent(Container.ADD_VALVE_EVENT, valve);
    }

 add一个元素是加在basic之前，处理pipeline的时候，是先取出first。

所以如果first==null，表面还没有pipeline种还没有元素，此时就先设置first。

不然，先找到basic以前的位置，将新的valve插入在basic之前，进行排队。

验证下可以看下面的remove操作

Java代码  

1. public   void  removeValve(Valve valve) {  
2.   
3.     Valve current;  
4.     if (first == valve) {  
5.         first = first.getNext();  
6.         current = null ;  
7.     } else  {  
8.         current = first;  
9.     }  
10.     while  (current !=  null ) {  
11.         if  (current.getNext() == valve) {  
12.             current.setNext(valve.getNext());  
13.             break ;  
14.         }  
15.         current = current.getNext();  
16.     }  
17.   
18.     if  (first == basic) first =  null ;  
19.   
20.     if  (valve  instanceof  Contained)  
21.         ((Contained) valve).setContainer(null );  
22.   
23.     // Stop this valve if necessary   
24.     if  (getState().isAvailable()) {  
25.         if  (valve  instanceof  Lifecycle) {  
26.             try  {  
27.                 ((Lifecycle) valve).stop();  
28.             } catch  (LifecycleException e) {  
29.                 log.error("StandardPipeline.removeValve: stop: " , e);  
30.             }  
31.         }  
32.     }  
33.     try  {  
34.         ((Lifecycle) valve).destroy();  
35.     } catch  (LifecycleException e) {  
36.         log.error("StandardPipeline.removeValve: destroy: " , e);  
37.     }  
38.       
39.     container.fireContainerEvent(Container.REMOVE_VALVE_EVENT, valve);  
40. }  

    public void removeValve(Valve valve) {

        Valve current;
        if(first == valve) {
            first = first.getNext();
            current = null;
        } else {
            current = first;
        }
        while (current != null) {
            if (current.getNext() == valve) {
                current.setNext(valve.getNext());
                break;
            }
            current = current.getNext();
        }

        if (first == basic) first = null;

        if (valve instanceof Contained)
            ((Contained) valve).setContainer(null);

        // Stop this valve if necessary
        if (getState().isAvailable()) {
            if (valve instanceof Lifecycle) {
                try {
                    ((Lifecycle) valve).stop();
                } catch (LifecycleException e) {
                    log.error("StandardPipeline.removeValve: stop: ", e);
                }
            }
        }
        try {
            ((Lifecycle) valve).destroy();
        } catch (LifecycleException e) {
            log.error("StandardPipeline.removeValve: destroy: ", e);
        }
        
        container.fireContainerEvent(Container.REMOVE_VALVE_EVENT, valve);
    }