上一篇博客 Tomcat 源码解析一请求处理的整体过程-黄泉天怒(上)

NonLoginAuthenticator

  NonLoginAuthenticator并没有实现invoke()方法，而是由父类AuthenticatorBase实现了invoke()方法，AuthenticatorBase类关系如下。

  先弄清楚NonLoginAuthenticator这个管道是在何时被加入到StandardContext的Pipeline里的呢？ 在StandardPipeline的addValve()方法中打断点。

  最终发现在configureStart()方法中调用了authenticatorConfig()，实现了向StandardContext的Pipeline中添加Valve。

  大家可能感到迷惑，什么时候调用configureStart()方法呢？这个需要去看之前的Tomcat 源码解析一容器加载-大寂灭指 相关的三篇博客了。 这里就不深入，先进入authenticatorConfig()方法 。

/**
 * Set up an Authenticator automatically if required, and one has not
 * already been configured.
 * 基于解析完Web容器，检测Web应用部署描述中使用的安全角色名，当发现使用示定义的角色时，提示警告将未定义的角色添加到Context 安全角色列表中。
 */
protected void authenticatorConfig() {
    LoginConfig loginConfig = context.getLoginConfig();
    if (loginConfig == null) {
        // Need an authenticator to support HttpServletRequest.login()
        loginConfig = DUMMY_LOGIN_CONFIG;
        context.setLoginConfig(loginConfig);
    }

    // Has an authenticator been configured already?
    if (context.getAuthenticator() != null)
        return;

    if (!(context instanceof ContainerBase)) {
        return;     // Cannot install a Valve even if it would be needed
    }

    // Has a Realm been configured for us to authenticate against?
    if (context.getRealm() == null) {
        log.error(sm.getString("contextConfig.missingRealm"));
        ok = false;
        return;
    }

    /*
     * First check to see if there is a custom mapping for the login
     * method. If so, use it. Otherwise, check if there is a mapping in
     * org/apache/catalina/startup/Authenticators.properties.
     */
    Valve authenticator = null;
    if (customAuthenticators != null) {
        authenticator = (Valve)
            customAuthenticators.get(loginConfig.getAuthMethod());
    }
    // 当Context 需要进行安全认证但是没有指定具体的Authenticator时，根据服务器配置自动创建默认的实例。
    if (authenticator == null) {
        if (authenticators == null) {
            log.error(sm.getString("contextConfig.authenticatorResources"));
            ok = false;
            return;
        }

        // Identify the class name of the Valve we should configure
        String authenticatorName = null;
        authenticatorName =
                authenticators.getProperty(loginConfig.getAuthMethod());
        if (authenticatorName == null) {
            log.error(sm.getString("contextConfig.authenticatorMissing",
                             loginConfig.getAuthMethod()));
            ok = false;
            return;
        }

        // Instantiate and install an Authenticator of the requested class
        try {
            Class authenticatorClass = Class.forName(authenticatorName);
            authenticator = (Valve) authenticatorClass.newInstance();
        } catch (Throwable t) {
            ExceptionUtils.handleThrowable(t);
            log.error(sm.getString(
                                "contextConfig.authenticatorInstantiate",
                                authenticatorName),
                      t);
            ok = false;
        }
    }

    if (authenticator != null && context instanceof ContainerBase) {
        Pipeline pipeline = ((ContainerBase) context).getPipeline();
        if (pipeline != null) {
            ((ContainerBase) context).getPipeline().addValve(authenticator);
            if (log.isDebugEnabled()) {
                log.debug(sm.getString(
                                "contextConfig.authenticatorConfigured",
                                loginConfig.getAuthMethod()));
            }
        }
    }
}

  想弄清楚上面代码，第一要看懂LoginConfig的由来，默认LoginConfig为protected static final LoginConfigDUMMY_LOGIN_CONFIG =
new LoginConfig(“NONE”, null, null, null); ，第二点明白authenticators属性什么时候赋值，赋的值是什么？请看ContextConfig的静态代码块。

static {
    // Load our mapping properties for the standard authenticators
    Properties props = new Properties();
    InputStream is = null;
    try {
        is = ContextConfig.class.getClassLoader().getResourceAsStream(
                "org/apache/catalina/startup/Authenticators.properties");
        if (is != null) {
            props.load(is);
        }
    } catch (IOException ioe) {
        props = null;
    } finally {
        if (is != null) {
            try {
                is.close();
            } catch (IOException e) {
            }
        }
    }
	authenticators = props;
    // Load the list of JARS to skip
    addJarsToSkip(Constants.DEFAULT_JARS_TO_SKIP);
    addJarsToSkip(Constants.PLUGGABILITY_JARS_TO_SKIP);
}

  authenticators属性来源于org/apache/catalina/startup/Authenticators.properties文件，而Authenticators.properties的文件内容为

  此时再来看authenticatorConfig()方法就简单多了，默认情况下loginConfig的authMethod值为NONE，因此从authenticators获取到的配置类名为org.apache.catalina.authenticator.NonLoginAuthenticator，再用反射创建NonLoginAuthenticator对象，添加到StandardContext的Pipeline的Valve中。

public void invoke(Request request, Response response) throws IOException, ServletException {
    if (log.isDebugEnabled()) {
        log.debug("Security checking request " + request.getMethod() + " " +
                request.getRequestURI());
    }
    LoginConfig config = this.context.getLoginConfig();

    // Have we got a cached authenticated Principal to record?
    if (cache) {
        Principal principal = request.getUserPrincipal();
        if (principal == null) {
            Session session = request.getSessionInternal(false);
            if (session != null) {
                principal = session.getPrincipal();
                if (principal != null) {
                    if (log.isDebugEnabled()) {
                        log.debug("We have cached auth type " + session.getAuthType() +
                                " for principal " + principal);
                    }
                    request.setAuthType(session.getAuthType());
                    request.setUserPrincipal(principal);
                }
            }
        }
    }

    boolean authRequired = isContinuationRequired(request);

    Realm realm = this.context.getRealm();
    // Is this request URI subject to a security constraint?
    SecurityConstraint[] constraints = realm.findSecurityConstraints(request, this.context);

    if (constraints == null && !context.getPreemptiveAuthentication() && !authRequired) {
        if (log.isDebugEnabled()) {
            log.debug(" Not subject to any constraint");
        }
        getNext().invoke(request, response);
        return;
    }
    // Make sure that constrained resources are not cached by web proxies
    // or browsers as caching can provide a security hole
    if (constraints != null && disableProxyCaching &&
            !"POST".equalsIgnoreCase(request.getMethod())) {
        if (securePagesWithPragma) {
            // Note: These can cause problems with downloading files with IE
            response.setHeader("Pragma", "No-cache");
            response.setHeader("Cache-Control", "no-cache");
        } else {
            response.setHeader("Cache-Control", "private");
        }
        response.setHeader("Expires", DATE_ONE);
    }

    if (constraints != null) {
        // Enforce any user data constraint for this security constraint
        if (log.isDebugEnabled()) {
            log.debug(" Calling hasUserDataPermission()");
        }
        if (!realm.hasUserDataPermission(request, response, constraints)) {
            if (log.isDebugEnabled()) {
                log.debug(" Failed hasUserDataPermission() test");
            }
            /*
             * ASSERT: Authenticator already set the appropriate HTTP status
             * code, so we do not have to do anything special
             */
            return;
        }
    }

    // Since authenticate modifies the response on failure,
    // we have to check for allow-from-all first.
    boolean hasAuthConstraint = false;
    if (constraints != null) {
        hasAuthConstraint = true;
        for (int i = 0; i < constraints.length && hasAuthConstraint; i++) {
            if (!constraints[i].getAuthConstraint()) {
                hasAuthConstraint = false;
            } else if (!constraints[i].getAllRoles()) {
                String[] roles = constraints[i].findAuthRoles();
                if (roles == null || roles.length == 0) {
                    hasAuthConstraint = false;
                }
            }
        }
    }

    if (!authRequired && hasAuthConstraint) {
        authRequired = true;
    }

    if (!authRequired && context.getPreemptiveAuthentication()) {
        authRequired =
                request.getCoyoteRequest().getMimeHeaders().getValue("authorization") != null;
    }

    if (!authRequired && context.getPreemptiveAuthentication() &&
            HttpServletRequest.CLIENT_CERT_AUTH.equals(getAuthMethod())) {
        X509Certificate[] certs = getRequestCertificates(request);
        authRequired = certs != null && certs.length > 0;
    }

    if (authRequired) {
        if (log.isDebugEnabled()) {
            log.debug(" Calling authenticate()");
        }
        if (!authenticate(request, response, config)) {
            if (log.isDebugEnabled()) {
                log.debug(" Failed authenticate() test");
            }
            /*
             * ASSERT: Authenticator already set the appropriate HTTP status
             * code, so we do not have to do anything special
             */
            return;
        }

    }

    if (constraints != null) {
        if (log.isDebugEnabled()) {
            log.debug(" Calling accessControl()");
        }
        if (!realm.hasResourcePermission(request, response, constraints, this.context)) {
            if (log.isDebugEnabled()) {
                log.debug(" Failed accessControl() test");
            }
            /*
             * ASSERT: AccessControl method has already set the appropriate
             * HTTP status code, so we do not have to do anything special
             */
            return;
        }
    }

    // Any and all specified constraints have been satisfied
    if (log.isDebugEnabled()) {
        log.debug(" Successfully passed all security constraints");
    }
    getNext().invoke(request, response);
}

  因此对于NonLoginAuthenticator而方，走的是上面加粗代码。对于Tomcat权限这一块，目前不做深入分析，当然，如果想修改默认配置NonLoginAuthenticator，可以在WEB-INF/web.xml中添加login-config标签。如下图所示

  最终在解析web.xml时，添加到StandardContext中。

  大家可能感到好奇，我是怎么找到这样使用的呢？首先找到StandardContext的setLoginConfig()方法。 发现在WebXml使用了setLoginConfig()

  WebXml的loginConfig最终来源于其setLoginConfig方法 。我们知道WebXml是web.xml的封装，而在Tomcat中所有的xml的解析都是由Degister框架，根据Degister框架的特性，肯定配置了"setLoginConfig" 字符串，因此全局搜索"setLoginConfig"。

  终于找到了login-config的配置，本例中只配置了auth-method，还可以倒置realm-name， form-login-config/form-error-page， form-login-config/form-login-page等信息。 接下来分析StandardContextValve类。

StandardContextValve

  接下来看StandardContextValve的内部实现

public final void invoke(Request request, Response response)
    throws IOException, ServletException {

    // Disallow any direct access to resources under WEB-INF or META-INF
    // 当然禁止访问META-INF和WEB-INF的内容，如果访问，则抛出404异常
    MessageBytes requestPathMB = request.getRequestPathMB();
    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;
    }
    // Select the Wrapper to be used for this Request
    // 如果Wrapper不存在或者Wrapper不可用，则抛出404异常
    Wrapper wrapper = request.getWrapper();
    if (wrapper == null || wrapper.isUnavailable()) {
        response.sendError(HttpServletResponse.SC_NOT_FOUND);
        return;
    }
    
    // Acknowledge the request
    // 向客户端发送ack事件 
    try {
        response.sendAcknowledgement();
    } catch (IOException ioe) {
        container.getLogger().error(sm.getString(
                "standardContextValve.acknowledgeException"), ioe);
        request.setAttribute(RequestDispatcher.ERROR_EXCEPTION, ioe);
        // 如果抛出异常，则返回505错误码
        response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
        return;
    }

    if (request.isAsyncSupported()) {
        request.setAsyncSupported(wrapper.getPipeline().isAsyncSupported());
    }
    wrapper.getPipeline().getFirst().invoke(request, response);
}

  接下来进入StandardWrapperValve的invoke()方法。

StandardWrapperValve

/**
 * StandardWrapperValve 是 StandardWrapper 实例上的基本阀门，该阀门做两件 事情:
 *  1.提交 Servlet 的所有相关过滤器
 *  2.调用发送者的 service 方法要实现这些内容，下面是 StandardWrapperValve 在他的 invoke 方法要实现的:
 *  3.调用 StandardWrapper 的 allocate 的方法来获得一个 servlet 实例
 *  4.调用它的 private createFilterChain 方法获得过滤链
 *  5.调用过滤器链的 doFilter 方法。包括调用 servlet 的 service 方法
 *  6.释放过滤器链
 *  7.调用包装器的 deallocate 方法
 *  8.如果 Servlet 无法使用了，调用包装器的 unload 方法
 */
@Override
public final void invoke(Request request, Response response)
    throws IOException, ServletException {

    // Initialize local variables we may need
    boolean unavailable = false;
    Throwable throwable = null;
    // This should be a Request attribute...
    long t1=System.currentTimeMillis();
    requestCount.incrementAndGet();
    StandardWrapper wrapper = (StandardWrapper) getContainer(); // 属于哪个Wrapper
    Servlet servlet = null;
    Context context = (Context) wrapper.getParent();  // 属于哪个Context

    // Check for the application being marked unavailable
    if (!context.getState().isAvailable()) {
    	// 如果容器的状态不可用，则返回503
        response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE,
                       sm.getString("standardContext.isUnavailable"));
        unavailable = true;
    }
    
    // Check for the servlet being marked unavailable
    // 如果Context可用，但是Wrapper不可用, 在定义servlet时，可以设置enabled
    if (!unavailable && wrapper.isUnavailable()) {
        container.getLogger().info(sm.getString("standardWrapper.isUnavailable",
                wrapper.getName()));
        long available = wrapper.getAvailable();
        if ((available > 0L) && (available < Long.MAX_VALUE)) {
            response.setDateHeader("Retry-After", available);
            response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE,
                    sm.getString("standardWrapper.isUnavailable",
                            wrapper.getName()));
        } else if (available == Long.MAX_VALUE) {
            response.sendError(HttpServletResponse.SC_NOT_FOUND,
                    sm.getString("standardWrapper.notFound",
                            wrapper.getName()));
        }
        unavailable = true;
    }

    // Allocate a servlet instance to process this request
    try {
        if (!unavailable) {
        	// 实例化，初始化servlet 
            servlet = wrapper.allocate();
        }
    } catch (UnavailableException e) {
        container.getLogger().error(
                sm.getString("standardWrapper.allocateException",
                        wrapper.getName()), e);
        long available = wrapper.getAvailable();
        if ((available > 0L) && (available < Long.MAX_VALUE)) {
            response.setDateHeader("Retry-After", available);
            response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE,
                       sm.getString("standardWrapper.isUnavailable",
                                    wrapper.getName()));
        } else if (available == Long.MAX_VALUE) {
            response.sendError(HttpServletResponse.SC_NOT_FOUND,
                       sm.getString("standardWrapper.notFound",
                                    wrapper.getName()));
        }
    } catch (ServletException e) {
        container.getLogger().error(sm.getString("standardWrapper.allocateException",
                         wrapper.getName()), StandardWrapper.getRootCause(e));
        throwable = e;
        exception(request, response, e);
    } catch (Throwable e) {
        ExceptionUtils.handleThrowable(e);
        container.getLogger().error(sm.getString("standardWrapper.allocateException",
                         wrapper.getName()), e);
        throwable = e;
        exception(request, response, e);
        servlet = null;
    }

    // Identify if the request is Comet related now that the servlet has been allocated
    boolean comet = false;
    if (servlet instanceof CometProcessor && Boolean.TRUE.equals(request.getAttribute(
            Globals.COMET_SUPPORTED_ATTR))) {
        comet = true;
        request.setComet(true);
    }

    MessageBytes requestPathMB = request.getRequestPathMB();
    DispatcherType dispatcherType = DispatcherType.REQUEST;
    if (request.getDispatcherType()==DispatcherType.ASYNC) dispatcherType = DispatcherType.ASYNC;
    request.setAttribute(Globals.DISPATCHER_TYPE_ATTR,dispatcherType);
    request.setAttribute(Globals.DISPATCHER_REQUEST_PATH_ATTR,
            requestPathMB);
    // Create the filter chain for this request
    ApplicationFilterFactory factory =
        ApplicationFilterFactory.getInstance();

    // 最重要的方法是 createFilterChain 方法并调用过滤器链的 doFilter 方法。方 法 createFilterChain 创建了一个
    // ApplicationFilterChain 实例，并将所有的 过滤器添加到上面。ApplicationFilterChain 类将在下面的小节中介绍。
    // 要完 全的理解这个类，还需要理解 FilterDef 和 ApplicationFilterConfig 类。这些 内容将在下面介绍
    ApplicationFilterChain filterChain =
        factory.createFilterChain(request, wrapper, servlet);

    // Reset comet flag value after creating the filter chain
    request.setComet(false);

    // Call the filter chain for this request
    // NOTE: This also calls the servlet's service() method
    try {
        if ((servlet != null) && (filterChain != null)) {
            // Swallow output if needed
            if (context.getSwallowOutput()) {
                try {
                    SystemLogHandler.startCapture();
                    if (request.isAsyncDispatching()) {
                        request.getAsyncContextInternal().doInternalDispatch();
                    } else if (comet) {
                        filterChain.doFilterEvent(request.getEvent());
                        request.setComet(true);
                    } else {
                        filterChain.doFilter(request.getRequest(),
                                response.getResponse());
                    }
                } finally {
                    String log = SystemLogHandler.stopCapture();
                    if (log != null && log.length() > 0) {
                        context.getLogger().info(log);
                    }
                }
            } else {
                if (request.isAsyncDispatching()) {
                    request.getAsyncContextInternal().doInternalDispatch();
                } else if (comet) {
                    request.setComet(true);
                    filterChain.doFilterEvent(request.getEvent());
                } else {
                    filterChain.doFilter
                        (request.getRequest(), response.getResponse());
                }
            }

        }
    } catch (ClientAbortException e) {
        throwable = e;
        exception(request, response, e);
    } catch (IOException e) {
        container.getLogger().error(sm.getString(
                "standardWrapper.serviceException", wrapper.getName(),
                context.getName()), e);
        throwable = e;
        exception(request, response, e);
    } catch (UnavailableException e) {
        container.getLogger().error(sm.getString(
                "standardWrapper.serviceException", wrapper.getName(),
                context.getName()), e);
        //            throwable = e;
        //            exception(request, response, e);
        wrapper.unavailable(e);
        long available = wrapper.getAvailable();
        if ((available > 0L) && (available < Long.MAX_VALUE)) {
            response.setDateHeader("Retry-After", available);
            response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE,
                       sm.getString("standardWrapper.isUnavailable",
                                    wrapper.getName()));
        } else if (available == Long.MAX_VALUE) {
            response.sendError(HttpServletResponse.SC_NOT_FOUND,
                        sm.getString("standardWrapper.notFound",
                                    wrapper.getName()));
        }
        // Do not save exception in 'throwable', because we
        // do not want to do exception(request, response, e) processing
    } catch (ServletException e) {
        Throwable rootCause = StandardWrapper.getRootCause(e);
        if (!(rootCause instanceof ClientAbortException)) {
            container.getLogger().error(sm.getString(
                    "standardWrapper.serviceExceptionRoot",
                    wrapper.getName(), context.getName(), e.getMessage()),
                    rootCause);
        }
        throwable = e;
        exception(request, response, e);
    } catch (Throwable e) {
        ExceptionUtils.handleThrowable(e);
        container.getLogger().error(sm.getString(
                "standardWrapper.serviceException", wrapper.getName(),
                context.getName()), e);
        throwable = e;
        exception(request, response, e);
    }

    // Release the filter chain (if any) for this request
    if (filterChain != null) {
        if (request.isComet()) {
            // If this is a Comet request, then the same chain will be used for the
            // processing of all subsequent events.
            filterChain.reuse();
        } else {
            filterChain.release();
        }
    }

    // Deallocate the allocated servlet instance
    try {
        if (servlet != null) {
            wrapper.deallocate(servlet);
        }
    } catch (Throwable e) {
        ExceptionUtils.handleThrowable(e);
        container.getLogger().error(sm.getString("standardWrapper.deallocateException",
                         wrapper.getName()), e);
        if (throwable == null) {
            throwable = e;
            exception(request, response, e);
        }
    }

    // If this servlet has been marked permanently unavailable,
    // unload it and release this instance
    try {
        if ((servlet != null) &&
            (wrapper.getAvailable() == Long.MAX_VALUE)) {
            wrapper.unload();
        }
    } catch (Throwable e) {
        ExceptionUtils.handleThrowable(e);
        container.getLogger().error(sm.getString("standardWrapper.unloadException",
                         wrapper.getName()), e);
        if (throwable == null) {
            throwable = e;
            exception(request, response, e);
        }
    }
    long t2=System.currentTimeMillis();

    long time=t2-t1;
    processingTime += time;
    if( time > maxTime) maxTime=time;
    if( time < minTime) minTime=time;

}

  先来看Servlet的实例化初始化方法

public Servlet allocate() throws ServletException {
    // If we are currently unloading this servlet, throw an exception
    if (unloading) {
        throw new ServletException(sm.getString("standardWrapper.unloading", getName()));
    }
    boolean newInstance = false;
    // If not SingleThreadedModel, return the same instance every time
    if (!singleThreadModel) {
        // Load and initialize our instance if necessary
        if (instance == null || !instanceInitialized) {
            synchronized (this) {
                if (instance == null) {
                    try {
                        if (log.isDebugEnabled()) {
                            log.debug("Allocating non-STM instance");
                        }
                        // Note: We don't know if the Servlet implements
                        // SingleThreadModel until we have loaded it.
                        // 一个Servlet只有被加载后才能知道是不是实现了SingleThreadModel接口
                        instance = loadServlet();
                        newInstance = true;
                        // 如果没有继承singleThreadModel接口
                        if (!singleThreadModel) {
                            // For non-STM, increment here to prevent a race
                            // condition with unload. Bug 43683, test case
                            // #3
                            // 分配实例的次数+1
                            countAllocated.incrementAndGet();
                        }
                    } catch (ServletException e) {
                        throw e;
                    } catch (Throwable e) {
                        ExceptionUtils.handleThrowable(e);
                        throw new ServletException(sm.getString("standardWrapper.allocate"), e);
                    }
                }
                if (!instanceInitialized) {
                    initServlet(instance);
                }
            }
        }
        
        if (singleThreadModel) {
            // 新生成了一个实例后，把实例放入instancePool
            if (newInstance) {
                // Have to do this outside of the sync above to prevent a
                // possible deadlock
                synchronized (instancePool) {
                    instancePool.push(instance);
                    nInstances++;
                }
            }
        } else {
            if (log.isTraceEnabled()) {
                log.trace("  Returning non-STM instance");
            }
            // For new instances, count will have been incremented at the
            // time of creation
            if (!newInstance) {
                // 分配实例的次数加1，如果是新创的实例，在上面就会加1
                countAllocated.incrementAndGet();
            }
            return instance;
        }
    }

    synchronized (instancePool) {
        // countAllocated表示当前需要的实例数
        // nInstances表示当前已经生成的实例数
        // 如果需要的大于或等于存在的实例数，那么则要新生成了，如果已经超过了最大限制，就只能等其他线程释放servlet了
        while (countAllocated.get() >= nInstances) {
            // Allocate a new instance if possible, or else wait
            // 如果现在生成的实例小于最大限制，则继续生成
            if (nInstances < maxInstances) {
                try {
                    instancePool.push(loadServlet());
                    nInstances++;
                } catch (ServletException e) {
                    throw e;
                } catch (Throwable e) {
                    ExceptionUtils.handleThrowable(e);
                    throw new ServletException(sm.getString("standardWrapper.allocate"), e);
                }
            } else {
                // 否则等等
                try {
                    instancePool.wait();
                } catch (InterruptedException e) {
                    // Ignore
                }
            }
        }
        if (log.isTraceEnabled()) {
            log.trace("  Returning allocated STM instance");
        }
        // 分配次数+1，直接从instancePool取
        countAllocated.incrementAndGet();
        return instancePool.pop();
    }
}

Servlet对象池

  Servlet在不实现SingleThreadModel的情况下以单例实例模式运行，如图10.3所示，这种情况下，Wrapper容器只通过反射实例化一个Servlet对象，对此，Servlet的所有客户端请求都会共用此Servlet对象，而对于多个客户端请求Tomcat会使用多线程处理，所以要注意保证此Servlet对象的线程安全，多个线程不管执行顺序如何都能保证执行结果的正确性，关于线程安全问题，这里举一个刚做Web开发可能会犯的错误，在某个Servlet使用成员变量累加统计访问次数，这就存在线程安全问题。

  为了支持一个Servlet对象对一个线程，Servlet规范提出了一个SingleThreadModel接口，Tomcat容器必须要完成的机制是， 如果某个Servlet类实现了SingleThreadModel接口，则要保证一个线程独占一个Servlet对象，假如线程1正在使用Servlet1对象，则线程2不能再使用Servlet1对象，只能使用Servlet2对象 。

  针对SingleThreadModel模式，Tomcat 的Wrapper 容器使用了对象池策略， Wrapper容器会有一个Servlet堆 ，负责保证若干个Servlet对象，当需要Servlet对象时从堆中pop()出一个对象，而当用完后则push回堆中，Wrapper 容器中最多可以有20个某个Servlet类对象，例如XXXServlet类的对象池， 已有20个线程占用了20个对象，于是第21个线程执行时就会因此阻塞而等待，直至对象池中有可用的对象才继续执行。

  整个流程如图10.4所示，某个线程处理客户端请求时，它首先尝试从Servlet对象池中获取Servlet对象，此时如果对象池中可用的对象则直接返回一个对象，如果不够，则使用则继续实例化Servlet对象并push到对象池中， 但Servlet对象的总数量必须保证在20个以内， 如果20个Servlet对象都被其他线程使用了， 那么就必须要等到其他线程用完放回后才能获取，此时该线程会一直等待，从对象池中获取到Servlet对象后则调用Servlet对象的service()方法对客户端请求进行处理，处理完后将Servlet对象放回对象池中。

  本节介绍了Servlet对象池， 它是为了支持Servlet规范SingleThreadModel接口而引入的它就是一个栈结构，需要时就pop出一个对象，使用完就push回去，请看下面代码实现 。

@Override
public void deallocate(Servlet servlet) throws ServletException {
    // If not SingleThreadModel, no action is required
    if (!singleThreadModel) {
        // 分配次数-1
        countAllocated.decrementAndGet();
        return;
    }

    // Unlock and free this instance
    synchronized (instancePool) {
        // 分配次数-1，
        countAllocated.decrementAndGet();
        instancePool.push(servlet);
        instancePool.notify();
    }
}

public synchronized Servlet loadServlet() throws ServletException {

    if (unloading) {
        throw new ServletException(
                sm.getString("standardWrapper.unloading", getName()));
    }

    // Nothing to do if we already have an instance or an instance pool
    if (!singleThreadModel && (instance != null))
        return instance;

    PrintStream out = System.out;
    if (swallowOutput) {
        SystemLogHandler.startCapture();
    }

    Servlet servlet;
    try {
        long t1=System.currentTimeMillis();
        // Complain if no servlet class has been specified
        if (servletClass == null) {
            unavailable(null);
            throw new ServletException
                (sm.getString("standardWrapper.notClass", getName()));
        }

        InstanceManager instanceManager = ((StandardContext)getParent()).getInstanceManager();
        try {
            // 有了类加载器和要加载的 Servlet 名字，就可以使用 loadServlet 方法来加载类 了。
            // 1. 创建Servlet实例，如果添加了JNDI 注解，将进行依赖注入
            servlet = (Servlet) instanceManager.newInstance(servletClass);
        } catch (ClassCastException e) {
            unavailable(null);
            // Restore the context ClassLoader
            throw new ServletException
                (sm.getString("standardWrapper.notServlet", servletClass), e);
        } catch (Throwable e) {
            e = ExceptionUtils.unwrapInvocationTargetException(e);
            ExceptionUtils.handleThrowable(e);
            unavailable(null);

            // Added extra log statement for Bugzilla 36630:
            // https://bz.apache.org/bugzilla/show_bug.cgi?id=36630
            if(log.isDebugEnabled()) {
                log.debug(sm.getString("standardWrapper.instantiate", servletClass), e);
            }

            // Restore the context ClassLoader
            throw new ServletException
                (sm.getString("standardWrapper.instantiate", servletClass), e);
        }

        if (multipartConfigElement == null) {
            // 2. 读取javax.servlet.annotation.MultipartConfig配置，以用于multipart/form-data请求处理，包括临时文件存储路径 。
            // 上传文件最大字节数，请求最大字节数，文件大小阈值。
            MultipartConfig annotation =
                    servlet.getClass().getAnnotation(MultipartConfig.class);
            if (annotation != null) {
                multipartConfigElement =
                        new MultipartConfigElement(annotation);
            }
        }

        // Special handling for ContainerServlet instances
        // 如果通过了安全性检查，接下来检查该 Servlet 是否是一个 ContainerServlet。 ContainerServlet 是实现了 org.apache.catalina.ContainerServlet
        // 接口的 Servlet，它可以访问 Catalina 的内部函数。如果该 Servlet 是 ContainerServlet，loadServlet 方法调用 ContainerServlet 的 setWrapper
        // 方法，传递该 StandardWrapper 实例。
        if ((servlet instanceof ContainerServlet) &&
                // isContainerProvidedServlet 方法返回 true 值。classLoader 会获得另一个 ClassLoader 的实例，这样就可以访问 Catalina 的内部了。
                (isContainerProvidedServlet(servletClass) ||
                        ((Context) getParent()).getPrivileged() )) {
            ((ContainerServlet) servlet).setWrapper(this);
        }

        classLoadTime=(int) (System.currentTimeMillis() -t1);

        // 实现了SingleThreadModel接口
        if (servlet instanceof SingleThreadModel) {
            if (instancePool == null) {
                instancePool = new Stack();
            }
            singleThreadModel = true;
        }

        // 4. 初始化servlet
        initServlet(servlet);

        fireContainerEvent("load", this);

        loadTime=System.currentTimeMillis() -t1;
    } finally {
        if (swallowOutput) {
            String log = SystemLogHandler.stopCapture();
            if (log != null && log.length() > 0) {
                if (getServletContext() != null) {
                    getServletContext().log(log);
                } else {
                    out.println(log);
                }
            }
        }
    }
    return servlet;

}

  加载Servlet代码分为4步。

1. 反射实例化Servlet。
2. MultipartConfig注解处理
3. 如果实现了ContainerServlet，则设置其Wrapper为this
4. 初始化Servlet

  其实上面代码中通过实现管理器servlet = (Servlet) instanceManager.newInstance(servletClass); 这一行代码虽然内部是通过反射实现servletClass的实例化。

public Object newInstance(String className) throws IllegalAccessException,
InvocationTargetException, NamingException, InstantiationException,
ClassNotFoundException, IllegalArgumentException, NoSuchMethodException, SecurityException {
    Class clazz = loadClassMaybePrivileged(className, classLoader);
    return newInstance(clazz.getDeclaredConstructor().newInstance(), clazz);
}

  细心的读者肯定会发现，竟然传了一个classLoader，那这个classLoader是什么呢？ 在DefaultInstanceManager实例化时，传了了WebappClassLoader，因此在实例化Servlet时，其类加载器为StandardContext的类加载器，也就是WebappClassLoader加载器。 接下来就是initServlet()的实现了。

private synchronized void initServlet(Servlet servlet)
        throws ServletException {

    if (instanceInitialized && !singleThreadModel) return;

    // Call the initialization method of this servlet
    try {
        // 接下来 loadServlet 方法触发 BEFORE_INIT_EVENT 事件，并调用发送者的 init 方法。
        instanceSupport.fireInstanceEvent(InstanceEvent.BEFORE_INIT_EVENT,
                                          servlet);

        if( Globals.IS_SECURITY_ENABLED) {
            boolean success = false;
            try {
                Object[] args = new Object[] { facade };
                SecurityUtil.doAsPrivilege("init",
                                           servlet,
                                           classType,
                                           args);
                success = true;
            } finally {
                if (!success) {
                    // destroy() will not be called, thus clear the reference now
                    SecurityUtil.remove(servlet);
                }
            }
        } else {
            //因此，当 StandardWrapper 对象调用 Servlet 实例的 init 方法的时候，它传递 的是一个 StandardWrapperFacade 对象。
            // 在 Servlet 内部调用 ServletConfig 的 getServletName, getInitParameter, 和 getInitParameterNames 方法只需
            // 要调用它们在 StandardWrapper 的实现就行。
            servlet.init(facade);
        }

        instanceInitialized = true;

        instanceSupport.fireInstanceEvent(InstanceEvent.AFTER_INIT_EVENT,
                                          servlet);
    } catch (UnavailableException f) {
        instanceSupport.fireInstanceEvent(InstanceEvent.AFTER_INIT_EVENT,
                                          servlet, f);
        unavailable(f);
        throw f;
    } catch (ServletException f) {
        instanceSupport.fireInstanceEvent(InstanceEvent.AFTER_INIT_EVENT,
                                          servlet, f);
        // If the servlet wanted to be unavailable it would have
        // said so, so do not call unavailable(null).
        throw f;
    } catch (Throwable f) {
        ExceptionUtils.handleThrowable(f);
        getServletContext().log("StandardWrapper.Throwable", f );
        instanceSupport.fireInstanceEvent(InstanceEvent.AFTER_INIT_EVENT,
                                          servlet, f);
        // If the servlet wanted to be unavailable it would have
        // said so, so do not call unavailable(null).
        throw new ServletException
            (sm.getString("standardWrapper.initException", getName()), f);
    }
}

  instanceInitialized控制只初始化一次，而Servlet真正的初始化代码在servlet.init(facade);这一行。 其他的都是一些事件处理，因此Servlet在每次创建时都会调用其init()方法，有且仅有一次，在具体分析Servlet的init()方法时，先来看看Servlet的种类。

Servlet种类

  根据请求的的资源不同的种类，可以把Servlet分为三种类别，比如请求可能访问一个普通的Servlet，也可能访问一个JSP页面，也可以访问的是一个静态资源，根据对这些不同的类别的处理方式，可以分为三种Servlet，如图10.6所示，一个请求到达Tomcat后将由URI映射器根据请求的URI进行建模， 它会计算出请求发往哪个 Host 容器的哪个Context容器的哪个Wrapper 处理， 在路由的Wrapper 容器时会通过一定的算法选择不同的Servlet进行处理，比如，普通Servlet请求由路由到普通的Servlet，JSP则路由到JspServlet ，而静态资源则路由到DefaultServlet 。
Servlet路径的匹配规则如下
首先，尝试使用精确匹配法匹配精确的类型Servlet 的路径 。
然后，尝试使用前缀匹配通配符类型的Servlet。
接着，尝试使用扩展名匹配通配符类型的Servlet
最后匹配默认的Servlet。
如果一个请求到来，则通过以上规则匹配对应的Servlet，例如请求http://localhost:8080/test 精确匹配test的Servlet ，而http://localhost:8080/test.jsp，则会匹配*.jsp 的JspServlet ，下面分别讨论三种不同的Servlet 。

1. 普通Servlet

  普通Servlet就是我们最常见的Servlet，做Web开发都会涉及Servlet，要处理业务逻辑就会自己定义Servlet进行处理， 这就是普通的Servlet，编写好后Servlet通过配置web.xml文件就可以完成部署。 配置格式如下。

    my
    com.example.servelettest.HelloServlet



    my
    /test

2. JspServlet

  Web应用开发人员一般对这个Servlet比较陌生，因为他们不会直接与它打交道，既然是Servlet，那么肯定要声明后才被部署使用， 它被部署到Tomcat的安装目录下conf目录下的web.xml文件中，这里的web.xml文件是Tomcat的全局Web描述文件，JspServlet的配置如下 。

    jsp
    org.apache.jasper.servlet.JspServlet
    
        fork
        false
    
    
        xpoweredBy
        false
    
    
        trimSpaces
        false
    
    3





    jsp
    *.jsp
    *.jspx

  可以看到，所以以.jsp 和.jspx 结尾的请求都会被JspServlet处理，它包揽了所有的JSP页面的处理， 我们知道JSP页面最终也是会被Tomcat 编译成相应的Servlet，如果想看详细的编译过程，请看之前的博客 Tomcat 源码解析一JSP编译器Jasper-佛怒火莲 系列， 而这些Servlet的处理都次给了JspServlet 。
  JspServlet处理逻辑大致如下 。
  a) 判断是不是第一次访问Servlet，如果是，则会先编译JSP页面，殷富一定的包和类名规则生成相应的Servlet类。
  b) 加载刚刚编译好的JSP Serlvet类，并初始化它们
  c) 调用刚刚加载好的JSP Servlet的service方法，处理请求。
至此完成了JSP页面的请求。

3. DefaultServlet

  同样是Tomcat内部使用的一个Servlet ，DefaultServlet是Tomcat专门提供用于处理静态资源的Servlet，它同样被部署到Tomcat安装目录下的conf目录下的web.xml文件中，DefaultServlet的配置如下 。

    default


    org.apache.catalina.servlets.DefaultServlet
    
        debug
        0
    
    
        listings
        
        true
    
    1





    default
    /

  可以看到所有的URI请求都会被匹配，但由于 Mapper组件匹配Servlet时将DefaultServlet放到最后才匹配，所以它并不会把所有的请求都拦截下来， 只有那些经过精确匹配，前缀匹配，扩展名匹配等还没有匹配上的，才会留给DefaultServlet，DefaultServlet通过JNDI根据URI在tomcat内部查找资源，然后以该资源响应客户端 。

  首先来看DefaultServlet的初始化。在之前的博客也分析过这一块。 Tomcat 源码解析一容器加载-大寂灭指(下)，但今天继续回顾一下。在DefaultServlet的init()中打一个断点。启动Tomcat

  先看是哪里调用了DefaultServlet的初始化方法。

  从调用链中得知，是StandardContext在启动时调用了所有子容器的load()方法。

  进而调用了servlet.init(facade);方法，但StandardWrapper中，facade的默认值为StandardWrapperFacade facade = new StandardWrapperFacade(this); 而this就是StandardWrapper。

  getServletConfig()事实上就是StandardWrapper

  而里面的这些参数配置默认来源于catalina.base/conf/web.xml

    default


    org.apache.catalina.servlets.DefaultServlet
    
        debug
        0
    
    
        listings
        true
    
    1

  先不分析这些参数有什么作用，后面使用到再来分析。

  接下来看JspServlet的初始化。 同样JspServlet也是在StandardContext启动时进行初始化。

public void init(ServletConfig config) throws ServletException {

    super.init(config);
    this.config = config;
    this.context = config.getServletContext();

    // Initialize the JSP Runtime Context
    // Check for a custom Options implementation
    // 允许指定的类来配置 Jasper。如果没有指定，则使用默认的 Servlet 内置参数(EmbeddedServletOptions)。
    String engineOptionsName = config.getInitParameter("engineOptionsClass");
    if (Constants.IS_SECURITY_ENABLED && engineOptionsName != null) {
        log.info(Localizer.getMessage(
                "jsp.info.ignoreSetting", "engineOptionsClass", engineOptionsName));
        engineOptionsName = null;
    }
    if (engineOptionsName != null) {
        // Instantiate the indicated Options implementation
        try {
            ClassLoader loader = Thread.currentThread().getContextClassLoader();
            Class engineOptionsClass = loader.loadClass(engineOptionsName);
            Class[] ctorSig = { ServletConfig.class, ServletContext.class };
            Constructor ctor = engineOptionsClass.getConstructor(ctorSig);
            Object[] args = { config, context };
            options = (Options) ctor.newInstance(args);
        } catch (Throwable e) {
            e = ExceptionUtils.unwrapInvocationTargetException(e);
            ExceptionUtils.handleThrowable(e);
            // Need to localize this.
            log.warn("Failed to load engineOptionsClass", e);
            // Use the default Options implementation
            options = new EmbeddedServletOptions(config, context);
        }
    } else {
        // Use the default Options implementation
        options = new EmbeddedServletOptions(config, context);
    }
    rctxt = new JspRuntimeContext(context, options);
    if (config.getInitParameter("jspFile") != null) {
        jspFile = config.getInitParameter("jspFile");
        try {
            if (null == context.getResource(jspFile)) {
                throw new ServletException("missing jspFile: [" + jspFile + "]");
            }
        } catch (MalformedURLException e) {
            throw new ServletException("Can not locate jsp file", e);
        }
        try {
            if (SecurityUtil.isPackageProtectionEnabled()){
               AccessController.doPrivileged(new PrivilegedExceptionAction