Converting ZonedDateTime type to Gson

Question

I have rest service that return arraylist of object,and I have implemented jersy restful client to execute it,but I have problem in converting ZonedDateTime type to json so I get this error

 Caused by: java.lang.IllegalStateException: Expected BEGIN_OBJECT but was STRING at line 1 column 231 path $[0].lastmodifieddate

How can i fix this problem?

lastmodifieddate column in entity

 @Column(name = "lastmodifieddate")
 private ZonedDateTime lastmodifieddate;

 //getter and setter

rest service

@RequestMapping(value = "/getScoreFactor",
        method = RequestMethod.GET,
        produces = MediaType.APPLICATION_JSON_VALUE)
@Timed
public List<Scorefactor> getScoreFactor() throws JSONException {
    return scoreService.getScoreFactor();
}

jersy restful client

  try {

        Client client = Client.create();
        WebResource webResource = client
           .resource("http://localhost:8080/adap/api/getScoreFactor");
        ClientResponse response = webResource.accept("application/json")
                   .get(ClientResponse.class);

        String output =  response.getEntity(String.class);

        System.out.println("output--"+output);
        Type listType =  new TypeToken<List<Scorefactor>>() {}.getType();

        List<Scorefactor> scorefactors = new Gson().fromJson(output,listType);

        System.out.println(scorefactors);

    } catch (Exception e) {

        e.printStackTrace();

}

Possible duplicate of [Java 8 LocalDateTime deserialized using Gson](http://stackoverflow.com/questions/22310143/java-8-localdatetime-deserialized-using-gson) — andersschuller, Apr 04 '16 at 17:44

pomo · Answer 1 · 2017-10-13T09:15:45.860

public static final Gson GSON = new GsonBuilder()
    .registerTypeAdapter(ZonedDateTime.class, new TypeAdapter<ZonedDateTime>() {
        @Override
        public void write(JsonWriter out, ZonedDateTime value) throws IOException {
            out.value(value.toString());
        }

        @Override
        public ZonedDateTime read(JsonReader in) throws IOException {
            return ZonedDateTime.parse(in.nextString());
        }
    })
    .enableComplexMapKeySerialization()
    .create();

score 11 · Accepted Answer · answered Apr 05 '16 at 11:23

I have fixed it,This is the code after updates

Client client = Client.create();
        WebResource webResource = client
           .resource("http://localhost:8080/adap/api/getScoreFactor");
        ClientResponse response = webResource.accept("application/json")
                   .get(ClientResponse.class);

        String output =  response.getEntity(String.class);

        Gson gson = new GsonBuilder().registerTypeAdapter(ZonedDateTime.class, new JsonDeserializer<ZonedDateTime>() {
            @Override
            public ZonedDateTime deserialize(JsonElement json, Type type, JsonDeserializationContext jsonDeserializationContext) throws JsonParseException {
                return ZonedDateTime.parse(json.getAsJsonPrimitive().getAsString());
            }
            }).create();

        Type listType =  new TypeToken<List<Scorefactor>>() {}.getType();

        List<Scorefactor> scorefactors = gson.fromJson(output,listType);

score 7 · Answer 3 · answered Apr 05 '16 at 06:37

There are at least two ways to achieve this:

1) Gson with JsonDeserializer

Little changes within your code:

Type listType =  new TypeToken<List<Scorefactor>>() {}.getType();
List<Scorefactor> scorefactors = new GsonBuilder()
            .registerTypeAdapter(ZonedDateTime.class, GsonHelper.ZDT_DESERIALIZER)
            .create()
            .fromJson(output, listType);

Helper Class

class GsonHelper {

    public static final JsonDeserializer<ZonedDateTime> ZDT_DESERIALIZER = new JsonDeserializer<ZonedDateTime>() {
        @Override
        public ZonedDateTime deserialize(final JsonElement json, final Type typeOfT, final JsonDeserializationContext context) throws JsonParseException {
            JsonPrimitive jsonPrimitive = json.getAsJsonPrimitive();
            try {

                // if provided as String - '2011-12-03T10:15:30+01:00[Europe/Paris]'
                if(jsonPrimitive.isString()){
                    return ZonedDateTime.parse(jsonPrimitive.getAsString(), DateTimeFormatter.ISO_ZONED_DATE_TIME);
                }

                // if provided as Long
                if(jsonPrimitive.isNumber()){
                    return ZonedDateTime.ofInstant(Instant.ofEpochMilli(jsonPrimitive.getAsLong()), ZoneId.systemDefault());
                }

            } catch(RuntimeException e){
                throw new JsonParseException("Unable to parse ZonedDateTime", e);
            }
            throw new JsonParseException("Unable to parse ZonedDateTime");
        }
    };

}

2) Use MessageBodyReader & XMLAdapter

Changes for your Client implementation:

ClientConfig config = new DefaultClientConfig();
config.getFeatures().put(JSONConfiguration.FEATURE_POJO_MAPPING, Boolean.TRUE);
Client client = Client.create(config);

List<Scorefactor> result = client.resource("http://localhost:8080/adap/api/getScoreFactor"")
                .accept("application/json")
                .get(ClientResponse.class)
                .getEntity(new GenericType<List<Scorefactor>>(){});

System.out.println(result);

You might need to import jersey-json for this

<dependency>
    <groupId>com.sun.jersey</groupId>
    <artifactId>jersey-bundle</artifactId>
    <version>1.19.1</version>
</dependency>
<dependency>
    <groupId>com.sun.jersey</groupId>
    <artifactId>jersey-json</artifactId>
    <version>1.19.1</version>
</dependency>

Btw, why do you use 1.*?

Your Scorefactor

@XmlRootElement
@XmlAccessorType(XmlAccessType.FIELD)
public class Scorefactor implements Serializable {

    @Column(name = "lastmodifieddate")
    @XmlElement(name = "lastmodifieddate")
    @XmlJavaTypeAdapter(ZonedDateTimeToStringXmlAdapter.class)
    private ZonedDateTime lastmodifieddate;

    //...

ZonedDateTime from / to String (recommended)

public class ZonedDateTimeToStringXmlAdapter extends XmlAdapter<String, ZonedDateTime> {

    @Override
    public ZonedDateTime unmarshal(final String v) throws DateTimeParseException {
        return ZonedDateTime.parse(v);
    }

    @Override
    public String marshal(final ZonedDateTime v) throws Exception {
        return v.toString();
    }

}

ZonedDateTime from / to Long

public class ZonedDateTimeToLongXmlAdapter extends XmlAdapter<Long, ZonedDateTime> {

    @Override
    public ZonedDateTime unmarshal(final Long v) throws DateTimeParseException {
        return ZonedDateTime.ofInstant(Instant.ofEpochMilli(v.longValue()), ZoneId.systemDefault()); 
    }

    @Override
    public Long marshal(final ZonedDateTime v) throws Exception {
        return Long.valueOf(v.toInstant().toEpochMilli());
    }

}

You could also build your own MessageBodyReader/MessageBodyWriter or use other implementations like Moxy.

I would like to recommend to use Jersey 2.*.

Hope this was helpful somehow. Have a nice day.

score 0 · Answer 4 · answered Mar 22 '20 at 07:18

Your solution posted doesn't work because ZonedDateTime's Json serialization is not a Json primitive but a Json object that contains more than a single element. It needs to develop a bit and here is a completed solution:

public Gson gson() {
    return new GsonBuilder().registerTypeAdapter(ZonedDateTime.class, new JsonDeserializer<ZonedDateTime>() {
        @Override
        public ZonedDateTime deserialize(JsonElement json, Type type,
                JsonDeserializationContext jsonDeserializationContext) throws JsonParseException {

            JsonObject jsonObj = json.getAsJsonObject();

            JsonObject dateTime = jsonObj.getAsJsonObject("dateTime");
            JsonObject date = dateTime.getAsJsonObject("date");
            int year = date.get("year").getAsInt();
            int month = date.get("month").getAsInt();
            int day = date.get("day").getAsInt();

            JsonObject time = dateTime.getAsJsonObject("time");
            int hour = time.get("hour").getAsInt();
            int minute = time.get("minute").getAsInt();
            int second = time.get("second").getAsInt();
            int nano = time.get("nano").getAsInt();

            JsonObject zone = jsonObj.getAsJsonObject("zone");
            String id = zone.get("id").getAsString();

            return ZonedDateTime.of(year, month, day, hour, minute, second, nano, ZoneId.of(id));
        }
    }).create();
}

This solution works for me. However, do you know why gson cannot deserialize ZonedDateTime properly? — Sami, Mar 04 '21 at 11:11
Because ZonedDateTime's JSON serialization is a JSON object that contains more than a single element. So in the override method deserialize we need to read JSON object properly such as JsonObject jsonObj = json.getAsJsonObject(). In the original solution it was json.getAsJsonPrimitive(). — Quang Vien, Mar 05 '21 at 13:23

Converting ZonedDateTime type to Gson

4 Answers4

1) Gson with JsonDeserializer

2) Use MessageBodyReader & XMLAdapter

Linked