Removing JSON Elements With Jackson

1. Introduction

The Jackson library is a powerful tool for working with JSON (JavaScript Object Notation) in Java applications. Additionally, it provides a wide range of features to read, write, and manipulate JSON data efficiently. Consequently, one common task when dealing with JSON is removing specific elements from the JSON structure.

In this tutorial, we’ll explore how to remove JSON elements using Jackson and understand the process through practical examples.

2. Setting up the Environment

To use Jackson, let’s first add the jackson-dataformat-xml dependency to our pom.xml file:

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
    <version>2.15.2</version>
</dependency>

This library allows us to use the data binding API.

3. Removing JSON Elements by Key

When it comes to removing JSON, the simplest way to do that is by its key. Jackson provides several methods that facilitate this task. One of the commonly used approaches is with the JsonNode class, which represents a JSON node in the Jackson API.

To remove an element by key, we’d follow these steps:

• Parse the JSON string or input stream using the Jackson ObjectMapper
• Convert the JSON data into a JsonNode object
• Use the remove(String fieldName) method on the JsonNode object to remove the desired element
• Convert the modified JsonNode back into a JSON string usingObjectMapper

Let’s suppose we have the following JSON object:

{
    "name": "John",
    "age": 30,
    "city": "New York"
}

We’d like to remove the age property from this object. Below is the corresponding code snippet:

@Test
public void given_JsonData_whenUsingJackson_thenRemoveElementByKey() throws JsonProcessingException {
    String json = "{\"name\": \"John\", \"age\": 30, \"city\": \"New York\"}";
    ObjectMapper objectMapper = new ObjectMapper();
    JsonNode jsonNode = objectMapper.readTree(json);
    ObjectNode object = (ObjectNode) jsonNode;
    object.remove("age");
    String updatedJson = objectMapper.writeValueAsString(object);
    Assertions.assertEquals("{\"name\":\"John\",\"city\":\"New York\"}", updatedJson);
}

In the above test method, we remove the element with the key age from the JSON object and verify that the resulting JSON string doesn’t contain that element.

The expected and actual JSON output should be the same:

{
    "name": "John",
    "city": "New York"
}

4. Removing JSON Elements by Conditions

Sometimes, there are situations where we need to remove elements from a collection based on specific conditions. For instance, we might want to remove all elements with a particular value or of a particular type.

Luckily, Jackson offers multiple methods to achieve this objective. One approach involves using JsonNode, iterating through its elements, and removing elements that meet the given condition.

Let’s consider the given scenario where we have the following JSON object:

{
    "name": "John",
    "age": 30,
    "city": "New York"
}

We’d like to remove any element that is a number and has a value of 30 from this object. Let’s see how to do this:

@Test
public void given_JsonData_whenUsingJackson_thenRemoveElementsByCondition() throws JsonProcessingException {
    String json = "{\"name\": \"John\", \"age\": 30, \"city\": \"New York\"}";
    ObjectMapper objectMapper = new ObjectMapper();
    JsonNode jsonNode = objectMapper.readTree(json);
    Iterator<JsonNode> elements = jsonNode.elements();
    while (elements.hasNext()) {
        JsonNode element = elements.next();
        if (element.isNumber() && element.asInt() == 30) {
            elements.remove();
        }
    }
    String updatedJson = objectMapper.writeValueAsString(jsonNode);
    Assertions.assertEquals("{\"name\":\"John\",\"city\":\"New York\"}", updatedJson);
}

In the above example, we iterate through the elements of the JsonNode and remove any element that’s a number and has a value of 30. The resulting JSON string doesn’t contain the removed element.

The expected JSON output and the actual JSON output should be the same:

{
    "name": "John",
    "city": "New York"
}

5. Removing JSON Elements From Complex Structures

In some cases, we may encounter complex JSON structures that consist of nested objects or arrays. Handling these structures efficiently requires the ability to remove specific elements based on our requirements.

By using Jackson’s rich set of APIs, we can iterate over the elements of a JsonNode instance and perform conditional checks to identify elements for removal.

To remove elements from nested objects or arrays, we follow these steps:

• Parse the JSON string or input stream usingObjectMapper
• Traverse the JSON structure to reach the desired element using JsonNode methods like get(String fieldName) or path(String fieldName)
• Use the appropriate removal method (remove(String fieldName), remove(int index), etc.) on the selected JsonNode
• Convert the modified JsonNode back into a JSON string using the ObjectMapper

Let’s consider we’re dealing with a nested JSON object that has a complex structure:

{
    "name": "John",
    "details": {
        "age": 30,
        "city": "New York"
    }
}

We’d like to remove the element with the key age from the details nested object:

@Test
public void given_JsonData_whenUsingJackson_thenRemoveElementFromNestedStructure() throws JsonProcessingException {
    String json = "{\"name\": \"John\", \"details\": {\"age\": 30, \"city\": \"New York\"}}";
    ObjectMapper objectMapper = new ObjectMapper();
    JsonNode jsonNode = objectMapper.readTree(json);
    JsonNode detailsNode = jsonNode.path("details");
    ((ObjectNode) detailsNode).remove("age");
    String updatedJson = objectMapper.writeValueAsString(jsonNode);
    Assertions.assertEquals("{\"name\":\"John\",\"details\":{\"city\":\"New York\"}}", updatedJson);
}

In the above code, we access the nested object (details) and remove the element with the key (age). The resulting JSON string reflects the modified structure, and the expected JSON output should be the same as the actual JSON output:

{
    "name": "John",
    "details": {
        "city": "New York"
    }
}

6. Conclusion

In this article, we explored different techniques to remove JSON elements using the Jackson library in Java. We discussed removing elements by key, removing elements based on conditions, and removing elements from complex JSON structures.

Overall, by using the powerful features provided by Jackson, we can easily manipulate JSON data to meet our application’s requirements.