tessl/maven-org-springframework-boot--spring-boot-starter-jetty
Starter for using Jetty as the embedded servlet container in Spring Boot applications
—
Pending
http-client.mddocs/
HTTP Client
Spring Boot HTTP client builders for creating Jetty-based HTTP clients. These builders provide an easy way to configure Jetty HTTP clients for use with RestTemplate and WebClient in Spring Boot applications.
Capabilities
Jetty Client HTTP Request Factory Builder
Builder for creating JettyClientHttpRequestFactory instances with custom configuration.
/**
* Builder for JettyClientHttpRequestFactory
*/
public class JettyClientHttpRequestFactoryBuilder
implements ClientHttpRequestFactoryBuilder<JettyClientHttpRequestFactory> {
/** Create builder with default configuration */
public JettyClientHttpRequestFactoryBuilder();
/** Set custom HTTP client instance */
public JettyClientHttpRequestFactoryBuilder httpClient(HttpClient httpClient);
/** Set connect timeout */
public JettyClientHttpRequestFactoryBuilder connectTimeout(Duration connectTimeout);
/** Set read timeout */
public JettyClientHttpRequestFactoryBuilder readTimeout(Duration readTimeout);
/** Build the JettyClientHttpRequestFactory */
public JettyClientHttpRequestFactory build();
}Usage Examples:
@Configuration
public class HttpClientConfig {
@Bean
public RestTemplate jettyRestTemplate() {
// Create Jetty HTTP client
HttpClient httpClient = new HttpClient();
httpClient.setConnectTimeout(5000);
httpClient.setIdleTimeout(30000);
httpClient.setMaxConnectionsPerDestination(20);
// Create request factory
JettyClientHttpRequestFactory requestFactory =
new JettyClientHttpRequestFactory(httpClient);
requestFactory.setConnectTimeout(Duration.ofSeconds(5));
requestFactory.setReadTimeout(Duration.ofSeconds(30));
// Create RestTemplate
RestTemplate restTemplate = new RestTemplate(requestFactory);
// Add message converters if needed
restTemplate.getMessageConverters().add(new MappingJackson2HttpMessageConverter());
return restTemplate;
}
@Bean
public WebClient jettyWebClient() {
HttpClient httpClient = new HttpClient();
httpClient.setConnectTimeout(5000);
httpClient.setFollowRedirects(false);
JettyClientHttpConnector connector = new JettyClientHttpConnector(httpClient);
return WebClient.builder()
.clientConnector(connector)
.defaultHeader(HttpHeaders.USER_AGENT, "My Application")
.build();
}
}Reactive HTTP Client Connector
HTTP client connector for reactive applications using Spring WebClient with non-blocking I/O.
/**
* Reactive HTTP client connector using Jetty HTTP client
*/
public class JettyClientHttpConnector implements ClientHttpConnector {
/** Create connector with default HTTP client */
public JettyClientHttpConnector();
/** Create connector with custom HTTP client */
public JettyClientHttpConnector(HttpClient httpClient);
/** Create connector with custom resource factory */
public JettyClientHttpConnector(JettyResourceFactory resourceFactory);
/** Connect to the given URI with request */
public Mono<ClientHttpResponse> connect(HttpMethod method, URI uri,
Function<? super ClientHttpRequest, Mono<Void>> requestCallback);
/** Get the underlying HTTP client */
public HttpClient getHttpClient();
}HTTP Client Configuration
Comprehensive HTTP client configuration options for connection management and performance tuning.
/**
* HTTP client configuration and customization
*/
public class HttpClient {
/** Create HTTP client with default configuration */
public HttpClient();
/** Create HTTP client with SSL context factory */
public HttpClient(SslContextFactory.Client sslContextFactory);
/** Set connect timeout in milliseconds */
public void setConnectTimeout(long connectTimeout);
/** Set idle timeout in milliseconds */
public void setIdleTimeout(long idleTimeout);
/** Set maximum connections per destination */
public void setMaxConnectionsPerDestination(int maxConnectionsPerDestination);
/** Set maximum requests queued per destination */
public void setMaxRequestsQueuedPerDestination(int maxRequestsQueuedPerDestination);
/** Set request buffer size */
public void setRequestBufferSize(int requestBufferSize);
/** Set response buffer size */
public void setResponseBufferSize(int responseBufferSize);
/** Enable/disable HTTP/2 support */
public void setHttp2Enabled(boolean http2Enabled);
/** Set whether to follow redirects */
public void setFollowRedirects(boolean followRedirects);
/** Set user agent string */
public void setUserAgentField(HttpField userAgentField);
/** Add protocol handlers */
public void setProtocolHandlers(List<ProtocolHandler> protocolHandlers);
/** Start the HTTP client */
public void start() throws Exception;
/** Stop the HTTP client */
public void stop() throws Exception;
}SSL Configuration for HTTP Client
SSL/TLS configuration for secure HTTP client connections.
/**
* SSL context factory for Jetty HTTP client
*/
public class SslContextFactory.Client extends SslContextFactory {
/** Create SSL context factory for client */
public SslContextFactory.Client();
/** Create SSL context factory with trust all certificates */
public SslContextFactory.Client(boolean trustAll);
/** Set trust store path and password */
public void setTrustStorePath(String trustStorePath);
public void setTrustStorePassword(String trustStorePassword);
/** Set key store path and password */
public void setKeyStorePath(String keyStorePath);
public void setKeyStorePassword(String keyStorePassword);
/** Set included/excluded protocols */
public void setIncludeProtocols(String... protocols);
public void setExcludeProtocols(String... protocols);
/** Set included/excluded cipher suites */
public void setIncludeCipherSuites(String... cipherSuites);
public void setExcludeCipherSuites(String... cipherSuites);
/** Enable/disable hostname verification */
public void setHostnameVerifier(HostnameVerifier hostnameVerifier);
/** Set endpoint identification algorithm */
public void setEndpointIdentificationAlgorithm(String endpointIdentificationAlgorithm);
/** Trust all certificates (for testing only) */
public void setTrustAll(boolean trustAll);
}SSL Client Configuration Example:
@Configuration
public class SecureHttpClientConfig {
@Bean
public WebClient secureWebClient() {
// SSL configuration
SslContextFactory.Client sslContextFactory = new SslContextFactory.Client();
sslContextFactory.setTrustStorePath("/path/to/truststore.jks");
sslContextFactory.setTrustStorePassword("truststore-password");
sslContextFactory.setIncludeProtocols("TLSv1.2", "TLSv1.3");
sslContextFactory.setEndpointIdentificationAlgorithm("HTTPS");
// HTTP client configuration
HttpClient httpClient = new HttpClient(sslContextFactory);
httpClient.setConnectTimeout(10000);
httpClient.setIdleTimeout(30000);
httpClient.setMaxConnectionsPerDestination(50);
// Create reactive connector
JettyClientHttpConnector connector = new JettyClientHttpConnector(httpClient);
return WebClient.builder()
.clientConnector(connector)
.build();
}
}Connection Pooling
Connection pooling configuration for efficient connection reuse and resource management.
/**
* Connection pool configuration for HTTP client
*/
public class HttpClient {
/** Set maximum connections per destination */
public void setMaxConnectionsPerDestination(int maxConnectionsPerDestination);
/** Set maximum requests queued per destination */
public void setMaxRequestsQueuedPerDestination(int maxRequestsQueuedPerDestination);
/** Set connection pool timeout */
public void setConnectionPoolTimeout(long connectionPoolTimeout);
/** Set whether to remove idle destinations */
public void setRemoveIdleDestinations(boolean removeIdleDestinations);
/** Get destination statistics */
public Set<Destination> getDestinations();
/** Clear destinations and connections */
public void clearDestinations();
}HTTP/2 Support
HTTP/2 protocol support for improved performance and multiplexing.
/**
* HTTP/2 configuration for Jetty HTTP client
*/
public class HTTP2Client {
/** Create HTTP/2 client */
public HTTP2Client();
/** Create HTTP/2 client with connector */
public HTTP2Client(Connector connector);
/** Set initial session receive window */
public void setInitialSessionRecvWindow(int initialSessionRecvWindow);
/** Set initial stream receive window */
public void setInitialStreamRecvWindow(int initialStreamRecvWindow);
/** Set maximum concurrent streams */
public void setMaxConcurrentPushedStreams(int maxConcurrentPushedStreams);
/** Set max frame length */
public void setMaxFrameLength(int maxFrameLength);
/** Connect to HTTP/2 server */
public void connect(InetSocketAddress address, Session.Listener listener);
/** Start the HTTP/2 client */
public void start() throws Exception;
/** Stop the HTTP/2 client */
public void stop() throws Exception;
}Request/Response Handling
Advanced request and response handling with customization options.
/**
* HTTP request and response handling
*/
public class Request {
/** Set request timeout */
public Request timeout(long timeout, TimeUnit unit);
/** Set request headers */
public Request header(String name, String value);
public Request headers(HttpFields headers);
/** Set request content */
public Request content(ContentProvider content);
public Request content(ContentProvider content, String contentType);
/** Set request parameters */
public Request param(String name, String value);
/** Set request attributes */
public Request attribute(String name, Object value);
/** Send request asynchronously */
public void send(Response.CompleteListener listener);
/** Send request synchronously */
public ContentResponse send() throws InterruptedException, TimeoutException, ExecutionException;
}
/**
* Response handling and processing
*/
public interface Response {
/** Get response status */
int getStatus();
/** Get response reason */
String getReason();
/** Get response headers */
HttpFields getHeaders();
/** Get response content */
byte[] getContent();
/** Get response content as string */
String getContentAsString();
/** Get response media type */
String getMediaType();
/** Get response encoding */
String getEncoding();
}Advanced Usage Example:
@Service
public class HttpClientService {
private final HttpClient httpClient;
public HttpClientService(HttpClient httpClient) {
this.httpClient = httpClient;
}
public Mono<String> fetchDataReactively(String url) {
Request request = httpClient.newRequest(url)
.method(HttpMethod.GET)
.timeout(30, TimeUnit.SECONDS)
.header(HttpHeaders.ACCEPT, MediaType.APPLICATION_JSON);
return Mono.fromFuture(request.send().toCompletableFuture())
.map(ContentResponse::getContentAsString);
}
public String fetchDataSynchronously(String url) throws Exception {
ContentResponse response = httpClient.newRequest(url)
.method(HttpMethod.GET)
.timeout(30, TimeUnit.SECONDS)
.send();
if (response.getStatus() == 200) {
return response.getContentAsString();
} else {
throw new RuntimeException("HTTP " + response.getStatus() + ": " + response.getReason());
}
}
}Install with Tessl CLI
npx tessl i tessl/maven-org-springframework-boot--spring-boot-starter-jetty