com.mokung.pomegranate.jackson.JsonUtils Maven / Gradle / Ivy

Go to download
package com.mokung.pomegranate.jackson;

import java.io.IOException;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.fasterxml.jackson.databind.node.TextNode;

/**
 * json 工具
 * 
 * @author mokung
 */
public final class JsonUtils {

    /***
     * 字符串 解析 为 Pojo
     *
     * @param txt
     *            json 字符串
     * @param clazz
     *            clazz
     * @param 
     *            类型
     * @return null:解析失败
     */
    public static  T parserPojo(final String txt, final Class clazz) {
        return parserPojo(getDefaultObjectMapper(), txt, clazz);
    }

    /***
     * 字符串 解析 为 Pojo
     * 
     * @param objectMapper
     *            objectMapper
     * @param txt
     *            json 字符串
     * @param clazz
     *            clazz
     * @param 
     *            类型
     * @return null:解析失败
     */
    public static  T parserPojo(final ObjectMapper objectMapper, final String txt, final Class clazz) {
        JsonNode jsonNode = parserJsonNode(objectMapper, txt);
        if (jsonNode == null) {
            return null;
        }
        try {
            JsonNode valueJsonStringNode = objectMapper.readTree(objectMapper.writeValueAsString(jsonNode));
            return objectMapper.treeToValue(valueJsonStringNode, clazz);
        } catch (Exception e1) {
            return null;
        }
    }

    /***
     * 解析 json 为 {@link JsonArray}
     * 
     * @param txt
     *            json字符串
     * @return null:解析异常
     */
    public static JsonArray parserArray(final String txt) {
        return parserArray(getDefaultObjectMapper(), txt);
    }

    /***
     * 解析 json 为 {@link JsonArray}
     *
     * @param objectMapper
     *            objectMapper
     * @param txt
     *            json字符串
     * @return null:解析异常
     */
    public static JsonArray parserArray(final ObjectMapper objectMapper, final String txt) {
        AbstractJsonContainer jsonContainer = parserJsonContainer(objectMapper, txt);
        if (jsonContainer instanceof JsonArray) {
            return (JsonArray)jsonContainer;
        }
        return null;
    }

    /***
     * 解析 json 为 {@link JsonObject}
     * 
     * @param txt
     *            json字符串
     * @return null:解析异常
     */
    public static JsonObject parserObject(final String txt) {
        return parserObject(getDefaultObjectMapper(), txt);
    }

    /***
     * 解析 json 为 {@link JsonObject}
     *
     * @param objectMapper
     *            objectMapper
     * @param txt
     *            json字符串
     * @return null:解析异常
     */
    public static JsonObject parserObject(final ObjectMapper objectMapper, final String txt) {
        AbstractJsonContainer jsonContainer = parserJsonContainer(objectMapper, txt);
        if (jsonContainer instanceof JsonObject) {
            return (JsonObject)jsonContainer;
        }
        return null;
    }

    /***
     * 
     * 
     * 解析 json 为 {@link JsonObject} 或 {@link JsonArray}
     * 
     * @param txt
     *            json字符串
     * @return null:解析异常
     */
    public static AbstractJsonContainer parserJsonContainer(final String txt) {
        return parserJsonContainer(getDefaultObjectMapper(), txt);
    }

    /***
     * 解析 json 为 {@link JsonObject} 或 {@link JsonArray}
     * 
     * @param objectMapper
     *            objectMapper
     * @param txt
     *            json字符串
     * @return null:解析异常
     */
    public static AbstractJsonContainer parserJsonContainer(final ObjectMapper objectMapper, final String txt) {
        JsonNode jsonNode = parserJsonNode(objectMapper, txt);
        if (jsonNode instanceof ObjectNode) {
            return new JsonObject(objectMapper, (ObjectNode)jsonNode);
        }
        if (jsonNode instanceof ArrayNode) {
            return new JsonArray(objectMapper, (ArrayNode)jsonNode);
        }
        return null;
    }

    /**
     * 解析字符串为 {@link JsonNode}
     *
     * @param txt
     *            json字符串
     * @return null:解析异常
     */
    public static JsonNode parserJsonNode(final String txt) {
        return parserJsonNode(getDefaultObjectMapper(), txt);
    }

    /**
     * 解析字符串为 {@link JsonNode}
     * 
     * @param objectMapper
     *            ObjectMapper
     * @param txt
     *            json字符串
     * @return null:解析异常
     */
    public static JsonNode parserJsonNode(final ObjectMapper objectMapper, final String txt) {
        try {
            return objectMapper.readTree(txt);
        } catch (IOException e) {
            return new TextNode(txt);
        }
    }

    /**
     * pojo 转换为 {@link JsonArray}
     *
     * @param object
     *            pojo
     * @return null 解析异常
     */
    public static JsonArray toJsonArray(final Object object) {
        return toJsonArray(getDefaultObjectMapper(), object);
    }

    /**
     * pojo 转换为 {@link JsonArray}
     *
     * @param objectMapper
     *            ObjectMapper
     * @param object
     *            pojo
     * @return null 解析异常
     */
    public static JsonArray toJsonArray(final ObjectMapper objectMapper, final Object object) {
        String txt = toJsonString(objectMapper, object);
        if (txt == null) {
            return null;
        }
        return parserArray(objectMapper, txt);
    }

    /**
     * pojo 转换为 {@link JsonObject}
     *
     * @param object
     *            pojo
     * @return null 解析异常
     */
    public static JsonObject toJsonObject(final Object object) {
        return toJsonObject(getDefaultObjectMapper(), object);
    }

    /**
     * pojo 转换为 {@link JsonObject}
     *
     * @param objectMapper
     *            ObjectMapper
     * @param object
     *            pojo
     * @return null 解析异常
     */
    public static JsonObject toJsonObject(final ObjectMapper objectMapper, final Object object) {
        String txt = toJsonString(objectMapper, object);
        if (txt == null) {
            return null;
        }
        return parserObject(objectMapper, txt);
    }

    /**
     * pojo 转换为 {@link JsonNode}
     *
     * @param object
     *            pojo
     * @return null 解析异常
     */
    public static JsonNode toJsonNode(final Object object) {
        return toJsonNode(getDefaultObjectMapper(), object);
    }

    /**
     * pojo 转换为 {@link JsonNode}
     * 
     * @param objectMapper
     *            ObjectMapper
     * @param object
     *            pojo
     * @return null 解析异常
     */
    public static JsonNode toJsonNode(final ObjectMapper objectMapper, final Object object) {
        String txt = toJsonString(objectMapper, object);
        if (txt == null) {
            return null;
        }
        return parserJsonNode(objectMapper, txt);
    }

    /**
     * pojo 转换为 json 字符串
     *
     * @param object
     *            pojo
     * @return null 转换失败
     */
    public static String toJsonString(final Object object) {
        return toJsonString(getDefaultObjectMapper(), object);
    }

    /**
     * pojo 转换为 json 字符串
     * 
     * @param objectMapper
     *            {@link ObjectMapper}
     * @param object
     *            pojo
     * @return null 转换失败
     */
    public static String toJsonString(final ObjectMapper objectMapper, final Object object) {
        try {
            return objectMapper.writeValueAsString(object);
        } catch (JsonProcessingException e) {
            return null;
        }
    }

    /**
     * 获取默认的 {@link ObjectMapper}
     * 
     * @return {@link ObjectMapper}
     */
    private static ObjectMapper getDefaultObjectMapper() {
        return GlobalConfiguration.getInstance().getObjectMapper();
    }

    private JsonUtils() {}
}