管道Pipeline

处理模式

Pipeline--Valve是一种责任链模式，它和普通责任链模式有两点区别：

每个Pipeline都是有特定的Valve，而且是在管道的最后一个执行，这个Valve叫BaseValve，并且BaseValve是不可删除的；
在上层容器的管道的BaseValve中会调用下层容器的管道。

Tomcat中的管道

Tomcat按照包含关系有4个级别的容器,标准实现分别是：

StandardEngine
StandardHost
StandardContext
StandardWrapper

请求对象和响应对象分别在这4个容器之间通过管道机制进行传递。

初始化

在 server.xml 中配置阀门：

<Engine name="Catalina" defaultHost="localhost">
    <Host name="localhost"  appBase="webapps"
          unpackWARs="true" autoDeploy="true">
        <Valve className="org.apache.catalina.valves.WswAccessValve"/>
    </Host>
</Engine>

WswAccessValve

public class WswAccessValve extends ValveBase {

    @Override
    public void invoke(Request request, Response response) {
        String uri = request.getRequestURI();
        System.out.println("uri = " + uri);
        getNext().invoke(request, response);
    }
}

四个基础Valve

public StandardEngine() {
    super();
    pipeline.setBasic(new StandardEngineValve());
}

public StandardHost() {
    super();
    pipeline.setBasic(new StandardHostValve());
}

public StandardContext() {
    super();
    pipeline.setBasic(new StandardContextValve());
}

public StandardWrapper() {
    super();
    pipeline.setBasic(new StandardWrapperValve());
}

构造Valve链

// 在处理 server.xml 中配置的 Valve 时
// StandardPipeline
@Override
public void addValve(Valve valve) {
    // 验证 是否可以 绑定 容器（Engine、Host等）
    if (valve instanceof Contained)
        ((Contained) valve).setContainer(this.container);
    // 是否有必要调用 start 方法【默认没有调用，不属于LifeCycle】
    if (getState().isAvailable()) {
        if (valve instanceof Lifecycle) {
            ((Lifecycle) valve).start();
        }
    }
    // first valve == null，就设置为第一个
    if (first == null) {
        first = valve;
        valve.setNext(basic);
    } else {
        Valve current = first;
        while (current != null) {
            if (current.getNext() == basic) {
                // 按照在xml中定义的顺序+basicValve
                // 组装成链式结构，first + 新增 valve + basicValve
                current.setNext(valve);
                valve.setNext(basic);
                break;
            }
            current = current.getNext();
        }
    }
    // [没有执行]
    container.fireContainerEvent(Container.ADD_VALVE_EVENT, valve);
}

执行流程

// org.apache.catalina.connector.CoyoteAdapter
@Override
public void service(org.apache.coyote.Request req,                                                  org.apache.coyote.Response res) {
        // 此处调用 Pipeline Value 的 invoke 方法。（Engine是最顶层容器）
        connector.getService()
            .getContainer()
            .getPipeline()
            .getFirst()
            .invoke(request, response);
    }
}

// StandardPipeline
@Override
public Valve getFirst() {
    // 如果有注册Valve，就返回
    if (first != null) {
        return first;
    }
    // 返回注册的 BasicValve
    return basic;
}

// StandardEngineValve
@Override
public final void invoke(Request request, Response response) {
    // 根据 当前 request 找到合适的 host，通过 MappingData 
    Host host = request.getHost();
    // 没有匹配的 host， 直接返回
    if (host == null) {
        response.sendError
            (HttpServletResponse.SC_BAD_REQUEST,
             sm.getString("standardEngine.noHost",
                          request.getServerName()));
        return;
    }

    // 执行Host的Pipeline
    host.getPipeline().getFirst().invoke(request, response);
}

// StandardHostValve
@Override
public final void invoke(Request request, Response response) {
    Context context = request.getContext();
    if (context == null) {
        response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
                           sm.getString("standardHost.noContext"));
        return;
    }

    boolean asyncAtStart = request.isAsync();
    boolean asyncDispatching = request.isAsyncDispatching();

    try {
        context.bind(Globals.IS_SECURITY_ENABLED, MY_CLASSLOADER);

        if (!asyncAtStart && !context.fireRequestInitEvent(request.getRequest())) {
            return;
        }

        try {
            if (!asyncAtStart || asyncDispatching) {
                context.getPipeline().getFirst().invoke(request, response);
            } else {
                // Make sure this request/response is here because an error
                // report is required.
                if (!response.isErrorReportRequired()) {
                    throw new IllegalStateException(sm.getString("standardHost.asyncStateError"));
                }
            }
        } catch (Throwable t) {
            if (!response.isErrorReportRequired()) {
                request.setAttribute(RequestDispatcher.ERROR_EXCEPTION, t);
                throwable(request, response, t);
            }
        }

        response.setSuspended(false);

        Throwable t = (Throwable) request.getAttribute(RequestDispatcher.ERROR_EXCEPTION);

        // Protect against NPEs if the context was destroyed during a
        // long running request.
        if (!context.getState().isAvailable()) {
            return;
        }

        // Look for (and render if found) an application level error page
        if (response.isErrorReportRequired()) {
            if (t != null) {
                throwable(request, response, t);
            } else {
                status(request, response);
            }
        }

        if (!request.isAsync() && !asyncAtStart) {
            context.fireRequestDestroyEvent(request.getRequest());
        }
    } finally {
        if (ACCESS_SESSION) {
            request.getSession(false);
        }
        context.unbind(Globals.IS_SECURITY_ENABLED, MY_CLASSLOADER);
    }
}

// StandardContextValve
@Override
public final void invoke(Request request, Response response) {
    // /index.html
    MessageBytes requestPathMB = request.getRequestPathMB();
    // 不允许直接访问 WEB-INF or META-INF
    if ((requestPathMB.startsWithIgnoreCase("/META-INF/", 0))
        || (requestPathMB.equalsIgnoreCase("/META-INF"))
        || (requestPathMB.startsWithIgnoreCase("/WEB-INF/", 0))
        || (requestPathMB.equalsIgnoreCase("/WEB-INF"))) {
        response.sendError(HttpServletResponse.SC_NOT_FOUND);
        return;
    }

    // 根据当前 request 选择合适的 wrapper【servlet】
    Wrapper wrapper = request.getWrapper();
    if (wrapper == null || wrapper.isUnavailable()) {
        response.sendError(HttpServletResponse.SC_NOT_FOUND);
        return;
    }
    
    // 发送确认请求，HTTP/1.1 100
    try {
        response.sendAcknowledgement();
    } catch (IOException ioe) {
        return;
    }

    // 调用 Wrapper 的 pipeline 处理
    wrapper.getPipeline().getFirst().invoke(request, response);
}

// StandardWrapperValve
@Override
public final void invoke(Request request, Response response)
    throws IOException, ServletException {

    // 分配 servlet 实例处理此次请求
    if (!unavailable) {
        // 会判断  Servlet 是否有  
        // ******* SingleThreadModel 接口 ******************
        servlet = wrapper.allocate();
    }
   
    // 创建 Filter
    ApplicationFilterChain filterChain =
        ApplicationFilterFactory.createFilterChain(request, wrapper, servlet);

    // Call the filter chain for this request
    if ((servlet != null) && (filterChain != null)) {
        if (request.isAsyncDispatching()) {
            request.getAsyncContextInternal().doInternalDispatch();
        } else {
            // 此处 先调用 过滤器方法，再走service 方法
            // 和 Filter 章节关联
            filterChain.doFilter(request.getRequest(),
                                 response.getResponse());
        }
    } else {
        if (request.isAsyncDispatching()) {
            request.getAsyncContextInternal().doInternalDispatch();
        } else {
            filterChain.doFilter
                (request.getRequest(), response.getResponse());
        }
    }

    // 释放 filterChain
    if (filterChain != null) {
        filterChain.release();
    }

    // 释放 instance
    if (servlet != null) {
        wrapper.deallocate(servlet);
    }

    // 如果不可用，卸载 & 释放 instance
    if ((servlet != null) &&
        (wrapper.getAvailable() == Long.MAX_VALUE)) {
        wrapper.unload();
    }
}

Tomcat中Pipeline

管道Pipeline

处理模式

Tomcat中的管道

初始化

WswAccessValve

四个基础Valve

构造Valve链

执行流程

猜你喜欢