jackson学习之一：基本信息 jackson学习之二：jackson-core

• • jackson学习之一：基本信息
  • jackson学习之二：jackson-core
  • jackson学习之三：常用API操作
  • jackson学习之四：WRAP_ROOT_VALUE（root对象）
  • jackson学习之五：JsonInclude注解
  • jackson学习之六：常用类注解
  • jackson学习之七：常用Field注解
  • jackson学习之八：常用方法注解
  • jackson学习之九：springboot整合(配置文件)
  • jackson学习之十(终篇)：springboot整合(配置类)
    • • jackson学习之一：基本信息

        • 本文是《jackson学习》系列的第一篇，先来一起了解jackson：

          1. jackson的github地址：https://github.com/FasterXML/jackson
          2. 按照官网所述，jackson是java技术栈内最好的JSON解析工具(best JSON parser for Java)；
          3. 除了JSON解析，jackson还是个数据处理工具集：基于流的解析库和生成库、数据绑定、数据格式化模块(Avro、XML、Protobuf、YAML等)；

          版本信息

          1. jackson共有1.x和2.x两个版本系列，其中1.x已废弃不再有版本发布，2.x是活跃版本；
          2. 1.x和2.x不兼容，如果您的代码已经使用了1.x，现在想改用2.x，您就必须修改使用jackson的那部分代码；
          3. 虽然不兼容，但是1.x和2.x不冲突，您的项目可以在pom.xml中同时依赖这两个版本，假设您原有三处代码调用了1.x的API，现在可以把一处改成2.x的，另外两处维持不变，这个特性适合将项目逐步从1.x升级到2.x(This is by design and was chosen as the strategy to allow smoother migration from 1.x to 2.x.)；
          4. 2.x系列版本中，有的版本已关闭(除非bug或者安全问题才会发布新的小版本)，有的版本还处于活跃状态，如下图，您可以在这个地址获取最新情况：https://github.com/FasterXML/jackson/wiki/Jackson-Releases

          

          三个核心模块

          jackson有三个核心模块，如下，括号内是maven的artifactId：

          1. Streaming（jackson-core）：低阶API库，提供流式解析工具JsonParser，流式生成工具JsonGenerator；
          2. Annotations（jackson-annotations）：jackson注解；
          3. Databind (jackson-databind)：基于java对象的序列化、反序列化能力，需要前面两个模块的支持才能实现；

          低阶API库的作用

          1. 当我们用jackson做JSON操作时，常用的是Databind模块的ObjectMapper类，对处于核心位置的jackson-core反倒是很少直接用到，那么该模块有什么作用呢？
          2. 如下图，BeanSerializer是jackson-databind的功能类，其serialize方法负责将java对象转为JSON，方法中的处理逻辑就是调用JsonGenerator的API，而JsonGenerator就是jackson-core中负责序列化的主要功能类：

          
          3. 可见Databind模块的ObjectMapper类提供给我们的API，其底层操作是基于jackson-core实现的；
          至此，我们对jackson已有了基本了解，接下来的文章会开始一系列的实战，通过实战来掌握和理解这套优秀的工具；

      • jackson学习之二：jackson-core

        • jackson学习之二：jackson-core

           

          欢迎访问我的GitHub

          https://github.com/zq2599/blog_demos

          内容：所有原创文章分类汇总及配套源码，涉及Java、Docker、Kubernetes、DevOPS等；

          系列文章汇总

          • jackson学习之一：基本信息
          • jackson学习之二：jackson-core
          • jackson学习之三：常用API操作
          • jackson学习之四：WRAP_ROOT_VALUE（root对象）
          • jackson学习之五：JsonInclude注解
          • jackson学习之六：常用类注解
          • jackson学习之七：常用Field注解
          • jackson学习之八：常用方法注解
          • jackson学习之九：springboot整合(配置文件)
          • jackson学习之十(终篇)：springboot整合(配置类)

          关于jackson-core

          1. 本文主要内容是jackson-core库，这是个低阶API库，提供流式解析工具JsonParser，流式生成工具JsonGenerator；
          2. 在日常的序列化和反序列化处理中，最常用的是jackson-annotations和jackson-databind，而jackson-core由于它提供的API过于基础，我们大多数情况下是用不上的；
          3. 尽管jackson-databind负责序列化和反序列化处理，但它的底层实现是调用了jackson-core的API；
          4. 本着万丈高楼平地起的原则，本文咱们通过实战了解神秘的jackson-core，了解整个jackson的序列化和反序列化基本原理；

          源码下载

          1. 如果您不想编码，可以在GitHub下载所有源码，地址和链接信息如下表所示(https://github.com/zq2599/blog_demos)：

          名称	链接	备注
          项目主页	https://github.com/zq2599/blog_demos	该项目在GitHub上的主页
          git仓库地址(https)	https://github.com/zq2599/blog_demos.git	该项目源码的仓库地址，https协议
          git仓库地址(ssh)	git@github.com:zq2599/blog_demos.git	该项目源码的仓库地址，ssh协议

          2. 这个git项目中有多个文件夹，本章的应用在jacksondemo文件夹下，如下图红框所示：

          

          创建父子工程

          创建名为jacksondemo的maven工程，这是个父子结构的工程，其pom.xml内容如下：

          <?xml version="1.0" encoding="UTF-8"?>
          <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
              <modelVersion>4.0.0</modelVersion>
              <properties>
                  <java.version>1.8</java.version>
              </properties>
              <groupId>com.bolingcavalry</groupId>
              <artifactId>jacksondemo</artifactId>
              <version>1.0-SNAPSHOT</version>
              <packaging>pom</packaging>
              <modules>
                  <module>core</module>
                  <module>beans</module>
                  <module>databind</module>
              </modules>
              <dependencyManagement>
                  <dependencies>
                      <dependency>
                          <groupId>com.fasterxml.jackson.core</groupId>
                          <artifactId>jackson-databind</artifactId>
                          <version>2.11.0</version>
                          <scope>compile</scope>
                      </dependency>
                      <dependency>
                          <groupId>org.slf4j</groupId>
                          <artifactId>slf4j-log4j12</artifactId>
                          <version>1.7.25</version>
                          <scope>compile</scope>
                      </dependency>
                      <dependency>
                          <groupId>commons-io</groupId>
                          <artifactId>commons-io</artifactId>
                          <version>2.7</version>
                          <scope>compile</scope>
                      </dependency>
                      <dependency>
                          <groupId>org.apache.commons</groupId>
                          <artifactId>commons-lang3</artifactId>
                          <version>3.10</version>
                          <scope>compile</scope>
                      </dependency>
                  </dependencies>
              </dependencyManagement>
          </project>
          

          新增子工程beans

          1. 在父工程jscksondemo下新增名为beans的子工程，这里面是一些常量和Pojo类；
          2. 增加定义常量的类Constant.java：

          package com.bolingcavalry.jacksondemo.beans;
          
          public class Constant {
              /**
               * 该字符串的值是个网络地址，该地址对应的内容是个JSON
               */
              public final static String TEST_JSON_DATA_URL = "https://raw.githubusercontent.com/zq2599/blog_demos/master/files/twitteer_message.json";
              /**
               * 用来验证反序列化的JSON字符串
               */
              public final static String TEST_JSON_STR = "{
          " +
                      "  "id":1125687077,
          " +
                      "  "text":"@stroughtonsmith You need to add a \"Favourites\" tab to TC/iPhone. Like what TwitterFon did. I can't WAIT for your Twitter App!! :) Any ETA?",
          " +
                      "  "fromUserId":855523, 
          " +
                      "  "toUserId":815309,
          " +
                      "  "languageCode":"en"
          " +
                      "}";
              /**
               * 用来验证序列化的TwitterEntry实例
               */
              public final static TwitterEntry TEST_OBJECT = new TwitterEntry();
              /**
               * 准备好TEST_OBJECT对象的各个参数
               */
              static {
                  TEST_OBJECT.setId(123456L);
                  TEST_OBJECT.setFromUserId(101);
                  TEST_OBJECT.setToUserId(102);
                  TEST_OBJECT.setText("this is a message for serializer test");
                  TEST_OBJECT.setLanguageCode("zh");
              }}
          

          3. 增加一个Pojo，对应的是一条推特消息：

          package com.bolingcavalry.jacksondemo.beans;
          /**
           * @Description: 推特消息bean
           * @author: willzhao E-mail: zq2599@gmail.com
           * @date: 2020/7/4 16:24
           */
          public class TwitterEntry {
              /**
               * 推特消息id
               */
              long id;
              /**
               * 消息内容
               */
              String text;    /**
               * 消息创建者
               */
              int fromUserId;
              /**
               * 消息接收者
               */
              int toUserId;
              /**
               * 语言类型
               */
              String languageCode;    public long getId() {
                  return id;
              }    public void setId(long id) {
                  this.id = id;
              }    public String getText() {
                  return text;
              }    public void setText(String text) {
                  this.text = text;
              }    public int getFromUserId() {
                  return fromUserId;
              }    public void setFromUserId(int fromUserId) {
                  this.fromUserId = fromUserId;
              }    public int getToUserId() {
                  return toUserId;
              }    public void setToUserId(int toUserId) {
                  this.toUserId = toUserId;
              }    public String getLanguageCode() {
                  return languageCode;
              }    public void setLanguageCode(String languageCode) {
                  this.languageCode = languageCode;
              }    public TwitterEntry() {
              }    public String toString() {
                  return "[Tweet, id: "+id+", text='"+text+"', from: "+fromUserId+", to: "+toUserId+", lang: "+languageCode+"]";
              }}
          

          4. 以上就是准备工作了，接下来开始实战jackson-core；

          JsonFactory线程安全吗?

          1. JsonFactory是否是线程安全的，这是编码前要弄清楚的问题，因为JsonParser和JsonGenerator的创建都离不开JsonFactory；
          2. 如下图红框所示，jackson官方文档中明确指出JsonFactory是线程安全的，可以放心的作为全局变量给多线程同时使用：

          
          3. 官方文档地址：http://fasterxml.github.io/jackson-core/javadoc/2.11/

          jackson-core实战

          1. 新建子工程core，pom.xml如下：

          <?xml version="1.0" encoding="UTF-8"?>
          <project xmlns="http://maven.apache.org/POM/4.0.0"
                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
              <parent>
                  <artifactId>jacksondemo</artifactId>
                  <groupId>com.bolingcavalry</groupId>
                  <version>1.0-SNAPSHOT</version>
                  <relativePath>../pom.xml</relativePath>
              </parent>
              <modelVersion>4.0.0</modelVersion>
              <groupId>com.bolingcavalry</groupId>
              <artifactId>core</artifactId>
              <name>core</name>
              <description>Demo project for jackson core use</description>
              <build>
                  <plugins>
                      <plugin>
                          <groupId>org.apache.maven.plugins</groupId>
                          <artifactId>maven-compiler-plugin</artifactId>
                          <configuration>
                              <source>8</source>
                              <target>8</target>
                          </configuration>
                      </plugin>
                  </plugins>
              </build>
              <dependencies>
                  <dependency>
                      <groupId>com.fasterxml.jackson.core</groupId>
                      <artifactId>jackson-databind</artifactId>
                  </dependency>
                  <dependency>
                      <groupId>org.slf4j</groupId>
                      <artifactId>slf4j-log4j12</artifactId>
                  </dependency>
                  <dependency>
                      <groupId>commons-io</groupId>
                      <artifactId>commons-io</artifactId>
                  </dependency>
                  <dependency>
                      <groupId>org.apache.commons</groupId>
                      <artifactId>commons-lang3</artifactId>
                  </dependency>
                  <dependency>
                      <groupId>com.bolingcavalry</groupId>
                      <artifactId>beans</artifactId>
                      <version>${project.version}</version>
                  </dependency>
              </dependencies>
          </project>
          

          2. 新建StreamingDemo类，这里面是调用jackson-core的API进行序列化和反序列化的所有demo，如下：

          package com.bolingcavalry.jacksondemo.core;
          
          import com.bolingcavalry.jacksondemo.beans.TwitterEntry;
          import com.fasterxml.jackson.core.*;
          import com.fasterxml.jackson.databind.ObjectMapper;
          import org.apache.commons.io.IOUtils;
          import org.apache.commons.lang3.StringUtils;
          import org.slf4j.Logger;
          import org.slf4j.LoggerFactory;
          
          import java.io.ByteArrayOutputStream;
          import java.io.IOException;
          import java.net.URL;
          
          /**
           * @Description: jackson低阶方法的使用
           * @author: willzhao E-mail: zq2599@gmail.com
           * @date: 2020/7/4 15:50
           */
          public class StreamingDemo {
          
              private static final Logger logger = LoggerFactory.getLogger(StreamingDemo.class);
          
              JsonFactory jsonFactory = new JsonFactory();
          
              /**
               * 该字符串的值是个网络地址，该地址对应的内容是个JSON
               */
              final static String TEST_JSON_DATA_URL = "https://raw.githubusercontent.com/zq2599/blog_demos/master/files/twitteer_message.json";
          
              /**
               * 用来验证反序列化的JSON字符串
               */
              final static String TEST_JSON_STR = "{
          " +
                      "  "id":1125687077,
          " +
                      "  "text":"@stroughtonsmith You need to add a \"Favourites\" tab to TC/iPhone. Like what TwitterFon did. I can't WAIT for your Twitter App!! :) Any ETA?",
          " +
                      "  "fromUserId":855523, 
          " +
                      "  "toUserId":815309,
          " +
                      "  "languageCode":"en"
          " +
                      "}";
          
              /**
               * 用来验证序列化的TwitterEntry实例
               */
              final static TwitterEntry TEST_OBJECT = new TwitterEntry();
          
              /**
               * 准备好TEST_OBJECT对象的各个参数
               */
              static {
                  TEST_OBJECT.setId(123456L);
                  TEST_OBJECT.setFromUserId(101);
                  TEST_OBJECT.setToUserId(102);
                  TEST_OBJECT.setText("this is a message for serializer test");
                  TEST_OBJECT.setLanguageCode("zh");
              }
          
          
              /**
               * 反序列化测试(JSON -> Object)，入参是JSON字符串
               * @param json JSON字符串
               * @return
               * @throws IOException
               */
              public TwitterEntry deserializeJSONStr(String json) throws IOException {
          
                  JsonParser jsonParser = jsonFactory.createParser(json);
          
                  if (jsonParser.nextToken() != JsonToken.START_OBJECT) {
                      jsonParser.close();
                      logger.error("起始位置没有大括号");
                      throw new IOException("起始位置没有大括号");
                  }
          
                  TwitterEntry result = new TwitterEntry();
          
                  try {
                      // Iterate over object fields:
                      while (jsonParser.nextToken() != JsonToken.END_OBJECT) {
          
                          String fieldName = jsonParser.getCurrentName();
          
                          logger.info("正在解析字段 [{}]", jsonParser.getCurrentName());
          
                          // 解析下一个
                          jsonParser.nextToken();
          
                          switch (fieldName) {
                              case "id":
                                  result.setId(jsonParser.getLongValue());
                                  break;
                              case "text":
                                  result.setText(jsonParser.getText());
                                  break;
                              case "fromUserId":
                                  result.setFromUserId(jsonParser.getIntValue());
                                  break;
                              case "toUserId":
                                  result.setToUserId(jsonParser.getIntValue());
                                  break;
                              case "languageCode":
                                  result.setLanguageCode(jsonParser.getText());
                                  break;
                              default:
                                  logger.error("未知字段 '" + fieldName + "'");
                                  throw new IOException("未知字段 '" + fieldName + "'");
                          }
                      }
                  } catch (IOException e) {
                      logger.error("反序列化出现异常 :", e);
                  } finally {
                      jsonParser.close(); // important to close both parser and underlying File reader
                  }
          
                  return result;
              }
          
              /**
               * 反序列化测试(JSON -> Object)，入参是JSON字符串
               * @param url JSON字符串的网络地址
               * @return
               * @throws IOException
               */
              public TwitterEntry deserializeJSONFromUrl(String url) throws IOException {
                  // 从网络上取得JSON字符串
                  String json = IOUtils.toString(new URL(TEST_JSON_DATA_URL), JsonEncoding.UTF8.name());
          
                  logger.info("从网络取得JSON数据 :
          {}", json);
          
                  if(StringUtils.isNotBlank(json)) {
                      return deserializeJSONStr(json);
                  } else {
                      logger.error("从网络获取JSON数据失败");
                      return null;
                  }
              }
          
          
              /**
               * 序列化测试(Object -> JSON)
               * @param twitterEntry
               * @return 由对象序列化得到的JSON字符串
               */
              public String serialize(TwitterEntry twitterEntry) throws IOException{
                  String rlt = null;
                  ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
                  JsonGenerator jsonGenerator = jsonFactory.createGenerator(byteArrayOutputStream, JsonEncoding.UTF8);
          
                  try {
                      jsonGenerator.useDefaultPrettyPrinter();
          
                      jsonGenerator.writeStartObject();
                      jsonGenerator.writeNumberField("id", twitterEntry.getId());
                      jsonGenerator.writeStringField("text", twitterEntry.getText());
                      jsonGenerator.writeNumberField("fromUserId", twitterEntry.getFromUserId());
                      jsonGenerator.writeNumberField("toUserId", twitterEntry.getToUserId());
                      jsonGenerator.writeStringField("languageCode", twitterEntry.getLanguageCode());
                      jsonGenerator.writeEndObject();
                  } catch (IOException e) {
                      logger.error("序列化出现异常 :", e);
                  } finally {
                      jsonGenerator.close();
                  }
          
                  // 一定要在
                  rlt = byteArrayOutputStream.toString();
          
                  return rlt;
              }
          
          
              public static void main(String[] args) throws Exception {
          
                  StreamingDemo streamingDemo = new StreamingDemo();
          
                  // 执行一次对象转JSON操作
                  logger.info("********************执行一次对象转JSON操作********************");
                  String serializeResult = streamingDemo.serialize(TEST_OBJECT);
                  logger.info("序列化结果是JSON字符串 : 
          {}
          
          ", serializeResult);
          
                  // 用本地字符串执行一次JSON转对象操作
                  logger.info("********************执行一次本地JSON反序列化操作********************");
                  TwitterEntry deserializeResult = streamingDemo.deserializeJSONStr(TEST_JSON_STR);
                  logger.info("
          本地JSON反序列化结果是个java实例 : 
          {}
          
          ", deserializeResult);
          
                  // 用网络地址执行一次JSON转对象操作
                  logger.info("********************执行一次网络JSON反序列化操作********************");
                  deserializeResult = streamingDemo.deserializeJSONFromUrl(TEST_JSON_DATA_URL);
                  logger.info("
          网络JSON反序列化结果是个java实例 : 
          {}", deserializeResult);
          
                  ObjectMapper a;
              }
          }
          

          3. 上述代码可见JsonParser负责将JSON解析成对象的变量值，核心是循环处理JSON中的所有内容；
          4. JsonGenerator负责将对象的变量写入JSON的各个属性，这里是开发者自行决定要处理哪些字段；
          5. 不论是JsonParser还是JsonGenerator，大家都可以感觉到工作量很大，需要开发者自己动手实现对象和JSON字段的关系映射，实际应用中不需要咱们这样辛苦的编码，jackson的另外两个库(annonation的databind)已经帮我们完成了大量工作，上述代码只是揭示最基础的jackson执行原理；
          6. 执行StreamingDemo类，得到结果如下，序列化和反序列化都成功了：

          

          • 以上就是jackson-core的基本功能，咱们了解了jackson最底层的工作原理，接下来的文章会继续实践更多操作；

          欢迎关注公众号：程序员欣宸

      • jackson学习之三：常用API操作
      • jackson学习之四：WRAP_ROOT_VALUE（root对象）
      • jackson学习之五：JsonInclude注解
      • jackson学习之六：常用类注解
      • jackson学习之七：常用Field注解
      • jackson学习之八：常用方法注解
      • jackson学习之九：springboot整合(配置文件)
      • jackson学习之十(终篇)：springboot整合(配置类)

jackson学习之四：WRAP_ROOT_VALUE（root对象）

 

欢迎访问我的GitHub

https://github.com/zq2599/blog_demos

内容：所有原创文章分类汇总及配套源码，涉及Java、Docker、Kubernetes、DevOPS等；

系列文章汇总

• jackson学习之一：基本信息
• jackson学习之二：jackson-core
• jackson学习之三：常用API操作
• jackson学习之四：WRAP_ROOT_VALUE（root对象）
• jackson学习之五：JsonInclude注解
• jackson学习之六：常用类注解
• jackson学习之七：常用Field注解
• jackson学习之八：常用方法注解
• jackson学习之九：springboot整合(配置文件)
• jackson学习之十(终篇)：springboot整合(配置类)

本篇概览

本文是《jackson学习》系列的第四篇，前面学习了常用API，可以执行最基本的序列化和反序列化操作，接下来要学习的就是jackson强大的注解能力，本篇要学的是root对象特性，主要内容如下：

1. 关于root对象
2. 测试用的POJO类
3. 序列化实战
4. 反序列化实战

关于root对象（WRAP_ROOT_VALUE）

1. 对于只有id和name两个字段的POJO实例来说，正常的序列化结果如下：

{
  "id" : 1,
  "name" : "book"
}

2. jackson在序列化时，可以在上述json外面再包裹一层，官方叫做WRAP_ROOT_VALUE，本文中叫做root对象，如下所示，整个json的只有一个键值对，key是aaabbbccc，value内部才是POJO实例的id和name字段的值：

{
  "aaabbbccc" : {
    "id" : 2,
    "name" : "food"
  }
}

提前小结

root对象特性提前做个小结，这样如果您时间有限，仅看这一节即可：

• 先看序列化场景：

1. 执行下面代码，jackson在序列化时会增加root对象：

mapper.enable(SerializationFeature.WRAP_ROOT_VALUE);

2. root对象的key，默认是实例的类名，如果实例有JsonRootName注解，就是该注解的value值；
3. root对象的value如下所示，相当于不支持root对象时的序列化结果：

{
  "id" : 1,
  "name" : "book"
}

• 再看反序列化场景：

1. 执行下面代码，jackson在反序列化时会先解析root对象：

mapper.enable(DeserializationFeature.UNWRAP_ROOT_VALUE);

2. root对象的key，默认是实例的类名，如果实例有JsonRootName注解，就是该注解的value值；
3. root对象的value如下所示，相当于不支持root对象时用来反序列化的json字符串：

{
  "id" : 1,
  "name" : "book"
}

准备两个POJO类

用对比的方式可以更清楚了解JsonRootName的作用，接下来的学习咱们准备两个POJO类，一个没有JsonRootName注解，另一个有JsonRootName注解：

1. 名为Order1.java的，没有JsonRootName注解：

public class Order1 {
    private int id;
    private String name;
	// 省去get、set、toString方法
	...
}

2. 名为Order2.java的，有JsonRootName注解，value值为aaabbbccc：

import com.fasterxml.jackson.annotation.JsonRootName;

@JsonRootName(value = "aaabbbccc")
public class Order2 {
	private int id;
    private String name;
	// 省去get、set、toString方法
	...
}

• 可见Order1和Order2的代码是一致的，唯一的不同是Order2带有注解JsonRootName；

序列化

1. 需要设置WRAP_ROOT_VALUE属性，jackson才会支持root对象，JsonRootName注解才会发挥作用，设置代码如下：

mapper.enable(SerializationFeature.WRAP_ROOT_VALUE);

2. 写一段代码，在不开启WRAP_ROOT_VALUE属性的时候执行序列化，再开启WRAP_ROOT_VALUE属性执行序列化，对比试试：

public static void main(String[] args) throws Exception {
        // 实例化Order1和Order2
        Order1 order1 = new Order1();
        order1. setId(1);
        order1.setName("book");

        Order2 order2 = new Order2();
        order2. setId(2);
        order2.setName("food");

        // 没有开启WRAP_ROOT_VALUE的时候
        logger.info("没有开启WRAP_ROOT_VALUE
");
        ObjectMapper mapper1 = new ObjectMapper();
        // 美化输出
        mapper1.enable(SerializationFeature.INDENT_OUTPUT);

        logger.info("没有JsonRootName注解类，序列化结果：

{}

", mapper1.writeValueAsString(order1));
        logger.info("有JsonRootName注解的类，序列化结果：

{}



", mapper1.writeValueAsString(order2));

        // 开启了WRAP_ROOT_VALUE的时候
        logger.info("开启了WRAP_ROOT_VALUE
");
        ObjectMapper mapper2 = new ObjectMapper();
        // 美化输出
        mapper2.enable(SerializationFeature.INDENT_OUTPUT);
        // 序列化的时候支持JsonRootName注解
        mapper2.enable(SerializationFeature.WRAP_ROOT_VALUE);

        logger.info("没有JsonRootName注解类，序列化结果：

{}

", mapper2.writeValueAsString(order1));
        logger.info("有JsonRootName注解的类，序列化结果：

{}", mapper2.writeValueAsString(order2));
    }

3. 执行结果如下，JsonRootName在序列化时的作用一目了然：指定了root对象的key：

反序列化（默认设置）

1. 在没有做任何设置的时候，下面这个字符串用来反序列化成Order2对象，会成功吗？

{
  "id" : 2,
  "name" : "food"
}

2. 试了下是可以的：

3. 那下面这个字符串能反序列化成Order2对象吗？

{
  "aaabbbccc" : {
    "id" : 2,
    "name" : "food"
  }
}

4. 代码和结果如下图所示，反序列化时jackson并不认识aaabbbccc这个key，因为jackson此时并不支持root对象：

• 小结：默认情况下，反序列化时json字符串不能有root对象；

反序列化（开启UNWRAP_ROOT_VALUE属性）

1. 如果开启了UNWRAP_ROOT_VALUE属性，用于反序列化的json字符串就必须要有root对象了，开启UNWRAP_ROOT_VALUE属性的代码如下：

mapper.enable(DeserializationFeature.UNWRAP_ROOT_VALUE);

2. 代码和结果如下图，可见带有root对象的json字符串，可以反序列化成功，root对象的key就是JsonRootName注解的value属性：

3. 值得注意的是，上述json字符串中，root对象的key为aaabbbccc，这和Order2的JsonRootName注解的value值是一致的，如果不一致就会反序列化失败，如下图：

• 至此，jackson的WRAP_ROOT_VALUE特性就学习完成了，在web开发时这是个很常用的功能，用于在最外面包裹一层，以便整体上添加额外的内容，希望能给您带来参考；

你不孤单，欣宸原创一路相伴

1. Java系列
2. Spring系列
3. Docker系列
4. kubernetes系列
5. 数据库+中间件系列
6. DevOps系列

 

 

jackson学习之二：jackson-core

 

欢迎访问我的GitHub

https://github.com/zq2599/blog_demos

内容：所有原创文章分类汇总及配套源码，涉及Java、Docker、Kubernetes、DevOPS等；

系列文章汇总

• jackson学习之一：基本信息
• jackson学习之二：jackson-core
• jackson学习之三：常用API操作
• jackson学习之四：WRAP_ROOT_VALUE（root对象）
• jackson学习之五：JsonInclude注解
• jackson学习之六：常用类注解
• jackson学习之七：常用Field注解
• jackson学习之八：常用方法注解
• jackson学习之九：springboot整合(配置文件)
• jackson学习之十(终篇)：springboot整合(配置类)

关于jackson-core

1. 本文主要内容是jackson-core库，这是个低阶API库，提供流式解析工具JsonParser，流式生成工具JsonGenerator；
2. 在日常的序列化和反序列化处理中，最常用的是jackson-annotations和jackson-databind，而jackson-core由于它提供的API过于基础，我们大多数情况下是用不上的；
3. 尽管jackson-databind负责序列化和反序列化处理，但它的底层实现是调用了jackson-core的API；
4. 本着万丈高楼平地起的原则，本文咱们通过实战了解神秘的jackson-core，了解整个jackson的序列化和反序列化基本原理；

源码下载

1. 如果您不想编码，可以在GitHub下载所有源码，地址和链接信息如下表所示(https://github.com/zq2599/blog_demos)：

名称	链接	备注
项目主页	https://github.com/zq2599/blog_demos	该项目在GitHub上的主页
git仓库地址(https)	https://github.com/zq2599/blog_demos.git	该项目源码的仓库地址，https协议
git仓库地址(ssh)	git@github.com:zq2599/blog_demos.git	该项目源码的仓库地址，ssh协议

2. 这个git项目中有多个文件夹，本章的应用在jacksondemo文件夹下，如下图红框所示：

创建父子工程

创建名为jacksondemo的maven工程，这是个父子结构的工程，其pom.xml内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <groupId>com.bolingcavalry</groupId>
    <artifactId>jacksondemo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>
    <modules>
        <module>core</module>
        <module>beans</module>
        <module>databind</module>
    </modules>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>com.fasterxml.jackson.core</groupId>
                <artifactId>jackson-databind</artifactId>
                <version>2.11.0</version>
                <scope>compile</scope>
            </dependency>
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-log4j12</artifactId>
                <version>1.7.25</version>
                <scope>compile</scope>
            </dependency>
            <dependency>
                <groupId>commons-io</groupId>
                <artifactId>commons-io</artifactId>
                <version>2.7</version>
                <scope>compile</scope>
            </dependency>
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-lang3</artifactId>
                <version>3.10</version>
                <scope>compile</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

新增子工程beans

1. 在父工程jscksondemo下新增名为beans的子工程，这里面是一些常量和Pojo类；
2. 增加定义常量的类Constant.java：

package com.bolingcavalry.jacksondemo.beans;

public class Constant {
    /**
     * 该字符串的值是个网络地址，该地址对应的内容是个JSON
     */
    public final static String TEST_JSON_DATA_URL = "https://raw.githubusercontent.com/zq2599/blog_demos/master/files/twitteer_message.json";
    /**
     * 用来验证反序列化的JSON字符串
     */
    public final static String TEST_JSON_STR = "{
" +
            "  "id":1125687077,
" +
            "  "text":"@stroughtonsmith You need to add a \"Favourites\" tab to TC/iPhone. Like what TwitterFon did. I can't WAIT for your Twitter App!! :) Any ETA?",
" +
            "  "fromUserId":855523, 
" +
            "  "toUserId":815309,
" +
            "  "languageCode":"en"
" +
            "}";
    /**
     * 用来验证序列化的TwitterEntry实例
     */
    public final static TwitterEntry TEST_OBJECT = new TwitterEntry();
    /**
     * 准备好TEST_OBJECT对象的各个参数
     */
    static {
        TEST_OBJECT.setId(123456L);
        TEST_OBJECT.setFromUserId(101);
        TEST_OBJECT.setToUserId(102);
        TEST_OBJECT.setText("this is a message for serializer test");
        TEST_OBJECT.setLanguageCode("zh");
    }}

3. 增加一个Pojo，对应的是一条推特消息：

package com.bolingcavalry.jacksondemo.beans;
/**
 * @Description: 推特消息bean
 * @author: willzhao E-mail: zq2599@gmail.com
 * @date: 2020/7/4 16:24
 */
public class TwitterEntry {
    /**
     * 推特消息id
     */
    long id;
    /**
     * 消息内容
     */
    String text;    /**
     * 消息创建者
     */
    int fromUserId;
    /**
     * 消息接收者
     */
    int toUserId;
    /**
     * 语言类型
     */
    String languageCode;    public long getId() {
        return id;
    }    public void setId(long id) {
        this.id = id;
    }    public String getText() {
        return text;
    }    public void setText(String text) {
        this.text = text;
    }    public int getFromUserId() {
        return fromUserId;
    }    public void setFromUserId(int fromUserId) {
        this.fromUserId = fromUserId;
    }    public int getToUserId() {
        return toUserId;
    }    public void setToUserId(int toUserId) {
        this.toUserId = toUserId;
    }    public String getLanguageCode() {
        return languageCode;
    }    public void setLanguageCode(String languageCode) {
        this.languageCode = languageCode;
    }    public TwitterEntry() {
    }    public String toString() {
        return "[Tweet, id: "+id+", text='"+text+"', from: "+fromUserId+", to: "+toUserId+", lang: "+languageCode+"]";
    }}

4. 以上就是准备工作了，接下来开始实战jackson-core；

JsonFactory线程安全吗?

1. JsonFactory是否是线程安全的，这是编码前要弄清楚的问题，因为JsonParser和JsonGenerator的创建都离不开JsonFactory；
2. 如下图红框所示，jackson官方文档中明确指出JsonFactory是线程安全的，可以放心的作为全局变量给多线程同时使用：

3. 官方文档地址：http://fasterxml.github.io/jackson-core/javadoc/2.11/

jackson-core实战

1. 新建子工程core，pom.xml如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>jacksondemo</artifactId>
        <groupId>com.bolingcavalry</groupId>
        <version>1.0-SNAPSHOT</version>
        <relativePath>../pom.xml</relativePath>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.bolingcavalry</groupId>
    <artifactId>core</artifactId>
    <name>core</name>
    <description>Demo project for jackson core use</description>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
    <dependencies>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
        </dependency>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
        </dependency>
        <dependency>
            <groupId>com.bolingcavalry</groupId>
            <artifactId>beans</artifactId>
            <version>${project.version}</version>
        </dependency>
    </dependencies>
</project>

2. 新建StreamingDemo类，这里面是调用jackson-core的API进行序列化和反序列化的所有demo，如下：

package com.bolingcavalry.jacksondemo.core;

import com.bolingcavalry.jacksondemo.beans.TwitterEntry;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.net.URL;

/**
 * @Description: jackson低阶方法的使用
 * @author: willzhao E-mail: zq2599@gmail.com
 * @date: 2020/7/4 15:50
 */
public class StreamingDemo {

    private static final Logger logger = LoggerFactory.getLogger(StreamingDemo.class);

    JsonFactory jsonFactory = new JsonFactory();

    /**
     * 该字符串的值是个网络地址，该地址对应的内容是个JSON
     */
    final static String TEST_JSON_DATA_URL = "https://raw.githubusercontent.com/zq2599/blog_demos/master/files/twitteer_message.json";

    /**
     * 用来验证反序列化的JSON字符串
     */
    final static String TEST_JSON_STR = "{
" +
            "  "id":1125687077,
" +
            "  "text":"@stroughtonsmith You need to add a \"Favourites\" tab to TC/iPhone. Like what TwitterFon did. I can't WAIT for your Twitter App!! :) Any ETA?",
" +
            "  "fromUserId":855523, 
" +
            "  "toUserId":815309,
" +
            "  "languageCode":"en"
" +
            "}";

    /**
     * 用来验证序列化的TwitterEntry实例
     */
    final static TwitterEntry TEST_OBJECT = new TwitterEntry();

    /**
     * 准备好TEST_OBJECT对象的各个参数
     */
    static {
        TEST_OBJECT.setId(123456L);
        TEST_OBJECT.setFromUserId(101);
        TEST_OBJECT.setToUserId(102);
        TEST_OBJECT.setText("this is a message for serializer test");
        TEST_OBJECT.setLanguageCode("zh");
    }


    /**
     * 反序列化测试(JSON -> Object)，入参是JSON字符串
     * @param json JSON字符串
     * @return
     * @throws IOException
     */
    public TwitterEntry deserializeJSONStr(String json) throws IOException {

        JsonParser jsonParser = jsonFactory.createParser(json);

        if (jsonParser.nextToken() != JsonToken.START_OBJECT) {
            jsonParser.close();
            logger.error("起始位置没有大括号");
            throw new IOException("起始位置没有大括号");
        }

        TwitterEntry result = new TwitterEntry();

        try {
            // Iterate over object fields:
            while (jsonParser.nextToken() != JsonToken.END_OBJECT) {

                String fieldName = jsonParser.getCurrentName();

                logger.info("正在解析字段 [{}]", jsonParser.getCurrentName());

                // 解析下一个
                jsonParser.nextToken();

                switch (fieldName) {
                    case "id":
                        result.setId(jsonParser.getLongValue());
                        break;
                    case "text":
                        result.setText(jsonParser.getText());
                        break;
                    case "fromUserId":
                        result.setFromUserId(jsonParser.getIntValue());
                        break;
                    case "toUserId":
                        result.setToUserId(jsonParser.getIntValue());
                        break;
                    case "languageCode":
                        result.setLanguageCode(jsonParser.getText());
                        break;
                    default:
                        logger.error("未知字段 '" + fieldName + "'");
                        throw new IOException("未知字段 '" + fieldName + "'");
                }
            }
        } catch (IOException e) {
            logger.error("反序列化出现异常 :", e);
        } finally {
            jsonParser.close(); // important to close both parser and underlying File reader
        }

        return result;
    }

    /**
     * 反序列化测试(JSON -> Object)，入参是JSON字符串
     * @param url JSON字符串的网络地址
     * @return
     * @throws IOException
     */
    public TwitterEntry deserializeJSONFromUrl(String url) throws IOException {
        // 从网络上取得JSON字符串
        String json = IOUtils.toString(new URL(TEST_JSON_DATA_URL), JsonEncoding.UTF8.name());

        logger.info("从网络取得JSON数据 :
{}", json);

        if(StringUtils.isNotBlank(json)) {
            return deserializeJSONStr(json);
        } else {
            logger.error("从网络获取JSON数据失败");
            return null;
        }
    }


    /**
     * 序列化测试(Object -> JSON)
     * @param twitterEntry
     * @return 由对象序列化得到的JSON字符串
     */
    public String serialize(TwitterEntry twitterEntry) throws IOException{
        String rlt = null;
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        JsonGenerator jsonGenerator = jsonFactory.createGenerator(byteArrayOutputStream, JsonEncoding.UTF8);

        try {
            jsonGenerator.useDefaultPrettyPrinter();

            jsonGenerator.writeStartObject();
            jsonGenerator.writeNumberField("id", twitterEntry.getId());
            jsonGenerator.writeStringField("text", twitterEntry.getText());
            jsonGenerator.writeNumberField("fromUserId", twitterEntry.getFromUserId());
            jsonGenerator.writeNumberField("toUserId", twitterEntry.getToUserId());
            jsonGenerator.writeStringField("languageCode", twitterEntry.getLanguageCode());
            jsonGenerator.writeEndObject();
        } catch (IOException e) {
            logger.error("序列化出现异常 :", e);
        } finally {
            jsonGenerator.close();
        }

        // 一定要在
        rlt = byteArrayOutputStream.toString();

        return rlt;
    }


    public static void main(String[] args) throws Exception {

        StreamingDemo streamingDemo = new StreamingDemo();

        // 执行一次对象转JSON操作
        logger.info("********************执行一次对象转JSON操作********************");
        String serializeResult = streamingDemo.serialize(TEST_OBJECT);
        logger.info("序列化结果是JSON字符串 : 
{}

", serializeResult);

        // 用本地字符串执行一次JSON转对象操作
        logger.info("********************执行一次本地JSON反序列化操作********************");
        TwitterEntry deserializeResult = streamingDemo.deserializeJSONStr(TEST_JSON_STR);
        logger.info("
本地JSON反序列化结果是个java实例 : 
{}

", deserializeResult);

        // 用网络地址执行一次JSON转对象操作
        logger.info("********************执行一次网络JSON反序列化操作********************");
        deserializeResult = streamingDemo.deserializeJSONFromUrl(TEST_JSON_DATA_URL);
        logger.info("
网络JSON反序列化结果是个java实例 : 
{}", deserializeResult);

        ObjectMapper a;
    }
}

3. 上述代码可见JsonParser负责将JSON解析成对象的变量值，核心是循环处理JSON中的所有内容；
4. JsonGenerator负责将对象的变量写入JSON的各个属性，这里是开发者自行决定要处理哪些字段；
5. 不论是JsonParser还是JsonGenerator，大家都可以感觉到工作量很大，需要开发者自己动手实现对象和JSON字段的关系映射，实际应用中不需要咱们这样辛苦的编码，jackson的另外两个库(annonation的databind)已经帮我们完成了大量工作，上述代码只是揭示最基础的jackson执行原理；
6. 执行StreamingDemo类，得到结果如下，序列化和反序列化都成功了：

• 以上就是jackson-core的基本功能，咱们了解了jackson最底层的工作原理，接下来的文章会继续实践更多操作；

欢迎关注公众号：程序员欣宸