package com.intfish.resourceserver.util;

import com.fasterxml.jackson.annotation.JsonInclude;

import com.fasterxml.jackson.core.Version;

import com.fasterxml.jackson.core.type.TypeReference;

import com.fasterxml.jackson.databind.DeserializationFeature;

import com.fasterxml.jackson.databind.JavaType;

import com.fasterxml.jackson.databind.ObjectMapper;

import com.fasterxml.jackson.databind.module.SimpleModule;

import com.fasterxml.jackson.datatype.jdk8.Jdk8Module;

import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;

import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;

import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;

import com.fasterxml.jackson.datatype.jsr310.deser.LocalTimeDeserializer;

import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;

import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;

import com.fasterxml.jackson.datatype.jsr310.ser.LocalTimeSerializer;

import com.fasterxml.jackson.module.paramnames.ParameterNamesModule;

import com.intfish.resourceserver.config.DoubleSerializer;

import java.io.IOException;

import java.text.SimpleDateFormat;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.LocalTime;

import java.time.format.DateTimeFormatter;

import java.util.List;

import java.util.Map;

import java.util.TimeZone;

public class JacksonUtils {

    private final static ObjectMapper OBJECT_MAPPER;

    static{

        OBJECT_MAPPER = new ObjectMapper();

        // 设置时区

        OBJECT_MAPPER.setTimeZone(TimeZone.getTimeZone("GMT+8"));

        // 设置时间格式

        OBJECT_MAPPER.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));

        JavaTimeModule javaTimeModule = new JavaTimeModule();

        /** 序列化配置,针对java8 时间 **/

        javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));

        javaTimeModule.addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd")));

        javaTimeModule.addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern("HH:mm:ss")));

        /** 反序列化配置,针对java8 时间 **/

        javaTimeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));

        javaTimeModule.addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd")));

        javaTimeModule.addDeserializer(LocalTime.class, new LocalTimeDeserializer(DateTimeFormatter.ofPattern("HH:mm:ss")));

        /** 声明自定义模块,配置double类型序列化配置 **/

        SimpleModule module = new SimpleModule("DoubleSerializer", new Version(1, 0, 0, ""));

        // 注意Double和double需要分配配置

        module.addSerializer(Double.class, new DoubleSerializer());

        module.addSerializer(double.class, new DoubleSerializer());

        /** 注册模块 **/

        OBJECT_MAPPER.registerModule(javaTimeModule)

                .registerModule(module)

                .registerModule(new Jdk8Module())

                .registerModule(new ParameterNamesModule()).configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)
                .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

    }

    private JacksonUtils() {

    }

    public static ObjectMapper getInstance() {

        return OBJECT_MAPPER;

    }

    /**

     * javaBean、列表数组转换为json字符串

     */

    public static String obj2json(Object obj) throws Exception {

        return OBJECT_MAPPER.writeValueAsString(obj);

    }

    /**

     * javaBean、列表数组转换为json字符串,忽略空值

     */

    public static String obj2jsonIgnoreNull(Object obj) throws Exception {

        ObjectMapper mapper = new ObjectMapper();

        mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);

        return mapper.writeValueAsString(obj);

    }

    /**

     * json 转JavaBean

     */

    public static <T> T json2pojo(String jsonString, Class<T> clazz) throws Exception {

        OBJECT_MAPPER.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);

        return OBJECT_MAPPER.readValue(jsonString, clazz);

    }

    /**

     * json字符串转换为map

     */

    public static Map<String, Object> json2map(String jsonString) throws Exception {

        ObjectMapper mapper = new ObjectMapper();

        mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);

        return mapper.readValue(jsonString, new TypeReference<Map<String, Object>>() {});

    }

    /**

     * json字符串转换为map

     */

    public static <T> Map<String, T> json2map(String jsonString, Class<T> clazz) throws Exception {

        ObjectMapper mapper = new ObjectMapper();

        mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);

        Map<String, T> map = mapper.readValue(jsonString, new TypeReference<Map<String, T>>() {});

        return map;

    }

    /**

     * 深度转换json成map

     *

     * @param json

     * @return

     */

    public static Map<String, Object> json2mapDeeply(String json) throws Exception {

        return json2MapRecursion(json, OBJECT_MAPPER);

    }

    /**

     * 把json解析成list，如果list内部的元素存在jsonString，继续解析

     *

     * @param json

     * @param mapper 解析工具

     * @return

     * @throws Exception

     */

    private static List<Object> json2ListRecursion(String json, ObjectMapper mapper) throws Exception {

        if (json == null) {

            return null;

        }

        List<Object> list = mapper.readValue(json, List.class);

        for (Object obj : list) {

            if (obj != null && obj instanceof String) {

                String str = (String) obj;

                if (str.startsWith("[")) {

                    obj = json2ListRecursion(str, mapper);

                } else if (obj.toString().startsWith("{")) {

                    obj = json2MapRecursion(str, mapper);

                }

            }

        }

        return list;

    }

    public static <T> T json2ObjectList(String json,  Class<T> valueType) throws IOException {

        ObjectMapper mapper = JacksonUtils.getInstance();

        return mapper.readValue(json, valueType);

    }

    /**

     * 把json解析成map，如果map内部的value存在jsonString，继续解析

     *

     * @param json

     * @param mapper

     * @return

     * @throws Exception

     */

    private static Map<String, Object> json2MapRecursion(String json, ObjectMapper mapper) throws Exception {

        if (json == null) {

            return null;

        }

        Map<String, Object> map = mapper.readValue(json, Map.class);

        for (Map.Entry<String, Object> entry : map.entrySet()) {

            Object obj = entry.getValue();

            if (obj != null && obj instanceof String) {

                String str = ((String) obj);

                if (str.startsWith("[")) {

                    List<?> list = json2ListRecursion(str, mapper);

                    map.put(entry.getKey(), list);

                } else if (str.startsWith("{")) {

                    Map<String, Object> mapRecursion = json2MapRecursion(str, mapper);

                    map.put(entry.getKey(), mapRecursion);

                }

            }

        }

        return map;

    }

    /**

     * 与javaBean json数组字符串转换为列表

     */

    public static <T> List<T> json2list(String jsonArrayStr) throws Exception {

        List<T> lst = (List<T>) OBJECT_MAPPER.readValue(jsonArrayStr, List.class);

        return lst;

    }

    public static <T> List<T> json2list(String jsonArrayStr, TypeReference<List<T>> typeReference) throws Exception {

        List<T> lst = OBJECT_MAPPER.readValue(jsonArrayStr, typeReference);

        return lst;

    }

    /**

     * 获取泛型的Collection Type

     *

     * @param collectionClass 泛型的Collection

     * @param elementClasses  元素类

     * @return JavaType Java类型

     * @since 1.0

     */

    public static JavaType getCollectionType(Class<?> collectionClass, Class<?>... elementClasses) {

        return OBJECT_MAPPER.getTypeFactory().constructParametricType(collectionClass, elementClasses);

    }

    /**

     * map  转JavaBean

     */

    public static <T> T map2pojo(Map map, Class<T> clazz) {

        return OBJECT_MAPPER.convertValue(map, clazz);

    }

    /**

     * map 转json

     *

     * @param map

     * @return

     */

    public static String mapToJson(Map map) {

        try {

            return OBJECT_MAPPER.writeValueAsString(map);

        } catch (Exception e) {

            e.printStackTrace();

        }

        return "";

    }

    /**

     * map 转json

     *

     * @param object

     * @return

     */

    public static String objectToJson(Object object) {

        try {

            return OBJECT_MAPPER.writeValueAsString(object);

        } catch (Exception e) {

            e.printStackTrace();

        }

        return "";

    }

    /**

     * map  转JavaBean

     */

    public static <T> T obj2pojo(Object obj, Class<T> clazz) {

        return OBJECT_MAPPER.convertValue(obj, clazz);

    }

}

package com.intfish.resourceserver.config;

import com.fasterxml.jackson.core.JsonGenerator;

import com.fasterxml.jackson.databind.JsonSerializer;

import com.fasterxml.jackson.databind.SerializerProvider;

import java.io.IOException;

import java.math.BigDecimal;

public class DoubleSerializer extends JsonSerializer<Double> {

    @Override

    public void serialize(Double value, JsonGenerator gen, SerializerProvider serializers)

            throws IOException {

        BigDecimal d = new BigDecimal(value.toString());

        gen.writeNumber(d.stripTrailingZeros().toPlainString());

    }

    @Override

    public Class<Double> handledType() {

        return Double.class;

    }

}