JsonUtil

package com.gdpu.util;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.ObjectReader;
import com.fasterxml.jackson.databind.ObjectWriter;
import com.fasterxml.jackson.databind.PropertyNamingStrategy;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import java.io.IOException;
import java.util.List;
import java.util.Map;

public class JsonUtil {
    private static final ObjectWriter OBJECT_MAPPER_SNAKE_CASE_WRITER;
    private static final ObjectReader OBJECT_MAPPER_SNAKE_CASE_READER;
    private static final ObjectMapper OBJECT_MAPPER;
    private static final ObjectWriter OBJECT_WRITER;
    private static final ObjectReader OBJECT_READER;
    private static final ObjectReader OBJECT_READER_IGNORE_UNKNOWN_PROPS;


    static {
        ObjectMapper objectMapperSnakeCase = new ObjectMapper();
        objectMapperSnakeCase.setPropertyNamingStrategy(PropertyNamingStrategy.SNAKE_CASE);
        OBJECT_MAPPER_SNAKE_CASE_WRITER = objectMapperSnakeCase.writer();
        OBJECT_MAPPER_SNAKE_CASE_READER = objectMapperSnakeCase.reader();

        ObjectMapper objectMapperIgnoreUnknownProps = new ObjectMapper();
        objectMapperIgnoreUnknownProps.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        OBJECT_READER_IGNORE_UNKNOWN_PROPS = objectMapperIgnoreUnknownProps.reader();

        OBJECT_MAPPER = new ObjectMapper();
        OBJECT_WRITER = OBJECT_MAPPER.writer();
        OBJECT_READER = OBJECT_MAPPER.reader();
    }

    /**
     * 将json字符串转换为Map
     *
     * @param json json字符串
     * @return map
     */
    public static Map<String, Object> fromJson(String json) {
        try {
            return OBJECT_READER.forType(Map.class).readValue(json);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 将表示对象的json字符串转换为Json节点
     *
     * @param json json字符串
     * @return json节点
     */
    public static JsonNode toJsonNode(String json) {
        try {
            return OBJECT_READER.readTree(json);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 将对象转换为name为snake case风格json字符串
     *
     * @param object 对象
     * @return json字符串
     */
    public static String toJsonStringWithSnakeCaseName(Object object) {
        try {
            return OBJECT_MAPPER_SNAKE_CASE_WRITER.writeValueAsString(object);
        } catch (JsonProcessingException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 将对象转换为json字符串
     *
     * @param object 对象
     * @return json字符串
     */
    public static String toJsonString(Object object) {
        try {
            return OBJECT_WRITER.writeValueAsString(object);
        } catch (JsonProcessingException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 将json字符串转换为目标类的对象
     *
     * @param json  json字符串
     * @param clazz 目标类Class对象
     * @param <T>   目标类
     * @return 目标类对象
     */
    public static <T> T fromJson(String json, Class<T> clazz) {
        try {
            return OBJECT_READER.forType(clazz).readValue(json);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 将json字符串转换为目标类的对象
     *
     * @param json  json字符串
     * @param clazz 目标类Class对象
     * @param <T>   目标类
     * @return 目标类对象
     */
    public static <T> T fromJson(String json, Class<T> clazz, boolean ignoreUnknownProperties) {
        try {
            if (ignoreUnknownProperties) {
                return OBJECT_READER_IGNORE_UNKNOWN_PROPS.forType(clazz).readValue(json);
            } else {
                return OBJECT_READER.forType(clazz).readValue(json);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 将name为snake case风格的json字符串转换为目标类的对象 同fromJson
     *
     * @param json  json字符串
     * @param clazz 目标类Class对象
     * @param <T>   目标类
     * @return 目标类对象
     */
    public static <T> T fromJsonWithSnakeCaseName(String json, Class<T> clazz) {
        try {
            return OBJECT_MAPPER_SNAKE_CASE_READER.forType(clazz).readValue(json);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 将json字符串转换为目标类对象数组
     *
     * @param json  json字符串
     * @param clazz 目标对象
     * @param <T>   目标类
     * @return 目标类对象数组
     */
    public static <T> List<T> parseJArray(String json, Class<T> clazz) {
        try {
            return OBJECT_READER.forType(OBJECT_READER.getTypeFactory().constructCollectionType(List.class, clazz))
                    .readValue(json);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 创建可写的Json Node，用于构造Json对象
     *
     * @return json节点
     */
    public static ObjectNode createJsonNode() {
        return OBJECT_MAPPER.createObjectNode();
    }


    /**
     * 创建可写的Json Array Node，用于构造Json列表对象
     *
     * @return json列表节点
     */
    public static ArrayNode createJsonArrayNode() {
        return OBJECT_MAPPER.createArrayNode();
    }
}