语法篇-JSON基础

布满荆棘的人生 2024-04-17 11:46 18阅读 0赞

### 一、JSON初识 ###

### 1.1基础认识 ###

> JSON是一种轻量级的数据交换格式，它基于JavaScript语言的对象表示法，可以在多种语言之间进行数据交换。JSON的基本数据类型有数值、字符串、布尔值、数组、对象和空值。JSON的格式简洁易读，也易于解析和处理。JSON的标准文件扩展名是.json
> 
>  *  采用完全独立于编程语言的**文本格式**来存储和表示数据。
> 
> 然而，不是所有的系统都支持使用JSON来交换数据。数据交换格式有很多，如前面提到的XML (extensible markup language,可扩展性标记语言)，可能早在JSON被发明前就已  
> 经在应用了。有许多系统可以并还在使用像XML这样的格式，或是用表格 和分隔符来表示  
> 数据的格式，如逗号分隔值(CSV)。

### 1.2JSON语法 ###

#### 1.2.1专业术语及概念 ####

![330dbb22c9be4938adcaba479685a735.png][]

![66fbd9e48d994f8da883245c8fc59836.png][]

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

#### 1.2.2JSON基于JavaScript对象字面量 ####

![7f1b0040ad7c444b8016bc8b6d9c535d.png][]

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

#### 1.2.3名称-值对 ####

![b275ebd19e3544f186eb3527ce68ef7b.png][]

#### 1.2.4正确的JSON语法 ####

> 属性名可以包含下划线(\_ ) 或数字，但是大多数情况下 最好是使用英文字母A-Z或a-z
> 
> 在JSON中， 名称两边的双引号却是必须要加的。
> 
>   
> 不同于名称， 值并不总是需要被双引号包裹。当值是字符串时，必须使用双引号。而在JSON 中，还有数字、 布尔值、数组、对象、null 等其他数据类型，这些都不应被双引号包裹。![cfa55adca391473da2c37150e298bd1e.png][]

![f39443ea7d1a41a8bffcb507e864d9ad.png][]

#### 1.2.5语法验证 ####

网上验证工具

#### 1.2.6JSON文件 ####

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

#### 1.2.7JSON媒体类型![4fbb1a0030654a928d84607082ab17f4.png][] ####

### 1.3JSON的数据类型 ###

1.3.1概述

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

#### 1.3.2JSON 中的数据类型包括 ####

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

#### 1.3.3对象数据类型 ####

![5781a4c887794a498ed59b2bb07cdda0.png][]

#### 1.3.4字符串数据类型 ####

![4a59c0873d644e0287b577b184fdb1b8.png][]

举例

![214853ddad8c4ca39ed86c4e7b2bf43d.png][]

#### 1.3.5数字数据类型 ####

![bc524a72e7bd4a7e92ae8152166326d1.png][]

#### 1.3.6 布尔数据类型 ####

![5738e8b5020f4f27bcbcaa5ac72614ae.png][]

#### 1.3.7 null类型 ####

![a4595a9760794d1cb4a5b4317233f7e0.png][]

#### 1.3.8 数组数据类型![7f1b0040ad7c444b8016bc8b6d9c535d.png][] ####

![c887d2f497e24c079e5af73698da787a.png][]

#### ![71f472771e8949d3b61697da9a7a389a.png][] 1.3.9总结 ####

![5a024b4d604f4fb9b399b107f6408674.png][]

![b0a2e01877dc4e7ea8878a8ff5e1b2a6.png][]

### 1.4JSON和JS的区别 ###

![02cd18011c564955aced299cbac5d3fd.png][]

### 1.5JSON和JS对象互转 ###

![599f7812d8b54638a77474ab82c56133.png][]

![e4fa1557afbc4fa78c22338590dc1047.png][]

## 二、JSON处理 ##

### 2.1数据类型 ###

![52197d533e9344c198930ce44dc2cac7.png][]

### 2.2常见解析轮子 ###

![28c01bc6e2a8425087c87424f4c31614.png][]

### 2.3JSON主要用途 ###

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

### 2.4JSON和XML比较 ###

### ![214a884ad82b490fbf02432ca70134e0.png][]2.5基于org.json的解析 ###

#### 2.5.1 配置文件 ####

#### 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配置文件 ####

<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配置 ####

<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);
        }
    }

##  ##

[330dbb22c9be4938adcaba479685a735.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/12/13461fe5e58845b192c90772ca1b3526.png
[66fbd9e48d994f8da883245c8fc59836.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/12/b49b7d5cc24c45c7badb1e81e916b28f.png
[7f1b0040ad7c444b8016bc8b6d9c535d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/12/5aca8fc0ea28450ba9eb5601331015df.png
[b275ebd19e3544f186eb3527ce68ef7b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/12/cca0a97dfcfc43f889ba812bc65feb4b.png
[cfa55adca391473da2c37150e298bd1e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/12/cbe245c5b51e408aa0c06c5d5d71d1c1.png
[f39443ea7d1a41a8bffcb507e864d9ad.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/12/d49cfe349abd4991b8d1b29fc5b800f6.png
[4fbb1a0030654a928d84607082ab17f4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/12/300a97106e7642a782c90ad1f5380ac9.png
[5781a4c887794a498ed59b2bb07cdda0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/12/a5970a89f16d4f28aa73ab03f7e10738.png
[4a59c0873d644e0287b577b184fdb1b8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/12/41be9af62e6240bfb4e10187ba9613ed.png
[214853ddad8c4ca39ed86c4e7b2bf43d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/12/427b4b1ebbe44d39ab9ebe63b52f84bb.png
[bc524a72e7bd4a7e92ae8152166326d1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/12/579b9547af47461b8d7be77447e50981.png
[5738e8b5020f4f27bcbcaa5ac72614ae.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/12/f67f8542cc134d6499def9f73a5dfae5.png
[a4595a9760794d1cb4a5b4317233f7e0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/12/56963d17a88b44d4a2e7bed6587e77da.png
[c887d2f497e24c079e5af73698da787a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/12/c57b1adab700481aaee8baa735fdedd3.png
[71f472771e8949d3b61697da9a7a389a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/12/de407fe6c69341ff888d29ff2ff383ab.png
[5a024b4d604f4fb9b399b107f6408674.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/12/1f1875e5c0914e2998e99d337c2551a0.png
[b0a2e01877dc4e7ea8878a8ff5e1b2a6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/12/30e2d2ceacbf44e9b6a3e288f7b0d7fd.png
[02cd18011c564955aced299cbac5d3fd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/12/d3651c5cd2a54583ad8cd29d6e46f029.png
[599f7812d8b54638a77474ab82c56133.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/12/897cf047b51e43abbc67301c401ba318.png
[e4fa1557afbc4fa78c22338590dc1047.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/12/be93426ea5844a43937a7f084b1c2614.png
[52197d533e9344c198930ce44dc2cac7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/12/bf614f3a978743d78bf9e1c329f30c2f.png
[28c01bc6e2a8425087c87424f4c31614.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/12/d24398ce07c54ab4a0601696ede7ce6f.png
[214a884ad82b490fbf02432ca70134e0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/12/fcb2833eb31b475fa1c49b2c3273dcb1.png