使用 JsonObject 作为 Jersey 2 响应的实体

Question

I have this simple code:

package com.example

import javax.json.Json;
import javax.json.JsonObject;

...

@Path("/")
public class Resource {
    @GET
    @Produces(MediaType.APPLICATION_JSON)
    public Response defaultEntry() {
        JsonObject result = (Json.createObjectBuilder()
                             .add("hello", "world")
                             .build());

        return Response.status(200).entity(result.toString()).build();
    }
}

I am new to Java, could someone please explain why, if I omit the call to result.toString() and simply pass result to .entity (like so: return Response.status(200).entity(result).build() ), I get JSON on the client that includes type information etc, but not what I expected:

{"hello":{"chars":"world","string":"world","valueType":"STRING"}}

what is the intention of this? How is passing JsonObject to it different from passing a string?

Also, I did not find Response.entity method in the documentation ( https://jersey.java.net/apidocs/2.11/jersey/javax/ws/rs/core/Response.html ). I copied this code from a tutorial, that did not explain properly what is going on...

Answer 1

I wish I had a better answer for you, this more of a hint until a better answer arrives. There are a few moving parts here. JsonObject is an interface. Its implementation is not described. Furthermore there is a Json serializer that is turning your returned objects into Json text. It is both these things together that is leading to this Json schema output. When you did the .toString() variation, the serializer just returned the String as is. But when you return the JsonObject now you have these two dynamics at play, the implementation of the JsonObject and the implementation of the serializer. Since you are using Jersey 2.0 you could be using Jackson, Moxy, or Jettison serializers. These all might have different output when serializing the JsonObject, but we would have to test to be sure. Furthermore, the JsonObject implementation might be configured in a way that when serialized by your chosen serializer leads to its output being a Json schema, versus just regular Json. This can be done using annotations that are specific to the chosen Json serializer.

In my career I have used multiple Json serializers. Jackson is probably the most popular one out there. But I have also used Gson extensively. In one project we configured Gson in some way where its serialized Json output came out as a Json schema when serializing POJO's. So its not far fetched to have a Json serializer output Json schema under certain conditions.

When serializing POJO's (aka Java Beans), you expect a regular Json output when using default settings of your serializer on a Java Bean. But when sending back objects that could have complex interworkings with specific Json serializers you may get varying Json output.

In this situation you would have to run tests to dive deeper into what is going on. For example, I would first test out the serializer against a POJO that matches the JsonObject you created. Then I would also test out other Json serializers on the same JsonObject. See if you can pick up on a pattern.

Answer 2

The datatype module jackson-datatype-jsr353 provides support for javax.json types. The page includes instructions how to add the dependency and register the module with Jackson's ObjectMapper .

Starting with Jackson 2.11.0, the module moved under the umbrella of jackson-datatypes-misc .