Gson – Exclude or Ignore Fields

Gson allows us to exclude or ignore the fields from Java classes that we want not to be included in serialization and deserialization. Gson supports many inbuilt mechanisms for excluding top-level classes, fields and field types.

1. Gson @Expose Annotation

@Expose marks certain fields of the objects to be excluded, by default, for consideration for serialization and deserialization to JSON. It means that Gson will exclude all fields in a class that are not marked with @Expose annotation.

The @Expose annotation is useful in a style of programming where you want to explicitly specify all fields that should get considered for serialization or deserialization.

1.1. How to Use @Expose

@Expose is optional and offers two configuration parameters :

• serialize – If true, the field marked with this annotation is written out in the JSON while serializing.
• deserialize – If true, the field marked with this annotation is deserialized from the JSON.

@Expose(serialize = false)
private String lastName;

@Expose (serialize = false, deserialize = false)
private String emailAddress;

1.2. Creating Gson Instance with Expose Behavior

If we created Gson with new Gson(), and execute the toJson() and fromJson() methods then @Expose will not have any effect on serialization and deserialization.

To use this annotation, we must create Gson instance by using GsonBuilder class and it’s excludeFieldsWithoutExposeAnnotation() method.

Gson gson = new GsonBuilder()
		.excludeFieldsWithoutExposeAnnotation()
		.create();

2. Exclude Fields with Modifiers

2.1. Transient Fields

By default, Gson would exclude a field from serialization and deserialization – both, if we simply mark the field as transient. Remember that it is not capable of blocking one-way transformation. It blocks both.

transient will have the same effect as @Expose (serialize = false, deserialize = false).

@Expose(serialize = false)
private String lastName;

private transient String emailAddress;

2.2. Other Modifiers

By using excludeFieldsWithModifiers() method of GsonBuilder, we can exclude fields that have some common modifier.

For example, we want to exclude all static members of a class, we can create the Gson object like this:

Gson gson = new GsonBuilder()
		.excludeFieldsWithModifiers(Modifier.STATIC)
		.create();

We can use any number of the Modifier constants to “excludeFieldsWithModifiers” method. For example:

Gson gson = new GsonBuilder()
		.excludeFieldsWithModifiers(Modifier.STATIC,
							Modifier.TRANSIENT,
							Modifier.VOLATILE)
		.create();

3. Exclusion Strategies

If any of the above-given techniques is not working for us, then we can create our own strategy. ExclusionStrategy is used to decide whether or not a field or top-level class should be serialized or deserialized as part of the JSON output/input.

• For serialization, if the shouldSkipClass(Class) or shouldSkipField(fieldAttributes) methods return true then that class or field type will not be part of the JSON output.
• For deserialization, if shouldSkipClass(Class) or shouldSkipField(fieldAttributes) methods return true, then it will not be set as part of the Java object structure.

For example, below ExclusionStrategy definition will exclude all fields annotated with @Hidden annotation.

//public @interface Hidden {
  // some implementation here
//}
 
// Excludes any field (or class) that is tagged with an "@Hidden"
public class HiddenAnnotationExclusionStrategy implements ExclusionStrategy 
{
  public boolean shouldSkipClass(Class<?> clazz) {
    return clazz.getAnnotation(Hidden.class) != null;
  }
 
  public boolean shouldSkipField(FieldAttributes f) {
    return f.getAnnotation(Hidden.class) != null;
  }
}

To use this exclusion strategy, set it in GsonBuilder object.

GsonBuilder builder = new GsonBuilder();
builder.setExclusionStrategies( new HiddenAnnotationExclusionStrategy() );
 
Gson gson = builder.create();

Still, if none of the above mechanisms satisfy our needs then we can always use custom serializers and deserializers.

Happy Learning !!