JsonDeserializer
Date: 2016-11-03

com.google.gson

## Interface JsonDeserializer<T>

- Type Parameters:
    `T` - type for which the deserializer is being registered. It is possible that a deserializer may be asked to deserialize a specific generic type of the T.

      public interface JsonDeserializer<T>

  Interface representing a custom deserializer for Json. You should write a custom deserializer, if you are not happy with the default deserialization done by Gson. You will also need to register this deserializer through `GsonBuilder.registerTypeAdapter(Type, Object)`.

  Let us look at example where defining a deserializer will be useful. The `Id` class defined below has two fields: `clazz` and `value`.

       public class Id<T> {
         private final Class<T> clazz;
         private final long value;
         public Id(Class<T> clazz, long value) {
           this.clazz = clazz;
           this.value = value;
         }
         public long getValue() {
           return value;
         }
       }

  The default deserialization of `Id(com.foo.MyObject.class, 20L)` will require the Json string to be `{"clazz":com.foo.MyObject,"value":20}`. Suppose, you already know the type of the field that the `Id` will be deserialized into, and hence just want to deserialize it from a Json string `20`. You can achieve that by writing a custom deserializer:

       class IdDeserializer implements JsonDeserializer<Id>() {
         public Id deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
             throws JsonParseException {
           return new Id((Class)typeOfT, id.getValue());
         }

  You will also need to register `IdDeserializer` with Gson as follows:

       Gson gson = new GsonBuilder().registerTypeAdapter(Id.class, new IdDeserializer()).create();

  New applications should prefer `TypeAdapter`, whose streaming API is more efficient than this interface's tree API.

- - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `T` | `deserialize(JsonElement json, java.lang.reflect.Type typeOfT, JsonDeserializationContext context)` Gson invokes this call-back method during deserialization when it encounters a field of the specified type.

- - ### Method Detail

    - #### deserialize

          T deserialize(JsonElement json,
                      java.lang.reflect.Type typeOfT,
                      JsonDeserializationContext context)
                        throws JsonParseException

      Gson invokes this call-back method during deserialization when it encounters a field of the specified type.

      In the implementation of this call-back method, you should consider invoking `JsonDeserializationContext.deserialize(JsonElement, Type)` method to create objects for any non-trivial field of the returned object. However, you should never invoke it on the the same type passing `json` since that will cause an infinite loop (Gson will call your call-back method again).

      Parameters:
        `json` - The Json data being deserialized
        `typeOfT` - The type of the Object to deserialize to
      Returns:
        a deserialized object of the specified type typeOfT which is a subclass of `T`
      Throws:
        `JsonParseException` - if json is not in the expected format of `typeofT`