2. 程式人生 > >深入理解Tomcat系列之五：Context容器和Wrapper容器

深入理解Tomcat系列之五：Context容器和Wrapper容器

阿新 • • 發佈：2017-07-29
ssa stream servlet實例 可用 igel sse ould rip alt

前言

Context容器是一個Web項目的代表，主要管理Servlet實例，在Tomcat中Servlet實例是以Wrapper出現的。如今問題是怎樣才幹通過Context容器找到詳細的Servlet呢？在解決問題之前。Context容器須要先啟動，啟動的過程就是載入個類資源文件以及打開子容器以及Pipeline管道的過程。啟動Context容器後。就能夠處理詳細的請求了，詳細是通過Request對象，從代碼清單4-3的Wrapper wrapper = request.getWrapper()就能夠看出來。


那麽Context調用invoke方法後又發生什麽了呢？詳細運行的是org.apache.catalina.core.StandardContextValve的invoke方法。相當於進入了Context管道中，要開始通過管道中一個個閘門了。

StandardContext的處理流程能夠用以下的圖簡化：

技術分享

代碼清單4-3：

/**
 * Select the appropriate child Wrapper to process this request,
 * based on the specified request URI.  If no matching Wrapper can
 * be found, return an appropriate HTTP error.
 *
 * @param request Request to be processed
 * @param response Response to be produced
 *
 * @exception IOException if an input/output error occurred
 * @exception ServletException if a servlet error occurred
 */
@Override
public final void invoke(Request request, Response response)
    throws IOException, ServletException {
    // Disallow any direct access to resources under WEB-INF or META-INF
    MessageBytes requestPathMB = request.getRequestPathMB();
    if ((requestPathMB.startsWithIgnoreCase("/META-INF/", 0))
            || (requestPathMB.equalsIgnoreCase("/META-INF"))
            || (requestPathMB.startsWithIgnoreCase("/WEB-INF/", 0))
            || (requestPathMB.equalsIgnoreCase("/WEB-INF"))) {
        response.sendError(HttpServletResponse.SC_NOT_FOUND);
        return;
    }
    // Select the Wrapper to be used for this Request
    Wrapper wrapper = request.getWrapper();
    if (wrapper == null || wrapper.isUnavailable()) {
        response.sendError(HttpServletResponse.SC_NOT_FOUND);
        return;
    }
    // Acknowledge the request
    try {
        response.sendAcknowledgement();
    } catch (IOException ioe) {
        container.getLogger().error(sm.getString(
                "standardContextValve.acknowledgeException"), ioe);
        request.setAttribute(RequestDispatcher.ERROR_EXCEPTION, ioe);
        response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
        return;
    }

    if (request.isAsyncSupported()) {
        request.setAsyncSupported(wrapper.getPipeline().isAsyncSupported());
    }
    wrapper.getPipeline().getFirst().invoke(request, response);
}
  1. 禁止直接訪問WEB-INF或者META-INF文件夾下的資源
  2. 選擇詳細的Wrapper處理請求
  3. 返回一個確認響應
  4. 調用Wrapper容器的invoke方法，把處理請求交給StandardWrapperValve處理

Wrapper容器
Wrapper容器負責管理一個Servlet，包含Servlet的裝載、初始化、資源回收。Wrapper是最底層的容器，其不能在加入子容器了。Wrapper是一個接口。其標準實現類是StandardWrapper，以下是這兩個類的結構：

技術分享
技術分享

上面的圖都僅僅是類的一部分。因為Wrapper與Servlet息息相關。當中的loadServlet方法負責裝載Servlet，其源代碼例如以下：

代碼清單4-4：

/**
 * Load and initialize an instance of this servlet, if there is not already
 * at least one initialized instance.  This can be used, for example, to
 * load servlets that are marked in the deployment descriptor to be loaded
 * at server startup time.
 */
public synchronized Servlet loadServlet() throws ServletException {
    if (unloading) {
        throw new ServletException(
                sm.getString("standardWrapper.unloading", getName()));
    }
    // Nothing to do if we already have an instance or an instance pool
    if (!singleThreadModel && (instance != null))
        return instance;
    PrintStream out = System.out;
    if (swallowOutput) {
        SystemLogHandler.startCapture();
    }
    Servlet servlet;
    try {
        long t1=System.currentTimeMillis();
        // Complain if no servlet class has been specified
        if (servletClass == null) {
            unavailable(null);
            throw new ServletException
                (sm.getString("standardWrapper.notClass", getName()));
        }
        InstanceManager instanceManager = ((StandardContext)getParent()).getInstanceManager();
        try {
            servlet = (Servlet) instanceManager.newInstance(servletClass);
        } catch (ClassCastException e) {
            unavailable(null);
            // Restore the context ClassLoader
            throw new ServletException
                (sm.getString("standardWrapper.notServlet", servletClass), e);
        } catch (Throwable e) {
            e = ExceptionUtils.unwrapInvocationTargetException(e);
            ExceptionUtils.handleThrowable(e);
            unavailable(null);
            // Added extra log statement for Bugzilla 36630:
            // http://issues.apache.org/bugzilla/show_bug.cgi?id=36630
            if(log.isDebugEnabled()) {
                log.debug(sm.getString("standardWrapper.instantiate", servletClass), e);
            }
            // Restore the context ClassLoader
            throw new ServletException
                (sm.getString("standardWrapper.instantiate", servletClass), e);
        }
        if (multipartConfigElement == null) {
            MultipartConfig annotation =
                    servlet.getClass().getAnnotation(MultipartConfig.class);
            if (annotation != null) {
                multipartConfigElement =
                        new MultipartConfigElement(annotation);
            }
        }
        processServletSecurityAnnotation(servlet.getClass());
        // Special handling for ContainerServlet instances
        if ((servlet instanceof ContainerServlet) &&
                (isContainerProvidedServlet(servletClass) ||
                        ((Context) getParent()).getPrivileged() )) {
            ((ContainerServlet) servlet).setWrapper(this);
        }
        classLoadTime=(int) (System.currentTimeMillis() -t1);
        if (servlet instanceof SingleThreadModel) {
            if (instancePool == null) {
                instancePool = new Stack<Servlet>();
            }
            singleThreadModel = true;
        }
        //init servlet instance
        initServlet(servlet);
        fireContainerEvent("load", this);
        loadTime=System.currentTimeMillis() -t1;
    } finally {
        if (swallowOutput) {
            String log = SystemLogHandler.stopCapture();
            if (log != null && log.length() > 0) {
                if (getServletContext() != null) {
                    getServletContext().log(log);
                } else {
                    out.println(log);
                }
            }
        }
    }
    return servlet;
}

該類主要負責初始化一個Servlet實例，並調用該實例的init方法，然後通知感興趣的事件監聽程序。代碼清單4-3中調用了Wrapper的invoke方法，這種方法完畢什麽呢？

代碼清單4-5：

/**
 * Invoke the servlet we are managing, respecting the rules regarding
 * servlet lifecycle and SingleThreadModel support.
 *
 * @param request Request to be processed
 * @param response Response to be produced
 *
 * @exception IOException if an input/output error occurred
 * @exception ServletException if a servlet error occurred
 */
@Override
public final void invoke(Request request, Response response)
    throws IOException, ServletException {
    // Initialize local variables we may need
    boolean unavailable = false;
    Throwable throwable = null;
    // This should be a Request attribute...
    long t1=System.currentTimeMillis();
    requestCount++;
    StandardWrapper wrapper = (StandardWrapper) getContainer();
    Servlet servlet = null;
    Context context = (Context) wrapper.getParent();

    // Check for the application being marked unavailable
    if (!context.getState().isAvailable()) {
        response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE,
                       sm.getString("standardContext.isUnavailable"));
        unavailable = true;
    }
    // Check for the servlet being marked unavailable
    if (!unavailable && wrapper.isUnavailable()) {
        container.getLogger().info(sm.getString("standardWrapper.isUnavailable",
                wrapper.getName()));
        long available = wrapper.getAvailable();
        if ((available > 0L) && (available < Long.MAX_VALUE)) {
            response.setDateHeader("Retry-After", available);
            response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE,
                    sm.getString("standardWrapper.isUnavailable",
                            wrapper.getName()));
        } else if (available == Long.MAX_VALUE) {
            response.sendError(HttpServletResponse.SC_NOT_FOUND,
                    sm.getString("standardWrapper.notFound",
                            wrapper.getName()));
        }
        unavailable = true;
    }
    // Allocate a servlet instance to process this request
    try {
        if (!unavailable) {
            servlet = wrapper.allocate();
        }
    } catch (UnavailableException e) {
        container.getLogger().error(
                sm.getString("standardWrapper.allocateException",
                        wrapper.getName()), e);
        long available = wrapper.getAvailable();
        if ((available > 0L) && (available < Long.MAX_VALUE)) {
            response.setDateHeader("Retry-After", available);
            response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE,
                       sm.getString("standardWrapper.isUnavailable",
                                    wrapper.getName()));
        } else if (available == Long.MAX_VALUE) {
            response.sendError(HttpServletResponse.SC_NOT_FOUND,
                       sm.getString("standardWrapper.notFound",
                                    wrapper.getName()));
        }
    } catch (ServletException e) {
        container.getLogger().error(sm.getString("standardWrapper.allocateException",
                         wrapper.getName()), StandardWrapper.getRootCause(e));
        throwable = e;
        exception(request, response, e);
    } catch (Throwable e) {
        ExceptionUtils.handleThrowable(e);
        container.getLogger().error(sm.getString("standardWrapper.allocateException",
                         wrapper.getName()), e);
        throwable = e;
        exception(request, response, e);
        servlet = null;
    }
    // Identify if the request is Comet related now that the servlet has been allocated
    boolean comet = false;
    if (servlet instanceof CometProcessor && request.getAttribute(
            Globals.COMET_SUPPORTED_ATTR) == Boolean.TRUE) {
        comet = true;
        request.setComet(true);
    }

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

    // Reset comet flag value after creating the filter chain
    request.setComet(false);
    // Call the filter chain for this request
    // NOTE: This also calls the servlet‘s service() method
    try {
        if ((servlet != null) && (filterChain != null)) {
            // Swallow output if needed
            if (context.getSwallowOutput()) {
                try {
                    SystemLogHandler.startCapture();
                    if (request.isAsyncDispatching()) {
                        //TODO SERVLET3 - async
                        ((AsyncContextImpl)request.getAsyncContext()).doInternalDispatch(); 
                    } else if (comet) {
                        filterChain.doFilterEvent(request.getEvent());
                        request.setComet(true);
                    } else {
                        filterChain.doFilter(request.getRequest(), 
                                response.getResponse());
                    }
                } finally {
                    String log = SystemLogHandler.stopCapture();
                    if (log != null && log.length() > 0) {
                        context.getLogger().info(log);
                    }
                }
            } else {
                if (request.isAsyncDispatching()) {
                    //TODO SERVLET3 - async
                    ((AsyncContextImpl)request.getAsyncContext()).doInternalDispatch();
                } else if (comet) {
                    request.setComet(true);
                    filterChain.doFilterEvent(request.getEvent());
                } else {
                    filterChain.doFilter
                        (request.getRequest(), response.getResponse());
                }
            }
        }
    } catch (ClientAbortException e) {
        throwable = e;
        exception(request, response, e);
    } catch (IOException e) {
        container.getLogger().error(sm.getString(
                "standardWrapper.serviceException", wrapper.getName(),
                context.getName()), e);
        throwable = e;
        exception(request, response, e);
    } catch (UnavailableException e) {
        container.getLogger().error(sm.getString(
                "standardWrapper.serviceException", wrapper.getName(),
                context.getName()), e);
        //            throwable = e;
        //            exception(request, response, e);
        wrapper.unavailable(e);
        long available = wrapper.getAvailable();
        if ((available > 0L) && (available < Long.MAX_VALUE)) {
            response.setDateHeader("Retry-After", available);
            response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE,
                       sm.getString("standardWrapper.isUnavailable",
                                    wrapper.getName()));
        } else if (available == Long.MAX_VALUE) {
            response.sendError(HttpServletResponse.SC_NOT_FOUND,
                        sm.getString("standardWrapper.notFound",
                                    wrapper.getName()));
        }
        // Do not save exception in ‘throwable‘, because we
        // do not want to do exception(request, response, e) processing
    } catch (ServletException e) {
        Throwable rootCause = StandardWrapper.getRootCause(e);
        if (!(rootCause instanceof ClientAbortException)) {
            container.getLogger().error(sm.getString(
                    "standardWrapper.serviceExceptionRoot",
                    wrapper.getName(), context.getName(), e.getMessage()),
                    rootCause);
        }
        throwable = e;
        exception(request, response, e);
    } catch (Throwable e) {
        ExceptionUtils.handleThrowable(e);
        container.getLogger().error(sm.getString(
                "standardWrapper.serviceException", wrapper.getName(),
                context.getName()), e);
        throwable = e;
        exception(request, response, e);
    }
    // Release the filter chain (if any) for this request
    if (filterChain != null) {
        if (request.isComet()) {
            // If this is a Comet request, then the same chain will be used for the
            // processing of all subsequent events.
            filterChain.reuse();
        } else {
            filterChain.release();
        }
    }
    // Deallocate the allocated servlet instance
    try {
        if (servlet != null) {
            wrapper.deallocate(servlet);
        }
    } catch (Throwable e) {
        ExceptionUtils.handleThrowable(e);
        container.getLogger().error(sm.getString("standardWrapper.deallocateException",
                         wrapper.getName()), e);
        if (throwable == null) {
            throwable = e;
            exception(request, response, e);
        }
    }
    // If this servlet has been marked permanently unavailable,
    // unload it and release this instance
    try {
        if ((servlet != null) &&
            (wrapper.getAvailable() == Long.MAX_VALUE)) {
            wrapper.unload();
        }
    } catch (Throwable e) {
        ExceptionUtils.handleThrowable(e);
        container.getLogger().error(sm.getString("standardWrapper.unloadException",
                         wrapper.getName()), e);
        if (throwable == null) {
            throwable = e;
            exception(request, response, e);
        }
    }
}
  1. 初始化一些本地變量
  2. 推斷當前應用是否可用。就是推斷是否確實有這個項目
  3. 分配一個Servlet實例
  4. 為請求創建一個過濾器鏈
  5. 過濾器過濾請求
  6. 關閉過濾器
  7. 又一次委派原來委派的Servlet實例
  8. 釋放資源

這種方法與上面的loadServlet關系例如以下：

技術分享

能夠看出在調用loadServlet的allocate方法的時候調用了StandardWrapperValve的invoke方法，在Wrapper容器獲得請求後，通過allocate方法從實例池棧中彈出一個servlet實例來處理這個請求，servlet實例被封裝成filterChain對象，緊接著通過一系列的過濾器過濾到達servlet.service()方法。這個過程能夠例如以下：

技術分享

深入理解Tomcat系列之五：Context容器和Wrapper容器

相關推薦

深入理解Tomcat系列之五：Context容器和Wrapper容器

ssa stream servlet實例 可用 igel sse ould rip alt 前言 Context容器是一個Web項目的代表，主要管理Servlet實例，在Tomcat中Servlet實例是以Wrapper出現的。如今問題是怎樣才幹通過C

深入理解Tomcat系列之七：詳解URL請求

前言 這裡分析一個實際的請求是如何在Tomcat中被處理的，以及最後是怎麼樣找到要處理的Servlet的？當我們在瀏覽器中輸入http://hostname:port/contextPath/servletPath，前面的hostname與port用於建立tc

深入理解Tomcat系列之六 Servlet工作原理

                     前言Servlet是Web開發中的核心技術，作為一名合格的開發人員，就必須清楚Servlet的工作原理。本章沒有對Servlet技術本身進行詳細的說明，只是針對開發過程中一次Servlet的請求的處理過程進行分析的。Servlet實際上就是一個java類，只不過可以和

深入理解Tomcat系列之三 Connector

                     前言Connector是Tomcat的聯結器，其主要任務是負責處理瀏覽器傳送過來的請求，並建立一個Request和Response的物件用於和瀏覽器交換資料，然後產生一個執行緒用於處理請求，Connector會把Request和Response物件傳遞給該執行緒，該執

深入理解Spring系列之八：常用的擴充套件介面

Spring不僅提供了一個進行快速開發的基礎框架，而且還提供了很多可擴充套件的介面，用於滿足一些額外的開發需求，本篇將對常用的可擴充套件介面進行歸納總結。 1.InitializingBean介面 InitializingBean介面中只有一個afterPr

深入理解Tomcat系列之七 詳解URL請求

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

深入理解Tomcat系列之四 Engine和Host容器

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

《視訊直播技術詳解》系列之五：推流和傳輸

七牛雲於 6 月底釋出了一個針對視訊直播的實時流網路 LiveNet 和完整的直播雲解決方案，很多開發者對這個網路和解決方案的細節和使用場景非常感興趣。結合七牛實時流網路 LiveNet 和直播雲解決方案的實踐，我們用八篇文章，更系統化地介紹當下大熱的視訊直播各環節的關鍵技

C# 9.0新特性詳解系列之五：記錄(record)和with表示式

## [1][1] 背景與動機 傳統面向物件程式設計的核心思想是一個物件有著唯一標識，表現為物件引用，封裝著隨時可變的屬性狀態，如果你改變了一個屬性的狀態，這個物件還是原來那個物件，就是物件引用沒有因為狀態的改變而改變，也就是說該物件可以有很多種狀態。C#從最初開始也是一直這樣設計和工作的。但是一些時候，你

深入理解Tomcat系列之一：系統架構

chan 比較 efi 多個 soci 重點 之一 處理流程 containe 前言： Tomcat是Apache基金組織下的開源項目，性質是一個Web服務器。下面這種情況很普遍：在eclipse床架一個web項目並部署到Tomcat中，啟動tomcat，在瀏覽器中輸入一個

深入理解Spring系列之十二：@Transactional是如何工作的

結合Spring框架，在進行資料庫操作的時候，經常使用@Transactional註解，工作經歷中看到很多開發者使用方式都是錯誤的，沒有深入理解過其原理，這是很危險的！！本篇將深入Spring原始碼，分析@Transactional註解的工作原理。相信，看完你會

深入理解Tomcat系列之一：系統架構（轉）

前言 Tomcat是Apache基金組織下的開源專案，性質是一個Web伺服器。下面這種情況很普遍：在eclipse床架一個web專案並部署到Tomcat中，啟動tomcat，在瀏覽器中輸入一個類似http://localhost:8080/webproject/anyname.jsp的url，然後就可以看到

數據庫面試系列之五：mysql的存儲引擎

當前 查看 efault 表鎖 blog 如果 show 事務 測試 mysql的默認存儲引擎是innoDB,是唯一一個支持事務和支持外鍵的存儲引擎， 可以通過：show variables like ‘default_storage_engine‘;查看當前數據庫到默認引

Office 365 系列之五：創建新用戶

office365 創建賬號、分配許可 本章節跟大家分享怎麽去創建新用戶、分配許可以及修改用戶後綴和電子郵件地址。 登錄 Office 365 管理中心，點擊“用戶”--“活動用戶”--“+添加用戶”； 參照截圖，輸入對應的姓名、顯示名、登錄名、密碼等信息點擊“添加”

mongo 3.4分片集群系列之五：詳解平衡器

大致 mongos 搭建 一次 相對 時間 表示 部分 man 這個系列大致想跟大家分享以下篇章（我會持續更新的↖(^ω^)↗）： 1、mongo 3.4分片集群系列之一：淺談分片集群 2、mongo 3.4分片集群系列之二：搭建分片集群--哈希分片 3、mongo 3.4

多線程系列之五：Balking 模式

實現 vat 正常 bject ret .get 完全 .data 工具 一,什麽是Balking模式 如果現在不合適執行這個操作，或者沒必要執行這個操作，就停止處理，直接返回。在Balking模式中，如果守護條件不成立，就立即中斷處理。 二，例子： 定期將當前數據內容寫入

Kubernetes系列之五：使用yaml檔案建立service向外暴露服務

Service和Pod的理論介紹，方便繼續下去 Pod是有生命週期的，使用凡人皆有一死來描述pod很貼切，當一個工作節點(node)銷燬時，節點上執行的pods也會被銷燬， ReplicationController會動態地在其他節點上建立Pod來保持應用程式的執行，每一個Pod都有一個

深入理解Redis系列之SpringBoot整合Redis

SpringBoot環境 快速搭建一個SpringBoot工程 進入 https://start.spring.io 網站, 使用該網站初始化一個SpringBoot工程 新增相關依賴 因為使用spring initializer已經幫我們把Redis的依賴建立好了; 但是

Spring Boot 系列之五：Spring Boot 通過devtools進行熱部署

前面已經分享過四篇學習文章： 1、Spring Boot 系統之一：Spring Boot 入門 2、Spring Boot 系統之二：Spring Boot 修改預設埠號和context path 3、Spring Boot 系統之三：Spring Boot 整合JdbcTemplat

碼農裝13寶典系列之五：Ubuntu自定義字型縮放級別

目前主流顯示器都有一個很高的解析度，而使用預設的解析度會使字型顯示過小，單純地調整解析度又容易讓字看起來發虛。 系統提供了一個字型縮放級別調整的功能。Windows初始化時就已經為使用者設定好了，而Ubuntu只有兩個選項：100%、200%，顯然不能滿足需求。 那怎麼辦？ 這裡需要