How Tomcat Uses the Observer Pattern to Manage Its Lifecycle

In the previous article we introduced Tomcat's overall architecture; this piece focuses on how Tomcat manages its entire lifecycle.

Tomcat's lifecycle management employs the Observer pattern, allowing a single Server component to start all containers and their components, triggering listeners automatically. The same mechanism handles shutdown, providing a "one‑click" start/stop experience.

1. Simple Description of the Observer Pattern

The Observer (or publish/subscribe) pattern defines a one‑to‑many dependency: multiple observer objects listen to a single subject. When the subject's state changes, it notifies all observers so they can update themselves.

This pattern is widely used in Java AWT event handling, Servlet listeners, Spring event processing, and Tomcat's own lifecycle management.

It solves the problem of tight coupling between collaborating classes by separating the subject from its observers, making maintenance, extension, and reuse easier.

The pattern involves three roles:

1. Subject : maintains a collection of observers and provides methods to add or remove them.

2. ConcreteSubject : stores state and notifies registered observers when the state changes.

3. Observer : defines an interface for objects that need to be notified.

4. ConcreteObserver : implements the observer interface to synchronize its state with the subject.

2. Tomcat Lifecycle Management Related Classes

The main classes involved are:

(1) Lifecycle: the abstract subject role; all container and component classes (e.g., StandardContext) implement this interface.

(2) LifecycleListener: the abstract observer role; concrete listeners such as ContextConfig, HostConfig, and EngineConfig react to container start and stop events.

(3) LifecycleEvent: encapsulates information about a lifecycle change.

(4) LifecycleSupport: utility class that manages listeners (not used in Tomcat 9.0.x).

(5) LifecycleException: represents lifecycle‑related exceptions.

3. Lifecycle Interface Overview

The common interface for component lifecycle methods is org.apache.catalina.Lifecycle. It defines:

(1) Thirteen String constants representing event types (e.g., BEFORE_START, AFTER_START).

(2) Three listener‑management methods: addLifecycleListener, findLifecycleListeners, and removeLifecycleListener.

(3) Four lifecycle methods: init, start, stop, and destroy.

(4) Two state‑query methods: getState (returns a LifecycleState enum) and getStateName (returns the state name as a string).

4. Default Implementation: LifecycleBase

The default implementation of Lifecycle is org.apache.catalina.util.LifecycleBase. It provides concrete implementations for the methods defined in the interface.

(1) Listener management: a lifecycleListeners collection stores all listeners, with methods to add, remove, find, and invoke them.

(2) Four lifecycle methods ( init, start, stop, destroy) each delegate to a template method ( initInternal, startInternal, stopInternal, destroyInternal) that subclasses must implement.

(3) State query methods getState and getStateName simply return the current lifecycle state, which is set during each lifecycle method.

5. Observer Pattern in Tomcat

In Tomcat, the Lifecycle interface acts as the abstract subject. Concrete subjects include StandardEngine, StandardHost, StandardContext, and StandardServer. LifecycleListener defines the actions observers perform when they are interested in a particular subject event. Users can implement custom listeners as needed.

Tomcat extends the pattern with LifecycleSupport, which holds an array of LifecycleListener instances. When a subject action occurs, LifecycleSupport iterates over this array and invokes each listener's method.

The notification flow is illustrated below:

Events are represented by LifecycleEvent, which carries a type attribute indicating the kind of lifecycle change (e.g., BEFORE_START, AFTER_STOP).

The overall observer workflow in Tomcat is:

Add listeners to the LifecycleSupport listener array.

When a container (subject) performs an action, a LifecycleEvent is created. LifecycleSupport notifies each listener in the array.

Listeners examine the event type and execute the appropriate response.