jackson学习之二：jackson-core

最新推荐文章于 2024-08-08 07:54:46 发布
最新推荐文章于 2024-08-08 07:54:46 发布
阅读量8.7k 收藏 14
点赞数 5
分类专栏： java服务端 文章标签： jackson java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/boling_cavalry/article/details/108571629
版权

欢迎访问我的GitHub

这里分类和汇总了欣宸的全部原创(含配套源码)：https://github.com/zq2599/blog_demos

系列文章汇总

关于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协议
  1. 这个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 = "{\n" +
            "  \"id\":1125687077,\n" +
            "  \"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?\",\n" +
            "  \"fromUserId\":855523, \n" +
            "  \"toUserId\":815309,\n" +
            "  \"languageCode\":\"en\"\n" +
            "}";
    /**
     * 用来验证序列化的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");
    }}
  1. 增加一个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+"]";
    }}
  1. 以上就是准备工作了，接下来开始实战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>
  1. 新建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 = "{\n" +
            "  \"id\":1125687077,\n" +
            "  \"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?\",\n" +
            "  \"fromUserId\":855523, \n" +
            "  \"toUserId\":815309,\n" +
            "  \"languageCode\":\"en\"\n" +
            "}";

    /**
     * 用来验证序列化的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数据 :\n{}", 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字符串 : \n{}\n\n", serializeResult);

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

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

        ObjectMapper a;
    }
}
  1. 上述代码可见JsonParser负责将JSON解析成对象的变量值，核心是循环处理JSON中的所有内容；
  2. JsonGenerator负责将对象的变量写入JSON的各个属性，这里是开发者自行决定要处理哪些字段；
  3. 不论是JsonParser还是JsonGenerator，大家都可以感觉到工作量很大，需要开发者自己动手实现对象和JSON字段的关系映射，实际应用中不需要咱们这样辛苦的编码，jackson的另外两个库(annonation的databind)已经帮我们完成了大量工作，上述代码只是揭示最基础的jackson执行原理；
  4. 执行StreamingDemo类，得到结果如下，序列化和反序列化都成功了：
    在这里插入图片描述
  • 以上就是jackson-core的基本功能，咱们了解了jackson最底层的工作原理，接下来的文章会继续实践更多操作；

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

微信搜索「程序员欣宸」，我是欣宸，期待与您一同畅游Java世界…

程序员欣宸
关注
专栏目录
jackson学习之二：jackson-core(1)，java基础面试题大全及答案
2401_84437691的博客
04-18 970
在日常的序列化和反序列化处理中，最常用的是jackson-annotations和jackson-databind，而jackson-core由于它提供的API过于基础，我们大多数情况下是用不上的；| git仓库地址(https) | https://github.com/zq2599/blog_demos.git | 该项目源码的仓库地址，https协议 |本着万丈高楼平地起的原则，本文咱们通过实战了解神秘的jackson-core，了解整个jackson的序列化和反序列化基本原理；
jackson-core-2.10.0.zip
07-10
通过该类库可以方便的将实体对象转换成json，可以是实体列表，单个实体。内包含多个文件包含文档该版本目前还是比较新的。
Jackson-Core 开源项目使用教程
最新发布
gitblog_00826的博客
08-08 942
Jackson-Core 开源项目使用教程 jackson-coreCore part of Jackson that defines Streaming API as well as basic shared abstractions项目地址:https://gitcode.com/gh_mirrors/ja/jackson-core 1. 项目的目录结构及介绍 Jackson-Core 项目...
jackson-core-2.9.6.jar
08-29
jackson-core-2.9.6.jar是Jackson的核心支持包，是该类库的主要部分。
Jackson之jackson-core
热门推荐
明月阁
12-09 1万+
原文链接：http://www.dubby.cn/detail.html?id=9069我们在这里使用jackson-core提供的JsonParser和JsonGenerator来实现基本的序列化和反序列化。1.数据和实体类我们先定义出JSON字符串:{ "id":123456789, "text":"我是杨正，我在http://www.duby.cn", "fromUserId":1
jackson-core.jar
12-31
jackson-core.jar
jackson-core-2.9.3.jar
12-11
jackson-core-2.9.3.jar jackson 2.9.3 java处理json MD5:b3661b78c6f6efebf9b4714fbbc1270b 大小:313 KB jacksonAPI文档下载地址: http://download.csdn.net/download/tan3739/10153940 jackson源码下载地址: http://download.csdn.net/download/tan3739/10153950
jackson -core -2.8.0 .jar json jar包合集
11-20
jackson -core -2.8.0 .jar json jar包合集 jackson 2.8.0 java处理json需要的jar包 内包含文件： jackson-core-2.8.0.jar jackson-core-2.8.0-sources.jar jackson-core-2.8.0-javadoc.jar
jackson学习之二：jackson-core，2024年最新跨越速运java面试经历
2401_84437691的博客
04-18 992
切莫死记硬背，小心面试官直接让你出门右拐1000道互联网Java面试题：
com.fasterxml.jackson.core.JsonParseException: Invalid UTF-8 start byte 0x94 解决办法 feign加拦截器
Java持续实践
07-09 568
原因是目标feign接口的服务有一个拦截器, 会去请求头中获取用户名, 而我的请求没有加上这个请求头, 导致被拦截器拦截, 直接返回的中文字符串, 不是json ,从而报错.但是用postman单独去请求目标的feign的接口的时候, 是正常返回的json数据. 说明请求的feign接口是没有问题的.加上此拦截器后, 再次请求feign接口 , 打印的日志feign接口返回的是一个中文的报错信息 ,而不是json , 因此报了。请求feign接口的时候, 把请求头。加上用户名, 即可解决。
jackson-core-2.5.0.jar
10-03
Spring4框架中需要使用的 jackson-core-2.5.0.jar 核心包
jackson-core-jackson-core-2.9.3
07-31
jackson-core-2.9.3.jar,json处理的相关工具,可下后生成jar包
jackson-core 1.8.5 LGPL版
08-25
Jackson 是一个 Java 用来处理 JSON 格式数据的类库，性能非常好.
jackson-core-2.9.9.jar
10-09
java开发json依赖包，jackson-core-2.9.9.jar
jackson-core所需的三个包；jackson-databind.jar,jackson-annotations.jar,jackson-core.jar
05-11
总结来说，Jackson是Java处理JSON的必备工具，其核心组件包括jackson-core、jackson-databind和jackson-annotations。在Spring MVC应用中，要正确处理JSON数据，必须确保Content-Type设置正确，并且服务器配置了合适...
jackson-core-2.6.7-API文档-中文版.zip
07-06
赠送jar包：jackson-core-2.6.7.jar； 赠送原API文档：jackson-core-2.6.7-javadoc.jar； 赠送源代码：jackson-core-2.6.7-sources.jar； 赠送Maven依赖信息文件：jackson-core-2.6.7.pom； 包含翻译后的API文档：...
jackson-core-2.11.4-API文档-中文版.zip
07-05
赠送jar包：jackson-core-2.11.4.jar； 赠送原API文档：jackson-core-2.11.4-javadoc.jar； 赠送源代码：jackson-core-2.11.4-sources.jar； 赠送Maven依赖信息文件：jackson-core-2.11.4.pom； 包含翻译后的API文档...
如何解决 提供可传递的易受攻击的依赖项 maven:com.fasterxml.jackson.core:jackson-databind:2.13.3 CVE-2022-42003 7.5 Deserialization of Untrusted Data vulnerability pending CVSS allocation CVE-2022-42004 7.5 Deserialization of Untrusted Data vulnerability pending CVSS allocation
06-10
要解决提供可传递的易受攻击的依赖项 com.fasterxml.jackson.core:jackson-databind:2.13.3 CVE-2022-42003 和 CVE-2022-42004 的漏洞，可以采取以下措施： 1. 更新依赖项：查看项目的依赖关系图，找到依赖于 com.fasterxml.jackson.core:jackson-databind 的组件，并尽可能升级到不受漏洞影响的版本。例如，可以将 jackson-databind 升级到 2.13.4 版本或更高版本，该版本已修复了 CVE-2022-42003 和 CVE-2022-42004 的漏洞。 2. 移除依赖项：如果没有必要使用 jackson-databind，可以考虑将其从项目中移除，从而避免潜在的安全风险。 3. 防御措施：如果无法立即更新或移除依赖项，可以采取一些防御措施来降低潜在的攻击风险。例如，可以使用反序列化过滤器或安全的 JSON 序列化/反序列化库来限制反序列化操作，并对输入数据进行有效的验证和过滤。 总之，要解决提供可传递的易受攻击的依赖项的漏洞，需要及时采取措施，确保项目的安全性和稳定性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序员欣宸

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值