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