Parsing JSON Data in Android Apps

In the previous chapter, we learned how to perform network requests using Retrofit, providing our Android app with a simple yet powerful solution. Now, we’ll delve deeper into parsing JSON data retrieved from the server—converting it into objects usable within our application.

Introduction to JSON Data Structure

JSON (JavaScript Object Notation) is a lightweight data interchange format that is easy for humans to read and write, and equally easy for machines to parse and generate. Typically, JSON data follows a key-value structure. Here’s an example:

{
  "user": {
    "id": 1,
    "name": "John Doe",
    "email": "john@example.com"
  },
  "posts": [
    {
      "id": 1,
      "title": "Hello World",
      "content": "This is my first post."
    },
    {
      "id": 2,
      "title": "Another Post",
      "content": "This is another post."
    }
  ]
}

In this chapter, we’ll discuss how to parse JSON data in the above format using the Gson library.

Adding Dependencies

First, we need to add the Gson library dependency to the project’s build.gradle file. Add the following line inside the dependencies block:

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

Ensure you sync your project to download the library.

Creating Data Models

To parse JSON data, we need corresponding Java classes that map the JSON structure. For the example above, the user and posts sections can be modeled as follows:

public class User {
    private int id;
    private String name;
    private String email;

    // Getters and Setters
}

public class Post {
    private int id;
    private String title;
    private String content;

    // Getters and Setters
}

public class ResponseData {
    private User user;
    private List<Post> posts;

    // Getters and Setters
}

Parsing JSON Data

Next, we’ll demonstrate how to use Gson to parse JSON data obtained via Retrofit. We assume Retrofit has already been configured and can successfully retrieve JSON responses.

Example

Below is a complete example showing how to fetch data using Retrofit and parse the resulting JSON:

import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;
import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;
import com.google.gson.Gson;

public class ApiService {

    // Retrofit base configuration
    private static final String BASE_URL = "https://api.example.com/";
    private Retrofit retrofit;

    public ApiService() {
        retrofit = new Retrofit.Builder()
                .baseUrl(BASE_URL)
                .addConverterFactory(GsonConverterFactory.create())
                .build();
    }

    public void getUserData() {
        MyApi api = retrofit.create(MyApi.class);
        Call<ResponseData> call = api.getUserData();
        call.enqueue(new Callback<ResponseData>() {
            @Override
            public void onResponse(Call<ResponseData> call, Response<ResponseData> response) {
                if (response.isSuccessful()) {
                    ResponseData data = response.body();
                    if (data != null) {
                        User user = data.getUser();
                        List<Post> posts = data.getPosts();
                        // Process the data
                        System.out.println(user.getName());
                        for (Post post : posts) {
                            System.out.println(post.getTitle());
                        }
                    }
                }
            }

            @Override
            public void onFailure(Call<ResponseData> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }
}

In this example, we first issue a network request via Retrofit and receive a ResponseData object. Then, we directly invoke getUser() and getPosts() to access the User and Post data.

Summary

In this chapter, we learned how to use the Gson library to parse JSON data returned from network requests. Through a concrete example, we demonstrated how to map JSON structures onto our data models—and how to utilize those parsed objects within the app. Understanding JSON structure and its mapping to Java objects is essential foundational knowledge for upcoming topics, including network requests using OkHttp.

The next chapter will cover how to perform network requests using the OkHttp library, along with handling JSON parsing in a similar fashion.