Tomcat中的filter调用doFilter的问题

之前在学tomcat的web三大组件的时候,其实一直有几个问题没有搞懂过,
1.filter的执行顺序为什么一定在servlet之前?当然，只是一直是记住这个规则，而已。
2.filter中为什么一定要调用chain.doFilter,不调用的话,好像请求就被截断了？
3.我如果在chain.doFilter下面还添加一些语句会发生什么呢?

刚刚学了责任链模式,所以看看,拿到tomcat的源码之后,我们可以重点看下这个类ApplicationFilterChain，这个类里面维护了ApplicationFilterConfig[] 这样的一个过滤器数组,这个数组就是我们配置进去的过滤器,
源码:

public final class ApplicationFilterChain implements FilterChain {
/**
     * Filters. 配置的过滤器数组
     */
    private ApplicationFilterConfig[] filters = new ApplicationFilterConfig[0];


    /**
     * The int which is used to maintain the current position
     * in the filter chain.
     */
    private int pos = 0; // 当前执行的过滤器的在数组中的而位置


    /**
     * The int which gives the current number of filters in the chain.
     */
    private int n = 0; // 总共过滤器的数量
@Override
    public void doFilter(ServletRequest request, ServletResponse response)
        throws IOException, ServletException {

        if( Globals.IS_SECURITY_ENABLED ) {
            final ServletRequest req = request;
            final ServletResponse res = response;
            try {
                java.security.AccessController.doPrivileged(
                    new java.security.PrivilegedExceptionAction<Void>() {
                        @Override
                        public Void run()
                            throws ServletException, IOException {
                            internalDoFilter(req,res);
                            return null;
                        }
                    }
                );
            } catch( PrivilegedActionException pe) {
                Exception e = pe.getException();
                if (e instanceof ServletException)
                    throw (ServletException) e;
                else if (e instanceof IOException)
                    throw (IOException) e;
                else if (e instanceof RuntimeException)
                    throw (RuntimeException) e;
                else
                    throw new ServletException(e.getMessage(), e);
            }
        } else {
            internalDoFilter(request,response);
        }
    }

    private void internalDoFilter(ServletRequest request,
                                  ServletResponse response)
        throws IOException, ServletException {

        // Call the next filter if there is one
        // 0 -> 2  ,假设一共有两个Filter
        // 第一轮: pos = 0, n = 2, 做判断 0 < 2, 好,这个时候pos + 1 所以此时pos = 1
        //        假设此时的第一个Filter没有调用chain.doFilter(req,resp)方法,那么会执行下面的return;
        //        就不会执行下面的servlet调用service方法了
        // 假设第一轮中,调用了chain.doFilter,这个,又回到上面这个方法,接着又调用本方法, 注意此时是同一个FilterChain
        //        此时 pos = 1, 所以 1 < 2, 依旧成立, 好,这个时候pos + 1 所以此时pos = 2
        //        假设第二个过滤器如果又没调用chain.doFilter那么filter.doFilter(request, response, this);这一句又断了,就直接执行return;
        //        就不会执行下面的servlet调用service方法了
        // 第二轮: 假设第二轮调用了,那么又会回到当前的方法2<2不成立, 那么就会执行下面的servlet调用service方法了
        // =========这是责任链模式的另外一种用法========
        // 思考: 假设其中某一个Filter, 它不是在最后一句调用的filterChain.doFilter
        //      那么其实也实现了spring mvc的拦截器一样的功能,等servlet处理完了之后, 然后逆序调用filter的那句话后面的代码,
        //      特别注意: 这个时候处理完的request和response已经让servlet处理过了, 所以filter可以继续接着对这个处理完成了的请求中的request和response对象处理
        //               然后再返回给客户端

        if (pos < n) { //
            ApplicationFilterConfig filterConfig = filters[pos++];
            try {
                Filter filter = filterConfig.getFilter();

                if (request.isAsyncSupported() && "false".equalsIgnoreCase(
                        filterConfig.getFilterDef().getAsyncSupported())) {
                    request.setAttribute(Globals.ASYNC_SUPPORTED_ATTR, Boolean.FALSE);
                }
                if( Globals.IS_SECURITY_ENABLED ) {
                    final ServletRequest req = request;
                    final ServletResponse res = response;
                    Principal principal =
                        ((HttpServletRequest) req).getUserPrincipal();

                    Object[] args = new Object[]{req, res, this};
                    SecurityUtil.doAsPrivilege ("doFilter", filter, classType, args, principal);
                } else {
                    filter.doFilter(request, response, this);
                }
            } catch (IOException | ServletException | RuntimeException e) {
                throw e;
            } catch (Throwable e) {
                e = ExceptionUtils.unwrapInvocationTargetException(e);
                ExceptionUtils.handleThrowable(e);
                throw new ServletException(sm.getString("filterChain.filter"), e);
            }
            return; // 这个return;语句是关键,如果中间的FilterChain断了的话,那么会直接到这里来,下面调用servlet的方法也不会执行了
        }

        // We fell off the end of the chain -- call the servlet instance
        try {
            if (ApplicationDispatcher.WRAP_SAME_OBJECT) {
                lastServicedRequest.set(request);
                lastServicedResponse.set(response);
            }

            if (request.isAsyncSupported() && !servletSupportsAsync) {
                request.setAttribute(Globals.ASYNC_SUPPORTED_ATTR,
                        Boolean.FALSE);
            }
            // Use potentially wrapped request from this point
            if ((request instanceof HttpServletRequest) &&
                    (response instanceof HttpServletResponse) &&
                    Globals.IS_SECURITY_ENABLED ) {
                final ServletRequest req = request;
                final ServletResponse res = response;
                Principal principal =
                    ((HttpServletRequest) req).getUserPrincipal();
                Object[] args = new Object[]{req, res};
                SecurityUtil.doAsPrivilege("service",
                                           servlet,
                                           classTypeUsedInService,
                                           args,
                                           principal);
            } else {
                servlet.service(request, response);
            }
        } catch (IOException | ServletException | RuntimeException e) {
            throw e;
        } catch (Throwable e) {
            e = ExceptionUtils.unwrapInvocationTargetException(e);
            ExceptionUtils.handleThrowable(e);
            throw new ServletException(sm.getString("filterChain.servlet"), e);
        } finally {
            if (ApplicationDispatcher.WRAP_SAME_OBJECT) {
                lastServicedRequest.set(null);
                lastServicedResponse.set(null);
            }
        }
    }

    }
```java

本文地址：https://blog.csdn.net/qq_16992475/article/details/109560016