浅析Tomcat的Pipeline-Value

Pipeline-Value处理模式

Pipeline-Value主要是用来处理tomcat的内容的，并由四个层次组成分别是StandardEngineValue、StandardHostValue、StandardContextValue和StandardWrappperValue。

      Pipeline-Value是责任链模式，责任链模式是指在一个请求处理的过程中有多个矗立着依次对请求进行处理，每个处理者负责做好自己相应的处理，处理完成之后将处理后的请求返回，让下一个处理者继续处理。就好像驾车的过程中会遇到交警检查，Pipeline相当于每次开车的过车，Value相当于交警。

      不过Pipeline-Value的管道模型和普通的责任链模式稍微有点不同，区别有两点，1.每次的Pipeline都有特定的Value，而且是在管道的最后一个执行的，这个Value叫BaseValue，BaseValue是不可删除的，2.在上层管道容器的BaseValue会调用下层的管道，4个容器的BaseValue分别是StandardEngineValue、StandardHostValue、StandardContextValue和StandardWrappperValue。

      Filter中用到的FilterChain其实就是这种模式，FilterChain相当于Pipline，每个Filter都相当于一个Value，Servlet相当于最后的BaseValue。

 

pipeline-value处理流程图

Pipeline-Value的实现方法

      Pipeline管道的实现分为生命周期管理和处理请求两部分，下面分别介绍

      Pipeline管道生命周期的实现方法

      Container中的Pipeline在抽象实现类ContainerBase中定义，并在生命周期的startInternal、stopInternal、destroyInternal方法中调用管道的相应生命周期方法

Container的4个容器都继承自ContainerBase，所以4个容器在执行生命周期的方法时都会调用管道的生命周期方法。

protected synchronized void startInternal() throws LifecycleException {
        Valve current = this.first;
        if(current == null) {
            current = this.basic;
        }

        for(; current != null; current = current.getNext()) {
            if(current instanceof Lifecycle) {
                ((Lifecycle)current).start();
            }
        }

        this.setState(LifecycleState.STARTING);
    }

    protected synchronized void stopInternal() throws LifecycleException {
        this.setState(LifecycleState.STOPPING);
        Valve current = this.first;
        if(current == null) {
            current = this.basic;
        }

        for(; current != null; current = current.getNext()) {
            if(current instanceof Lifecycle) {
                ((Lifecycle)current).stop();
            }
        }

    }

    protected void destroyInternal() {
        Valve[] valves = this.getValves();
        Valve[] arr$ = valves;
        int len$ = valves.length;

        for(int i$ = 0; i$ < len$; ++i$) {
            Valve valve = arr$[i$];
            this.removeValve(valve);
        }

    }
public Valve[] getValves() {
        ArrayList valveList = new ArrayList();
        Valve current = this.first;
        if(current == null) {
            current = this.basic;
        }

        while(current != null) {
            valveList.add(current);
            current = current.getNext();
        }

        return (Valve[])valveList.toArray(new Valve[0]);
    }

Pipeline管道处理请求的实现方法

      Pipeline调用所包含的Value的invoke方法来处理请求，并且在BaseValue里又调用了子容器的Pipeline所包含的Value的invoke，直到最后的Wrapper的Pipeline所包含的Base-Value——StandardWrapperValue。

Connector在接收到请求后会调用最顶层容器的Pipeline来处理，顶层容器的Pipeline处理完之后就会在其BaseValue里调用下层容器的Pipeline进行处理，这样就可以进行逐层的Pipeline来处理了（此处应用到队列）。Engine的BaseValue是StandardEngineValue，它的invoke代码如下：

public final void invoke(Request request, Response response) throws IOException, ServletException {
        Host host = request.getHost();
        if(host == null) {
            response.sendError(400, sm.getString("standardEngine.noHost", new Object[]{request.getServerName()}));
        } else {
            if(request.isAsyncSupported()) {
                request.setAsyncSupported(host.getPipeline().isAsyncSupported());
            }

            host.getPipeline().getFirst().invoke(request, response);
        }
    }

这里的实现，首先从request中获取到Host，然后调用其管道的第一个Value的invoke方法进行处理，Host的BaseValue也同样会调用Context的Pipeline，Context的BaseValue会调用Wrapper的Pipeline，Wrapper的Pipeline最后会在其BaseValue（Standard-WrapperValue）中创建FilterChain并调用其doFilter方法来处理请求，FilterChain包含着我们配置的请求相匹配的Filter和Servlet，其doFilter方法会一次调用所有的Filter的diFilter方法和servlet的service方法，Filter和Servlet实际处理请求的方法在Wrapper的管道Pipeline的BaseValue——Stadard-WrapperValue中调用，生命周期相关的方法是在Wrapper的实现类StandardWrapper中调用的