Transitioning from Gson to Kotlin Serialization: Embracing Null Safety and Robust Deserialization

Photo by Marc Reichelt on Unsplash

Introduction

It’s been a while since I last wrote an article, and I’m excited to share my thoughts with everyone in the community. In this article, I want to delve into the reasons behind my shift in mindset from using Gson for deserialization with Kotlin to embracing Kotlin serialization. Specifically, I want to highlight the remarkable null safety feature offered by Kotlin and discuss a scenario that opened my eyes to its benefits.

Null Safety and its Importance

One of the standout features of Kotlin is its robust null safety mechanism. To illustrate its significance, let’s consider a scenario involving a data class with non-nullable variables

data class SimpleTest(
    val field1: String,
    val field2: String
)

In Kotlin, we cannot assign null values to these variables, ensuring that they always have valid values. This helps prevent null pointer exceptions and enhances code reliability.

Challenges with Gson Deserialization

Now, let’s explore a situation where we perform Gson deserialization, converting a JSON string into the SimpleTest data class

val json = "{\"field1\":\"one\",\"field2\":\"two\"}"

val result = GsonBuilder().create().fromJson(json)

When we access the data, everything works smoothly

println(result.field1) // prints "one"
println(result.field2) // prints "two"

However, let’s introduce an interesting twist. Imagine we provide a malformed field name in the JSON

val json = "{\"field1\":\"one\",\"malformed\":\"two\"}" // second field name is malformed here.

val result = GsonBuilder().create().fromJson(json)

Now, observe the outcome

println(result.field1) // prints "one"
println(result.field2) // throws a java.lang.NullPointerException

Unexpectedly, we encounter a NullPointerException when attempting to access result.field2. This experience taught me that using Gson alone for parsing results can be risky. If the field names change without careful consideration, unexpected behavior or crashes may occur, making it difficult to troubleshoot and understand the issue.

The Benefits of Kotlin Serialization

This is where Kotlin serialization comes to the rescue. In the event of a structural change, the deserializer provided by Kotlin serialization assigns null to the entire object instead of specific fields. This approach gives us better control over fallback logic and error handling.

Conclusion

In conclusion, my journey from Gson to Kotlin serialization has been driven by the compelling null safety feature that Kotlin offers. Through the scenario I shared, I learned the importance of using serialization libraries that align with Kotlin’s null safety philosophy. Kotlin serialization’s ability to handle structure changes by nullifying the entire object rather than individual fields provides us with a solid foundation for handling data inconsistencies and maintaining a robust system.

I hope you found this article insightful. Until next time!