狂神：
测试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会作为backup
spring.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:ss
time-zone: GMT+8
#设置空如何序列化
default-property-inclusion: non_null
serialization:
#格式化输出
indent_output: true
#忽略无法转换的对象
fail_on_empty_beans: false
deserialization:
#允许对象忽略json中不存在的属性
fail_on_unknown_properties: false
parser:
#允许出现特殊字符和转义符
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>()
{
@Override
public 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 {
@JsonIgnore
private Long id;
@JsonProperty("userName")
private String name;
@JsonIgnore
private Integer age;
@JsonIgnore
private 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();
@Test
public 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();
@Test
void 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 详细教程 - 知乎
![[Linux打怪升级之路]-缓冲区](https://img-blog.csdnimg.cn/297efc010473415ea72a4abd03e9ea42.png)
