tomcat 中ApplicationFilterChain类的源码分析

落日映苍穹つ 2022-09-04 00:59 126阅读 0赞

tomcat 中ApplicationFilterChain类的源码分析：

1、此类源码：

public final class ApplicationFilterChain implements FilterChain {
    
        // Used to enforce requirements of SRV.8.2 / SRV.14.2.5.1
        private static final ThreadLocal<ServletRequest> lastServicedRequest;
        private static final ThreadLocal<ServletResponse> lastServicedResponse;
    
        static {
            if (ApplicationDispatcher.WRAP_SAME_OBJECT) {
                lastServicedRequest = new ThreadLocal<>();
                lastServicedResponse = new ThreadLocal<>();
            } else {
                lastServicedRequest = null;
                lastServicedResponse = null;
            }
        }
    
        // -------------------------------------------------------------- Constants
    
    
        public static final int INCREMENT = 10;
    
    
        // ----------------------------------------------------- Instance Variables
    
        /**
         * Filters.tomcat和其里面的服务中所有的过滤器的数组（实现Filter接口的类）
         */
        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;
    
    
        /**
         * The servlet instance to be executed by this chain.
         */
        private Servlet servlet = null;
    
    
        /**
         * Does the associated servlet instance support async processing?
         */
        private boolean servletSupportsAsync = false;
    
        /**
         * The string manager for our package.
         */
        private static final StringManager sm =
          StringManager.getManager(Constants.Package);
    
    
        /**
         * Static class array used when the SecurityManager is turned on and
         * <code>doFilter</code> is invoked.
         */
        private static final Class<?>[] classType = new Class[]{
            ServletRequest.class, ServletResponse.class, FilterChain.class};
    
        /**
         * Static class array used when the SecurityManager is turned on and
         * <code>service</code> is invoked.
         */
        private static final Class<?>[] classTypeUsedInService = new Class[]{
            ServletRequest.class, ServletResponse.class};
    
    
        // ---------------------------------------------------- FilterChain Methods
    
        /**
         * Invoke the next filter in this chain, passing the specified request
         * and response.  If there are no more filters in this chain, invoke
         * the <code>service()</code> method of the servlet itself.
         *
         * @param request The servlet request we are processing
         * @param response The servlet response we are creating
         *
         * @exception IOException if an input/output error occurs
         * @exception ServletException if a servlet exception occurs
         */
        @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
            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;
            }
    
            // 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);
                }
            }
        }
    
    
        /**
         * The last request passed to a servlet for servicing from the current
         * thread.
         *
         * @return The last request to be serviced.
         */
        public static ServletRequest getLastServicedRequest() {
            return lastServicedRequest.get();
        }
    
    
        /**
         * The last response passed to a servlet for servicing from the current
         * thread.
         *
         * @return The last response to be serviced.
         */
        public static ServletResponse getLastServicedResponse() {
            return lastServicedResponse.get();
        }
    
    
        // -------------------------------------------------------- Package Methods
    
        /**
         * Add a filter to the set of filters that will be executed in this chain.
         *
         * @param filterConfig The FilterConfig for the servlet to be executed
         */
        void addFilter(ApplicationFilterConfig filterConfig) {
    
            // Prevent the same filter being added multiple times
            for(ApplicationFilterConfig filter:filters)
                if(filter==filterConfig)
                    return;
    
            if (n == filters.length) {
                ApplicationFilterConfig[] newFilters =
                    new ApplicationFilterConfig[n + INCREMENT];
                System.arraycopy(filters, 0, newFilters, 0, n);
                filters = newFilters;
            }
            filters[n++] = filterConfig;
    
        }
    
    
        /**
         * Release references to the filters and wrapper executed by this chain.
         */
        void release() {
            for (int i = 0; i < n; i++) {
                filters[i] = null;
            }
            n = 0;
            pos = 0;
            servlet = null;
            servletSupportsAsync = false;
        }
    
    
        /**
         * Prepare for reuse of the filters and wrapper executed by this chain.
         */
        void reuse() {
            pos = 0;
        }
    
    
        /**
         * Set the servlet that will be executed at the end of this chain.
         *
         * @param servlet The Wrapper for the servlet to be executed
         */
        void setServlet(Servlet servlet) {
            this.servlet = servlet;
        }
    
    
        void setServletSupportsAsync(boolean servletSupportsAsync) {
            this.servletSupportsAsync = servletSupportsAsync;
        }
    
    
        /**
         * Identifies the Filters, if any, in this FilterChain that do not support
         * async.
         *
         * @param result The Set to which the fully qualified class names of each
         *               Filter in this FilterChain that does not support async will
         *               be added
         */
        public void findNonAsyncFilters(Set<String> result) {
            for (int i = 0; i < n ; i++) {
                ApplicationFilterConfig filter = filters[i];
                if ("false".equalsIgnoreCase(filter.getFilterDef().getAsyncSupported())) {
                    result.add(filter.getFilterClass());
                }
            }
        }
    }

2、实现 FilterChain 接口

每个请求都会创建一个新的FilterChain对象。

注意：Filter配置是针对整个Web项目的，而每个FilterChain对象是针对每个请求的。

即定位ApplicationFilterChain的创建操作即可。ApplicationFilterChain对象由ApplicationFilterFactory工厂的createFilterChain方法生成。而这个方法在ApplicationDispatcher的invoke方法内被调用。这个invoke方法是Connector把新请求传递给Container的方式。

3、流程分析：

每次调用 internalDoFilter 方法，pos 就加1，也就是获取下一个 ApplicationFilterConfig，直到 pos 等于 n 的时候才不执行 if 语句，为了达到这个效果，应用程序必须在自定义的在 Filter 里执行 FilterChain\#doFilter 方法，才能再次进入 ApplicationFilterChain\#internalDoFilter 方法，这样就完成了调用 ApplicationFilterChain 里所有的 Filter 的 doFilter 方法。  
这种方式是责任链模式的一种体现。

4、Filter 调用完成之后，开始调用业务方法，

servlet.service(request, response);

5、点击进入。。。。