Welcome to the next step in your journey of working with JSON data using Java. In previous lessons, you learned how to parse JSON files in Java and explore JSON's hierarchical structure. Now, we'll focus on constructing JSON objects and writing them to files. In this lesson, you'll discover how to create JSON objects using Java classes and serialize them using the Jackson library's ObjectMapper class.

In Java, crafting a JSON object is straightforward when the data is structured using classes. This approach allows for intuitive mapping of class fields to JSON key-value pairs, making the process efficient and organized. Here are the key steps to move from structured data to a JSON object:

1. Define Classes: Set up Java classes to represent the hierarchical structure of your JSON data. This involves identifying the main data entities and their relationships.

2. Create Instances: Instantiate these classes and populate them with data. This involves initializing objects and setting field values to reflect the information you wish to serialize.

3. Serialize to JSON: Use the Jackson library's ObjectMapper class to serialize these objects into a JSON string, ready for storage or transmission.

These steps form the foundation of translating structured class-based data into a JSON format, seamlessly bridging Java applications with JSON data handling.

In this lesson we will work with a data model for event-related information is encapsulated in two classes: Participant and Event. In order to have more control over the JSON structure, you can use the @JsonProperty annotation is directly above the fields to specify how Java fields are mapped to JSON keys during serialization.

The Participant class holds details about each event participant, including their name and project, with @JsonProperty ensuring these fields are translated the way we want into JSON properties.

Java
Copy to clipboard
1import com.fasterxml.jackson.annotation.JsonProperty;
2
3public class Participant {
4    @JsonProperty("participantName")
5    private String name;
6
7    @JsonProperty("participantProject")
8    private String project;
9
10    public Participant(String name, String project) {
11        this.name = name;
12        this.project = project;
13    }
14
15    // Getters and setters...
16}

The Event class includes general event information such as the event name and date, along with a collection of Participant objects.

Java
Copy to clipboard
1import com.fasterxml.jackson.annotation.JsonProperty;
2import java.util.ArrayList;
3import java.util.List;
4
5public class Event {
6    @JsonProperty("eventName")
7    private String event;
8
9    @JsonProperty("eventDate")
10    private String date;
11
12    @JsonProperty("eventParticipants")
13    private List<Participant> participants;
14
15    public Event(String event, String date) {
16        this.event = event;
17        this.date = date;
18        this.participants = new ArrayList<>();
19    }
20
21    public void addParticipant(Participant participant) {
22        this.participants.add(participant);
23    }
24
25    // Getters and setters...
26}

These classes form the backbone of our JSON structure, with Event serving as the primary entity encompassing participant details.

To populate our classes with data, we instantiate the Participant and Event objects.

Java
Copy to clipboard
1// Create event object
2Event event = new Event("Science Fair", "2023-05-25");
3event.addParticipant(new Participant("Alex", "Volcano Model"));
4event.addParticipant(new Participant("Jordan", "Robotics"));
5event.addParticipant(new Participant("Taylor", "Solar System"));

This setup initializes a list of participants and links them to a specific event, encapsulated within an Event.

With our data structure populated, we can serialize it into JSON format using the ObjectMapper class in Jackson.

Java
Copy to clipboard
1// Create ObjectMapper instance
2ObjectMapper objectMapper = new ObjectMapper();
3
4// Convert the event object directly to JSON string with pretty print
5String jsonString = objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(event);

This code snippet converts the structured Event object into a JSON string, optimizing it for readability with indentation.

Once we have the JSON string, the next step is to write it to a file for storage or distribution.

Java
Copy to clipboard
1// Specifying the output file path as a Path object
2Path outputFilePath = Paths.get("event_data.json");
3
4// Writing the JSON string to a file
5Files.write(outputFilePath, jsonString.getBytes());

The resulting JSON data stored in event_data.json would look like this:

JSON
Copy to clipboard
1{
2  "eventName": "Science Fair",
3  "eventDate": "2023-05-25",
4  "eventParticipants": [
5    {
6      "participantName": "Alex",
7      "participantProject": "Volcano Model"
8    },
9    {
10      "participantName": "Jordan",
11      "participantProject": "Robotics"
12    },
13    {
14      "participantName": "Taylor",
15      "participantProject": "Solar System"
16    }
17  ]
18}

The @JsonProperty annotations ensure that the Java fields are serialized with the chosen JSON keys. This step guarantees data persistence and facilitates storage or sharing of structured JSON data.

In this lesson, you've gained skills in constructing and writing JSON data using Java. We began with simple objects, expanded into complex structures involving collections, and wrote the data to a file in a clearly formatted manner. These capabilities are crucial for handling JSON in real-world applications.

Congrats on reaching this stage in the course! You are now equipped with the essential skills for managing JSON data effectively. Up next, you'll find practice exercises to bolster your understanding with hands-on experience. Keep pushing forward!