JsonUtil

package com.zkml.common.util;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.*;

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

/**
 * @Description : 自定义工具类（逐步完善）
 * @Author :zhaojun
 * @Time :2019-04-22 14:12
 */
public final class JsonUtil {

    /**
     * 单例 ObjectMapper
     */
    private final static ObjectMapper objectMapper = new ObjectMapper();

    static {
        // 全部字段序列化
        //对象的所有字段全部列入
        objectMapper.setSerializationInclusion(JsonInclude.Include.ALWAYS);
        //取消默认转换timestamps形式
        objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, true);
        //允许非引号字段名
        objectMapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);
        //所有的日期格式都统一为以下的样式，即yyyy-MM-dd HH:mm:ss
        objectMapper.setDateFormat(new SimpleDateFormat(DateUtil.DATE_FORMAT));
        //忽略空Bean转json的错误
        objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
        //忽略 在json字符串中存在，但是在java对象中不存在对应属性的情况。防止错误
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    }

    /**
     * 返回json串
     *
     * @param obj
     * @return
     */
    public static String getJsonString(Object obj) {
        if (null == obj || isPrimitive(obj) || obj instanceof String) {
            return String.valueOf(obj);
        }
        String str = null;
        try {
            str = objectMapper.writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return str;
    }

    /**
     * json转换成对象
     *
     * @param json
     * @param tClass
     * @param <E>
     * @return
     */
    public static <E> E jsonToObject(String json, Class<E> tClass) {
        E obj = null;
        try {
            obj = objectMapper.readValue(json, tClass);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return obj;
    }

    /**
     * json转HashMap
     *
     * @param json
     * @return
     */
    public static HashMap jsonToMap(String json) {
        HashMap map = null;
        try {
            map = objectMapper.readValue(json, HashMap.class);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return map;
    }

    /**
     * object转map
     *
     * @param obj
     * @return
     */
    public static Map objectToMap(Object obj) {
        return jsonToMap(getJsonString(obj));
    }

    /**
     * map转Object
     *
     * @param map
     * @param tClass
     * @param <E>
     * @return
     */
    public static <E> E mapToObject(Map map, Class<E> tClass) {
        return jsonToObject(getJsonString(map), tClass);
    }

    /**
     * mapList转List
     *
     * @param mapList
     * @param tClass
     * @param <E>
     * @return
     */
    public static <E> List<E> mapListToObjectList(List<Map> mapList, Class<E> tClass) {
        return jsonToObject(getJsonString(mapList), List.class, tClass);
    }

    /**
     * 字段符转List之类的集合
     *
     * @param json
     * @param typeReference
     * @return
     */
    public static <E> E jsonToObject(String json, TypeReference typeReference) {
        E obj = null;
        try {
            obj = objectMapper.readValue(json, typeReference);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return obj;
    }

    /**
     * 字段符转集合类
     *
     * @param json
     * @param collectionClass 比如 List.class
     * @param elementClasses  比如  User.class
     * @return
     */
    public static <E> E jsonToObject(String json, Class<?> collectionClass, Class<?>... elementClasses) {
        JavaType javaType = objectMapper.getTypeFactory().constructParametricType(collectionClass, elementClasses);
        E obj = null;
        try {
            obj = objectMapper.readValue(json, javaType);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return obj;
    }

    /**
     * 验证是否是基本数据类型
     * @param obj 类对象
     * @return  true基本数据  false不是
     */
    private static boolean isPrimitive(Object obj) {
        try {
            return ((Class<?>)obj.getClass().getField("TYPE").get(null)).isPrimitive();
        } catch (Exception e) {
            return false;
        }
    }
}