Set a Response Body in JAX-RS

1. Overview

To simplify the development of REST web services and their clients in Java, a standard and portable implementation of JAX-RS API has been designed which is called Jersey.

Jersey is an open source framework for developing REST web services that provide support for JAX-RS APIs and serves as a JAX-RS reference implementation.

In this tutorial, we’ll look at how we can set up a Jersey response body with different media types.

2. Maven Dependencies

First, we need the following dependencies included in the pom.xml file:

<dependency>
    <groupId>org.glassfish.jersey.bundles</groupId>
    <artifactId>jaxrs-ri</artifactId>
    <version>3.1.1</version>
</dependency>
<dependency>
    <groupId>org.glassfish.jersey.core</groupId>
    <artifactId>jersey-server</artifactId>
    <version>3.1.1</version>
</dependency>

The latest version of JAX-RS can be found  at jaxrs-ri, and Jersey server can be found at jersey-server

3. Response in Jersey

Naturally, there are different ways to build a response using Jersey, and we’ll look into how we can build them below.

All the examples here are HTTP GET requests, and we’ll be using the curl command to test the resources.

3.1. Ok Text Response

The endpoint shown here is a simple example of how plain text can be returned as a Jersey response:

@GET
@Path("/ok")
public Response getOkResponse() {

    String message = "This is a text response";

    return Response
      .status(Response.Status.OK)
      .entity(message)
      .build();
}

We can do an HTTP GET using curl to verify the response:

curl -XGET http://localhost:8080/jersey/response/ok

This endpoint will send back a response as follows:

This is a text response

When the media type isn’t specified, Jersey will default to text/plain.

3.2. Error Response

Errors can also be sent back as a Jersey response:

@GET
@Path("/not_ok")
public Response getNOkTextResponse() {

    String message = "There was an internal server error";

    return Response
      .status(Response.Status.INTERNAL_SERVER_ERROR)
      .entity(message)
      .build();
}

To verify the response, we can do an HTTP GET request using curl :

curl -XGET http://localhost:8080/jersey/response/not_ok

The error message will be sent back in the response:

There was an internal server error

3.3. Plain Text Response

We can also return simple plain text responses:

@GET
@Path("/text_plain")
public Response getTextResponseTypeDefined() {

    String message = "This is a plain text response";

    return Response
      .status(Response.Status.OK)
      .entity(message)
      .type(MediaType.TEXT_PLAIN)
      .build();
}

Again, we can do an HTTP GET using curl to verify the response:

curl -XGET http://localhost:8080/jersey/response/text_plain

The response will be as follows:

This is a plain text response

The same outcome could also be achieved via the Produces annotation instead of using the type() method in the Response:

@GET
@Path("/text_plain_annotation")
@Produces({ MediaType.TEXT_PLAIN })
public Response getTextResponseTypeAnnotated() {

    String message = "This is a plain text response via annotation";

    return Response
      .status(Response.Status.OK)
      .entity(message)
      .build();
}

We can do response verification using curl:

curl -XGET http://localhost:8080/jersey/response/text_plain_annotation

Here’s the response:

This is a plain text response via annotation

3.4. JSON Response Using POJO

A simple Plain Old Java Object (POJO) can also be used build a Jersey response.

We have a very simple Person POJO shown below, which we’ll use to build a response:

public class Person {
    String name;
    String address;

    // standard constructor
    // standard getters and setters
}

The Person POJO can now be used to return JSON as the Response body:

@GET
@Path("/pojo")
public Response getPojoResponse() {

    Person person = new Person("Abhinayak", "Nepal");

    return Response
      .status(Response.Status.OK)
      .entity(person)
      .build();
}

The working of this GET endpoint can be verified – via the following curl command:

curl -XGET http://localhost:8080/jersey/response/pojo

The Person POJO will be transformed into a JSON and sent back as a response:

{"address":"Nepal","name":"Abhinayak"}

3.5. JSON Response Using Simple String

We can use preformatted strings to create a response, and it can be done simply.

The following endpoint is an example of how a JSON represented as a String can be sent back as a JSON in the Jersey response:

@GET
@Path("/json")
public Response getJsonResponse() {

    String message = "{\"hello\": \"This is a JSON response\"}";

    return Response
      .status(Response.Status.OK)
      .entity(message)
      .type(MediaType.APPLICATION_JSON)
      .build();
}

This can be verified by doing an HTTP GET using curl to verify the response:

curl -XGET http://localhost:8080/jersey/response/json

Calling this resource will return a JSON:

{"hello":"This is a JSON response"}

The same pattern applies for other common media types like XML or HTML. We just need to notify Jersey that it’s an XML or HTML using MediaType.TEXT_XML or MediaType.TEXT_HTML and Jersey will handle the rest.

4. Conclusion

In this quick article, we constructed Jersey (JAX-RS) responses for a variety of media types.