基于Jackson封装的常用JSON操作API，特别适合于用习惯了Fastjson的开发者

qq_38229543

已于 2024-09-13 09:51:24 修改

阅读量649

点赞数 1

文章标签： json maven java

于 2020-10-29 18:40:16 首次发布

本文链接：https://blog.csdn.net/qq_38229543/article/details/109365565

版权

由于Fastjson近来频繁出现各种漏洞，好多公司逐渐开始减少或禁止Fastjson的使用。除了Fastjson，市面上比较优秀的JSON类库还有很多，比较有名的比如Jackson、Gson等。

但是Jackson原生的API和Fastjson对比，使用起来稍微有些麻烦，因此本人参考Fastjson的基本使用API，封装了Jackson操作JSON的常用方法。

废话不多说，直接上代码。

1.maven依赖，引入jackson系列的所有依赖和Guava 工具类库

  <!--Jackson -->
  <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>2.11.3</version>
  </dependency>
  <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.11.3</version>
  </dependency>
  <dependency>
      <groupId>com.fasterxml.jackson.datatype</groupId>
      <artifactId>jackson-datatype-jdk8</artifactId>
      <version>2.11.3</version>
  </dependency>
  <dependency>
      <groupId>com.fasterxml.jackson.datatype</groupId>
      <artifactId>jackson-datatype-jsr310</artifactId>
      <version>2.11.3</version>
  </dependency>
  <dependency>
      <groupId>com.fasterxml.jackson.module</groupId>
      <artifactId>jackson-module-parameter-names</artifactId>
      <version>2.11.3</version>
  </dependency>
  <!--Guava 工具类库 -->
  <dependency>
      <groupId>com.google.guava</groupId>
      <artifactId>guava</artifactId>
      <version>30.0-jre</version>
  </dependency>

2.Jackson工具类

package com.counter.util;

import com.fasterxml.jackson.annotation.JsonInclude;
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.SerializationFeature;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.fasterxml.jackson.databind.type.CollectionType;
import com.fasterxml.jackson.databind.type.MapType;
import com.fasterxml.jackson.databind.type.TypeFactory;
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 java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Optional;

/**
 * Jackson JSON工具类
 *
 * @author 2020/10/29
 */
public class JacksonUtil {
    private static ObjectMapper objectMapper = new ObjectMapper();

    private final static String DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
    private final static String DATE_FORMAT = "yyyy-MM-dd";
    private final static String TIME_FORMAT = "HH:mm:ss";
    /**
     * 默认日期格式化对象
     */
    private static ThreadLocal<SimpleDateFormat> formatLocal = ThreadLocal.withInitial(() -> new SimpleDateFormat(DATE_TIME_FORMAT));

    static {
        //在反序列化时忽略在 json 中存在但 Java 对象不存在的属性
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        //在序列化时日期格式默认为 yyyy-MM-dd'T'HH:mm:ss.SSS
        objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        //在序列化时自定义默认时间日期格式（如果pojo使用了@JsonFormat注解指定日期格式，则会覆盖默认设置）
        objectMapper.setDateFormat(new SimpleDateFormat(DATE_TIME_FORMAT));
        //在序列化时忽略值为 null 的属性
        objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        //POJO无public的属性或方法时，不报错
        objectMapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
        
        //设置按照字段名进行序列化
        objectMapper.setVisibility(PropertyAccessor.SETTER, JsonAutoDetect.Visibility.NONE);
        objectMapper.setVisibility(PropertyAccessor.GETTER, JsonAutoDetect.Visibility.NONE);
        objectMapper.setVisibility(PropertyAccessor.IS_GETTER, JsonAutoDetect.Visibility.NONE);
        objectMapper.setVisibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY);

        //针对于JDK新时间类。序列化时带有T的问题，自定义格式化字符串
        JavaTimeModule javaTimeModule = new JavaTimeModule();
        javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DATE_TIME_FORMAT)));
        javaTimeModule.addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern(DATE_FORMAT)));
        javaTimeModule.addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern((TIME_FORMAT))));
        javaTimeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DATE_TIME_FORMAT)));
        javaTimeModule.addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern(DATE_FORMAT)));
        javaTimeModule.addDeserializer(LocalTime.class, new LocalTimeDeserializer(DateTimeFormatter.ofPattern(TIME_FORMAT)));
        objectMapper.registerModule(javaTimeModule);
    }

    /**
     * 获取objectMapper对象
     *
     * @return ObjectMapper
     */
    public static ObjectMapper getObjectMapper() {
        return objectMapper;
    }

    //============================================== 序列化/反序列化 方法封装 =============================================================

    /**
     * 普通JSON序列化
     *
     * @param obj 目标对象
     * @return String
     */
    public static String toJSONString(Object obj) {
        if (obj == null) {
            return null;
        }
        try {
            return objectMapper.writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            throw new IllegalArgumentException(e);
        }
    }

    /**
     * 格式化/美化/优雅 JSON序列化
     *
     * @param obj 目标对象
     * @return String
     */
    public static String toPrettyJSONString(Object obj) {
        if (obj == null) {
            return null;
        }
        try {
            return objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            throw new IllegalArgumentException(e);
        }
    }

    /**
     * JSON字符串反序列化为Java对象
     *
     * @param jsonString JSON字符串
     * @param classType  对象类型
     * @return T
     */
    public static <T> T toJavaObject(String jsonString, Class<T> classType) {
        if (isEmpty(jsonString)) {
            return null;
        }
        try {
            return objectMapper.readValue(jsonString, classType);
        } catch (JsonProcessingException e) {
            throw new IllegalArgumentException(e);
        }
    }

    /**
     * Object类型的对象转为指定的Java对象
     *
     * @param object    当前对象
     * @param classType 目标对象类型
     * @return T
     */
    public static <T> T toJavaObject(Object object, Class<T> classType) {
        if (object == null || isEmpty(object.toString())) {
            return null;
        }
        if (classType == null) {
            throw new IllegalArgumentException("classType is null!");
        }
        try {
            if (object instanceof String) {
                return objectMapper.readValue((String) object, classType);
            }
            return objectMapper.readValue(toJSONString(object), classType);
        } catch (JsonProcessingException e) {
            throw new IllegalArgumentException(e);
        }
    }

    /**
     * JSON字符串反序列化为Map集合
     *
     * @param jsonString JSON字符串
     * @param keyType    key的泛型类型
     * @param valueType  value的泛型类型
     * @return Map<K, V>
     */
    public static <K, V> Map<K, V> toMap(String jsonString, Class<K> keyType, Class<V> valueType) {
        if (isEmpty(jsonString)) {
            return null;
        }
        if (keyType == null || valueType == null) {
            throw new IllegalArgumentException("keyType or valueType is null!");
        }
        try {
            //第二参数是 map 的 key 的类型，第三参数是 map 的 value 的类型
            MapType javaType = objectMapper.getTypeFactory().constructMapType(Map.class, keyType, valueType);
            return objectMapper.readValue(jsonString, javaType);
        } catch (JsonProcessingException e) {
            throw new IllegalArgumentException(e);
        }
    }

    /**
     * JSON字符串反序列化为Map集合
     *
     * @param jsonString JSON字符串
     * @return Map<String, Object>
     */
    public static Map<String, Object> toMap(String jsonString) {
        return toMap(jsonString, String.class, Object.class);
    }

    /**
     * Object类型的对象转为Map集合
     *
     * @param object    当前对象
     * @param keyType   map的Key类型
     * @param valueType map的Value类型
     * @return Map<K, V>
     */
    public static <K, V> Map<K, V> toMap(Object object, Class<K> keyType, Class<V> valueType) {
        if (object == null || isEmpty(object.toString())) {
            return null;
        }
        if (keyType == null || valueType == null) {
            throw new IllegalArgumentException("keyType or valueType is null!");
        }
        try {
            //第二参数是 map 的 key 的类型，第三参数是 map 的 value 的类型
            MapType javaType = objectMapper.getTypeFactory().constructMapType(Map.class, keyType, valueType);
            if (object instanceof String) {
                return objectMapper.readValue((String) object, javaType);
            }
            return objectMapper.readValue(toJSONString(object), javaType);
        } catch (JsonProcessingException e) {
            throw new IllegalArgumentException(e);
        }
    }

    public static Map<String, Object> toMap(Object object) {
        return toMap(object, String.class, Object.class);
    }

    /**
     * JSON字符串反序列化为List集合
     *
     * @param jsonString JSON字符串
     * @param classType  List的泛型
     * @return List<T>
     */
    public static <T> List<T> toList(String jsonString, Class<T> classType) {
        if (isEmpty(jsonString)) {
            return null;
        }
        if (classType == null) {
            throw new IllegalArgumentException("classType is null!");
        }
        try {
            CollectionType javaType = objectMapper.getTypeFactory().constructCollectionType(List.class, classType);
            return objectMapper.readValue(jsonString, javaType);
        } catch (JsonProcessingException e) {
            throw new IllegalArgumentException(e);
        }
    }

    public static List<Object> toList(String jsonString) {
        return toList(jsonString, Object.class);
    }

    /**
     * Object类型的对象转为List集合
     *
     * @param object    当前对象
     * @param classType List的泛型
     * @return List<T>
     */
    public static <T> List<T> toList(Object object, Class<T> classType) {
        if (object == null || isEmpty(object.toString())) {
            return null;
        }
        if (classType == null) {
            throw new IllegalArgumentException("classType is null!");
        }
        try {
            CollectionType javaType = objectMapper.getTypeFactory().constructCollectionType(List.class, classType);
            if (object instanceof String) {
                return objectMapper.readValue((String) object, javaType);
            }
            return objectMapper.readValue(toJSONString(object), javaType);
        } catch (JsonProcessingException e) {
            throw new IllegalArgumentException(e);
        }
    }

    public static List<Object> toList(Object object) {
        return toList(object, Object.class);
    }

    /**
     * JSON数组字符串反序列化为泛型为<Map<K,V>的List集合
     *
     * @param jsonArrayString JSON数组字符串
     * @param keyType         Map的Key类型
     * @param valueType       Map的Value类型
     * @return List<Map < K, V>>
     */
    public static <K, V> List<Map<K, V>> toMapList(String jsonArrayString, Class<K> keyType, Class<V> valueType) {
        if (isEmpty(jsonArrayString)) {
            return null;
        }
        if (keyType == null || valueType == null) {
            throw new IllegalArgumentException("keyType or valueType is null!");
        }
        try {
            TypeFactory typeFactory = objectMapper.getTypeFactory();
            MapType mapType = typeFactory.constructMapType(Map.class, keyType, valueType);
            CollectionType collectionType = typeFactory.constructCollectionType(List.class, mapType);
            return objectMapper.readValue(jsonArrayString, collectionType);
        } catch (JsonProcessingException e) {
            throw new IllegalArgumentException(e);
        }
    }

    public static List<Map<String, Object>> toMapList(String jsonArrayString) {
        return toMapList(jsonArrayString, String.class, Object.class);
    }

    /**
     * Object类型的对象转为泛型为<Map<K,V>的List集合
     *
     * @param object    当前对象
     * @param keyType   Map的Key类型
     * @param valueType Map的Value类型
     * @return List<Map < K, V>>
     */
    public static <K, V> List<Map<K, V>> toMapList(Object object, Class<K> keyType, Class<V> valueType) {
        if (object == null || isEmpty(object.toString())) {
            return null;
        }
        if (keyType == null || valueType == null) {
            throw new IllegalArgumentException("keyType or valueType is null!");
        }
        try {
            TypeFactory typeFactory = objectMapper.getTypeFactory();
            MapType mapType = typeFactory.constructMapType(Map.class, keyType, valueType);
            CollectionType collectionType = objectMapper.getTypeFactory().constructCollectionType(List.class, mapType);
            if (object instanceof String) {
                return objectMapper.readValue((String) object, collectionType);
            }
            return objectMapper.readValue(toJSONString(object), collectionType);
        } catch (JsonProcessingException e) {
            throw new IllegalArgumentException(e);
        }
    }

    public static List<Map<String, Object>> toMapList(Object object) {
        return toMapList(object, String.class, Object.class);
    }
    
   /**
     * JSON字符串转换为JSON
     *
     * @param jsonString JSON对象字符串
     * @return JsonNode
     */
    public static JsonNode toJSON(String jsonString) {
        if (isEmpty(jsonString)) {
            return null;
        }
        try {
            return objectMapper.readTree(jsonString);
        } catch (JsonProcessingException e) {
            throw new IllegalArgumentException(e);
        }
    }

    /**
     * JSON字符串转换为JSON对象
     *
     * @param jsonString JSON对象字符串
     * @return ObjectNode
     */
    public static ObjectNode parseJSONObject(String jsonString) {
        if (isEmpty(jsonString)) {
            return null;
        }
        try {
            return (ObjectNode) objectMapper.readTree(jsonString);
        } catch (JsonProcessingException e) {
            throw new IllegalArgumentException(e);
        }
    }

    /**
     * Object类型转换为JSON对象
     *
     * @param object 当前对象
     * @return ObjectNode
     */
    public static ObjectNode parseJSONObject(Object object) {
        if (object == null || isEmpty(object.toString())) {
            return null;
        }
        try {
            if (ObjectNode.class.isAssignableFrom(object.getClass())) {
                return (ObjectNode) object;
            }
            if (object instanceof String) {
                return (ObjectNode) objectMapper.readTree((String) object);
            }
            return (ObjectNode) objectMapper.readTree(toJSONString(object));
        } catch (JsonProcessingException e) {
            throw new IllegalArgumentException(e);
        }
    }

    /**
     * JSON字符串转换为JSON数组
     *
     * @param jsonString JSON数组字符串
     * @return ArrayNode
     */
    public static ArrayNode parseJSONArray(String jsonString) {
        if (isEmpty(jsonString)) {
            return newJSONArray();
        }
        try {
            return (ArrayNode) objectMapper.readTree(jsonString);
        } catch (JsonProcessingException e) {
            throw new IllegalArgumentException(e);
        }
    }

    /**
     * Object类型转换为JSON数组
     *
     * @param object 当前对象
     * @return ArrayNode
     */
    public static ArrayNode parseJSONArray(Object object) {
        if (object == null || isEmpty(object.toString())) {
            return null;
        }
        try {
            if (ArrayNode.class.isAssignableFrom(object.getClass())) {
                return (ArrayNode) object;
            }
            if (object instanceof String) {
                return (ArrayNode) objectMapper.readTree((String) object);
            }
            return (ArrayNode) objectMapper.readTree(toJSONString(object));
        } catch (JsonProcessingException e) {
            throw new IllegalArgumentException(e);
        }
    }

    //============================================== 获取value值方法封装 =============================================================

    /**
     * 获取JSON对象 ObjectNode
     *
     * @param jsonNode json对象
     * @param key      JSON key
     * @return ObjectNode
     */
    public static ObjectNode getJSONObject(JsonNode jsonNode, String key) {
        if (jsonNode == null) {
            return null;
        }
        return (ObjectNode) Optional.ofNullable(jsonNode.get(key)).orElse(null);
    }

    /**
     * 获取JSON数组 ArrayNode
     *
     * @param jsonNode json对象
     * @param key      JSON key
     * @return ArrayNode
     */
    public static ArrayNode getJSONArray(JsonNode jsonNode, String key) {
        if (jsonNode == null) {
            return null;
        }
        return (ArrayNode) Optional.ofNullable(jsonNode.get(key)).orElse(null);
    }

    /**
     * 获取String类型的value
     *
     * @param jsonNode     json对象
     * @param key          JSON key
     * @param defaultValue 默认value
     * @return String
     */
    public static String getString(JsonNode jsonNode, String key, String defaultValue) {
        if (jsonNode == null) {
            return null;
        }
        return Optional.ofNullable(jsonNode.get(key)).filter(x -> !x.isNull()).map(JacksonUtil::getJsonNodeString).orElse(defaultValue);
    }

    public static String getString(JsonNode jsonNode, String key) {
        return getString(jsonNode, key, null);
    }

    /**
     * 获取Byte类型的value
     *
     * @param jsonNode     json对象
     * @param key          JSON key
     * @param defaultValue 默认value
     * @return Byte
     */
    public static Byte getByte(JsonNode jsonNode, String key, Byte defaultValue) {
        if (jsonNode == null) {
            return null;
        }
        return Optional.ofNullable(jsonNode.get(key)).filter(x -> !x.isNull()).map(x -> Byte.valueOf(getJsonNodeString(x))).orElse(defaultValue);
    }

    public static Byte getByte(JsonNode jsonNode, String key) {
        return getByte(jsonNode, key, null);
    }

    /**
     * 获取Short类型的value
     *
     * @param jsonNode     json对象
     * @param key          JSON key
     * @param defaultValue 默认value
     * @return Short
     */
    public static Short getShort(JsonNode jsonNode, String key, Short defaultValue) {
        if (jsonNode == null) {
            return null;
        }
        return Optional.ofNullable(jsonNode.get(key)).filter(x -> !x.isNull()).filter(x -> !x.isNull()).map(x -> Short.valueOf(getJsonNodeString(x))).orElse(defaultValue);
    }

    public static Short getShort(JsonNode jsonNode, String key) {
        return getShort(jsonNode, key, null);
    }

    /**
     * 获取Integer类型的value
     *
     * @param jsonNode     json对象
     * @param key          JSON key
     * @param defaultValue 默认value
     * @return Integer
     */
    public static Integer getInteger(JsonNode jsonNode, String key, Integer defaultValue) {
        if (jsonNode == null) {
            return null;
        }
        return Optional.ofNullable(jsonNode.get(key)).filter(x -> !x.isNull()).map(x -> Integer.valueOf(getJsonNodeString(x))).orElse(defaultValue);
    }

    public static Integer getInteger(JsonNode jsonNode, String key) {
        return getInteger(jsonNode, key, null);
    }

    /**
     * 获取Long类型的value
     *
     * @param jsonNode     json对象
     * @param key          JSON key
     * @param defaultValue 默认value
     * @return Long
     */
    public static Long getLong(JsonNode jsonNode, String key, Long defaultValue) {
        if (jsonNode == null) {
            return null;
        }
        return Optional.ofNullable(jsonNode.get(key)).filter(x -> !x.isNull()).map(x -> Long.valueOf(getJsonNodeString(x))).orElse(defaultValue);
    }

    public static Long getLong(JsonNode jsonNode, String key) {
        return getLong(jsonNode, key, null);
    }

    /**
     * 获取Double类型的value
     *
     * @param jsonNode     json对象
     * @param key          JSON key
     * @param defaultValue 默认value
     * @return Double
     */
    public static Double getDouble(JsonNode jsonNode, String key, Double defaultValue) {
        if (jsonNode == null) {
            return null;
        }
        return Optional.ofNullable(jsonNode.get(key)).filter(x -> !x.isNull()).map(x -> Double.valueOf(getJsonNodeString(x))).orElse(defaultValue);
    }

    public static Double getDouble(JsonNode jsonNode, String key) {
        return getDouble(jsonNode, key, null);
    }

    /**
     * 获取Boolean类型的value
     *
     * @param jsonNode     json对象
     * @param key          JSON key
     * @param defaultValue 默认value
     * @return boolean
     */
    public static boolean getBoolean(JsonNode jsonNode, String key, boolean defaultValue) {
        if (jsonNode == null) {
            return false;
        }
        return Optional.ofNullable(jsonNode.get(key)).filter(x -> !x.isNull()).map(x -> Boolean.valueOf(getJsonNodeString(x))).orElse(defaultValue);
    }

    public static boolean getBoolean(JsonNode jsonNode, String key) {
        return getBoolean(jsonNode, key, false);
    }

    /**
     * 获取Date类型的value
     *
     * @param jsonNode json对象
     * @param key      JSON key
     * @param format   日期格式对象
     * @return Date
     */
    public static Date getDate(JsonNode jsonNode, String key, SimpleDateFormat format) {
        if (jsonNode == null || format == null) {
            return null;
        }
        String dateStr = Optional.ofNullable(jsonNode.get(key)).filter(x -> !x.isNull()).map(JacksonUtil::getJsonNodeString).orElse(null);
        if (dateStr == null) {
            return null;
        }
        try {
            return format.parse(dateStr);
        } catch (ParseException e) {
            throw new IllegalArgumentException(e);
        }
    }

    public static Date getDate(JsonNode jsonNode, String key) {
        return getDate(jsonNode, key, formatLocal.get());
    }

    //============================================== 创建JSON对象/JSON数组 方法封装 =============================================================

    /**
     * 创建一个JSON对象
     *
     * @return ObjectNode
     */
    public static ObjectNode newJSONObject() {
        return objectMapper.createObjectNode();
    }

    /**
     * 创建一个JSON数组
     *
     * @return ArrayNode
     */
    public static ArrayNode newJSONArray() {
        return objectMapper.createArrayNode();
    }

   /**
     * 判断JSON属性个数是否为0
     *
     * @param jsonNode JsonNode
     * @return boolean
     */
    public static boolean isEmpty(JsonNode jsonNode) {
        return jsonNode == null || jsonNode.size() == 0;
    }
	public static boolean isNotEmpty(JsonNode jsonNode) {
        return !isEmpty(jsonNode);
    }
    /**
     * 判断字符串是否为null或者空字符串
     *
     * @param jsonString 字符串
     * @return boolean
     */
    private static boolean isEmpty(String jsonString) {
        return jsonString == null || jsonString.trim().length() <= 0;
    }

    /**
     * 去掉JsonNode toString后字符串的两端的双引号（直接用JsonNode的toString方法获取到的值做后续处理，Jackson去获取String类型的方法有坑）
     * @param jsonNode JsonNode
     * @return String
     */
    private static String getJsonNodeString(JsonNode jsonNode){
        if(jsonNode==null){
            return null;
        }
        //去掉字符串左右的引号
        String quotesLeft="^[\"]";
        String quotesRight="[\"]$";
        return jsonNode.toString().replaceAll(quotesLeft,"").replaceAll(quotesRight,"");
    }
}

3.测试实体类

package test.entity;

import com.fasterxml.jackson.annotation.JsonFormat;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.util.*;

/**
 * @author lzq 2020/10/29
 */
public class Person {
    // 正常case
    private String name;
    // 空对象case
    private Integer age;
    // 日期转换case
    @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm")
    private Date date;
    // 默认值case
    private int height;

    private LocalDate localDate;
    private LocalDateTime localDateTime;
    private LocalTime localTime;

    private Info info;
    private List<String> list;
    private Map<String,Object> map;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Date getDate() {
        return date;
    }

    public void setDate(Date date) {
        this.date = date;
    }

    public int getHeight() {
        return height;
    }

    public void setHeight(int height) {
        this.height = height;
    }

    public LocalDate getLocalDate() {
        return localDate;
    }

    public void setLocalDate(LocalDate localDate) {
        this.localDate = localDate;
    }

    public LocalDateTime getLocalDateTime() {
        return localDateTime;
    }

    public void setLocalDateTime(LocalDateTime localDateTime) {
        this.localDateTime = localDateTime;
    }

    public LocalTime getLocalTime() {
        return localTime;
    }

    public void setLocalTime(LocalTime localTime) {
        this.localTime = localTime;
    }

    public Info getInfo() {
        return info;
    }

    public void setInfo(Info info) {
        this.info = info;
    }

    public List<String> getList() {
        return list;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public Map<String, Object> getMap() {
        return map;
    }

    public void setMap(Map<String, Object> map) {
        this.map = map;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", date=" + date +
                ", height=" + height +
                ", localDate=" + localDate +
                ", localDateTime=" + localDateTime +
                ", localTime=" + localTime +
                ", info=" + info +
                ", list=" + list +
                ", map=" + map +
                '}';
    }

    public static class Info{
        private String city;
        private String address;
        private int[] nums;
        private HashMap<String,Object> extension;

        public String getCity() {
            return city;
        }

        public void setCity(String city) {
            this.city = city;
        }

        public String getAddress() {
            return address;
        }

        public void setAddress(String address) {
            this.address = address;
        }

        public int[] getNums() {
            return nums;
        }

        public void setNums(int[] nums) {
            this.nums = nums;
        }

        public HashMap<String, Object> getExtension() {
            return extension;
        }

        public void setExtension(HashMap<String, Object> extension) {
            this.extension = extension;
        }

        @Override
        public String toString() {
            return "Info{" +
                    "city='" + city + '\'' +
                    ", address='" + address + '\'' +
                    ", nums=" + Arrays.toString(nums) +
                    ", extension=" + extension +
                    '}';
        }
    }
}

public class ZhangSan extends Person {
    private String zhangsanName;

    public String getZhangsanName() {
        return zhangsanName;
    }
    public void setZhangsanName(String zhangsanName) {
        this.zhangsanName = zhangsanName;
    }
}

4.测试类

package test.jackson;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.counter.util.JacksonUtil;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import org.junit.Assert;
import org.junit.Test;
import test.jackson.entity.AnXuanOrder;
import test.jackson.entity.Person;
import test.jackson.entity.Person.Info;
import test.jackson.entity.ZhangSan;

import java.math.BigDecimal;
import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.util.*;

/**
 * @author 2020/10/29
 */
public class JacksonUtilTest {

    @Test
    public void toJSONString() {
        // 造数据
        Person person = new Person();
        person.setName("Tom");
        person.setAge(40);
        person.setDate(new Date());
        person.setLocalDate(LocalDate.now());
        person.setLocalDateTime(LocalDateTime.now());
        person.setLocalTime(LocalTime.now());

        //System.out.println(JacksonUtil.toJSONString(person));
        //System.out.println(JacksonUtil.toPrettyJSONString(person));

        // 造数据
        List<Person> list = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            person = new Person();
            person.setName("Tom");
            person.setAge(new Random().nextInt(100));
            person.setDate(new Date());
            person.setLocalDate(LocalDate.now());
            person.setLocalDateTime(LocalDateTime.now());
            person.setLocalTime(LocalTime.now());
            list.add(person);
        }
        System.out.println("List序列化");
        //System.out.println(JacksonUtil.toPrettyJSONString(list));


    }

    @Test
    public void toJavaObject() {
        String json = "{\n" +
                "  \"name\" : \"Tom\",\n" +
                "  \"age\" : 40,\n" +
                "  \"date\" : \"2020-10-29 16:24\",\n" +
                "  \"height\" : 0,\n" +
                "  \"url\" : \"https://www.baidu.com?aaa=666&rrr=6\",\n" +
                "  \"localDate\" : \"2020-10-29\",\n" +
                "  \"localDateTime\" : \"2020-10-29 16:24:29\",\n" +
                "  \"localTime\" : \"16:24:29\"\n" +
                "}";
        System.out.println(JacksonUtil.parseJSONObject(json));
        //System.out.println(JacksonUtil.toJavaObject(json, Person.class));
        //System.out.println(JacksonUtil.toJavaObject(JacksonUtil.toJavaObject(json, Person.class), Person.class));
        //System.out.println(JacksonUtil.toJavaObject(JacksonUtil.toMap(json), Person.class));
    }

    @Test
    public void toMap() {
        String json = "{\n" +
                "  \"name\" : \"Tom\",\n" +
                "  \"age\" : 40,\n" +
                "  \"date\" : \"2020-10-29 16:24\",\n" +
                "  \"height\" : 0,\n" +
                "  \"localDate\" : \"2020-10-29\",\n" +
                "  \"localDateTime\" : \"2020-10-29 16:24:29\",\n" +
                "  \"localTime\" : \"16:24:29\"\n" +
                "}";
        Map<String, Object> map1 = JacksonUtil.toMap(json);
        System.out.println(map1);
        String json2 = "{\n" +
                "  \"name\":\"张三\",\n" +
                "  \"job\":\"罪犯\"\n" +
                "}";
        Map<String, String> map2 = JacksonUtil.toMap(json2, String.class, String.class);
        System.out.println(map2);
        String json3 = "{\n" +
                "  \"age\":99,\n" +
                "  \"height\":0.09\n" +
                "}";
        Map<String, Double> map3 = JacksonUtil.toMap(json3, String.class, Double.class);
        System.out.println(map3);

    }

    @Test
    public void toList() {
        String json = "[ {\n" +
                "  \"name\" : \"Tom\",\n" +
                "  \"age\" : 55,\n" +
                "  \"date\" : \"2020-10-29 16:36\",\n" +
                "  \"height\" : 0,\n" +
                "  \"localDate\" : \"2020-10-29\",\n" +
                "  \"localDateTime\" : \"2020-10-29 16:36:45\",\n" +
                "  \"localTime\" : \"16:36:45\"\n" +
                "}, {\n" +
                "  \"name\" : \"Tom\",\n" +
                "  \"age\" : 75,\n" +
                "  \"date\" : \"2020-10-29 16:36\",\n" +
                "  \"height\" : 0,\n" +
                "  \"localDate\" : \"2020-10-29\",\n" +
                "  \"localDateTime\" : \"2020-10-29 16:36:45\",\n" +
                "  \"localTime\" : \"16:36:45\"\n" +
                "}, {\n" +
                "  \"name\" : \"Tom\",\n" +
                "  \"age\" : 6,\n" +
                "  \"date\" : \"2020-10-29 16:36\",\n" +
                "  \"height\" : 0,\n" +
                "  \"localDate\" : \"2020-10-29\",\n" +
                "  \"localDateTime\" : \"2020-10-29 16:36:45\",\n" +
                "  \"localTime\" : \"16:36:45\"\n" +
                "} ]";
        List<Object> list1 = JacksonUtil.toList(json);
        System.out.println(list1);
        System.out.println("=================================================");
        List<Person> list2 = JacksonUtil.toList(json, Person.class);
        System.out.println(list2);
    }


    @Test
    public void parseObjectNode() {
        String json = "{\n" +
                "  \"name\":\"张三\",\n" +
                "  \"job\":\"罪犯\",\n" +
                "  \"body\":{\n" +
                "\t\"age\":99,\n" +
                "\t\"height\":0.09\n" +
                "  },\n" +
                "  \"bir\":\"2020-10-29 12:03:56\",\n" +
                "  \"nums\":[1,2,5,6,8,9],\n" +
                "  \"extension\":[\n" +
                "    {\n" +
                "\t \"city\":\"北京\",\n" +
                "\t \"address\":\"朝阳区\"\n" +
                "\t},\n" +
                "\t{ \n" +
                "\t \"city\":\"天津\",\n" +
                "\t \"address\":\"北辰区\"\n" +
                "\t}\n" +
                "  ]\n" +
                "}";
        ObjectNode jsonNode = JacksonUtil.parseJSONObject(json);
        System.out.println(jsonNode.toPrettyString());
        System.out.println(JacksonUtil.getJSONArray(jsonNode,"extension"));
        Object a = json;
        System.out.println(JacksonUtil.parseJSONObject(a));
    }

    @Test
    public void parseArrayNode() {
        String json = "[\n" +
                "    {\n" +
                "\t \"city\":\"北京\",\n" +
                "\t \"address\":\"朝阳区\"\n" +
                "\t},\n" +
                "\t{ \n" +
                "\t \"city\":\"天津\",\n" +
                "\t \"address\":\"北辰区\"\n" +
                "\t}\n" +
                "  ]";
        ArrayNode jsonNodes = JacksonUtil.parseJSONArray(json);
        System.out.println(jsonNodes.toPrettyString());
        System.out.println("===============================");
        for (JsonNode jsonNode : jsonNodes) {
            System.out.println(jsonNode);
        }
    }

    @Test
    public void getObjectNode() {
        String json = "{\n" +
                "  \"name\":\"张三\",\n" +
                "  \"job\":\"罪犯\",\n" +
                "  \"body\":{\n" +
                "\t\"age\":99,\n" +
                "\t\"height\":0.09\n" +
                "  },\n" +
                "  \"bir\":\"2020-10-29 12:03:56\",\n" +
                "  \"nums\":[1,2,5,6,8,9],\n" +
                "  \"extension\":[\n" +
                "    {\n" +
                "\t \"city\":\"北京\",\n" +
                "\t \"address\":\"朝阳区\"\n" +
                "\t},\n" +
                "\t{ \n" +
                "\t \"city\":\"天津\",\n" +
                "\t \"address\":\"北辰区\"\n" +
                "\t}\n" +
                "  ]\n" +
                "}";
        ObjectNode jsonNode = JacksonUtil.parseJSONObject(json);
        System.out.println(JacksonUtil.getJSONObject(jsonNode, "body"));
    }

    @Test
    public void getArrayNode() {
        String json = "{\n" +
                "  \"name\":\"张三\",\n" +
                "  \"job\":\"罪犯\",\n" +
                "  \"body\":{\n" +
                "\t\"age\":99,\n" +
                "\t\"height\":0.09\n" +
                "  },\n" +
                "  \"bir\":\"2020-10-29 12:03:56\",\n" +
                "  \"nums\":[1,2,5,6,8,9],\n" +
                "  \"extension\":[\n" +
                "    {\n" +
                "\t \"city\":\"北京\",\n" +
                "\t \"address\":\"朝阳区\"\n" +
                "\t},\n" +
                "\t{ \n" +
                "\t \"city\":\"天津\",\n" +
                "\t \"address\":\"北辰区\"\n" +
                "\t}\n" +
                "  ]\n" +
                "}";
        ObjectNode jsonNode = JacksonUtil.parseJSONObject(json);
        System.out.println(JacksonUtil.getJSONArray(jsonNode, "extension"));
        System.out.println(JacksonUtil.getJSONArray(jsonNode, "nums"));
    }

    @Test
    public void getString() {
        String json = "\n" +
                "{\n" +
                "  \"name\":\"张三\",\n" +
                "  \"job\":\"罪犯\",\n" +
                "  \"bir\":\"2020-10-29 12:03:56\",\n" +
                "  \"nums\":[1,2,5,6,8,9],\n" +
                "  \"flagStr\":\"true\",\n" +
                "  \"flag\":true,\n" +
                "  \"ageStr\":\"99\",\n" +
                "  \"age\":99,\n" +
                "  \"heightStr\":\"5.09\",\n" +
                "  \"height\":5.09\n" +
                "\n" +
                "}";
        ObjectNode jsonNode = JacksonUtil.parseJSONObject(json);
        System.out.println(JacksonUtil.getString(jsonNode, "name"));
        System.out.println(JacksonUtil.getString(jsonNode, "name1"));
        System.out.println(JacksonUtil.getString(jsonNode, "name1", "默认"));
        System.out.println(JacksonUtil.getString(jsonNode, "age"));
        System.out.println(JacksonUtil.getString(jsonNode, "bir"));
        System.out.println(JacksonUtil.getString(jsonNode, "height"));

    }


    @Test
    public void getByte() {
        String json = "\n" +
                "{\n" +
                "  \"flagStr\":\"true\",\n" +
                "  \"flag\":true,\n" +
                "  \"ageStr\":\"99\",\n" +
                "  \"age\":99,\n" +
                "  \"age1\":127,\n" +
                "  \"heightStr\":\"5.09\",\n" +
                "  \"height\":5.09\n" +
                "\n" +
                "}";
        ObjectNode jsonNode = JacksonUtil.parseJSONObject(json);
        System.out.println(JacksonUtil.getByte(jsonNode, "age"));
        System.out.println(JacksonUtil.getByte(jsonNode, "ageStr"));
        System.out.println(JacksonUtil.getByte(jsonNode, "age1"));
    }

    @Test
    public void getShort() {
        String json = "\n" +
                "{\n" +
                "  \"flagStr\":\"true\",\n" +
                "  \"flag\":true,\n" +
                "  \"ageStr\":\"99\",\n" +
                "  \"age\":99,\n" +
                "  \"heightStr\":\"5.09\",\n" +
                "  \"height\":5.09\n" +
                "\n" +
                "}";
        ObjectNode jsonNode = JacksonUtil.parseJSONObject(json);
        System.out.println(JacksonUtil.getShort(jsonNode, "age"));
        System.out.println(JacksonUtil.getShort(jsonNode, "ageStr"));
    }

    @Test
    public void getInteger() {
        String json = "\n" +
                "{\n" +
                "  \"flagStr\":\"true\",\n" +
                "  \"flag\":true,\n" +
                "  \"ageStr\":\"99\",\n" +
                "  \"age\":99,\n" +
                "  \"heightStr\":\"5.09\",\n" +
                "  \"height\":5.09\n" +
                "\n" +
                "}";
        ObjectNode jsonNode = JacksonUtil.parseJSONObject(json);
        System.out.println(JacksonUtil.getInteger(jsonNode, "age"));
        System.out.println(JacksonUtil.getInteger(jsonNode, "ageStr"));
    }

    @Test
    public void getLong() {
        String json = "\n" +
                "{\n" +
                "  \"flagStr\":\"true\",\n" +
                "  \"flag\":true,\n" +
                "  \"ageStr\":\"99\",\n" +
                "  \"age\":99,\n" +
                "  \"heightStr\":\"5.09\",\n" +
                "  \"height\":5.09\n" +
                "\n" +
                "}";
        ObjectNode jsonNode = JacksonUtil.parseJSONObject(json);
        System.out.println(JacksonUtil.getInteger(jsonNode, "age"));
        System.out.println(JacksonUtil.getInteger(jsonNode, "ageStr"));
    }

    @Test
    public void getDouble() {
        String json = "\n" +
                "{\n" +
                "  \"flagStr\":\"true\",\n" +
                "  \"flag\":true,\n" +
                "  \"ageStr\":\"99\",\n" +
                "  \"age\":99,\n" +
                "  \"heightStr\":\"5.09\",\n" +
                "  \"height\":5.09\n" +
                "\n" +
                "}";
        ObjectNode jsonNode = JacksonUtil.parseJSONObject(json);
        System.out.println(JacksonUtil.getDouble(jsonNode, "age"));
        System.out.println(JacksonUtil.getDouble(jsonNode, "ageStr"));
        System.out.println(JacksonUtil.getDouble(jsonNode, "heightStr"));
        System.out.println(JacksonUtil.getDouble(jsonNode, "height"));
    }


    @Test
    public void getBoolean() {
        String json = "\n" +
                "{\n" +
                "  \"flagStr\":\"true\",\n" +
                "  \"flag\":true,\n" +
                "  \"ageStr\":\"99\",\n" +
                "  \"age\":99,\n" +
                "  \"heightStr\":\"5.09\",\n" +
                "  \"height\":5.09\n" +
                "\n" +
                "}";
        ObjectNode jsonNode = JacksonUtil.parseJSONObject(json);
        System.out.println(JacksonUtil.getBoolean(jsonNode, "age"));
        System.out.println(JacksonUtil.getBoolean(jsonNode, "ageStr"));
        System.out.println(JacksonUtil.getBoolean(jsonNode, "heightStr"));
        System.out.println(JacksonUtil.getBoolean(jsonNode, "height"));
        System.out.println(JacksonUtil.getBoolean(jsonNode, "flagStr"));
        System.out.println(JacksonUtil.getBoolean(jsonNode, "flag"));
        Assert.assertTrue(JacksonUtil.getBoolean(jsonNode, "flag"));
    }


    @Test
    public void getDate() {
        String json = "\n" +
                "{\n" +
                "  \"name\":\"张三\",\n" +
                "  \"job\":\"罪犯\",\n" +
                "  \"bir\":\"2020-10-29 12:03:56\",\n" +
                "  \"flagStr\":\"true\",\n" +
                "  \"flag\":true,\n" +
                "  \"ageStr\":\"99\",\n" +
                "  \"age\":99,\n" +
                "  \"heightStr\":\"5.09\",\n" +
                "  \"height\":5.09\n" +
                "\n" +
                "}";
        ObjectNode jsonNode = JacksonUtil.parseJSONObject(json);
        System.out.println(JacksonUtil.getDate(jsonNode, "bir"));
        System.out.println(JacksonUtil.getDate(jsonNode, "bir", new SimpleDateFormat("yyyy-MM-dd HH:mm")));
        System.out.println(JacksonUtil.getDate(jsonNode, "bir", new SimpleDateFormat("yyyy-MM-dd HH")));
    }


    @Test
    public void newObjectNode() {
        ObjectNode jsonNodes = JacksonUtil.newJSONObject();
        jsonNodes.put("name", "张三丰");
        jsonNodes.put("age", "111");
        System.out.println(jsonNodes);
        jsonNodes.remove("age");
        System.out.println(jsonNodes);
    }

    @Test
    public void newArrayNode() {
        ArrayNode jsonNodes = JacksonUtil.newJSONArray();
        ObjectNode jsonNode = JacksonUtil.newJSONObject();
        jsonNode.put("name", "张三丰");
        jsonNode.put("age", "111");
        jsonNodes.add(jsonNode);
        System.out.println(jsonNodes);
        System.out.println(JacksonUtil.toPrettyJSONString(jsonNodes));
        System.out.println(JacksonUtil.toJSONString(jsonNodes));
    }

    /**
     * 复杂对象测试
     */
    @Test
    public void complexObjTest() {
        // 造数据
        Person person = new Person();
        person.setName("Tom");
        person.setAge(40);
        person.setHeight(888);
        person.setDate(new Date());
        person.setLocalDate(LocalDate.now());
        person.setLocalDateTime(LocalDateTime.now());
        person.setLocalTime(LocalTime.now());
        person.setList(Lists.newArrayList("list1", "list2", "list3"));
        person.setMap(ImmutableMap.of("key1", "value1", "key2", "value2", "key3", "value3"));
        Person.Info info = new Person.Info();
        info.setCity("北京");
        info.setAddress("朝阳区");
        info.setNums(new int[]{3, 5, 77, 99999, 0});
        info.setExtension(new HashMap<>(ImmutableMap.of("k1", "v1", "k2", "v2", "k3", "v3")));
        person.setInfo(info);

        String json = JacksonUtil.toPrettyJSONString(person);
        System.out.println(json);

        System.out.println(JacksonUtil.parseJSONObject(json));
        Person person1 = JacksonUtil.toJavaObject(json, Person.class);
        System.out.println(person1);
    }

    @Test
    public void test6() {
        System.out.println(JacksonUtil.toJSONString("979dfs8g|\n\n4s6df" +
                "*6///**/tderdgfsfds ggsr dgfssq$@#@@#%$^fe"));
        System.out.println(JacksonUtil.toJSONString(11));
        ESBMessage esbMessage = new ESBMessage();
        esbMessage.setReConsumeTimes((byte) 0);
        esbMessage.setVersion((byte) 0);
        esbMessage.setTotalLen(0);
        esbMessage.setSubject(0);
        esbMessage.setMessageID(0L);
        esbMessage.setMessageType((byte) 0);
        esbMessage.setDeliveryMode((byte) 0);
        esbMessage.setClientID(0);
        esbMessage.setBody(new byte[]{11});
        esbMessage.setSessionID(0L);
        esbMessage.setProtocolType((byte) 0);
        esbMessage.setNeedReplay((byte) 0);
        esbMessage.setCommandType((byte) 0);
        esbMessage.setIp(0);
        esbMessage.setTimestamp(0L);
        esbMessage.setSequenceId(0);
        esbMessage.setSequenceKey(new Object());
        esbMessage.setDelayLevel(0);
        esbMessage.setDelaySeconds(0L);
        esbMessage.setESBKey("");
        esbMessage.setProperties("");
        esbMessage.setPropertiesMap(Maps.newHashMap());
        esbMessage.setPropertiesLen(0);
        esbMessage.setBodyLen(0);
        esbMessage.setLogicOffset(0L);
        esbMessage.setPullVersion(0L);
        esbMessage.setTag("");
        esbMessage.setStrictOrder(false);
        esbMessage.setStarttime(0L);
        esbMessage.setWaitSendTmp1(0L);
        esbMessage.setAfterSendTmp2(0L);
        esbMessage.setReceiveAckTmp3(0L);

        System.out.println(JacksonUtil.toPrettyJSONString(esbMessage));
    }

    @Test
    public void test7() {
        ObjectNode jsonNode = JacksonUtil.newJSONObject();
        // ObjectNode jsonNode = new ObjectNode(JsonNodeFactory.withExactBigDecimals(true));
        jsonNode.put("aa", BigDecimal.valueOf(1000000000000L));
        System.out.println(jsonNode.toPrettyString());
    }


    @Test
    public void test8() {
        String json = "{\n" +
                "\t\"unityLocals\": \"1162,1162\",\n" +
                "\t\"localType\": 2,\n" +
                "\t\"unityCityId\": 37,\n" +
                "\t\"xiaoquId\": 100430655,\n" +
                "\t\"addDate\": 1520603180000,\n" +
                "\t\"bianHao\": \"\",\n" +
                "\t\"casLock\": 0,\n" +
                "\t\"cateId\": 13,\n" +
                "\t\"brokerId\": 11111,\n" +
                "\t\"chaoXiang\": 2,\n" +
                "\t\"contactName\": \"苏中闰\",\n" +
                "\t\"effectiveDate\": 1552139180563,\n" +
                "\t\"houseId\": 735654988077056,\n" +
                "\t\"jiaGe\": \"880000\",\n" +
                "\t\"jiageDanwei\": 0,\n" +
                "\t\"mianJi\": \"147.0\",\n" +
                "\t\"params\": {\n" +
                "\t\t\"22\": \"0\",\n" +
                "\t\t\"88\": \"4\",\n" +
                "\t\t\"89\": \"2389\",\n" +
                "\t\t\"24\": \"1\",\n" +
                "\t\t\"25\": \"2\"\n" +
                "\t},\n" +
                "\n" +
                "\t\"phone\": \"18716365076\",\n" +
                "\t\"postDate\": 1520603180000,\n" +
                "\t\"shi\": 3,\n" +
                "\t\"source\": 17,\n" +
                "\t\"state\": 5,\n" +
 
                "\t\"stateAjk\": 0,\n" +
                "\t\"suoZaiLouCeng\": 15,\n" +
                "\t\"ting\": 2,\n" +
                "\t\"title\": \"急售！！陈家坪华宇花园三房147平 才88万 拎包入住\",\n" +
                "\t\"userIP\": \"10.126.92.95\",\n" +
                "\t\"userId\": 4453615,\n" +
                "\t\"userIdAjk\": 4453615,\n" +
                "\t\"wei\": 2,\n" +
                "\t\"xiangXiDiZhi\": \"南华街810号\",\n" +
                "\t\"zhuangXiuQingKuang\": 4,\n" +
                "\t\"zongLouCeng\": 30,\n" +
                "\n" +
                "\t\"msgSendTime\": 1555918430958,\n" +
                "\t\"system\": \"\",\n" +
                "\t\"fromIp\": \"100\",\n" +
                "\t\"callerKey\": \"******dsfdsdfsfsdf\",\n" +
                "\t\"isBiz\": 1,\n" +
                "\t\"isVip\": 1,\n" +
                "\t\"webSite\": [1, 2],\n" +
                "\t\"userId\": 44429517666583,\n" +
                "\t\"sortId\": 103527,\n" +
                "\t\"picList\": [{\n" +
                "\t\t\"host\": \"1\",\n" +
                "\t\t\"hash\": \"36fe930c068a57f066e5445153494d14\",\n" +
                "\t\t\"width\": 931,\n" +
                "\t\t\"size\": 146747,\n" +
                "\t\t\"category\": 1,\n" +
                "\t\t\"height\": 912,\n" +
                "\t\t\"order\": 0,\n" +
                "\t\t\"isCover\": 1,\n" +
                "\t\t\"fullPath\": \"http://pic1.ajkimg.com/display/anjuke/36fe930c068a57f066e5445153494d14/600x600.jpg\",\n" +
                "\t\t\"addTime\": 1546329618\n" +
                "\t}, {\n" +
                "\t\t\"host\": \"1\",\n" +
                "\t\t\"hash\": \"7093bdcc322fd774e3f56284be933513\",\n" +
                "\t\t\"width\": 1242,\n" +
                "\t\t\"size\": 125422,\n" +
                "\t\t\"category\": 1,\n" +
                "\t\t\"height\": 640,\n" +
                "\t\t\"order\": 1,\n" +
                "\t\t\"isCover\": 0,\n" +
                "\t\t\"fullPath\": \"http://pic1.ajkimg.com/display/anjuke/7093bdcc322fd774e3f56284be933513/600x600.jpg\",\n" +
                "\t\t\"addTime\": 1546329618\n" +
                "\t}]\n" +
                "\n" +
                "}";

        ObjectNode jsonNodes = JacksonUtil.parseJSONObject(json);
        //System.out.println(jsonNodes);
        // System.out.println(JacksonUtil.toPrettyJSONString(jsonNodes));
        System.out.println(JacksonUtil.toMap(JSON.parseObject(json)));
        System.out.println(JacksonUtil.toJSONString("55555张三"));
    }

    @Test
    public void test9() {
        AnXuanOrder anXuanOrder = new AnXuanOrder();
        anXuanOrder.setAddTime(new Timestamp(System.currentTimeMillis()));
        anXuanOrder.setBizCode(0);
        anXuanOrder.setOrderId(0L);
        anXuanOrder.setSign("");
        anXuanOrder.setStartTime("");
        anXuanOrder.setEndTime("");
        anXuanOrder.setPpu("");
        anXuanOrder.setStatus(0);

        System.out.println(JacksonUtil.toPrettyJSONString(anXuanOrder));

    }

    @Test
    public void test10() {
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("name", 2);
        jsonObject.put("age", 5);

        System.out.println(JacksonUtil.toPrettyJSONString(jsonObject));

        ZhangSan zhangSan = new ZhangSan();
        zhangSan.setZhangsanName("88888888");
        zhangSan.setName("99999999");
        zhangSan.setAge(0);
        zhangSan.setDate(new Date());
        zhangSan.setHeight(0);
        zhangSan.setLocalDate(LocalDate.now());
        zhangSan.setLocalDateTime(LocalDateTime.now());
        zhangSan.setLocalTime(LocalTime.now());
        zhangSan.setInfo(new Info());
        zhangSan.setList(Lists.newArrayList());
        zhangSan.setMap(Maps.newHashMap());
        System.out.println(JacksonUtil.toPrettyJSONString(zhangSan));
    }

    @Test
    public void test11() {
        List<Person> list = Lists.newArrayList();
        Person person1 = new Person();
        person1.setName("Tom");
        person1.setAge(40);
        person1.setDate(new Date());
        person1.setLocalDate(LocalDate.now());
        person1.setLocalDateTime(LocalDateTime.now());
        person1.setLocalTime(LocalTime.now());

        Person person2 = new Person();
        person2.setName("张飞");
        person2.setAge(99);
        person2.setDate(new Date());
        person2.setLocalDate(LocalDate.now());
        person2.setLocalDateTime(LocalDateTime.now());
        person2.setLocalTime(LocalTime.now());

        list.add(person1);
        list.add(person2);

        List<Map<String, Object>> maps = JacksonUtil.toMapList(list, String.class, Object.class);

        for (Map<String, Object> map : maps) {
            map.forEach((key,value)-> System.out.println(key+"->"+value));
        }

    }

    @Test
    public void test12(){
        Object json="[ {\n" +
                "  \"name\" : \"Tom\",\n" +
                "  \"age\" : 40,\n" +
                "  \"date\" : \"2020-12-05 17:12\",\n" +
                "  \"height\" : 0,\n" +
                "  \"localDate\" : \"2020-12-05\",\n" +
                "  \"localDateTime\" : \"2020-12-05 17:12:45\",\n" +
                "  \"localTime\" : \"17:12:45\"\n" +
                "}, {\n" +
                "  \"name\" : \"张飞\",\n" +
                "  \"age\" : 99,\n" +
                "  \"date\" : \"2020-12-05 17:12\",\n" +
                "  \"height\" : 0,\n" +
                "  \"localDate\" : \"2020-12-05\",\n" +
                "  \"localDateTime\" : \"2020-12-05 17:12:45\",\n" +
                "  \"localTime\" : \"17:12:45\"\n" +
                "} ]";
        List<Map<String, Object>> maps = JacksonUtil.toMapList(json, String.class, Object.class);
        System.out.println(JacksonUtil.toPrettyJSONString(maps));

        List<Map<String, Object>> maps1 = JacksonUtil.toMapList(maps);
        System.out.println(JacksonUtil.toPrettyJSONString(maps1));
    }

    @Test
    public void test13(){
        String json="{\"attributes\":\"6\",\"message\":\"接口转发异常：500 \",\"result\":[{\"aaa\":444}],\"result1\":{\"aaa\":444,\"bbb\":\"bbb\"},\"status\":\"error\",\"date\":\"2020-12-05 17:12\"}";
        ObjectNode jsonObject = JacksonUtil.parseJSONObject(json);
        System.out.println(JacksonUtil.getString(jsonObject,"result"));
        System.out.println(JacksonUtil.getString(jsonObject,"result1"));
       // String attributes = JacksonUtil.getString(jsonObject,"attributes");

        //Map<String, Object> am = JacksonUtil.toMap(attributes);
        //System.out.println(am);

        System.out.println(JacksonUtil.getBoolean(jsonObject, "attributes"));
        System.out.println(JacksonUtil.getInteger(jsonObject, "attributes"));
        System.out.println(JacksonUtil.getDouble(jsonObject, "attributes"));
        System.out.println(JacksonUtil.getByte(jsonObject, "attributes"));
        System.out.println(JacksonUtil.getLong(jsonObject, "attributes"));
        //System.out.println(JacksonUtil.getDate(jsonObject, "attributes"));
        System.out.println(JacksonUtil.getDate(jsonObject, "date",new SimpleDateFormat("yyyy-MM-dd HH:mm")));
    }
}