JSON.simple - Kurzanleitung

JSON.simpleist ein einfaches Java-basiertes Toolkit für JSON. Mit JSON.simple können Sie JSON-Daten codieren oder decodieren.

Eigenschaften

  • Specification Compliant - JSON.simple entspricht vollständig der JSON-Spezifikation - RFC4627.

  • Lightweight - Es hat nur sehr wenige Klassen und bietet die erforderlichen Funktionen wie Codieren / Decodieren und Escape-JSON.

  • Reuses Collections - Die meisten Vorgänge werden über Map / List-Schnittstellen ausgeführt, um die Wiederverwendbarkeit zu erhöhen.

  • Streaming supported - Unterstützt das Streaming von JSON-Ausgabetext.

  • SAX like Content Handler - Bietet eine SAX-ähnliche Schnittstelle zum Streamen großer Mengen von JSON-Daten.

  • High performance - Heap-basierter Parser wird verwendet und bietet eine hohe Leistung.

  • No dependency- Keine externe Bibliotheksabhängigkeit. Kann unabhängig eingeschlossen werden.

  • JDK1.2 compatible - Quellcode und Binärdatei sind JDK1.2-kompatibel

Einrichtung der lokalen Umgebung

JSON.simple ist eine Bibliothek für Java. Die allererste Voraussetzung ist daher, dass JDK auf Ihrem Computer installiert ist.

System Anforderungen

JDK Erinnerung Festplattenplatz Betriebssystem
1,5 oder höher. Keine Mindestanforderung. Keine Mindestanforderung. Keine Mindestanforderung.

Schritt 1: Überprüfen Sie die Java-Installation auf Ihrem Computer

Öffnen Sie zunächst die Konsole und führen Sie einen Java-Befehl aus, der auf dem Betriebssystem basiert, an dem Sie arbeiten.

Betriebssystem Aufgabe Befehl
Windows Öffnen Sie die Befehlskonsole c: \> Java-Version
Linux Öffnen Sie das Befehlsterminal $ java -version
Mac Terminal öffnen Maschine: <joseph $ java -version

Lassen Sie uns die Ausgabe für alle Betriebssysteme überprüfen -

Betriebssystem Ausgabe
Windows

Java-Version "1.8.0_101"

Java (TM) SE-Laufzeitumgebung (Build 1.8.0_101)

Linux

Java-Version "1.8.0_101"

Java (TM) SE-Laufzeitumgebung (Build 1.8.0_101)

Mac

Java-Version "1.8.0_101"

Java (TM) SE-Laufzeitumgebung (Build 1.8.0_101)

Wenn auf Ihrem System kein Java installiert ist, laden Sie das Java Software Development Kit (SDK) über den folgenden Link herunter : www.oracle.com . Wir gehen davon aus, dass Java 1.8.0_101 die installierte Version für dieses Tutorial ist.

Schritt 2: Stellen Sie die JAVA-Umgebung ein

Stellen Sie die JAVA_HOMEUmgebungsvariable, die auf den Speicherort des Basisverzeichnisses verweist, in dem Java auf Ihrem Computer installiert ist. Zum Beispiel.

Betriebssystem Ausgabe
Windows Setzen Sie die Umgebungsvariable JAVA_HOME auf C: \ Programme \ Java \ jdk1.8.0_101
Linux export JAVA_HOME = / usr / local / java-current
Mac export JAVA_HOME = / Library / Java / Home

Hängen Sie den Java-Compiler-Speicherort an den Systempfad an.

Betriebssystem Ausgabe
Windows Hängen Sie die Zeichenfolge an C:\Program Files\Java\jdk1.8.0_101\bin am Ende der Systemvariablen, Path.
Linux export PATH = $ PATH: $ JAVA_HOME / bin /
Mac nicht benötigt

Überprüfen Sie die Java-Installation mit dem Befehl java -version wie oben erklärt.

Schritt 3: Laden Sie das JSON.simple-Archiv herunter

Laden Sie die neueste Version der JAR-Datei JSON.simple von json-simple @ MVNRepository herunter . Zum Zeitpunkt des Schreibens dieses Tutorials haben wir json-simple-1.1.1.jar heruntergeladen und in den Ordner C: \> JSON kopiert.

Betriebssystem Archivname
Windows json-simple-1.1.1.jar
Linux json-simple-1.1.1.jar
Mac json-simple-1.1.1.jar

Schritt 4: Legen Sie die JSON_JAVA-Umgebung fest

Stellen Sie die JSON_JAVAUmgebungsvariable, die auf den Speicherort des Basisverzeichnisses verweist, in dem JSON.simple jar auf Ihrem Computer gespeichert ist. Nehmen wir an, wir haben json-simple-1.1.1.jar im JSON-Ordner gespeichert.

Sr.Nr. Betriebssystem & Beschreibung
1

Windows

Setzen Sie die Umgebungsvariable JSON_JAVA auf C: \ JSON

2

Linux

export JSON_JAVA = / usr / local / JSON

3

Mac

export JSON_JAVA = / Library / JSON

Schritt 5: Setzen Sie die Variable CLASSPATH

Stellen Sie die CLASSPATH Umgebungsvariable, die auf den Speicherort JSON.simple jar verweist.

Sr.Nr. Betriebssystem & Beschreibung
1

Windows

Setzen Sie die Umgebungsvariable CLASSPATH auf% 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 ordnet Entitäten beim Decodieren oder Parsen von links nach rechts zu und ordnet Entitäten beim Codieren von rechts nach links zu.

JSON Java
Zeichenfolge java.lang.String
Nummer java.lang.Number
wahr | falsch java.lang.Boolean
Null Null
Array java.util.List
Objekt java.util.Map

Auf der Decodierung der Standard konkrete Klasse von java.util.List ist org.json.simple.JSONArray und die Standard konkrete Klasse von java.util.Map ist org.json.simple.JSONObject .

Die folgenden Zeichen sind reservierte Zeichen und können in JSON nicht verwendet werden. Sie müssen ordnungsgemäß maskiert werden, um in Zeichenfolgen verwendet zu werden.

  • Backspace durch \ b ersetzt werden

  • Form feed durch \ f ersetzt werden

  • Newline durch \ n ersetzt werden

  • Carriage return durch \ r ersetzt werden

  • Tab durch \ t ersetzt werden

  • Double quote durch \ "ersetzt werden

  • Backslash durch \\ ersetzt werden

JSONObject.escape()Methode kann verwendet werden, um solche reservierten Schlüsselwörter in einem JSON-String zu maskieren. Es folgt das Beispiel -

Beispiel

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

Ausgabe

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

JSONValue bietet eine statische Methode parse (), um die angegebene json-Zeichenfolge zu analysieren und ein JSONObject zurückzugeben, mit dem die Werte analysiert werden können. Siehe das folgende Beispiel.

Beispiel

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

Ausgabe

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

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

JSONParser.parse () löst bei ungültigem JSON eine ParseException aus. Das folgende Beispiel zeigt, wie mit ParseException umgegangen wird.

Beispiel

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

Ausgabe

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

Mit ContainerFactory kann ein benutzerdefinierter Container für analysierte JSON-Objekte / Arrays erstellt werden. Zuerst müssen wir ein ContainerFactory-Objekt erstellen und es dann in der Analysemethode von JSONParser verwenden, um das erforderliche Objekt abzurufen. Siehe das folgende Beispiel -

Beispiel

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

Ausgabe

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

Die ContentHandler-Schnittstelle wird verwendet, um eine SAX-ähnliche Schnittstelle zum Streamen des großen JSON bereitzustellen. Es bietet auch Stoppfähigkeit. Das folgende Beispiel veranschaulicht das Konzept.

Beispiel

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

Ausgabe

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

Mit JSON.simple können wir ein JSON-Objekt auf folgende Weise codieren:

  • Encode a JSON Object - to String - Einfache Codierung.

  • Encode a JSON Object - Streaming - Die Ausgabe kann für das Streaming verwendet werden.

  • Encode a JSON Object - Using Map - Codierung durch Beibehaltung der Reihenfolge.

  • Encode a JSON Object - Using Map and Streaming - Codierung durch Beibehalten der Reihenfolge und Streamen.

Das folgende Beispiel veranschaulicht die obigen Konzepte.

Beispiel

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

Ausgabe

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}

Mit JSON.simple können wir ein JSON-Array auf folgende Weise codieren:

  • Encode a JSON Array - to String - Einfache Codierung.

  • Encode a JSON Array - Streaming - Die Ausgabe kann für das Streaming verwendet werden.

  • Encode a JSON Array - Using List - Codierung mithilfe der Liste.

  • Encode a JSON Array - Using List and Streaming - Codierung mit List und zum Streamen.

Das folgende Beispiel veranschaulicht die obigen Konzepte.

Beispiel

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

Ausgabe

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]

In JSON.simple können zwei JSON-Objekte mithilfe der JSONObject.putAll () -Methode problemlos zusammengeführt werden.

Das folgende Beispiel veranschaulicht das obige Konzept.

Beispiel

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

Ausgabe

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

In JSON.simple können zwei JSON-Arrays mithilfe der JSONArray.addAll () -Methode problemlos zusammengeführt werden.

Das folgende Beispiel veranschaulicht das obige Konzept.

Beispiel

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

Ausgabe

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

Mit dem JSONArray-Objekt können wir einen JSON erstellen, der aus Grundelementen, Objekt und Array besteht.

Das folgende Beispiel veranschaulicht das obige Konzept.

Beispiel

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

Ausgabe

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

Mit dem JSONValue-Objekt können wir einen JSON erstellen, der aus Grundelementen, Map und List besteht.

Das folgende Beispiel veranschaulicht das obige Konzept.

Beispiel

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

Ausgabe

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

Mit dem JSONValue-Objekt können wir einen JSON erstellen, der aus Grundelementen, Objekt, Karte und Liste besteht.

Das folgende Beispiel veranschaulicht das obige Konzept.

Beispiel

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

Ausgabe

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

Wir können die JSON-Ausgabe basierend auf der benutzerdefinierten Klasse anpassen. Die einzige Voraussetzung ist die Implementierung der JSONAware-Schnittstelle.

Das folgende Beispiel veranschaulicht das obige Konzept.

Beispiel

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

Ausgabe

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

Wir können die JSON-Streaming-Ausgabe basierend auf der benutzerdefinierten Klasse anpassen. Die einzige Voraussetzung ist die Implementierung der JSONStreamAware-Schnittstelle.

Das folgende Beispiel veranschaulicht das obige Konzept.

Beispiel

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

Ausgabe

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