tessl/maven-org-eclipse-jetty--jetty-client

Eclipse Jetty HTTP Client - A lightweight, asynchronous HTTP client library that supports HTTP/1.1, HTTP/2, WebSocket, and various authentication mechanisms, proxy configurations, and connection pooling strategies.

—

Pending

Overview

Eval results

Files

Request Configuration

Name: tessl/maven-org-eclipse-jetty--jetty-client
Author: tessl

The Request interface provides a fluent API for configuring HTTP requests with comprehensive customization options including headers, timeouts, content, cookies, and HTTP methods.

Request Interface

The core interface for configuring and sending HTTP requests.

public interface Request {
    // Connection information
    Connection getConnection();
    
    // URI components
    String getScheme();
    Request scheme(String scheme);
    String getHost();
    Request host(String host);
    int getPort();
    Request port(int port);
    String getPath();
    Request path(String path);
    String getQuery();
    Request query(String query);
    URI getURI();
    
    // HTTP method and version
    HttpMethod getMethod();
    Request method(HttpMethod method);
    Request method(String method);
    HttpVersion getVersion();
    Request version(HttpVersion version);
    
    // Headers and cookies
    HttpFields getHeaders();
    Request headers(Consumer<HttpFields> headers);
    Request header(String name, String value);
    Request headers(HttpFields headers);
    List<HttpCookie> getCookies();
    Request cookie(HttpCookie cookie);
    
    // Timeout configuration
    Request timeout(long timeout, TimeUnit unit);
    long getTimeout();
    
    // Content
    Request body(Request.Content content);
    Request file(Path file) throws IOException;
    Request file(Path file, String contentType) throws IOException;
    
    // Sending
    ContentResponse send() throws InterruptedException, ExecutionException, TimeoutException;
    void send(Response.CompleteListener listener);
    
    // Listener management
    Request onRequestQueued(Request.QueuedListener listener);
    Request onRequestBegin(Request.BeginListener listener);
    Request onRequestHeaders(Request.HeadersListener listener);
    Request onRequestCommit(Request.CommitListener listener);
    Request onRequestContent(Request.ContentListener listener);
    Request onRequestSuccess(Request.SuccessListener listener);
    Request onRequestFailure(Request.FailureListener listener);
    Request onResponseBegin(Response.BeginListener listener);
    Request onResponseHeader(Response.HeaderListener listener);
    Request onResponseHeaders(Response.HeadersListener listener);
    Request onResponseContent(Response.ContentListener listener);
    Request onResponseContentDemanded(Response.DemandedContentListener listener);
    Request onResponseSuccess(Response.SuccessListener listener);
    Request onResponseFailure(Response.FailureListener listener);
}

URI Configuration

Configure the target URI components of the request.

Basic URI Configuration

Request request = client.newRequest("https://api.example.com")
    .path("/users/123")
    .query("format=json&include=profile");

Component-by-Component Configuration

Request request = client.newRequest("localhost", 8080)
    .scheme("https")
    .path("/api/v1/data")
    .query("limit=10&offset=0");

Query Parameter Building

// Using Fields for structured query parameters
Fields queryFields = new Fields();
queryFields.add("category", "books");
queryFields.add("sort", "title");
queryFields.add("order", "asc");

String queryString = queryFields.toQueryString();
Request request = client.newRequest("https://api.example.com/search")
    .query(queryString);

HTTP Method Configuration

Configure the HTTP method for the request.

Using HttpMethod Enum

Request request = client.newRequest("https://api.example.com/users/123")
    .method(HttpMethod.PUT);

Using String Method

Request request = client.newRequest("https://api.example.com/data")
    .method("PATCH");

Common HTTP Methods

// GET (default for newRequest)
Request getRequest = client.newRequest("https://api.example.com/users");

// POST (also available via client.POST())
Request postRequest = client.newRequest("https://api.example.com/users")
    .method(HttpMethod.POST);

// PUT
Request putRequest = client.newRequest("https://api.example.com/users/123")
    .method(HttpMethod.PUT);

// DELETE
Request deleteRequest = client.newRequest("https://api.example.com/users/123")
    .method(HttpMethod.DELETE);

// PATCH
Request patchRequest = client.newRequest("https://api.example.com/users/123")
    .method(HttpMethod.PATCH);

Header Configuration

Configure HTTP headers for the request.

Adding Individual Headers

Request request = client.newRequest("https://api.example.com/data")
    .header("Authorization", "Bearer " + token)
    .header("Content-Type", "application/json")
    .header("Accept", "application/json")
    .header("User-Agent", "MyApp/1.0");

Using Consumer for Headers

Request request = client.newRequest("https://api.example.com/data")
    .headers(headers -> {
        headers.add("Authorization", "Bearer " + token);
        headers.add("Content-Type", "application/json");
        headers.add("Accept", "application/json");
        headers.add("X-Custom-Header", "custom-value");
    });

Setting All Headers at Once

HttpFields headers = HttpFields.build()
    .add("Authorization", "Bearer " + token)
    .add("Content-Type", "application/json")
    .add("Accept", "application/json");

Request request = client.newRequest("https://api.example.com/data")
    .headers(headers);

Cookie Configuration

Configure cookies for the request.

Adding Individual Cookies

HttpCookie sessionCookie = HttpCookie.build("JSESSIONID", "ABC123")
    .path("/")
    .secure(true)
    .build();
    
HttpCookie userCookie = HttpCookie.build("userId", "12345")
    .path("/")
    .build();

Request request = client.newRequest("https://api.example.com/data")
    .cookie(sessionCookie)
    .cookie(userCookie);

Creating Cookies with Builder

HttpCookie cookie = HttpCookie.build("preferences", "theme=dark;lang=en")
    .domain(".example.com")
    .path("/")
    .maxAge(Duration.ofDays(30))
    .secure(true)
    .httpOnly(true)
    .sameSite(HttpCookie.SameSite.STRICT)
    .build();

Request request = client.newRequest("https://api.example.com/user/profile")
    .cookie(cookie);

Timeout Configuration

Configure request timeout settings.

Request Timeout

// Timeout in milliseconds
Request request = client.newRequest("https://api.example.com/data")
    .timeout(5000, TimeUnit.MILLISECONDS);

// Timeout in seconds
Request request = client.newRequest("https://api.example.com/data")
    .timeout(30, TimeUnit.SECONDS);

// Timeout in minutes
Request request = client.newRequest("https://api.example.com/long-running")
    .timeout(5, TimeUnit.MINUTES);

No Timeout

Request request = client.newRequest("https://api.example.com/data")
    .timeout(0, TimeUnit.MILLISECONDS); // No timeout

HTTP Version Configuration

Configure the HTTP protocol version.

// HTTP/1.1 (default)
Request request = client.newRequest("https://api.example.com/data")
    .version(HttpVersion.HTTP_1_1);

// HTTP/2
Request request = client.newRequest("https://api.example.com/data")
    .version(HttpVersion.HTTP_2);

// HTTP/1.0
Request request = client.newRequest("https://api.example.com/data")
    .version(HttpVersion.HTTP_1_0);

Content Configuration

Configure request body content. See Content Management for detailed content options.

String Content

Request request = client.newRequest("https://api.example.com/users")
    .method(HttpMethod.POST)
    .content(new StringRequestContent("application/json", jsonData));

File Content

Path file = Paths.get("/path/to/file.json");
Request request = client.newRequest("https://api.example.com/upload")
    .method(HttpMethod.POST)
    .file(file);

Request Listeners

Configure listeners to monitor request lifecycle events.

Request Event Listeners

Request request = client.newRequest("https://api.example.com/data")
    .onRequestQueued(req -> System.out.println("Request queued"))
    .onRequestBegin(req -> System.out.println("Request begun"))
    .onRequestHeaders(req -> System.out.println("Request headers sent"))
    .onRequestSuccess(req -> System.out.println("Request succeeded"))
    .onRequestFailure((req, failure) -> System.err.println("Request failed: " + failure));

Response Event Listeners

Request request = client.newRequest("https://api.example.com/data")
    .onResponseBegin(resp -> System.out.println("Response begun"))
    .onResponseHeaders(resp -> System.out.println("Response headers received"))
    .onResponseContent((resp, content) -> {
        System.out.println("Received " + content.remaining() + " bytes");
    })
    .onResponseSuccess(resp -> System.out.println("Response succeeded"))
    .onResponseFailure((resp, failure) -> System.err.println("Response failed: " + failure));

Advanced Configuration Examples

Complete REST API Request

String jsonPayload = "{\"name\":\"John Doe\",\"email\":\"john@example.com\"}";

ContentResponse response = client.newRequest("https://api.example.com/users")
    .method(HttpMethod.POST)
    .header("Authorization", "Bearer " + authToken)
    .header("Content-Type", "application/json")
    .header("Accept", "application/json")
    .header("User-Agent", "MyApp/1.2.3")
    .timeout(10, TimeUnit.SECONDS)
    .content(new StringRequestContent(jsonPayload))
    .send();

File Upload with Custom Headers

Path uploadFile = Paths.get("/path/to/document.pdf");

ContentResponse response = client.newRequest("https://api.example.com/upload")
    .method(HttpMethod.POST)
    .header("Authorization", "Bearer " + authToken)
    .header("Content-Type", "application/pdf")
    .header("X-File-Name", uploadFile.getFileName().toString())
    .header("X-File-Size", String.valueOf(Files.size(uploadFile)))
    .timeout(5, TimeUnit.MINUTES)
    .file(uploadFile)
    .send();

Request with Custom Validation

Request request = client.newRequest("https://api.example.com/sensitive-data")
    .header("Authorization", "Bearer " + authToken)
    .onRequestBegin(req -> {
        // Validate authorization before sending
        if (!isValidToken(authToken)) {
            throw new IllegalStateException("Invalid authorization token");
        }
    })
    .onResponseHeaders(resp -> {
        // Validate response headers
        String contentType = resp.getHeaders().get("Content-Type");
        if (!"application/json".equals(contentType)) {
            throw new IllegalStateException("Unexpected content type: " + contentType);
        }
    });

ContentResponse response = request.send();

Install with Tessl CLI

npx tessl i tessl/maven-org-eclipse-jetty--jetty-client

docs

authentication.md

connection-pooling.md

content-management.md

http-operations.md

index.md

proxy-configuration.md

request-configuration.md

response-processing.md

tile.json

tessl/maven-org-eclipse-jetty--jetty-client