Skip to main content

How to handle nested JSON objects using GSON in Kotlin Android

How to handle nested JSON objects using GSON in Kotlin Android.

Here's a detailed step-by-step tutorial on how to handle nested JSON objects using GSON in Kotlin for Android development.

Step 1: Add GSON Dependency​

To begin with, you need to add the GSON library as a dependency in your project. Open your app-level build.gradle file and add the following line under the dependencies section:

implementation 'com.google.code.gson:gson:2.8.7'

Sync your project, and you will be able to use GSON in your Kotlin code.

Step 2: Create Model Classes​

Next, you need to create model classes that represent the structure of the JSON objects you want to parse. For example, let's say we have the following JSON object:

{
  "name": "John Doe",
  "age": 30,
  "address": {
    "street": "123 Main St",
    "city": "New York",
    "state": "NY"
  }
}

To parse this JSON, create two model classes: Person and Address. Here's how you can define these classes in Kotlin:

data class Address(
    val street: String,
    val city: String,
    val state: String
)

data class Person(
    val name: String,
    val age: Int,
    val address: Address
)

Step 3: Parse JSON using GSON​

Now, you can use GSON to parse the JSON string into your model classes. Here's an example of how to do it:

val jsonString = "{\"name\":\"John Doe\",\"age\":30,\"address\":{\"street\":\"123 Main St\",\"city\":\"New York\",\"state\":\"NY\"}}"
val gson = Gson()
val person = gson.fromJson(jsonString, Person::class.java)

In this example, we create a Gson object, and then use its fromJson() method to parse the JSON string into an instance of the Person class.

Step 4: Access Nested JSON Data​

Once you have parsed the JSON into your model classes, you can access the data using the properties of the model objects. For example:

val name = person.name
val age = person.age
val street = person.address.street
val city = person.address.city
val state = person.address.state

In this code snippet, we access the name and age properties directly from the person object. We also access the nested address object and its properties (street, city, and state).

That's it! You have successfully parsed and accessed nested JSON objects using GSON in Kotlin.

Additional Tips​

  • If your JSON contains an array of nested objects, you can define a list property in your model class to represent it. GSON will automatically parse the array into a list of objects.
  • If your JSON contains optional fields or fields with different names than your model properties, you can use annotations provided by GSON to handle them. For example, you can use @SerializedName to specify a different name for a property.

Here's an example of using GSON annotations to handle optional fields:

data class Person(
    val name: String,
    val age: Int,
    @SerializedName("phone_number")
    val phoneNumber: String?
)

In this example, the phoneNumber field in the JSON has a different name than the property in the model class, and it is marked as optional using the ? operator.

I hope this tutorial helps you handle nested JSON objects using GSON in Kotlin for Android development.