How To Register Typeadapterfactory Serialize Nulls

In this weblog mail, we'll prove how yous can simplify the customization of (de)serialization. In the past few web log posts, we've demonstrated how to customize serialization, deserialization and how to utilise instance creators.

All of those options were simply available via a custom Gson instance and some average code. Gson 2.7 introduced a simple annotation were you lot can save quite a fleck of lawmaking and achieve the aforementioned result. If you're interested in @JsonAdapter, go along reading!

Of course, this will not be the only post in our Gson series. If you're interested in the other topics, bank check out our series outline:

Gson Series Overview

@JsonAdapter Notation

If yous've read our previous blog posts on custom (de)serialization, yous know the general structure is not likewise complicated, but always a few lines of average code:

          GsonBuilder gsonBuilder = new GsonBuilder();  Type merchantListType = new TypeToken<Listing<Merchant>>() {}.getType();   JsonSerializer<List<Merchant>> serializer = ...; // implementation detail   gsonBuilder.registerTypeAdapter(merchantListType, serializer);  Gson customGson = gsonBuilder.create();   String customJSON = customGson.toJson(subscription);

The snippet in a higher place shows you an example of a custom serializer. Nosotros'll still demand an implementation of the JsonSerializer interface, simply the other code around it can be simplified.

Custom Serialization

The first pace is to pull out the serializer object in the snippet higher up and move it into a class. The course has the identical setup as the bearding annunciation as we've done it equally an object:

          public class MerchantListSerializer implements JsonSerializer<List<Merchant>> {       @Override     public JsonElement serialize(List<Merchant> src, Type typeOfSrc, JsonSerializationContext context) {         JsonArray jsonMerchant = new JsonArray();          for (Merchant merchant : src) {             jsonMerchant.add("" + merchant.getId());         }          render jsonMerchant;     } }

Once you've wrapped it in a public course, you tin can use it in the @JsonAdapter note. The @JsonAdapterannotation, but like the other annotations we've explored in previous posts, are added to the Coffee model. In the example in a higher place, we would demand to change the models that include List<Merchant> backdrop.

For example:

          public course UserSubscriptionAnnotation {       String proper name;     String electronic mail;     int age;     boolean isDeveloper;      // new!     @JsonAdapter(MerchantListSerializer.class)     Listing<Merchant> merchantList; }

The belongings that requires a custom serializer, will be enhanced by the @JsonAdapter annotation. The annotation simply accepts one unmarried parameter: a class reference. That class needs to implement either JsonSerializer or JsonDeserializer.

All the following Gson conversions volition utilize your custom (de)serialization. You won't demand a custom Gson instance anymore. Thus, the following snippet would be sufficient:

          UserSubscriptionAnnotation subscription = new UserSubscriptionAnnotation(                   "Norman",                 "norman@fs.io",                 26,                 truthful,                 subscribedMerchants);  Gson gson = new Gson();   String fullJSON = gson.toJson(subscription);

You can completely go rid of the GsonBuilder part and simply use the default new Gson() instance.

Custom Deserialization

The same approach and annotation likewise works for custom deserialization. If y'all bank check the code from our custom deserialization blog mail service y'all'll find the following setup code:

          GsonBuilder gsonBuilder = new GsonBuilder();  JsonDeserializer<UserDate> deserializer = ...; // implementation item   gsonBuilder.registerTypeAdapter(UserDate.grade, deserializer);  Gson customGson = gsonBuilder.create();   UserDate customObject = customGson.fromJson(userJson, UserDate.class);

Over again, the alternative solution is to change information technology from a custom Gson instance with registered type adapters to annotating the model.

First, we've to extract the deserializer into a class:

          public class UserDateDeserializer implements JsonDeserializer<UserDate> {       @Override     public UserDate deserialize(JsonElement json, Blazon typeOfT, JsonDeserializationContext context) throws JsonParseException {         JsonObject jsonObject = json.getAsJsonObject();          Engagement date = new Appointment(             jsonObject.get("year").getAsInt(),             jsonObject.get("month").getAsInt(),             jsonObject.get("day").getAsInt()         );          render new UserDate(             jsonObject.go("name").getAsString(),             jsonObject.get("email").getAsString(),             jsonObject.go("isDeveloper").getAsBoolean(),             jsonObject.get("historic period").getAsInt(),             appointment         );     } }

As you lot can see, the code in the deserialize() stays identical.

The 2d step is to add together the note to the model:

          @JsonAdapter(UserDateDeserializer.class) public class UserDate {       private Cord _name;     private String email;     private boolean isDeveloper;     private int age;      private Date registerDate  }

A slight difference to the previous example of custom serialization via note is that we're annotating the entire class and non a specific property. Both means are possible and useful!

The deserialization is now reduced to a single line of code:

          UserDate standardObject = new Gson().fromJson(userJson, UserDate.grade);

Beyond the Telescopic of @JsonAdapter: Multiple Customizations

One limitation of Java annotations is that you lot tin only add ane annotation for each course (or holding). If ane of your models or properties requires a custom serializer and a custom deserializer, you lot'll need to continue to utilize the long manner via a custom Gson instance with registerTypeAdapter() calls.

Outlook

In this tutorial, y'all've learned how you can utilise the @JsonAdapter annotation to save a lot of average code and simplify your code base of operations. While it doesn't add together any new functionality, it makes your code cleaner and easier to understand.

Additionally, it prevents yous from accidentally registering multiple custom (de)serializer by only allowing i note for each model (and property).

If you've feedback or a question, permit the states know in the comments or on twitter @futurestud_io.

Make it stone & enjoy coding!