JSON、Fastjson、Jackson基本用法

在工地上写代码

已于 2022-06-22 23:32:14 修改

阅读量718

点赞数

分类专栏： Json 文章标签： json java

于 2022-06-21 23:35:37 首次发布

本文链接：https://blog.csdn.net/weixin_43972609/article/details/125400452

版权

Json 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

一、Json

什么是Json

List itemJSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式，目前使用特别广泛。
List item采用完全独立于编程语言的文本格式来存储和表示数据。
List item简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。
List item易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。
在 JavaScript 语言中，一切都是对象。因此，任何JavaScript 支持的类型都可以通过 JSON 来表示，例如字符串、数字、对象、数组等。看看他的要求和语法格式：
List item对象表示为键值对，数据由逗号分隔
List item花括号保存对象
List item方括号保存数组

JSON 键值对是用来保存 JavaScript 对象的一种方式，和 JavaScript 对象的写法也大同小异，键/值对组合中的键名写在前面并用双引号 “” 包裹，使用冒号 : 分隔，然后紧接着值：

{"name": "QinJiang"}
{"age": "3"}
{"sex": "男"}

很多人搞不清楚 JSON 和 JavaScript 对象的关系，甚至连谁是谁都不清楚。其实，可以这么理解：JSON 是 JavaScript 对象的字符串表示法，它使用文本表示一个 JS 对象的信息，本质是一个字符串。

var obj = {a: 'Hello', b: 'World'}; //这是一个对象，注意键名也是可以使用引号包裹的
var json = '{"a": "Hello", "b": "World"}'; //这是一个 JSON 字符串，本质是一个字符串

JSON 和 JavaScript 对象互转
要实现从JSON字符串转换为JavaScript 对象，使用 JSON.parse() 方法：

var obj = JSON.parse('{"a": "Hello", "b": "World"}');
//结果是 {a: 'Hello', b: 'World'}

要实现从JavaScript 对象转换为JSON字符串，使用 JSON.stringify() 方法：

var json = JSON.stringify({a: 'Hello', b: 'World'});
//结果是 '{"a": "Hello", "b": "World"}'

二、Fastjson

1、Fastjson 简介

Fastjson 是一个 Java 库，可以将 Java 对象转换为 JSON 格式，当然它也可以将 JSON 字符串转换为 Java 对象。
Fastjson 可以操作任何 Java 对象，即使是一些预先存在的没有源码的对象。
Fastjson 源码地址：https://github.com/alibaba/fastjson
Fastjson 中文 Wiki：https://github.com/alibaba/fastjson/wiki/Quick-Start-CN

2、Fastjson 特性

提供服务器端、安卓客户端两种解析工具，性能表现较好。
提供了 toJSONString() 和 parseObject() 方法来将 Java 对象与 JSON 相互转换。调用toJSONString方法即可将对象转换成 JSON 字符串，parseObject 方法则反过来将 JSON 字符串转换成对象。
允许转换预先存在的无法修改的对象（只有class、无源代码）。
Java泛型的广泛支持。
允许对象的自定义表示、允许自定义序列化类。
支持任意复杂对象（具有深厚的继承层次和广泛使用的泛型类型）。

3、使用

A、配置 maven 依赖:

<dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.83</version>
</dependency>

B、Java对象转 JSON字符串、JSON字符串转 Java对象、Map转JSON、map转string、JSON转Map

User类
package com.example.json.Demo.entity;
public class User {
    private String name;
    private int age;
    private String sex;
    public User(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
}

package com.example.json.Demo.controller;
import com.alibaba.fastjson.JSON;
import com.example.json.Demo.entity.User;
import java.util.ArrayList;
import java.util.List;
public class FastJsonController {
        public static void main(String[] args){
        User user1=new User("秦疆1号",3,"男");
        User user2=new User("秦疆2号",3,"男1");
        User user3=new User("秦疆3号",3,"男2");
        User user4=new User("秦疆4号",3,"男3");
        List<User> list = new ArrayList<User>();
        list.add(user1);
        list.add(user2);
        list.add(user3);
        list.add(user4);
//        *******Java对象 转 JSON字符串*******
        String str1 = JSON.toJSONString(user1);
        System.out.println(str1);
        String str2 = JSON.toJSONString(list);
        System.out.println(str2);
    //****** JSON字符串 转 Java对象*******
        User jsonUser = JSON.parseObject(str1,User.class);
        System.out.println(jsonUser);
   //          ****** Map转JSON*******
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("a", "a");
        map.put("b", "123");
        JSONObject json = new JSONObject(map);
        System.out.println(json);
//            ****** map转string*******
        Map<String, Object> map = new HashMap<>();
        map.put("a", "b");
        String str = JSONObject.toJSONString(map);
        System.out.println(str);
//            ****** JSON转Map*******
        JSONObject json = new JSONObject();
        json.put("ccc", "321");
        json.put("bbb", "123");
        Map<String, Object> map = (Map<String, Object>)json;
        System.out.println(map);
    }
    }

C、创建 JSON 对象
创建 JSON 对象非常简单，只需使用 JSONObject（fastJson提供的json对象）和 JSONArray（fastJson提供json数组对象）对象即可。
我们可以把JSONObject当成一个Map<String,Object> 来看，只是JSONObject提供了更为丰富便捷的方法，方便我们对于对象属性的操作。
同样我们可以把 JSONArray 当做一个 List，可以把 JSONArray 看成 JSONObject 对象的一个集合。

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;

public class FastJsonController {
        public static void main(String[] args){
		JSONArray jsonArray = new JSONArray();
        for (int i = 0; i < 2; i++) {
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("age", 10);
            jsonObject.put("name", "Doe " + i);
            jsonObject.put("Date", "2016/12/12 12:12:12");
            jsonArray.add(jsonObject);
        }
        String jsonOutput = jsonArray.toJSONString();
        System.out.println(jsonOutput);
}}

结果：

[{"name":"Doe 0","age":10,"Date":"2016/12/12 12:12:12"},{"name":"Doe 1","age":10,"Date":"2016/12/12 12:12:12"}]

D、fastJSON，使用TypeReference处理复杂的泛型对象

解析JSON, 并将其转换为对应的数据结构。
例如，简单对象，或者复杂的泛型对象
普通对象直接转换：

A a = JSON.parseObject(str, A.class);

如果是Map带有泛型的对象，直接转换则格式不正确

// 如果需要Map<String, String>
Map a = JSON.parseObject(str, Map.class)
// 结果不是想要的格式

使用 TypeReference

String resultJson= HttpUtil.postGeneralUrl(apiUrl, "application/json",jsonString,"utf-8");
Map resultMap = JSON.parseObject(resultJson, new TypeReference<Map<String, String>>() {});

三、Jackson

1、简介

Jackson 是当前用的比较广泛的，用来序列化和反序列化 json 的 Java 的开源框架。
Jackson 的 1.x 版本的包名是 org.codehaus.jackson ，
当升级到 2.x 版本时，包名变为 com.fasterxml.jackson。

Jackson 的核心模块由三部分组成。
jackson-core，核心包，提供基于"流模式"解析的相关 API，它包括 JsonPaser 和 JsonGenerator。 Jackson 内部实现正是通过高性能的流模式API 的 JsonGenerator 和 JsonParser 来生成和解析 json；
jackson-annotations，注解包，提供标准注解功能；
jackson-databind ，数据绑定包，提供基于"对象绑定" 解析的相关 API （ ObjectMapper ）和"树模型" 解析的相关 API （JsonNode）；基于"对象绑定" 解析的 API 和"树模型"解析的 API 依赖基于"流模式"解析的 API。

2、使用

使用Maven构建项目，需要添加依赖：

<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-core</artifactId>
  <version>2.9.6</version>
</dependency>
<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-annotations</artifactId>
  <version>2.9.6</version>
</dependency>
<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.9.6</version>
</dependency>

jackson-databind 依赖 jackson-core 和 jackson-annotations，所以可以只地添加jackson-databind依赖，jackson-core 和 jackson-annotations 也随之添加到 Java 项目工程中。

<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.9.6</version>
</dependency>

Jackson 最常用的 API 就是基于"对象绑定" 的 ObjectMapper：

ObjectMapper可以从字符串，流或文件中解析JSON，并创建表示已解析的JSON的Java对象。将JSON解析为Java对象也称为从JSON反序列化Java对象。

ObjectMapper也可以从Java对象创建JSON。从Java对象生成JSON也称为将Java对象序列化为JSON。

Object映射器可以将JSON解析为自定义的类的对象，也可以解析置JSON树模型的对象。

之所以称为ObjectMapper是因为它将JSON映射到Java对象（反序列化），或者将Java对象映射到JSON（序列化）

User类
package com.example.json.Demo.entity;
public class User {
    private String name;
    private int age;
    private String sex;
    public User() {}  //必须加
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }
    public User(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
}

jackson的反序列化需要无参构造函数，如果没有会报错：
在这里插入图片描述
A、JSON字符串转 Java对象

package com.example.json.Demo.controller;
import com.example.json.Demo.entity.User;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;
public class JacksonController {
    public static void main(String[] args) {
        try {
        	//创建一个jackson的对象映射器，用来解析数据
            ObjectMapper mapper = new ObjectMapper();
            String jsonString = "{\"name\":\"李四\", \"age\":21,\"sex\":\"男\"}";
            User student = mapper.readValue(jsonString,User.class);
            System.out.println(student.toString());
        } catch (IOException e) {
            e.printStackTrace();
        }
  }
}

结果：

User{name='李四', age=21, sex='男'}

B、Java对象转Json字符串

package com.example.json.Demo.controller;
import com.example.json.Demo.entity.User;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;
public class JacksonController {
    public static void main(String[] args) {
        try {
            ObjectMapper mapper1 = new ObjectMapper();
            User user = new User("王五",22,"男");
            String str1 = mapper1.writeValueAsString(user);
            System.out.println(str1);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}