如何使用 spring 引导 api 调用提取嵌套的 json 值

Question

I have the following json.

[
    {
        "id": 1,
        "footwearList": [
            {
                "id": 1,
                "name": "sandals",
                "category": "men"
            },
            {
                "id": 3,
                "name": "sandals",
                "category": "women"
            }
        ],
        "clothingList": [
            {
                "id": 1,
                "name": "t-shirt",
                "category": "men"
            },
            {
                "id": 3,
                "name": "tshirt",
                "category": "women"
            }
        ]
    },
    {
        "id": 2,
        "footwearList": [
            {
                "id": 2,
                "name": "shoes",
                "category": "men"
            },
            {
                "id": 4,
                "name": "shoes",
                "category": "women"
            }
        ],
        "clothingList": [
            {
                "id": 2,
                "name": "shirt",
                "category": "men"
            },
            {
                "id": 4,
                "name": "shirt",
                "category": "women"
            }
        ]
    }
]

Fetched this json from api call from controller and wanted to fetch nested values like (footwearlist, clothinglist) from the json through api call from controller. And if found then again fetching by filtering category.

I tried using JsonPath with added dependency in pom.xml

Dependency:

<dependency>
            <groupId>com.jayway.jsonpath</groupId>
            <artifactId>json-path</artifactId>
            <version>2.7.0</version>
        </dependency>

Tried to fetch the nested json but it didn,t work.

    public List<Store> getCategory(){
        List<Store> footwear = JsonPath.read(json, "$..footwear");
    }

Answer 1

There's no need to introduce a new dependency, there are several possible way to solve this problem using Jackson.

Jackson Streaming API

If, for some reason, you don't want to materialize all data as objects and want to iterate over it. Then generate a JsonNode from your JSON using ObjectMapper.readTree() , and examine the field-names of each nested node. For that, you can use JsonNode.fields() . If the matching field was encountered - grab the data.

To check whether a field is matching you can make use of the regular expression. Here's regex-based predicate that would check if the given string contains substring "footwear" :

public static final Predicate<String> FOOTWEAR = Pattern.compile("footwear").asPredicate();

That's how the code for iterating over the tree having the structure you shown might look like:

String json = // incoming JSON
        
ObjectMapper mapper = new ObjectMapper();
        
List<Item> items = StreamSupport.stream(mapper.readTree(json).spliterator(), false)
    .<JsonNode>mapMulti((node, consumer) ->
        node.fields().forEachRemaining(entry -> {
            if (FOOTWEAR.test(entry.getKey())) entry.getValue().forEach(consumer);
        })
    )
    .map(StreamingNestedObjects::nodeToItem)
    .toList();
        
items.forEach(System.out::println);

Output:

Item{id=1, name='sandals', category='men'}
Item{id=3, name='sandals', category='women'}
Item{id=2, name='shoes', category='men'}
Item{id=4, name='shoes', category='women'}

Assuming that Item class look like this:

public class Item {
    private int id;
    private String name;
    private String category;
    
    // getters, setters, etc.
}

But the incoming JSON is not very massive, I would advise to make of the Jackson's Data binding.

Data Binding

Consider the following class Store :

public class Store {
    private int id;
    private Map<String, List<Item>> items = new HashMap<>();
    
    @JsonAnySetter
    public void readStore(String key, List<Item> value) {
        items.put(key, value);
    }

    @JsonAnyGetter
    public Map<String, List<Item>> writeStore(String key, List<Item> value) {
        return items;
    }

    // no-args constructor, getter and setter for id property, etc.
}

One of its properties is a map of type Map<String, List<Item>> containing lists of items. This map can be serialized/deserialized via @JsonAnySetter and @JsonAnyGetter .

That how you can parse your incoming JSON into a list of Store instances:

ObjectMapper mapper = new ObjectMapper();
        
List<Store> stores = mapper.readValue(json, new TypeReference<>() {});

Then iterate over the list, check the Keys of the Maps and pick the stores you need.