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