语法篇-JSON基础

一、JSON初识

1.1基础认识

JSON是一种轻量级的数据交换格式，它基于JavaScript语言的对象表示法，可以在多种语言之间进行数据交换。JSON的基本数据类型有数值、字符串、布尔值、数组、对象和空值。JSON的格式简洁易读，也易于解析和处理。JSON的标准文件扩展名是.json

采用完全独立于编程语言的文本格式来存储和表示数据。

然而，不是所有的系统都支持使用JSON来交换数据。数据交换格式有很多，如前面提到的XML (extensible markup language,可扩展性标记语言)，可能早在JSON被发明前就已
经在应用了。有许多系统可以并还在使用像XML这样的格式，或是用表格和分隔符来表示
数据的格式，如逗号分隔值(CSV)。

1.2JSON语法

1.2.1专业术语及概念

●对象表示为键值对,数据由逗号分隔
●花括号保存对象
●方括号保存数组

1.2.2JSON基于JavaScript对象字面量

数据交换格式的核心是数据，所以 JSON中并不会涉及JavaScript对象字面量中的函数。JSON所基于的JavaScript对象字面量单纯指对象字面量及其属性的语法表示。这种属性表示方法也就是通过名称-值对来实现的

1.2.3名称-值对

1.2.4正确的JSON语法

属性名可以包含下划线(_ ) 或数字，但是大多数情况下最好是使用英文字母A-Z或a-z

在JSON中，名称两边的双引号却是必须要加的。

不同于名称，值并不总是需要被双引号包裹。当值是字符串时，必须使用双引号。而在JSON 中，还有数字、布尔值、数组、对象、null 等其他数据类型，这些都不应被双引号包裹。

1.2.5语法验证

网上验证工具

1.2.6JSON文件

JSON这种数据交换格式是可以作为独立的文件存在于文件系统中的。它的文件扩展名非常好记: .json.

1.2.7JSON媒体类型

1.3JSON的数据类型

1.3.1概述

原始数据类型
复合数据类型
枚举数据类型
对象数据类型

1.3.2JSON 中的数据类型包括

对象
字符串
数字
布尔值
null
数组

1.3.3对象数据类型

1.3.4字符串数据类型

举例

1.3.5数字数据类型

1.3.6 布尔数据类型

1.3.7 null类型

1.3.8 数组数据类型

1.3.9总结

1.4JSON和JS的区别

1.5JSON和JS对象互转

   <script>
       'use strict';
       var user = {
           name : '烟雨平生',
           age : 20,
           sex : "男"
       }
       console.log(user);
       var str = JSON.stringify(user);
       console.log(str);
       var obj = JSON.parse(str);
       console.log(obj);
    </script>

二、JSON处理

2.1数据类型

2.2常见解析轮子

2.3JSON主要用途

JSON生成
JSON解析
JSON校验
和Java Bean对象进行互解析
具有一个无参的构造函数
可以包括多个属性，所有属性都是private
每个属性都有相应的Getter/Setter方法、
Java Bean用于封装数据，又可称为POJO(Plain Old Java Object)

2.4JSON和XML比较

2.5基于org.json的解析

2.5.1 配置文件

 <dependency>
            <groupId>org.json</groupId>
            <artifactId>json</artifactId>
            <version>20210307</version>
        </dependency>

2.5.2所用json文件

{
  "books": [
    {
      "author": "J.K. Rowling",
      "title": "Harry Potter and the Sorcerer's Stone",
      "year": "1997",
      "price": 25,
      "category": "Fantasy"
    },
    {
      "author": "George Orwell",
      "title": "1984",
      "year": "1949",
      "price": 15,
      "category": "Dystopian Fiction"
    }
  ]
}

2.5.3辅助类

package org.example;

public class Book {
    private String category;
    private String title;
    private String author;
    private String year;
    private int price;

    public String getCategory() {
        return category;
    }

    public void setCategory(String category) {
        this.category = category;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public String getYear() {
        return year;
    }

    public void setYear(String year) {
        this.year = year;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }
    @Override
    public String toString(){
        return "Book [category=" + category + ", title=" + title + ", author=" + author
                + ", year=" + year + ", price=" + price + "]";
    }
}

package org.example;
import java.util.List;
public class Person {
    private String name;
    private int age;
    private List<Integer> scores;
   public  Person(){

   }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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 List<Integer> getScores() {
        return scores;
    }

    public void setScores(List<Integer> scores) {
        this.scores = scores;
    }
}

2.5.4解析类

package org.example;

import org.json.JSONArray;
import org.json.JSONObject;

import java.io.File;
import java.io.FileReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * 使用 org.json 包来解析 JSON 示例
 * @author Tom
 */
public class OrgJsonTest {
    public static void main(String[] args) {
        testJsonObject();
        System.out.println("=========华丽丽的分割线==============");
        testJsonFile();
    }

    public static void testJsonObject() {
        // 构造对象
        Person p = new Person();
        p.setName("Tom");
        p.setAge(20);
        p.setScores(Arrays.asList(60, 70, 80));

        // 构造 JSONObject 对象
        JSONObject obj = new JSONObject();
        obj.put("name", p.getName());
        obj.put("age", p.getAge());
        obj.put("scores", p.getScores());

        // 输出 JSON 对象内容
        System.out.println(obj);
        System.out.println("name: " + obj.getString("name"));
        System.out.println("age: " + obj.getInt("age"));
        System.out.println("scores: " + obj.getJSONArray("scores"));
    }

    public static void testJsonFile() {
        File file = new File("D:\\workspace-java\\untitled4\\src\\main\\resources\\books.json");
        try (FileReader reader = new FileReader(file)) {
            // 读取文件内容到 Json0bject 对象中
            int fileLen = (int) file.length();
            char[] chars = new char[fileLen];
            reader.read(chars);
            String content = String.valueOf(chars);

            // 解析 JSON 对象
            JSONObject jsonObject = new JSONObject(content);
            JSONArray books = jsonObject.getJSONArray("books");

            List<Book> bookList = new ArrayList<>();
            for (Object book : books) {
                // 获取单个 JSONObject 对象
                JSONObject bookObject = (JSONObject) book;
                Book book1 = new Book();
                book1.setAuthor(bookObject.getString("author"));
                book1.setYear(bookObject.getString("year"));
                book1.setTitle(bookObject.getString("title"));
                book1.setPrice(bookObject.getInt("price"));
                book1.setCategory(bookObject.getString("category"));
                bookList.add(book1);
            }

            // 输出解析结果
            for (Book book : bookList) {
                System.out.println(book.getAuthor() + ", " + book.getTitle());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

2.6基于GSON的解析

2.6.1配置文件

    <!-- 添加 Google GSON 依赖 -->
    <dependency>
        <groupId>com.google.code.gson</groupId>
        <artifactId>gson</artifactId>
        <version>2.8.8</version>
    </dependency>

2.6.2解析类

package org.example;

import java.io.File;
import java.io.FileReader;
import java.util.Arrays;
import java.util.List;

import com.google.gson.Gson;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import com.google.gson.reflect.TypeToken;

public class GsonTest {
    public static void main(String[] args) {
        testJsonObject();
        System.out.println("=========华丽丽的分割线==========");
        testJsonFile();
    }

    public static void testJsonObject() {
        // 构造对象
        Person p = new Person();
        p.setName("Tom");
        p.setAge(20);
        p.setScores(Arrays.asList(60, 70, 80));

        // 从Java对象到JSON字符串
        Gson gson = new Gson();
        String s = gson.toJson(p);
        System.out.println(s); // {"name":"Tom","age":20,"scores":[60,70,80]}

        // 从JSON字符串到Java对象
        Person p2 = gson.fromJson(s, Person.class);
        System.out.println(p2.getName()); // Tom
        System.out.println(p2.getAge()); // 20
        System.out.println(p2.getScores()); // [60, 70, 80]

        // 调用GSON的JsonObject
        JsonObject json = gson.toJsonTree(p).getAsJsonObject();
        System.out.println(json.get("name")); // "Tom"
        System.out.println(json.get("age")); // 20
        System.out.println(json.get("scores")); // [60, 70, 80]
    }

    public static void testJsonFile() {
        Gson gson = new Gson();
        File file = new File("D:\\workspace-java\\untitled4\\src\\main\\resources\\books.json");
        try (FileReader reader = new FileReader(file)) {
            // 将JSON文件内容解析成List<Book>对象
           // List<Book> books = gson.fromJson(reader, new TypeToken<List<Book>>(){}.getType());
            // 解析根元素的 JSON 对象
            JsonObject rootObject = JsonParser.parseReader(reader).getAsJsonObject();

            // 获取 "books" 属性对应的 JSON 数组
            JsonArray booksArray = rootObject.getAsJsonArray("books");

            List<Book> books = gson.fromJson(booksArray, new TypeToken<List<Book>>(){}.getType());
            for (Book book : books) {
                System.out.println(book.getAuthor() + ", " + book.getTitle());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

2.6.3所用json文件

[
  {
    "author": "Author 1",
    "title": "Title 1"
  },
  {
    "author": "Author 2",
    "title": "Title 2"
  },
  {
    "author": "Author 3",
    "title": "Title 3"
  }
]

2.7基于jackson的解析

2.7.1配置

   <!-- Jackson 库 -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-core</artifactId>
        <version>2.12.5</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.12.5</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-annotations</artifactId>
        <version>2.12.5</version>
    </dependency>

2.7.2解析类

package org.example;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTest {
    public static void main(String[] args) throws Exception {
        testJsonObject();
        System.out.println("=========华丽丽的分割线==============");
        testJsonFile();
    }

    static void testJsonObject() throws IOException {
        ObjectMapper om = new ObjectMapper();

        // 构造一个 Person 对象
        Person p = new Person();
        p.setName("Tom");
        p.setAge(20);
        p.setScores(Arrays.asList(60, 70, 80));

        // 将 Person 对象解析为 JSON 字符串
        String jsonStr = om.writeValueAsString(p);
        System.out.println(jsonStr);

        // 从 JSON 字符串重构为 Person 对象
        Person p2 = om.readValue(jsonStr, Person.class);
        System.out.println("Name: " + p2.getName());
        System.out.println("Age: " + p2.getAge());
        System.out.println("Scores: " + p2.getScores());

        // 从 JSON 字符串重构为 JsonNode 对象
        JsonNode node = om.readTree(jsonStr);
        System.out.println("Name from JsonNode: " + node.get("name").asText());
        System.out.println("Age from JsonNode: " + node.get("age").asText());
        System.out.println("Scores from JsonNode: " + node.get("scores"));
    }

    static void testJsonFile() throws IOException {
        ObjectMapper om = new ObjectMapper();

        // 从 JSON 文件中加载，并重构为 Java 对象
        File jsonFile = new File("D:\\workspace-java\\untitled4\\src\\main\\resources\\books2.json");
        List<Book> books = om.readValue(jsonFile, new TypeReference<List<Book>>() {
        });

        // 打印书籍信息
        for (Book book : books) {
            System.out.println("Author: " + book.getAuthor());
            System.out.println("Title: " + book.getTitle());
        }
    }
}

2.8基于fastjson的解析

fastjson.jar是阿里开发的一款专门用于Java开发的包，可以方便的实现json对象与JavaBean对象的转换，实现JavaBean对象与json字符串的转换，实现json对象与json字符串的转换。实现json的转换方法很多，最后的实现结果都是一样的。

2.8.1配置

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

2.8.2解析类

fastjson 三个主要的类：

JSONObject 代表 json 对象

JSONObject实现了Map接口, 猜想 JSONObject底层操作是由Map实现的。

JSONObject对应json对象，通过各种形式的get()方法可以获取json对象中的数据，也可利用诸如size()，isEmpty()等方法获取"键：值"对的个数和判断是否为空。其本质是通过实现Map接口并调用接口中的方法完成的。

JSONArray 代表 json 对象数组

内部是有List接口中的方法来完成操作的。

JSON代表 JSONObject和JSONArray的转化

JSON类源码分析与使用

仔细观察这些方法，主要是实现json对象，json对象数组，javabean对象，json字符串之间的相互转化。

2.8.2测试类

package org.example;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

//需要导入lombok
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {

    private String name;
    private int age;
    private String sex;

}

package org.example;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;


import java.util.ArrayList;
import java.util.List;

public class FastJsonDemo {
    public static void main(String[] args) {
        //创建一个对象
        User user1 = new User("1号", 3, "男");
        User user2 = new User("2号", 3, "男");
        User user3 = new User("3号", 3, "男");
        User user4 = new User("4号", 3, "男");
        List<User> list = new ArrayList<User>();
        list.add(user1);
        list.add(user2);
        list.add(user3);
        list.add(user4);

        System.out.println("*******Java对象 转 JSON字符串*******");
        String str1 = JSON.toJSONString(list);
        System.out.println("JSON.toJSONString(list)==>"+str1);
        String str2 = JSON.toJSONString(user1);
        System.out.println("JSON.toJSONString(user1)==>"+str2);

        System.out.println("\n****** JSON字符串 转 Java对象*******");
        User jp_user1=JSON.parseObject(str2,User.class);
        System.out.println("JSON.parseObject(str2,User.class)==>"+jp_user1);

        System.out.println("\n****** Java对象 转 JSON对象 ******");
        JSONObject jsonObject1 = (JSONObject) JSON.toJSON(user2);
        System.out.println("(JSONObject) JSON.toJSON(user2)==>"+jsonObject1.getString("name"));

        System.out.println("\n****** JSON对象 转 Java对象 ******");
        User to_java_user = JSON.toJavaObject(jsonObject1, User.class);
        System.out.println("JSON.toJavaObject(jsonObject1, User.class)==>"+to_java_user);
    }
}