Class Gson

java.lang.Object
com.google.gson.Gson

public final class Gson extends Object
This is the main class for using Gson. Gson is typically used by first constructing a Gson instance and then invoking toJson(Object) or fromJson(String, Class) methods on it. Gson instances are Thread-safe so you can reuse them freely across multiple threads.

You can create a Gson instance by invoking new Gson() if the default configuration is all you need. You can also use GsonBuilder to build a Gson instance with various configuration options such as versioning support, pretty printing, custom JsonSerializers, JsonDeserializers, and InstanceCreators.

Here is an example of how Gson is used for a simple Class:

 Gson gson = new Gson(); // Or use new GsonBuilder().create();
 MyType target = new MyType();
 String json = gson.toJson(target); // serializes target to Json
 MyType target2 = gson.fromJson(json, MyType.class); // deserializes json into target2
 

If the object that your are serializing/deserializing is a ParameterizedType (i.e. contains at least one type parameter and may be an array) then you must use the toJson(Object, Type) or fromJson(String, Type) method. Here is an example for serializing and deserializing a ParameterizedType:

 Type listType = new TypeToken<List<String>>() {}.getType();
 List<String> target = new LinkedList<String>();
 target.add("blah");

 Gson gson = new Gson();
 String json = gson.toJson(target, listType);
 List<String> target2 = gson.fromJson(json, listType);
 

See the Gson User Guide for a more complete set of examples.

See Also:
  • Field Details

    • DEFAULT_JSON_NON_EXECUTABLE

      static final boolean DEFAULT_JSON_NON_EXECUTABLE
      See Also:
    • DEFAULT_LENIENT

      static final boolean DEFAULT_LENIENT
      See Also:
    • DEFAULT_PRETTY_PRINT

      static final boolean DEFAULT_PRETTY_PRINT
      See Also:
    • DEFAULT_ESCAPE_HTML

      static final boolean DEFAULT_ESCAPE_HTML
      See Also:
    • DEFAULT_SERIALIZE_NULLS

      static final boolean DEFAULT_SERIALIZE_NULLS
      See Also:
    • DEFAULT_COMPLEX_MAP_KEYS

      static final boolean DEFAULT_COMPLEX_MAP_KEYS
      See Also:
    • DEFAULT_SPECIALIZE_FLOAT_VALUES

      static final boolean DEFAULT_SPECIALIZE_FLOAT_VALUES
      See Also:
    • NULL_KEY_SURROGATE

      private static final TypeToken<?> NULL_KEY_SURROGATE
    • JSON_NON_EXECUTABLE_PREFIX

      private static final String JSON_NON_EXECUTABLE_PREFIX
      See Also:
    • calls

      private final ThreadLocal<Map<TypeToken<?>,Gson.FutureTypeAdapter<?>>> calls
      This thread local guards against reentrant calls to getAdapter(). In certain object graphs, creating an adapter for a type may recursively require an adapter for the same type! Without intervention, the recursive lookup would stack overflow. We cheat by returning a proxy type adapter. The proxy is wired up once the initial adapter has been created.
    • typeTokenCache

      private final Map<TypeToken<?>,TypeAdapter<?>> typeTokenCache
    • constructorConstructor

      private final ConstructorConstructor constructorConstructor
    • jsonAdapterFactory

      private final JsonAdapterAnnotationTypeAdapterFactory jsonAdapterFactory
    • factories

      final List<TypeAdapterFactory> factories
    • excluder

      final Excluder excluder
    • fieldNamingStrategy

      final FieldNamingStrategy fieldNamingStrategy
    • instanceCreators

      final Map<Type,InstanceCreator<?>> instanceCreators
    • serializeNulls

      final boolean serializeNulls
    • complexMapKeySerialization

      final boolean complexMapKeySerialization
    • generateNonExecutableJson

      final boolean generateNonExecutableJson
    • htmlSafe

      final boolean htmlSafe
    • prettyPrinting

      final boolean prettyPrinting
    • lenient

      final boolean lenient
    • serializeSpecialFloatingPointValues

      final boolean serializeSpecialFloatingPointValues
    • datePattern

      final String datePattern
    • dateStyle

      final int dateStyle
    • timeStyle

      final int timeStyle
    • longSerializationPolicy

      final LongSerializationPolicy longSerializationPolicy
    • builderFactories

      final List<TypeAdapterFactory> builderFactories
    • builderHierarchyFactories

      final List<TypeAdapterFactory> builderHierarchyFactories
    • objectToNumberStrategy

      final ToNumberStrategy objectToNumberStrategy
    • numberToNumberStrategy

      final ToNumberStrategy numberToNumberStrategy
  • Constructor Details

  • Method Details

    • newBuilder

      public GsonBuilder newBuilder()
      Returns a new GsonBuilder containing all custom factories and configuration used by the current instance.
      Returns:
      a GsonBuilder instance.
    • excluder

      @Deprecated public Excluder excluder()
      Deprecated.
      This method by accident exposes an internal Gson class; it might be removed in a future version.
    • fieldNamingStrategy

      public FieldNamingStrategy fieldNamingStrategy()
      Returns the field naming strategy used by this Gson instance.
      See Also:
    • serializeNulls

      public boolean serializeNulls()
      Returns whether this Gson instance is serializing JSON object properties with null values, or just omits them.
      See Also:
    • htmlSafe

      public boolean htmlSafe()
      Returns whether this Gson instance produces JSON output which is HTML-safe, that means all HTML characters are escaped.
      See Also:
    • doubleAdapter

      private TypeAdapter<Number> doubleAdapter(boolean serializeSpecialFloatingPointValues)
    • floatAdapter

      private TypeAdapter<Number> floatAdapter(boolean serializeSpecialFloatingPointValues)
    • checkValidFloatingPoint

      static void checkValidFloatingPoint(double value)
    • longAdapter

      private static TypeAdapter<Number> longAdapter(LongSerializationPolicy longSerializationPolicy)
    • atomicLongAdapter

      private static TypeAdapter<AtomicLong> atomicLongAdapter(TypeAdapter<Number> longAdapter)
    • atomicLongArrayAdapter

      private static TypeAdapter<AtomicLongArray> atomicLongArrayAdapter(TypeAdapter<Number> longAdapter)
    • getAdapter

      public <T> TypeAdapter<T> getAdapter(TypeToken<T> type)
      Returns the type adapter for type.
      Throws:
      IllegalArgumentException - if this GSON cannot serialize and deserialize type.
    • getDelegateAdapter

      public <T> TypeAdapter<T> getDelegateAdapter(TypeAdapterFactory skipPast, TypeToken<T> type)
      This method is used to get an alternate type adapter for the specified type. This is used to access a type adapter that is overridden by a TypeAdapterFactory that you may have registered. This features is typically used when you want to register a type adapter that does a little bit of work but then delegates further processing to the Gson default type adapter. Here is an example:

      Let's say we want to write a type adapter that counts the number of objects being read from or written to JSON. We can achieve this by writing a type adapter factory that uses the getDelegateAdapter method:

       
        class StatsTypeAdapterFactory implements TypeAdapterFactory {
          public int numReads = 0;
          public int numWrites = 0;
          public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
            final TypeAdapter<T> delegate = gson.getDelegateAdapter(this, type);
            return new TypeAdapter<T>() {
              public void write(JsonWriter out, T value) throws IOException {
                ++numWrites;
                delegate.write(out, value);
              }
              public T read(JsonReader in) throws IOException {
                ++numReads;
                return delegate.read(in);
              }
            };
          }
        }
         
      This factory can now be used like this:
       
        StatsTypeAdapterFactory stats = new StatsTypeAdapterFactory();
        Gson gson = new GsonBuilder().registerTypeAdapterFactory(stats).create();
        // Call gson.toJson() and fromJson methods on objects
        System.out.println("Num JSON reads" + stats.numReads);
        System.out.println("Num JSON writes" + stats.numWrites);
        
      Note that this call will skip all factories registered before skipPast. In case of multiple TypeAdapterFactories registered it is up to the caller of this function to insure that the order of registration does not prevent this method from reaching a factory they would expect to reply from this call. Note that since you can not override type adapter factories for String and Java primitive types, our stats factory will not count the number of String or primitives that will be read or written.
      Parameters:
      skipPast - The type adapter factory that needs to be skipped while searching for a matching type adapter. In most cases, you should just pass this (the type adapter factory from where getDelegateAdapter(com.google.gson.TypeAdapterFactory, com.google.gson.reflect.TypeToken<T>) method is being invoked).
      type - Type for which the delegate adapter is being searched for.
      Since:
      2.2
    • getAdapter

      public <T> TypeAdapter<T> getAdapter(Class<T> type)
      Returns the type adapter for type.
      Throws:
      IllegalArgumentException - if this GSON cannot serialize and deserialize type.
    • toJsonTree

      public JsonElement toJsonTree(Object src)
      This method serializes the specified object into its equivalent representation as a tree of JsonElements. This method should be used when the specified object is not a generic type. This method uses Object.getClass() to get the type for the specified object, but the getClass() loses the generic type information because of the Type Erasure feature of Java. Note that this method works fine if the any of the object fields are of generic type, just the object itself should not be of a generic type. If the object is of generic type, use toJsonTree(Object, Type) instead.
      Parameters:
      src - the object for which Json representation is to be created setting for Gson
      Returns:
      Json representation of src.
      Since:
      1.4
    • toJsonTree

      public JsonElement toJsonTree(Object src, Type typeOfSrc)
      This method serializes the specified object, including those of generic types, into its equivalent representation as a tree of JsonElements. This method must be used if the specified object is a generic type. For non-generic objects, use toJsonTree(Object) instead.
      Parameters:
      src - the object for which JSON representation is to be created
      typeOfSrc - The specific genericized type of src. You can obtain this type by using the TypeToken class. For example, to get the type for Collection<Foo>, you should use:
       Type typeOfSrc = new TypeToken<Collection<Foo>>(){}.getType();
       
      Returns:
      Json representation of src
      Since:
      1.4
    • toJson

      public String toJson(Object src)
      This method serializes the specified object into its equivalent Json representation. This method should be used when the specified object is not a generic type. This method uses Object.getClass() to get the type for the specified object, but the getClass() loses the generic type information because of the Type Erasure feature of Java. Note that this method works fine if the any of the object fields are of generic type, just the object itself should not be of a generic type. If the object is of generic type, use toJson(Object, Type) instead. If you want to write out the object to a Writer, use toJson(Object, Appendable) instead.
      Parameters:
      src - the object for which Json representation is to be created setting for Gson
      Returns:
      Json representation of src.
    • toJson

      public String toJson(Object src, Type typeOfSrc)
      This method serializes the specified object, including those of generic types, into its equivalent Json representation. This method must be used if the specified object is a generic type. For non-generic objects, use toJson(Object) instead. If you want to write out the object to a Appendable, use toJson(Object, Type, Appendable) instead.
      Parameters:
      src - the object for which JSON representation is to be created
      typeOfSrc - The specific genericized type of src. You can obtain this type by using the TypeToken class. For example, to get the type for Collection<Foo>, you should use:
       Type typeOfSrc = new TypeToken<Collection<Foo>>(){}.getType();
       
      Returns:
      Json representation of src
    • toJson

      public void toJson(Object src, Appendable writer) throws JsonIOException
      This method serializes the specified object into its equivalent Json representation. This method should be used when the specified object is not a generic type. This method uses Object.getClass() to get the type for the specified object, but the getClass() loses the generic type information because of the Type Erasure feature of Java. Note that this method works fine if the any of the object fields are of generic type, just the object itself should not be of a generic type. If the object is of generic type, use toJson(Object, Type, Appendable) instead.
      Parameters:
      src - the object for which Json representation is to be created setting for Gson
      writer - Writer to which the Json representation needs to be written
      Throws:
      JsonIOException - if there was a problem writing to the writer
      Since:
      1.2
    • toJson

      public void toJson(Object src, Type typeOfSrc, Appendable writer) throws JsonIOException
      This method serializes the specified object, including those of generic types, into its equivalent Json representation. This method must be used if the specified object is a generic type. For non-generic objects, use toJson(Object, Appendable) instead.
      Parameters:
      src - the object for which JSON representation is to be created
      typeOfSrc - The specific genericized type of src. You can obtain this type by using the TypeToken class. For example, to get the type for Collection<Foo>, you should use:
       Type typeOfSrc = new TypeToken<Collection<Foo>>(){}.getType();
       
      writer - Writer to which the Json representation of src needs to be written.
      Throws:
      JsonIOException - if there was a problem writing to the writer
      Since:
      1.2
    • toJson

      public void toJson(Object src, Type typeOfSrc, JsonWriter writer) throws JsonIOException
      Writes the JSON representation of src of type typeOfSrc to writer.
      Throws:
      JsonIOException - if there was a problem writing to the writer
    • toJson

      public String toJson(JsonElement jsonElement)
      Converts a tree of JsonElements into its equivalent JSON representation.
      Parameters:
      jsonElement - root of a tree of JsonElements
      Returns:
      JSON String representation of the tree
      Since:
      1.4
    • toJson

      public void toJson(JsonElement jsonElement, Appendable writer) throws JsonIOException
      Writes out the equivalent JSON for a tree of JsonElements.
      Parameters:
      jsonElement - root of a tree of JsonElements
      writer - Writer to which the Json representation needs to be written
      Throws:
      JsonIOException - if there was a problem writing to the writer
      Since:
      1.4
    • newJsonWriter

      public JsonWriter newJsonWriter(Writer writer) throws IOException
      Returns a new JSON writer configured for the settings on this Gson instance.
      Throws:
      IOException
    • newJsonReader

      public JsonReader newJsonReader(Reader reader)
      Returns a new JSON reader configured for the settings on this Gson instance.
    • toJson

      public void toJson(JsonElement jsonElement, JsonWriter writer) throws JsonIOException
      Writes the JSON for jsonElement to writer.
      Throws:
      JsonIOException - if there was a problem writing to the writer
    • fromJson

      public <T> T fromJson(String json, Class<T> classOfT) throws JsonSyntaxException
      This method deserializes the specified Json into an object of the specified class. It is not suitable to use if the specified class is a generic type since it will not have the generic type information because of the Type Erasure feature of Java. Therefore, this method should not be used if the desired type is a generic type. Note that this method works fine if the any of the fields of the specified object are generics, just the object itself should not be a generic type. For the cases when the object is of generic type, invoke fromJson(String, Type). If you have the Json in a Reader instead of a String, use fromJson(Reader, Class) instead.
      Type Parameters:
      T - the type of the desired object
      Parameters:
      json - the string from which the object is to be deserialized
      classOfT - the class of T
      Returns:
      an object of type T from the string. Returns null if json is null or if json is empty.
      Throws:
      JsonSyntaxException - if json is not a valid representation for an object of type classOfT
    • fromJson

      public <T> T fromJson(String json, Type typeOfT) throws JsonSyntaxException
      This method deserializes the specified Json into an object of the specified type. This method is useful if the specified object is a generic type. For non-generic objects, use fromJson(String, Class) instead. If you have the Json in a Reader instead of a String, use fromJson(Reader, Type) instead.
      Type Parameters:
      T - the type of the desired object
      Parameters:
      json - the string from which the object is to be deserialized
      typeOfT - The specific genericized type of src. You can obtain this type by using the TypeToken class. For example, to get the type for Collection<Foo>, you should use:
       Type typeOfT = new TypeToken<Collection<Foo>>(){}.getType();
       
      Returns:
      an object of type T from the string. Returns null if json is null or if json is empty.
      Throws:
      JsonParseException - if json is not a valid representation for an object of type typeOfT
      JsonSyntaxException - if json is not a valid representation for an object of type
    • fromJson

      public <T> T fromJson(Reader json, Class<T> classOfT) throws JsonSyntaxException, JsonIOException
      This method deserializes the Json read from the specified reader into an object of the specified class. It is not suitable to use if the specified class is a generic type since it will not have the generic type information because of the Type Erasure feature of Java. Therefore, this method should not be used if the desired type is a generic type. Note that this method works fine if the any of the fields of the specified object are generics, just the object itself should not be a generic type. For the cases when the object is of generic type, invoke fromJson(Reader, Type). If you have the Json in a String form instead of a Reader, use fromJson(String, Class) instead.
      Type Parameters:
      T - the type of the desired object
      Parameters:
      json - the reader producing the Json from which the object is to be deserialized.
      classOfT - the class of T
      Returns:
      an object of type T from the string. Returns null if json is at EOF.
      Throws:
      JsonIOException - if there was a problem reading from the Reader
      JsonSyntaxException - if json is not a valid representation for an object of type
      Since:
      1.2
    • fromJson

      public <T> T fromJson(Reader json, Type typeOfT) throws JsonIOException, JsonSyntaxException
      This method deserializes the Json read from the specified reader into an object of the specified type. This method is useful if the specified object is a generic type. For non-generic objects, use fromJson(Reader, Class) instead. If you have the Json in a String form instead of a Reader, use fromJson(String, Type) instead.
      Type Parameters:
      T - the type of the desired object
      Parameters:
      json - the reader producing Json from which the object is to be deserialized
      typeOfT - The specific genericized type of src. You can obtain this type by using the TypeToken class. For example, to get the type for Collection<Foo>, you should use:
       Type typeOfT = new TypeToken<Collection<Foo>>(){}.getType();
       
      Returns:
      an object of type T from the json. Returns null if json is at EOF.
      Throws:
      JsonIOException - if there was a problem reading from the Reader
      JsonSyntaxException - if json is not a valid representation for an object of type
      Since:
      1.2
    • assertFullConsumption

      private static void assertFullConsumption(Object obj, JsonReader reader)
    • fromJson

      public <T> T fromJson(JsonReader reader, Type typeOfT) throws JsonIOException, JsonSyntaxException
      Reads the next JSON value from reader and convert it to an object of type typeOfT. Returns null, if the reader is at EOF. Since Type is not parameterized by T, this method is type unsafe and should be used carefully
      Throws:
      JsonIOException - if there was a problem writing to the Reader
      JsonSyntaxException - if json is not a valid representation for an object of type
    • fromJson

      public <T> T fromJson(JsonElement json, Class<T> classOfT) throws JsonSyntaxException
      This method deserializes the Json read from the specified parse tree into an object of the specified type. It is not suitable to use if the specified class is a generic type since it will not have the generic type information because of the Type Erasure feature of Java. Therefore, this method should not be used if the desired type is a generic type. Note that this method works fine if the any of the fields of the specified object are generics, just the object itself should not be a generic type. For the cases when the object is of generic type, invoke fromJson(JsonElement, Type).
      Type Parameters:
      T - the type of the desired object
      Parameters:
      json - the root of the parse tree of JsonElements from which the object is to be deserialized
      classOfT - The class of T
      Returns:
      an object of type T from the json. Returns null if json is null or if json is empty.
      Throws:
      JsonSyntaxException - if json is not a valid representation for an object of type typeOfT
      Since:
      1.3
    • fromJson

      public <T> T fromJson(JsonElement json, Type typeOfT) throws JsonSyntaxException
      This method deserializes the Json read from the specified parse tree into an object of the specified type. This method is useful if the specified object is a generic type. For non-generic objects, use fromJson(JsonElement, Class) instead.
      Type Parameters:
      T - the type of the desired object
      Parameters:
      json - the root of the parse tree of JsonElements from which the object is to be deserialized
      typeOfT - The specific genericized type of src. You can obtain this type by using the TypeToken class. For example, to get the type for Collection<Foo>, you should use:
       Type typeOfT = new TypeToken<Collection<Foo>>(){}.getType();
       
      Returns:
      an object of type T from the json. Returns null if json is null or if json is empty.
      Throws:
      JsonSyntaxException - if json is not a valid representation for an object of type typeOfT
      Since:
      1.3
    • toString

      public String toString()
      Overrides:
      toString in class Object