How to Remove a text node from a Json file using Jackson

I'm trying to remove a text node from Json using Jackson api, but I'm getting below error :

com.fasterxml.jackson.databind.node.TextNode cannot be cast to com.fasterxml.jackson.databind.node.ObjectNode

not sure where I went to wrong.

    ObjectMapper mapper = new ObjectMapper();
    
    JsonNode json = mapper.readValue(jsonText, JsonNode.class);
    for (JsonNode node : json) {
    			if (node.isNull() || node.isBoolean() || node.isNumber() || node.isTextual()) {
    					((ObjectNode) node).removeAll();
    }
}

I got why I'm getting here bcz I'm trying to convert primitive to Object, how to Delete a primitive node from a Json, what do I need to do here.

The problem here is not because of primitives vs. objects, but because an ObjectNode represents a JSON object - namely a {...} structure, whereas a TextNode represents a piece of JSON text "foo". You can't convert between these different Java objects representing these different JSON structures.

To delete sections of a JSON structure, I would recommend using an iterator.

Assume we have some test data:

{
	"count": 123,
	"active": true,
	"message": "hello world",
	"details": {
		"firstName": "John",
		"lastName": "Smith"
	}
}

I will process this as a string in the following code example:

String jsonText = "{\"count\":123,\"active\":true,\"message\":\"hello world\",\"details\":{\"firstName\":\"John\",\"lastName\":\"Smith\"}}";
System.out.println(jsonText);
        
ObjectMapper mapper = new ObjectMapper();
JsonNode json = mapper.readValue(jsonText, JsonNode.class);
        
Iterator<JsonNode> it = json.iterator();
while (it.hasNext()) {
    JsonNode node = it.next();
    if (node.isNull() || node.isBoolean() || node.isNumber() || node.isTextual()) {
        it.remove(); 
    } 
}

String outputText = mapper.writeValueAsString(json);
System.out.println(outputText);

The output from this is as follows:

{"count":123,"active":true,"message":"hello world","details":{"firstName":"John","lastName":"Smith"}}
{"details":{"firstName":"John","lastName":"Smith"}}

All the text, boolean, and number fields have been removed - only the "details" object {...} is not deleted. If the test input had contained an array [...], that would also have been preserved.

Note that this solution only iterates over the top level of nodes in the JSON test data. It does not iterate over the subnodes inside the "details" array. If you want to drill down into the hierarchy of your JSON, you would need a modified approach - for example by recursively calling a method:

private JsonNode removeUnwantedNodes(JsonNode json) {
    Iterator<JsonNode> it = json.iterator();
    while (it.hasNext()) {
        JsonNode node = it.next();
        if (node.isNull() || node.isBoolean() || node.isNumber() || node.isTextual()) {
            it.remove();
        } else if (node.isContainerNode()) {
            removeUnwantedNodes(node);
        }
    }
    return json;
}

In this example, the isContainerNode() method checks for JSON objects {...} and JSON arrays [...].

Update - Empty Containers

One consequence of deleting text/boolean/number nodes is that you can end up with empty containers in your JSON: {} and [].

You may need one or more subsequent passes to remove these.

The condition to check is:

if (node.isContainerNode() && node.isEmpty()) {
    it.remove();
}

This can be added to the approach shown above.

The way I would handle this is as follows:

(a) Create a deep copy of the JSON before iterating over it (for node removal). Make the copy using JsonNode prevJson = json.deepCopy();.

(b) Use a while loop to repeatedly iterate over the JSON, comparing the resulting JSON with the previous copy:

while (!json.equals(prevJson)) {
    prevJson = json.deepCopy();
    json = iterateForRemoval(json);
}

Once the removal process can no longer find anything that needs removing, you are done.

This is necessary to clean up things such as nested arrays and objects: [ [ [...] ] ], where a first pass will only be able to clean up the innermost array, and subsequent passes will remove the resulting empty arrays.