Jackson 的 使用

---

依赖

<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.11.0</version>
</dependency>

jackson-databind 依赖 jackson-core 和 jackson-annotations，当添加 jackson-databind 之后， jackson-core 和 jackson-annotations 也随之添加到 Java 项目工程中。
在添加相关依赖包之后，就可以使用 Jackson。

配置信息

//在反序列化时忽略在 json 中存在但 Java 对象不存在的属性 
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES,false); 

//在序列化时日期格式默认为 yyyy-MM-dd'T'HH:mm:ss.SSSZ 
mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false) 

//在序列化时忽略值为 null 的属性 
mapper.setSerializationInclusion(Include.NON_NULL); 

//忽略值为默认值的属性 
mapper.setDefaultPropertyInclusion(Include.NON_DEFAULT);

更多配置信息可以查看 Jackson 的 DeserializationFeature，SerializationFeature 和 Include。

注解

Jackson 根据它的默认方式序列化和反序列化 java 对象，若根据实际需要，灵活的调整它的默认方式，可以使用 Jackson 的注解。
常用的注解及用法如下：

@JsonProperty：用于属性，把属性的名称序列化时转换为另外一个名称。

@JsonProperty("birth_date")
 private Date birthDate;

@JsonFormat：用于属性或者方法，把属性的格式序列化时转换成指定的格式。

@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
 public Date birthDate;

@JsonPropertyOrder：用于类，指定属性在序列化时 json 中的顺序。

@JsonPropertyOrder({ "birth_date", "name" })
 public class Person{}

说明

Jackson 最常用的 API 就是基于”对象绑定” 的 ObjectMapper。
writeValue：将 java 对 象序列化 为 json，并 将 json 存 储成不同的格式，String（writeValueAsString），Byte Array（writeValueAsString），Writer， File，OutStream 和 DataOutput。
readValue：将不同的数据源像 String ， Byte Array， Reader，File，URL， InputStream 将 json 反序列化为 java 对象。

封装

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.*;

import java.io.IOException;

/**
 * author ：demon
 * date ：2021 2021/11/2 11:18
 * desc ：
 */
public class ObjectMapperUtil {

    private static ObjectMapperUtil objectMapperUtil;
    private ObjectMapper objectMapper;

    private ObjectMapperUtil() {
        System.out.println("初始化-ObjectMapper-");
        objectMapper = new ObjectMapper();

        // json不进行换行缩进等操作  默认就是不进行操作，写了这行和没写的效果一样
        objectMapper.disable(SerializationFeature.INDENT_OUTPUT);

        // 属性为Null的不进行序列化，只对pojo起作用，对map和list不起作用
        objectMapper.setSerializationInclusion(JsonInclude.Include.ALWAYS);

        // json是否允许属性名没有引号 ，默认是false
        objectMapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);
        // json是否允许属性名为单引号 ，默认是false
        objectMapper.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true);
        // 反序列化的时候如果多了其他属性,不抛出异常
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        // 如果是空对象的时候,不抛异常
        objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);

        //属性为null的转换
        objectMapper.getSerializerProvider().setNullValueSerializer(new JsonSerializer<Object>() {
            @Override
            public void serialize(Object arg0, JsonGenerator arg1, SerializerProvider arg2) throws IOException {
                arg1.writeString("");
            }
        });

        // 取消时间的转化格式,默认是时间戳,可以取消,同时需要设置要表现的时间格式
        // objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        // objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));

    }

    public static ObjectMapperUtil getInstance() {
        if (objectMapperUtil == null) {
            objectMapperUtil = ObjectMapperUtilLoader.instance;
        }
        return objectMapperUtil;
    }

    public ObjectMapper getObjectMapper() {
        return objectMapper;
    }

    private static class ObjectMapperUtilLoader {
        private static final ObjectMapperUtil instance = new ObjectMapperUtil();
    }

}

使用

实体对象转化字符串

try {
    String jsonString = ObjectMapperUtil.getInstance().getObjectMapper().writerWithDefaultPrettyPrinter().writeValueAsString(new 实体对象());
} catch (JsonProcessingException e) {
    e.printStackTrace();
}

字符串转化键值对象

try {
    Map<String, Object> jsonMap = ObjectMapperUtil.getInstance().getObjectMapper().readValue(jsonString, new TypeReference<Map<String, Object>>() {});
} catch (JsonProcessingException e) {
    e.printStackTrace();
}

创建对象

ObjectMapper objectMapper = ObjectMapperUtil.getInstance().getObjectMapper();

ObjectNode objectNode = objectMapper.createObjectNode();
objectNode.put("name", "张三");
objectNode.put("age", 30);

ArrayNode arrayNode = objectMapper.createArrayNode();
arrayNode.add("Java");
arrayNode.add("Python");
objectNode.set("job", arrayNode);

System.out.println(objectNode.toString());  // {"name":"张三","age":30,"job":["Java","Python"]}