Jersey client API for reading chunked input

 

Jersey client API for reading chunked input

To read the chunked input on the client, Jersey offers the org.glassfish.jersey.client.ChunkedInput<T>class. Here is a client example that reads the employee list in chunks, as returned by the server:

//Other imports omitted for brevity 
import org.glassfish.jersey.media.sse.EventInput; 
import javax.ws.rs.client.ClientBuilder; 
 
String BASE_URI = "http://localhost:8080/hr-app/api"; 
Client client = ClientBuilder.newClient(); 
Response response = client.target().path("employees") 
   .path("chunk").request().get(); 
ChunkedInput<List<Employee>> chunks = response 
    .readEntity(new GenericType<ChunkedInput<List<Employee>>>(){}); 
List<Employee> chunk; 
while ((chunk = chunks.read()) != null) { 
  //Code to process List<Employee> received in chunks goes here  
} 
//Close the client after use 
client.close();

Having discussed chunked output and input, we now will move on to another exciting feature offered by the Jersey framework, which allows the RESTful web APIs to push notifications to clients.


























Comments

Post a Comment

Popular posts from this blog

Understanding the JAX-RS resource life cycle

Image
Understanding the JAX-RS resource life cycle The following diagram depicts the sequence of actions taking place on the server when a client invokes the JAX-RS RESTful web service: For an incoming REST API call, the container identifies the Java servlet configured for handling the REST API calls by parsing the URI, and then delegates the request to the designated servlet. The servlet initializes the JAX-RS runtime and kicks off the RESTful web service request processing cycle for the REST API call in the following sequence: The runtime executes prematching filters ( ContainerRequestFilter  with the  @Prematching  annotation), which happens before resolving the resource method. The prematching filters are useful if you want to influence resource method resolution. The next step is to identify the resource method for serving the request. After the resolution of the resource method, postmatching filters are executed (filters without  @Prematching ). Postmatching filters ...
Read more

Building JAX-RS clients with basic authentication

Image
  Building JAX-RS clients with basic authentication A normal client-server transaction can follow two scenarios of basic authentication. On one hand, a client submits a request to the server without any authentication credentials (as depicted in the previous sequence diagram). On the other hand, a client submits a request to the server with the authentication credentials. Let's take a closer look at these two scenarios. When a client submits a request without the authentication credentials, the server responds back stating unauthorized access with an HTTP error code of  401 . If the request is executed from a web browser, users see the ubiquitous  Authentication Required  browser popup, as shown here: Users can then supply the valid credentials to complete the request. Note that the web browser keeps track of the 401 response and is charged with sending the proper authentication credentials back with the original URI. This makes the transaction seamless for the users...
Read more

Generating a chunked output using Jersey APIs

  Generating a chunked output using Jersey APIs A chunked response means that instead of waiting for the entire result, the results are   split  into chunks (partial results) and sent one after the other. Sending a response in chunks is useful for a RESTful web API if the resource returned by the API is huge in size. With Jersey, you can use the  org.glassfish.jersey.server.ChunkedOutput  class as the return type to send the response to a client in chunks. The chunked output content can be any data type for which  MessageBodyWriter<T>  (entity provider) is available. When you specify  ChunkedOutput  as the return type for a REST resource method, it tells the runtime that the response will be chunked and sent one by one to the client. Seeing  ChunkedOutput  as the return type for a method, Jersey will switch to the asynchronous processing mode while processing this method at runtime, without you having to explicitly use  A...
Read more