Tomcat Deep Dive: Java Servlet Container Architecture & Lifecycle

Tomcat Overview

Tomcat is an open‑source Java Web application server that implements part of the Java EE specifications, such as Servlet, JSP, JSTL and WebSocket.

Servlet Container

Tomcat provides the essential Servlet and JSP specifications; other Java EE features (EJB, JPA, JMS, etc.) require additional containers.

Typical deployment uses Tomcat together with Spring and other libraries to build full‑stack web applications.

Core Components

Tomcat consists of a Server that manages multiple Service instances. Each Service contains a Connector (listening on a port) and a Container (Catalina) which hosts the servlet engine.

Key sub‑components:

Engine : top‑level container, may contain multiple Host virtual hosts.

Host : represents a virtual host and contains one or more Context objects.

Context : a web application, holding multiple Wrapper objects that wrap individual Servlets.

Wrapper : creates, initializes and destroys a Servlet instance.

Loader , Realm , JMX , Jasper , Pipeline , Valve , Naming etc. provide class loading, security, management, JSP compilation, request processing chain and JNDI support.

Lifecycle Management

Each component follows a lifecycle with states such as New, Initializing, Initialized, Started, Stopped, Destroyed. Methods like initInternal, startInternal, stopInternal and destroyInternal are invoked by the container.

Listeners configured in server.xml (e.g., EngineConfig, HostConfig, ContextConfig) receive lifecycle events to perform configuration tasks such as parsing context.xml and web.xml.

Connector Types

Tomcat supports three connector implementations, selectable in server.xml:

BIO – blocking I/O based on java.io.

NIO – non‑blocking I/O using java.nio and selector‑based multiplexing.

APR – native Apache Portable Runtime library accessed via JNI for high‑performance I/O.

Each connector handles HTTP or AJP protocols and may use thread pools, event‑driven processing, and various optimizations (e.g., sendfile, epoll).

Request Processing Pipeline

Incoming requests are accepted by a Connector, parsed into Request and Response objects, and passed through the container’s Pipeline . The pipeline consists of a chain of Valve objects, ending with a BasicValve that invokes the next container level.

JSP Engine

JSP pages are compiled by the Jasper engine into Servlets. The JSP lifecycle includes compilation, initialization, execution, and destruction. JSP syntax elements such as scriptlets, declarations, expressions, directives, actions and implicit objects are described.

Asynchronous Servlets and Comet

Tomcat implements asynchronous servlet processing (Servlet 3.0) where a request can be put into async mode with request.startAsync(), freeing the container thread while business logic runs in a separate thread pool.

Comet support allows server‑push by implementing the CometProcessor interface with callbacks begin, read, end and error.

Example of Parallel Startup

List<Future<Void>> results = new ArrayList<Future<Void>>();
for (int i = 0; i < children.length; i++) {
    results.add(startStopExecutor.submit(new StartChild(children[i])));
}
boolean fail = false;
for (Future<Void> result : results) {
    try {
        result.get();
    } catch (Exception e) {
        log.error(sm.getString("containerBase.threadedStartFailed"), e);
        fail = true;
    }
}

Web Application Deployment

Applications are deployed by configuring server.xml (setting appBase for Host and docBase for Context) or by placing a .war file in the webapps directory. The HostConfig and ContextConfig listeners parse these configurations and create the corresponding StandardContext objects.

Images illustrating the architecture, container composition, connector comparison, NIO connector parameters, pipeline/valve, JSP engine, and async flow are included throughout the article.