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

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Securityby

Pending

The risk profile of this skill

Overview

Eval results

Files

Eclipse Jetty HTTP Client

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

Eclipse Jetty HTTP Client is a comprehensive, asynchronous HTTP client library for Java that provides high-performance network communication capabilities. It supports modern web protocols including HTTP/1.1, HTTP/2, and WebSocket connections, with built-in authentication mechanisms, proxy configurations, and sophisticated connection pooling strategies.

Package Information

Package Name: org.eclipse.jetty:jetty-client
Package Type: Maven
Language: Java
Installation: Add to your Maven pom.xml:
```
<dependency>
  <groupId>org.eclipse.jetty</groupId>
  <artifactId>jetty-client</artifactId>
  <version>12.0.21</version>
</dependency>
```

Core Imports

import org.eclipse.jetty.client.HttpClient;
import org.eclipse.jetty.client.Request;
import org.eclipse.jetty.client.Response;
import org.eclipse.jetty.client.ContentResponse;

Basic Usage

import org.eclipse.jetty.client.HttpClient;
import org.eclipse.jetty.client.ContentResponse;

// Create and start the HTTP client
HttpClient httpClient = new HttpClient();
httpClient.start();

try {
    // Simple GET request (synchronous)
    ContentResponse response = httpClient.GET("https://api.example.com/data");
    System.out.println("Status: " + response.getStatus());
    System.out.println("Content: " + response.getContentAsString());
    
    // POST request with JSON content
    ContentResponse postResponse = httpClient.POST("https://api.example.com/users")
        .header("Content-Type", "application/json")
        .body(new StringRequestContent("{\"name\":\"John\",\"email\":\"john@example.com\"}"))
        .send();
        
    // Asynchronous request with callback
    httpClient.newRequest("https://api.example.com/async")
        .send(result -> {
            if (result.isSucceeded()) {
                Response response = result.getResponse();
                System.out.println("Async response status: " + response.getStatus());
            }
        });
        
} finally {
    // Always stop the client when done
    httpClient.stop();
}

Architecture

The Jetty HTTP Client is built around several key components:

HttpClient: Central configuration point and request factory
Request/Response Model: Fluent API for building and handling HTTP requests/responses
Transport Layer: Pluggable transport implementations (HTTP/1.1, HTTP/2, WebSocket)
Connection Management: Multiple connection pool strategies for different use cases
Content Processing: Flexible content handling for request bodies and response processing
Authentication System: Support for Basic, Digest, and SPNEGO authentication
Protocol Handlers: Automatic handling of redirects, authentication challenges, and upgrades

Capabilities

Core HTTP Operations

Essential HTTP client functionality for making GET, POST, PUT, DELETE and other HTTP requests with full request/response lifecycle management.

public class HttpClient extends ContainerLifeCycle {
    public HttpClient();
    public void start() throws Exception;
    public void stop() throws Exception;
    
    public ContentResponse GET(String uri) throws InterruptedException, ExecutionException, TimeoutException;
    public ContentResponse GET(URI uri) throws InterruptedException, ExecutionException, TimeoutException;
    public Request POST(String uri);
    public Request POST(URI uri);
    public Request newRequest(String uri);
    public Request newRequest(URI uri);
    public Request newRequest(String host, int port);
}

HTTP Operations

Request Configuration

Fluent API for configuring HTTP requests including headers, timeouts, content, cookies, and HTTP methods with comprehensive customization options.

public interface Request {
    Request scheme(String scheme);
    Request host(String host);
    Request port(int port);
    Request path(String path);
    Request method(HttpMethod method);
    Request method(String method);
    Request version(HttpVersion version);
    Request timeout(long timeout, TimeUnit unit);
    Request header(String name, String value);
    Request cookie(HttpCookie cookie);
    Request body(Content content);
    
    ContentResponse send() throws InterruptedException, ExecutionException, TimeoutException;
    void send(Response.CompleteListener listener);
}

Request Configuration

Response Processing

Comprehensive response handling including status codes, headers, content processing, and streaming capabilities with multiple listener patterns.

public interface Response {
    Request getRequest();
    HttpVersion getVersion();
    int getStatus();
    String getReason();
    HttpFields getHeaders();
    HttpFields getTrailers();
}

public interface ContentResponse extends Response {
    String getMediaType();
    String getEncoding();
    byte[] getContent();
    String getContentAsString();
}

Response Processing

Content Management

Flexible content handling for request bodies and response processing, supporting strings, byte arrays, streams, files, forms, and multipart data.

public class StringRequestContent extends BytesRequestContent;
public class BytesRequestContent extends ByteBufferRequestContent;
public class InputStreamRequestContent implements Request.Content;
public class PathRequestContent implements Request.Content;
public class FormRequestContent implements Request.Content;
public class MultiPartRequestContent implements Request.Content;

Content Management

Authentication

Support for HTTP authentication mechanisms including Basic, Digest, and SPNEGO/Kerberos with credential storage and automatic challenge handling.

public interface AuthenticationStore {
    void addAuthentication(Authentication authentication);
    void removeAuthentication(Authentication authentication);
    AuthenticationResult findAuthenticationResult(URI uri);
}

public class BasicAuthentication implements Authentication;
public class DigestAuthentication implements Authentication;
public class SPNEGOAuthentication implements Authentication;

Authentication

Proxy Configuration

Comprehensive proxy support including HTTP, SOCKS4, and SOCKS5 proxies with authentication and per-destination configuration.

public class ProxyConfiguration {
    public void addProxy(Proxy proxy);
    public boolean removeProxy(Proxy proxy);
    public List<Proxy> getProxies();
}

public class HttpProxy extends ProxyConfiguration.Proxy;
public class Socks4Proxy extends ProxyConfiguration.Proxy;
public class Socks5Proxy extends ProxyConfiguration.Proxy;

Proxy Configuration

Connection Pooling

Multiple connection pool strategies for optimizing connection reuse and performance including duplex, multiplex, round-robin, and random selection pools.

public interface ConnectionPool {
    Connection acquire(boolean create);
    boolean release(Connection connection);
    boolean remove(Connection connection);
}

public class DuplexConnectionPool implements ConnectionPool;
public class MultiplexConnectionPool implements ConnectionPool;
public class RoundRobinConnectionPool implements ConnectionPool;

Connection Pooling

Types

Core Types

public interface Request {
    interface Listener extends EventListener {
        default void onQueued(Request request) {}
        default void onBegin(Request request) {}
        default void onHeaders(Request request) {}
        default void onCommit(Request request) {}
        default void onContent(Request request, ByteBuffer content) {}
        default void onSuccess(Request request) {}
        default void onFailure(Request request, Throwable failure) {}
    }
    
    interface Content {
        String getContentType();
        long getLength();
        boolean isReproducible();
    }
}

public interface Response {
    interface Listener extends EventListener {
        default void onBegin(Response response) {}
        default void onHeader(Response response, HttpField field) {}
        default void onHeaders(Response response) {}
        default void onContent(Response response, ByteBuffer content) {}
        default void onSuccess(Response response) {}
        default void onFailure(Response response, Throwable failure) {}
        default void onComplete(Result result) {}
    }
    
    interface CompleteListener extends Listener {
        void onComplete(Result result);
    }
}

public interface Result {
    Request getRequest();
    Response getResponse();
    Throwable getRequestFailure();
    Throwable getResponseFailure();
    boolean isSucceeded();
    boolean isFailed();
}

HTTP Types

// From org.eclipse.jetty.http package (external dependency)
public enum HttpMethod { GET, POST, PUT, DELETE, HEAD, OPTIONS, TRACE, CONNECT, PATCH }
public enum HttpVersion { HTTP_1_0, HTTP_1_1, HTTP_2, HTTP_3 }
public class HttpFields implements Iterable<HttpField> {}
public class HttpField {}
public class HttpCookie {}

Configuration Types

public class Origin {
    public Origin(String scheme, String host, int port);
    public String getScheme();
    public String getHost();
    public int getPort();
}

public class ProxyConfiguration.Proxy {
    public Origin.Address getAddress();
    public boolean isSecure();
    public Set<String> getIncludedAddresses();
    public Set<String> getExcludedAddresses();
}

Workspace: tessl
Visibility: Public
Created: 6 months ago
Last updated: 2 months ago
Describes: pkg:maven/org.eclipse.jetty/jetty-client@12.0.x
Publish Source: CLI
Badge