# All Classes

All Classes Interface Summary Class Summary Enum Summary Exception Summary Error Summary
AbandonedConfig: Configuration settings for abandoned object removal.
AbandonedTrace: Tracks connection usage for recovering and reporting abandoned connections.
AbsoluteOrder: Title: Membership - Absolute Order
AbsoluteOrder.AbsoluteComparator
AbstractAccessLogValve: Abstract implementation of the Valve interface that generates a web server access log with the detailed line contents matching a configurable pattern.
AbstractAccessLogValve.AccessLogElement: AccessLogElement writes the partial message into the buffer.
AbstractAccessLogValve.ByteSentElement: write bytes sent, excluding HTTP headers - %b, %B
AbstractAccessLogValve.CachedElement: Marks an AccessLogElement as needing to be have the value cached at the start of the request rather than just recorded at the end as the source data for the element may not be available at the end of the request.
AbstractAccessLogValve.ConnectionStatusElement: Write connection status when response is completed - %X
AbstractAccessLogValve.CookieElement: write a specific cookie - %{xxx}c
AbstractAccessLogValve.DateFormatCache: Cache structure for formatted timestamps based on seconds.
AbstractAccessLogValve.ElapsedTimeElement: write time taken to process the request - %D, %T
AbstractAccessLogValve.FirstByteTimeElement: write time until first byte is written (commit time) in millis - %F
AbstractAccessLogValve.HeaderElement: write incoming headers - %{xxx}i
AbstractAccessLogValve.HttpStatusCodeElement: write HTTP status code of the response - %s
AbstractAccessLogValve.LocalAddrElement: write local IP address - %A
AbstractAccessLogValve.LogicalUserNameElement: write remote logical username from identd (always returns '-') - %l
AbstractAccessLogValve.MethodElement: write request method (GET, POST, etc.) - %m
AbstractAccessLogValve.QueryElement: write Query string (prepended with a '?'
AbstractAccessLogValve.RequestAttributeElement: write an attribute in the ServletRequest - %{xxx}r
AbstractAccessLogValve.RequestElement: write first line of the request (method and request URI) - %r
AbstractAccessLogValve.RequestURIElement: write requested URL path - %U
AbstractAccessLogValve.ResponseHeaderElement: write a specific response header - %{xxx}o
AbstractAccessLogValve.SessionAttributeElement: write an attribute in the HttpSession - %{xxx}s
AbstractAccessLogValve.SessionIdElement: write user session ID - %S
AbstractAccessLogValve.StringElement: write any string
AbstractAccessLogValve.ThreadNameElement: write thread name - %I
AbstractAccessLogValve.UserElement: write remote user that was authenticated (if any), else '-' - %u
AbstractAjpProtocol<S>: The is the base implementation for the AJP protocol handlers.
AbstractArchiveResource
AbstractArchiveResourceSet
AbstractCatalinaCommandTask
AbstractCatalinaTask: Abstract base class for Ant tasks that interact with the Manager web application for dynamically deploying and undeploying applications.
AbstractChunk: Base class for the *Chunk implementation to reduce duplication.
AbstractCreateStatementInterceptor: Abstraction interceptor.
AbstractEndpoint<S,​U>
AbstractEndpoint.BindState
AbstractEndpoint.Handler<S>
AbstractEndpoint.Handler.SocketState: Different types of socket states to react upon.
AbstractFileResourceSet
AbstractGroup: Convenience base class for `Group` implementations.
AbstractHttp11JsseProtocol<S>
AbstractHttp11Protocol<S>
AbstractInputStreamJar: Base implementation of Jar for implementations that use a JarInputStream to access the JAR file.
AbstractJsseEndpoint<S,​U>
AbstractObjectCreationFactory: Abstract base class for `ObjectCreationFactory` implementations.
AbstractProcessor: Provides functionality and attributes common to all supported protocols (currently HTTP and AJP) for processing a single request/response.
AbstractProcessorLight: This is a light-weight abstract processor implementation that is intended as a basis for all Processor implementations from the light-weight upgrade processors to the HTTP/AJP processors.
AbstractProtocol<S>
AbstractProtocol.ConnectionHandler<S>
AbstractProtocol.RecycledProcessors
AbstractQueryReport: Abstract class that wraps statements and intercepts query executions.
AbstractRef
AbstractReplicatedMap<K,​V>
AbstractReplicatedMap.MapEntry<K,​V>
AbstractReplicatedMap.MapMessage
AbstractReplicatedMap.MapOwner
AbstractResource
AbstractResourceSet
AbstractRole: Convenience base class for `Role` implementations.
AbstractRxTask
AbstractSender
AbstractSingleArchiveResource
AbstractSingleArchiveResourceSet: Base class for a `WebResourceSet` based on a single, rather than nested, archive.
AbstractUser: Convenience base class for `User` implementations.
AcceptEncoding
AcceptLanguage
Acceptor<U>
Acceptor.AcceptorState
AccessLog: Intended for use by a `Valve` to indicate that the `Valve` provides access logging.
AccessLogAdapter: A helper class that wraps several AccessLog instances.
AccessLogValve: This is a concrete implementation of `AbstractAccessLogValve` that outputs the access log to a file.
ActionCode: ActionCodes represent callbacks from the servlet container to the coyote connector.
ActionHook: Action hook.
Adapter: Adapter.
AddDefaultCharsetFilter: Filter that explicitly sets the default character set for media subtypes of the "text" type to ISO-8859-1, or another user defined character set.
AddDefaultCharsetFilter.ResponseWrapper: Wrapper that adds a character set for text media types if no character set is specified.
AddPortOffsetRule
Address: Deprecated. The scope of the APR/Native Library will be reduced in Tomcat 10.1.x / Tomcat Native 2.x onwards to only include those components required to provide OpenSSL integration with the NIO and NIO2 connectors.
AjpAprProtocol: Deprecated. The APR/Native Connector will be removed in Tomcat 10.1.x onwards.
AjpMessage: A single packet for communication between the web server and the container.
AjpNio2Protocol: This the NIO2 based protocol handler implementation for AJP.
AjpNioProtocol: This the NIO based protocol handler implementation for AJP.
AjpProcessor: AJP Processor implementation.
AjpProtocol: Deprecated. This class will be removed in Tomcat 9.
AnnotationElementValue
AnnotationEntry: Represents one annotation in the annotation table
Annotations: base class for annotations
AntCompiler: Main JSP compiler class.
AntCompiler.JasperAntLogger
AntCompiler.SystemLogHandler
ApplicationBufferHandler: Callback interface to be able to expand buffers when buffer overflow exceptions happen or to replace buffers
ApplicationContext: Standard implementation of `ServletContext` that represents a web application's execution environment.
ApplicationContextFacade: Facade object which masks the internal `ApplicationContext` object from the web application.
ApplicationFilterChain: Implementation of `javax.servlet.FilterChain` used to manage the execution of a set of filters for a particular request.
ApplicationFilterConfig: Implementation of a `javax.servlet.FilterConfig` useful in managing the filter instances instantiated when a web application is first started.
ApplicationFilterFactory: Factory for the creation and caching of Filters and creation of Filter Chains.
ApplicationFilterRegistration
ApplicationMapping
ApplicationMappingImpl
ApplicationMappingMatch: Represents the ways that a request can be mapped to a servlet
ApplicationParameter: Representation of a context initialization parameter that is configured in the server configuration file, rather than the application deployment descriptor.
ApplicationPart: Adaptor to allow `FileItem` objects generated by the package renamed commons-upload to be used by the Servlet 3.0 upload API that expects `Part`s.
ApplicationPushBuilder
ApplicationServletRegistration
ApplicationSessionCookieConfig
AprEndpoint: Deprecated. The APR/Native Connector will be removed in Tomcat 10.1.x onwards.
AprEndpoint.AprSocketWrapper
AprEndpoint.SendfileData: SendfileData class.
AprEndpoint.SocketInfo
AprEndpoint.SocketList
AprEndpoint.SocketTimeouts
AprLifecycleListener: Implementation of `LifecycleListener` that will init and and destroy APR.
AprSSLSupport: Deprecated. The APR/Native Connector will be removed in Tomcat 10.1.x onwards.
Arg
ArrayElementValue
Arrays
ArrayStack<E>: Imported copy of the `ArrayStack` class from Commons Collections, which was the only direct dependency from Digester.
Ascii: This class implements some basic ASCII character handling functions.
ASCIIReader: Deprecated. Will be removed in Tomcat 9.0.x onwards
Asn1Parser: This is a very basic ASN.1 parser that provides the limited functionality required by Tomcat.
Asn1Writer
AsyncChannelGroupUtil: This is a utility class that enables multiple `WsWebSocketContainer` instances to share a single `AsynchronousChannelGroup` while ensuring that the group is destroyed when no longer required.
AsyncChannelWrapper: This is a wrapper for a `AsynchronousSocketChannel` that limits the methods available thereby simplifying the process of implementing SSL/TLS support since there are fewer methods to intercept.
AsyncChannelWrapperNonSecure: Generally, just passes calls straight to the wrapped `AsynchronousSocketChannel`.
AsyncChannelWrapperSecure: Wraps the `AsynchronousSocketChannel` with SSL/TLS.
AsyncContextCallback: Provides a mechanism for the Coyote connectors to communicate with the `AsyncContext`.
AsyncContextImpl
AsyncDispatcher
AsyncFileHandler: A `FileHandler` implementation that uses a queue of log entries.
AsyncListenerWrapper
AsyncStateMachine: Manages the state transitions for async requests.
AttributeInfo: Internal configuration information for an `Attribute` descriptor.
AttributeParser: Converts a JSP attribute value into the unquoted equivalent.
AuthConfigFactoryImpl
Authentication
AuthenticationException: Exception thrown on authentication error connecting to a remote websocket endpoint.
AuthenticationType
Authenticator: An Authenticator is a component (usually a Valve or Container) that provides some sort of authentication service.
Authenticator: Base class for the authentication methods used by the WebSocket client.
AuthenticatorBase: Basic implementation of the Valve interface that enforces the `<security-constraint>` elements in the web application deployment descriptor.
AuthenticatorBase.AllowCorsPreflight
AuthenticatorFactory: Utility method to return the appropriate authenticator according to the scheme that the server uses.
Authorization: Parser for an "Authorization" header.
B2CConverter: NIO based character decoder.
BackgroundProcess
BackgroundProcessManager: Provides a background processing mechanism that triggers roughly once a second.
BackupManager
BadRequestException: Extend IOException to identify it as being caused by a bad request from a remote client.
Base64: Provides Base64 encoding and decoding as defined by RFC 2045.
BaseAttributeFilter: Implementation of `NotificationFilter` for attribute change notifications.
BaseCatalinaMBean<T>
BaseGenericObjectPool<T>: Base class that provides common functionality for `GenericObjectPool` and `GenericKeyedObjectPool`.
BaseKeyedPooledObjectFactory<K,​V>: A base implementation of `KeyedPooledObjectFactory`.
BaseModelMBean: Basic implementation of the `DynamicMBean` interface, which supports the minimal requirements of the interface contract.
BaseNCodec: Abstract superclass for Base-N encoders and decoders.
BaseNotificationBroadcaster: Implementation of `NotificationBroadcaster` for attribute change notifications.
BaseObject: A base class for common functionality.
BaseObjectPool<T>: A simple base implementation of `ObjectPool`.
BaseObjectPoolConfig<T>: Provides the implementation for the common attributes shared by the sub-classes.
BasePooledObjectFactory<T>: A base implementation of `PoolableObjectFactory`.
BaseRedirectorHelperTask: Abstract base class to add output redirection support for Catalina Ant tasks.
BaseSessionComparator<T>: Comparator which permits to compare on a session's content.
BasicAuthenticator: An Authenticator and Valve implementation of HTTP BASIC Authentication, as outlined in RFC 7617: "The 'Basic' HTTP Authentication Scheme"
BasicAuthenticator: Authenticator supporting the BASIC authentication method.
BasicAuthenticator.BasicCredentials: Parser for an HTTP Authorization header for BASIC authentication as per RFC 2617 section 2, and the Base64 encoded credentials as per RFC 2045 section 6.8.
BasicDataSource: Basic implementation of `javax.sql.DataSource` that is configured via JavaBeans properties.
BasicDataSourceFactory: JNDI object factory that creates an instance of `BasicDataSource` that has been configured based on the `RefAddr` values of the specified `Reference`, which must match the names and data types of the `BasicDataSource` bean properties with the following exceptions:
BasicDataSourceMXBean: Interface to keep API compatibility.
BeanFactory: Object factory for any Resource conforming to the JavaBean spec.
BeanRepository: Repository of {page, request, session, application}-scoped beans
BinaryDecoder: Deprecated. This interface is unused and will be removed in Tomcat 9
BinaryEncoder: Deprecated. This interface is unused and will be removed in Tomcat 9
BIOCallback: Deprecated. Unused.
BioReceiver
BioReplicationTask: A worker thread class which can drain channels and echo-back the input.
BioSender: Send cluster messages with only one socket.
BodyContentImpl: Write text to a character-output stream, buffering characters so as to provide for the efficient writing of single characters, arrays, and strings.
Bootstrap: Bootstrap loader for Catalina.
Buffer: Provides utilities related to the use of directly allocated `ByteBuffer` instances with native code.
BufferedInputFilter: Input filter responsible for reading and buffering the request body, so that it does not interfere with client SSL handshake messages.
BufferPool
BufferPool.BufferPoolAPI
ByteArrayOutputStream: This class implements an output stream in which the data is written into a byte array.
ByteArrayServletOutputStream: Class that extends ServletOutputStream, used as a wrapper from within `SsiInclude`
ByteBufferHolder: Simple wrapper for a `ByteBuffer` that remembers if the buffer has been flipped or not.
ByteBufferUtils
ByteChunk: This class is used to represent a chunk of bytes, and utilities to manipulate byte[].
ByteChunk.BufferOverflowException
ByteChunk.ByteInputChannel: Input interface, used when the buffer is empty.
ByteChunk.ByteOutputChannel: When we need more space we'll either grow the buffer ( up to the limit ) or send it to a channel.
ByteMessage: A byte message is not serialized and deserialized by the channel instead it is sent as a byte array By default Tribes uses java serialization when it receives an object to be sent over the wire.
C2BConverter: NIO based character encoder.
Cache
CachedResource: This class is designed to wrap a 'raw' WebResource and providing caching for expensive operations.
CallbackHandlerImpl: Default implementation of a JASPIC CallbackHandler.
CallMethodRule: Rule implementation that calls a method on an object on the stack (normally the top/parent object), passing arguments collected from subsequent `CallParamRule` rules or from the body of this element.
CallParamRule: Rule implementation that saves a parameter for use by a surrounding `CallMethodRule`.
CallStack: Strategy for obtaining and printing the current call stack.
CallStackUtils: Utility methods for `CallStack`.
CaseInsensitiveKeyMap<V>: A Map implementation that uses case-insensitive (using `Locale.ENGLISH`) strings as keys.
Catalina: Startup/Shutdown shell program for Catalina.
CatalinaCluster: A CatalinaCluster interface allows to plug in and out the different cluster implementations
CatalinaClusterSF: Generate Cluster Element with Membership,Sender,Receiver,Deployer and ReplicationValve
CatalinaProperties: Utility class to read the bootstrap Catalina configuration.
Catch
CertificateCreateRule: Rule implementation that creates an SSLHostConfigCertificate.
CertificateStoreAppender: Store the Certificate attributes.
CertificateVerifier: Is called during handshake and hooked into openssl via `SSL_CTX_set_cert_verify_callback`.
CGIServlet: CGI-invoking servlet for web applications, used to execute scripts which comply to the Common Gateway Interface (CGI) specification and are named in the path-info used to invoke this servlet.
CGIServlet.HTTPHeaderInputStream: This is an input stream specifically for reading HTTP headers.
Channel: Channel interface A channel is a representation of a group of nodes all participating in some sort of communication with each other. The channel is the main API class for Tribes, this is essentially the only class that an application needs to be aware of.
ChannelCoordinator: The channel coordinator object coordinates the membership service, the sender and the receiver.
ChannelData: The `ChannelData` object is used to transfer a message through the channel interceptor stack and eventually out on a transport to be sent to another node.
ChannelException: A channel exception is thrown when an internal error happens somewhere in the channel.
ChannelException.FaultyMember: Represent a failure to a specific member when a message was sent to more than one member
ChannelInterceptor: A ChannelInterceptor is an interceptor that intercepts messages and membership messages in the channel stack.
ChannelInterceptor.InterceptorEvent
ChannelInterceptorBase: Abstract class for the interceptor base class.
ChannelListener: An interface to listens to incoming messages from a channel.
ChannelMessage: Message that is passed through the interceptor stack after the data serialized in the Channel object and then passed down to the interceptor and eventually down to the ChannelSender component
ChannelReceiver: ChannelReceiver Interface The `ChannelReceiver` interface is the data receiver component at the bottom layer, the IO layer (for layers see the javadoc for the `Channel` interface).
ChannelSender: ChannelReceiver Interface The `ChannelSender` interface is the data sender component at the bottom layer, the IO layer (for layers see the javadoc for the `Channel` interface). The channel sender must support "silent" members, ie, be able to send a message to a member that is not in the membership, but is part of the destination parameter
ChannelSF: Generate Channel Element
CharChunk: Utilities to manipulate char chunks.
CharChunk.CharInputChannel: Input interface, used when the buffer is empty.
CharChunk.CharOutputChannel: When we need more space we'll either grow the buffer ( up to the limit ) or send it to a channel.
CharsetCache
CharsetMapper: Utility class that attempts to map from a Locale to the corresponding character set to be used for interpreting input text (or generating output text) when the Content-Type header does not include one.
CharsetUtil
CheckEol: Ant task that checks that all the files in the given fileset have end-of-line delimiters that are appropriate.
Choose
ChunkedInputFilter: Chunked input filter.
ChunkedOutputFilter: Chunked output filter.
Cipher: All the standard cipher suites for SSL/TSL.
ClassElementValue
ClassFormatException: Thrown when the BCEL attempts to read a class file and determines that a class is malformed or otherwise cannot be interpreted as a class file.
ClassLoaderFactory: Utility class for building class loaders for Catalina.
ClassLoaderFactory.Repository
ClassLoaderFactory.RepositoryType
ClassLoaderLogManager: Per classloader LogManager implementation.
ClassLoaderLogManager.ClassLoaderLogInfo
ClassLoaderLogManager.LogNode
ClassLoaderLogManager.RootLogger: This class is needed to instantiate the root of each per classloader hierarchy.
ClassLoaderUtil
ClassNameMBean<T>: A convenience base class for ModelMBean implementations where the underlying base class (and therefore the set of supported properties) is different for varying implementations of a standard interface.
ClassParser: Wrapper class that parses a given Java .class file.
ClasspathURLStreamHandler
ClientAbortException: Extend IOException to identify it as being caused by an abort of a request by a remote client.
ClientEndpointHolder
Closeable: Interface of an object, which may be closed.
CloseNowException: This exception is thrown to signal to the Tomcat internals that an error has occurred that requires the connection to be closed.
Cluster: A Cluster works as a Cluster client/server for the local host Different Cluster implementations can be used to support different ways to communicate within the Cluster.
ClusterDeployer: A ClusterDeployer interface allows to plug in and out the different deployment implementations
ClusterListener: Receive SessionID cluster change from other backup node after primary session node is failed.
ClusterManager: The common interface used by all cluster manager.
ClusterManagerBase
ClusterMessage
ClusterMessageBase
ClusterRuleSet: RuleSet for processing the contents of a Cluster definition element.
ClusterSession
ClusterSessionListener: Receive replicated SessionMessage form other cluster node.
ClusterSingleSignOn: A Valve that supports a "single sign on" user experience on each nodes of a cluster, where the security identity of a user who successfully authenticates to one web application is propagated to other web applications and to other nodes cluster in the same security domain.
ClusterSingleSignOnListener: Cluster extension of `SingleSignOnListener` that simply adds the marker interface `ReplicatedSessionListener` which allows the listener to be replicated across the cluster along with the session.
ClusterValve: Cluster valves are a simple extension to the Tomcat valve architecture with a small addition of being able to reference the cluster component in the container it sits in.
CollectedInfo
CombinedRealm: Realm implementation that contains one or more realms.
Compiler: Main JSP compiler class.
CompressionConfig
ConcurrentCache<K,​V>
ConcurrentCache<K,​V>
ConcurrentDateFormat: Deprecated. Unused.
ConcurrentDateFormat: A thread safe wrapper around `SimpleDateFormat` that does not make use of ThreadLocal and - broadly - only creates enough SimpleDateFormat objects to satisfy the concurrency requirements.
ConcurrentMessageDigest: A thread safe wrapper around `MessageDigest` that does not make use of ThreadLocal and - broadly - only creates enough MessageDigest objects to satisfy the concurrency requirements.
ConfigFileLoader: This class is used to obtain `InputStream`s for configuration files from a given location String.
ConnectionFactory: Abstract factory interface for creating `Connection`s.
ConnectionPool: Implementation of simple connection pool.
ConnectionPool
ConnectionPool.PoolCleaner
ConnectionPoolMBean
ConnectionState: Interceptor that keep track of connection state to avoid roundtrips to the database.
Connector: Implementation of a Coyote connector.
ConnectorCreateRule: Rule implementation that creates a connector.
ConnectorMBean: A ModelMBean implementation for the `org.apache.coyote.tomcat5.CoyoteConnector` component.
ConnectorSF: Store Connector and Listeners
ConnectorStoreAppender: Store the Connector attributes.
Const: Constants for the project, mostly defined in the JVM specification.
Constant: Abstract superclass for classes to represent the different constant types in the constant pool of a class file.
ConstantClass: This class is derived from the abstract `Constant` and represents a reference to a (external) class.
ConstantDouble: This class is derived from the abstract `Constant` and represents a reference to a Double object.
ConstantFloat: This class is derived from the abstract `Constant` and represents a reference to a float object.
ConstantInteger: This class is derived from the abstract `Constant` and represents a reference to an int object.
ConstantLong: This class is derived from the abstract `Constant` and represents a reference to a long object.
ConstantPool: This class represents the constant pool, i.e., a table of constants, of a parsed classfile.
Constants
Constants
Constants: Manifest constants for this Java package.
Constants: Manifest constants for the `org.apache.catalina.ha.tcp` package.
Constants
Constants
Constants
Constants: Static constants for this package.
Constants: Deprecated. Unused.
Constants
Constants
Constants: Manifest constants for the `org.apache.catalina.session` package.
Constants: String constants for the startup package.
Constants
Constants: Manifest constants for the `org.apache.catalina.tribes.membership` package.
Constants: Manifest constants for the `org.apache.catalina.tribes.transport` package.
Constants: Manifest constants for this Java package.
Constants: Manifest constants for the `org.apache.catalina.valves` package.
Constants: Constants.
Constants: Constants.
Constants: Constants.
Constants
Constants: Some constants and other global data that are used by the compiler and the runtime.
Constants: Deprecated. Unused.
Constants: Static constants for this package.
Constants
Constants: Constants.
Constants: String constants for the file package.
Constants
Constants
Constants
Constants: String constants for the scan package.
Constants: Static constants for this package.
Constants: Internal implementation constants.
Constants: Internal implementation constants.
Constants: Internal implementation constants.
Constants.AccessLog
ConstantUtf8: Extends the abstract `Constant` to represent a reference to a UTF-8 encoded string.
Contained: Decoupling interface which specifies that an implementing class is associated with at most one Container instance.
Container: A Container is an object that can execute requests received from a client, and return responses based on those requests.
ContainerBase: Abstract implementation of the Container interface, providing common functionality required by nearly every implementation.
ContainerEvent: General event for notifying listeners of significant changes on a Container.
ContainerListener: Interface defining a listener for significant Container generated events.
ContainerMBean
ContainerServlet: A ContainerServlet is a servlet that has access to Catalina internal functionality, and is loaded from the Catalina class loader instead of the web application class loader.
ContainerThreadMarker: Deprecated. Unused.
ContainerThreadMarker: Deprecated. Unused.
ContentRange
Context: A Context is a Container that represents a servlet context, and therefore an individual web application, in the Catalina servlet engine.
ContextAccessController: Handles the access control on the JNDI contexts.
ContextBind
ContextBindings: Handles the associations : Object with a NamingContext Calling thread with a NamingContext Calling thread with object bound to the same naming context Thread context class loader with a NamingContext Thread context class loader with object bound to the same NamingContext The objects are typically Catalina Server or Context objects.
ContextConfig: Startup event listener for a Context that configures the properties of that Context, and the associated defined servlets.
ContextEjb: Representation of an EJB resource reference for a web application, as represented in a `<ejb-ref>` element in the deployment descriptor.
ContextEnvironment: Representation of an application environment entry, as represented in an `<env-entry>` element in the deployment descriptor.
ContextEnvironmentMBean: A ModelMBean implementation for the `org.apache.tomcat.util.descriptor.web.ContextEnvironment` component.
ContextHandler: Representation of a handler reference for a web service, as represented in a `<handler>` element in the deployment descriptor.
ContextLocalEjb: Representation of a local EJB resource reference for a web application, as represented in a `<ejb-local-ref>` element in the deployment descriptor.
ContextMBean
ContextName: Utility class to manage context names so there is one place where the conversions between baseName, path and version take place.
ContextNamingInfoListener: Implementation of `LifecycleListener` that will create context naming information environment entries.
ContextResource: Representation of a resource reference for a web application, as represented in a `<resource-ref>` element in the deployment descriptor.
ContextResourceEnvRef: Representation of an application resource reference, as represented in an `<res-env-refy>` element in the deployment descriptor.
ContextResourceLink: Representation of a resource link for a web application, as represented in a `<ResourceLink>` element in the server configuration file.
ContextResourceLinkMBean: A ModelMBean implementation for the `org.apache.tomcat.util.descriptor.web.ContextResourceLink` component.
ContextResourceMBean: A ModelMBean implementation for the `org.apache.tomcat.util.descriptor.web.ContextResource` component.
ContextRuleSet: RuleSet for processing the contents of a Context definition element.
ContextService: Representation of a web service reference for a web application, as represented in a `<service-ref>` element in the deployment descriptor.
ContextTransaction: Representation of an application resource reference, as represented in an `<res-env-refy>` element in the deployment descriptor.
ContinueResponseTiming: Defines timing options for responding to requests that contain a '100-continue' expectations.
Cookie: Cookie header parser based on RFC6265 and RFC2109.
CookieProcessor
CookieProcessorBase
CopyParentClassLoaderRule: Rule that copies the `parentClassLoader` property from the next-to-top item on the stack (which must be a `Container`) to the top item on the stack (which must also be a `Container`).
CorsFilter: A `Filter` that enable client-side cross-origin requests by implementing W3C's CORS (Cross-Origin Resource Sharing) specification for resources.
CorsFilter.CORSRequestType: Enumerates varies types of CORS requests.
CoyoteAdapter: Implementation of a request processor which delegates the processing to a Coyote processor.
CoyoteInputStream: This class handles reading bytes.
CoyoteOutputStream: Coyote implementation of the servlet output stream.
CoyotePrincipal: Generic implementation of java.security.Principal that is used to represent principals authenticated at the protocol handler level.
CoyoteReader: Coyote implementation of the buffered reader.
CoyoteWriter: Coyote implementation of the servlet writer.
CrawlerSessionManagerValve: Web crawlers can trigger the creation of many thousands of sessions as they crawl a site which may result in significant memory consumption.
CredentialHandler: This interface is used by the `Realm` to compare the user provided credentials with the credentials stored in the `Realm` for that user.
CredentialHandlerRuleSet: RuleSet for processing the contents of a CredentialHandler definition element.
CredentialHandlerSF: Store server.xml Element CredentialHandler
CsrfPreventionFilter: Provides basic CSRF protection for a web application.
CsrfPreventionFilter.CsrfResponseWrapper
CsrfPreventionFilter.LruCache<T>: Despite its name, this is a FIFO cache not an LRU cache.
CsrfPreventionFilter.NonceCache<T>
CsrfPreventionFilterBase
CustomObjectInputStream: Custom subclass of `ObjectInputStream` that loads from the class loader for this web application.
DataSender
DataSource: A DataSource that can be instantiated through IoC and implements the DataSource interface since the DataSourceProxy is used as a generic proxy.
DataSourceConnectionFactory: A `DataSource`-based implementation of `ConnectionFactory`.
DataSourceFactory: JNDI object factory that creates an instance of `BasicDataSource` that has been configured based on the `RefAddr` values of the specified `Reference`, which must match the names and data types of the `BasicDataSource` bean properties.
DataSourceLinkFactory: Object factory for resource links for shared data sources.
DataSourceLinkFactory.DataSourceHandler: Simple wrapper class that will allow a user to configure a ResourceLink for a data source so that when `DataSource.getConnection()` is called, it will invoke `DataSource.getConnection(String, String)` with the preconfigured username and password.
DataSourceMXBean: Defines the methods that will be made available via JMX.
DataSourceProxy: The DataSource proxy lets us implements methods that don't exist in the current compiler JDK but might be methods that are part of a future JDK DataSource interface.
DataSourceRealm: Implementation of Realm that works with any JDBC JNDI DataSource.
DataSourceStore: Implementation of the `Store` interface that stores serialized session objects in a database.
DateFormatCache: Cache structure for SimpleDateFormat formatted timestamps based on seconds.
Decoder: Deprecated. This interface is unused and will be removed in Tomcat 9
DecoderEntry
DecoderException: Deprecated. This exception is unused and will be removed in Tomcat 9
DefaultEvictionPolicy<T>: Provides the default implementation of `EvictionPolicy` used by the pools.
DefaultInstanceManager
DefaultPooledObject<T>: This wrapper is used to track the additional information, such as state, for the pooled objects.
DefaultPooledObjectInfo: Implementation of object that is used to provide information on pooled objects via JMX.
DefaultPooledObjectInfoMBean: The interface that defines the information about pooled objects that will be exposed via JMX.
DefaultServerEndpointConfigurator
DefaultServlet: The default resource-serving servlet for most web applications, used to serve static resources such as HTML pages and images.
DefaultServlet.CompressionFormat
DefaultServlet.Range
DeferredFileOutputStream: An output stream which will retain data in memory until a specified threshold is reached, and only then commit it to disk.
DelegatingCallableStatement: A base delegating implementation of `CallableStatement`.
DelegatingConnection<C extends java.sql.Connection>: A base delegating implementation of `Connection`.
DelegatingDatabaseMetaData: A base delegating implementation of `DatabaseMetaData`.
DelegatingPreparedStatement: A base delegating implementation of `PreparedStatement`.
DelegatingResultSet: A base delegating implementation of `ResultSet`.
DelegatingStatement: A base delegating implementation of `Statement`.
DeltaManager: The DeltaManager manages replicated sessions by only replicating the deltas in data.
DeltaRequest: This class is used to track the series of actions that happens when a request is executed.
DeltaSession: Similar to the StandardSession except that this session will keep track of deltas during a request.
DeployTask: Ant task that implements the `/deploy` command, supported by the Tomcat manager application.
DeployXmlPermission: Grant this permission to a docBase to permit the web application to use any `META-INF/context.xml` that might be present with in the application when `deployXML` has been disabled at the Host level.
DestroyMode: Destroy context provided to object factories via destroyObject methods.
Diagnostics
DigestAuthenticator: An Authenticator and Valve implementation of HTTP DIGEST Authentication, as outlined in RFC 7616: "HTTP Digest Authentication"
DigestAuthenticator: Authenticator supporting the DIGEST authentication method.
DigestAuthenticator.AuthDigest: This enum exists because RFC 7616 and Java use different names for some digests.
DigestAuthenticator.DigestInfo
DigestAuthenticator.NonceInfo
DigestCredentialHandlerBase: Base implementation for the Tomcat provided `CredentialHandler`s.
Digester: A Digester processes an XML input stream by matching a series of element nesting patterns to execute Rules that have been added prior to the start of parsing.
Digester.EnvironmentPropertySource: Deprecated. Use `EnvironmentPropertySource` This will be removed in Tomcat 10 onwards.
DigesterFactory: Wrapper class around the Digester that hide Digester's initialization details.
DirectByteArrayOutputStream: Byte array output stream that exposes the byte array directly
Directory: Deprecated. The scope of the APR/Native Library will be reduced in Tomcat 10.1.x / Tomcat Native 2.x onwards to only include those components required to provide OpenSSL integration with the NIO and NIO2 connectors.
DirResourceSet: Represents a `WebResourceSet` based on a directory.
DiskFileItem: The default implementation of the `FileItem` interface.
DiskFileItemFactory: The default `FileItemFactory` implementation.
DispatchType: This enumeration lists the different types of dispatches that request processing can trigger.
DisposableConnectionFacade: A DisposableConnectionFacade object is the top most interceptor that wraps an object of type `PooledConnection`.
DistributedManager: Interface implemented by session managers that do not keep a complete copy of all sessions in memory but do know where every session is.
DocumentProperties: A collection of interfaces, one per property, that enables the object being populated by the digester to signal to the digester that it supports the given property and that the digester should populate that property if available.
DocumentProperties.Charset: The character encoding used by the source XML document.
DocumentProperties.Encoding: Deprecated. This method will be removed in Tomcat 9
DomainFilterInterceptor: Filters membership based on domain.
DomainFilterInterceptorMBean
DOMWriter: A sample DOM writer.
DriverAdapterCPDS: An adapter for JDBC drivers that do not include an implementation of `ConnectionPoolDataSource`, but still include a `DriverManager` implementation.
DriverConnectionFactory: A `Driver`-based implementation of `ConnectionFactory`.
DriverManagerConnectionFactory: A `DriverManager`-based implementation of `ConnectionFactory`.
DummyProxySession
EjbFactory: Object factory for EJBs.
EjbRef: Represents a reference address to an EJB.
ELArithmetic: A helper class of Arithmetic defined by the EL Specification
ELArithmetic.BigDecimalDelegate
ELArithmetic.BigIntegerDelegate
ELArithmetic.DoubleDelegate
ELArithmetic.LongDelegate
ELContextImpl: Implementation of ELContext
ELContextWrapper: Simple ELContextWrapper for runtime evaluation of EL w/ dynamic FunctionMappers
ElementValue: The element_value structure is documented at https://docs.oracle.com/javase/specs/jvms/se11/html/jvms-4.html#jvms-4.7.16.1
ElementValuePair: An annotation's element value pair.
ELFunctionMapper: This class generates functions mappers for the EL expressions in the page.
ELInterpreter: Defines the interface for the expression language interpreter.
ELInterpreterFactory: Provides `ELInterpreter` instances for JSP compilation.
ELInterpreterFactory.DefaultELInterpreter
ELInterpreterTagSetters: A non-specification compliant `ELInterpreter` that optimizes a subset of setters for tag attributes.
ELParser: This class implements a parser for EL expressions.
ELResolverImpl: Deprecated.
ELSupport: A helper class that implements the EL Specification
EmbeddedServletOptions: A class to hold all init parameters specific to the JSP engine.
EmptyResource
EmptyResourceSet: A `WebResourceSet` implementation that is not backed by a file system and behaves as if it has no resources available.
EncodedSolidusHandling
Encoder: Deprecated. This interface is unused and will be removed in Tomcat 9
EncoderException: Deprecated. This exception is unused and will be removed in Tomcat 9
EncodingMap: Deprecated. Will be removed in Tomcat 9.0.x onwards
EncryptInterceptor: Adds encryption using a pre-shared key.
EncryptInterceptorMBean
Encryption
EncryptionLevel
EndpointClassHolder
EndpointHolder
Engine: An Engine is a Container that represents the entire Catalina servlet engine.
EngineConfig: Startup event listener for an Engine that configures the properties of that Engine, and the associated defined contexts.
EngineRuleSet: RuleSet for processing the contents of a Engine definition element.
EntityTag
EnumElementValue
EnvironmentPropertySource: A `IntrospectionUtils.SecurePropertySource` that uses environment variables to resolve expressions.
Error: Deprecated. Unused.
ErrorDispatcher: Class responsible for dispatching JSP parse and javac compilation errors to the configured error handler.
ErrorHandler: The `ErrorHandler` class is used when sending messages that are sent asynchronously and the application still needs to get confirmation when the message was sent successfully or when a message errored out.
ErrorHandler: Interface for handling JSP parse and javac compilation errors.
ErrorPage: Representation of an error page element for a web application, as represented in a `<error-page>` element in the deployment descriptor.
ErrorPageSupport: Provides support for tracking per exception type and per HTTP status code error pages.
ErrorReportValve: Implementation of a Valve that outputs HTML error pages.
ErrorState
Escape: Provides utility methods to escape content for different contexts.
EvaluationContext
EvictionConfig: This class is used by pool implementations to pass configuration information to `EvictionPolicy` instances.
EvictionPolicy<T>: To provide a custom eviction policy (i.e. something other than `DefaultEvictionPolicy` for a pool, users must provide an implementation of this interface that provides the required eviction policy.
ExceptionUtils: Utilities for handling Throwables and Exceptions.
ExceptionUtils: Utilities for handling Throwables and Exceptions.
ExceptionUtils: Utilities for handling Throwables and Exceptions.
ExceptionUtils: Utilities for handling Throwables and Exceptions.
Executor
ExecutorFactory
ExpandWar: Expand out a WAR in a Host's appBase.
ExpiresFilter: ExpiresFilter is a Java Servlet API port of Apache mod_expires to add '`Expires`' and '`Cache-Control: max-age=`' headers to HTTP response according to its '`Content-Type`'.
ExpiresFilter.Duration: Duration composed of an `ExpiresFilter.Duration.amount` and a `ExpiresFilter.Duration.unit`
ExpiresFilter.DurationUnit: Duration unit
ExpiresFilter.ExpiresConfiguration: Main piece of configuration of the filter.
ExpiresFilter.StartingPoint: Expiration configuration starting point.
ExpressionBuilder
ExpressionEvaluatorImpl: Deprecated.
ExpressionFactoryImpl
ExpressionImpl: Deprecated.
ExpressionParseTree: Represents a parsed expression.
ExpressionTokenizer: Parses an expression string to return the individual tokens.
ExtendedAccessLogValve: An implementation of the W3c Extended Log File Format.
ExtendedAccessLogValve.CookieElement
ExtendedAccessLogValve.DateElement
ExtendedAccessLogValve.PatternTokenizer
ExtendedAccessLogValve.RequestAttributeElement
ExtendedAccessLogValve.RequestHeaderElement
ExtendedAccessLogValve.RequestParameterElement
ExtendedAccessLogValve.ResponseAllHeaderElement: write a specific response header - x-O(xxx)
ExtendedAccessLogValve.ResponseHeaderElement
ExtendedAccessLogValve.ServletContextElement
ExtendedAccessLogValve.SessionAttributeElement
ExtendedAccessLogValve.TimeElement
ExtendedRpcCallback: Extension to the `RpcCallback` interface.
Extension: Utility class that represents either an available "Optional Package" (formerly known as "Standard Extension") as described in the manifest of a JAR file, or the requirement for such an optional package.
ExtensionValidator: Ensures that all extension dependencies are resolved for a WEB application are met.
ExtractingRoot: If the main resources are packaged as a WAR file then any JARs will be extracted to the work directory and used from there.
FactoryBase: Abstract base class that provides common functionality required by sub-classes.
FactoryCreateRule: Rule implementation that uses an `ObjectCreationFactory` to create a new object which it pushes onto the object stack.
FailedContext: An implementation of `Context` that is used as a place-holder for deployed applications when their deployment fails and a Context instance (usually `StandardContext` but may be any Context implementation) cannot be created.
FailedRequestFilter: Filter that will reject requests if there was a failure during parameter parsing.
FairBlockingQueue<E>: A simple implementation of a blocking queue with fairness waiting.
FarmWarDeployer: A farm war deployer is a class that is able to deploy/undeploy web applications in WAR from within the cluster.
FastHttpDateFormat: Utility class to generate HTTP dates.
FastRemovalDequeue<T>: The FastRemovalDequeue is a Dequeue that supports constant time removal of entries.
FeatureInfo: Convenience base class for `AttributeInfo` and `OperationInfo` classes that will be used to collect configuration information for the `ModelMBean` beans exposed for management.
File: Deprecated. The scope of the APR/Native Library will be reduced in Tomcat 10.1.x / Tomcat Native 2.x onwards to only include those components required to provide OpenSSL integration with the NIO and NIO2 connectors.
FileChangeListener
FileCountLimitExceededException: This exception is thrown if a request contains more files than the specified limit.
FileHandler: Implementation of Handler that appends log messages to a file named {prefix}{date}{suffix} in a configured directory.
FileHandler.ThreadFactory
FileInfo: Deprecated. The scope of the APR/Native Library will be reduced in Tomcat 10.1.x / Tomcat Native 2.x onwards to only include those components required to provide OpenSSL integration with the NIO and NIO2 connectors.
FileItem: This class represents a file or form item that was received within a `multipart/form-data` POST request.
FileItemFactory: A factory interface for creating `FileItem` instances.
FileItemHeaders: This class provides support for accessing the headers for a file or form item that was received within a `multipart/form-data` POST request.
FileItemHeadersImpl: Default implementation of the `FileItemHeaders` interface.
FileItemHeadersSupport: Interface that will indicate that `FileItem` or `FileItemStream` implementations will accept the headers read for the item.
FileItemIterator: An iterator, as returned by `FileUploadBase.getItemIterator(RequestContext)`.
FileItemIteratorImpl: The iterator, which is returned by `FileUploadBase.getItemIterator(RequestContext)`.
FileItemStream: This interface provides access to a file or form item that was received within a `multipart/form-data` POST request.
FileItemStream.ItemSkippedException: This exception is thrown, if an attempt is made to read data from the `InputStream`, which has been returned by `FileItemStream.openStream()`, after `Iterator.hasNext()` has been invoked on the iterator, which created the `FileItemStream`.
FileItemStreamImpl: Default implementation of `FileItemStream`.
FileMessage: Contains the data for a file being transferred over TCP, this is essentially a fragment of a file, read and written by the FileMessageFactory.
FileMessageFactory: This factory is used to read files and write files by splitting them up into smaller messages.
FileResource: Represents a single resource (file or directory) that is located on a file system.
FileResourceSet: Represents a `WebResourceSet` based on a single file.
FileSizeLimitExceededException: Thrown to indicate that A files size exceeds the configured maximum.
FileStore: Concrete implementation of the Store interface that utilizes a file per saved Session in a configured directory.
FileUpload: High level API for processing file uploads.
FileUploadBase: High level API for processing file uploads.
FileUploadException: Exception for errors encountered while processing the request.
FileUploadIOException: This exception is thrown for hiding an inner `FileUploadException` in an `IOException`.
FileUtils: General file manipulation utilities.
FilterBase: Base class for filters that provides generic initialisation and a simple no-op destruction.
FilterDef: Representation of a filter definition for a web application, as represented in a `<filter>` element in the deployment descriptor.
FilterMap: Representation of a filter mapping for a web application, as represented in a `<filter-mapping>` element in the deployment descriptor.
FindLeaksTask: Ant task that implements the `/findleaks` command, supported by the Tomcat manager application.
ForceUtcTimeZone
ForEach
FormAuthenticator: An Authenticator and Valve implementation of FORM BASED Authentication, as described in the Servlet API Specification.
ForTokens
FragmentationInterceptor: The fragmentation interceptor splits up large messages into smaller messages and assembles them on the other end.
FragmentationInterceptor.FragCollection
FragmentationInterceptor.FragKey
FragmentationInterceptorMBean
FragmentJarScannerCallback: Callback handling a web-fragment.xml descriptor.
FunctionMapperFactory
FunctionMapperImpl
FunctionMapperImpl: Deprecated.
FunctionMapperImpl.Function
GenericKeyedObjectPool<K,​T>: A configurable `KeyedObjectPool` implementation.
GenericKeyedObjectPoolConfig<T>: A simple "struct" encapsulating the configuration for a `GenericKeyedObjectPool`.
GenericKeyedObjectPoolMXBean<K>: Defines the methods that will be made available via JMX.
GenericNamingResourcesFactory: Simple way of configuring generic resources by using reflection.
GenericObjectPool<T>: A configurable `ObjectPool` implementation.
GenericObjectPoolConfig<T>: A simple "struct" encapsulating the configuration for a `GenericObjectPool`.
GenericObjectPoolMXBean: Defines the methods that will be made available via JMX.
GenericPrincipal: Generic implementation of java.security.Principal that is available for use by `Realm` implementations.
Global: Deprecated. The scope of the APR/Native Library will be reduced in Tomcat 10.1.x / Tomcat Native 2.x onwards to only include those components required to provide OpenSSL integration with the NIO and NIO2 connectors.
GlobalNamingResourcesSF: store server.xml GlobalNamingResource.
GlobalResourcesLifecycleListener: Implementation of `LifecycleListener` that instantiates the set of MBeans associated with global JNDI resources that are subject to management.
Globals: Global constants that are applicable to multiple packages within Catalina.
Group: Abstract representation of a group of `User`s in a `UserDatabase`.
GroupChannel: The default implementation of a Channel. The GroupChannel manages the replication channel.
GroupChannel.HeartbeatThread: If `Channel.getHeartbeat()==true` then a thread of this class is created.
GroupChannel.InterceptorIterator: An iterator to loop through the interceptors in a channel.
GroupChannelMBean
GroupMBean: A ModelMBean implementation for the `org.apache.catalina.Group` component.
GSSRealm: Deprecated. This will be removed in Tomcat 9 and integrated into `Realm`.
GzipInterceptor
GzipOutputFilter: Gzip output filter.
Handler
HandlerRef: Represents a reference handler for a web service.
HeadersTooLargeException: Exception used to mark the specific error condition of the HTTP headers exceeding the maximum permitted size.
HeaderUtil
Heartbeat: Can be implemented by the ChannelListener and Membership listeners to receive heartbeat notifications from the Channel
HeartbeatListener
HexUtils: Tables useful when converting byte arrays to and from strings of hexadecimal digits.
HomesUserDatabase: Concrete implementation of the `UserDatabase` interface considers all directories in a directory whose pathname is specified to our constructor to be "home" directories for those users.
Host: A Host is a Container that represents a virtual host in the Catalina servlet engine.
Host
HostConfig: Startup event listener for a Host that configures the properties of that Host, and the associated defined contexts.
HostConfig.DeployedApplication: This class represents the state of a deployed application, as well as the monitored resources.
HostManagerServlet: Servlet that enables remote management of the virtual hosts installed on the server.
HostRuleSet: RuleSet for processing the contents of a Host definition element.
HpackDecoder: A decoder for HPACK.
HPackHuffman
HPackHuffman.HuffmanCode
HTMLHostManagerServlet: Servlet that enables remote management of the virtual hosts deployed on the server.
HTMLManagerServlet: Servlet that enables remote management of the web applications deployed within the same virtual host as this web application is.
Http11AprProtocol: Deprecated. The APR/Native Connector will be removed in Tomcat 10.1.x onwards.
Http11InputBuffer: InputBuffer for HTTP that provides request header parsing as well as transfer encoding.
Http11Nio2Protocol: HTTP/1.1 protocol implementation using NIO2.
Http11NioProtocol: HTTP/1.1 protocol implementation using NIO.
Http11OutputBuffer: Provides buffering for the HTTP headers (allowing responses to be reset before they have been committed) and the link to the Socket for writing the headers (once committed) and the response body.
Http11Processor
Http11Protocol: Deprecated. This class will be removed in Tomcat 9.
Http2OutputBuffer
Http2Protocol
HttpHeaderSecurityFilter: Provides a single configuration point for security measures that required the addition of one or more HTTP headers to the response.
HttpJspBase: This is the super class of all JSP-generated servlets.
HttpMessages: Handle (internationalized) HTTP messages.
HttpOutputBuffer
HttpParser: HTTP header value parser implementation.
IdentityInputFilter: Identity input filter.
IdentityOutputFilter: Identity output filter.
If
ImplicitTldRuleSet: RulesSet for digesting implicit.tld files.
Import
Import
Injectable
InjectionTarget
InputBuffer: The buffer used by Tomcat request.
InputBuffer: This class is only for internal use in the protocol implementation.
InputFilter: Input filter interface.
InputSourceUtil
InstanceKeyDataSource: The base class for `SharedPoolDataSource` and `PerUserPoolDataSource`.
InstanceManager
InstanceManagerBindings
InstanceManagerFactory
InstrumentableClassLoader: Specifies a class loader capable of being decorated with `ClassFileTransformer`s.
InterceptorPayload
InterceptorSF: Generate Interceptor Element
InternalHttpUpgradeHandler: This Tomcat specific interface is implemented by handlers that require direct access to Tomcat's I/O layer rather than going through the Servlet API.
InternalRewriteMap
InternalRewriteMap.Escape
InternalRewriteMap.LowerCase
InternalRewriteMap.Unescape
InternalRewriteMap.UpperCase
Introspection: Provides introspection utilities that either require knowledge of Tomcat internals or are solely used by Tomcat internals.
IntrospectionUtils: Utils for introspection and reflection
IntrospectionUtils.PropertySource
IntrospectionUtils.SecurePropertySource
InvalidContentTypeException: Thrown to indicate that the request is not a multipart request.
InvalidFileNameException: This exception is thrown in case of an invalid file name.
IOFileUploadException: Thrown to indicate an IOException.
IOTools: Contains commonly needed I/O-related methods
IOUtils: General IO stream manipulation utilities.
IPv6Utils: IPv6 utilities.
IStoreConfig
IStoreFactory
JAASCallbackHandler: Implementation of the JAAS `CallbackHandler` interface, used to negotiate delivery of the username and credentials that were specified to our constructor.
JAASMemoryLoginModule: Implementation of the JAAS LoginModule interface, primarily for use in testing `JAASRealm`.
JAASRealm: Implementation of Realm that authenticates users via the Java Authentication and Authorization Service (JAAS).
Jar: Provides an abstraction for use by the various classes that need to scan JARs.
JarFactory: Provide a mechanism to obtain objects that implement `Jar`.
JarFileUrlJar: Implementation of `Jar` that is optimised for file based JAR URLs that refer directly to a JAR file (e.g URLs of the form jar:file: ... .jar!
JarFileUrlNestedJar: Implementation of `Jar` that is optimised for file based JAR URLs that refer to a JAR file nested inside a WAR (e.g URLs of the form jar:file: ... .war!
JarResource: Represents a single resource (file or directory) that is located within a JAR.
JarResourceRoot
JarResourceSet: Represents a `WebResourceSet` based on a JAR file.
JarScanFilter
JarScanner: Scans a web application and classloader hierarchy for JAR files.
JarScannerCallback: This interface is implemented by clients of the `JarScanner` to enable them to receive notification of a discovered JAR.
JarScannerFactory: Provide a mechanism for Jasper to obtain a reference to the JarScanner implementation.
JarScannerSF: Store server.xml Element JarScanner
JarScanType
JarWarResource: Represents a single resource (file or directory) that is located within a JAR that in turn is located in a WAR file.
JarWarResourceSet: Represents a `WebResourceSet` based on a JAR file that is nested inside a packed WAR file.
JasperELResolver: Jasper-specific CompositeELResolver that optimizes certain functions to avoid unnecessary resolver calls.
JasperException: Base class for all exceptions generated by the JSP engine.
JasperInitializer: Initializer for the Jasper JSP Engine.
JasperLoader: Class loader for loading servlet class files (corresponding to JSP files) and tag handler class files (corresponding to tag files).
JavacErrorDetail: Class providing details about a javac compilation error.
JavaCharStream: An implementation of interface CharStream, where the stream is assumed to contain only ASCII characters (with java-like unicode escape processing).
JavaClass: Represents a Java class, i.e., the data structures, constant pool, fields, methods and commands contained in a Java .class file.
javaURLContextFactory: Context factory for the "java:" namespace.
Jdbc41Bridge: Defines bridge methods to JDBC 4.1 (Java 7) methods to allow call sites to operate safely (without `AbstractMethodError`) when using a JDBC driver written for JDBC 4.0 (Java 6).
JDBCAccessLogValve: This Tomcat extension logs server access directly to a database, and can be used instead of the regular file-based access log implemented in AccessLogValve.
JdbcInterceptor: Abstract class that is to be extended for implementations of interceptors.
JdbcLeakPrevention: This class is loaded by `WebappClassLoaderBase` to enable it to deregister JDBC drivers forgotten by the web application.
JDBCRealm: Deprecated. Will be removed in Tomcat 10 onwards.
JDBCStore: Deprecated. Removed in Tomcat 10 and replaced by DataSourceStore with removal of legacy JDBC code
JdkLoggerFormatter: A more compact formatter.
JDTCompiler: JDT class compiler.
JKStatusUpdateTask: Ant task that implements the `/status` command, supported by the mod_jk status (1.2.9) application.
JMXAccessorCondition: Definition:
JMXAccessorConditionBase
JMXAccessorCreateTask: Create new MBean at JMX JSR 160 MBeans Server.
JMXAccessorEqualsCondition: Definition
JMXAccessorGetTask: Access JMX JSR 160 MBeans Server.
JMXAccessorInvokeTask: Access JMX JSR 160 MBeans Server.
JMXAccessorQueryTask: Query for Mbeans.
JMXAccessorSetTask: Access JMX JSR 160 MBeans Server.
JMXAccessorTask: Access JMX JSR 160 MBeans Server.
JMXAccessorUnregisterTask: unregister an MBean at JMX JSR 160 MBeans Server.
JmxChannel
JmxEnabled: This interface is implemented by components that will be registered with an MBean server when they are created and unregistered when they are destroyed.
JMXGetTask: Ant task that implements the JMX Get command (`/jmxproxy/?`
JMXProxyServlet: This servlet will dump JMX attributes in a simple format and implement proxy services for modeler.
JMXQueryTask: Ant task that implements the JMX Query command (`/jmxproxy/?`
JmxRegistry
JMXSetTask: Ant task that implements the JMX Set command (`/jmxproxy/?`
JmxUtil
JNDIRealm: Implementation of Realm that works with a directory server accessed via the Java Naming and Directory Interface (JNDI) APIs.
JNDIRealm.JNDIConnection: Class holding the connection to the directory plus the associated non thread safe message formats.
JNDIRealm.User: A protected class representing a User
JniLifecycleListener: An implementation of LifeCycleListener that loads a native library into the JVM.
Jre19Compat
Jre21Compat
JreCompat
JreCompat: This is the base implementation class for JRE compatibility and provides an implementation based on Java 7.
JreMemoryLeakPreventionListener: Provide a workaround for known places where the Java Runtime environment can cause a memory leak or lock files.
JrePlatform
JreVendor
JsonAccessLogValve: Access log valve derivative that rewrites entries as JSON.
JsonAccessLogValve.CharElement: write any char
JsonErrorReportValve: Implementation of a Valve that outputs error jsons.
JSONFilter: Provides escaping of values so they can be included in a JSON document.
JSONParser: Basic JSON parser generated by JavaCC.
JSONParserConstants: Token literal values and constants.
JSONParserTokenManager: Token Manager.
JspApplicationContextImpl: Implementation of JspApplicationContext
JspC: Shell for the jspc compiler.
JspCompilationContext: A place holder for various things that are used through out the JSP engine.
JspConfig: Handles the jsp-config element in WEB_INF/web.xml.
JspConfig.JspProperty
JspConfig.JspPropertyGroup
JspConfigDescriptorImpl
JspContextWrapper: Implementation of a JSP Context Wrapper.
JspCServletContext: Simple `ServletContext` implementation without HTTP-specific methods.
JspELException
JspFactoryImpl: Implementation of JspFactory.
JspFragmentHelper: Helper class from which all Jsp Fragment helper classes extend.
JspHelper: Helper JavaBean for JSPs, because JSTL 1.1/EL 2.0 is too dumb to to what I need (call methods with parameters), or I am too dumb to use it correctly. :)
JspMethodExpression
JspMethodNotFoundException
JspPropertyGroup: Representation of a jsp-property-group element in web.xml.
JspPropertyGroupDescriptorImpl
JspPropertyNotFoundException
JspPropertyNotWritableException
JspRuntimeContext: Class for tracking JSP compile time file dependencies when the >%@include file="
JspRuntimeLibrary: Bunch of util methods that are used by code generated for useBean, getProperty and setProperty.
JspServlet: The JSP engine (a.k.a Jasper).
JspServletWrapper: The JSP engine (a.k.a Jasper).
JspSourceDependent: Interface for tracking the source files dependencies, for the purpose of compiling out of date pages.
JspSourceImports: The EL engine needs access to the imports used in the JSP page to configure the ELContext.
JspUtil: This class has all the utility method(s).
JspUtil.ValidAttribute
JspValueExpression: Wrapper for providing context to ValueExpressions
JspWriterImpl: Write text to a character-output stream, buffering characters so as to provide for the efficient writing of single characters, arrays, and strings.
JSSEImplementation
JSSEKeyManager: X509KeyManager which allows selection of a specific key pair and certificate chain (identified by their keystore alias name) to be used by the server to authenticate itself to SSL clients.
JSSESupport: JSSESupport.
JSSEUtil: SSLUtil implementation for JSSE.
JvmRouteBinderValve: Valve to handle Tomcat jvmRoute takeover using mod_jk module after node failure.
KeyedObjectPool<K,​V>: A "keyed" pooling interface.
KeyedPooledObjectFactory<K,​V>: An interface defining life-cycle methods for instances to be served by a `KeyedObjectPool`.
KeyExchange
KeyStoreUtil
LambdaExpressionNestedState: Stores the state required for correct evaluation of lambda expressions.
LazyReplicatedMap<K,​V>: A smart implementation of a stateful replicated map. uses primary/secondary backup strategy.
LegacyCookieProcessor: The legacy (up to early Tomcat 8 releases) cookie parser based on RFC6265, RFC2109 and RFC2616.
Library
LibraryNotFoundError
Lifecycle: Common interface for component life cycle methods.
Lifecycle.SingleUse: Marker interface used to indicate that the instance should only be used once.
LifecycleBase: Base implementation of the `Lifecycle` interface that implements the state transition rules for `Lifecycle.start()` and `Lifecycle.stop()`
LifecycleEvent: General event for notifying listeners of significant changes on a component that implements the Lifecycle interface.
LifecycleException: General purpose exception that is thrown to indicate a lifecycle related problem.
LifecycleListener: Interface defining a listener for significant events (including "component start" and "component stop" generated by a component that implements the Lifecycle interface.
LifecycleListenerRule: Rule that creates a new `LifecycleListener` and associates it with the top object on the stack which must implement `Container`.
LifecycleMBeanBase
LifecycleState: The list of valid states for components that implement `Lifecycle`.
LimitedInputStream: An input stream, which limits its data size.
LimitLatch: Shared latch that allows the latch to be acquired a limited number of times after which all subsequent requests to acquire the latch will be placed in a FIFO queue until one of the shares is returned.
ListenCallback: Internal interface, similar to the MessageListener but used at the IO base The listen callback interface is used by the replication system when data has been received.
ListException: An exception wrapping a list of exceptions.
ListTask: Ant task that implements the `/list` command, supported by the Tomcat manager application.
LoadBalancerDrainingValve: A Valve to detect situations where a load-balanced node receiving a request has been deactivated by the load balancer (JK_LB_ACTIVATION=DIS) and the incoming request has no valid session.
Loader: A Loader represents a Java ClassLoader implementation that can be used by a Container to load class files (within a repository associated with the Loader) that are designed to be reloaded upon request, as well as a mechanism to detect whether changes have occurred in the underlying repository.
LoaderSF: Store Loader Element.
Local: Deprecated. The scope of the APR/Native Library will be reduced in Tomcat 10.1.x / Tomcat Native 2.x onwards to only include those components required to provide OpenSSL integration with the NIO and NIO2 connectors.
Localizer: Class responsible for converting error codes to corresponding localized error messages.
LocalResolver: A resolver for locally cached XML resources.
Lock: Deprecated. The scope of the APR/Native Library will be reduced in Tomcat 10.1.x / Tomcat Native 2.x onwards to only include those components required to provide OpenSSL integration with the NIO and NIO2 connectors.
LockOutRealm: This class extends the CombinedRealm (hence it can wrap other Realms) to provide a user lock out mechanism if there are too many failed authentication attempts in a given period of time.
LockOutRealm.LockRecord
Log: A simple logging interface abstracting logging APIs.
LogConfigurationException: An exception that is thrown only if a suitable `LogFactory` or `Log` instance cannot be created by the corresponding factory methods.
LogFactory: This is a modified LogFactory that uses a simple `ServiceLoader` based discovery mechanism with a default of using JDK based logging.
LoginConfig: Representation of a login configuration element for a web application, as represented in a `<login-config>` element in the deployment descriptor.
Logs: Simple class that holds references to global loggers
LookupFactory: Object factory for lookups.
LookupRef: Represents a reference to lookup.
MailSessionFactory: Factory class that creates a JNDI named JavaMail Session factory, which can be used for managing inbound and outbound electronic mail messages via JavaMail APIs.
ManagedBean: Internal configuration information for a managed bean (MBean) descriptor.
ManagedChannel: Channel interface A managed channel interface gives you access to the components of the channels such as senders, receivers, interceptors etc for configurations purposes
ManagedConcurrentWeakHashMap<K,​V>: Concurrent hash map that holds its keys via weak references.
Manager: A Manager manages the pool of Sessions that are associated with a particular Context.
ManagerBase: Minimal implementation of the Manager interface that supports no session persistence or distributable capabilities.
ManagerBase.SessionTiming
ManagerServlet: Servlet that enables remote management of the web applications installed within the same virtual host as this web application is.
ManagerSF: Store server.xml Manager element
ManifestResource: Representation of a Manifest file and its available extensions and required extensions
Mapper: Mapper, which implements the servlet API mapping rules (which are derived from the HTTP rules).
Mapper.ContextList
Mapper.ContextVersion
Mapper.MapElement<T>
Mapper.MappedContext
Mapper.MappedHost
Mapper.MappedWrapper
MapperListener: Mapper listener.
MappingData: Mapping data.
Matcher: This is a utility class to match file globs.
MBeanDumper: General helper to dump MBean contents to the log.
MBeanFactory
MbeansDescriptorsDigesterSource
MbeansDescriptorsIntrospectionSource
MBeanUtils: Public utility methods in support of the server side MBeans implementation.
McastService: A membership implementation using simple multicast.
McastServiceImpl: A membership implementation using simple multicast.
McastServiceImpl.RecoveryThread
McastServiceMBean
MD5Encoder: Deprecated. Unused.
MediaType
MediaTypeCache: Caches the results of parsing content-type headers.
Member: The Member interface, defines a member in the group.
MemberImpl: A membership implementation using simple multicast.
Membership: A membership implementation using simple multicast.
Membership.MbrEntry: Inner class that represents a member entry
MembershipListener: The MembershipListener interface is used as a callback to the membership service.
MembershipService: MembershipService Interface The `MembershipService` interface is the membership component at the bottom layer, the IO layer (for layers see the javadoc for the `Channel` interface).
MemoryGroup: Deprecated. Use `AbstractGroup` instead.
MemoryRealm: Simple implementation of Realm that reads an XML file to configure the valid users, passwords, and roles.
MemoryRole: Deprecated. Use `AbstractRole` instead.
MemoryRuleSet: RuleSet for recognizing the users defined in the XML file processed by `MemoryRealm`.
MemoryUser: Deprecated. Use `AbstractUser` instead.
MemoryUserDatabase: Concrete implementation of `UserDatabase` that loads all defined users, groups, and roles into an in-memory data structure, and uses a specified XML file for its persistent storage.
MemoryUserDatabaseFactory: JNDI object creation factory for `MemoryUserDatabase` instances.
MemoryUserDatabaseMBean: A ModelMBean implementation for the `org.apache.catalina.users.MemoryUserDatabase` component.
MessageBytes: This class is used to represent a subarray of bytes in an HTTP message.
MessageDestination: Representation of a message destination for a web application, as represented in a `<message-destination>` element in the deployment descriptor.
MessageDestinationRef: Representation of a message destination reference for a web application, as represented in a `<message-destination-ref>` element in the deployment descriptor.
MessageDigest

MessageDigestCredentialHandler

This credential handler supports the following forms of stored passwords: encodedCredential - a hex encoded digest of the password digested using the configured digest {MD5}encodedCredential - a Base64 encoded MD5 digest of the password {SHA}encodedCredential - a Base64 encoded SHA1 digest of the password {SSHA}encodedCredential - 20 byte Base64 encoded SHA1 digest followed by variable length salt.

MessageDispatchInterceptor: The message dispatcher is a way to enable asynchronous communication through a channel.
MessageDispatchInterceptorMBean
MessageFactory
MessageHandlerResult
MessageHandlerResultType
MessageInfoImpl
MessageListener: The listener to be registered with the ChannelReceiver, internal Tribes component.
MethodExpressionImpl: An `Expression` that refers to a method on an object.
MethodExpressionLiteral
MIME2Java: Deprecated. Unused.
MimeHeaders: Memory-efficient repository for Mime Headers.
MimeUtility: Utility class to decode MIME texts.
Mmap: Deprecated. The scope of the APR/Native Library will be reduced in Tomcat 10.1.x / Tomcat Native 2.x onwards to only include those components required to provide OpenSSL integration with the NIO and NIO2 connectors.
ModelerSource: Source for descriptor data.
Multicast: Deprecated. The scope of the APR/Native Library will be reduced in Tomcat 10.1.x / Tomcat Native 2.x onwards to only include those components required to provide OpenSSL integration with the NIO and NIO2 connectors.
MultiCastSender
MultiLockFairBlockingQueue<E>: EXPERIMENTAL AND NOT YET COMPLETE!
MultipartDef: Representation of a the multipart configuration for a servlet.
MultipartStream: Low level API for processing file uploads.
MultipartStream.IllegalBoundaryException: Thrown upon attempt of setting an invalid boundary token.
MultipartStream.MalformedStreamException: Thrown to indicate that the input stream fails to follow the required syntax.
MultipartStream.ProgressNotifier: Internal class, which is used to invoke the `ProgressListener`.
MultipointBioSender
MultiPointSender
MultiThrowable: Wraps a list of throwables as a single throwable.
NameParserImpl: Parses names.
NamingContext: Catalina JNDI Context implementation.
NamingContextBindingsEnumeration: Naming enumeration implementation.
NamingContextEnumeration: Naming enumeration implementation.
NamingContextListener: Helper class used to initialize and populate the JNDI context associated with each context and server.
NamingEntry: Represents a binding in a NamingContext.
NamingResources: Defines an interface for the object that is added to the representation of a JNDI resource in web.xml to enable it to also be the implementation of that JNDI resource.
NamingResourcesImpl: Holds and manages the naming resources defined in the J2EE Enterprise Naming Context and their associated JNDI context.
NamingResourcesMBean: A ModelMBean implementation for the `org.apache.catalina.deploy.NamingResourcesImpl` component.
NamingResourcesSF: Store server.xml elements Resources at context and GlobalNamingResources
NamingRuleSet: RuleSet for processing the JNDI Enterprise Naming Context resource declaration elements.
NestedCredentialHandler
NetMask: A class representing a CIDR netmask.
NetMaskSet: This class maintains a Set of NetMask objects and allows to check if a given IP address is matched by any of the NetMasks, making it easy to create Allow and Deny lists of CIDR networks and hosts.
Nio2Channel: Base class for a SocketChannel wrapper used by the endpoint.
Nio2Endpoint: NIO2 endpoint.
Nio2Endpoint.Nio2SocketWrapper
Nio2Endpoint.SendfileData: SendfileData class.
NioChannel: Base class for a SocketChannel wrapper used by the endpoint.
NioEndpoint: NIO tailored thread pool, providing the following services: Socket acceptor thread Socket poller thread Worker threads pool TODO: Consider using the virtual machine's thread pool.
NioEndpoint.NioSocketWrapper
NioEndpoint.PollerEvent: PollerEvent, cacheable object for poller events to avoid GC
NioEndpoint.SendfileData: SendfileData class.
NioReceiver
NioReceiverMBean
NioReplicationTask: A worker thread class which can drain channels and echo-back the input.

NioSender

This class is NOT thread safe and should never be used with more than one thread at a time This is a state machine, handled by the process method States are: - NOT_CONNECTED -> connect() -> CONNECTED - CONNECTED -> setMessage() -> READY TO WRITE - READY_TO_WRITE -> write() -> READY TO WRITE | READY TO READ - READY_TO_READ -> read() -> READY_TO_READ | TRANSFER_COMPLETE - TRANSFER_COMPLETE -> CONNECTED

NonBlockingCoordinator: Title: Auto merging leader election algorithm
NonBlockingCoordinator.CoordinationEvent
NonBlockingCoordinator.CoordinationMessage
NonClosingJarInputStream: When using a `JarInputStream` with an XML parser, the stream will be closed by the parser.
NonLoginAuthenticator: An Authenticator and Valve implementation that checks only security constraints not involving user authentication.
NoOpCallStack: CallStack strategy using no-op implementations of all functionality.
NotificationInfo: Internal configuration information for a `Notification` descriptor.
NullRealm: Minimal Realm implementation that always returns null when an attempt is made to validate a user name and password.
ObjectCreateRule: Rule implementation that creates a new object and pushes it onto the object stack.
ObjectCreationFactory: Interface for use with `FactoryCreateRule`.
ObjectPool<T>: A pooling simple interface.
ObjectReader: The object reader object is an object used in conjunction with java.nio TCP messages.
OneLineFormatter: Provides same information as default log format but on a single line to make it easier to grep the logs.
OpenEjbFactory: Object factory for EJBs.
OpenSSLCipherConfigurationParser: Class in charge with parsing openSSL expressions to define a list of ciphers.
OpenSSLConf
OpenSSLConfCmd
OpenSSLConfSF: Store OpenSSLConf
OpenSSLContext
OpenSSLEngine: Implements a `SSLEngine` using OpenSSL BIO abstractions.
OpenSSLImplementation
OpenSSLSessionContext: OpenSSL specific `SSLSessionContext` implementation.
OpenSSLSessionStats: Stats exposed by an OpenSSL session context.
OpenSSLUtil
OperationInfo: Internal configuration information for an `Operation` descriptor.
Optional
Options: A class to hold all init parameters specific to the JSP engine.
OrderInterceptor: The order interceptor guarantees that messages are received in the same order they were sent.
OrderInterceptor.Counter
OrderInterceptor.MessageOrder
OS: Deprecated. The scope of the APR/Native Library will be reduced in Tomcat 10.1.x / Tomcat Native 2.x onwards to only include those components required to provide OpenSSL integration with the NIO and NIO2 connectors.
Otherwise
Out
OutputBuffer: The buffer used by Tomcat response.
OutputBuffer: Output buffer.
OutputFilter: Output filter.
PageContextImpl: Implementation of the PageContext class from the JSP spec.
ParallelNioSender
ParallelWebappClassLoader
Param
ParameterInfo: Internal configuration information for a `Parameter` descriptor.
ParameterMap<K,​V>: Implementation of java.util.Map that includes a `locked` property.
ParameterParser: A simple parser intended to parse sequences of name/value pairs.
Parameters
Parameters.FailReason
ParseException: This exception is thrown when parse errors are encountered.
PasswdUserDatabase: Concrete implementation of the `UserDatabase` interface that processes the `/etc/passwd` file on a Unix system.
PasswordCallback: Deprecated. Unused.
PEMFile: RFC 1421 PEM file containing X509 certificates or private keys.
PeriodicEventListener
PerMessageDeflate
PermissionCheck: This interface is implemented by components to enable privileged code to check whether the component has a given permission.
PersistentManager: Implementation of the Manager interface that makes use of a Store to swap active Sessions to disk.
PersistentManagerBase: Extends the `ManagerBase` class to implement most of the functionality required by a Manager which supports any kind of persistence, even if only for restarts.
PersistentManagerSF: store server.xml PersistentManager element with nested "Store"
PersistentValve: Valve that implements per-request session persistence.
PerUserPoolDataSource: A pooling `DataSource` appropriate for deployment within J2EE environment.
PerUserPoolDataSourceFactory: A JNDI ObjectFactory which creates `SharedPoolDataSource`s
Pipeline: Interface describing a collection of Valves that should be executed in sequence when the `invoke()` method is invoked.
PojoClassHolder
PojoEndpointBase: Base implementation (client and server have different concrete implementations) of the wrapper that converts a POJO instance into a WebSocket endpoint instance.
PojoEndpointClient: Wrapper class for instances of POJOs annotated with `ClientEndpoint` so they appear as standard `Endpoint` instances.
PojoEndpointServer: Wrapper class for instances of POJOs annotated with `ServerEndpoint` so they appear as standard `Endpoint` instances.
PojoHolder
PojoMessageHandlerBase<T>: Common implementation code for the POJO message handlers.
PojoMessageHandlerPartialBase<T>: Common implementation code for the POJO partial message handlers.
PojoMessageHandlerPartialBinary: ByteBuffer specific concrete implementation for handling partial messages.
PojoMessageHandlerPartialText: Text specific concrete implementation for handling partial messages.
PojoMessageHandlerWholeBase<T>: Common implementation code for the POJO whole message handlers.
PojoMessageHandlerWholeBinary: ByteBuffer specific concrete implementation for handling whole messages.
PojoMessageHandlerWholePong: PongMessage specific concrete implementation for handling whole messages.
PojoMessageHandlerWholeText: Text specific concrete implementation for handling whole messages.
PojoMethodMapping: For a POJO class annotated with `ServerEndpoint`, an instance of this class creates and caches the method handler, method information and parameter information for the onXXX calls.
PojoPathParam: Stores the parameter type and name for a parameter that needs to be passed to an onXxx method of `Endpoint`.
Poll: Deprecated. The scope of the APR/Native Library will be reduced in Tomcat 10.1.x / Tomcat Native 2.x onwards to only include those components required to provide OpenSSL integration with the NIO and NIO2 connectors.
Pool: Provides access to APR memory pools which are used to manage memory allocations for natively created instances.
PoolableCallableStatement: A `DelegatingCallableStatement` that cooperates with `PoolingConnection` to implement a pool of `CallableStatement`s.
PoolableConnection: A delegating connection that, rather than closing the underlying connection, returns itself to an `ObjectPool` when closed.
PoolableConnectionFactory: A `PooledObjectFactory` that creates `PoolableConnection`s.
PoolableConnectionMXBean: Defines the attributes and methods that will be exposed via JMX for `PoolableConnection` instances.
PoolablePreparedStatement<K>: A `DelegatingPreparedStatement` that cooperates with `PoolingConnection` to implement a pool of `PreparedStatement`s.
PoolCallback: Deprecated. The scope of the APR/Native Library will be reduced in Tomcat 10.1.x / Tomcat Native 2.x onwards to only include those components required to provide OpenSSL integration with the NIO and NIO2 connectors.
PoolConfiguration: A list of properties that are configurable for a connection pool.
PooledConnection: Represents a pooled connection and holds a reference to the `Connection` object
PooledConnectionMBean
PooledMultiSender
PooledObject<T>: Defines the wrapper that is used to track the additional information, such as state, for the pooled objects.
PooledObjectFactory<T>: An interface defining life-cycle methods for instances to be served by an `ObjectPool`.
PooledObjectState: Provides the possible states that a `PooledObject` may be in.
PooledParallelSender
PooledParallelSenderMBean
PooledSender
PooledSoftReference<T>: Extension of `DefaultPooledObject` to wrap pooled soft references.
PoolExhaustedException
PoolingConnection: A `DelegatingConnection` that pools `PreparedStatement`s.
PoolingConnection.StatementType: Statement types.
PoolingDataSource<C extends java.sql.Connection>: A simple `DataSource` implementation that obtains `Connection`s from the specified `ObjectPool`.
PoolingDriver: A `Driver` implementation that obtains `Connection`s from a registered `ObjectPool`.
PoolProperties
PoolProperties.InterceptorDefinition
PoolProperties.InterceptorProperty
PoolUtilities
PoolUtils: This class consists exclusively of static methods that operate on or return ObjectPool or KeyedObjectPool related interfaces.
Priority: HTTP priority header parser as per RFC 9218.
PrivilegedGetTccl
PrivilegedSetAccessControlContext
PrivilegedSetTccl
Proc: Deprecated. The scope of the APR/Native Library will be reduced in Tomcat 10.1.x / Tomcat Native 2.x onwards to only include those components required to provide OpenSSL integration with the NIO and NIO2 connectors.
Procattr: Deprecated. The scope of the APR/Native Library will be reduced in Tomcat 10.1.x / Tomcat Native 2.x onwards to only include those components required to provide OpenSSL integration with the NIO and NIO2 connectors.
ProcErrorCallback: Deprecated. The scope of the APR/Native Library will be reduced in Tomcat 10.1.x / Tomcat Native 2.x onwards to only include those components required to provide OpenSSL integration with the NIO and NIO2 connectors.
Processor: Common interface for processors of all protocols.
ProgressListener: The `ProgressListener` may be used to display a progress bar or do stuff like that.
PropertiesRoleMappingListener: Implementation of `LifecycleListener` that will populate the context's role mapping from a properties file.
ProtectedFunctionMapper: Maps EL functions to their Java method counterparts.
Protocol
ProtocolException: Used when we need to indicate failure but the (Servlet) API doesn't declare any appropriate exceptions.
ProtocolHandler: Abstract the protocol implementation, including threading, etc.
Proxy
ProxyConnection: A ProxyConnection object is the bottom most interceptor that wraps an object of type `PooledConnection`.
ProxyErrorReportValve: Implementation of a Valve that proxies or redirects error reporting to other urls.
PStmtKey: A key uniquely identifying `PreparedStatement`s.
PStmtKeyCPDS: Deprecated. Use `PStmtKey`.
QueryTimeoutInterceptor
QuotedStringTokenizer
RandomizedTextRewriteMap: Implement a map for the txt: and rnd: mod_rewrite capabilities.
Ranges
Ranges.Entry
RateLimitFilter: Servlet filter that can help mitigate Denial of Service (DoS) and Brute Force attacks by limiting the number of a requests that are allowed from a single IP address within a time window (also referred to as a time bucket), e.g. 300 Requests per 60 seconds.
ReadBufferOverflowException
Realm: A Realm is a read-only facade for an underlying security realm used to authenticate individual users, and identify the security roles associated with those users.
RealmBase: Simple implementation of Realm that reads an XML file to configure the valid users, passwords, and roles.
RealmBase.AllRolesMode
RealmRuleSet: RuleSet for processing the contents of a Realm definition element.
RealmSF: Store server.xml Element Realm
ReceiverBase
Redirect
ReferenceCountedJar: This class provides a wrapper around `Jar` that uses reference counting to close and re-create the wrapped `Jar` instance as required.
ReflectionUtil: Utilities for Managing Serialization and Reflection
Registry: Deprecated. The scope of the APR/Native Library will be reduced in Tomcat 10.1.x / Tomcat Native 2.x onwards to only include those components required to provide OpenSSL integration with the NIO and NIO2 connectors.
Registry: Registry for modeler MBeans.
RegistryMBean: Interface for modeler MBeans.
ReloadTask: Ant task that implements the `/reload` command, supported by the Tomcat manager application.
RemoteAddrFilter: Concrete implementation of `RequestFilter` that filters based on the string representation of the remote client's IP address.
RemoteAddrValve: Concrete implementation of `RequestFilterValve` that filters based on the string representation of the remote client's IP address optionally combined with the server connector port number.
RemoteCIDRFilter
RemoteCIDRValve
RemoteHostFilter: Concrete implementation of `RequestFilter` that filters based on the remote client's host name.
RemoteHostValve: Concrete implementation of `RequestFilterValve` that filters based on the remote client's host name optionally combined with the server connector port number.
RemoteIpFilter: Servlet filter to integrate "X-Forwarded-For" and "X-Forwarded-Proto" HTTP headers.
RemoteIpFilter.XForwardedRequest
RemoteIpValve: Tomcat port of mod_remoteip, this valve replaces the apparent client remote IP address and hostname for the request with the IP address list presented by a proxy or a load balancer via a request headers (e.g.
RemoteProcessException: Message thrown by a sender when USE_SYNC_ACK receives a FAIL_ACK_COMMAND.
Remove
RepeatableArchive: Ant task to assist with repeatable builds.
ReplicatedContext
ReplicatedContext.MultiEnumeration<T>
ReplicatedContext.ReplApplContext
ReplicatedMap<K,​V>: All-to-all replication for a hash map implementation.
ReplicatedMapEntry: For smarter replication, an object can implement this interface to replicate diffs The replication logic will call the methods in the following order: `1. if ( entry.isDirty() ) try { 2.`
ReplicatedSessionListener: This is a marker interface used to indicate an implementation of `SessionListener` that should be replicated with the session across the cluster.
ReplicationStream: Custom subclass of `ObjectInputStream` that loads from the class loader for this web application.
ReplicationTransmitter: Transmit message to other cluster members Actual senders are created based on the replicationMode type
ReplicationValve: Implementation of a Valve that logs interesting contents from the specified Request (before processing) and the corresponding Response (after processing).
Request: Wrapper object for the Coyote request.
Request: This is a low-level, efficient representation of a server request.
RequestContext: Abstracts access to the request information needed for file uploads.
RequestDumperFilter: Implementation of a Filter that logs interesting contents from the specified Request (before processing) and the corresponding Response (after processing).
RequestFacade: Facade class that wraps a Coyote request object.
RequestFilter: Implementation of a Filter that performs filtering based on comparing the appropriate request property (selected based on which subclass you choose to configure into your Container's pipeline) against the regular expressions configured for this Filter.
RequestFilterValve: Implementation of a Valve that performs filtering based on comparing the appropriate request property (selected based on which subclass you choose to configure into your Container's pipeline) against the regular expressions configured for this Valve.
RequestGroupInfo: Only as a JMX artifact, to aggregate the data collected from each RequestProcessor thread.
RequestInfo: Structure holding the Request and Response objects.
RequestUtil: General purpose request parsing and encoding utility methods.
RequestUtil
ResetAbandonedTimer: Class that resets the abandoned timer on any activity on the Connection or any successful query executions.
ResetAbandonedTimerMBean
ResizableExecutor
Resolver: Resolver abstract class.
ResolverImpl
ResourceBase: Representation of an Context element
ResourceEntry: Resource entry.
ResourceEnvFactory: Object factory for Resources env.
ResourceEnvRef: Represents a reference address to a resource environment.
ResourceFactory: Object factory for Resources.
ResourceLinkFactory: Object factory for resource links.
ResourceLinkRef: Represents a reference address to a resource.
ResourceRef: Represents a reference address to a resource.
ResourceSet<T>: Extended implementation of HashSet that includes a `locked` property.
ResourcesTask: Ant task that implements the `/resources` command, supported by the Tomcat manager application.
Response: Wrapper object for the Coyote response.
Response: A response object holds a message from a responding partner.
Response: Response object.
ResponseFacade: Facade class that wraps a Coyote response object.
ResponseIncludeWrapper: An HttpServletResponseWrapper, used from `SSIServletExternalResolver`
ResponseUtil
RestCsrfPreventionFilter: Provides basic CSRF protection for REST APIs.
RewriteCond
RewriteCond.Condition
RewriteCond.LexicalCondition
RewriteCond.PatternCondition
RewriteCond.ResourceCondition
RewriteMap
RewriteRule
RewriteValve: Note: Extra caution should be used when adding a Rewrite Rule.
RFC2231Utility: Utility class to decode/encode character set on HTTP Header fields based on RFC 2231.
Rfc6265CookieProcessor
Role: Abstract representation of a security role, suitable for use in environments like JAAS that want to deal with `Principals`.
RoleMBean: A ModelMBean implementation for the `org.apache.catalina.Role` component.
RpcCallback: The RpcCallback interface is an interface for the Tribes channel to request a response object to a request that came in.
RpcChannel: A channel to handle RPC messaging
RpcChannel.RpcCollector: Class that holds all response.
RpcChannel.RpcCollectorKey
RpcMessage
RpcMessage.NoRpcChannelReply
Rule: Concrete implementations of this class implement actions to be taken when a corresponding nested pattern of XML elements has been matched.
Rules: Public interface defining a collection of Rule instances (and corresponding matching patterns) plus an implementation of a matching policy that selects the rules that match a particular pattern of nested elements discovered during parsing.
RulesBase: Default implementation of the `Rules` interface that supports the standard rule matching behavior.
RuleSet: Public interface defining a shorthand means of configuring a complete set of related `Rule` definitions, possibly associated with a particular namespace URI, in one operation.
RuleSetBase: Deprecated. Unnecessary once deprecated methods are removed.
RxTaskPool: A very simple thread pool class.
RxTaskPool.TaskCreator
SafeForkJoinWorkerThreadFactory: Provides a `ForkJoinPool.ForkJoinWorkerThreadFactory` that provides `ForkJoinWorkerThread`s that won't trigger memory leaks due to retained references to web application class loaders.
SameSiteCookies
SavedRequest: Object that saves the critical information from a request so that form-based authentication can reproduce it once the user has been authenticated.
SavedRequestInputFilter: Input filter responsible for replaying the request body when restoring the saved request after FORM authentication.
SecretKeyCredentialHandler
SecureNio2Channel: Implementation of a secure socket channel for NIO2.
SecureNioChannel: Implementation of a secure socket channel
SecurityClassLoad: Static class used to preload java classes when using the Java SecurityManager so that the defineClassInPackage RuntimePermission does not trigger an AccessControlException.
SecurityClassLoad: Static class used to preload java classes when using the Java SecurityManager so that the defineClassInPackage RuntimePermission does not trigger an AccessControlException.
SecurityCollection: Representation of a web resource collection for a web application's security constraint, as represented in a `<web-resource-collection>` element in the deployment descriptor.
SecurityConfig: Util class to protect Catalina against package access and insertion.
SecurityConstraint: Representation of a security constraint element for a web application, as represented in a `<security-constraint>` element in the deployment descriptor.
SecurityListener: This listener must only be nested within `Server` elements.
SecurityManagerCallStack: CallStack strategy using a `SecurityManager`.
SecurityRoleRef: Representation of a security role reference for a web application, as represented in a `<security-role-ref>` element in the deployment descriptor.
SecurityUtil: This utility class associates a `Subject` to the current `AccessControlContext`.
SecurityUtil: Util class for Security related operations.
SelectorContext: Catalina JNDI Context implementation.
SemaphoreValve: Implementation of a Valve that limits concurrency.
Sender: Interface to send data to proxies.
SenderSF: Generate Sender Element
SenderState
SendfileDataBase
SendfileKeepAliveState
SendfileState
SendMailFactory: Factory class that creates a JNDI named javamail MimePartDataSource object which can be used for sending email using SMTP.
SendMessageData
Server: A `Server` element represents the entire Catalina servlet container.
ServerCookie: Server-side cookie representation.
ServerCookies: This class is not thread-safe.
ServerInfo: Simple utility module to make it easy to plug in the server identifier when integrating Tomcat.
ServerinfoTask: Ant task that implements the `/serverinfo` command supported by the Tomcat manager application.
Service: A Service is a group of one or more Connectors that share a single Container to process their incoming requests.
ServiceBindingPropertySource: A `IntrospectionUtils.SecurePropertySource` that uses Kubernetes service bindings to resolve expressions.
ServiceMBean
ServiceProxy: Object proxy for Web Services.
ServiceRef: Represents a reference web service.
ServiceRefFactory: Object factory for Web Services.
ServletDef: Representation of a servlet definition for a web application, as represented in a `<servlet>` element in the deployment descriptor.
ServletFileUpload: High level API for processing file uploads.
ServletRequestContext: Provides access to the request information needed for a request made to an HTTP servlet.
ServletResponseWrapperInclude: ServletResponseWrapper used by the JSP 'include' action.
ServletWriter: This is what is used to generate servlets.
Session: A Session is the Catalina-internal facade for an `HttpSession` that is used to maintain state information between requests for a particular user of a web application.
SessionConfig
SessionConfig: Representation of a session configuration element for a web application, as represented in a `<session-config>` element in the deployment descriptor.
SessionEvent: General event for notifying listeners of significant changes on a Session.
SessionIdGenerator
SessionIdGeneratorBase
SessionInitializerFilter: A `Filter` that initializes the `HttpSession` for the `HttpServletRequest` by calling its getSession() method.
SessionListener: Interface defining a listener for significant Session generated events.
SessionMessage: The SessionMessage interface is used when a session has been created, modified, expired in a Tomcat cluster node.
SessionMessageImpl: Session cluster message
SessionsTask: Ant task that implements the `/sessions` command supported by the Tomcat manager application.
SessionUtils: Utility methods on HttpSessions.
Set
SetAllPropertiesRule: Rule that uses the introspection utils to set properties.
SetCharacterEncodingFilter: Example filter that sets the character encoding to be used in parsing the incoming request, either unconditionally or only if the client did not specify a character encoding.
SetContextPropertiesRule: Rule that uses the introspection utils to set properties of a context (everything except "path").
SetNextNamingRule: Rule implementation that calls a method on the (top-1) (parent) object, passing the top object (child) as an argument.
SetNextRule: Rule implementation that calls a method on the (top-1) (parent) object, passing the top object (child) as an argument.
SetPropertiesRule: Rule implementation that sets properties on the object at the top of the stack, based on attributes with corresponding names.
SharedPoolDataSource: A pooling `DataSource` appropriate for deployment within J2EE environment.
SharedPoolDataSourceFactory: A JNDI ObjectFactory which creates `SharedPoolDataSource`s
Shm: Deprecated. The scope of the APR/Native Library will be reduced in Tomcat 10.1.x / Tomcat Native 2.x onwards to only include those components required to provide OpenSSL integration with the NIO and NIO2 connectors.
SimpleAuthConfigProvider: Basic implementation primarily intended for use when using third-party `ServerAuthModule` implementations that only provide the module.
SimpleCoordinator: A dinky coordinator, just uses a sorted version of the member array.
SimpleElementValue
SimpleInstanceManager: SimpleInstanceManager Implement the org.apache.tomcat.InstanceManager interface.
SimpleServerAuthConfig: Basic implementation primarily intended for use when using third-party `ServerAuthModule` implementations that only provide the module.
SimpleServerAuthContext: Basic implementation primarily intended for use when using third-party `ServerAuthModule` implementations that only provide the module.
SimpleTcpCluster: A Cluster implementation using simple multicast.
SingleSignOn: A Valve that supports a "single sign on" user experience, where the security identity of a user who successfully authenticates to one web application is propagated to other web applications in the same security domain.
SingleSignOnEntry: A class that represents entries in the cache of authenticated users.
SingleSignOnListener
SingleSignOnSessionKey: Key used by SSO to identify a session.
SizeException: This exception is thrown, if a requests permitted size is exceeded.
SizeLimitExceededException: Thrown to indicate that the request size exceeds the configured maximum.
SlowQueryReport: Slow query report interceptor.
SlowQueryReport.QueryStats
SlowQueryReport.QueryStatsComparator: Compare QueryStats by their lastInvocation value.
SlowQueryReportJmx: Publishes data to JMX and provides notifications when failures happen.
SlowQueryReportJmxMBean
SmapGenerator: Represents a source map (SMAP), which serves to associate lines of the input JSP file(s) to lines in the generated servlet in the final .class file, according to the JSR-045 spec.
SmapStratum: Represents the line and file mappings associated with a JSR-045 "stratum".
SmapUtil: Contains static utilities for generating SMAP data based on the current version of Jasper.
Sockaddr: Deprecated. The scope of the APR/Native Library will be reduced in Tomcat 10.1.x / Tomcat Native 2.x onwards to only include those components required to provide OpenSSL integration with the NIO and NIO2 connectors.
Socket: Deprecated. The scope of the APR/Native Library will be reduced in Tomcat 10.1.x / Tomcat Native 2.x onwards to only include those components required to provide OpenSSL integration with the NIO and NIO2 connectors.
SocketBufferHandler
SocketEvent: Defines events that occur per socket that require further processing by the container.
SocketProcessorBase<S>
SocketProperties: Properties that can be set in the <Connector> element in server.xml.
SocketWrapperBase<E>
SocketWrapperBase.BlockingMode
SocketWrapperBase.CompletionCheck
SocketWrapperBase.CompletionHandlerCall
SocketWrapperBase.CompletionState
SoftReferenceObjectPool<T>: A `SoftReference` based `ObjectPool`.
SpnegoAuthenticator: A SPNEGO authenticator that uses the SPNEGO/Kerberos support built in to Java 6.
SpnegoAuthenticator.AcceptAction: This class gets a gss credential via a privileged action.
SpnegoAuthenticator.AuthenticateAction
SpnegoAuthenticator.SpnegoTokenFixer: This class implements a hack around an incompatibility between the SPNEGO implementation in Windows and the SPNEGO implementation in Java 8 update 40 onwards.
SQLExceptionList: An SQLException based on a list of Throwable causes.
SSICommand: The interface that all SSI commands ( SSIEcho, SSIInclude, ...) must implement.
SSIConditional: SSI command that handles all conditional directives.
SSIConfig: Implements the Server-side #exec command
SSIEcho: Return the result associated with the supplied Server Variable.
SSIExec: Implements the Server-side #exec command
SSIExternalResolver: Interface used by SSIMediator to talk to the 'outside world' ( usually a servlet )
SSIFilter: Filter to process SSI requests within a webpage.
SSIFlastmod: Implements the Server-side #flastmod command
SSIFsize: Implements the Server-side #fsize command
SSIInclude: Implements the Server-side #include command
SSIMediator: Allows the different SSICommand implementations to share data/talk to each other
SSIPrintenv: Implements the Server-side #printenv command
SSIProcessor: The entry point to SSI processing.
SSIServlet: Servlet to process SSI requests within a webpage.
SSIServletExternalResolver: An implementation of SSIExternalResolver that is used with servlets.
SSIServletExternalResolver.ServletContextAndPath
SSIServletRequestUtil
SSISet: Implements the Server-side #set command
SSIStopProcessingException: Exception used to tell SSIProcessor that it should stop processing SSI commands.
SSL
SSLAuthenticator: An Authenticator and Valve implementation of authentication that utilizes SSL certificates to identify client users.
SSLConf
SslConnectorCiphersTask: Ant task that implements the `/sslConnectorCiphers` command supported by the Tomcat manager application.
SSLContext
SSLContext: This interface is needed to override the default SSLContext class to allow SSL implementation pluggability without having to use JCE.
SSLContext.SNICallBack: Interface implemented by components that will receive the call back to select an OpenSSL SSLContext based on the host name requested by the client.
SSLHostConfig: Represents the TLS configuration for a virtual host.
SSLHostConfig.CertificateVerification
SSLHostConfig.Type
SSLHostConfigCertificate
SSLHostConfigCertificate.Type
SSLHostConfigSF: Store SSLHostConfig
SSLImplementation: Provides a factory and base implementation for the Tomcat specific mechanism that allows alternative SSL/TLS implementations to be used without requiring the implementation of a full JSSE provider.
SSLSessionManager: Defines an interface used to manage SSL sessions.
SSLSocket: Deprecated. The scope of the APR/Native Library will be reduced in Tomcat 10.1.x / Tomcat Native 2.x onwards to only include those components required to provide OpenSSL integration with the NIO and NIO2 connectors.
SSLSupport: Defines an interface to interact with SSL sessions.
SSLUtil: Provides a common interface for `SSLImplementation`s to create the necessary JSSE implementation objects for TLS connections created via the JSSE API.
SSLUtil.ProtocolInfo: Optional interface that can be implemented by `SSLEngine`s to indicate that they support ALPN and can provided the protocol agreed with the client.
SSLUtilBase: Common base class for `SSLUtil` implementations.
SSLValve: When using mod_proxy_http, the client SSL information is not included in the protocol (unlike mod_jk and mod_proxy_ajp).
StandardContext: Standard implementation of the Context interface.
StandardContextSF: Store server.xml Context element with all children Store all context at server.xml Store existing app.xml context a conf/enginename/hostname/app.xml Store with backup
StandardEngine: Standard implementation of the Engine interface.
StandardEngine.AccessLogListener
StandardEngine.NoopAccessLog
StandardEngineSF: Store server.xml Element Engine
StandardHost: Standard implementation of the Host interface.
StandardHostSF: Store server.xml Element Host
StandardJarScanFilter
StandardJarScanner: The default `JarScanner` implementation scans the WEB-INF/lib directory followed by the provided classloader and then works up the classloader hierarchy.
StandardManager: Standard implementation of the Manager interface that provides simple session persistence across restarts of this component (such as when the entire server is shut down and restarted, or when a particular web application is reloaded.
StandardPipeline: Standard implementation of a processing Pipeline that will invoke a series of Valves that have been configured to be called in order.
StandardRoot: Provides the resources implementation for a web application.
StandardServer: Standard implementation of the Server interface, available for use (but not required) when deploying and starting Catalina.
StandardServerSF: Store server.xml Server element and children ( Listener,GlobalNamingResource,Service)
StandardService: Standard implementation of the `Service` interface.
StandardServiceSF: Store server.xml Element Service and all children
StandardSession: Standard implementation of the Session interface.
StandardSessionFacade: Facade for the StandardSession object.
StandardSessionIdGenerator
StandardThreadExecutor
StandardVirtualThreadExecutor: An executor that uses a new virtual thread for each task.
StandardWrapper: Standard implementation of the Wrapper interface that represents an individual servlet definition.
StandardWrapperFacade: Facade for the StandardWrapper object.
StartTask: Ant task that implements the `/start` command, supported by the Tomcat manager application.
StatementCache: Interceptor that caches `PreparedStatement` and/or `CallableStatement` instances on a connection.
StatementCacheMBean
StatementDecoratorInterceptor: Implementation of JdbcInterceptor that proxies resultSets and statements.
StatementFacade
StatementFinalizer: Keeps track of statements associated with a connection and invokes close upon `Connection.close()` Useful for applications that don't close the associated statements after being done with a connection.
StaticMember
StaticMembershipInterceptor
StaticMembershipInterceptorMBean
Status: Deprecated. The scope of the APR/Native Library will be reduced in Tomcat 10.1.x / Tomcat Native 2.x onwards to only include those components required to provide OpenSSL integration with the NIO and NIO2 connectors.
StatusManagerServlet: This servlet will display a complete status of the HTTP/1.1 connector.
StatusTransformer: This is a refactoring of the servlet to externalize the output into a simple class.
Stdlib: Deprecated. The scope of the APR/Native Library will be reduced in Tomcat 10.1.x / Tomcat Native 2.x onwards to only include those components required to provide OpenSSL integration with the NIO and NIO2 connectors.
StopPooledThreadException: A custom `RuntimeException` thrown by the `ThreadPoolExecutor` to signal that the thread should be disposed of.
StopTask: Ant task that implements the `/stop` command, supported by the Tomcat manager application.
Store: A Store is the abstraction of a Catalina component that provides persistent storage and loading of Sessions and their associated user data.
StoreAppender: StoreAppends generate really the xml tag elements
StoreBase: Abstract implementation of the `Store` interface to support most of the functionality required by a `Store`.
StoreConfig: Store Server/Service/Host/Context at file or PrintWriter.
StoreConfigLifecycleListener: Loads and registers a StoreConfig MBean with the name Catalina:type=StoreConfig.
StoreContextAppender: store StandardContext Attributes ...
StoreDescription: Bean of a StoreDescription
StoreFactoryBase: StoreFactory saves special elements.
StoreFactoryRule: Rule that creates a new `IStoreFactory` instance, and associates it with the top object on the stack (which must implement `IStoreFactory`).
StoreFileMover: Move server.xml or context.xml as backup TODO Get Encoding from Registry
StoreLoader: XML Format
StoreManager: PersistentManager would have been a better name but that would have clashed with the implementation name.
StoreRegistry: Central StoreRegistry for all server.xml elements
Stream
StreamELResolverImpl
Streams: Utility class for working with streams.
Strftime: Converts dates to strings using the same format specifiers as strftime Note: This does not mimic strftime perfectly.
StringCache: This class implements a String cache for ByteChunk and CharChunk.
StringInterpreter: Defines the interface for the String interpreter.
StringInterpreterEnum: Provides an optimised conversion of string values to Enums.
StringInterpreterFactory: Provides `StringInterpreter` instances for JSP compilation.
StringInterpreterFactory.DefaultStringInterpreter
StringManager: An internationalization / localization helper class which reduces the bother of handling ResourceBundles and takes care of the common cases of message formatting which otherwise require the creation of Object arrays and such.
StringManager: An internationalization / localization helper class which reduces the bother of handling ResourceBundles and takes care of the common cases of message formatting which otherwise require the creation of Object arrays and such.
StringManager: An internationalization / localization helper class which reduces the bother of handling ResourceBundles and takes care of the common cases of message formatting which otherwise require the creation of Object arrays and such.
StringUtils: Utility methods to build a separated list from a given set (not java.util.Set) of inputs and return that list as a string or append it to an existing StringBuilder.
StringUtils: Converts String to and from bytes using the encodings required by the Java specification.
StringUtils.Function<T>
StructuredField: Parsing of structured fields as per RFC 8941.
StuckThreadDetectionValve: This valve allows to detect requests that take a long time to process, which might indicate that the thread that is processing it is stuck.
Substitution
Substitution.RewriteCondBackReferenceElement
Substitution.ServerVariableElement
Substitution.ServerVariableEnvElement
Substitution.ServerVariableHttpElement
Substitution.ServerVariableSslElement
Substitution.StaticElement
Substitution.SubstitutionElement
SwallowedExceptionListener: Pools that unavoidably swallow exceptions may be configured with an instance of this listener so the user may receive notification of when this happens.
SwallowedExceptionLogger: Class for logging swallowed exceptions.
SymbolTable: Deprecated. Will be removed in Tomcat 9.0.x onwards
SynchronizedQueue<T>: This is intended as a (mostly) GC-free alternative to `ConcurrentLinkedQueue` when the requirement is to create an unbounded queue with no requirement to shrink the queue.
SynchronizedStack<T>: This is intended as a (mostly) GC-free alternative to `Stack` when the requirement is to create a pool of re-usable objects with no requirement to shrink the pool.
SystemLogHandler: This helper class may be used to do sophisticated redirection of System.out and System.err on a per Thread basis.
SystemPropertyReplacerListener: Deprecated. No longer used.
SystemPropertySource: A `IntrospectionUtils.SecurePropertySource` that uses system properties to resolve expressions.
TagConstants
TagFileXml: Bare-bone model of a tag file loaded from a TLD.
TagHandlerPool: Pool of tag handlers that can be reused.
TaglibDescriptorImpl
TaglibXml: Common representation of a Tag Library Descriptor (TLD) XML file.
TagPlugin: This interface is to be implemented by the plugin author, to supply an alternate implementation of the tag handlers.
TagPluginContext: This interface allows the plugin author to make inquiries about the properties of the current tag, and to use Jasper resources to generate direct Java codes in place of tag handler invocations.
TagPluginManager: Manages tag plugin optimizations.
TagPluginParser: Parser for Tag Plugin descriptors.
TagXml: Model of a tag define in a tag library descriptor.
TaskQueue: As task queue specifically designed to run with a thread pool executor.
TaskThread: A Thread implementation that records the time at which it was created.
TaskThreadFactory: Simple task thread factory to use to create threads for an executor implementation.
TcclThreadFactory: ThreadFactory implementation that creates threads with the thread context class loader set to the class loader that loaded this factory.
TcpFailureDetector: The TcpFailureDetector is a useful interceptor that adds reliability to the membership layer.
TcpFailureDetectorMBean
TcpPingInterceptor: Sends a ping to all members.
TcpPingInterceptorMBean
TcpSender
TextOptimizer
Thread: Deprecated. The scope of the APR/Native Library will be reduced in Tomcat 10.1.x / Tomcat Native 2.x onwards to only include those components required to provide OpenSSL integration with the NIO and NIO2 connectors.
ThreadBindingListener: Callback for establishing naming association when entering the application scope.
ThreaddumpTask: Ant task that implements the `/threaddump` command supported by the Tomcat manager application.
ThreadLocalLeakPreventionListener: A `LifecycleListener` that triggers the renewal of threads in Executor pools when a `Context` is being stopped to avoid thread-local related memory leaks.
ThreadPoolExecutor: An `ExecutorService` that executes each submitted task using one of possibly several pooled threads, normally configured using `Executors` factory methods.
ThreadPoolExecutor.AbortPolicy: A handler for rejected tasks that throws a `RejectedExecutionException`.
ThreadPoolExecutor.CallerRunsPolicy: A handler for rejected tasks that runs the rejected task directly in the calling thread of the `execute` method, unless the executor has been shut down, in which case the task is discarded.
ThreadPoolExecutor.DiscardOldestPolicy: A handler for rejected tasks that discards the oldest unhandled request and then retries `execute`, unless the executor is shut down, in which case the task is discarded.
ThreadPoolExecutor.DiscardPolicy: A handler for rejected tasks that silently discards the rejected task.
ThreadPoolExecutor.RejectedExecutionHandler
ThresholdingOutputStream: An output stream which triggers an event when a specified number of bytes of data have been written to it.
ThroughputInterceptor
ThroughputInterceptorMBean
ThrowableCallStack: CallStack strategy that uses the stack trace from a `Throwable`.
Time: Deprecated. The scope of the APR/Native Library will be reduced in Tomcat 10.1.x / Tomcat Native 2.x onwards to only include those components required to provide OpenSSL integration with the NIO and NIO2 connectors.
TimeBucketCounter: this class maintains a thread safe hash map that has timestamp-based buckets followed by a string for a key, and a counter for a value. each time the increment() method is called it adds the key if it does not exist, increments its value and returns it. a maintenance thread cleans up keys that are prefixed by previous timestamp buckets.
TldCache: This class caches parsed instances of TLD files to remove the need for the same TLD to be parsed for each JSP that references it.
TldParser: Parses a Tag Library Descriptor.
TldPreScanned
TldResourcePath: A TLD Resource Path as defined in JSP 7.3.2.
TldRuleSet: RulesSet for digesting TLD files.
TldRuleSet.Attribute
TldRuleSet.Variable
TldScanner: Scans for and loads Tag Library Descriptors contained in a web application.
TLS: Deprecated. Unused.
TLSCertificateReloadListener: A `LifecycleListener` that may be used to monitor the expiration dates of TLS certificates and trigger automatic reloading of the TLS configuration a set number of days before the TLS certificate expires.
TLSClientHelloExtractor: This class extracts the SNI host name and ALPN protocols from a TLS client-hello message.
TLSClientHelloExtractor.ExtractorResult
TLSUtil
Token: Describes the input token stream.
TokenList
TokenMgrError: Token Manager Error.
Tomcat: Minimal tomcat starter for embedding/unit tests.
Tomcat.DefaultWebXmlListener: Fix reload - required if reloading and using programmatic configuration.
Tomcat.ExistingStandardWrapper: Helper class for wrapping existing servlets.
Tomcat.FixContextListener: Fix startup sequence - required if you don't use web.xml.
TomcatCSS
TomcatJarInputStream: The purpose of this sub-class is to obtain references to the JarEntry objects for META-INF/ and META-INF/MANIFEST.MF that are otherwise swallowed by the JarInputStream implementation.
TomcatPrincipal: Defines additional methods implemented by `Principal`s created by Tomcat's standard `Realm` implementations.
TomcatURLStreamHandlerFactory
Tool: General purpose wrapper for command line tools that should execute in an environment with the common class loader environment set up by Catalina.
TooManyActiveSessionsException: An exception that indicates the maximum number of active sessions has been reached and the server is refusing to create any new sessions.
ToStringUtil: Utility class used to help generate return values for calls to `Object.toString()`.
TrackedUse: This interface allows pooled objects to make information available about when and how they were used available to the object pool.
TrackedWebResource
TransactionFactory: Object factory for User transactions.
TransactionRef: Represents a reference address to a transaction.
Transformation: The internal representation of the transformation that a WebSocket extension performs on a message.
TransformationFactory
TransformationResult
TrapException: Interceptor that traps any unhandled exception types and throws an exception that has been declared by the method called, or throw an SQLException if it is declared.
TwoPhaseCommitInterceptor
TwoPhaseCommitInterceptor.MapEntry
Txt2Html: Ant task to convert a given set of files from Text to HTML.
UCSReader: Deprecated. Will be removed in Tomcat 9.0.x onwards
UDecoder: All URL decoding happens here.
UEncoder: Efficient implementation of an UTF-8 encoder.
UEncoder.SafeCharsSet
UndeployMessage
UndeployTask: Ant task that implements the `/undeploy` command, supported by the Tomcat manager application.
UniqueAttributesImpl: Wraps the default attributes implementation and ensures that each attribute has a unique qname as required by the JSP specification.
UniqueId: Represents a globally unique Id.
Upgrade
UpgradeApplicationBufferHandler: Trivial implementation of `ApplicationBufferHandler` to support saving of HTTP request bodies during an HTTP/1.1 upgrade.
UpgradeGroupInfo: This aggregates the data collected from each UpgradeInfo instance.
UpgradeInfo: Structure to hold statistical information about connections that have been established using the HTTP/1.1 upgrade mechanism.
UpgradeProcessorBase
UpgradeProcessorExternal
UpgradeProcessorInternal
UpgradeProtocol
UpgradeServletInputStream
UpgradeServletOutputStream
UpgradeToken: Token used during the upgrade process.
UpgradeUtil
UploadContext: Enhanced access to the request information needed for file uploads, which fixes the Content Length data access in `RequestContext`.
UriTemplate: Extracts path parameters from URIs used to create web socket connections using the URI template defined for the associated Endpoint.
UriUtil: Utility class for working with URIs and URLs.
Url
URLEncoder: This class is very similar to the java.net.URLEncoder class.
UrlJar: Implementation of `Jar` that is optimised for non-file based JAR URLs.
UsageTracking<T>: This interface may be implemented by an object pool to enable clients (primarily those clients that wrap pools to provide pools with extended features) to provide additional information to the pool relating to object using allowing more informed decisions and reporting to be made regarding abandoned objects.
User: Abstract representation of a user in a `UserDatabase`.
User: Deprecated. The scope of the APR/Native Library will be reduced in Tomcat 10.1.x / Tomcat Native 2.x onwards to only include those components required to provide OpenSSL integration with the NIO and NIO2 connectors.
UserConfig: Startup event listener for a Host that configures Contexts (web applications) for all defined "users" who have a web application in a directory with the specified name in their home directories.
UserDatabase: Abstraction of the set of users defined by the operating system on the current server platform.
UserDatabase: Abstract representation of a database of `User`s and `Group`s that can be maintained by an application, along with definitions of corresponding `Role`s, and referenced by a `Realm` for authentication and access control.
UserDatabaseRealm: Implementation of `Realm` that is based on an implementation of `UserDatabase` made available through the JNDI resources configured for this instance of Catalina.
UserDatabaseRealm.UserDatabasePrincipal
UserDataHelper: This helper class assists with the logging associated with invalid input data.
UserDataHelper.Mode: Log mode for the next log message.
UserMBean: A ModelMBean implementation for the `org.apache.catalina.User` component.
Utf8Decoder: Decodes bytes to UTF-8.
Utf8Encoder: Encodes characters as bytes using UTF-8.
UTF8Reader: Deprecated. Will be removed in Tomcat 9.0.x onwards
Util: Util contains some often used consts, static methods and embedded class to support the JSTL tag plugin.
Util
Util: Utility class for internal use only within the `org.apache.tomcat.websocket` package.
Util.DecoderMatch
Util.ImportResponseWrapper: Wraps responses to allow us to retrieve results as Strings.
Utils
Utils
Utils: Utility methods.
UUIDGenerator: Smple generation of a UUID.
Validation
Validator: Interface to be implemented by custom validator classes.
ValidatorTask: Task for validating a web application deployment descriptor, using XML schema validation.
ValidatorXml: Model of a Tag Library Validator from the XML descriptor.
ValueExpressionImpl: An `Expression` that can get or set a value.
ValueExpressionLiteral
Valve: A Valve is a request processing component associated with a particular Container.
ValveBase: Convenience base class for implementations of the Valve interface.
VariableMapperFactory
VariableMapperImpl
VariableResolverImpl: Deprecated.
Vary: Deprecated. Use `TokenList`.
VerbatimFormatter: Outputs the just the log message with no additional elements.
VersionLoggerListener: Logs version information on startup.
VirtualResource
VirtualThreadExecutor: An executor that uses a new virtual thread for each task.
VminfoTask: Ant task that implements the `/vminfo` command supported by the Tomcat manager application.
VoidInputFilter: Void input filter, which returns -1 when attempting a read.
VoidOutputFilter: Void output filter, which silently swallows bytes written.
WarResource: Represents a single resource (file or directory) that is located within a WAR.
WarResourceSet: Represents a `WebResourceSet` based on a WAR file.
WarURLConnection
WarWatcher: The WarWatcher watches the deployDir for changes made to the directory (adding new WAR files->deploy or remove WAR files->undeploy) and notifies a listener of the changes made.
WarWatcher.WarFilter: File name filter for war files
WarWatcher.WarInfo: File information on existing WAR files
WatchedResourceSF
WebAnnotationSet: AnnotationSet for processing the annotations of the web application classes (`/WEB-INF/classes` and `/WEB-INF/lib`).
WebappClassLoader
WebappClassLoaderBase: Specialized web application class loader.
WebappClassLoaderBase.PrivilegedGetClassLoader
WebappLoader: Classloader implementation which is specialized for handling web applications in the most efficient way, while being Catalina aware (all accesses to resources are made through `WebResourceRoot`).
WebappProperties: An interface intended for use by class loaders associated with a web application that enables them to provide additional information to JULI about the web application with which they are associated.
WebappServiceLoader<T>: A variation of Java's JAR ServiceLoader that respects exclusion rules for web applications.
WebdavFixFilter: Filter that attempts to force MS WebDAV clients connecting on port 80 to use a WebDAV client that actually works.
WebdavServlet: Servlet which adds support for WebDAV level 2.
WebResource: Represents a file or directory within a web application.
WebResourceRoot: Represents the complete set of resources for a web application.
WebResourceRoot.ResourceSetType
WebResourceRootSF: Generate Resources element
WebResourceSet: Represents a set of resources that are part of a web application.
WebRuleSet: RuleSet for processing the contents of a web application deployment descriptor (`/WEB-INF/web.xml`) resource.
WebXml: Representation of common elements of web.xml and web-fragment.xml.
WebXmlParser
When
WrappedMessageHandler
Wrapper: A Wrapper is a Container that represents an individual servlet definition from the deployment descriptor of the web application.
WrapperLifecycleSF
WrapperListenerSF
WrapperMappingInfo: Encapsulates information used to register a Wrapper mapping.
WriteBuffer: Provides an expandable set of buffers for writes.
WriteBuffer.Sink: Interface implemented by clients of the WriteBuffer to enable data to be written back out from the buffer.
WsContainerProvider
WsContextListener: In normal usage, this `ServletContextListener` does not need to be explicitly configured as the `WsSci` performs all the necessary bootstrap and installs this listener in the `ServletContext`.
WsExtension
WsExtensionParameter
WsFilter: Handles the initial HTTP connection for WebSocket connections.
WsFrameBase: Takes the ServletInputStream, processes the WebSocket frames it contains and extracts the messages.

WsFrameBase.ReadState

WAITING - not suspended Server case: waiting for a notification that data is ready to be read from the socket, the socket is registered to the poller Client case: data has been read from the socket and is waiting for data to be processed PROCESSING - not suspended Server case: reading from the socket and processing the data Client case: processing the data if such has already been read and more data will be read from the socket SUSPENDING_WAIT - suspended, a call to suspend() was made while in WAITING state.

WsFrameClient
WsFrameServer
WsHandshakeRequest: Represents the request that this session was opened under.
WsHandshakeResponse: Represents the response to a WebSocket handshake.
WsHttpUpgradeHandler: Servlet 3.1 HTTP upgrade handler for WebSocket connections.
WsIOException: Allows the WebSocket implementation to throw an `IOException` that includes a `CloseReason` specific to the error that can be passed back to the client.
WsPongMessage
WsRemoteEndpointAsync
WsRemoteEndpointBase
WsRemoteEndpointBasic
WsRemoteEndpointImplBase
WsRemoteEndpointImplClient
WsRemoteEndpointImplServer: This is the server side `RemoteEndpoint` implementation - i.e. what the server uses to send data to the client.
WsSci: Registers an interest in any class that is annotated with `ServerEndpoint` so that Endpoint can be published via the WebSocket server.
WsServerContainer: Provides a per class loader (i.e. per web application) instance of a ServerContainer.
WsSession
WsSessionListener
WsWebSocketContainer
WsWriteTimeout: Provides timeouts for asynchronous web socket writes.
X509SubjectDnRetriever: An X509UsernameRetriever that returns a certificate's entire SubjectDN as the username.
X509UsernameRetriever: Provides an interface for retrieving a user name from an X509Certificate.
XADataSource
XByteBuffer: The XByteBuffer provides a dual functionality.
XMLChar: Deprecated. Will be removed in Tomcat 9.0.x onwards
XmlEncodingBase: Base class for those elements that need to track the encoding used in the source XML.
XMLEncodingDetector: Deprecated. Will be removed in Tomcat 9.0.x onwards
XmlErrorHandler
XmlIdentifiers: Defines constants for well-known Public and System identifiers documented by the Servlet and JSP specifications.
XMLString: Deprecated. Will be removed in Tomcat 9.0.x onwards
XMLStringBuffer: Deprecated. Will be removed in Tomcat 9.0.x onwards
XMLWriter: XMLWriter helper class.