Json-Jackson和FastJson

设置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 
     * @return
     */
    public static  T parse(@NonNull String json, Class 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


    com.fasterxml.jackson.core
    jackson-databind
    2.13.3

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 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 personList = objectMapper.readValue(file, new TypeReference>() {});
    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 employeeMap = objectMapper.readValue(expectedJson, new TypeReference(){});
    System.out.println(employeeMap.getClass());
    for (Entry entry : employeeMap.entrySet()) {
        System.out.println(entry.getKey() + ":" + entry.getValue());
    }
}

可以看到 Map 的输出结果：


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

Jackson 解析 JSON 详细教程 - 知乎

相关阅读:
QT学习笔记-QT访问各种关系数据库笔记汇总
 SpringBoot——自定义start
SQL Server事务隔离级别
 rsync远程同步
 shiro回话管理
 图像处理：模糊图像判断
 Python进阶复习-自带库
 AI写真教程：Stable Diffusion 之 IPAdapter-FaceId
部署docker仓库harbor
代码随想录day56｜583. 两个字符串的删除操作｜72. 编辑距离｜编辑距离总结篇｜Golang
原文地址：https://blog.csdn.net/ZHOU_VIP/article/details/132943617