tessl/maven-org-glassfish-jersey-core--jersey-client
Jersey core client implementation for building RESTful web service clients using JAX-RS API
—
Pending
request-execution.mddocs/
Request Execution
HTTP request building and execution capabilities providing comprehensive support for all standard HTTP methods, custom headers, query parameters, request entities, and both synchronous and asynchronous operations. This functionality forms the core of Jersey Client's HTTP communication capabilities.
Capabilities
Web Target
URI building and template resolution for constructing request endpoints with path segments, query parameters, matrix parameters, and URI template resolution.
public class JerseyWebTarget implements WebTarget {
/**
* Get the resolved URI for this web target
* @return resolved URI
*/
URI getUri();
/**
* Get URI builder for this web target
* @return URI builder instance
*/
UriBuilder getUriBuilder();
/**
* Append path segment to the URI
* @param path path segment to append
* @return new web target with appended path
*/
JerseyWebTarget path(String path);
/**
* Add matrix parameter to the URI
* @param name parameter name
* @param values parameter values
* @return new web target with matrix parameter
*/
JerseyWebTarget matrixParam(String name, Object... values);
/**
* Add query parameter to the URI
* @param name parameter name
* @param values parameter values
* @return new web target with query parameter
*/
JerseyWebTarget queryParam(String name, Object... values);
/**
* Create request builder for this web target
* @return request builder instance
*/
JerseyInvocation.Builder request();
/**
* Create request builder with Accept header
* @param acceptedResponseTypes accepted media types
* @return request builder with Accept header set
*/
JerseyInvocation.Builder request(String... acceptedResponseTypes);
/**
* Create request builder with Accept header
* @param acceptedResponseTypes accepted media types
* @return request builder with Accept header set
*/
JerseyInvocation.Builder request(MediaType... acceptedResponseTypes);
/**
* Resolve URI template parameter
* @param name template parameter name
* @param value parameter value
* @return new web target with resolved template
*/
JerseyWebTarget resolveTemplate(String name, Object value);
/**
* Resolve URI template parameter with encoding control
* @param name template parameter name
* @param value parameter value
* @param encodeSlashInPath whether to encode slash characters
* @return new web target with resolved template
*/
JerseyWebTarget resolveTemplate(String name, Object value, boolean encodeSlashInPath);
/**
* Resolve URI template parameter from encoded value
* @param name template parameter name
* @param value pre-encoded parameter value
* @return new web target with resolved template
*/
JerseyWebTarget resolveTemplateFromEncoded(String name, Object value);
/**
* Resolve multiple URI template parameters
* @param templateValues map of template parameter names to values
* @return new web target with resolved templates
*/
JerseyWebTarget resolveTemplates(Map<String, Object> templateValues);
/**
* Resolve multiple URI template parameters with encoding control
* @param templateValues map of template parameter names to values
* @param encodeSlashInPath whether to encode slash characters
* @return new web target with resolved templates
*/
JerseyWebTarget resolveTemplates(Map<String, Object> templateValues, boolean encodeSlashInPath);
/**
* Resolve multiple URI template parameters from encoded values
* @param templateValues map of template parameter names to pre-encoded values
* @return new web target with resolved templates
*/
JerseyWebTarget resolveTemplatesFromEncoded(Map<String, Object> templateValues);
/**
* Register provider class with this web target
* @param providerClass provider class to register
* @return new web target with registered provider
*/
JerseyWebTarget register(Class<?> providerClass);
/**
* Register provider instance with this web target
* @param provider provider instance to register
* @return new web target with registered provider
*/
JerseyWebTarget register(Object provider);
/**
* Set configuration property for this web target
* @param name property name
* @param value property value
* @return new web target with property set
*/
JerseyWebTarget property(String name, Object value);
/**
* Get configuration for this web target
* @return configuration instance
*/
ClientConfig getConfiguration();
}Usage Examples:
import jakarta.ws.rs.client.WebTarget;
import jakarta.ws.rs.core.MediaType;
// Basic URI building
WebTarget target = client.target("https://api.example.com");
WebTarget usersTarget = target.path("users").path("{id}");
// Query and matrix parameters
WebTarget searchTarget = target.path("search")
.queryParam("q", "jersey client")
.queryParam("limit", 10)
.matrixParam("version", "v1");
// URI template resolution
WebTarget userTarget = usersTarget.resolveTemplate("id", 123);
// Results in: https://api.example.com/users/123
// Multiple template resolution
Map<String, Object> templates = new HashMap<>();
templates.put("userId", 123);
templates.put("resourceId", 456);
WebTarget resourceTarget = target.path("users/{userId}/resources/{resourceId}")
.resolveTemplates(templates);Request Building
Request builder for configuring HTTP requests with headers, cookies, caching directives, and content negotiation settings.
public static class JerseyInvocation.Builder implements Invocation.Builder {
/**
* Set Accept header for content negotiation
* @param mediaTypes accepted media types
* @return this builder instance
*/
Builder accept(String... mediaTypes);
/**
* Set Accept header for content negotiation
* @param mediaTypes accepted media types
* @return this builder instance
*/
Builder accept(MediaType... mediaTypes);
/**
* Set Accept-Encoding header
* @param encodings accepted encodings
* @return this builder instance
*/
Invocation.Builder acceptEncoding(String... encodings);
/**
* Set Accept-Language header
* @param locales accepted locales
* @return this builder instance
*/
Builder acceptLanguage(Locale... locales);
/**
* Set Accept-Language header
* @param locales accepted language tags
* @return this builder instance
*/
Builder acceptLanguage(String... locales);
/**
* Add cookie to the request
* @param cookie cookie to add
* @return this builder instance
*/
Builder cookie(Cookie cookie);
/**
* Add cookie to the request
* @param name cookie name
* @param value cookie value
* @return this builder instance
*/
Builder cookie(String name, String value);
/**
* Set Cache-Control header
* @param cacheControl cache control directives
* @return this builder instance
*/
Builder cacheControl(CacheControl cacheControl);
/**
* Add custom header to the request
* @param name header name
* @param value header value
* @return this builder instance
*/
Builder header(String name, Object value);
/**
* Set multiple headers from map
* @param headers map of header names to values
* @return this builder instance
*/
Builder headers(MultivaluedMap<String, Object> headers);
/**
* Set configuration property for this request
* @param name property name
* @param value property value
* @return this builder instance
*/
Builder property(String name, Object value);
}Synchronous Request Execution
Synchronous HTTP request execution methods for all standard HTTP methods with support for typed responses and request entities.
public static class JerseyInvocation.Builder implements Invocation.Builder {
/**
* Execute GET request
* @return HTTP response
*/
Response get();
/**
* Execute GET request with typed response
* @param responseType expected response type
* @return typed response entity
*/
<T> T get(Class<T> responseType);
/**
* Execute GET request with generic typed response
* @param responseType expected generic response type
* @return typed response entity
*/
<T> T get(GenericType<T> responseType);
/**
* Execute POST request with entity
* @param entity request entity
* @return HTTP response
*/
Response post(Entity<?> entity);
/**
* Execute POST request with entity and typed response
* @param entity request entity
* @param responseType expected response type
* @return typed response entity
*/
<T> T post(Entity<?> entity, Class<T> responseType);
/**
* Execute POST request with entity and generic typed response
* @param entity request entity
* @param responseType expected generic response type
* @return typed response entity
*/
<T> T post(Entity<?> entity, GenericType<T> responseType);
/**
* Execute PUT request with entity
* @param entity request entity
* @return HTTP response
*/
Response put(Entity<?> entity);
/**
* Execute PUT request with entity and typed response
* @param entity request entity
* @param responseType expected response type
* @return typed response entity
*/
<T> T put(Entity<?> entity, Class<T> responseType);
/**
* Execute PUT request with entity and generic typed response
* @param entity request entity
* @param responseType expected generic response type
* @return typed response entity
*/
<T> T put(Entity<?> entity, GenericType<T> responseType);
/**
* Execute DELETE request
* @return HTTP response
*/
Response delete();
/**
* Execute DELETE request with typed response
* @param responseType expected response type
* @return typed response entity
*/
<T> T delete(Class<T> responseType);
/**
* Execute DELETE request with generic typed response
* @param responseType expected generic response type
* @return typed response entity
*/
<T> T delete(GenericType<T> responseType);
/**
* Execute HEAD request
* @return HTTP response
*/
Response head();
/**
* Execute OPTIONS request
* @return HTTP response
*/
Response options();
/**
* Execute OPTIONS request with typed response
* @param responseType expected response type
* @return typed response entity
*/
<T> T options(Class<T> responseType);
/**
* Execute OPTIONS request with generic typed response
* @param responseType expected generic response type
* @return typed response entity
*/
<T> T options(GenericType<T> responseType);
/**
* Execute TRACE request
* @return HTTP response
*/
Response trace();
/**
* Execute TRACE request with typed response
* @param responseType expected response type
* @return typed response entity
*/
<T> T trace(Class<T> responseType);
/**
* Execute TRACE request with generic typed response
* @param responseType expected generic response type
* @return typed response entity
*/
<T> T trace(GenericType<T> responseType);
/**
* Execute custom HTTP method request
* @param name HTTP method name
* @return HTTP response
*/
Response method(String name);
/**
* Execute custom HTTP method request with typed response
* @param name HTTP method name
* @param responseType expected response type
* @return typed response entity
*/
<T> T method(String name, Class<T> responseType);
/**
* Execute custom HTTP method request with generic typed response
* @param name HTTP method name
* @param responseType expected generic response type
* @return typed response entity
*/
<T> T method(String name, GenericType<T> responseType);
/**
* Execute custom HTTP method request with entity
* @param name HTTP method name
* @param entity request entity
* @return HTTP response
*/
Response method(String name, Entity<?> entity);
/**
* Execute custom HTTP method request with entity and typed response
* @param name HTTP method name
* @param entity request entity
* @param responseType expected response type
* @return typed response entity
*/
<T> T method(String name, Entity<?> entity, Class<T> responseType);
/**
* Execute custom HTTP method request with entity and generic typed response
* @param name HTTP method name
* @param entity request entity
* @param responseType expected generic response type
* @return typed response entity
*/
<T> T method(String name, Entity<?> entity, GenericType<T> responseType);
}Usage Examples:
import jakarta.ws.rs.core.Response;
import jakarta.ws.rs.core.MediaType;
import jakarta.ws.rs.client.Entity;
// Simple GET request
Response response = target.path("users").request().get();
if (response.getStatus() == 200) {
String json = response.readEntity(String.class);
}
// GET with typed response
User user = target.path("users/123")
.request(MediaType.APPLICATION_JSON)
.get(User.class);
// POST with entity
User newUser = new User("John", "john@example.com");
Response postResponse = target.path("users")
.request()
.post(Entity.json(newUser));
// PUT with entity and typed response
User updatedUser = target.path("users/123")
.request()
.put(Entity.json(updateData), User.class);
// Custom headers and content negotiation
List<Product> products = target.path("products")
.queryParam("category", "electronics")
.request(MediaType.APPLICATION_JSON)
.header("X-API-Key", "your-api-key")
.accept(MediaType.APPLICATION_JSON)
.get(new GenericType<List<Product>>() {});Asynchronous Request Execution
Asynchronous HTTP request execution using Future-based and callback-based approaches for non-blocking operations.
public class JerseyInvocation implements Invocation {
/**
* Submit request for asynchronous execution
* @return Future representing the response
*/
Future<Response> submit();
/**
* Submit request for asynchronous execution with typed response
* @param responseType expected response type
* @return Future representing the typed response
*/
<T> Future<T> submit(Class<T> responseType);
/**
* Submit request for asynchronous execution with generic typed response
* @param responseType expected generic response type
* @return Future representing the typed response
*/
<T> Future<T> submit(GenericType<T> responseType);
/**
* Submit request for asynchronous execution with callback
* @param callback invocation callback for handling response/errors
* @return Future representing the response
*/
<T> Future<T> submit(InvocationCallback<T> callback);
/**
* Submit request for asynchronous execution with callback and generic type
* @param responseType expected generic response type
* @param callback invocation callback for handling response/errors
* @return Future representing the typed response
*/
<T> Future<T> submit(GenericType<T> responseType, InvocationCallback<T> callback);
}
// Async invoker for request builder
public static class JerseyInvocation.Builder implements Invocation.Builder {
/**
* Get asynchronous invoker for this request
* @return async invoker instance
*/
jakarta.ws.rs.client.AsyncInvoker async();
}Usage Examples:
import jakarta.ws.rs.client.InvocationCallback;
import java.util.concurrent.Future;
// Future-based async execution
Future<Response> futureResponse = target.path("users")
.request()
.buildGet()
.submit();
// Process when ready
Response response = futureResponse.get(); // blocks until complete
// Callback-based async execution
target.path("users/123")
.request()
.async()
.get(new InvocationCallback<User>() {
@Override
public void completed(User user) {
System.out.println("Received user: " + user.getName());
}
@Override
public void failed(Throwable throwable) {
System.err.println("Request failed: " + throwable.getMessage());
}
});
// Async POST with callback
target.path("users")
.request()
.async()
.post(Entity.json(newUser), new InvocationCallback<Response>() {
@Override
public void completed(Response response) {
if (response.getStatus() == 201) {
System.out.println("User created successfully");
}
}
@Override
public void failed(Throwable throwable) {
System.err.println("Failed to create user: " + throwable.getMessage());
}
});Reactive Request Execution
Reactive HTTP request execution using CompletionStage for composable asynchronous operations.
public static class JerseyInvocation.Builder implements Invocation.Builder {
/**
* Get reactive invoker using CompletionStage
* @return CompletionStage-based reactive invoker
*/
CompletionStageRxInvoker rx();
/**
* Get reactive invoker for specific RxInvoker type
* @param clazz RxInvoker implementation class
* @return typed reactive invoker
*/
<T extends RxInvoker> T rx(Class<T> clazz);
}
public class JerseyCompletionStageRxInvoker implements CompletionStageRxInvoker {
// Reactive methods returning CompletionStage for all HTTP methods
// Implementation details are package-private, accessed via rx() method
}Usage Examples:
import java.util.concurrent.CompletionStage;
// Reactive GET request
CompletionStage<Response> completionStage = target.path("users")
.request()
.rx()
.get();
// Chain reactive operations
completionStage
.thenApply(response -> response.readEntity(String.class))
.thenAccept(json -> System.out.println("Response: " + json))
.exceptionally(throwable -> {
System.err.println("Request failed: " + throwable.getMessage());
return null;
});
// Reactive POST with typed response
target.path("users")
.request()
.rx()
.post(Entity.json(newUser), User.class)
.thenCompose(user -> {
// Chain another request
return target.path("users/" + user.getId() + "/profile")
.request()
.rx()
.get(UserProfile.class);
})
.thenAccept(profile -> System.out.println("User profile: " + profile));Invocation Building
Low-level invocation building for creating reusable request templates that can be executed multiple times.
public static class JerseyInvocation.Builder implements Invocation.Builder {
/**
* Build invocation for custom HTTP method
* @param method HTTP method name
* @return invocation instance
*/
JerseyInvocation build(String method);
/**
* Build invocation for custom HTTP method with entity
* @param method HTTP method name
* @param entity request entity
* @return invocation instance
*/
JerseyInvocation build(String method, Entity<?> entity);
/**
* Build GET invocation
* @return GET invocation instance
*/
JerseyInvocation buildGet();
/**
* Build DELETE invocation
* @return DELETE invocation instance
*/
JerseyInvocation buildDelete();
/**
* Build POST invocation with entity
* @param entity request entity
* @return POST invocation instance
*/
JerseyInvocation buildPost(Entity<?> entity);
/**
* Build PUT invocation with entity
* @param entity request entity
* @return PUT invocation instance
*/
JerseyInvocation buildPut(Entity<?> entity);
}
public class JerseyInvocation implements Invocation {
/**
* Execute the invocation synchronously
* @return HTTP response
*/
Response invoke();
/**
* Execute the invocation synchronously with typed response
* @param responseType expected response type
* @return typed response entity
*/
<T> T invoke(Class<T> responseType);
/**
* Execute the invocation synchronously with generic typed response
* @param responseType expected generic response type
* @return typed response entity
*/
<T> T invoke(GenericType<T> responseType);
}Usage Examples:
// Build reusable invocations
Invocation getUserInvocation = target.path("users/{id}")
.resolveTemplate("id", 123)
.request(MediaType.APPLICATION_JSON)
.buildGet();
// Execute multiple times
Response response1 = getUserInvocation.invoke();
Response response2 = getUserInvocation.invoke(); // Can reuse
// Build POST invocation template
Invocation createUserInvocation = target.path("users")
.request()
.buildPost(Entity.json(newUser));
// Execute and get typed response
User createdUser = createUserInvocation.invoke(User.class);Install with Tessl CLI
npx tessl i tessl/maven-org-glassfish-jersey-core--jersey-client