CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/maven-org-apache-tomcat-embed--tomcat-embed-core

Embedded Apache Tomcat servlet container with Jakarta Servlet API, HTTP connectors, and lifecycle management for Java web applications

Overview
Eval results
Files

embedded-tomcat.mddocs/

Embedded Tomcat API

Simplified API for programmatically creating, configuring, and managing embedded Tomcat server instances. Ideal for standalone applications, microservices, testing environments, and development tools that need a lightweight servlet container without external dependencies.

Capabilities

Tomcat Class

Primary class for creating and managing embedded Tomcat instances.

public class Tomcat {
    // Constructor
    public Tomcat();
    
    // Server configuration
    public void setPort(int port);
    public void setBaseDir(String basedir);
    public void setHostname(String s);
    
    // Web application management
    public Context addWebapp(String contextPath, String docBase);
    public Context addWebapp(String contextPath, URL source) throws IOException;
    public Context addWebapp(Host host, String contextPath, String docBase);
    public Context addWebapp(Host host, String contextPath, String docBase, LifecycleListener config);
    public Context addContext(String contextPath, String docBase);
    public Context addContext(Host host, String contextPath, String docBase);
    public Context addContext(Host host, String contextPath, String contextName, String dir);
    
    // Servlet management
    public Wrapper addServlet(String contextPath, String servletName, String servletClass);
    public static Wrapper addServlet(Context ctx, String servletName, String servletClass);
    public Wrapper addServlet(String contextPath, String servletName, Servlet servlet);
    public static Wrapper addServlet(Context ctx, String servletName, Servlet servlet);
    
    // Webapp defaults and configuration
    public void enableNaming();
    public void setSilent(boolean silent);
    public void setAddDefaultWebXmlToWebapp(boolean addDefaultWebXmlToWebapp);
    public LifecycleListener getDefaultWebXmlListener();
    public String noDefaultWebXmlPath();
    public void initWebappDefaults(String contextPath);
    public static void initWebappDefaults(Context ctx);
    public static void addDefaultMimeTypeMappings(Context context);
    
    // User/role management
    public void addUser(String user, String pass);
    public void addRole(String user, String role);
    
    // Lifecycle management
    public void init() throws LifecycleException;
    public void init(ConfigurationSource source) throws LifecycleException;
    public void init(ConfigurationSource source, String[] catalinaArguments) throws LifecycleException;
    public void start() throws LifecycleException;
    public void stop() throws LifecycleException;
    public void destroy() throws LifecycleException;
    
    // Component access
    public Server getServer();
    public Service getService();
    public Engine getEngine();
    public Host getHost();
    public void setHost(Host host);
    public Connector getConnector();
    public void setConnector(Connector connector);

    // Command line execution
    public static void main(String[] args) throws Exception;
}

Context Interface

Represents a web application context with servlets, filters, and resources.

public interface Context extends Container {
    // Path configuration
    void setPath(String path);
    String getPath();
    void setDocBase(String docBase);
    String getDocBase();
    
    // Servlet container initializers
    void addServletContainerInitializer(ServletContainerInitializer sci, Set<Class<?>> classes);
    void setContainerSciFilter(String containerSciFilter);
    String getContainerSciFilter();
    Set<String> addServletSecurity(ServletRegistration.Dynamic registration,
        ServletSecurityElement servletSecurityElement);
    
    // Listeners
    void addApplicationListener(String listener);
    void removeApplicationListener(String listener);
    String[] findApplicationListeners();
    void addApplicationEventListener(Object listener);
    void addApplicationLifecycleListener(Object listener);
    Object[] getApplicationEventListeners();
    void setApplicationEventListeners(Object[] listeners);
    Object[] getApplicationLifecycleListeners();
    void setApplicationLifecycleListeners(Object[] listeners);
    boolean fireRequestInitEvent(ServletRequest request);
    boolean fireRequestDestroyEvent(ServletRequest request);
    void addWrapperLifecycle(String listener);
    void removeWrapperLifecycle(String listener);
    String[] findWrapperLifecycles();
    void addWrapperListener(String listener);
    void removeWrapperListener(String listener);
    String[] findWrapperListeners();
    
    // Servlets and mappings
    void addServletMappingDecoded(String pattern, String name);
    void addServletMappingDecoded(String pattern, String name, boolean jspWildCard);
    void removeServletMapping(String pattern);
    String findServletMapping(String pattern);
    String[] findServletMappings();
    Wrapper createWrapper();
    void setWrapperClass(String wrapperClass);
    String getWrapperClass();
    void setResourceOnlyServlets(String resourceOnlyServlets);
    String getResourceOnlyServlets();
    boolean isResourceOnlyServlet(String servletName);
    
    // Filters
    void addFilterDef(FilterDef filterDef);
    void removeFilterDef(FilterDef filterDef);
    FilterDef findFilterDef(String filterName);
    FilterDef[] findFilterDefs();
    void addFilterMap(FilterMap filterMap);
    void addFilterMapBefore(FilterMap filterMap);
    void removeFilterMap(FilterMap filterMap);
    FilterMap[] findFilterMaps();
    
    // Security constraints and roles
    void addConstraint(SecurityConstraint constraint);
    void removeConstraint(SecurityConstraint constraint);
    SecurityConstraint[] findConstraints();
    void addSecurityRole(String role);
    void removeSecurityRole(String role);
    boolean findSecurityRole(String role);
    String[] findSecurityRoles();
    void addRoleMapping(String role, String link);
    void removeRoleMapping(String role);
    String findRoleMapping(String role);
    void setDenyUncoveredHttpMethods(boolean denyUncoveredHttpMethods);
    boolean getDenyUncoveredHttpMethods();
    LoginConfig getLoginConfig();
    void setLoginConfig(LoginConfig config);
    Authenticator getAuthenticator();
    void setPreemptiveAuthentication(boolean enable);
    boolean getPreemptiveAuthentication();
    
    // Initialization parameters
    void addParameter(String name, String value);
    String findParameter(String name);
    String[] findParameters();
    void removeParameter(String name);
    
    // Error pages
    void addErrorPage(ErrorPage errorPage);
    void removeErrorPage(ErrorPage errorPage);
    ErrorPage findErrorPage(int errorCode);
    ErrorPage findErrorPage(Throwable throwable);
    ErrorPage[] findErrorPages();
    
    // MIME mappings
    void addMimeMapping(String extension, String mimeType);
    String findMimeMapping(String extension);
    String[] findMimeMappings();
    void removeMimeMapping(String extension);
    
    // Welcome files
    void addWelcomeFile(String name);
    boolean findWelcomeFile(String name);
    String[] findWelcomeFiles();
    void removeWelcomeFile(String name);
    
    // Configuration
    void setCookies(boolean cookies);
    boolean getCookies();
    void setCrossContext(boolean crossContext);
    boolean getCrossContext();
    void setReloadable(boolean reloadable);
    boolean getReloadable();
    void setDisplayName(String displayName);
    String getDisplayName();
    
    // Classloader
    void setLoader(Loader loader);
    Loader getLoader();
    
    // Manager
    void setManager(Manager manager);
    Manager getManager();
    
    // Resource management
    void setResources(WebResourceRoot resources);
    WebResourceRoot getResources();
    void setAddWebinfClassesResources(boolean addWebinfClassesResources);
    boolean getAddWebinfClassesResources();
    JarScanner getJarScanner();
    void setJarScanner(JarScanner jarScanner);
    NamingResourcesImpl getNamingResources();
    void setNamingResources(NamingResourcesImpl namingResources);
    Object getNamingToken();
    
    // Session configuration
    void setSessionTimeout(int timeout);
    int getSessionTimeout();
    void setSessionCookieName(String sessionCookieName);
    String getSessionCookieName();
    void setUseHttpOnly(boolean useHttpOnly);
    boolean getUseHttpOnly();
    void setUsePartitioned(boolean usePartitioned);
    boolean getUsePartitioned();
    void setSessionCookieDomain(String sessionCookieDomain);
    String getSessionCookieDomain();
    void setSessionCookiePath(String sessionCookiePath);
    String getSessionCookiePath();
    void setSessionCookiePathUsesTrailingSlash(boolean sessionCookiePathUsesTrailingSlash);
    boolean getSessionCookiePathUsesTrailingSlash();
    void setValidateClientProvidedNewSessionId(boolean validateClientProvidedNewSessionId);
    boolean getValidateClientProvidedNewSessionId();
    void setAlwaysAccessSession(boolean alwaysAccessSession);
    boolean getAlwaysAccessSession();
    CookieProcessor getCookieProcessor();
    void setCookieProcessor(CookieProcessor cookieProcessor);

    // Deployment configuration
    void setConfigFile(URL configFile);
    URL getConfigFile();
    Resource findConfigFileResource(String name) throws IOException;
    void setAltDDName(String altDDName);
    String getAltDDName();
    void setPublicId(String publicId);
    String getPublicId();
    void setConfigured(boolean configured);
    boolean getConfigured();
    void setPrivileged(boolean privileged);
    boolean getPrivileged();
    void setDistributable(boolean distributable);
    boolean getDistributable();
    void setOverride(boolean override);
    boolean getOverride();
    void setWebappVersion(String webappVersion);
    String getWebappVersion();
    String getBaseName();
    String getEncodedPath();
    void reload();
    boolean getPaused();

    // Servlet version
    void setEffectiveMajorVersion(int major);
    int getEffectiveMajorVersion();
    void setEffectiveMinorVersion(int minor);
    int getEffectiveMinorVersion();
    boolean isServlet22();

    // Watched resources
    void addWatchedResource(String name);
    void removeWatchedResource(String name);
    String[] findWatchedResources();

    // Annotation processing
    void setIgnoreAnnotations(boolean ignoreAnnotations);
    boolean getIgnoreAnnotations();
    void setParallelAnnotationScanning(boolean parallelAnnotationScanning);
    boolean getParallelAnnotationScanning();

    // Instance management
    InstanceManager getInstanceManager();
    void setInstanceManager(InstanceManager instanceManager);
    InstanceManager createInstanceManager();
    void addPostConstructMethod(String clazz, String method);
    void removePostConstructMethod(String clazz);
    String findPostConstructMethod(String clazz);
    Map<String,String> findPostConstructMethods();
    void addPreDestroyMethod(String clazz, String method);
    void removePreDestroyMethod(String clazz);
    String findPreDestroyMethod(String clazz);
    Map<String,String> findPreDestroyMethods();

    // Application parameters
    void addApplicationParameter(ApplicationParameter parameter);
    void removeApplicationParameter(String name);
    ApplicationParameter[] findApplicationParameters();

    // Character encoding
    void setRequestCharacterEncoding(String encoding);
    String getRequestCharacterEncoding();
    void setResponseCharacterEncoding(String encoding);
    String getResponseCharacterEncoding();
    void addLocaleEncodingMappingParameter(String locale, String encoding);
    String getCharset(Locale locale);

    // Multipart configuration
    void setAllowCasualMultipartParsing(boolean allowCasualMultipartParsing);
    boolean getAllowCasualMultipartParsing();
    void setSwallowAbortedUploads(boolean swallowAbortedUploads);
    boolean getSwallowAbortedUploads();
    void setCreateUploadTargets(boolean createUploadTargets);
    boolean getCreateUploadTargets();

    // Advanced configuration
    void setSwallowOutput(boolean swallowOutput);
    boolean getSwallowOutput();
    ClassLoader getParentClassLoader();
    void setParentClassLoader(ClassLoader parent);
    void setFailCtxIfServletStartFails(boolean failCtxIfServletStartFails);
    boolean getFailCtxIfServletStartFails();
    ServletContext getServletContext();
    String getRealPath(String path);
    JspConfigDescriptor getJspConfigDescriptor();
    void setJspConfigDescriptor(JspConfigDescriptor descriptor);
    void setTldValidation(boolean tldValidation);
    boolean getTldValidation();
    void setXmlNamespaceAware(boolean xmlNamespaceAware);
    boolean getXmlNamespaceAware();
    void setXmlValidation(boolean xmlValidation);
    boolean getXmlValidation();
    void setXmlBlockExternal(boolean xmlBlockExternal);
    boolean getXmlBlockExternal();
    void setLogEffectiveWebXml(boolean logEffectiveWebXml);
    boolean getLogEffectiveWebXml();

    // Request processing
    void setSendRedirectBody(boolean enable);
    boolean getSendRedirectBody();
    void setUseRelativeRedirects(boolean useRelativeRedirects);
    boolean getUseRelativeRedirects();
    void setMapperContextRootRedirectEnabled(boolean mapperContextRootRedirectEnabled);
    boolean getMapperContextRootRedirectEnabled();
    void setMapperDirectoryRedirectEnabled(boolean mapperDirectoryRedirectEnabled);
    boolean getMapperDirectoryRedirectEnabled();
    void setDispatchersUseEncodedPaths(boolean dispatchersUseEncodedPaths);
    boolean getDispatchersUseEncodedPaths();
    void setFireRequestListenersOnForwards(boolean enable);
    boolean getFireRequestListenersOnForwards();
    void setEncodedSolidusHandling(String encodedSolidusHandling);
    String getEncodedSolidusHandling();
    EncodedSolidusHandling getEncodedSolidusHandlingEnum();
    void setEncodedReverseSolidusHandling(String encodedReverseSolidusHandling);
    String getEncodedReverseSolidusHandling();
    EncodedSolidusHandling getEncodedReverseSolidusHandlingEnum();
    void setContextGetResourceRequiresSlash(boolean contextGetResourceRequiresSlash);
    boolean getContextGetResourceRequiresSlash();
    void setDispatcherWrapsSameObject(boolean dispatcherWrapsSameObject);
    boolean getDispatcherWrapsSameObject();
    void setSuspendWrappedResponseAfterForward(boolean suspendWrappedResponseAfterForward);
    boolean getSuspendWrappedResponseAfterForward();
    void setAllowMultipleLeadingForwardSlashInPath(boolean allowMultipleLeadingForwardSlashInPath);
    boolean getAllowMultipleLeadingForwardSlashInPath();
    void setThreadBindingListener(ThreadBindingListener threadBindingListener);
    ThreadBindingListener getThreadBindingListener();

    // Async processing
    void incrementInProgressAsyncCount();
    void decrementInProgressAsyncCount();

    // Background processing
    void backgroundProcess();
}

Wrapper Interface

Represents an individual servlet within a context.

public interface Wrapper extends Container {
    // Servlet class
    void setServletClass(String servletClass);
    String getServletClass();
    void setServlet(Servlet servlet);
    Servlet getServlet();
    
    // Load on startup
    void setLoadOnStartup(int value);
    int getLoadOnStartup();
    
    // Run-as role
    void setRunAs(String runAs);
    String getRunAs();
    
    // Servlet state
    boolean isUnavailable();
    long getAvailable();
    void setAvailable(long available);

    // Request monitoring
    void incrementErrorCount();

    // Servlet methods
    String[] getServletMethods() throws ServletException;

    // Multipart configuration
    void setMultipartConfigElement(MultipartConfigElement multipartConfig);
    MultipartConfigElement getMultipartConfigElement();

    // Async support
    void setAsyncSupported(boolean asyncSupported);
    boolean isAsyncSupported();

    // Enabled
    void setEnabled(boolean enabled);
    boolean isEnabled();

    // Overridable
    boolean isOverridable();
    void setOverridable(boolean overridable);

    // Servlet lifecycle
    Servlet allocate() throws ServletException;
    void deallocate(Servlet servlet) throws ServletException;
    void load() throws ServletException;
    void unload() throws ServletException;
    void unavailable(UnavailableException unavailable);

    // Init parameters
    void addInitParameter(String name, String value);
    String findInitParameter(String name);
    String[] findInitParameters();
    void removeInitParameter(String name);

    // Mappings
    void addMapping(String mapping);
    String[] findMappings();
    void removeMapping(String mapping);

    // Security references
    void addSecurityReference(String name, String link);
    String findSecurityReference(String name);
    String[] findSecurityReferences();
    void removeSecurityReference(String name);
}

Usage Examples

Basic Embedded Server

import org.apache.catalina.startup.Tomcat;
import org.apache.catalina.Context;
import org.apache.catalina.LifecycleException;
import java.io.File;

public class SimpleEmbeddedTomcat {
    public static void main(String[] args) throws LifecycleException {
        Tomcat tomcat = new Tomcat();
        tomcat.setPort(8080);
        tomcat.setBaseDir(new File("target/tomcat").getAbsolutePath());
        
        // Add empty context (for servlets added programmatically)
        Context ctx = tomcat.addContext("", new File(".").getAbsolutePath());
        
        // Start server
        tomcat.start();
        tomcat.getServer().await();
    }
}

Adding Servlets Programmatically

import org.apache.catalina.startup.Tomcat;
import org.apache.catalina.Context;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

public class ServletExample {
    public static void main(String[] args) throws Exception {
        Tomcat tomcat = new Tomcat();
        tomcat.setPort(8080);
        
        Context ctx = tomcat.addContext("", System.getProperty("java.io.tmpdir"));
        
        // Add servlet instance
        HttpServlet servlet = new HttpServlet() {
            @Override
            protected void doGet(HttpServletRequest req, HttpServletResponse resp) 
                    throws IOException {
                resp.setContentType("text/html");
                PrintWriter writer = resp.getWriter();
                writer.println("<h1>Hello from Embedded Tomcat</h1>");
            }
        };
        
        Tomcat.addServlet(ctx, "helloServlet", servlet);
        ctx.addServletMappingDecoded("/hello", "helloServlet");

        // Add servlet by class name
        Tomcat.addServlet(ctx, "myServlet", "com.example.MyServlet");
        ctx.addServletMappingDecoded("/my/*", "myServlet");

        // Configure async support for async servlets
        Wrapper asyncWrapper = Tomcat.addServlet(ctx, "asyncServlet", new AsyncServlet());
        asyncWrapper.setAsyncSupported(true);
        ctx.addServletMappingDecoded("/async", "asyncServlet");

        // Configure multipart support for file upload servlets
        Wrapper uploadWrapper = Tomcat.addServlet(ctx, "uploadServlet", new FileUploadServlet());
        uploadWrapper.setMultipartConfigElement(new MultipartConfigElement("/tmp"));
        ctx.addServletMappingDecoded("/upload", "uploadServlet");

        tomcat.start();
        tomcat.getServer().await();
    }
}

Configuration Notes:

  • Async Servlets: Use wrapper.setAsyncSupported(true) to enable asynchronous processing
  • File Upload Servlets: Use wrapper.setMultipartConfigElement(new MultipartConfigElement("/tmp")) to enable multipart/form-data processing

Adding Web Application

import org.apache.catalina.startup.Tomcat;
import org.apache.catalina.Context;
import java.io.File;

public class WebAppExample {
    public static void main(String[] args) throws Exception {
        Tomcat tomcat = new Tomcat();
        tomcat.setPort(8080);
        tomcat.setBaseDir(new File("target/tomcat").getAbsolutePath());
        
        // Add existing web application
        String webappDirLocation = "src/main/webapp/";
        Context ctx = tomcat.addWebapp("/myapp", 
            new File(webappDirLocation).getAbsolutePath());
        
        tomcat.start();
        tomcat.getServer().await();
    }
}

Multiple Contexts

import org.apache.catalina.startup.Tomcat;
import org.apache.catalina.Context;
import org.apache.catalina.Host;
import java.io.File;

public class MultiContextExample {
    public static void main(String[] args) throws Exception {
        Tomcat tomcat = new Tomcat();
        tomcat.setPort(8080);
        tomcat.setBaseDir(new File("target/tomcat").getAbsolutePath());
        
        Host host = tomcat.getHost();
        
        // API context
        Context apiCtx = tomcat.addContext(host, "/api", 
            new File("target/api").getAbsolutePath());
        
        // Admin context
        Context adminCtx = tomcat.addContext(host, "/admin", 
            new File("target/admin").getAbsolutePath());
        
        // Web context
        Context webCtx = tomcat.addWebapp(host, "/", 
            new File("src/main/webapp").getAbsolutePath());
        
        tomcat.start();
        tomcat.getServer().await();
    }
}

Custom Connector Configuration

import org.apache.catalina.startup.Tomcat;
import org.apache.catalina.connector.Connector;
import org.apache.coyote.http11.Http11NioProtocol;

public class CustomConnectorExample {
    public static void main(String[] args) throws Exception {
        Tomcat tomcat = new Tomcat();
        tomcat.setBaseDir("target/tomcat");
        
        // Create custom HTTP connector
        Connector httpConnector = new Connector("HTTP/1.1");
        httpConnector.setPort(8080);
        httpConnector.setProperty("maxThreads", "200");
        httpConnector.setProperty("maxConnections", "10000");
        httpConnector.setProperty("connectionTimeout", "20000");
        httpConnector.setProperty("compression", "on");
        httpConnector.setProperty("compressibleMimeType", 
            "text/html,text/xml,text/plain,text/css,text/javascript,application/json");
        
        tomcat.setConnector(httpConnector);
        tomcat.getService().addConnector(httpConnector);
        
        // Add HTTPS connector
        Connector httpsConnector = new Connector("HTTP/1.1");
        httpsConnector.setPort(8443);
        httpsConnector.setSecure(true);
        httpsConnector.setScheme("https");
        httpsConnector.setProperty("SSLEnabled", "true");
        httpsConnector.setProperty("keystoreFile", "conf/keystore.jks");
        httpsConnector.setProperty("keystorePass", "changeit");
        
        tomcat.getService().addConnector(httpsConnector);
        
        Context ctx = tomcat.addContext("", System.getProperty("java.io.tmpdir"));
        
        tomcat.start();
        tomcat.getServer().await();
    }
}

Adding Users and Roles

import org.apache.catalina.startup.Tomcat;
import org.apache.catalina.Context;
import java.io.File;

public class SecurityExample {
    public static void main(String[] args) throws Exception {
        Tomcat tomcat = new Tomcat();
        tomcat.setPort(8080);
        tomcat.setBaseDir(new File("target/tomcat").getAbsolutePath());
        
        // Add users and roles
        tomcat.addUser("admin", "admin123");
        tomcat.addRole("admin", "manager");
        tomcat.addRole("admin", "admin-gui");
        
        tomcat.addUser("user", "user123");
        tomcat.addRole("user", "user");
        
        Context ctx = tomcat.addContext("", new File(".").getAbsolutePath());
        
        tomcat.start();
        tomcat.getServer().await();
    }
}

Testing Utility

import org.apache.catalina.startup.Tomcat;
import org.apache.catalina.Context;
import org.apache.catalina.LifecycleException;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.io.File;

public class TomcatTestHelper {
    private Tomcat tomcat;
    private int port = 8080;

    @BeforeEach
    public void setUp() throws LifecycleException {
        tomcat = new Tomcat();
        tomcat.setPort(port);
        tomcat.setBaseDir(new File("target/tomcat-test").getAbsolutePath());

        Context ctx = tomcat.addContext("", new File(".").getAbsolutePath());

        tomcat.start();
    }

    @AfterEach
    public void tearDown() throws LifecycleException {
        if (tomcat != null) {
            tomcat.stop();
            tomcat.destroy();
        }
    }

    @Test
    public void testServer() throws Exception {
        // Test HTTP requests against embedded server
        String url = "http://localhost:" + port + "/test";
        // ... perform HTTP request testing
    }
}

Advanced Context Configuration

import org.apache.catalina.startup.Tomcat;
import org.apache.catalina.Context;
import org.apache.catalina.Host;
import java.io.File;

public class AdvancedContextExample {
    public static void main(String[] args) throws Exception {
        Tomcat tomcat = new Tomcat();
        tomcat.setPort(8080);
        tomcat.setBaseDir("target/tomcat");

        Host host = tomcat.getHost();

        // Create context with explicit name (useful for managing multiple contexts)
        Context ctx = tomcat.addContext(host, "/myapp", "myapp-v1",
            new File("webapps/myapp").getAbsolutePath());

        // Initialize with default servlets, JSP support, and MIME types
        Tomcat.initWebappDefaults(ctx);

        tomcat.start();
        tomcat.getServer().await();
    }
}

Custom Webapp Configuration without Default web.xml

import org.apache.catalina.startup.Tomcat;
import org.apache.catalina.Context;
import org.apache.catalina.LifecycleListener;
import org.apache.catalina.startup.ContextConfig;
import java.io.File;

public class CustomWebappConfig {
    public static void main(String[] args) throws Exception {
        Tomcat tomcat = new Tomcat();
        tomcat.setPort(8080);
        tomcat.setBaseDir("target/tomcat");

        // Prevent default web.xml from being applied
        tomcat.setAddDefaultWebXmlToWebapp(false);

        Context ctx = tomcat.addContext("", new File("webapp").getAbsolutePath());

        // Manually add default web.xml listener for JSP support
        LifecycleListener listener = tomcat.getDefaultWebXmlListener();
        ctx.addLifecycleListener(listener);

        // Configure to skip default web.xml processing
        String noDefaultWebXml = tomcat.noDefaultWebXmlPath();
        for (LifecycleListener l : ctx.findLifecycleListeners()) {
            if (l instanceof ContextConfig) {
                ((ContextConfig) l).setDefaultWebXml(noDefaultWebXml);
            }
        }

        // Add only specific default MIME type mappings
        Tomcat.addDefaultMimeTypeMappings(ctx);

        tomcat.start();
        tomcat.getServer().await();
    }
}

Types

EncodedSolidusHandling

Enum for handling encoded solidus characters in request dispatcher paths.

public enum EncodedSolidusHandling {
    /** Reject requests that contain encoded solidus */
    REJECT,
    /** Pass encoded solidus through without decoding */
    PASS_THROUGH,
    /** Decode encoded solidus */
    DECODE
}

ThreadBindingListener

Interface for receiving notifications when a request enters/exits the application scope.

public interface ThreadBindingListener {
    /** Called when a thread is bound to the context */
    void bind();
    /** Called when a thread is unbound from the context */
    void unbind();
}

Install with Tessl CLI

npx tessl i tessl/maven-org-apache-tomcat-embed--tomcat-embed-core

docs

authentication.md

catalina-core.md

connectors.md

embedded-tomcat.md

index.md

logging.md

servlet-api.md

session-management.md

utilities.md

valves.md

web-resources.md

tile.json