JSON格式都可以转传入对应的class即可JSON转换实体转list任何

fastJSON为例。JSON转你传入对应的model类，或者转对应的list，入参为String，和对应的model例如student类，支持各种类型的JSON 嵌套list，map等等

@Component
@Slf4j
public class JsonUtils {
    private final ObjectMapper objectMapper;

    public JsonUtils(ObjectMapper objectMapper) {
        this.objectMapper = objectMapper;
    }


    public Object expand(Object input) {
        if (input instanceof List) {
            expandList((List<Object>) input);
            return input;
        } else if (input instanceof Map) {
            expandMap((Map<String, Object>) input);
            return input;
        } else if (input instanceof String) {
            return getJson((String) input);
        } else {
            return input;
        }
    }

    private void expandList(List<Object> input) {
        for (Object value : input) {
            if (value instanceof String) {
                if (isJsonString(value.toString())) {
                    value = getJson(value.toString());
                }
            } else if (value instanceof Map) {
                expandMap((Map<String, Object>) value);
            } else if (value instanceof List) {
                expandList((List<Object>) value);
            }
        }
    }

    private void expandMap(Map<String, Object> input) {
        for (Map.Entry<String, Object> entry : input.entrySet()) {
            Object value = entry.getValue();
            if (value instanceof String) {
                if (isJsonString(value.toString())) {
                    entry.setValue(getJson(value.toString()));
                }
            } else if (value instanceof Map) {
                expandMap((Map<String, Object>) value);
            } else if (value instanceof List) {
                expandList((List<Object>) value);
            }
        }
    }


    private Object getJson(String jsonAsString) {
        try {
            return objectMapper.readValue(jsonAsString, Object.class);
        } catch (Exception e) {
            return jsonAsString;
        }
    }

    private boolean isJsonString(String jsonAsString) {
        jsonAsString = jsonAsString.trim();
        return jsonAsString.startsWith("{") || jsonAsString.startsWith("[");
    }

    /**
     * 将对象转换成json字符串。
     * <p>Title: pojoToJson</p>
     * <p>Description: </p>
     *
     * @param data
     * @return
     */
    public String objectToJson(Object data) {
        try {
            String string = objectMapper.writeValueAsString(data);
            return string;
        } catch (JsonProcessingException e) {
            log.error("将对象转换成json字符串:", e);
        }
        return null;
    }

    /**
     * 将json结果集转化为对象
     *
     * @param jsonData json数据
     * @param beanType 对象中的object类型
     * @return
     */
    public <T> T jsonToPojo(String jsonData, Class<T> beanType) {
        try {
            T t = objectMapper.readValue(jsonData, beanType);
            return t;
        } catch (Exception e) {
            log.error("将json结果集转化为对象异常:", e);
        }
        return null;
    }

    /**
     * 将json数据转换成pojo对象list
     * <p>Title: jsonToList</p>
     * <p>Description: </p>
     *
     * @param jsonData
     * @param beanType
     * @return
     */
    public <T> List<T> jsonToList(String jsonData, Class<T> beanType) {
        try {
            Map<String, Object> input = objectMapper.readValue(jsonData, Map.class);
            List<T> list = new ArrayList<>();
            for (Map.Entry<String, Object> entry : input.entrySet()) {
                Object value = entry.getValue();
                if (value instanceof List) {
                    List<T> beanTypelist = new ArrayList<>();
                    JavaType javaType = objectMapper.getTypeFactory().constructParametricType(List.class, beanType);
                    beanTypelist = objectMapper.readValue(JSONObject.toJSONString(value), javaType);
                    list.addAll(beanTypelist);
                }
            }
            return list;
        } catch (Exception e) {
            log.error("将json数据转换成pojo对象list:", e);
        }
        return null;
    }

    public <T> T jsonToPojoByJsonKey(String jsonObject, Class<T> beanType) {
        try {
            Map<String, Object> input = objectMapper.readValue(jsonObject, Map.class);
            Class<T> searchType = beanType;
            T t = searchType.newInstance();
            for (Map.Entry<String, Object> entry : input.entrySet()) {
                T t1 = null;
                Object value = entry.getValue();
                if (value instanceof Map) {
                    t1 = objectMapper.readValue(JSONObject.toJSONString(value), beanType);
                }
                if (value instanceof String) {
                    t1 = objectMapper.readValue(JSONObject.toJSONString(entry), beanType);
                }
                if (value instanceof Integer) {
                    t1 = objectMapper.readValue(JSONObject.toJSONString(entry), beanType);
                }
                if (!ObjectUtils.isEmpty(t1)) {
                    MyBeanUtils.copyProperties(t1, t);
                }
            }

            return t;
        } catch (Exception e) {
            log.error("将json数据转换成pojo对象list:", e);
        }
        return null;
    }

    public <T> T jsonToPojoByJsonKey1(String jsonObject, T beanType) {
        try {
            Map<String, Object> input = objectMapper.readValue(jsonObject, Map.class);
            for (Map.Entry<String, Object> entry : input.entrySet()) {
                JSONObject json = (JSONObject) JSON.toJSON(entry);
                beanType = json.getObject(entry.getKey(), (Type) beanType.getClass());
            }
            return beanType;
        } catch (Exception e) {
            log.error("将json数据转换成pojo对象list:", e);
        }
        return null;
    }

    public <T> T getNodeTemplate(String jsonKey, String jsonObject, T data) {
        JSONObject json = JSONObject.parseObject(jsonObject);
        data = json.getObject(jsonKey, (Type) data.getClass());
        return data;
    }

    public static void main(String[] args) {
        //自动定义类
        ParameterValue parameterValue = new ParameterValue();
        JsonUtils jsonUtils = new JsonUtils(new ObjectMapper());
        String json = "{\n" +
                "\t\"installationSite\": {\n" +
                "\t\t\"namespace\": \"\",\n" +
                "\t\t\"applicationId\": \"\",\n" +
                "\t\t\"clusterId\": \"\"\n" +
                "\t},\n" +
                "\t\"globalParameters\": [{\n" +
                "\t\t\"name\": \"gjq1\",\n" +
                "\t\t\"parameterId\": \"WFPA23UboCTLAeQVN8fblyj8\",\n" +
                "\t\t\"value\": \"112\",\n" +
                "\t\t\"valueType\": \"string\"\n" +
                "\t},{\n" +
                "\t\t\"name\": \"gjq2\",\n" +
                "\t\t\"parameterId\": \"WFPA23UboCTLAeQVN8fblyj8\",\n" +
                "\t\t\"value\": \"116\",\n" +
                "\t\t\"valueType\": \"string\"\n" +
                "\t}],\n" +
                "    \t\"globalParameters1\": [{\n" +
                "\t\t\"name\": \"gjq3\",\n" +
                "\t\t\"parameterId\": \"WFPA23UboCTLAeQVN8fblyj8\",\n" +
                "\t\t\"value\": \"113\",\n" +
                "\t\t\"valueType\": \"string\"\n" +
                "\t},{\n" +
                "\t\t\"name\": \"gjq4\",\n" +
                "\t\t\"parameterId\": \"WFPA23UboCTLAeQVN8fblyj8\",\n" +
                "\t\t\"value\": \"114\",\n" +
                "\t\t\"valueType\": \"string\"\n" +
                "\t}],\n" +
                "\t\"failStrategyCode\": \"1\"\n" +
                "}";
        List<? extends ParameterValue> list = jsonUtils.jsonToList(json, parameterValue.getClass());
        list.stream().forEach(parameterValue1 -> {
            System.out.println(parameterValue1.getName());
            System.out.println(parameterValue1.getValue());
            System.out.println(parameterValue1.getValueType());
            System.out.println(parameterValue1.getParameterId());
            System.out.println("------------------");
        });
    }
}