StandardWrapper

Tomcat中有四种类型的Servlet容器，分别是 Engine、Host、Context、Wrapper,每个Wrapper实例表示一个具体的Servlet定义，StandardWrapper就是Catalina中的Wrapper接口的标准实现.

方法调用序列：指的是每当服务器接收到Http请求时，服务器中调用的一系列方法，对于每个引入的HTTP请求，连接器都会调用与其关联的Servlet容器的 invoke方法，然后，Servlet容器会调用其所有子容器的invoke方法，

具体的过程看下面：

1. 连接器创建request和response对象；
2. 连接器调用StandardContext实例的invoke方法，
3. 接着StandardContext实例的invoke方法会调用其管道对象的额invoke方法，StandardContext对象的基础阀是StandardContextValue类的实例，因此StandardContext的管道对象会调用其基础阀的invoke方法，
4. StandardContextValue实例的invoke方法会获取响应的Wrapper实例来处理HTTP请求，调用Wrapper实例的invoke方法
5. StandardWrapper类是Wrapper接口的标准实现，StandardWrapper对象会调用其管道对象的invoke方法。
6. StandardWrapper对象的基础阀是StandardWrapperValue类的实例，因此会调用StandardWrapperValue的invoke方法,其invoke方法会调用Wrapper实例的allocate方法获取servlet实例；
7. allocate方法会调用load方法载入相应的servlet类，若已经载入，咋无需重复载入，
8. load方法会调用servlet实例的init方法
9. StandWrapperValue调用Servlet实例的service方法

注意：StandardContext和StandardWrapper两个类的构造函数都设置了响应的基础阀作为其基础阀，

SingleThreadModel

servlet类可以实现javax.servlet.SingleThreadModel接口，这样的Servlet类与被称为STM Servlet类，根据Servlet规范，实现此接口的目的是保证Servlet类实例一次只能处理一个请求，下面给出点Servlet2.规范中，SRV.14.2.21一节的内容

若Servlet类实现了SingleThreadModel接口，则可以保证绝不会有两个线程同时执行该Servlet实例的service方法，这一点由Servlet容器通过控制对单一Servlet实例的同步访问实现，或者维护一个Servlet实例池，然后将每个新请求分派给一个空闲的Servlet实例

该接口并不能方法之Servlet访问共享资源造成的同步问题，例如访问类的静态变量或访问Servlet作用域之外的类，

事实上 实现了SingleThreadModel接口的Servlet类只能保证在同一时刻，只有一个线程在执行该Servlet实例的service方法，但是为了提高执行性能，Servlet容器会创建多个同一（Servlet类）的STM Servlet实例，也就说，STM Servlet实例的service方法会在多个STM Servlet实例中并发的执行，如果Servlet实例需要访问静态类变量或类外的某些资源的话，就有可能引起同步问题。

多线程的虚假安全性

在Servlet 2.4 规范中，SingleThreadModel接口已经弃用了，因为他会使Servlet程序员误以为实现了该接口的Servlet类就是多线程安全的，但是Servlet2.3 和 2.4规范还对该接口提供了支持。

StandardWrapper

StandardWrapper对象主要任务是载入它多代表的servlet类，并进行实例化，但是，StandardWrapper类并不调用 Servlet类的service方法，该任务是由StandardWrapperValue对象（StandardWrapper实例管道对象的的基础阀）完成的，StandardWrapperValue对象通过调用与其关联的StandardWrpper类的allocate方法从StandardWrapper实例中获取Servlet实例，在获得了Servlet实例之后，StandardWrapperValue实例就会调用 Servlet实例的service方法，。

当第一次请求某个Servlet类时，StandardWrapper载入Servlet类，由于StandardWrapper实例会动态的载入该Servlet类，因此，它必须知道该Servlet类的完全限定名，可以调用StandardWrapper的setServletClass方法指定该servlet类的完全限定名，也可以调用其setName方法为该servlet类指定一个名字，

置于当StandardWrapperValue实例请求 加载 Servlet实例时，，StandardWrapper实例必须考虑到该Servlet类是否实现了SingleThreadModel接口，对于那些没有实现SingleThreadModel接口的servlet类，StandardWrapper只会载入该servlet类一次，并对随后的请求都返回该servlet类的同一个实例，StandardWrapper实例不需要多个servlet实例，因为它假设该servlet类的service方法在多线程环境中是线程安全的，如果必要的话，由servlet程序员来负责同步对共享资源的访问，

面对一个STM servlet类，事情就不同了，StandardWrapper实例必须保证每个时刻只能有一个线程在执行STM servlet实例的 service方法，如果StandardWrapper实例只维护一个STM servlet实例的话，下面是可能出现调用STM servlet实例的 service方法的代码

 Servlet instance = wrapper.allocate();//从wrapper中获取了一个 servlet实例
        if((instance  instanceof SingleThreadModel)){
            synchronized (instance) {
                instance.service(request, response);
            }
        }else{
            instance.service(request, response);
        }

但是为了获得更好的性能，StandardWrapper实例会维护一个STM servlet实例池，Wrapper实例负责准备一个javax.servlet.servletConfig实例，后者在servlet实例内部可以获取到，

分配servlet实例

StandardWrapper实例的invoke方法会调用Wrapper实例的allocate方法获取请求的servlet的一个实例，因此StandardWrapper要实现allocate方法，给大家看下 其方法签名

/**
     * 
     * 分配这个Servlet的初始化实例，该实例准备调用它的<code>service()</code>方法。如果servlet类没有实现
     * <code>SingleThreadModel</code>， 则可以立即返回（唯一的 后续再有请求该servlet的请求
     * 不会再创建新的实例）初始化实例。如果servlet类实现<code>SingleThreadModel</code>，
     * 则Wrapper实现必须确保这个实例在通过调用<code>deallocate()</code>释放之前不会被再次分配。
     *
     * @exception ServletException
     *                如果servlet init()方法抛出异常
     * 
     * @exception ServletException
     *                如果发生加载错误
     */
    public Servlet allocate() throws ServletException {

注意：allocate方法返回请求servlet的一个实例，因为要支持 STM servlet，allocate方法需要变得复杂一点，事实上为了处理 STM servlet类 和 非STM servlet，allocate方法分为两个部分，第一部分

 if (!singleThreadModel) {  //返回一个 一个 非STM servlet的实例  } 

布尔变量 singleThreadModel用来标明该StandardWrapper实例标志的servlet类是否是STM servlet，该变量的初始值是false，LoadServlet方法会检查它正在载入的Servlet类是不是一个STM Servlet类，并根据结果修改变量singleThreadModel的值，

注意（）

下面看下第一部分 和第二部分

对于非STM Servlet类，StandardWrapper类定义了一个 名为 instance,类型为 javax.servlet.Servlet的变量

/**
     * 若该 {@code StandardWrapper} 实例 所代表的Servlet 为非（{@link SingleThreadModel}
     * Servlet）类， 则代表的该Servlet 只会被创建一次 ，{@code instance}存储只创建一次的Servlet实例
     */
    private Servlet instance = null;

allocate方法 会检查变量 instance 是否是 null,若是 则allocate方法调用LoadServlet方法载入相关的Servlet类，然后 将整型变量 countAllocated的值加1，并返回 instance的值代码如下

// 如果不是SingleThreadedModel，每次返回相同的实例
        if (!singleThreadModel) {
            // 返回一个 一个 非STM servlet的实例

            // Load and initialize our instance if necessary
            if (instance == null) {
                synchronized (this) {
                    if (instance == null) {
                        try {
                            instance = loadServlet();
                        } catch (ServletException e) {
                            throw e;
                        } catch (Throwable e) {
                            throw new ServletException(sm.getString("standardWrapper.allocate"), e);
                        }
                    }
                }
            }

            if (!singleThreadModel) {
                if (debug >= 2)
                    log("  Returning non-STM instance");
                //将当前活动的Servlet数 加1 
                countAllocated++;
                return (instance);
            }

        }

若StandardWrppper表示的Servlet类是一个STM Servlet类，则allocate方法会试图从对象池中返回一个Servlet实例，变量 instancePool是一个 java.util.Stack类型的栈，其中保存了所有的STM Servlet实例，

   /**
     * instancePool是一个 {@link java.util.Stack}类型的栈，其中保存了所有的STM Servlet实例
     */
    private Stack instancePool = null;

该变量在LoadServlet方法中初始化

只要STM Servlet实例数量不超过指定的最大数，allocate会返回一个STM Servlet实例。整型变量 maxInstances保存了在栈中存储的STM Servlet实例的最大值，默认值是20

  /** * 整型变量 maxInstances 保存了在栈中存储的STM Servlet实例的最大值，默认值是20  */  private int maxInstances = 20; 

为了跟踪当前 wrapper中 STM Servlet实例的数量，StandardWrapper类使用整型变量 nInstances来保存这个数值。

/**
     * 为了跟踪当前 wrapper中 STM Servlet实例的数量，StandardWrapper类使用整型变量 nInstances来保存这个数值。
     */
    private int nInstances = 0;

下面是allocate方法的第二部分

synchronized (instancePool) {
            // 为毛这样写呢 因为 就算该Wrapper代表的是 STM servlet，第一次执行alllocate方法的时候
            // 布尔变量 singleThreadModel 的值 是为false的，它会执行上面第一部分 非 STM servlet加载流程，
            // 在其调用loadServlet方法是时 其方法内部会根据 是否是继承了 SingleThreadModel接口来
            // 修改布尔变量singleThreadModel的值
            // 所以初始到这里时 为 countAllocated = 0 nInstances = 0；
            // 然后在while循环中直到 STM Servlet实例的数量与要大于 countAllocated 循环中 只会 将
            // nInstances的数量增加 而 countAllocated是在循环结束后增加
            while (countAllocated >= nInstances) {
                // 如果可能的话，分配一个新的实例，或者等待
                if (nInstances < maxInstances) {
                    // 如果当前活动的STM Servlet实例数量 没有达到允许的最大上限 则 创建新的 Servlet实例
                    // 并将其加入到 STM Servlet 实例池中
                    try {
                        instancePool.push(loadServlet());
                        // 将活动的STM Servlet实例数量 加 1
                        nInstances++;
                    } catch (ServletException e) {
                        throw e;
                    } catch (Throwable e) {
                        throw new ServletException(sm.getString("standardWrapper.allocate"), e);
                    }
                } else {
                    try {
                        // 若 当前活动的 STM servlet实例 数量已经达到了最大值 则将线程挂起 等待 有被用完的 STM
                        // serlvlet实例 被放回到栈中
                        instancePool.wait();
                    } catch (InterruptedException e) {
                        ;
                    }
                }
            }
            if (debug >= 2)
                log("  Returning allocated STM instance");
            // 将当前StandardWrapper中活动的 servlet实例数加一
            countAllocated++;
            // 并将 栈顶的STM servlet实例 取出
            return (Servlet) instancePool.pop();

        }

载入Servlet类

StandardWrapper实例实现了 Wrapper接口的 load方法，load方法调用 loadServlet方法载入某个Servlet类，并调用其init方法，此时要传入一个 javax.servlet.ServletConfig实例作为参数，下面展示一下 loadServlet方法是怎么工作的

loadServlet方法首先会检查当前的StandardWrapper类是否表示的是一个STM Servlet类，若不是 且 变量 instance不为null （表示以前已经载入过这个Servlet类）。它就直接返回该实例

/**
     * 
     * 
     * 如果还没有至少一个初始化的实例，则加载并初始化此servlet的实例。例如，这可以用于加载部署描述符中标记的、
     * 要在服务器启动时加载的servlet。
     */
    public synchronized Servlet loadServlet() throws ServletException {

        // 检查该StandardWrapper类表示的是否是一个STM Servlet类，若不是，且 instance变量
        // 不为null(代表之前载入过这个servlet类)，直接返回该实例
        if (!singleThreadModel && (instance != null))
            return instance;

若instance 为 null 或者 该servlet实例是一个STM servlet，则执行后续的方法，、

首先，它会获取System.out和 System.error的输出，便于它使用javax.servlet.ServletContext的log方法记录日志信息

 PrintStream out = System.out; 2 SystemLogHandler.startCapture(); 

然后它定义类型为javax.servler.Servlet名为servlet的变量，变量servlet表示已经载入的servlet实例，该实例将会有loadServlet方法返回

// 变量servlet表示已经载入的servlet实例，该实例将会有loadServlet方法返回
        Servlet servlet = null;

LoadServlet方法负责载入该Servlet类，原先类名会保存在类变量 ServletClass中，现在loadServlet方法要将变量名写入到字符串actualClass中;

//LoadServlet方法负责载入该Servlet类，原先类名会保存在类变量 ServletClass中，现在loadServlet方法要将变量名写入到字符串actualClass中;
            String actualClass = servletClass;

但是由于Catalina也是一个JSP容器，因此loadServlet方法必须检查请求的Servlet是不是一个jsp页面，若是，LoadServlet方法需要获取代表该JSP页面的实际的servlet类；

            //因为Catalina也是一个JSP容器，因此loadservlet方法必须检查请求的servlet是不是一个JSP页面，若是 loadServlet方法需要获取代表该JSP页面的实际servlet类
            if ((actualClass == null) && (jspFile != null)) {
                Wrapper jspWrapper = (Wrapper) ((Context) getParent()).findChild(Constants.JSP_SERVLET_NAME);
                if (jspWrapper != null)
                    actualClass = jspWrapper.getServletClass();
            }

如果找不到该JSP页面的实际的servlet类，则会使用变量 servletClass的值，但是若是没有调用StandardWrapper类的setServletClass方法设置ServletClass的值，则会抛出异常，并停止执行后续运行的方法

// 如果找不到该JSP页面的实际的servlet类，则会使用变量
            // servletClass的值，但是若是没有调用StandardWrapper类的setServletClass方法设置ServletClass的值，则会抛出异常，并停止执行后续运行的方法
            if (actualClass == null) {
                unavailable(null);
                throw new ServletException(sm.getString("standardWrapper.notClass", getName()));
            }

这时 要载入的Servlet类名已经解析完成，loadServlet方法会获取载入器，若找不到载入器则它会抛出异常，方法终止

// 这时 要载入的Servlet类名已经解析完成，loadServlet方法会获取载入器，若找不到载入器则它会抛出异常，方法终止
            Loader loader = getLoader();
            if (loader == null) {
                unavailable(null);
                throw new ServletException(sm.getString("standardWrapper.missingLoader", getName()));
            }

若可以找到载入器，则loadServlet方法会调用载入器的getClassLoader方法获取一个ClassLoader；

// 若可以找到载入器，则loadServlet方法会调用载入器的getClassLoader方法获取一个ClassLoader；
            ClassLoader classLoader = loader.getClassLoader();

在org.apache.catalina包下，Catalina提供了一写用于访问Servlet容器内部数据的专用Servlet类，如果某个Servlet类时这种专用的Servlet，即 isContainerProviededServlet方法返回true，则变量classLoader的赋值为另外一种ClassLoader实例，如此一来，

这个通过特殊classLoader加载出来的Servlet实例就可以访问Catalina内部数据了。

            // 在org.apache.catalina包下，Catalina提供了一写用于访问Servlet容器内部数据的专用Servlet类，如果某个Servlet类时这种专用的Servlet，即
            // isContainerProviededServlet方法返回true，则变量classLoader的赋值为另外一种ClassLoader实例，如此一来，
            // 这个通过特殊classLoader加载出来的Servlet实例就可以访问Catalina内部数据了。
            if (isContainerProvidedServlet(actualClass)) {
                classLoader = this.getClass().getClassLoader();
                log(sm.getString("standardWrapper.containerServlet", getName()));
            }

有了载入器和准备载入的Servlet类名之后，loadServlet方法就可以载入Servlet类了

//有了载入器和准备载入的Servlet类名之后，loadServlet方法就可以载入Servlet类了
            Class classClass = null;
            try {
                if (classLoader != null) {
                    System.out.println("Using classLoader.loadClass");
                    classClass = classLoader.loadClass(actualClass);
                } else {
                    System.out.println("Using forName");
                    classClass = Class.forName(actualClass);
                }
            } catch (ClassNotFoundException e) {
                unavailable(null);
                throw new ServletException(sm.getString("standardWrapper.missingClass", actualClass), e);
            }
            if (classClass == null) {
                unavailable(null);
                throw new ServletException(sm.getString("standardWrapper.missingClass", actualClass));
            }

然后实例化该Servlet类

//然后 实例化该Servlet类
            try {
                servlet = (Servlet) classClass.newInstance();
            } catch (ClassCastException e) {
                unavailable(null);
                // Restore the context ClassLoader
                throw new ServletException(sm.getString("standardWrapper.notServlet", actualClass), e);
            } catch (Throwable e) {
                unavailable(null);
                // Restore the context ClassLoader
                throw new ServletException(sm.getString("standardWrapper.instantiate", actualClass), e);
            }

在实例化之后 立即检查该Servlet是否允许载入，若不允许立即终止

// 实例化Servlet类之后 会立即检查该Servlet类是否允许载入 若不允许载入 终止 
            if (!isServletAllowed(servlet)) {
                throw new SecurityException(sm.getString("standardWrapper.privilegedServlet", actualClass));
            }

若通过了安全检查，它会继续检查该Servlet类是否是一个ContainerServlet类型的Servlet，实现了org.apache.catalina.ContainerServlet接口的Servlet可以访问Catalina的内部功能，若该servlet类是一个ContainerServlet，loadServlet方法会调用

ContainerServlet接口的setWrapper方法，传入这个StandardWrapper实例。

// 若通过了安全检查，它会继续检查该Servlet类是否是一个ContainerServlet类型的Servlet，实现了org.apache.catalina.ContainerServlet接口的Servlet可以访问Catalina的内部功能，若该servlet类是一个ContainerServlet，loadServlet方法会调用
            // ContainerServlet接口的setWrapper方法，传入这个StandardWrapper实例。
            if ((servlet instanceof ContainerServlet) && isContainerProvidedServlet(actualClass)) {
                System.out.println("calling setWrapper");
                ((ContainerServlet) servlet).setWrapper(this);
                System.out.println("after calling setWrapper");
            }

接下来，loadServlet方法触发 BEFORE_INIT_EVENT事件，调用Servlet实例的init方法

// 接下来，loadServlet方法触发 BEFORE_INIT_EVENT事件，调用Servlet实例的init方法
            try {
                instanceSupport.fireInstanceEvent(InstanceEvent.BEFORE_INIT_EVENT, servlet);
                //facade 为 javax.servlet.ServletConfig对象的一个外观变量
                servlet.init(facade);

继续展示下一部分代码前 先引入一个 变量的解释 loadOnStartup

我们在web.xml中配置servlet的时候会有个属性<load-on-startup></load-on-startup>，这里主要记一下它的作用，源码在后续记得好好看一下。

The load-on-startup element indicates that this servlet should be loaded (instantiated and have its init() called) on the startup of the web application. The optional contents of these element must be an integer indicating the order in which the servlet should be loaded. If the value is a negative integer, or the element is not present, the Container is free to load the servlet whenever it chooses.   If the value is a positive integer or 0, the container must load and initialize the servlet as the application is deployed. The container must guarantee that servlets marked with lower integers are loaded before servlets marked with higher integers. The container may choose the order of loading of servlets with the same load-on-start-up value.
意思大概：

1. load-on-startup 元素标记容器是否应该在web应用程序启动的时候就加载这个servlet，(实例化并调用其init()方法)。
2. 它的值必须是一个整数，表示servlet被加载的先后顺序。
3. 如果该元素的值为负数或者没有设置，则容器会当Servlet被请求时再加载。
4. 如果值为正整数或者0时，表示容器在应用启动时就加载并初始化这个servlet，值越小，servlet的优先级越高，就越先被加载。值相同时，容器就会自己选择顺序来加载。

初始值为-1；

/**
     * 
     * StandardWrapper代表的servlet的启动时加载顺序值（负值表示第一次调用时的加载）。
     * <p>
     * <b>load-on-startup</b>
     * 元素标记容器是否应该在web应用程序启动的时候就加载这个servlet，(实例化并调用其init()方法)。
     * 它的值必须是一个整数，表示servlet被加载的先后顺序。 如果该元素的值为负数或者没有设置，则容器会当Servlet被请求时再加载。
     * 如果值为正整数或者0时，表示容器在应用启动时就加载并初始化这个servlet，值越小，servlet的优先级越高，就越先被加载。值相同时，
     * 容器就会自己选择顺序来加载
     * </p>
     */
    private int loadOnStartup = -1;

若变量 loadOnstartup的值大于0，而被请求的Servlet类实际上是一个jsp页面，则也调用Servlet的service方法

// 若变量 loadOnstartup的值大于0，而被请求的Servlet类实际上是一个jsp页面，则也调用Servlet的service方法
                if ((loadOnStartup > 0) && (jspFile != null)) {
                    // Invoking jspInit
                    HttpRequestBase req = new HttpRequestBase();
                    HttpResponseBase res = new HttpResponseBase();
                    req.setServletPath(jspFile);
                    req.setQueryString("jsp_precompile=true");
                    servlet.service(req, res);
                }

接下来loadServlet方法会触发AFTER_INIT_EVENT事件

    //接下来loadServlet方法会触发AFTER_INIT_EVENT事件
                instanceSupport.fireInstanceEvent(InstanceEvent.AFTER_INIT_EVENT, servlet);

若StandardWrapper对象表示的Servlet类是一个STM servlet, 将SingleThreadModel类变量赋值为 true否则false 然后将该Servlet实例添加到STM servlet实例池中，因此会先判断变量 instancePool的值是否为null，若是则要给它赋值一个Stack对象：

            // 若StandardWrapper对象表示的Servlet类是一个STM servlet,
            // 将SingleThreadModel类变量赋值为 true否则false 然后将该Servlet实例添加到STM
            // servlet实例池中，因此会先判断变量 instancePool的值是否为null，若是则要给它赋值一个Stack对象：
            singleThreadModel = servlet instanceof SingleThreadModel;
            if (singleThreadModel) {
                if (instancePool == null)
                    instancePool = new Stack();
            }
            fireContainerEvent("load", this);

在finally代码块中，loadServlet方法停止捕获System.out 和 System.error对象，记录在早日ServletContext的log方法过程中产生的日志消息

finally {
            //停止捕获System.out 和 System.err对象，记录在载入ServletContext的log方法的过程中产生的日志消息
            String log = SystemLogHandler.stopCapture();
            if (log != null && log.length() > 0) {
                if (getServletContext() != null) {
                    getServletContext().log(log);
                } else {
                    out.println(log);
                }
            }
        }

最后返回已经载入的Servlet类

return servlet;

 ServletConfig对象

StandardWrapper类的LoadServlet在载入Servlet类后，会调用该Servlet实例的init方法，init方法需要传入一个javax.servlet.ServletConfig实例作为参数，那这个ServletCongfig 是咋被StandardWrapper类获取的捏，请看

/**
 * 
 * <p>
 * <b>Title:StandardWrapper.java</b>
 * </p>
 * <p>
 * Copyright:ChenDong 2018
 * </p>
 * <p>
 * Company:仅学习时使用
 * </p>
 * <p>
 * 类功能描述: 表示单个servlet定义的Wrapper接口的标准实现。不允许子容器，父容器必须是{@link Context}。
 * </p>
 * 
 * @author 陈东
 * @date 2018年12月1日 下午2:57:33
 * @version 1.0
 */
public final class StandardWrapper extends ContainerBase implements ServletConfig, Wrapper {

因为它本身就已经继承了 javax.servlet.ServletConfig接口，那么下面给大家展示一下ServletConfig接口的4个方法；

1. getServletContext()
2. getServletName()
3. getInitParameter
4. getInitParameterNames()

注意：StandardWrapper 类并不会将自身传递给Servlet实例的init方法，它会在一个StandardWrapperFacade实例中包装自身，将绝大多数的公共方法对 Servlet程序员隐藏起来。

先说下第一个方法：getServletContext方法 先看下方法签名xt getServletContext();

public ServletContext getServletContext() 

StandardWrapper实例肯定是StandardContext实例的子容器，也就是说StandardWrapper实例的父容器就是StandardContext实例，对于StandardContext对象来说，可以直接调用自身的getServletContext方法来获得一个ServletContext实例，下面是StandardWrapper中该方法的具体实现

/**
     * 返回与此{@link Servlet}关联的{@link ServletContext }上下文.
     */
    public ServletContext getServletContext() {

        if (parent == null)
            return (null);
        else if (!(parent instanceof Context))
            return (null);
        else
            return (((Context) parent).getServletContext());

    }

注意：从上面的代码也是可以看出 ，无法单独使用一个Wrapper实例来表示一个servlet类的定义，Wrapper实例必须存在于某个Context容器中，这样当调用其父容器的getServletContext方法时才能返回ServletContext类的一个实例

第二个方法 getServletName()

该方法返回Servlet类的名字，方法签名如下

java.lang.String getServletName();

那么在StandardWrapper中的实现如下

/**
     * 返回这个Servlet的名字.
     */
    public java.lang.String getServletName() {

        return (getName());

    }

该方法仅仅是简单调用了ContainerBase类（StandardWrapper的父类）的getName方法，ContainerBase类的 getName方法实现如下

public String getName() {

        return (name);

    }

可以通过setName方法设置变量name的值，通过传递Servlet的名称可以调用StandardWrapper实例的setName方法。

第三个方法 getInitParameter方法

该方法返回指定初始参数的值，该方法签名如下：

java.lang.String getInitParameter(java.lang.String name);

在StandardWrapper中，初始化参数存储在一个HashMap类型的名为parameters的变量中

    /**
     * 
     * 存储初始化参数的HashMap类型的变量，key值为参数名称
     */
    private HashMap parameters = new HashMap();

那么这个parameters是怎么填充值得呢？调用StandardWrapper类的addInitParameter方法，并传入参数的名字和对应的值来填充parameters的值

/**
     *
     * 向存储初始化参数的parameters变量中 添加一对新的初始化参数
     *
     * @param name
     *            要添加的初始化参数名称 Name of this initialization parameter to add
     * @param value
     *            要添加的初始参数的值
     */
    public void addInitParameter(String name, String value) {

        synchronized (parameters) {
            parameters.put(name, value);
        }
        fireContainerEvent("addInitParameter", name);

    }

那么StandardWrapper 中getInitParameter()方法的实现如下

/**
     *
     *
     * 返回指定名称的初始化参数值（如果有的话）；否则返回<code>null</code>.
     * 
     * @param name
     *            要检索的初始化参数的名称
     * 
     * 
     */
    public String getInitParameter(String name) {

        return (findInitParameter(name));

    }

其中findInitParameter方法接收一个指定的初始化参数名的字符串变量，调用HashMap变量 parameters的get方法获取初始化参数的值，下面是具体实现

/**
     * 返回指定名称的初始化参数值（如果有的话）；否则返回<code>null</code>.
     *
     * @param name
     *            要检索的初始化参数的名称
     */
    public String findInitParameter(String name) {

        synchronized (parameters) {
            return ((String) parameters.get(name));
        }

    }

第四个方法：getInitParameterNames（）方法

该方法返回所有初始化参数的名字的集合，实际上是一个枚举类型java.util.Enumeraton的实例，下面是该方法的签名

java.util.Enumeration getInitParameterNames();

那么在看下StandardWrapper中的具体实现

/**
     * 返回为该servlet定义的初始化参数名称集。如果没有定义，则返回空枚举。
     */
    public Enumeration getInitParameterNames() {

        synchronized (parameters) {
            return (new Enumerator(parameters.keySet()));
        }

    }

其中 Enumerator实现了java.util.Enumeration接口，

package org.apache.catalina.util;

import java.util.Collection;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Map;
import java.util.NoSuchElementException;

/**
 * 
 * <p>
 * <b>Title:Enumerator.java</b>
 * </p>
 * <p>
 * Copyright:ChenDong 2018
 * </p>
 * <p>
 * Company:仅学习时使用
 * </p>
 * <p>
 * 类功能描述:
 * 围绕Java2集合类对象Iterator包装枚举的适配器类，以便现有的返回枚举的API可以轻松地在新集合上运行。提供构造函数来容易地创建这样的包装器。
 * </p>
 * 
 * @author 26  * @date 2018年12月1日 下午4:01:40
 * @version 1.0
 */
public final class Enumerator implements Enumeration {

    // ----------------------------------------------------------- Constructors

    /**
     * 
     * 在指定集合的值上返回枚举。
     *
     * @param collection
     *            要返回枚举值的集合
     */
    public Enumerator(Collection collection) {

        this(collection.iterator());

    }

    /**
     * 在指定迭代器返回的值上返回枚举。
     *
     * 
     * 
     * @param iterator
     *            要被包装的迭代器
     */
    public Enumerator(Iterator iterator) {

        super();
        this.iterator = iterator;

    }

    /**
     * 在指定映射的所有value返回枚举
     *
     * @param map
     *            要返回枚举值得映射
     */
    public Enumerator(Map map) {

        this(map.values().iterator());

    }

    // ----------------------------------------------------- Instance Variables

    /**
     * 
     * 这个类所表示的<code>Enumeration</code>实际操作的<code>Iterator</code>。
     */
    private Iterator iterator = null;

    // --------------------------------------------------------- Public Methods

    /**
     * 
     * 检查该枚举是否包含更多元素
     * 
     * 
     * @return 当且仅当该枚举对象包含要提供的至少一个元素，则为<code>true</code>，否则为<code>true</code>
     */
    public boolean hasMoreElements() {

        return (iterator.hasNext());

    }

    /**
     * 如果该枚举要提供至少一个元素，则返回该枚举的下一个元素.
     *
     * @return 这个枚举的下一个元素
     *
     * @exception NoSuchElementException
     *                如果没有更多的元素存在
     */
    public Object nextElement() throws NoSuchElementException {

        return (iterator.next());

    }

}

 Servlet容器的父子关系

Wrapper实例代表一个Servlet实例，因此Wrapper实例不能再有子容器了，不应该在调用其addChild方法，否则抛出java.lang.IllegalStateException异常，下面是StandardWrapper类中的addChild方法的实现；

/**
     * Wrapper实例代表一个Servlet实例，因此Wrapper实例不能再有子容器了，不应该在调用其addChild方法， 否则抛出{@code
     * java.lang.IllegalStateException}异常，下面是{@link StandardWrapper}类中的
     * {@code addChild}方法的实现；
     *
     * @param child
     *            要被添加的子容器
     */
    public void addChild(Container child) {

        throw new IllegalStateException(sm.getString("standardWrapper.notChild"));

    }

说完了子容器 也就是Wrapper 不能有儿子，但是人家是可以有老子滴，当然了Wrapper的父容器只能是Context类的实现，若是在调用Wrapper实例的setParaent方法时传入了一个非Context类型的容器，则会抛出

java.lang.IllegalAumentException异常

/**
     * 
     *
     * <dd>为当前的Container也就是StandardWrapper 设置父容器，其父容器只能是Context类的实现</dd>
     * 
     * 
     * @param container
     *            要设置的父容器
     * @exception IllegalArgumentException
     *                传入了一个非Context类型的容器
     */
    public void setParent(Container container) {

        if ((container != null) && !(container instanceof Context))
            throw new IllegalArgumentException(sm.getString("standardWrapper.notContext"));
        super.setParent(container);

    }

 StandardWrapperFacade

下面来谈一下 StandardWrapperFacade类 也就是 StandardWrapper的外观类，

咱们上面说到过，StandardWrapper实例会调用它所代表的Servlet实例的init方法，init方法需要一个javax.servlet.ServletConfig实例，而StandardWrapper类本身就实现了 javax.servlet.ServletConfig接口，所以理论上StandardWrapper可以将自己传入Servlet的init方法中，

但是StandardWrapper类要将其大部分公共方法对Servlet程序员隐藏起来，为了实现这个目的StandardWrapper类将自身实例包装成StandardWrapperFacade类的一个实例，这个其实就是外观类的设计模式，有兴趣可以学习一下，

StandardWrapper 与 StandardWrapperFacade 都共同继承了javax.servlet.ServletConfig接口，（就是想要使用的是一个什么样的外观类 就让它继承什么接口 这样外观类就有了需要使用的全部方法，然后外观类中会有一个声明成接口类型 原类私有实例 变量，且还有接口方法，方法的全部实现都调用原类的方法），那么下面就详细展示一体

StandardWrapper类使用下面的代码来创建StandardWrapperFacade类的一个实例，需要将自身的实例作为参数传入到StandardWrapperFacade类的构造函数中：

   /**
     * 该{@link StandardWrapper}类的 {@link ServletConfig}类型的外观类
     */
    private StandardWrapperFacade facade = new StandardWrapperFacade(this);

StandardWrapperFacde类提供了一个私有 ServletConfig类型的类级别的变量 config 来保存原类的实例

   /**
     * 保存 该外观类封装的 原类
     */
    private ServletConfig config = null;

当在StandardWrapper对象内部创建StandardWrapperFacde类的一个实例时，StandardWrapperFacade类的构造函数需要传入StandardWrapper对象，并未变量 config赋值

    /**
     * 创建一个包装了 指定 {@link StandardWrapper} 的外观类
     */
    public StandardWrapperFacade(StandardWrapper config) {

        super();
        this.config = (ServletConfig) config;

    }

因此在StandardWrapper 中 调用 Servlet 的 init方法时，会传入一个同样实现了javax.servlet.ServletConfig接口的 StandardWrapperFacade的一个实例，这样在Servlet实例内调用ServletConfig类的方法的时候，StandardWrapperFacade实例会直接调用 包装的StandardWrapper类的相应方法;

package org.apache.catalina.core;

import java.util.Enumeration;
import javax.servlet.ServletConfig;
import javax.servlet.ServletContext;

/**
 * 
 * <p>
 * <b>Title:StandardWrapperFacade.java</b>
 * </p>
 * <p>
 * Copyright:ChenDong 2018
 * </p>
 * <p>
 * Company:仅学习时使用
 * </p>
 * <p>
 * 类功能描述: {@link StandardWrapper }类的 {@link ServletConfig }类型的外观类
 * </p>
 * 
 * @author 陈东
 * @date 2018年12月1日 下午5:12:01
 * @version 1.0
 */
public final class StandardWrapperFacade implements ServletConfig {

    // ----------------------------------------------------------- Constructors

    /**
     * 创建一个包装了 指定 {@link StandardWrapper} 的外观类
     */
    public StandardWrapperFacade(StandardWrapper config) {

        super();
        this.config = (ServletConfig) config;

    }

    // ----------------------------------------------------- Instance Variables

    /**
     * 保存 该外观类封装的 原类
     */
    private ServletConfig config = null;

    // -------------------------------------------------- ServletConfig Methods

    /**
     * 返回Servlet的名称
     */
    public String getServletName() {
        return config.getServletName();
    }

    /**
     * 获取ServletContext 实例，这里 获取的是 ServletContext的外观类
     */
    public ServletContext getServletContext() {
        ServletContext theContext = config.getServletContext();
        if ((theContext != null) && (theContext instanceof ApplicationContext))
            theContext = ((ApplicationContext) theContext).getFacade();
        return (theContext);
    }

    /**
     * 返回指定的初始化参数 值
     */
    public String getInitParameter(String name) {
        return config.getInitParameter(name);
    }

    /**
     * 返回 所有初始化参数的名字枚举 若无初始化参数 则返回一个空的枚举
     */
    public Enumeration getInitParameterNames() {
        return config.getInitParameterNames();
    }

}

 对getServletContext方法会做一些处理 并不返回 ServletContext本身而是返回其外观类，

为了更好的理解 下面的 SrandardWrapperValue功能 ，首先引入一个新的组件定义：

FilterDef类

org.apache.catalina.deploy.FilterDef类表示一个过滤器定义，过滤器通常都是 在Tomcat 部署描述文件中定义filter元素

package org.apache.catalina.deploy;

import java.util.HashMap;
import java.util.Map;

/**
 * 
 * <p>
 * <b>Title:FilterDef.java</b>
 * </p>
 * <p>
 * Copyright:ChenDong 2018
 * </p>
 * <p>
 * Company:仅学习时使用
 * </p>
 * <p>
 * 类功能描述:Web应用程序的过滤器定义的表示，如部署描述符中的{@code <filter>}元素所示。
 * </p>
 * 
 * <p>
 * 该类中的全部属性 都对应 web部署描述中的{@code <filter>}元素 ,
 * </p>
 * <p>
 * {@code <filter>}元素中包含六个子元素
 * </p>
 * <p>
 * {@code icon }可选元素。该元素声明了一个供IDE使用的图片
 * </p>
 * <p>
 * {@code filter-name}必需元素，该元素给过滤器设置一个名称。
 * </p>
 * <p>
 * {@code display-name}可选元素。设置一个给IDE使用的简短名称
 * </p>
 * <p>
 * {@code description} 可选元素。该元素给IDE提供过滤器的文件文档内容
 * </p>
 * <p>
 * {@code filter-class} 必需元素。指定过滤器实现类的完全限定名。
 * </p>
 * <p>
 * {@code init-param} 可选元素，定义过滤器的初始化参数，一个过滤器可以包含多个初始化参数
 * </p>
 * 
 * 
 * @author 陈东
 * @date 2018年12月1日 下午9:23:03
 * @version 1.0
 */
public final class FilterDef {

    // ------------------------------------------------------------- Properties

    /**
     * （可选元素）该过滤器的说明
     */
    private String description = null;

    public String getDescription() {
        return (this.description);
    }

    public void setDescription(String description) {
        this.description = description;
    }

    /**
     * 此过滤器的显示名称.
     */
    private String displayName = null;

    public String getDisplayName() {
        return (this.displayName);
    }

    public void setDisplayName(String displayName) {
        this.displayName = displayName;
    }

    /**
     * （必须元素）实现此过滤器的Java类的完全限定名
     */
    private String filterClass = null;

    public String getFilterClass() {
        return (this.filterClass);
    }

    public void setFilterClass(String filterClass) {
        this.filterClass = filterClass;
    }

    /**
     * （必需元素）这个过滤器的名称，它必须在为特定web应用程序定义的过滤器中是唯一的.
     */
    private String filterName = null;

    public String getFilterName() {
        return (this.filterName);
    }

    public void setFilterName(String filterName) {
        this.filterName = filterName;
    }

    /**
     * 
     * （可选元素）与这个过滤器相关的大图标
     */
    private String largeIcon = null;

    public String getLargeIcon() {
        return (this.largeIcon);
    }

    public void setLargeIcon(String largeIcon) {
        this.largeIcon = largeIcon;
    }

    /**
     * 此过滤器的初始化参数集，由参数名键入。
     */
    private Map parameters = new HashMap();

    public Map getParameterMap() {

        return (this.parameters);

    }

    /**
     * 与此过滤器相关联的小图标.
     */
    private String smallIcon = null;

    public String getSmallIcon() {
        return (this.smallIcon);
    }

    public void setSmallIcon(String smallIcon) {
        this.smallIcon = smallIcon;
    }

    // --------------------------------------------------------- Public Methods

    /**
     * 向与此过滤器关联的参数集添加初始化参数
     *
     * @param name
     *            初始化参数的 name
     * @param value
     *            初始化参数的 value
     */
    public void addInitParameter(String name, String value) {

        parameters.put(name, value);

    }

    public String toString() {

        StringBuffer sb = new StringBuffer("FilterDef[");
        sb.append("filterName=");
        sb.append(this.filterName);
        sb.append(", filterClass=");
        sb.append(this.filterClass);
        sb.append("]");
        return (sb.toString());

    }

}

然后这里在啰嗦几句关于上面的过滤器定义类，FilterDef类中的每一个属性表示在定义filter元素时生命的子元素，上面有写哈，其中Map类型的变量 parameters存储了初始化过滤器时所需要的所有参数，addInitparameter方法用于向parameters中添加新的name/value形式的参数名和对应的值。

FilterMap

org.apache.catalina.deploy.FilterMap类 是 我们常常用的 <filter-mapping>元素的定义组件 这个就不细说了 代码上我都写了注释，有兴趣的可以展开看下

package org.apache.catalina.deploy;

import org.apache.catalina.util.RequestUtil;

/**
 * 
 * <p>
 * <b>Title:FilterMap.java</b>
 * </p>
 * <p>
 * Copyright:ChenDong 2018
 * </p>
 * <p>
 * Company:仅学习时使用
 * </p>
 * <p>
 * 类功能描述:Web应用程序的筛选器映射的表示，如部署描述符中的<code>&lt;filter-mapping&gt;</code>元素所示。
 * 每个筛选器映射必须包含筛选器名称加上URL模式或servlet名称。
 * </p>
 * <p>
 * 介绍一下 <code>&lt;filter-mapping&gt;</code>元素包含的几个子元素
 * </p>
 * <p>
 * {@code filter-name } 必需, 该元素 必需与{@code <filter>}元素中声明的匹配
 * </p>
 * <p>
 * {@code url-pattern} 必需，该元素 声明了一个以/或者以*开始的匹配模式，这个模式指定了过滤器所应用的URL，但一个元素内只能配置一个
 * 若希望该过滤器应用于 多个 URL匹配模式 则应该提供多个 <code>&lt;filter-mapping&gt;</code>元素
 * </p>
 * <p>
 * {@code servlet-name} 这个是搭配使用的 但是如果使用 就必须有值，该元素给出的名称必须匹配Servlet或JSP页面的名称，
 * </p>
 * 
 * @author 陈东
 * @date 2018年12月2日 下午3:03:29
 * @version 1.0
 */
public final class FilterMap {

    // ------------------------------------------------------------- Properties

    /**
     * 当该映射与特定请求匹配时要执行的过滤器的名称
     */
    private String filterName = null;

    public String getFilterName() {
        return (this.filterName);
    }

    public void setFilterName(String filterName) {
        this.filterName = filterName;
    }

    /**
     * 此映射匹配的servlet名称。
     */
    private String servletName = null;

    public String getServletName() {
        return (this.servletName);
    }

    public void setServletName(String servletName) {
        this.servletName = servletName;
    }

    /**
     * 此映射匹配的URL模式。
     */
    private String urlPattern = null;

    public String getURLPattern() {
        return (this.urlPattern);
    }

    public void setURLPattern(String urlPattern) {
        this.urlPattern = RequestUtil.URLDecode(urlPattern);
    }

    // --------------------------------------------------------- Public Methods

    /**
     * Render a String representation of this object.
     */
    public String toString() {

        StringBuffer sb = new StringBuffer("FilterMap[");
        sb.append("filterName=");
        sb.append(this.filterName);
        if (servletName != null) {
            sb.append(", servletName=");
            sb.append(servletName);
        }
        if (urlPattern != null) {
            sb.append(", urlPattern=");
            sb.append(urlPattern);
        }
        sb.append("]");
        return (sb.toString());

    }

}

ApplicationFilterConfig类

org.apache.catalina.core.ApplicationFilterConfig类实现了 javax.servlet.FilterConfig接口，ApplicationFilterConfig类用于管理Web应用程序第一次启动时，创建的所有的过滤器实例。

可以通过把一个 org.apcahe.catalina.Contex对象和 一个FilterDef对象传递给ApplicationFilterConfig的构造函数来创建一个ApplicationFilterConfig对象

    /**
     * 可以通过把一个{@link Context}对象 和一个 {@link FilterDef}对象传递给该构造函数，来创建一个新的
     * {@link ApplicationFilterConfig}实例
     *
     * @param context
     *            关联的Context
     * @param filterDef
     *            要构造{@code ApplicationFilterConfig}的过滤器定义
     *
     * @exception ClassCastException
     *                如果{@code FilterDef}中的 {@code filterClass}变量指定的类 没有实现
     *                <code>javax.servlet.Filter</code> 接口，抛出该异常。
     * 
     * @exception ClassNotFoundException
     *                如果{@code FilterDef}中的 {@code filterClass}变量指定的类
     *                没有被加载器找到，抛出异常 。
     * @exception IllegalAccessException
     *                如果{@code FilterDef}中的 {@code filterClass}变量指定的类
     *                不能公开实例化，抛出异常 。
     * @exception InstantiationException
     *                如果实例化{@code Filter}对象时发生异常
     * @exception ServletException
     *                如果被过滤器的{@code init}方法抛出异常
     */
    public ApplicationFilterConfig(Context context, FilterDef filterDef) throws ClassCastException,
            ClassNotFoundException, IllegalAccessException, InstantiationException, ServletException {

        super();
        this.context = context;
        setFilterDef(filterDef);

    }

 其中的Context表示的是一个Web应用程序，FilterDef对象表示一个过滤器的定义，

该类中使用一个 org.apcache.catalina,Context类型的 私有变量  context 来接收 构造函数 传入的 context对象

   /**
     * 与我们相关联的Context对象(代表一个Web应用程序)
     */
    private Context context = null;

利用setFilterDef方法来设置 过滤器定义，且分配一个新的过滤器实例，下面看下方法定义

   /**
     * 
     * 设置我们配置的 过滤器定义对象，并且还会有实例化该过滤器的功能
     * 
     * @param filterDef
     *            新的过滤器定义
     *
     * @exception ClassCastException
     *                如果{@code FilterDef}中的 {@code filterClass}变量指定的类 没有实现
     *                <code>javax.servlet.Filter</code> 接口，抛出该异常。
     * 
     * @exception ClassNotFoundException
     *                如果{@code FilterDef}中的 {@code filterClass}变量指定的类
     *                没有被加载器找到，抛出异常 。
     * @exception IllegalAccessException
     *                如果{@code FilterDef}中的 {@code filterClass}变量指定的类
     *                不能公开实例化，抛出异常 。
     * @exception InstantiationException
     *                如果实例化{@code Filter}对象时发生异常
     * @exception ServletException
     *                如果被过滤器的{@code init}方法抛出异常
     */
    void setFilterDef(FilterDef filterDef) throws ClassCastException, ClassNotFoundException, IllegalAccessException,
            InstantiationException, ServletException {

        this.filterDef = filterDef;
        if (filterDef == null) {

            // 释放任何先前分配的过滤器实例
            if (this.filter != null)
                this.filter.destroy();
            this.filter = null;

        } else {

            // 分配新的过滤器实例
            Filter filter = getFilter();

        }

    }

ApplicationFilterConfig类的 getFilter方法会返回一个javax,servler.Filter对象，该方法负责载入并实例化一个过滤器

/**
     * 返回已配置的应用程序过滤器器（{@code javax.servlet.Filter}）.
     *
     * @exception ClassCastException
     *                如果{@code FilterDef}中的 {@code filterClass}变量指定的类 没有实现
     *                <code>javax.servlet.Filter</code> 接口，抛出该异常。
     * 
     * @exception ClassNotFoundException
     *                如果{@code FilterDef}中的 {@code filterClass}变量指定的类
     *                没有被加载器找到，抛出异常 。
     * @exception IllegalAccessException
     *                如果{@code FilterDef}中的 {@code filterClass}变量指定的类
     *                不能公开实例化，抛出异常 。
     * @exception InstantiationException
     *                如果实例化{@code Filter}对象时发生异常
     * @exception ServletException
     *                如果被过滤器的{@code init}方法抛出异常
     */
    Filter getFilter() throws ClassCastException, ClassNotFoundException, IllegalAccessException,
            InstantiationException, ServletException {

        // 返回现有的过滤器实例，如果有的话
        if (this.filter != null)
            return (this.filter);

        // 标识我们将使用的类加载器 土话 就是 把我们想定义的Filter 的类的完全限定名 取出来
        String filterClass = filterDef.getFilterClass();
        ClassLoader classLoader = null;
        // 如果 我们要加载的Filter 是 Catalina包下的类 我们不需要使用 Context容器中的loader
        // 直接使用当前的系统类加载器就行了
        // 因为 loader的加载器 是有资源访问限制的 这就不细说了
        if (filterClass.startsWith("org.apache.catalina."))
            classLoader = this.getClass().getClassLoader();
        else
            classLoader = context.getLoader().getClassLoader();

        // 搞什么飞机
        ClassLoader oldCtxClassLoader = Thread.currentThread().getContextClassLoader();

        // 实例化此过滤器的一个新实例并返回它
        Class clazz = classLoader.loadClass(filterClass);
        this.filter = (Filter) clazz.newInstance();

        filter.init(this);
        return (this.filter);

    }

下面直接把全部代码贴出来

package org.apache.catalina.core;

import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Map;
import javax.servlet.Filter;
import javax.servlet.FilterConfig;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import org.apache.catalina.Context;
import org.apache.catalina.deploy.FilterDef;
import org.apache.catalina.util.Enumerator;

/**
 * 
 * <p>
 * <b>Title:ApplicationFilterConfig.java</b>
 * </p>
 * <p>
 * Copyright:ChenDong 2018
 * </p>
 * <p>
 * Company:仅学习时使用
 * </p>
 * <p>
 * 类功能描述:实现了<code>javax.servlet.FilterConfig</code>接口，
 * 用于管理Web应用程序第一次启动时创建的所有的过滤器实例
 * </p>
 * 
 * @author 陈东
 * @date 2018年12月1日 下午10:05:41
 * @version 1.0
 */
final class ApplicationFilterConfig implements FilterConfig {

    // ----------------------------------------------------------- Constructors

    /**
     * 可以通过把一个{@link Context}对象 和一个 {@link FilterDef}对象传递给该构造函数，来创建一个新的
     * {@link ApplicationFilterConfig}实例
     *
     * @param context
     *            关联的Context（表示一个Web应用程序）
     * @param filterDef
     *            要构造{@code ApplicationFilterConfig}的过滤器定义
     *
     * @exception ClassCastException
     *                如果{@code FilterDef}中的 {@code filterClass}变量指定的类 没有实现
     *                <code>javax.servlet.Filter</code> 接口，抛出该异常。
     * 
     * @exception ClassNotFoundException
     *                如果{@code FilterDef}中的 {@code filterClass}变量指定的类
     *                没有被加载器找到，抛出异常 。
     * @exception IllegalAccessException
     *                如果{@code FilterDef}中的 {@code filterClass}变量指定的类
     *                不能公开实例化，抛出异常 。
     * @exception InstantiationException
     *                如果实例化{@code Filter}对象时发生异常
     * @exception ServletException
     *                如果被过滤器的{@code init}方法抛出异常
     */
    public ApplicationFilterConfig(Context context, FilterDef filterDef) throws ClassCastException,
            ClassNotFoundException, IllegalAccessException, InstantiationException, ServletException {

        super();
        this.context = context;
        setFilterDef(filterDef);

    }

    // ----------------------------------------------------- Instance Variables

    /**
     * 与我们相关联的Context对象(代表一个Web应用程序)
     */
    private Context context = null;

    /**
     * 我们配置的应用程序过滤器.
     */
    private Filter filter = null;

    /**
     * 我们配置的应用程序过滤器的<code>FilterDef</code>定义（Filter 是过滤器实例
     * 而<code>FilterDef</code>是定义过滤器的对象）
     */
    private FilterDef filterDef = null;

    // --------------------------------------------------- FilterConfig Methods

    /**
     * 返回我们配置的应用程序 过滤器的名字
     */
    public String getFilterName() {

        return (filterDef.getFilterName());

    }

    /**
     * 返回包含命名初始化参数的<code>String</code>类型的值，如果参数不存在，返回<code>null</code>。
     *
     * @param name
     *            请求返回的初始化参数的名称
     */
    public String getInitParameter(String name) {

        Map map = filterDef.getParameterMap();
        if (map == null)
            return (null);
        else
            return ((String) map.get(name));

    }

    /**
     * 返回此筛选器的初始化参数名称的<code>Enumeration</code>。
     */
    @SuppressWarnings("rawtypes")
    public Enumeration getInitParameterNames() {

        Map map = filterDef.getParameterMap();
        if (map == null)
            return (new Enumerator(new ArrayList()));
        else
            return (new Enumerator(map.keySet()));

    }

    /**
     * 
     * 返回相关Web应用程序的{@link ServletContext}。
     */
    public ServletContext getServletContext() {

        return (this.context.getServletContext());

    }

    public String toString() {

        StringBuffer sb = new StringBuffer("ApplicationFilterConfig[");
        sb.append("name=");
        sb.append(filterDef.getFilterName());
        sb.append(", filterClass=");
        sb.append(filterDef.getFilterClass());
        sb.append("]");
        return (sb.toString());

    }

    // -------------------------------------------------------- Package Methods

    /**
     * 返回已配置的应用程序过滤器器（{@code javax.servlet.Filter}）.
     *
     * @exception ClassCastException
     *                如果{@code FilterDef}中的 {@code filterClass}变量指定的类 没有实现
     *                <code>javax.servlet.Filter</code> 接口，抛出该异常。
     * 
     * @exception ClassNotFoundException
     *                如果{@code FilterDef}中的 {@code filterClass}变量指定的类
     *                没有被加载器找到，抛出异常 。
     * @exception IllegalAccessException
     *                如果{@code FilterDef}中的 {@code filterClass}变量指定的类
     *                不能公开实例化，抛出异常 。
     * @exception InstantiationException
     *                如果实例化{@code Filter}对象时发生异常
     * @exception ServletException
     *                如果被过滤器的{@code init}方法抛出异常
     */
    Filter getFilter() throws ClassCastException, ClassNotFoundException, IllegalAccessException,
            InstantiationException, ServletException {

        // 返回现有的过滤器实例，如果有的话
        if (this.filter != null)
            return (this.filter);

        // 标识我们将使用的类加载器 土话 就是 把我们想定义的Filter 的类的完全限定名 取出来
        String filterClass = filterDef.getFilterClass();
        ClassLoader classLoader = null;
        // 如果 我们要加载的Filter 是 Catalina包下的类 我们不需要使用 Context容器中的loader
        // 直接使用当前的系统类加载器就行了
        // 因为 loader的加载器 是有资源访问限制的 这就不细说了
        if (filterClass.startsWith("org.apache.catalina."))
            classLoader = this.getClass().getClassLoader();
        else
            classLoader = context.getLoader().getClassLoader();

        // 搞什么飞机
        ClassLoader oldCtxClassLoader = Thread.currentThread().getContextClassLoader();

        // 实例化此过滤器的一个新实例并返回它
        Class clazz = classLoader.loadClass(filterClass);
        this.filter = (Filter) clazz.newInstance();

        filter.init(this);
        return (this.filter);

    }

    /**
     * 返回我们配置的 过滤器定义类 {@link FilterDef}
     */
    FilterDef getFilterDef() {

        return (this.filterDef);

    }

    /**
     * 
     * 如果存在，则释放与此{@link FilterConfig}关联的过滤器实例。
     */
    void release() {

        if (this.filter != null)
            filter.destroy();
        this.filter = null;

    }

    /**
     * 
     * 设置我们配置的 过滤器定义对象，并且还会有实例化该过滤器的功能
     * 
     * @param filterDef
     *            新的过滤器定义
     *
     * @exception ClassCastException
     *                如果{@code FilterDef}中的 {@code filterClass}变量指定的类 没有实现
     *                <code>javax.servlet.Filter</code> 接口，抛出该异常。
     * 
     * @exception ClassNotFoundException
     *                如果{@code FilterDef}中的 {@code filterClass}变量指定的类
     *                没有被加载器找到，抛出异常 。
     * @exception IllegalAccessException
     *                如果{@code FilterDef}中的 {@code filterClass}变量指定的类
     *                不能公开实例化，抛出异常 。
     * @exception InstantiationException
     *                如果实例化{@code Filter}对象时发生异常
     * @exception ServletException
     *                如果被过滤器的{@code init}方法抛出异常
     */
    void setFilterDef(FilterDef filterDef) throws ClassCastException, ClassNotFoundException, IllegalAccessException,
            InstantiationException, ServletException {

        this.filterDef = filterDef;
        if (filterDef == null) {

            // 释放任何先前分配的过滤器实例
            if (this.filter != null)
                this.filter.destroy();
            this.filter = null;

        } else {

            // 分配新的过滤器实例
            Filter filter = getFilter();

        }

    }

    // -------------------------------------------------------- Private Methods

}

 ApplicationFilterChain

过滤器链的定义

org.apache.catalina.core.ApplicationFilterChain类实现了 javax.servlert.FilterChain接口，StandardWrapperValue类的 invoke方法会创建ApplicationFliterChain类的一个实例，并调用其doFilter方法，ApplicationFilterChain类的doFilter方法会调用过滤器链中的第一个过滤器的doFilter方法，Filter接口的doFilter方法的签名是

 void doFilter(ServletRequest var1, ServletResponse var2, FilterChain var3) throws IOException, ServletException; 

这个熟悉 Container容器的管道的同学可能一看就看出来这个其实 和 管道的 ValveContext 对象的 invoke方法类似，目的都是把管道或者链中的所有对象都执行一遍，

那个可能有不熟悉的同学 这里就简单的说下：ApplicationFilterChain类的doFilter方法 会将 ApplicationFilterChain自身作为第三个参数传给过滤器的doFilter方法，在过滤器的doFilter中，可以显示的通过调用FilterChain对象的doFilter方法来调用另一个过滤器，如果某个过滤器时过滤器链中的最后一个过滤器，则会调用被请求的Servlet类的service方法，如果过滤器没有调用chain.doFilter方法，则不会调用后面的过滤器。

展示一下 Filter中的 doFilter方法的伪代码

void doFilter(ServletRequest var1, ServletResponse var2, FilterChain var3) throws IOException, ServletException{
/******** 想干啥干啥*********/
var3.doFilter(var1,var2);
}

然后同样把全部代码粘贴出来有兴趣可以看下

package org.apache.catalina.core;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.security.PrivilegedActionException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.Servlet;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.catalina.InstanceEvent;
import org.apache.catalina.util.InstanceSupport;
import org.apache.catalina.util.StringManager;

/**
 * 
 * <p>
 * <b>Title:ApplicationFilterChain.java</b>
 * </p>
 * <p>
 * Copyright:ChenDong 2018
 * </p>
 * <p>
 * Company:仅学习时使用
 * </p>
 * <p>
 * 类功能描述: 用于管理特定请求的一组过滤器执行链
 * 是<code>javax.servlet.FilterChain</code>的实现。当已定义的过滤器集全部执行完毕时，对
 * <code>doFilter()</code> 的下一次调用将执行servlet的<code>service()</code>方法。
 * </p>
 * 
 * @author 陈东
 * @date 2018年12月2日 上午10:47:54
 * @version 1.0
 */
final class ApplicationFilterChain implements FilterChain {

    // ----------------------------------------------------------- Constructors

    /**
     * 构造一个没有定义过滤器的新链实例
     */
    public ApplicationFilterChain() {

        super();

    }

    // ----------------------------------------------------- Instance Variables

    /**
     * 将在这个链上执行的一组过滤器。
     */
    private ArrayList filters = new ArrayList();

    /**
     * 
     * 用于保持过滤器链中当前位置的迭代器。这个迭代器被称为第一次调用<code>doFilter()</code>
     */
    private Iterator iterator = null;

    /**
     * 要由这个链执行的servlet实例.
     */
    private Servlet servlet = null;

    /**
     * StringManger工具类.
     */
    private static final StringManager sm = StringManager.getManager(Constants.Package);

    /**
     * 
     * 与Wrapper关联的InstanceSupport实例（用于发送“before filter”和“after filter”事件。
     */
    private InstanceSupport support = null;

    // ---------------------------------------------------- FilterChain Methods

    /**
     * 
     * 调用该链中的下一个过滤器，传递指定的请求和响应。如果在此链中不再有过滤器，则调用servlet本身的 <code>service()</code>
     * 方法
     * 
     * @param request
     *            我们正在处理的servlet请求
     * @param response
     *            我们正在创建的servlet响应
     *
     * @exception IOException
     *                如果发生输入/输出错误
     * @exception ServletException
     *                如果出现servlet异常
     */
    public void doFilter(ServletRequest request, ServletResponse response) throws IOException, ServletException {

        // 如果设置了安全管理器
        if (System.getSecurityManager() != null) {
            final ServletRequest req = request;
            final ServletResponse res = response;
            try {
                java.security.AccessController.doPrivileged(new java.security.PrivilegedExceptionAction() {
                    public Object 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);
        }
    }

    /**
     * 
     * 
     * <p>
     * Title: internalDoFilter
     * </p>
     * 
     * @date 2018年12月2日 上午10:54:27
     * 
     *       <p>
     *       功能描述:真正干活的“doFilter”
     *       </p>
     * 
     * @param request
     * @param response
     * @throws IOException
     * @throws ServletException
     */
    private void internalDoFilter(ServletRequest request, ServletResponse response)
            throws IOException, ServletException {

        // 第一次调用这个方法时构造 过滤器链的迭代器
        if (this.iterator == null)
            this.iterator = filters.iterator();

        // 如果链中有一个过滤器，则调用下一个过滤器
        if (this.iterator.hasNext()) {
            // 真正的过滤器 是由 ApplicationFilterConfig 类 的getFilter方法实例化的
            ApplicationFilterConfig filterConfig = (ApplicationFilterConfig) iterator.next();
            Filter filter = null;
            try {
                filter = filterConfig.getFilter();
                // 触发BEFORE_FILTER_EVENT 事件
                support.fireInstanceEvent(InstanceEvent.BEFORE_FILTER_EVENT, filter, request, response);
                // 真正执行 doFilter方法
                filter.doFilter(request, response, this);
                // 触发AFTER_FILTER_EVENT事件
                support.fireInstanceEvent(InstanceEvent.AFTER_FILTER_EVENT, filter, request, response);
            } catch (IOException e) {
                if (filter != null)
                    support.fireInstanceEvent(InstanceEvent.AFTER_FILTER_EVENT, filter, request, response, e);
                throw e;
            } catch (ServletException e) {
                if (filter != null)
                    support.fireInstanceEvent(InstanceEvent.AFTER_FILTER_EVENT, filter, request, response, e);
                throw e;
            } catch (RuntimeException e) {
                if (filter != null)
                    support.fireInstanceEvent(InstanceEvent.AFTER_FILTER_EVENT, filter, request, response, e);
                throw e;
            } catch (Throwable e) {
                if (filter != null)
                    support.fireInstanceEvent(InstanceEvent.AFTER_FILTER_EVENT, filter, request, response, e);
                throw new ServletException(sm.getString("filterChain.filter"), e);
            }
            return;
        }
        // 到这里呢 说明联中的过滤器已经执行完了 所以接下来要调用Servlet实例的 service方法了
        try {
            // 触发 BEFORE_SERVICE_EVENT事件
            support.fireInstanceEvent(InstanceEvent.BEFORE_SERVICE_EVENT, servlet, request, response);
            // 真正调用 Servlet的service方法
            if ((request instanceof HttpServletRequest) && (response instanceof HttpServletResponse)) {
                servlet.service((HttpServletRequest) request, (HttpServletResponse) response);
            } else {
                servlet.service(request, response);
            }
            // 触发AFTER_SERVICE_EVENT事件
            support.fireInstanceEvent(InstanceEvent.AFTER_SERVICE_EVENT, servlet, request, response);
        } catch (IOException e) {
            support.fireInstanceEvent(InstanceEvent.AFTER_SERVICE_EVENT, servlet, request, response, e);
            throw e;
        } catch (ServletException e) {
            support.fireInstanceEvent(InstanceEvent.AFTER_SERVICE_EVENT, servlet, request, response, e);
            throw e;
        } catch (RuntimeException e) {
            support.fireInstanceEvent(InstanceEvent.AFTER_SERVICE_EVENT, servlet, request, response, e);
            throw e;
        } catch (Throwable e) {
            support.fireInstanceEvent(InstanceEvent.AFTER_SERVICE_EVENT, servlet, request, response, e);
            throw new ServletException(sm.getString("filterChain.servlet"), e);
        }

    }

    // -------------------------------------------------------- Package Methods

    /**
     * 将一个过滤器添加到将在这个链中执行的过滤器集合中.
     *
     * @param filterConfig
     *            要执行的servlet的过滤器
     */
    void addFilter(ApplicationFilterConfig filterConfig) {

        this.filters.add(filterConfig);

    }

    /**
     * 释放对该链执行的过滤器和包装器的引用。
     */
    void release() {

        this.filters.clear();
        this.iterator = iterator;
        this.servlet = null;

    }

    /**
     * 置将在该链的末尾执行的servlet
     *
     * @param servlet
     *            执行的servlet
     */
    void setServlet(Servlet servlet) {

        this.servlet = servlet;

    }

    /**
     * 设置用于此过滤器链的事件通知的{@code InstanceSupport}对象。
     * 
     * @param support
     *            InstanceSupport对象
     */
    void setSupport(InstanceSupport support) {

        this.support = support;

    }

}

StandardWrapperValue

StandardWrapperValue类 是StandardWrapper实例中的基础阀，它主要完成两个操作;

1. 执行与该Servlet实例关联的全部过滤器
2. 调用Servlet实例的service方法

为了完成上述任务，在StandardWrapperVlaue类的 invoke方法中会执行以下几个操作，

1. 调用StandardWrapper实例的allocate方法获取该StandardWrapper实例所表示的Servlet类实例。
2. 调用私有方法 createFilterChain 创建过滤器链
3. 调用过滤器链的 doFilter方法，其中包括调用Servlet实例的service方法，
4. 释放过滤器
5. 调用Wrapper实例的deallocate方法；
6. 过该Servlet类再也不会被使用到，则调用Wrapper实例的unload方法

展示一下 invoke方法的部分代码

第一步 调用StandardWrapper类的allocate方法来分配一个Servlet实例

// 分配servlet实例来处理此请求
        try {
            if (!unavailable) {
                // 第一操作 调用StandardWrapper类的allocate方法 分配一个Servlet实例
                servlet = wrapper.allocate();
            }
        } catch (ServletException e) {
            log(sm.getString("standardWrapper.allocateException", wrapper.getName()), e);
            throwable = e;
            exception(request, response, e);
            servlet = null;
        } catch (Throwable e) {
            log(sm.getString("standardWrapper.allocateException", wrapper.getName()), e);
            throwable = e;
            exception(request, response, e);
            servlet = null;
        }

第二步

创建过滤器链

// 第二步：调用私有方法 createFilterChain 来创建过滤器链
        ApplicationFilterChain filterChain = createFilterChain(request, servlet);

再展示下 createFilterChain的方法代码

/**
     * 
     * 构造并返回一个FilterChain实现，它将包装指定servlet实例的执行。如果我们根本不执行一个过滤链，返回
     * <code>null</code>。
     * <p>
     * <strong>FIXME</strong> - 链实例!
     *
     * @param request
     *            我们正在处理的servlet请求
     * @param servlet
     *            要被包装的Servlet实例
     */
    private ApplicationFilterChain createFilterChain(Request request, Servlet servlet) {

        // 如果没有servlet执行，返回null
        if (servlet == null)
            return (null);

        // 创建并初始化过滤器链对象
        ApplicationFilterChain filterChain = new ApplicationFilterChain();
        filterChain.setServlet(servlet);
        StandardWrapper wrapper = (StandardWrapper) getContainer();
        filterChain.setSupport(wrapper.getInstanceSupport());

        // 获取此Context的过滤器映射
        StandardContext context = (StandardContext) wrapper.getParent();
        // 这个过滤器映射集合怎么得来的 根据 web描述文件中的 <filter -mapping>
        FilterMap filterMaps[] = context.findFilterMaps();

        // 如果没有过滤器映射，我们就完成了
        if ((filterMaps == null) || (filterMaps.length == 0))
            return (filterChain);

        // 获取匹配过滤器映射所需的信息
        String requestPath = null;
        if (request instanceof HttpRequest) {
            HttpServletRequest hreq = (HttpServletRequest) request.getRequest();
            String contextPath = hreq.getContextPath();
            if (contextPath == null)
                contextPath = "";
            String requestURI = ((HttpRequest) request).getDecodedRequestURI();
            if (requestURI.length() >= contextPath.length())
                requestPath = requestURI.substring(contextPath.length());
        }
        String servletName = wrapper.getName();

        int n = 0;

        // 将匹配到相关路径映射的过滤器添加到该过滤器链
        for (int i = 0; i < filterMaps.length; i++) {

            if (!matchFiltersURL(filterMaps[i], requestPath))
                continue;
            ApplicationFilterConfig filterConfig = (ApplicationFilterConfig) context
                    .findFilterConfig(filterMaps[i].getFilterName());
            if (filterConfig == null) {

                continue;
            }
            filterChain.addFilter(filterConfig);
            n++;
        }

        // 添加与Servlet名称匹配的过滤器
        for (int i = 0; i < filterMaps.length; i++) {

            if (!matchFiltersServlet(filterMaps[i], servletName))
                continue;
            ApplicationFilterConfig filterConfig = (ApplicationFilterConfig) context
                    .findFilterConfig(filterMaps[i].getFilterName());
            if (filterConfig == null) {
                continue;
            }
            filterChain.addFilter(filterConfig);
            n++;
        }

        // 返回过滤器链
        return (filterChain);

    }

第三步 执行过滤器的doFilter方法 ，在其链的doFilter方法最后 会调用 Servlet的service方法 可以参见上面的ApplicationFilterChain类

    if ((servlet != null) && (filterChain != null)) {
                // 第三步：调用过滤器的 doFilter方法 包括调用Servlet的service方法
                filterChain.doFilter(sreq, sres);
       }

第四步 释放过滤器链

try {
            if (filterChain != null)
                // 第四步 释放过滤器链
                filterChain.release();
        } catch (Throwable e) {
            log(sm.getString("standardWrapper.releaseFilters", wrapper.getName()), e);
            if (throwable == null) {
                throwable = e;
                exception(request, response, e);
            }
        }

第五步 调用Wrapper的deallocate方法 将Servlet实例还给 StandardWrapper

// 第五步 调用Wrapper实例的 deallocate方法
        try {
            if (servlet != null) {

                wrapper.deallocate(servlet);
            }
        } catch (Throwable e) {
            log(sm.getString("standardWrapper.deallocateException", wrapper.getName()), e);
            if (throwable == null) {
                throwable = e;
                exception(request, response, e);
            }
        }

在给大家展示一下StandardWrapper类的dellocate方法

/**
     * 
     * 将先前分配的servlet返回到可用实例池中。如果此servlet类不实现{@link SingleThreadModel}接口，
     * 则实际上不需要任何操作
     * 
     * @param servlet
     *            被返回来的Servlet实例
     *
     * @exception ServletException
     *                如果发生了分配错误
     */
    public void deallocate(Servlet servlet) throws ServletException {

        // 如果此servlet类不实现{@link SingleThreadModel}接口,只需要把当前活动的Servlet实例计数减一 就可以了
        if (!singleThreadModel) {
            countAllocated--;
            return;
        }

        // 解锁并释放此实例
        synchronized (instancePool) {
            countAllocated--;
            instancePool.push(servlet);
            instancePool.notify();
        }

    }

第六步 若该Servlet类在也不会被使用到，则调用Wrapper实例的unload方法

说这个方法之前 现引入一个StandardWrapper类的表示变量 

   /**
     * 这个servlet可用的日期和时间（自纪元以来以毫秒为单位），或者如果servlet可用，则为零。如果此值等于.{@code MAX_VALUE}
     * 则此servlet的不可用性被认为是永久性的。
     */
    private long available = 0L

这个变量是可以通过下面方法设置的

/**
     * 设置该servlet的可用日期/时间，从该纪元开始，以毫秒为单位。如果此日期/时间在将来，
     * 则对该servlet的任何请求都将返回{@code SC_SERVICE_UNAVAILABLE}错误
     *
     * @param available
     *            新的可用日期/时间
     */
    public void setAvailable(long available) {

        long oldAvailable = this.available;
        if (available > System.currentTimeMillis())
            this.available = available;
        else
            this.available = 0L;
        support.firePropertyChange("available", new Long(oldAvailable), new Long(this.available));

    }

那么我们回过头来看  第六步 如检查到 上面的表示 为 MAX_VALUE，就会执行 wrapper 的unload方法

try {
            if ((servlet != null) && (wrapper.getAvailable() == Long.MAX_VALUE)) {
                wrapper.unload();
            }
        } catch (Throwable e) {
            log(sm.getString("standardWrapper.unloadException", wrapper.getName()), e);
            if (throwable == null) {
                throwable = e;
                exception(request, response, e);
            }
        }

看下面 展示 unload方法

/**
     * 在调用每个实例的<code>destroy()</code>方法后，卸载此servlet的所有初始化实例。例如，
     * 可以在关闭整个servlet引擎之前， 或者在从与Loader的存储库关联的加载程序中重新加载所有类之前
     *
     * @exception ServletException
     *                if an exception is thrown by the destroy() method
     */
    public synchronized void unload() throws ServletException {

        // 如果我们从来没有加载过实例
        if (!singleThreadModel && (instance == null))
            return;
        unloading = true;

        // 如果当前实例已分配，则暂时停留
        // (可能超过一个，如果非STM）
        if (countAllocated > 0) {
            int nRetries = 0;
            while (nRetries < 10) {
                if (nRetries == 0) {
                    log("等待" + countAllocated + " 实例被解除分配 ");
                }
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    ;
                }
                nRetries++;
            }
        }

        // 获取当前线程中的加载器
        ClassLoader oldCtxClassLoader = Thread.currentThread().getContextClassLoader();
        // 获取当初实例化 Instance时 的加载器
        ClassLoader classLoader = instance.getClass().getClassLoader();

        PrintStream out = System.out;
        SystemLogHandler.startCapture();

        // 调用Servlet 的destory()方法
        try {
            instanceSupport.fireInstanceEvent(InstanceEvent.BEFORE_DESTROY_EVENT, instance);
            Thread.currentThread().setContextClassLoader(classLoader);
            instance.destroy();
            instanceSupport.fireInstanceEvent(InstanceEvent.AFTER_DESTROY_EVENT, instance);
        } catch (Throwable t) {
            instanceSupport.fireInstanceEvent(InstanceEvent.AFTER_DESTROY_EVENT, instance, t);
            instance = null;
            instancePool = null;
            nInstances = 0;
            fireContainerEvent("unload", this);
            unloading = false;
            throw new ServletException(sm.getString("standardWrapper.destroyException", getName()), t);
        } finally {
            // 将上面存起来的线程加载器 重置回去
            Thread.currentThread().setContextClassLoader(oldCtxClassLoader);
            // Write captured output
            String log = SystemLogHandler.stopCapture();
            if (log != null && log.length() > 0) {
                if (getServletContext() != null) {
                    getServletContext().log(log);
                } else {
                    out.println(log);
                }
            }
        }

        // 撤销被销毁的实例
        instance = null;

        if (singleThreadModel && (instancePool != null)) {
            try {
                Thread.currentThread().setContextClassLoader(classLoader);
                // 这里是将 栈顶元素的元素取出进行销毁（因为StandardWrapperValue的invoke方法会先将
                // Servlet换回来）
                // 这里 为什么要把 STM池中的Servlet实例都销毁呢？大家不要忘记 哈 实质上N个STM
                // 实例全都是代表一个Servlet的 当初是为了提升性能才实例了多个，所以要全部销毁
                while (!instancePool.isEmpty()) {
                    ((Servlet) instancePool.pop()).destroy();
                }
            } catch (Throwable t) {
                instancePool = null;
                nInstances = 0;
                unloading = false;
                fireContainerEvent("unload", this);
                throw new ServletException(sm.getString("standardWrapper.destroyException", getName()), t);
            } finally {
                // restore the context ClassLoader
                Thread.currentThread().setContextClassLoader(oldCtxClassLoader);
            }
            instancePool = null;
            nInstances = 0;
        }

        unloading = false;
        fireContainerEvent("unload", this);

    }

那么目前为止 关于 tomcat 的Servlet容器之一 标准实现的StandardWrapper 类的相关功能 就说完了 下一篇文章将会 展示 另一个 Servlet容器  Context的标准实现 StandardContext