tomcat-容器和组件

最新推荐文章于 2024-09-17 22:32:25 发布

aBOUNTWINTER

最新推荐文章于 2024-09-17 22:32:25 发布

阅读量460

点赞数

分类专栏： Tomcat 文章标签： tomcat

本文链接：https://blog.csdn.net/aBOUNTWINTER/article/details/51750028

版权

Tomcat 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

Container


* A Container is an object that can execute requests received from
* a client, and return responses based on those requests.  A Container may
* optionally support a pipeline of Valves that process the request in an
* order configured at runtime, by implementing the <b>Pipeline</b> interface
* as well.
* 
* Containers will exist at several conceptual levels within Catalina.  The
* following examples represent common cases:
* 
* Engine - Representation of the entire Catalina servlet engine,
*     most likely containing one or more subcontainers that are either Host
*     or Context implementations, or other custom groups.
* Host - Representation of a virtual host containing a number
*     of Contexts.
* Context - Representation of a single ServletContext, which will
*     typically contain one or more Wrappers for the supported servlets.
* Wrapper - Representation of an individual servlet definition
*     (which may support multiple servlet instances if the servlet itself
*     implements SingleThreadModel).
* 
* A given deployment of Catalina need not include Containers at all of the
* levels described above.  For example, an administration application
* embedded within a network device (such as a router) might only contain
* a single Context and a few Wrappers, or even a single Wrapper if the
* application is relatively small.  Therefore, Container implementations
* need to be designed so that they will operate correctly in the absence
* of parent Containers in a given deployment.

components

* A Container may also be associated with a number of support components
* that provide functionality which might be shared (by attaching it to a
* parent Container) or individually customized.  The following support
* components are currently recognized:
* 
* Loader - Class loader to use for integrating new Java classes
*     for this Container into the JVM in which Catalina is running.
* Logger - Implementation of the <code>log()</code> method
*     signatures of the <code>ServletContext</code> interface.
* Manager - Manager for the pool of Sessions associated with
*     this Container.
* Realm - Read-only interface to a security domain, for
*     authenticating user identities and their corresponding roles.
* Resources - JNDI directory context enabling access to static
*     resources, enabling custom linkages to existing server components when
*     Catalina is embedded in a larger server.
*

组件的生命周期：

Init => start => stop => destroy

*            start()
*  -----------------------------
*  |                           |
*  | init()                    |
* NEW ->-- INITIALIZING        |
* | |           |              |     ------------------<-----------------------
* | |           |auto          |     |                                        |
* | |          \|/    start() \|/   \|/     auto          auto         stop() |
* | |      INITIALIZED -->-- STARTING_PREP -->- STARTING -->- STARTED -->---  |
* | |         |                                                  |         |  |
* | |         |                                                  |         |  |
* | |         |                                                  |         |  |
* | |destroy()|                                                  |         |  |
* | -->-----<--       auto                    auto               |         |  |
* |     |       ---------<----- MUST_STOP ---------------------<--         |  |
* |     |       |                                                          |  |
* |    \|/      ---------------------------<--------------------------------  ^
* |     |       |                                                             |
* |     |      \|/            auto                 auto              start()  |
* |     |  STOPPING_PREP ------>----- STOPPING ------>----- STOPPED ---->------
* |     |                                ^                  |  |  ^
* |     |               stop()           |                  |  |  |
* |     |       --------------------------                  |  |  |
* |     |       |                                  auto     |  |  |
* |     |       |                  MUST_DESTROY------<-------  |  |
* |     |       |                    |                         |  |
* |     |       |                    |auto                     |  |
* |     |       |    destroy()      \|/              destroy() |  |
* |     |    FAILED ---->------ DESTROYING ---<-----------------  |
* |     |                        ^     |                          |
* |     |     destroy()          |     |auto                      |
* |     -------->-----------------    \|/                         |
* |                                 DESTROYED                     |
* |                                                               |
* |                            stop()                             |
* --->------------------------------>------------------------------

组件生命周期事件

/**
 * The LifecycleEvent type for the "component after init" event.
 */
public static final String BEFORE_INIT_EVENT = "before_init";


/**
 * The LifecycleEvent type for the "component after init" event.
 */
public static final String AFTER_INIT_EVENT = "after_init";


/**
 * The LifecycleEvent type for the "component start" event.
 */
public static final String START_EVENT = "start";


/**
 * The LifecycleEvent type for the "component before start" event.
 */
public static final String BEFORE_START_EVENT = "before_start";


/**
 * The LifecycleEvent type for the "component after start" event.
 */
public static final String AFTER_START_EVENT = "after_start";


/**
 * The LifecycleEvent type for the "component stop" event.
 */
public static final String STOP_EVENT = "stop";


/**
 * The LifecycleEvent type for the "component before stop" event.
 */
public static final String BEFORE_STOP_EVENT = "before_stop";


/**
 * The LifecycleEvent type for the "component after stop" event.
 */
public static final String AFTER_STOP_EVENT = "after_stop";


/**
 * The LifecycleEvent type for the "component after destroy" event.
 */
public static final String AFTER_DESTROY_EVENT = "after_destroy";


/**
 * The LifecycleEvent type for the "component before destroy" event.
 */
public static final String BEFORE_DESTROY_EVENT = "before_destroy";


/**
 * The LifecycleEvent type for the "periodic" event.
 */
public static final String PERIODIC_EVENT = "periodic";


/**
 * The LifecycleEvent type for the "configure_start" event. Used by those
 * components that use a separate component to perform configuration and
 * need to signal when configuration should be performed - usually after
 * {@link #BEFORE_START_EVENT} and before {@link #START_EVENT}.
 */
public static final String CONFIGURE_START_EVENT = "configure_start";


/**
 * The LifecycleEvent type for the "configure_stop" event. Used by those
 * components that use a separate component to perform configuration and
 * need to signal when de-configuration should be performed - usually after
 * {@link #STOP_EVENT} and before {@link #AFTER_STOP_EVENT}.
 */
public static final String CONFIGURE_STOP_EVENT = "configure_stop";