Eclipse Jetty HTTP Client

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

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();
}

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);
}

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);
}

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();
}

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;

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;

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;

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;

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();
}

// 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 {}

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();
}