tessl/maven-org-springframework-boot--spring-boot-starter-tomcat

Starter for using Tomcat as the embedded servlet container, providing default servlet container functionality for Spring Boot web applications

—

Pending

Overview

Eval results

Files

Web Server Factories

Name: tessl/maven-org-springframework-boot--spring-boot-starter-tomcat
Author: tessl

Core factory classes for creating and configuring Tomcat-based web servers. These factories provide both servlet and reactive web server support with extensive customization options and integrate seamlessly with Spring Boot's auto-configuration system.

Capabilities

TomcatServletWebServerFactory

Main factory class for creating Tomcat-based servlet web servers. Extends AbstractServletWebServerFactory and implements ConfigurableTomcatWebServerFactory.

/**
 * Factory for creating Tomcat-based servlet web servers
 */
public class TomcatServletWebServerFactory extends AbstractServletWebServerFactory 
    implements ConfigurableTomcatWebServerFactory {
    
    /** Default constructor using auto-detected port */
    public TomcatServletWebServerFactory();
    
    /** Constructor with specific port */
    public TomcatServletWebServerFactory(int port);
    
    /** Constructor with context path and port */
    public TomcatServletWebServerFactory(String contextPath, int port);
    
    /** Creates and configures the web server with servlet context initializers */
    public WebServer getWebServer(ServletContextInitializer... initializers);
    
    /** Sets the Tomcat base directory for temporary files */
    public void setBaseDirectory(File baseDirectory);
    
    /** Sets the Tomcat connector protocol (default: Http11NioProtocol) */
    public void setProtocol(String protocol);
    
    /** Sets URI encoding charset (default: UTF-8) */
    public void setUriEncoding(Charset uriEncoding);
    
    /** Controls whether to disable Tomcat's MBean registry */
    public void setDisableMBeanRegistry(boolean disableMBeanRegistry);
    
    /** Gets the current TLD skip patterns */
    public Set<String> getTldSkipPatterns();
    
    /** Sets TLD skip patterns for faster startup */
    public void setTldSkipPatterns(Collection<String> patterns);
    
    /** Adds additional TLD skip patterns */
    public void addTldSkipPatterns(String... patterns);
    
    /** Adds Tomcat Engine-level valves for request processing */
    public void addEngineValves(Valve... engineValves);
    
    /** Adds Tomcat Context-level valves for request processing */
    public void addContextValves(Valve... contextValves);
    
    /** Adds context lifecycle listeners for webapp lifecycle events */
    public void addContextLifecycleListeners(LifecycleListener... listeners);
    
    /** Adds connector customizers for fine-grained connector configuration */
    public void addConnectorCustomizers(TomcatConnectorCustomizer... customizers);
    
    /** Adds context customizers for webapp context configuration */
    public void addContextCustomizers(TomcatContextCustomizer... customizers);
    
    /** Adds protocol handler customizers for low-level protocol configuration */
    public void addProtocolHandlerCustomizers(TomcatProtocolHandlerCustomizer<?>... customizers);
    
    /** Adds additional Tomcat connectors to the server */
    public void addAdditionalTomcatConnectors(Connector... connectors);
}

Usage Examples:

import org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.io.File;
import java.nio.charset.StandardCharsets;

@Configuration
public class TomcatConfig {
    
    @Bean
    public TomcatServletWebServerFactory tomcatFactory() {
        TomcatServletWebServerFactory factory = new TomcatServletWebServerFactory(8080);
        factory.setBaseDirectory(new File("/tmp/tomcat"));
        factory.setUriEncoding(StandardCharsets.UTF_8);
        factory.addTldSkipPatterns("custom-*.jar", "legacy-*.jar");
        return factory;
    }
}

TomcatReactiveWebServerFactory

Factory for creating Tomcat-based reactive web servers. Extends AbstractReactiveWebServerFactory and implements ConfigurableTomcatWebServerFactory.

/**
 * Factory for creating Tomcat-based reactive web servers
 */
public class TomcatReactiveWebServerFactory extends AbstractReactiveWebServerFactory 
    implements ConfigurableTomcatWebServerFactory {
    
    /** Default constructor using auto-detected port */
    public TomcatReactiveWebServerFactory();
    
    /** Constructor with specific port */
    public TomcatReactiveWebServerFactory(int port);
    
    /** Creates reactive web server with HTTP handler */
    public WebServer getWebServer(HttpHandler httpHandler);
    
    /** Sets the Tomcat base directory for temporary files */
    public void setBaseDirectory(File baseDirectory);
    
    /** Sets background processor delay for maintenance tasks */
    public void setBackgroundProcessorDelay(int delay);
    
    /** Sets URI encoding charset */
    public void setUriEncoding(Charset uriEncoding);
    
    /** Adds Tomcat Engine-level valves for request processing */
    public void addEngineValves(Valve... engineValves);
    
    /** Adds connector customizers for fine-grained connector configuration */
    public void addConnectorCustomizers(TomcatConnectorCustomizer... customizers);
    
    /** Adds context customizers for webapp context configuration */
    public void addContextCustomizers(TomcatContextCustomizer... customizers);
    
    /** Adds protocol handler customizers for low-level protocol configuration */
    public void addProtocolHandlerCustomizers(TomcatProtocolHandlerCustomizer<?>... customizers);
}

TomcatWebServer

WebServer implementation that controls a Tomcat web server instance. Usually created via factory classes but can be used directly for advanced scenarios.

/**
 * WebServer implementation that manages a Tomcat server instance
 */
public class TomcatWebServer implements WebServer {
    
    /** Constructor with Tomcat instance */
    public TomcatWebServer(Tomcat tomcat);
    
    /** Constructor with auto-start control */
    public TomcatWebServer(Tomcat tomcat, boolean autoStart);
    
    /** Full constructor with shutdown configuration */
    public TomcatWebServer(Tomcat tomcat, boolean autoStart, Shutdown shutdown);
    
    /** Starts the web server */
    public void start() throws WebServerException;
    
    /** Stops the web server */
    public void stop() throws WebServerException;
    
    /** Gets the port the server is running on */
    public int getPort();
    
    /** Initiates graceful shutdown with callback */
    public void shutDownGracefully(GracefulShutdownCallback callback);
}

ConfigurableTomcatWebServerFactory

Common interface for Tomcat-specific web server factory configuration, implemented by both servlet and reactive factories.

/**
 * Common configuration interface for Tomcat web server factories
 */
public interface ConfigurableTomcatWebServerFactory {
    
    /** Sets Tomcat base directory for temporary files and work directories */
    void setBaseDirectory(File baseDirectory);
    
    /** Sets background processor delay in seconds for maintenance tasks */
    void setBackgroundProcessorDelay(int delay);
    
    /** Adds Tomcat Engine-level valves for request processing */
    void addEngineValves(Valve... engineValves);
    
    /** Adds connector customizers for fine-grained connector configuration */
    void addConnectorCustomizers(TomcatConnectorCustomizer... customizers);
    
    /** Adds context customizers for webapp context configuration */
    void addContextCustomizers(TomcatContextCustomizer... customizers);
    
    /** Adds protocol handler customizers for low-level protocol configuration */
    void addProtocolHandlerCustomizers(TomcatProtocolHandlerCustomizer<?>... customizers);
    
    /** Sets URI encoding for request/response processing */
    void setUriEncoding(Charset uriEncoding);
}

Advanced Usage Example:

@Configuration
public class AdvancedTomcatConfig {
    
    @Bean
    public ConfigurableTomcatWebServerFactory configurableTomcat() {
        TomcatServletWebServerFactory factory = new TomcatServletWebServerFactory();
        
        // Configure base settings
        factory.setBaseDirectory(new File("/opt/tomcat-temp"));
        factory.setBackgroundProcessorDelay(5);
        factory.setUriEncoding(StandardCharsets.UTF_8);
        
        // Add custom valves
        factory.addEngineValves(new AccessLogValve());
        
        // Add customizers
        factory.addConnectorCustomizers(connector -> {
            connector.setPort(8443);
            connector.setSecure(true);
            connector.setScheme("https");
        });
        
        factory.addContextCustomizers(context -> {
            context.setSessionTimeout(30);
            context.setCookies(false);
        });
        
        return factory;
    }
}

Factory Integration

Web server factories are automatically configured by Spring Boot's auto-configuration system:

Auto-Detection: Factories are conditionally created based on classpath presence of Tomcat classes
Property Binding: Configuration properties are automatically applied via customizers
Customizer Discovery: All TomcatConnectorCustomizer, TomcatContextCustomizer, and TomcatProtocolHandlerCustomizer beans are automatically applied
Startup Integration: Factories are invoked during Spring Boot application startup to create the embedded server

Error Handling

Factories may throw these exceptions during server creation:

WebServerException - General web server configuration or startup issues
PortInUseException - When the configured port is already in use
IllegalStateException - Invalid factory configuration or state

/**
 * Exception thrown when a web server cannot be started or configured
 */
public class WebServerException extends RuntimeException {
    public WebServerException(String message);
    public WebServerException(String message, Throwable cause);
}

/**
 * Exception thrown when the configured port is already in use
 */
public class PortInUseException extends WebServerException {
    public PortInUseException(int port);
    public PortInUseException(int port, Throwable cause);
}

Install with Tessl CLI

npx tessl i tessl/maven-org-springframework-boot--spring-boot-starter-tomcat

docs

auto-configuration.md

configuration-properties.md

index.md

server-customization.md

web-server-factories.md

tile.json

tessl/maven-org-springframework-boot--spring-boot-starter-tomcat