📌  相关文章
📜  JSON.simple-快速指南

📅  最后修改于: 2020-11-16 07:27:57             🧑  作者: Mango

JSON.simple是用于JSON的基于Java的简单工具包。您可以使用JSON.simple编码或解码JSON数据。

特征

  • 符合规范-JSON.simple完全符合JSON规范RFC4627。

  • 轻量级-它只有很少的类，并提供必要的功能，例如编码/解码和转义json。

  • 重用集合-大多数操作是使用Map / List接口完成的，从而增加了可重用性。

  • 流支持-支持流JSON输出文本。

  • 类似于Content Handler的SAX-提供类似SAX的接口以流式传输大量JSON数据。

  • 高性能-使用基于堆的解析器并提供高性能。

  • 无依赖性-无外部库依赖性。可以独立包含。

  • 兼容JDK1.2-源代码和二进制文件均兼容JDK1.2

JSON.simple-环境设置

本地环境设置

JSON.simple是Java的库，因此首要要求是在您的计算机上安装JDK。

系统要求

JDK Memory Disk Space Operating System
1.5 or above. No minimum requirement. No minimum requirement. No minimum requirement.

步骤1：验证机器中的Java安装

首先，打开控制台并根据您正在使用的操作系统执行Java命令。

OS Task Command
Windows Open Command Console c:\> java -version
Linux Open Command Terminal $ java -version
Mac Open Terminal machine:< joseph$ java -version

让我们验证所有操作系统的输出-

OS Output
Windows

java version “1.8.0_101”

Java(TM) SE Runtime Environment (build 1.8.0_101)
Linux

java version “1.8.0_101”

Java(TM) SE Runtime Environment (build 1.8.0_101)
Mac

java version “1.8.0_101”

Java(TM) SE Runtime Environment (build 1.8.0_101)

如果您的系统上未安装Java，请从以下链接www.oracle.com下载Java软件开发工具包(SDK)。我们假定Java 1.8.0_101是本教程的安装版本。

步骤2：设定JAVA环境

将JAVA_HOME环境变量设置为指向您的计算机上安装Java的基本目录位置。例如。

OS Output
Windows Set the environment variable JAVA_HOME to C:\Program Files\Java\jdk1.8.0_101
Linux export JAVA_HOME = /usr/local/java-current
Mac export JAVA_HOME = /Library/Java/Home

将Java编译器位置附加到系统路径。

OS Output
Windows Append the string C:\Program Files\Java\jdk1.8.0_101\bin at the end of the system variable, Path.
Linux export PATH = $PATH:$JAVA_HOME/bin/
Mac not required

如上所述，使用命令java -version验证Java安装。

步骤3：下载JSON.simple存档

从json-simple @ MVNRepository下载最新版本的JSON.simple jar文件。在编写本教程时，我们已经下载了json-simple-1.1.1.jar，并将其复制到C：\> JSON文件夹中。

OS Archive name
Windows json-simple-1.1.1.jar
Linux json-simple-1.1.1.jar
Mac json-simple-1.1.1.jar

步骤4：设定JSON_JAVA环境

将JSON_JAVA环境变量设置为指向计算机上存储JSON.simple jar的基本目录位置。假设我们已将json-simple-1.1.1.jar存储在JSON文件夹中。

Sr.No OS & Description
1

Windows

Set the environment variable JSON_JAVA to C:\JSON
2

Linux

export JSON_JAVA = /usr/local/JSON
3

Mac

export JSON_JAVA = /Library/JSON

步骤5：设置CLASSPATH变量

将CLASSPATH环境变量设置为指向JSON.simple jar位置。

Sr.No OS & Description
1

Windows

Set the environment variable CLASSPATH to %CLASSPATH%;%JSON_JAVA%\json-simple-1.1.1.jar;.;
2

Linux

export CLASSPATH = $CLASSPATH:$JSON_JAVA/json-simple-1.1.1.jar:.
3

Mac

export CLASSPATH = $CLASSPATH:$JSON_JAVA/json-simple-1.1.1.jar:.

JSON.simple-JAVA映射

JSON.simple在解码或解析时将实体从左侧映射到右侧，并在编码时将实体从右侧映射到左侧。

JSON Java
string java.lang.String
number java.lang.Number
true|false java.lang.Boolean
null null
array java.util.List
object java.util.Map

在解码时，默认的具体类的java.util.List的是org.json.simple.JSONArray和默认的具体类java.util.Map的是org.json.simple.JSONObject。

JSON.simple-转义特殊字符

以下字符是保留字符，不能在JSON中使用，必须正确转义后才能在字符串。

  • 退格键将替换为\ b

  • 形式进料至与\ F代替

  • 换行符将替换为\ n

  • 回车用\ r代替

  • 制表符将替换为\ t

  • 双引号将替换为\“

  • 反斜杠将替换为\\

JSONObject.escape()方法可用于转义JSON字符串中的此类保留关键字。以下是示例-

例

import org.json.simple.JSONObject;

public class JsonDemo {
   public static void main(String[] args) {
      JSONObject jsonObject = new JSONObject();
      String text = "Text with special character /\"\'\b\f\t\r\n.";
      System.out.println(text);
      System.out.println("After escaping.");
      text = jsonObject.escape(text);
      System.out.println(text);
   }
}

输出

Text with special character /"'
.
After escaping.
Text with special character \/\"'\b\f\t\r\n.

JSON.simple-使用JSONValue

JSONValue提供一个静态方法parse()来解析给定的json字符串，以返回一个JSONObject，然后该JSONObject可用于获取已解析的值。请参见下面的示例。

例

import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
import org.json.simple.JSONValue;

public class JsonDemo {
   public static void main(String[] args) {
      String s = "[0,{\"1\":{\"2\":{\"3\":{\"4\":[5,{\"6\":7}]}}}}]";
      Object obj = JSONValue.parse(s);
      JSONArray array = (JSONArray)obj;

      System.out.println("The 2nd element of array");
      System.out.println(array.get(1));
      System.out.println();

      JSONObject obj2 = (JSONObject)array.get(1);
      System.out.println("Field \"1\"");
      System.out.println(obj2.get("1"));    

      s = "{}";
      obj = JSONValue.parse(s);
      System.out.println(obj);

      s = "[5,]";
      obj = JSONValue.parse(s);
      System.out.println(obj);

      s = "[5,,2]";
      obj = JSONValue.parse(s);
      System.out.println(obj);
   }
}

输出

The 2nd element of array
{"1":{"2":{"3":{"4":[5,{"6":7}]}}}}

Field "1"
{"2":{"3":{"4":[5,{"6":7}]}}}
{}
[5]
[5,2]

JSON.simple-异常处理

JSONParser.parse()在无效JSON的情况下引发ParseException。下面的示例演示如何处理ParseException。

例

import org.json.simple.parser.JSONParser;
import org.json.simple.parser.ParseException;

class JsonDemo {
   public static void main(String[] args) {
      JSONParser parser = new JSONParser();
      String text = "[[null, 123.45, \"a\tb c\"]}, true";

      try{
         Object obj = parser.parse(text);         
         System.out.println(obj);
      }catch(ParseException pe) {
         System.out.println("position: " + pe.getPosition());
         System.out.println(pe);
      }
   }
}

输出

position: 24
Unexpected token RIGHT BRACE(}) at position 24.

JSON.simple-容器工厂

ContainerFactory可用于为解析的JSON对象/数组创建Custom容器。首先，我们需要创建一个ContainerFactory对象，然后在JSONParser的parse Method中使用它来获取所需的对象。请参阅下面的示例-

例

import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import org.json.simple.parser.ContainerFactory;
import org.json.simple.parser.JSONParser;
import org.json.simple.parser.ParseException;

class JsonDemo {
   public static void main(String[] args) {
      JSONParser parser = new JSONParser();
      String text =  "{\"first\": 123, \"second\": [4, 5, 6], \"third\": 789}";
      ContainerFactory containerFactory = new ContainerFactory() {
         @Override
         public Map createObjectContainer() {
            return new LinkedHashMap<>();
         }
         @Override
         public List creatArrayContainer() {
            return new LinkedList<>();
         }
      };
      try {
         Map map = (Map)parser.parse(text, containerFactory);       
         map.forEach((k,v)->System.out.println("Key : " + k + " Value : " + v));
      } catch(ParseException pe) {
         System.out.println("position: " + pe.getPosition());
         System.out.println(pe);
      }
   }
}

输出

Key : first Value : 123
Key : second Value : [4, 5, 6]
Key : third Value : 789

JSON.simple-ContentHandler

ContentHandler接口用于提供类似于SAX的接口以流式传输大型json。它还提供了可停止的功能。以下示例说明了该概念。

例

import java.io.IOException;
import java.util.List;
import java.util.Stack;

import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
import org.json.simple.parser.ContentHandler;
import org.json.simple.parser.JSONParser;
import org.json.simple.parser.ParseException;

class JsonDemo {
   public static void main(String[] args) {
      JSONParser parser = new JSONParser();
      String text =  "{\"first\": 123, \"second\": [4, 5, 6], \"third\": 789}";
      try {
         CustomContentHandler handler = new CustomContentHandler();
         parser.parse(text, handler,true);       
      } catch(ParseException pe) {
      }
   }
}
class CustomContentHandler implements ContentHandler {
   @Override
   public boolean endArray() throws ParseException, IOException {     
      System.out.println("inside endArray");
      return true;
   }
   @Override
   public void endJSON() throws ParseException, IOException {
      System.out.println("inside endJSON");
   }
   @Override
   public boolean endObject() throws ParseException, IOException {       
      System.out.println("inside endObject");
      return true;
   }
   @Override
   public boolean endObjectEntry() throws ParseException, IOException {
      System.out.println("inside endObjectEntry");
      return true;
   }
   public boolean primitive(Object value) throws ParseException, IOException {
      System.out.println("inside primitive: " + value);
      return true;
   }
   @Override
   public boolean startArray() throws ParseException, IOException {
      System.out.println("inside startArray");
      return true;
   }
   @Override
   public void startJSON() throws ParseException, IOException {
      System.out.println("inside startJSON");
   }
   @Override
   public boolean startObject() throws ParseException, IOException {
      System.out.println("inside startObject");      
      return true;
   }
   @Override
   public boolean startObjectEntry(String key) throws ParseException, IOException {
      System.out.println("inside startObjectEntry: " + key); 
      return true;
   }    
}

输出

inside startJSON
inside startObject
inside startObjectEntry: first
inside primitive: 123
inside endObjectEntry
inside startObjectEntry: second
inside startArray
inside primitive: 4
inside primitive: 5
inside primitive: 6
inside endArray
inside endObjectEntry
inside startObjectEntry: third
inside primitive: 789
inside endObjectEntry
inside endObject
inside endJSON

JSON.simple-编码JSONObject

使用JSON.simple，我们可以使用以下方式对JSON对象进行编码-

  • 将JSON对象编码-字符串-简单编码。

  • 编码JSON对象-流-输出可用于流。

  • 编码JSON对象-使用Map-通过保留顺序进行编码。

  • 编码JSON对象-使用Map和Streaming-通过保留顺序和流进行编码。

以下示例说明了上述概念。

例

import java.io.IOException;
import java.io.StringWriter;
import java.util.LinkedHashMap;
import java.util.Map;

import org.json.simple.JSONObject;
import org.json.simple.JSONValue;

class JsonDemo {
   public static void main(String[] args) throws IOException {
      JSONObject obj = new JSONObject();
      String jsonText;

      obj.put("name", "foo");
      obj.put("num", new Integer(100));
      obj.put("balance", new Double(1000.21));
      obj.put("is_vip", new Boolean(true));
      jsonText = obj.toString();

      System.out.println("Encode a JSON Object - to String");
      System.out.print(jsonText);

      StringWriter out = new StringWriter();
      obj.writeJSONString(out);       
      jsonText = out.toString();

      System.out.println("\nEncode a JSON Object - Streaming");       
      System.out.print(jsonText);

      Map obj1 = new LinkedHashMap();
      obj1.put("name", "foo");
      obj1.put("num", new Integer(100));
      obj1.put("balance", new Double(1000.21));
      obj1.put("is_vip", new Boolean(true));

      jsonText = JSONValue.toJSONString(obj1); 
      System.out.println("\nEncode a JSON Object - Preserving Order");
      System.out.print(jsonText);

      out = new StringWriter();
      JSONValue.writeJSONString(obj1, out); 
      jsonText = out.toString();
      System.out.println("\nEncode a JSON Object - Preserving Order and Stream");
      System.out.print(jsonText);
   }
}

输出

Encode a JSON Object - to String
{"balance":1000.21,"is_vip":true,"num":100,"name":"foo"}
Encode a JSON Object - Streaming
{"balance":1000.21,"is_vip":true,"num":100,"name":"foo"}
Encode a JSON Object - Preserving Order
{"name":"foo","num":100,"balance":1000.21,"is_vip":true}
Encode a JSON Object - Preserving Order and Stream
{"name":"foo","num":100,"balance":1000.21,"is_vip":true}

JSON.simple-编码JSONArray

使用JSON.simple，我们可以使用以下方式对JSON数组进行编码-

  • 将JSON数组编码-字符串-简单编码。

  • 编码JSON数组-流-输出可用于流。

  • 编码JSON数组-使用列表-使用列表编码。

  • 编码JSON数组-使用列表和流-使用列表和流进行编码。

以下示例说明了上述概念。

例

import java.io.IOException;
import java.io.StringWriter;
import java.util.LinkedList;
import java.util.List;

import org.json.simple.JSONArray;
import org.json.simple.JSONValue;

class JsonDemo {
   public static void main(String[] args) throws IOException {
      JSONArray list = new JSONArray();
      String jsonText;

      list.add("foo");
      list.add(new Integer(100));
      list.add(new Double(1000.21));
      list.add(new Boolean(true));
      list.add(null);
      jsonText = list.toString();

      System.out.println("Encode a JSON Array - to String");
      System.out.print(jsonText);

      StringWriter out = new StringWriter();
      list.writeJSONString(out);       
      jsonText = out.toString();

      System.out.println("\nEncode a JSON Array - Streaming");       
      System.out.print(jsonText);

      List list1 = new LinkedList();
      list1.add("foo");
      list1.add(new Integer(100));
      list1.add(new Double(1000.21));
      list1.add(new Boolean(true));
      list1.add(null);

      jsonText = JSONValue.toJSONString(list1); 
      System.out.println("\nEncode a JSON Array - Using List");
      System.out.print(jsonText);

      out = new StringWriter();
      JSONValue.writeJSONString(list1, out); 
      jsonText = out.toString();
      System.out.println("\nEncode a JSON Array - Using List and Stream");
      System.out.print(jsonText);
   }
}

输出

Encode a JSON Array - to String
["foo",100,1000.21,true,null]
Encode a JSON Array - Streaming
["foo",100,1000.21,true,null]
Encode a JSON Array - Using List
["foo",100,1000.21,true,null]
Encode a JSON Array - Using List and Stream
["foo",100,1000.21,true,null]

JSON.simple-合并对象

在JSON.simple中，我们可以使用JSONObject.putAll()方法轻松合并两个JSON对象。

以下示例说明了上述概念。

例

import java.io.IOException;
import org.json.simple.JSONObject;

class JsonDemo {
   public static void main(String[] args) throws IOException {
      JSONObject obj1 = new JSONObject();       
      obj1.put("name", "foo");
      obj1.put("num", new Integer(100)); 

      JSONObject obj2 = new JSONObject();       
      obj2.put("balance", new Double(1000.21));
      obj2.put("is_vip", new Boolean(true));       
      obj1.putAll(obj2);       
      System.out.println(obj1);
   }
}

输出

{"balance":1000.21,"is_vip":true,"num":100,"name":"foo"}

JSON.simple-合并数组

在JSON.simple中，我们可以使用JSONArray.addAll()方法轻松合并两个JSON数组。

以下示例说明了上述概念。

例

import java.io.IOException;
import org.json.simple.JSONArray;

class JsonDemo {
   public static void main(String[] args) throws IOException {
      JSONArray list1 = new JSONArray();
      list1.add("foo");
      list1.add(new Integer(100));

      JSONArray list2 = new JSONArray();       
      list2.add(new Double(1000.21));
      list2.add(new Boolean(true));
      list2.add(null);

      list1.addAll(list2);       
      System.out.println(list1);       
   }
}

输出

["foo",100,1000.21,true,null]

JSON.simple-基元，对象，数组

使用JSONArray对象，我们可以创建一个由原语，对象和数组组成的JSON。

以下示例说明了上述概念。

例

import java.io.IOException;
import org.json.simple.JSONArray;
import org.json.simple.JSONObject;

class JsonDemo {
   public static void main(String[] args) throws IOException {
      JSONArray list1 = new JSONArray();
      list1.add("foo");
      list1.add(new Integer(100));

      JSONArray list2 = new JSONArray();       
      list2.add(new Double(1000.21));
      list2.add(new Boolean(true));
      list2.add(null);

      JSONObject obj = new JSONObject();

      obj.put("name", "foo");
      obj.put("num", new Integer(100));
      obj.put("balance", new Double(1000.21));
      obj.put("is_vip", new Boolean(true));
     
      obj.put("list1", list1); 
      obj.put("list2", list2);
      System.out.println(obj);       
   }
}

输出

{"list1":["foo",100],"balance":1000.21,"is_vip":true,"num":100,"list2":[1000.21,true,null],"name":"foo"}

JSON.simple-基本，地图，列表组合

使用JSONValue对象，我们可以创建一个由原语，Map和List组成的JSON。

以下示例说明了上述概念。

例

import java.io.IOException;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import org.json.simple.JSONValue;

class JsonDemo {
   public static void main(String[] args) throws IOException {
      Map m1 = new LinkedHashMap(); 
      m1.put("k11","v11"); 
      m1.put("k12","v12"); 
      m1.put("k13", "v13");

      List l1 = new LinkedList();
      l1.add(m1);
      l1.add(new Integer(100));

      String jsonString = JSONValue.toJSONString(l1);
      System.out.println(jsonString);
   }
}

输出

[{"k11":"v11","k12":"v12","k13":"v13"},100]

JSON.simple-基本体，对象，地图，列表

使用JSONValue对象，我们可以创建一个由原语，Object，Map和List组成的JSON。

以下示例说明了上述概念。

例

import java.io.IOException;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import org.json.simple.JSONObject;
import org.json.simple.JSONValue;

class JsonDemo {
   public static void main(String[] args) throws IOException {
      JSONObject obj = new JSONObject();

      Map m1 = new LinkedHashMap(); 
      m1.put("k11","v11");
      m1.put("k12","v12");
      m1.put("k13", "v13");

      List l1 = new LinkedList();      
      l1.add(new Integer(100));

      obj.put("m1", m1);
      obj.put("l1", l1);
      String jsonString = JSONValue.toJSONString(obj);
      System.out.println(jsonString);
   }
}

输出

{"m1":{"k11":"v11","k12":"v12","k13":"v13"},"l1":[100]}

JSON.simple-自定义输出

我们可以基于自定义类自定义JSON输出。唯一的要求就是实现JSONAware接口。

以下示例说明了上述概念。

例

import java.io.IOException;

import org.json.simple.JSONArray;
import org.json.simple.JSONAware;
import org.json.simple.JSONObject;

class JsonDemo {
   public static void main(String[] args) throws IOException {
      JSONArray students = new JSONArray(); 
      students.add(new Student(1,"Robert")); 
      students.add(new Student(2,"Julia")); 

      System.out.println(students);     
   }
}
class Student implements JSONAware {
   int rollNo;
   String name;
   Student(int rollNo, String name){
      this.rollNo = rollNo;
      this.name = name;
   }
   @Override
   public String toJSONString() {
      StringBuilder sb = new StringBuilder();
      sb.append("{");
      sb.append("name");
      sb.append(":");
      sb.append("\"" + JSONObject.escape(name) + "\"");
      sb.append(",");
      sb.append("rollNo");
      sb.append(":");
      sb.append(rollNo);
      sb.append("}");
      return sb.toString();
   }    
}

输出

[{name:"Robert",rollNo:1},{name:"Julia",rollNo:2}]

JSON.simple-自定义输出流

我们可以基于自定义类自定义JSON流输出。唯一的要求就是实现JSONStreamAware接口。

以下示例说明了上述概念。

例

import java.io.IOException;
import java.io.StringWriter;
import java.io.Writer;
import java.util.LinkedHashMap;
import java.util.Map;

import org.json.simple.JSONArray;
import org.json.simple.JSONStreamAware;
import org.json.simple.JSONValue;

class JsonDemo {
   public static void main(String[] args) throws IOException {
      JSONArray students = new JSONArray(); 
      students.add(new Student(1,"Robert")); 
      students.add(new Student(2,"Julia")); 
      StringWriter out = new StringWriter();
      students.writeJSONString(out); 
      System.out.println(out.toString());     
   }
}
class Student implements JSONStreamAware {
   int rollNo;
   String name;

   Student(int rollNo, String name){
      this.rollNo = rollNo;
      this.name = name;
   }
   @Override
   public void writeJSONString(Writer out) throws IOException {
      Map obj = new LinkedHashMap();
      obj.put("name", name);
      obj.put("rollNo", new Integer(rollNo));
      JSONValue.writeJSONString(obj, out);        
   }    
}

输出

[{name:"Robert",rollNo:1},{name:"Julia",rollNo:2}]