Json 工具类

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/heihu_malice7/article/details/85334365

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializeConfig;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.alibaba.fastjson.serializer.SimpleDateFormatSerializer;
import org.apache.commons.lang3.StringUtils;
import org.codehaus.jackson.JsonParseException;
import org.codehaus.jackson.map.DeserializationConfig;
import org.codehaus.jackson.map.JsonMappingException;
import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.map.SerializationConfig;
import org.codehaus.jackson.map.annotate.JsonSerialize;
import org.codehaus.jackson.type.TypeReference;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.util.*;

public class JsonUtil {
    private static final Logger logger = LoggerFactory.getLogger(JsonUtil.class);
    private static final SerializeConfig config;
    static {
        config = new SerializeConfig();
        config.put(Date.class, new SimpleDateFormatSerializer("yyyy-MM-dd HH:mm:ss"));
    }

    /**
     * 匹配常规序列化
     */
    private static final SerializerFeature[] features = {SerializerFeature.WriteMapNullValue, // 输出空置字段
            SerializerFeature.WriteNullListAsEmpty, // list字段如果为null，输出为[]，而不是null
            SerializerFeature.WriteNullNumberAsZero, // 数值字段如果为null，输出为0，而不是null
            SerializerFeature.WriteNullBooleanAsFalse, // Boolean字段如果为null，输出为false，而不是null
            SerializerFeature.WriteNullStringAsEmpty // 字符类型字段如果为null，输出为""，而不是null
    };

    /**
     * 匹配特殊OBJECT对象序列化
     * 新版 simleFactory 二进制，高性能
     * 反序列化的作用是确定是否强制让非数组模式的json字符串与java集合类型相匹配
     */
    private static final ObjectMapper objMapper = new ObjectMapper();
    static{
        objMapper.configure(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        objMapper.configure(SerializationConfig.Feature.WRITE_DATES_AS_TIMESTAMPS, false);
        objMapper.setSerializationInclusion(JsonSerialize.Inclusion.NON_NULL);
        objMapper.configure(DeserializationConfig.Feature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);
    }

    /** Object TO Json String 字符串输出 */
    public static String toJson(Object object) {
        try {
            return JSON.toJSONString(object, new SerializeConfig(), features);
        } catch (Exception e) {
            logger.error("method=toJSON() | 对象转为Json字符串 Error！" + e.getMessage(), e);
        }
        return null;
    }

    /** Object TO Json String Json-lib兼容的日期输出格式 */
    public static String toJSONLib(Object object) {
        try {
            return JSON.toJSONString(object, config, features);
        } catch (Exception e) {
            logger.error("method=toJSONLib() | 对象转为Json字符串 Json-lib兼容的日期输出格式   Error！" + e.getMessage(), e);
        }
        return null;
    }

    /** 转换为数组 Object  */
    public static <T> Object[] toArray(String text) {
        try {
            return toArray(text, null);
        } catch (Exception e) {
            logger.error("method=toArray() | 将json格式的数据转换为数组 Object  Error！" + e.getMessage(), e);
        }
        return null;
    }

    /** 转换为数组 （可指定类型）  */
    public static <T> Object[] toArray(String text, Class<T> clazz) {
        try {
            return JSON.parseArray(text, clazz).toArray();
        } catch (Exception e) {
            logger.error("method=toArray() | 将json格式的数据转换为数组 （可指定类型）   Error！" + e.getMessage(), e);
        }
        return null;
    }

    /** Json 转为  Jave Bean */
    public static <T> T toBean(String text, Class<T> clazz) {
        try {
            return JSON.parseObject(text, clazz);
        } catch (Exception e) {
            logger.error("method=toBean() | Json 转为  Jave Bean  Error！" + e.getMessage(), e);
        }
        return null;
    }

    /** Json 转为   Map */
    public static Map<?,?> toMap(String json) {
        try {
            return JSON.parseObject(json);
        } catch (Exception e) {
            logger.error("method=toMap() | Json 转为   Map {},{}" + e.getMessage(), e);
        }
        return null;
    }

    /** Json 转 List,Class 集合中泛型的类型，非集合本身，可json-lib兼容的日期格式*/
    public static <T> List<T> toList(String text, Class<T> clazz) {
        try {
            return JSON.parseArray(text, clazz);
        } catch (Exception e) {
            logger.error("method=toList() | Json 转为   List {},{}" + e.getMessage(), e);
        }
        return null;
    }

    public static HashMap<String, Object> fromJsonToMap(String json) {
        HashMap<String, Object> map = new HashMap<String, Object>();
        try {
            map = objMapper.readValue(json, map.getClass());
        } catch (JsonParseException e) {
            logger.error("Json串转换成对象出错：{}"+json);
            return null;
        } catch (JsonMappingException e) {
            logger.error("Json串转换成对象出错：{}"+ json);
            return null;
        } catch (IOException e) {
            logger.error("Json串转换成对象出错：{}"+ json);
            return null;
        }
        return map;
    }

    /**
     * 读取集合如List/Map,且不是List<String>时.
     * @param jsonString
     * @param typeReference
     * @return
     */
    public static <T> T fromJsonForList(String jsonString, TypeReference<T> typeReference) {
        if (StringUtils.isBlank(jsonString)) {
            return null;
        }
        try {
            return (T) objMapper.readValue(jsonString, typeReference);
        }
        catch (IOException e) {
            logger.error("parse json string error:" + jsonString, e);
        }
        return null;
    }


    /** 从json字符串获取指定key的字符串 */
    public static Object getValueFromJson(final String json, final String key) {
        try {
            if(StringUtils.isNotBlank(json) || StringUtils.isNotBlank(key)){
                return JSON.parseObject(json).getString(key);
            }
        } catch (Exception e) {
            logger.error("method=getStringFromJson() | 从json获取指定key的字符串 Error！" + e.getMessage(), e);
        }
        return null;
    }
}