1. Overview

While developing software, we frequently need to parse JSON strings to Java and Kotlin objects. Sometimes we need to map this JSON to generic classes, such as when parsing a collection of objects.

In this article, we’ll explore the use of Gson and TypeToken to deserialize JSON to generic Kotlin objects. TypeToken captures the generic definition to tell Gson the exact object type we want to convert our JSON to.

2. Dependencies

First, we need to make sure that our Kotlin project includes the Gson dependency. Let’s look at how we can configure this library for projects that use Maven and Gradle.

2.1. Gradle

For use with Gradle, we apply the Gson dependency in the build.gradle file:

dependencies {
  implementation 'com.google.code.gson:gson:2.10.1'

2.2. Maven

With Maven, add the following to the pom.xml file of the project:


3. Different Ways to Deserialize JSON to Kotlin Objects

As mentioned earlier, we seek to perform the deserialization of generic Kotlin objects with the use of Gson and TypeToken. By default, Gson can handle deserialization of statically typed Kotlin classes.

When we need to deserialize a generic class, we must create a TypeToken to help Gson understand the correct type to be deserialized. TypeToken has no public constructor, but it does have a protected constructor. This means to create an instance, we must extend it. We can do this inline with an anonymous subclass.

Throughout this section, we’re going to consider a custom Kotlin class called Book:

data class Book(
    val id: Int,
    val title: String,
    val author: String

Let’s consider this JSON list containing several Books as well:

    "id": 1,
    "title": "First title",
    "author": "Micheal L"
    "id": 2,
    "title": "Second title",
    "author": "Enombe N"
    "id": 1,
    "title": "Third title",
    "author": "Steve P"

Each of the various ways we’re about to discuss makes use of one simple method: fromJson(). Basically, the fromJson() method permits Gson to convert a JSON string to an equivalent Java or Kotlin object.

3.1. Basic Usage of Gson Without Generics

Now, considering the Book class and JSON string above, we can deserialize the JSON string explicitly to an array of Book objects:

fun `explicit deserialization of JSON to Kotlin object`() {
    val books = Gson().fromJson(jsonStr, Array<Book>::class.java)
    assertEquals(3, books.size)
    assertEquals("First title", books[0].title)

This is a simplistic approach to deserializing JSON to custom objects as we’ve already defined the type of object we’re deserializing to.

It’s important to note that Kotlin arrays aren’t actually generic. Although they look the same, they’re special. It is not possible to generically define arrays.

Let’s now look into various ways we can obtain Kotlin objects from JSON using Gson and TypeToken generically.

3.2. Using TypeToken from an Object Expression

In this method, we first define an object expression that extends from TypeToken, and we then parameterize it with the Java type. We use the Gson.fromJson() method with the type specified for the intended result, and this type should match the TypeToken object created.

Lastly, let’s use this object with Gson to get a list of custom objects:

fun `get list of Books with explicit TypeToken object`() {
    val bookType = object : TypeToken<List<Book>>() {}.type
    val books = Gson().fromJson<List<Book>>(jsonStr, bookType)

     assertEquals(3, books.size)
     assertEquals("Second title", books[1].title)

3.3. Using Gson and an Extension Function

Kotlin allows for reified type parameters to know the exact type that a generic type parameter T represents at runtime. In order to use the reified type, we need to use an inline function.

Therefore, we can wrap the creation of an anonymous object of the TypeToken class in an extension function that is inline and makes use of a reified parameter. This allows for a more fluid deserialization syntax that just needs to make use of a type parameter.

First, we create an extension function on Gson to obtain our custom Kotlin object list from a JSON string:

inline fun <reified T> Gson.fromJsonList(json: String) 
        = fromJson<List<T>>(json, object : TypeToken<List<T>>() {}.type)

Second, we use an inline function with the reified keyword to mitigate type erasure at runtime.

T is a generic type that will be inferred from the call to the inline function. Therefore, we don’t need to specify the type parameter explicitly. Lastly, object is an anonymous instance class that extends from TypeToken.

This inline function accepts a JSON string as a parameter and returns a list of custom objects specified by T.

Let’s see how to use this inline function in a simple test:

fun `get list of Books with Gson extension function`() {
    val books = Gson().fromJsonList<Book>(jsonStr)

    assertEquals(3, books.size)
    assertEquals("Second title", books[1].title)

3.4. Using a Generic Helper Function

Furthermore, we can deserialize a JSON string to a list of custom objects with a generic type by creating a helper function that facilitates the creation of a TypeToken class:

inline fun <reified T> genericType(): Type = object: TypeToken<T>() {}.type

Finally, let’s test our helper function:

fun `get list of Books with generic helper function`() {
    val bookType = genericType<List<Book>>()
    val gson = Gson()
    val books = gson.fromJson<List<Book>>(userJson, bookType)

    assertEquals(3, books.size)
    assertEquals("Third title", books[2].title)

4. Conclusion

In this article, we’ve explored how we can use Gson to deserialize JSON to custom Kotlin objects using Generics. We discussed four ways to do that, complete with concrete examples.

As always, the complete code is available over on GitHub.

Inline Feedbacks
View all comments
Comments are open for 30 days after publishing a post. For any issues past this date, use the Contact form on the site.