tessl/maven-org-springframework-boot--spring-boot-starter-jetty
Starter for using Jetty as the embedded servlet container in Spring Boot applications
—
Pending
server-configuration.mddocs/
Server Configuration
Comprehensive server configuration and customization options including SSL, threading, connectors, and advanced Jetty features. Provides extensive customization capabilities for both servlet and reactive applications.
Capabilities
JettyServerCustomizer
Primary interface for customizing Jetty server configuration with direct access to the underlying Jetty Server instance.
/**
* Interface for customizing Jetty Server instances
*/
@FunctionalInterface
public interface JettyServerCustomizer {
/** Customize the Jetty Server instance */
void customize(Server server);
}Usage Examples:
@Configuration
public class JettyCustomizerConfig {
@Bean
public JettyServletWebServerFactory jettyFactory() {
JettyServletWebServerFactory factory = new JettyServletWebServerFactory();
// Add multiple customizers
factory.addServerCustomizers(
// Custom connector configuration
server -> {
ServerConnector connector = new ServerConnector(server);
connector.setPort(8080);
connector.setIdleTimeout(30000);
connector.setAcceptQueueSize(128);
server.addConnector(connector);
},
// Thread pool configuration
server -> {
QueuedThreadPool threadPool = new QueuedThreadPool();
threadPool.setMaxThreads(200);
threadPool.setMinThreads(10);
threadPool.setIdleTimeout(60000);
server.setThreadPool(threadPool);
}
);
return factory;
}
}ConfigurableJettyWebServerFactory
Common interface for both servlet and reactive Jetty web server factories providing configuration methods.
/**
* Common configuration interface for Jetty web server factories
*/
public interface ConfigurableJettyWebServerFactory extends ConfigurableWebServerFactory {
/** Add server customizers for configuration */
void addServerCustomizers(JettyServerCustomizer... customizers);
/** Set number of acceptor threads */
void setAcceptors(int acceptors);
/** Set number of selector threads */
void setSelectors(int selectors);
/** Configure forward headers handling */
void setUseForwardHeaders(boolean useForwardHeaders);
/** Set custom thread pool */
void setThreadPool(ThreadPool threadPool);
/** Set maximum number of connections */
void setMaxConnections(int maxConnections);
}Thread Pool Configuration
Custom thread pool implementations and configuration for Jetty servers.
/**
* Jetty thread pool configuration
*/
public class JettyThreadPool implements ThreadPool {
/** Create thread pool with default configuration */
public JettyThreadPool();
/** Create thread pool with specified parameters */
public JettyThreadPool(int maxThreads, int minThreads, int idleTimeout);
/** Create thread pool from server properties */
public static JettyThreadPool create(ServerProperties.Jetty jettyProperties);
/** Get maximum number of threads */
public int getMaxThreads();
/** Set maximum number of threads */
public void setMaxThreads(int maxThreads);
/** Get minimum number of threads */
public int getMinThreads();
/** Set minimum number of threads */
public void setMinThreads(int minThreads);
/** Get idle timeout in milliseconds */
public int getIdleTimeout();
/** Set idle timeout in milliseconds */
public void setIdleTimeout(int idleTimeout);
/** Execute a task */
public void execute(Runnable job);
/** Check if thread pool is low on threads */
public boolean isLowOnThreads();
}Web Server Factory Customizers
Auto-configuration customizers that apply default Jetty configuration based on Spring Boot properties.
/**
* Auto-configuration customizer for Jetty web server factories
*/
public class JettyWebServerFactoryCustomizer
implements WebServerFactoryCustomizer<ConfigurableJettyWebServerFactory> {
/** Create customizer with server properties */
public JettyWebServerFactoryCustomizer(ServerProperties serverProperties);
/** Apply customization to factory */
public void customize(ConfigurableJettyWebServerFactory factory);
}
/**
* Virtual threads customizer for Jetty (Java 21+)
*/
public class JettyVirtualThreadsWebServerFactoryCustomizer
implements WebServerFactoryCustomizer<ConfigurableJettyWebServerFactory> {
/** Create virtual threads customizer */
public JettyVirtualThreadsWebServerFactoryCustomizer();
/** Apply virtual threads configuration */
public void customize(ConfigurableJettyWebServerFactory factory);
}SSL/TLS Configuration
SSL/TLS configuration and customization for secure connections.
/**
* SSL/TLS customizer for Jetty servers
*/
public class SslServerCustomizer implements JettyServerCustomizer {
/** Create SSL customizer with default configuration */
public SslServerCustomizer();
/** Customize server with SSL configuration */
public void customize(Server server);
/** Configure SSL context factory */
public void configureSslContextFactory(SslContextFactory.Server sslContextFactory);
/** Set SSL protocols */
public void setIncludeProtocols(String... protocols);
/** Set SSL cipher suites */
public void setIncludeCipherSuites(String... cipherSuites);
/** Set client authentication mode */
public void setNeedClientAuth(boolean needClientAuth);
public void setWantClientAuth(boolean wantClientAuth);
}SSL Configuration Example:
@Configuration
public class JettySslConfig {
@Bean
public JettyServletWebServerFactory jettyFactory() {
JettyServletWebServerFactory factory = new JettyServletWebServerFactory();
factory.addServerCustomizers(server -> {
// SSL Context Factory
SslContextFactory.Server sslContextFactory = new SslContextFactory.Server();
sslContextFactory.setKeyStorePath("/path/to/keystore.jks");
sslContextFactory.setKeyStorePassword("password");
sslContextFactory.setKeyManagerPassword("password");
// Security protocols
sslContextFactory.setIncludeProtocols("TLSv1.2", "TLSv1.3");
sslContextFactory.setExcludeCipherSuites(
"SSL_RSA_WITH_DES_CBC_SHA",
"SSL_DHE_RSA_WITH_DES_CBC_SHA"
);
// HTTP Configuration
HttpConfiguration httpConfig = new HttpConfiguration();
httpConfig.setSecureScheme("https");
httpConfig.setSecurePort(8443);
httpConfig.addCustomizer(new SecureRequestCustomizer());
// SSL Connection Factory
SslConnectionFactory sslConnectionFactory =
new SslConnectionFactory(sslContextFactory, "http/1.1");
HttpConnectionFactory httpConnectionFactory =
new HttpConnectionFactory(httpConfig);
// SSL Connector
ServerConnector sslConnector = new ServerConnector(server,
sslConnectionFactory, httpConnectionFactory);
sslConnector.setPort(8443);
server.addConnector(sslConnector);
});
return factory;
}
}Forward Headers Support
Configuration for handling forward headers from proxies and load balancers.
/**
* Forward headers customizer for proxy support
*/
public class ForwardHeadersCustomizer implements JettyServerCustomizer {
/** Create forward headers customizer */
public ForwardHeadersCustomizer();
/** Customize server for forward headers */
public void customize(Server server);
/** Set trusted proxy addresses */
public void setTrustedProxies(String... trustedProxies);
/** Set forward header names */
public void setForwardedHostHeader(String forwardedHostHeader);
public void setForwardedPortHeader(String forwardedPortHeader);
public void setForwardedProtoHeader(String forwardedProtoHeader);
}Properties Configuration
Spring Boot properties integration for Jetty server configuration through the server.jetty.* namespace.
Properties Configuration Example:
server:
jetty:
acceptors: 2
selectors: 4
max-http-post-size: 10MB
threads:
max: 200
min: 10
idle-timeout: 60s
connection:
idle-timeout: 30s
accept-queue-size: 128Install with Tessl CLI
npx tessl i tessl/maven-org-springframework-boot--spring-boot-starter-jetty