Json-Jackson和FastJson

狂神： 

测试Jackson

纯Java解决日期格式化

设置ObjectMapper

FastJson：

---

知乎：Jackson使用指南

1、常见配置

方式一：yml配置

spring.jackson.date-format指定日期格式，比如yyyy-MM-dd HH:mm:ss，或者具体的格式化类的全限定名spring.jackson.time-zone指定日期格式化时区，比如America/Los_Angeles或者GMT+10.spring.jackson.deserialization是否开启Jackson的反序列化spring.jackson.generator是否开启json的generators.spring.jackson.joda-date-time-format指定Joda date/time的格式，比如yyyy-MM-ddHH:mm:ss). 如果没有配置的话，dateformat会作为backupspring.jackson.locale指定json使用的Locale.spring.jackson.mapper是否开启Jackson通用的特性.spring.jackson.parser是否开启jackson的parser特性.spring.jackson.property-naming-strategy指定PropertyNamingStrategy(CAMEL_CASE_TO_LOWER_CASE_WITH_UNDERSCORES)或者指定PropertyNamingStrategy子类的全限定类名.spring.jackson.serialization是否开启jackson的序列化.spring.jackson.serialization-inclusion指定序列化时属性的inclusion方式，具体查看JsonInclude.Include枚举.
spring:jackson:#日期格式化date-format: yyyy-MM-dd HH:mm:sstime-zone: GMT+8#设置空如何序列化default-property-inclusion: non_null    serialization:#格式化输出 indent_output: true#忽略无法转换的对象fail_on_empty_beans: falsedeserialization:#允许对象忽略json中不存在的属性fail_on_unknown_properties: falseparser:#允许出现特殊字符和转义符allow_unquoted_control_chars: true#允许出现单引号allow_single_quotes: true

方式二：重新注入ObjectMapper

@Bean
@Primary
@ConditionalOnMissingBean(ObjectMapper.class)
public ObjectMapper jacksonObjectMapper(Jackson2ObjectMapperBuilder builder{ObjectMapper objectMapper = builder.createXmlMapper(false).build();// 通过该方法对mapper对象进行设置，所有序列化的对象都将按改规则进行系列化// Include.Include.ALWAYS 默认// Include.NON_DEFAULT 属性为默认值不序列化// Include.NON_EMPTY 属性为 空（""） 或者为 NULL 都不序列化，则返回的json是没有这个字段的。这样对移动端会更省流量// Include.NON_NULL 属性为NULL 不序列化objectMapper.setSerializationInclusion(JsonInclude.Include.NON_EMPTY);objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);// 允许出现特殊字符和转义符objectMapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_CONTROL_CHARS, true);// 允许出现单引号objectMapper.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true);// 字段保留，将null值转为""objectMapper.getSerializerProvider().setNullValueSerializer(new JsonSerializer<Object>(){@Overridepublic void serialize(Object o, JsonGenerator jsonGenerator,SerializerProvider serializerProvider)throws IOException{jsonGenerator.writeString("");}});return objectMapper;
}

2、常用 API

因为日常开发最常用的api就是对象的序列化和反序列化，这里封装一个工具类，这里只展示部分

API，其他API可参考 JSON解析-Jackson

package com.it.jackson.util;import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import lombok.NonNull;
import lombok.extern.slf4j.Slf4j;@Slf4j
public class JsonUtils {private static ObjectMapper mapper = new ObjectMapper();static {// 对于空的对象转json的时候不抛出错误mapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);// 允许属性名称没有引号mapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);// 允许单引号mapper.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true);// 设置输入时忽略在json字符串中存在但在java对象实际没有的属性mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);// 设置输出时包含属性的风格mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);}/*** 序列化，将对象转化为json字符串** @param data* @return*/public static String toJsonString(Object data) {if (data == null) {return null;}String json = null;try {json = mapper.writeValueAsString(data);} catch (JsonProcessingException e) {log.error("[{}] toJsonString error：{{}}", data.getClass().getSimpleName(), e);}return json;}/*** 反序列化，将json字符串转化为对象** @param json* @param clazz* @param <T>* @return*/public static <T> T parse(@NonNull String json, Class<T> clazz) {T t = null;try {t = mapper.readValue(json, clazz);} catch (Exception e) {log.error(" parse json [{}] to class [{}] error：{{}}", json, clazz.getSimpleName(), e);}return t;}}

测试：

package com.it.jackson.domain;import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;import java.util.Date;@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class User {private Long id;private String name;private Integer age;private Date birthday;
}package com.it.jackson.test;import com.it.jackson.domain.User;
import com.it.jackson.util.JsonUtils;
import lombok.extern.slf4j.Slf4j;import java.util.Date;@Slf4j
public class JacksonTest {public static void main(String[] args) {User user = User.builder().id(1L).name("tom").age(23).birthday(new Date()).build();String json = JsonUtils.toJsonString(user);log.info("obj toJsonString:[{}]", json);User u = JsonUtils.parse(json, User.class);log.info("parse json to obj: [{}]", u);}
}16:44:01.871 [main] INFO com.it.jackson.test.JacksonTest - obj toJsonString:[{"id":1,"name":"tom","age":23,"birthday":1587890641047}]
16:44:01.941 [main] INFO com.it.jackson.test.JacksonTest - parse json to obj: [User(id=1, name=tom, age=23, birthday=Sun Apr 26 16:44:01 CST 2020)]

3、常用 注解

3.1、JsonProperty

【@JsonProperty】类似于sql里字段的别名，用于序列化，使用注解字段属性，替代原字段属性

@JsonProperty("userName")
private String name;
序列化结果为：在序列化的json串中，userName替代了name
{"userName":"tom"}

3.2、JsonIgnore

【@JsonIgnore】在序列化时忽略该字段

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class User {@JsonIgnoreprivate Long id;@JsonProperty("userName")private String name;@JsonIgnoreprivate Integer age;@JsonIgnoreprivate Date birthday;
}序列化结果为：
{"userName":"tom"}

3.3、JsonIgnoreProperties

【@JsonIgnoreProperties】

1、序列化@JsonIgnoreProperties与@JsonIgnore类似，用于类上，注解使用的是字段别名

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;import java.util.Date;@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@JsonIgnoreProperties({"id","userName","birthday"})
public class User {private Long id;@JsonProperty("userName")private String name;private Integer age;private Date birthday;
}序列化结果为：
{"age":23}

2、@JsonIgnoreProperties(ignoreUnknown = true)用于忽略字段不匹配情况，相当于

mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);

【@JsonTypeName @JsonTypeInfo】用在类上，在序列化时增加一层

import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.JsonTypeName;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;import java.util.Date;@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@JsonTypeName(value = "user")
@JsonTypeInfo(include = JsonTypeInfo.As.WRAPPER_OBJECT, use = JsonTypeInfo.Id.NAME)
public class User {private Long id;@JsonProperty("userName")private String name;private Integer age;private Date birthday;
}序列化结果：{"user":{"id":1,"age":23,"birthday":1587891781603,"userName":"tom"}}

3.4、JsonRootName

【@JsonRootName】

组合在序列化上等于类上注解@JsonRootName(“user”) 和

mapper.enable(SerializationFeature.WRAP_ROOT_VALUE),反序列化无用;

3.5、JsonForma

【@JsonForma】格式化日期格式

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class User {private Long id;@JsonProperty("userName")private String name;private Integer age;@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss:SSS", timezone = "GMT+8")private Date birthday;
}
序列化结果：{"id":1,"age":23,"birthday":"2020-04-26 17:09:32:818","userName":"tom"}

---

知乎：Jackson解析JSON详细教程

JSON介绍

什么是 JSON ？JSON 是 ”JavaScript Object Notation“ 的缩写，JSON是一种基于文本的格式，

可以把它理解为是一个结构化的数据，这个结构化数据中可以包含键值映射、嵌套对象以及数

组等信息。

Jackson介绍

Jackson和FastJson一样，是一个Java语言编写的，可以进行JSON处理的开源工具库，

Jackson的使用非常广泛，Spring框架默认使用Jackson进行JSON处理。

Jackson有三个核包，分别是Streaming、Databid、Annotations，通过这些包可以方便的对

JSON 进行操作。

Streaming[4]在jackson-core 模块。 定义了一些流处理相关的API以及特定的 JSON 实现。

Annotations[5]在jackson-annotations 模块，包含了 Jackson 中的注解。

Databind[6]在jackson-databind 模块， 在Streaming包的基础上实现了数据绑定，依赖

于Streaming和Annotations包。

得益于Jackson高扩展性的设计，有很多常见的文本格式以及工具都有对 Jackson 的相应适配，

如 CSV、XML、YAML 等。

Jackson Maven依赖

在使用 Jackson 时，大多数情况下我们只需要添加jackson-databind依赖项，就可以使用

Jackson功能了，它依赖了下面两个包。

com.fasterxml.jackson.core:jackson-annotations

com.fasterxml.jackson.core:jackson-core

<dependency><groupId>com.fasterxml.jackson.core</groupId><artifactId>jackson-databind</artifactId><version>2.13.3</version>
</dependency>

ObjectMapper对象映射器

ObjectMapper是Jackson库中最常用的一个类，使用它可以进行Java对象和JSON字符串之间快

速转换。如果你用过 FastJson，那么Jackson中的ObjectMapper就如同FastJson中的JSON类。

这个类中有一些常用的方法：

readValue() 方法可以进行JSON的反序列化操作，比如可以将字符串、文件流、字节流、字节

数组等将常见的内容转换成 Java 对象。

writeValue() 方法可以进行JSON的序列化操作，可以将Java对象转换成JSON字符串。

大多数情况下，ObjectMapper的工作原理是通过Java Bean对象的Get/Set方法进行转换时映射

的，所以正确编写 Java 对象的Get/Set 方法尤为重要，不过ObjectMapper也提供了诸多配置，

比如可以通过配置或者注解的形式对 Java 对象和 JSON 字符串之间的转换过程进行自定义。这些

在下面部分都会介绍到。

Jackson JSON基本操作

Jackson作为一个Java中的JSON工具库，处理JSON字符串和Java 对象是它最基本最常用的

功能，下面通过一些例子来演示其中的用法。

Jackson JSON序列化

编写一个Person类，定义三个属性，名称、年龄以及技能

/*** @author zhou*/
@Data
public class Person {private String name;private Integer age;private List<String> skillList;
}

将Java对象转换成JSON字符串

import java.util.Arrays;import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;/*** @author https://www.wdbyte.com*/
class PersonTest {ObjectMapper objectMapper = new ObjectMapper();@Testpublic void pojoToJsonString() throws JsonProcessingException {Person person = new Person();person.setName("aLng");person.setAge(27);person.setSkillList(Arrays.asList("java", "c++"));String json = objectMapper.writeValueAsString(person);System.out.println(json);}
}

输出的 JSON 字符串：

{"name":"aLng","age":27,"skillList":["java","c++"]}

Jackson甚至可以直接把序列化后的 JSON 字符串写入文件或者读取成字节数组 

mapper.writeValue(new File("result.json"), myResultObject);
// 或者
byte[] jsonBytes = mapper.writeValueAsBytes(myResultObject);
// 或者
String jsonString = mapper.writeValueAsString(myResultObject);

Jackson JSON反序列化

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;/*** @author https://www.wdbyte.com*/
class PersonTest {ObjectMapper objectMapper = new ObjectMapper();@Testvoid jsonStringToPojo() throws JsonProcessingException {String expectedJson = "{\"name\":\"aLang\",\"age\":27,\"skillList\":[\"java\",\"c++\"]}";Person person = objectMapper.readValue(expectedJson, Person.class);System.out.println(person);}
}

输出结果：

Person(name=aLang, age=27, skillList=[java, c++])

JSON转List

上面演示JSON字符串都是单个对象的，如果JSON是一个对象列表那么使用Jackson该怎么处理

呢？已经存在一个文件 PersonList.json 

[{"name": "aLang","age": 27,"skillList": ["java","c++"]},{"name": "darcy","age": 26,"skillList": ["go","rust"]}
]

ObjectMapper objectMapper = new ObjectMapper();@Test
public void fileToPojoList() throws IOException {File file = new File("src/EmployeeList.json");List<Person> personList = objectMapper.readValue(file, new TypeReference<List<Person>>() {});for (Person person : personList) {System.out.println(person);}}

可以输出对象内容：

Person(name=aLang, age=27, skillList=[java, c++])
Person(name=darcy, age=26, skillList=[go, rust])

JSON转Map

JSON 转 Map 在我们没有一个对象的 Java 对象时十分实用，下面演示如何使用 Jackson 把

JSON 文本转成 Map 对象。

ObjectMapper objectMapper = new ObjectMapper();@Test
public void jsonStringToMap() throws IOException {String expectedJson = "{\"name\":\"aLang\",\"age\":27,\"skillList\":[\"java\",\"c++\"]}";Map<String, Object> employeeMap = objectMapper.readValue(expectedJson, new TypeReference<Map>(){});System.out.println(employeeMap.getClass());for (Entry<String, Object> entry : employeeMap.entrySet()) {System.out.println(entry.getKey() + ":" + entry.getValue());}
}

可以看到 Map 的输出结果：

class java.util.LinkedHashMap
name:aLang
age:27
skillList:[java, c++]

Jackson 解析 JSON 详细教程 - 知乎