devbox
菜鸟追梦旅行
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

语法篇-JSON基础_json语法

作者：菜鸟追梦旅行 | 2024-04-25 13:05:21

赞

踩

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对象互转

  1.    <script>
  2.        'use strict';
  3.        var user = {
  4.            name : '烟雨平生',
  5.            age : 20,
  6.            sex : "男"
  7.        }
  8.        console.log(user);
  9.        var str = JSON.stringify(user);
  10.        console.log(str);
  11.        var obj = JSON.parse(str);
  12.        console.log(obj);
  13.     </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 配置文件

  1.  <dependency>
  2.             <groupId>org.json</groupId>
  3.             <artifactId>json</artifactId>
  4.             <version>20210307</version>
  5.         </dependency>

2.5.2所用json文件

  1. {
  2.   "books": [
  3.     {
  4.       "author": "J.K. Rowling",
  5.       "title": "Harry Potter and the Sorcerer's Stone",
  6.       "year": "1997",
  7.       "price": 25,
  8.       "category": "Fantasy"
  9.     },
  10.     {
  11.       "author": "George Orwell",
  12.       "title": "1984",
  13.       "year": "1949",
  14.       "price": 15,
  15.       "category": "Dystopian Fiction"
  16.     }
  17.   ]
  18. }

2.5.3辅助类

  1. package org.example;
  2.  
  3. public class Book {
  4.     private String category;
  5.     private String title;
  6.     private String author;
  7.     private String year;
  8.     private int price;
  9.  
  10.     public String getCategory() {
  11.         return category;
  12.     }
  13.  
  14.     public void setCategory(String category) {
  15.         this.category = category;
  16.     }
  17.  
  18.     public String getTitle() {
  19.         return title;
  20.     }
  21.  
  22.     public void setTitle(String title) {
  23.         this.title = title;
  24.     }
  25.  
  26.     public String getAuthor() {
  27.         return author;
  28.     }
  29.  
  30.     public void setAuthor(String author) {
  31.         this.author = author;
  32.     }
  33.  
  34.     public String getYear() {
  35.         return year;
  36.     }
  37.  
  38.     public void setYear(String year) {
  39.         this.year = year;
  40.     }
  41.  
  42.     public int getPrice() {
  43.         return price;
  44.     }
  45.  
  46.     public void setPrice(int price) {
  47.         this.price = price;
  48.     }
  49.     @Override
  50.     public String toString(){
  51.         return "Book [category=" + category + ", title=" + title + ", author=" + author
  52.                 + ", year=" + year + ", price=" + price + "]";
  53.     }
  54. }
  1. package org.example;
  2. import java.util.List;
  3. public class Person {
  4.     private String name;
  5.     private int age;
  6.     private List<Integer> scores;
  7.    public  Person(){
  8.  
  9.    }
  10.     public Person(String name, int age) {
  11.         this.name = name;
  12.         this.age = age;
  13.     }
  14.  
  15.     public String getName() {
  16.         return name;
  17.     }
  18.  
  19.     public void setName(String name) {
  20.         this.name = name;
  21.     }
  22.  
  23.     public int getAge() {
  24.         return age;
  25.     }
  26.  
  27.     public void setAge(int age) {
  28.         this.age = age;
  29.     }
  30.  
  31.     public List<Integer> getScores() {
  32.         return scores;
  33.     }
  34.  
  35.     public void setScores(List<Integer> scores) {
  36.         this.scores = scores;
  37.     }
  38. }

2.5.4解析类

  1. package org.example;
  2.  
  3. import org.json.JSONArray;
  4. import org.json.JSONObject;
  5.  
  6. import java.io.File;
  7. import java.io.FileReader;
  8. import java.util.ArrayList;
  9. import java.util.Arrays;
  10. import java.util.List;
  11.  
  12. /**
  13.  * 使用 org.json 包来解析 JSON 示例
  14.  * @author Tom
  15.  */
  16. public class OrgJsonTest {
  17.     public static void main(String[] args) {
  18.         testJsonObject();
  19.         System.out.println("=========华丽丽的分割线==============");
  20.         testJsonFile();
  21.     }
  22.  
  23.     public static void testJsonObject() {
  24.         // 构造对象
  25.         Person p = new Person();
  26.         p.setName("Tom");
  27.         p.setAge(20);
  28.         p.setScores(Arrays.asList(60, 70, 80));
  29.  
  30.         // 构造 JSONObject 对象
  31.         JSONObject obj = new JSONObject();
  32.         obj.put("name", p.getName());
  33.         obj.put("age", p.getAge());
  34.         obj.put("scores", p.getScores());
  35.  
  36.         // 输出 JSON 对象内容
  37.         System.out.println(obj);
  38.         System.out.println("name: " + obj.getString("name"));
  39.         System.out.println("age: " + obj.getInt("age"));
  40.         System.out.println("scores: " + obj.getJSONArray("scores"));
  41.     }
  42.  
  43.     public static void testJsonFile() {
  44.         File file = new File("D:\\workspace-java\\untitled4\\src\\main\\resources\\books.json");
  45.         try (FileReader reader = new FileReader(file)) {
  46.             // 读取文件内容到 Json0bject 对象中
  47.             int fileLen = (int) file.length();
  48.             char[] chars = new char[fileLen];
  49.             reader.read(chars);
  50.             String content = String.valueOf(chars);
  51.  
  52.             // 解析 JSON 对象
  53.             JSONObject jsonObject = new JSONObject(content);
  54.             JSONArray books = jsonObject.getJSONArray("books");
  55.  
  56.             List<Book> bookList = new ArrayList<>();
  57.             for (Object book : books) {
  58.                 // 获取单个 JSONObject 对象
  59.                 JSONObject bookObject = (JSONObject) book;
  60.                 Book book1 = new Book();
  61.                 book1.setAuthor(bookObject.getString("author"));
  62.                 book1.setYear(bookObject.getString("year"));
  63.                 book1.setTitle(bookObject.getString("title"));
  64.                 book1.setPrice(bookObject.getInt("price"));
  65.                 book1.setCategory(bookObject.getString("category"));
  66.                 bookList.add(book1);
  67.             }
  68.  
  69.             // 输出解析结果
  70.             for (Book book : bookList) {
  71.                 System.out.println(book.getAuthor() + ", " + book.getTitle());
  72.             }
  73.         } catch (Exception e) {
  74.             e.printStackTrace();
  75.         }
  76.     }
  77. }
  78.

2.6基于GSON的解析

2.6.1配置文件

  1.     <!-- 添加 Google GSON 依赖 -->
  2.     <dependency>
  3.         <groupId>com.google.code.gson</groupId>
  4.         <artifactId>gson</artifactId>
  5.         <version>2.8.8</version>
  6.     </dependency>

2.6.2解析类

  1. package org.example;
  2.  
  3. import java.io.File;
  4. import java.io.FileReader;
  5. import java.util.Arrays;
  6. import java.util.List;
  7.  
  8. import com.google.gson.Gson;
  9. import com.google.gson.JsonArray;
  10. import com.google.gson.JsonObject;
  11. import com.google.gson.JsonParser;
  12. import com.google.gson.reflect.TypeToken;
  13.  
  14. public class GsonTest {
  15.     public static void main(String[] args) {
  16.         testJsonObject();
  17.         System.out.println("=========华丽丽的分割线==========");
  18.         testJsonFile();
  19.     }
  20.  
  21.     public static void testJsonObject() {
  22.         // 构造对象
  23.         Person p = new Person();
  24.         p.setName("Tom");
  25.         p.setAge(20);
  26.         p.setScores(Arrays.asList(60, 70, 80));
  27.  
  28.         // 从Java对象到JSON字符串
  29.         Gson gson = new Gson();
  30.         String s = gson.toJson(p);
  31.         System.out.println(s); // {"name":"Tom","age":20,"scores":[60,70,80]}
  32.  
  33.         // 从JSON字符串到Java对象
  34.         Person p2 = gson.fromJson(s, Person.class);
  35.         System.out.println(p2.getName()); // Tom
  36.         System.out.println(p2.getAge()); // 20
  37.         System.out.println(p2.getScores()); // [60, 70, 80]
  38.  
  39.         // 调用GSON的JsonObject
  40.         JsonObject json = gson.toJsonTree(p).getAsJsonObject();
  41.         System.out.println(json.get("name")); // "Tom"
  42.         System.out.println(json.get("age")); // 20
  43.         System.out.println(json.get("scores")); // [60, 70, 80]
  44.     }
  45.  
  46.     public static void testJsonFile() {
  47.         Gson gson = new Gson();
  48.         File file = new File("D:\\workspace-java\\untitled4\\src\\main\\resources\\books.json");
  49.         try (FileReader reader = new FileReader(file)) {
  50.             // 将JSON文件内容解析成List<Book>对象
  51.            // List<Book> books = gson.fromJson(reader, new TypeToken<List<Book>>(){}.getType());
  52.             // 解析根元素的 JSON 对象
  53.             JsonObject rootObject = JsonParser.parseReader(reader).getAsJsonObject();
  54.  
  55.             // 获取 "books" 属性对应的 JSON 数组
  56.             JsonArray booksArray = rootObject.getAsJsonArray("books");
  57.  
  58.             List<Book> books = gson.fromJson(booksArray, new TypeToken<List<Book>>(){}.getType());
  59.             for (Book book : books) {
  60.                 System.out.println(book.getAuthor() + ", " + book.getTitle());
  61.             }
  62.         } catch (Exception e) {
  63.             e.printStackTrace();
  64.         }
  65.     }
  66. }

2.6.3所用json文件

  1. [
  2.   {
  3.     "author": "Author 1",
  4.     "title": "Title 1"
  5.   },
  6.   {
  7.     "author": "Author 2",
  8.     "title": "Title 2"
  9.   },
  10.   {
  11.     "author": "Author 3",
  12.     "title": "Title 3"
  13.   }
  14. ]

2.7基于jackson的解析

2.7.1配置

  1.    <!-- Jackson 库 -->
  2.     <dependency>
  3.         <groupId>com.fasterxml.jackson.core</groupId>
  4.         <artifactId>jackson-core</artifactId>
  5.         <version>2.12.5</version>
  6.     </dependency>
  7.     <dependency>
  8.         <groupId>com.fasterxml.jackson.core</groupId>
  9.         <artifactId>jackson-databind</artifactId>
  10.         <version>2.12.5</version>
  11.     </dependency>
  12.     <dependency>
  13.         <groupId>com.fasterxml.jackson.core</groupId>
  14.         <artifactId>jackson-annotations</artifactId>
  15.         <version>2.12.5</version>
  16.     </dependency>

2.7.2解析类

  1. package org.example;
  2. import java.io.File;
  3. import java.io.IOException;
  4. import java.util.Arrays;
  5. import java.util.List;
  6.  
  7. import com.fasterxml.jackson.core.type.TypeReference;
  8. import com.fasterxml.jackson.databind.JsonNode;
  9. import com.fasterxml.jackson.databind.ObjectMapper;
  10.  
  11. public class JacksonTest {
  12.     public static void main(String[] args) throws Exception {
  13.         testJsonObject();
  14.         System.out.println("=========华丽丽的分割线==============");
  15.         testJsonFile();
  16.     }
  17.  
  18.     static void testJsonObject() throws IOException {
  19.         ObjectMapper om = new ObjectMapper();
  20.  
  21.         // 构造一个 Person 对象
  22.         Person p = new Person();
  23.         p.setName("Tom");
  24.         p.setAge(20);
  25.         p.setScores(Arrays.asList(60, 70, 80));
  26.  
  27.         // 将 Person 对象解析为 JSON 字符串
  28.         String jsonStr = om.writeValueAsString(p);
  29.         System.out.println(jsonStr);
  30.  
  31.         // 从 JSON 字符串重构为 Person 对象
  32.         Person p2 = om.readValue(jsonStr, Person.class);
  33.         System.out.println("Name: " + p2.getName());
  34.         System.out.println("Age: " + p2.getAge());
  35.         System.out.println("Scores: " + p2.getScores());
  36.  
  37.         // 从 JSON 字符串重构为 JsonNode 对象
  38.         JsonNode node = om.readTree(jsonStr);
  39.         System.out.println("Name from JsonNode: " + node.get("name").asText());
  40.         System.out.println("Age from JsonNode: " + node.get("age").asText());
  41.         System.out.println("Scores from JsonNode: " + node.get("scores"));
  42.     }
  43.  
  44.     static void testJsonFile() throws IOException {
  45.         ObjectMapper om = new ObjectMapper();
  46.  
  47.         // 从 JSON 文件中加载，并重构为 Java 对象
  48.         File jsonFile = new File("D:\\workspace-java\\untitled4\\src\\main\\resources\\books2.json");
  49.         List<Book> books = om.readValue(jsonFile, new TypeReference<List<Book>>() {
  50.         });
  51.  
  52.         // 打印书籍信息
  53.         for (Book book : books) {
  54.             System.out.println("Author: " + book.getAuthor());
  55.             System.out.println("Title: " + book.getTitle());
  56.         }
  57.     }
  58. }

2.8基于fastjson的解析

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

2.8.1配置

  1. <dependency>
  2.    <groupId>com.alibaba</groupId>
  3.    <artifactId>fastjson</artifactId>
  4.    <version>1.2.60</version>
  5. </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测试类

  1. package org.example;
  2.  
  3. import lombok.AllArgsConstructor;
  4. import lombok.Data;
  5. import lombok.NoArgsConstructor;
  6.  
  7. //需要导入lombok
  8. @Data
  9. @AllArgsConstructor
  10. @NoArgsConstructor
  11. public class User {
  12.  
  13.     private String name;
  14.     private int age;
  15.     private String sex;
  16.  
  17. }
  1. package org.example;
  2.  
  3. import com.alibaba.fastjson.JSON;
  4. import com.alibaba.fastjson.JSONObject;
  5.  
  6.  
  7. import java.util.ArrayList;
  8. import java.util.List;
  9.  
  10. public class FastJsonDemo {
  11.     public static void main(String[] args) {
  12.         //创建一个对象
  13.         User user1 = new User("1号", 3, "男");
  14.         User user2 = new User("2号", 3, "男");
  15.         User user3 = new User("3号", 3, "男");
  16.         User user4 = new User("4号", 3, "男");
  17.         List<User> list = new ArrayList<User>();
  18.         list.add(user1);
  19.         list.add(user2);
  20.         list.add(user3);
  21.         list.add(user4);
  22.  
  23.         System.out.println("*******Java对象 转 JSON字符串*******");
  24.         String str1 = JSON.toJSONString(list);
  25.         System.out.println("JSON.toJSONString(list)==>"+str1);
  26.         String str2 = JSON.toJSONString(user1);
  27.         System.out.println("JSON.toJSONString(user1)==>"+str2);
  28.  
  29.         System.out.println("\n****** JSON字符串 转 Java对象*******");
  30.         User jp_user1=JSON.parseObject(str2,User.class);
  31.         System.out.println("JSON.parseObject(str2,User.class)==>"+jp_user1);
  32.  
  33.         System.out.println("\n****** Java对象 转 JSON对象 ******");
  34.         JSONObject jsonObject1 = (JSONObject) JSON.toJSON(user2);
  35.         System.out.println("(JSONObject) JSON.toJSON(user2)==>"+jsonObject1.getString("name"));
  36.  
  37.         System.out.println("\n****** JSON对象 转 Java对象 ******");
  38.         User to_java_user = JSON.toJavaObject(jsonObject1, User.class);
  39.         System.out.println("JSON.toJavaObject(jsonObject1, User.class)==>"+to_java_user);
  40.     }
  41. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/菜鸟追梦旅行/article/detail/485408
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号