Json-Jackson和FastJson

骑猪看日落 2024-03-02 08:03 80阅读 0赞

狂神：

![48d72e79efdf4fafb91c11b82c7de87b.png][]

![a1d6436116ef451487d8257eba325b5b.png][]

![2788b149ae70453191f611b9ea47050a.png][]

![364dbe8a9e344e619ba854c9f1a69498.png][]

测试Jackson

![0d753b9e8d5e4172a123caa9e20b33f9.png][]

![f30ced66f6af46ba9b6d3349ca0996b2.png][]

纯Java解决日期格式化

![ff290728fd8f420b8160e0c40dff0356.png][]

设置ObjectMapper

![ab9bd4f2e834436babefe44324110cf2.png][]

FastJson：

![b30848fffe7541129a4809836df5c1c3.png][]

![92b93e9d24734c4b8d94ad17325b036d.png][]

![a142552ecaed48feaacb5b74933676e5.png][]

![4ff4676f190e493c9b42c3e70891019e.png][]

--------------------

**知乎：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++])

![5294e51605cd49deb65f234c057770b0.png][]**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 详细教程 - 知乎][Jackson _ JSON _ -]

[48d72e79efdf4fafb91c11b82c7de87b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/c2b4be2658284a1ea9476bdc57d379c6.png
[a1d6436116ef451487d8257eba325b5b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/21d8dd95d84944b5a279b7ed094847e7.png
[2788b149ae70453191f611b9ea47050a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/94d6aa03a1544bc1b78f795a6bc59700.png
[364dbe8a9e344e619ba854c9f1a69498.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/85fc874fb16f42238f678e6b27fbbec9.png
[0d753b9e8d5e4172a123caa9e20b33f9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/f56457bc63cd4ba7ae8dc6ab6fb76834.png
[f30ced66f6af46ba9b6d3349ca0996b2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/0be4e0e081184d9da8d9ed7d8ada92e1.png
[ff290728fd8f420b8160e0c40dff0356.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/ca44e91f518e4465ac88889411bc7e16.png
[ab9bd4f2e834436babefe44324110cf2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/c176ea995bbb4edabf8e02f20ced42fb.png
[b30848fffe7541129a4809836df5c1c3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/b985a8d510e34719a4f6d05a18aa4944.png
[92b93e9d24734c4b8d94ad17325b036d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/7c39a68455f94e1bb26bf373f0ee63e5.png
[a142552ecaed48feaacb5b74933676e5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/4a9134737bb8496990dde99d46643ccf.png
[4ff4676f190e493c9b42c3e70891019e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/c4f8ca3b53064e1c97a96d3fc85ad684.png
[5294e51605cd49deb65f234c057770b0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/00ea9f59a2884d17a16f40cffa007e1c.png
[Jackson _ JSON _ -]: https://zhuanlan.zhihu.com/p/544720345