java 数据处理 json、json数组 自己封装的一个工具类

package com.sk.skwmsapi.common.utils;


import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.type.TypeFactory;

import java.io.IOException;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.logging.Logger;
import java.util.stream.Collectors;


/**
 * /**
 *
 * @ClassName JsonDataUtil
 * @description: TODO
 * @Author：Fan
 * @Date：2024-05-05-11:44
 * @Description： extractNestedList: 从JSON字符串中提取嵌套的列表。
 * transformList: 提取JSON中的数据列表并应用自定义转换函数。
 * deserializeList: 直接反序列化JSON字符串到对象列表。
 * deserializeAndTransformList: 直接反序列化JSON字符串到对象列表后，进一步应用转换逻辑。
 */
public class JsonDataUtil {


    private static final Logger log = Logger.getLogger(JsonDataUtil.class.getName());
    private static final ObjectMapper objectMapper = new ObjectMapper();


    /**
     * 从JSON字符串中直接提取指定字段的值，假设字段值为List<Map<String, Object>>类型。
     *
     * @param jsonString JSON字符串
     * @param fieldName  要提取的字段名
     * @return 字段对应的List<Map < String, Object>>值，或null（如果解析失败或字段不存在）
     */
    public static List<Map<String, Object>> extractNestedList(String jsonString, String fieldName) {
        try {
            JsonNode rootNode = objectMapper.readTree(jsonString);
            JsonNode nodeList = rootNode.path(fieldName);
            if (nodeList.isArray()) {
                // 使用readValue方法直接将JsonNode转换为List<Map<String, Object>>
                return objectMapper.readValue(nodeList.traverse(), new TypeReference<List<Map<String, Object>>>() {
                });
            }
        } catch (IOException e) {
            log.severe("Error extracting nested list: " + e.getMessage());
        }
        // 如果发生错误或未找到任何数据，返回空列表
        return Collections.emptyList();
    }

    /**
     * 将JSON字符串中指定字段的值转换为指定类型列表。
     *
     * @param <T>         目标类型
     * @param jsonString  JSON字符串
     * @param fieldName   要提取的字段名
     * @param transformer 转换函数，将Map<String, Object>转换为目标类型T
     * @return 转换后的列表，或空列表（如果解析失败或字段不存在）
     */
    public static <T> List<T> transformList(String jsonString, String fieldName, Function<Map<String, Object>, T> transformer) {
        try {
            List<Map<String, Object>> dataList = extractNestedList(jsonString, fieldName);
            return dataList.stream().map(transformer).collect(Collectors.toList());
        } catch (Exception e) {
            log.severe("Error transforming list: " + e.getMessage());
        }
        return Collections.emptyList();
    }

    /**
     * 直接从JSON字符串反序列化指定字段为对象列表。
     *
     * @param <T>        目标类型
     * @param jsonString JSON字符串
     * @param clazz      目标类型的Class对象
     * @return 反序列化后的对象列表，或空列表（如果解析失败或字段不存在）
     */
    public static <T> List<T> deserializeList(String jsonString, Class<T[]> clazz) {
        try {
            JavaType type = TypeFactory.defaultInstance().constructCollectionType(List.class, clazz);
            return objectMapper.readValue(jsonString, type);
        } catch (IOException e) {
            log.severe("Error deserializing list: " + e.getMessage());
        }
        return Collections.emptyList();
    }

    /**
     * 直接从JSON字符串反序列化指定字段为对象列表，并应用转换函数进一步处理。
     *
     * @param <T>         目标类型
     * @param jsonString  JSON字符串
     * @param clazz       目标类型的Class对象
     * @param transformer 自定义转换函数，应用于反序列化后的对象
     * @return 转换后的对象列表，或空列表（如果解析失败或字段不存在）
     */
    public static <T, R> List<R> deserializeAndTransformList(String jsonString, Class<T[]> clazz, Function<T, R> transformer) {
        try {
            // 直接反序列化JSON字符串到指定类型的数组
            T[] array = objectMapper.readValue(jsonString, clazz);
            if (array != null) {
                // 将数组转换为列表，并应用转换函数处理每个元素
                return java.util.Arrays.stream(array)
                        .map(transformer)
                        .collect(Collectors.toList());
            }
        } catch (IOException e) {
            log.severe("Error deserializing and transforming list: " + e.getMessage());
        }
        return Collections.emptyList();
    }


}