上一篇博客 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 configureString 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 classtry {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 authenticatorsProperties 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 skipaddJarsToSkip(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 holeif (constraints != null && disableProxyCaching &&!"POST".equalsIgnoreCase(request.getMethod())) {if (securePagesWithPragma) {// Note: These can cause problems with downloading files with IEresponse.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 constraintif (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 satisfiedif (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 needboolean unavailable = false;Throwable throwable = null;// This should be a Request attribute...long t1=System.currentTimeMillis();requestCount.incrementAndGet();StandardWrapper wrapper = (StandardWrapper) getContainer(); // 属于哪个WrapperServlet servlet = null;Context context = (Context) wrapper.getParent();  // 属于哪个Context// Check for the application being marked unavailableif (!context.getState().isAvailable()) {// 如果容器的状态不可用，则返回503response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE,sm.getString("standardContext.isUnavailable"));unavailable = true;}// Check for the servlet being marked unavailable// 如果Context可用，但是Wrapper不可用, 在定义servlet时，可以设置enabledif (!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 requesttry {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 allocatedboolean 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 requestApplicationFilterFactory 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 chainrequest.setComet(false);// Call the filter chain for this request// NOTE: This also calls the servlet's service() methodtry {if ((servlet != null) && (filterChain != null)) {// Swallow output if neededif (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 requestif (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 instancetry {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 instancetry {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 exceptionif (unloading) {throw new ServletException(sm.getString("standardWrapper.unloading", getName()));}boolean newInstance = false;// If not SingleThreadedModel, return the same instance every timeif (!singleThreadModel) {// Load and initialize our instance if necessaryif (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// 分配实例的次数+1countAllocated.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) {// 新生成了一个实例后，把实例放入instancePoolif (newInstance) {// Have to do this outside of the sync above to prevent a// possible deadlocksynchronized (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 creationif (!newInstance) {// 分配实例的次数加1，如果是新创的实例，在上面就会加1countAllocated.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 requiredif (!singleThreadModel) {// 分配次数-1countAllocated.decrementAndGet();return;}// Unlock and free this instancesynchronized (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 poolif (!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 specifiedif (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 ClassLoaderthrow 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=36630if(log.isDebugEnabled()) {log.debug(sm.getString("standardWrapper.instantiate", servletClass), e);}// Restore the context ClassLoaderthrow 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. 初始化servletinitServlet(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 servlettry {// 接下来 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 nowSecurityUtil.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文件就可以完成部署。 配置格式如下。

mycom.example.servelettest.HelloServlet
my/test

2. JspServlet

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

jsporg.apache.jasper.servlet.JspServletforkfalsexpoweredByfalsetrimSpacesfalse3jsp*.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的配置如下 。

defaultorg.apache.catalina.servlets.DefaultServletdebug0listingstrue1default/

  可以看到所有的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

defaultorg.apache.catalina.servlets.DefaultServletdebug0listingstrue1

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

  接下来看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 implementationtry {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 implementationoptions = new EmbeddedServletOptions(config, context);}} else {// Use the default Options implementationoptions = 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