How to Read and Write JSON Files in Java

Java provides several libraries to work with JSON data. This guide will explore how to read and write JSON files using popular libraries like Jackson and Gson. JSON (JavaScript Object Notation) is a lightweight data interchange format that's easy for humans to read and write and easy for machines to parse and generate.

1. Libraries for JSON in Java

Two of the most commonly used libraries for handling JSON in Java are:

• Jackson: A popular JSON library for Java that provides comprehensive support for reading and writing JSON.
• Gson: A library developed by Google, known for its ease of use and the ability to convert Java Objects into their JSON representation and vice versa.

2. Adding Dependencies

To use these libraries, you need to include them in your project. If you're using Maven, you can add the following dependencies:

For Jackson

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.13.0</version>
</dependency>

For Gson

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.8.9</version>
</dependency>

3. Writing JSON to a File

Let's start with writing JSON data to a file using both Jackson and Gson.

Using Jackson

Create a Java class representing the data structure, and then use the Jackson library to serialize it to JSON format.

If you're using Eclipse and prefer to add the JAR files manually, follow the steps outlined in this guide on how to add external libraries (JAR files) in Eclipse.

import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.File;
import java.io.IOException;

public class WriteJsonExample {
    public static void main(String[] args) {
        ObjectMapper mapper = new ObjectMapper();

        // Sample data object
        Person person = new Person("John", "Doe", 30);

        try {
            // Write object to JSON file
            mapper.writeValue(new File("person.json"), person);
            System.out.println("JSON file created: " + new File("person.json").getAbsolutePath());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

class Person {
    private String firstName;
    private String lastName;
    private int age;

    public Person() { }

    public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    // Getters and setters omitted for brevity
}

Using Gson

import com.google.gson.Gson;
import java.io.FileWriter;
import java.io.IOException;

public class WriteJsonWithGson {
    public static void main(String[] args) {
        Gson gson = new Gson();

        // Sample data object
        Person person = new Person("John", "Doe", 30);

        try (FileWriter writer = new FileWriter("person_gson.json")) {
            gson.toJson(person, writer);
            System.out.println("JSON file created: " + new File("person_gson.json").getAbsolutePath());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

4. Reading JSON from a File

Next, let's read JSON data from a file and deserialize it into a Java object.

Using Jackson

import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.File;
import java.io.IOException;

public class ReadJsonExample {
    public static void main(String[] args) {
        ObjectMapper mapper = new ObjectMapper();

        try {
            // Read JSON file and convert to Person object
            Person person = mapper.readValue(new File("person.json"), Person.class);
            System.out.println("Person from JSON: " + person.getFirstName() + " " + person.getLastName());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Using Gson

import com.google.gson.Gson;
import java.io.FileReader;
import java.io.IOException;

public class ReadJsonWithGson {
    public static void main(String[] args) {
        Gson gson = new Gson();

        try (FileReader reader = new FileReader("person_gson.json")) {
            // Read JSON file and convert to Person object
            Person person = gson.fromJson(reader, Person.class);
            System.out.println("Person from JSON: " + person.getFirstName() + " " + person.getLastName());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

5. Creating a JSON Utility Class

To make JSON handling more convenient, you can create a utility class that abstracts the reading and writing operations. This class will provide generic methods to serialize and deserialize objects.

import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.File;
import java.io.IOException;

public class JsonUtil {

    private static final ObjectMapper mapper = new ObjectMapper();

    public static  void writeJsonToFile(String filePath, T object) throws IOException {
        mapper.writeValue(new File(filePath), object);
    }

    public static  T readJsonFromFile(String filePath, Class clazz) throws IOException {
        return mapper.readValue(new File(filePath), clazz);
    }
}

6. Using the JSON Utility Class

Now, you can easily read and write JSON files using the utility class:

public class JsonUtilExample {
    public static void main(String[] args) {
        String filePath = "person.json";

        // Sample data object
        Person person = new Person("Jane", "Doe", 28);

        try {
            // Write JSON to file
            JsonUtil.writeJsonToFile(filePath, person);

            // Read JSON from file
            Person newPerson = JsonUtil.readJsonFromFile(filePath, Person.class);
            System.out.println("Person from JSON: " + newPerson.getFirstName() + " " + newPerson.getLastName());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

7. Conclusion

This guide covered how to read and write JSON files in Java using Jackson and Gson libraries. Whether you're handling simple data structures or complex objects, these libraries offer powerful tools for JSON processing in Java.