Using Google GSON : Extra Goodies : Part II

We continue with Using GSON from last article, also in case you missed the first article in series here is link. So, here we go with another installment in series.

Versioning Support

If you want to maintain multiple versions of an object for JSON conversion, Google GSON library has nice @Since annotation for it. This annotation can be applied to fields and classes.

For example, suppose you are maintaining the multiple versions of the your REST API and you are using JSON as end response payload. In next iteration of your API you are added some of fields for particular JSON entity and you don’t want to send the newly added fields to previous API version then @Since annotation comes into picture. Lets see in following listing, how we use this feature.

To make use of this annotation, you must configure the Gson instance to specific version using GsonBuilder, of course.

public class Example33 {
public static void main(String[] args) {
Gson gson = new GsonBuilder().setVersion(2.0).create();
String json = gson.toJson(new ExampleClass());
System.out.println("Output for version 2.0...");
System.out.println(json);
gson= new GsonBuilder().setVersion(1.0).create();
json = gson.toJson(new ExampleClass());
System.out.println("\nOutput for version 1.0...");
System.out.println(json);
gson= new Gson();
json = gson.toJson(new ExampleClass());
System.out.println("\nOutput for No version set...");
System.out.println(json);
}
}
class ExampleClass{
String field= "field";
// this is in version 1.0
@Since(1.0) String newField1 = "field 1";
// following will be included in the version 1.1
@Since(2.0) String newField2 = "field 2";
}
view raw Example33.java hosted with ❤ by GitHub

Output of above as

Output for version 2.0...
{"field":"field","newField1":"field 1","newField2":"field 2"}
Output for version 1.0...
{"field":"field","newField1":"field 1"}
Output for No version set...
{"field":"field","newField1":"field 1","newField2":"field 2"}
view raw output hosted with ❤ by GitHub

If you are not specifying any version it will include the all the fields regardless of its version.

Disable HTML Escaping

By default, during conversion any html characters contained, will be converted to their corresponding Unicode i.e. <  to \u003c, > to \u003e , & to \u0026and so on

For passing the html characters as is, you need to configure the gson instance to with use of GsonBuilder#disableHtmlEscaping() method.

Following listing shows the usage –

public class Example34 {
public static void main(String[] args) {
String str ="<myval>";
Gson gson = new Gson();
System.out.println("Normal behaviour...");
System.out.println(gson.toJson(str));
System.out.println("\nDisabled html escaping...");
gson = new GsonBuilder().disableHtmlEscaping().create();
System.out.println(gson.toJson(str));
}
}
view raw E1.java hosted with ❤ by GitHub

Output  as follows

Normal behaviour...
"\u003cmyval\u003e"
Disabled html escaping...
"<myval>"
view raw output hosted with ❤ by GitHub

Exclude the fields from Json Output

For this, Google GSON has 4 ways to deal,

  1. fields with transient and static modifier

  2. exclude with fields with specific modifiers

  3. Using Expose annotation

  4. User defined exclusion strategies

Lets see each of this in detail-

1. fields with transient and static modifier

This is default behavior, where you modify the field with transient  modifier it will not included as we saw in first article in series and of course, one with static modifier are also excluded as they are part of class and not the instance.

2. exclude fields with specific modifiers

You can configure gson instance, such that it will exclude the fields with modifiers you specified, e.g. you can exclude/ignore the fields which have protected or private modifier.

To leverage this you need to use GsonBuilder#excludeFieldsWithModifiers()  as shown in following series of listing.

class Developer {
private String name;
private String classz;
List<String> languagesKnown;
public Developer() {
name = "ajduke";
classz= "Developer";
languagesKnown = new ArrayList<>();
languagesKnown.add("Java");
languagesKnown.add("Scala");
languagesKnown.add("Ruby");
}
}
view raw Developer.java hosted with ❤ by GitHub

For this example, we are not including the private fields. Although you can exclude fields with any modifiers (any modifiers that applies to fields)

Gson gson = new Gson();
System.out.println("Default behaviour ");
GsonBuilder gsonBuilder = new GsonBuilder();
Gson prettyGson = gsonBuilder.setPrettyPrinting().create();
String json = prettyGson.toJson(new Developer());
System.out.println(json);
System.out.println("Ignoring/excluding fields ");
GsonBuilder excludeFieldsWithModifiers = gsonBuilder
.excludeFieldsWithModifiers(Modifier.PRIVATE);
Gson create = excludeFieldsWithModifiers.create();
String json2 = create.toJson(new Developer());
System.out.println(json2);
view raw Exe3.java hosted with ❤ by GitHub

In following output, you can see private fields are excluded as per our program, Although you can ignore fields which can have protected, synchronized etc.

Default behaviour
{
"name": "ajduke",
"classz": "Developer",
"languagesKnown": [
"Java",
"Scala",
"Ruby"
]
}
Ignoring/excluding fields
{
"languagesKnown": [
"Java",
"Scala",
"Ruby"
]
}
view raw Exe3-ouput hosted with ❤ by GitHub

3. Using Expose annotation

Gson also provides an annotation which you can mark for the fields, thus those fields will be excluded from serialized output..

For using this we need to following two

  1. configure gson instance as follows
    Gson gson= GsonBuilder().excludeFieldsWithoutExposeAnnotation().create()

  2. and mark the fields with @Expose annotations, which are to be included in final json output. So, one which are not marked will be excluded

Following listing shows the detailed usage

class Developer {
// this field will be included
@Expose
private String name;
private String classz;
List<String> languagesKnown;
public Developer() {
name = "ajduke";
languagesKnown = new ArrayList<>();
languagesKnown.add("Java");
languagesKnown.add("Scala");
languagesKnown.add("Ruby");
}
}
view raw Developer.java hosted with ❤ by GitHub

public class GsonEx {
public static void main(String[] args) throws IOException {
Gson gson = new GsonBuilder().excludeFieldsWithoutExposeAnnotation().create();
String json = gson.toJson(new Developer());
System.out.println(json);
}
}
view raw gistfile1.java hosted with ❤ by GitHub

Ouput as follows-

{"name":"ajduke"}
view raw gistfile1.txt hosted with ❤ by GitHub

4. User defined exclusion strategy

Google Gson library provides very granular level of exclusions of fields based on type of field and field attributes.

For this you need to implement the ExclusionStrategy interface by implementing the two of its methods such as shouldSkipClass() and shouldSkipField(). Former can implemented such that it will skip fields based on type of it and later can implemented based on field attribute such its modifier, its annotation etc

and now after implementation ExclusionStrategy interface, you need to pass it to GsonBuilder#setExclusionStrategies() method for configuring the gson instance.

Following is minimal implementation of use of Exclusion strategy, in which we exclude the fields are having type as String, List and also field which are having annotation as Deprecated

Note the following implementation of ExclusionStrategy

class ExclusionStrategyImpl implements ExclusionStrategy {
private final Class<?> classTypeToSkip;
public ExclusionStrategyImpl(Class<?> classTypeToSkip) {
this.classTypeToSkip = classTypeToSkip;
}
@Override
public boolean shouldSkipClass(Class<?> claz) {
return classTypeToSkip == claz;
}
@Override
public boolean shouldSkipField(FieldAttributes fa) {
return fa.getAnnotation(Deprecated.class) !=null;
}
}

Our custom Developer class for showing example

class Developer {
@Deprecated
private int count = 45;
private String name;
private String classz;
List<String> languagesKnown;
public Developer() {
name = "ajduke";
classz = Developer.class.getCanonicalName();
languagesKnown = new ArrayList<>();
languagesKnown.add("Java");
languagesKnown.add("Scala");
languagesKnown.add("Ruby");
}
}
view raw Developer.java hosted with ❤ by GitHub

public class Ex35 {
public static void main(String[] args) {
Gson gson = null;
Developer developer = new Developer();
String json = null;
gson = new Gson();
json = gson.toJson(developer);
System.out.println("Default behaviuor....");
System.out.println(json);
// exclude field having String
gson = new GsonBuilder().setExclusionStrategies(
new ExclusionStrategyImpl(List.class)).create();
json = gson.toJson(developer);
System.out.println("\nExclude fields with type - List");
System.out.println(json);
// exclude field having List
gson = new GsonBuilder().setExclusionStrategies(
new ExclusionStrategyImpl(String.class)).create();
json = gson.toJson(developer);
System.out.println("\nExclude fields with type - String");
System.out.println(json);
}
}
view raw Ex35.java hosted with ❤ by GitHub

Output of above as follows

Default behaviuor....
{"count":45,"name":"ajduke","classz":"in.ajduke.ap013.Developer","languagesKnown":["Java","Scala","Ruby"]}
Exclude fields with type - List
{"name":"ajduke","classz":"in.ajduke.ap013.Developer"}
Exclude fields with type - String
{"languagesKnown":[null,null,null]}
view raw output hosted with ❤ by GitHub

Custom field naming using field naming policy

As we saw in last article that Gson defaulted to include the output json field name same as that of class field name and also we can override this with use annotation @serilizedName.

In Gson there is more we can define the json field name to change to Uppercase, lowercase etc without use of any annotation.

For this you need to use GsonBuilder().setFieldNamingPolicy() method and passing the appropriate FieldNamePolicy

Following listing shows usage

package in.ajduke.ap013;
import com.google.gson.FieldNamingPolicy;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
public class Example34 {
public static void main(String[] args) {
Gson gson = new Gson();
String json = gson.toJson(new JsonClass());
System.out.println("Default behaviour....");
System.out.println(json);
gson = new GsonBuilder().setFieldNamingPolicy(
FieldNamingPolicy.LOWER_CASE_WITH_DASHES).create();
json = gson.toJson(new JsonClass());
System.out.println("\nFields with lower case with dashes...");
System.out.println(json);
gson = new GsonBuilder().setFieldNamingPolicy(
FieldNamingPolicy.UPPER_CAMEL_CASE_WITH_SPACES).create();
json = gson.toJson(new JsonClass());
System.out.println("\nFields with upper case with spaces...");
System.out.println(json);
}
}
class JsonClass {
String myField = "value1";
String myAnotherField = "value2";
}
view raw Exe34.java hosted with ❤ by GitHub

Default behaviour....
{"myField":"value1","myAnotherField":"value2"}
Fields with lower case and dashes...
{"my-field":"value1","my-another-field":"value2"}
Fields with lower case and dashes...
{"My Field":"value1","My Another Field":"value2"}
view raw output.txt hosted with ❤ by GitHub

One thought on “Using Google GSON : Extra Goodies : Part II

Add yours

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

Blog at WordPress.com.

Up ↑

%d bloggers like this: