JSON.simple - Szybki przewodnik
JSON.simpleto prosty zestaw narzędzi oparty na języku Java dla formatu JSON. Możesz użyć JSON.simple do kodowania lub dekodowania danych JSON.
funkcje
Specification Compliant - JSON.simple jest w pełni zgodny ze specyfikacją JSON - RFC4627.
Lightweight - Ma bardzo mało klas i zapewnia niezbędne funkcje, takie jak kodowanie / dekodowanie i ucieczka json.
Reuses Collections - Większość operacji jest wykonywana przy użyciu interfejsów Map / List, co zwiększa możliwość ponownego użycia.
Streaming supported - Obsługuje przesyłanie strumieniowe tekstu wyjściowego JSON.
SAX like Content Handler - Zapewnia interfejs podobny do SAX do przesyłania strumieniowego dużej ilości danych JSON.
High performance - Używany jest parser oparty na stercie, który zapewnia wysoką wydajność.
No dependency- Brak zależności od biblioteki zewnętrznej. Może być dołączany niezależnie.
JDK1.2 compatible - Kod źródłowy i plik binarny są kompatybilne z JDK1.2
Konfiguracja środowiska lokalnego
JSON.simple to biblioteka dla Javy, więc pierwszym wymaganiem jest zainstalowanie JDK na komputerze.
Wymagania systemowe
JDK | Pamięć | Miejsca na dysku | System operacyjny |
---|---|---|---|
1.5 lub nowszy. | Brak minimalnych wymagań. | Brak minimalnych wymagań. | Brak minimalnych wymagań. |
Krok 1: Zweryfikuj instalację Java na swoim komputerze
Przede wszystkim otwórz konsolę i wykonaj polecenie java w oparciu o system operacyjny, na którym pracujesz.
OS | Zadanie | Komenda |
---|---|---|
Windows | Otwórz konsolę poleceń | c: \> java -version |
Linux | Otwórz terminal poleceń | $ java -version |
Prochowiec | Otwórz Terminal | maszyna: <joseph $ java -version |
Sprawdźmy dane wyjściowe dla wszystkich systemów operacyjnych -
OS | Wynik |
---|---|
Windows | wersja java „1.8.0_101” Java (TM) SE Runtime Environment (kompilacja 1.8.0_101) |
Linux | wersja java „1.8.0_101” Java (TM) SE Runtime Environment (kompilacja 1.8.0_101) |
Prochowiec | wersja java „1.8.0_101” Java (TM) SE Runtime Environment (kompilacja 1.8.0_101) |
Jeśli nie masz zainstalowanej w systemie oprogramowania Java, pobierz pakiet Java Software Development Kit (SDK) z następującego łącza www.oracle.com . Zakładamy Java 1.8.0_101 jako zainstalowaną wersję tego samouczka.
Krok 2: Ustaw środowisko JAVA
Ustaw JAVA_HOMEzmienna środowiskowa wskazująca lokalizację katalogu podstawowego, w którym na komputerze jest zainstalowana Java. Na przykład.
OS | Wynik |
---|---|
Windows | Ustaw zmienną środowiskową JAVA_HOME na C: \ Program Files \ Java \ jdk1.8.0_101 |
Linux | eksportuj JAVA_HOME = / usr / local / java-current |
Prochowiec | eksportuj JAVA_HOME = / Library / Java / Home |
Dołącz lokalizację kompilatora Java do ścieżki systemowej.
OS | Wynik |
---|---|
Windows | Dołącz ciąg C:\Program Files\Java\jdk1.8.0_101\bin na końcu zmiennej systemowej, Path. |
Linux | export PATH = $ PATH: $ JAVA_HOME / bin / |
Prochowiec | nie wymagane |
Sprawdź instalację oprogramowania Java za pomocą polecenia java -version jak wyjaśniono powyżej.
Krok 3: Pobierz archiwum JSON.simple
Pobierz najnowszą wersję pliku jar JSON.simple z json-simple @ MVNRepository . W czasie pisania tego samouczka pobraliśmy plik json-simple-1.1.1.jar i skopiowaliśmy go do folderu C: \> JSON.
OS | Nazwa archiwum |
---|---|
Windows | json-simple-1.1.1.jar |
Linux | json-simple-1.1.1.jar |
Prochowiec | json-simple-1.1.1.jar |
Krok 4: Ustaw środowisko JSON_JAVA
Ustaw JSON_JAVAzmienna środowiskowa wskazująca lokalizację katalogu podstawowego, w którym na komputerze jest przechowywany plik jar JSON.simple. Załóżmy, że zapisaliśmy json-simple-1.1.1.jar w folderze JSON.
Sr.No | System operacyjny i opis |
---|---|
1 | Windows Ustaw zmienną środowiskową JSON_JAVA na C: \ JSON |
2 | Linux eksportuj JSON_JAVA = / usr / local / JSON |
3 | Mac eksportuj JSON_JAVA = / Library / JSON |
Krok 5: Ustaw zmienną CLASSPATH
Ustaw CLASSPATH zmienna środowiskowa wskazująca lokalizację jar JSON.simple.
Sr.No | System operacyjny i opis |
---|---|
1 | Windows Ustaw zmienną środowiskową CLASSPATH na% 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 odwzorowuje encje od lewej do prawej strony podczas dekodowania lub analizowania oraz mapuje encje od prawej do lewej podczas kodowania.
JSON | Jawa |
---|---|
strunowy | java.lang.String |
numer | java.lang.Number |
prawda | fałsz | java.lang.Boolean |
zero | zero |
szyk | java.util.List |
obiekt | java.util.Map |
Podczas dekodowania domyślną klasą konkretną java.util.List jest org.json.simple.JSONArray, a domyślną klasą betonu java.util.Map jest org.json.simple.JSONObject .
Następujące znaki są znakami zastrzeżonymi i nie mogą być używane w formacie JSON i muszą być odpowiednio zmienione, aby można je było używać w łańcuchach.
Backspace do zastąpienia przez \ b
Form feed do zastąpienia przez \ f
Newline do zastąpienia przez \ n
Carriage return do zastąpienia przez \ r
Tab do zastąpienia przez \ t
Double quote do zastąpienia przez \ "
Backslash do zastąpienia przez \\
JSONObject.escape()można użyć do zmiany znaczenia zarezerwowanych słów kluczowych w ciągu JSON. Oto przykład -
Przykład
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);
}
}
Wynik
Text with special character /"'
.
After escaping.
Text with special character \/\"'\b\f\t\r\n.
JSONValue udostępnia statyczną metodę parse (), która analizuje dany ciąg json w celu zwrócenia obiektu JSONObject, którego można następnie użyć do uzyskania przeanalizowanych wartości. Zobacz poniższy przykład.
Przykład
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);
}
}
Wynik
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 () zgłasza ParseException w przypadku nieprawidłowego kodu JSON. Poniższy przykład pokazuje, jak obsługiwać ParseException.
Przykład
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);
}
}
}
Wynik
position: 24
Unexpected token RIGHT BRACE(}) at position 24.
ContainerFactory może służyć do tworzenia niestandardowego kontenera dla przeanalizowanych obiektów / tablic JSON. Najpierw musimy utworzyć obiekt ContainerFactory, a następnie użyć go w metodzie parsowania JSONParser, aby uzyskać wymagany obiekt. Zobacz poniższy przykład -
Przykład
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);
}
}
}
Wynik
Key : first Value : 123
Key : second Value : [4, 5, 6]
Key : third Value : 789
Interfejs ContentHandler zapewnia interfejs podobny do SAX do przesyłania strumieniowego dużych plików json. Zapewnia również możliwość zatrzymania. Poniższy przykład ilustruje tę koncepcję.
Przykład
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;
}
}
Wynik
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
Używając JSON.simple, możemy zakodować obiekt JSON na następujące sposoby -
Encode a JSON Object - to String - Proste kodowanie.
Encode a JSON Object - Streaming - Wyjście może być używane do przesyłania strumieniowego.
Encode a JSON Object - Using Map - Kodowanie poprzez zachowanie kolejności.
Encode a JSON Object - Using Map and Streaming - Kodowanie poprzez zachowanie kolejności i przesyłanie strumieniowe.
Poniższy przykład ilustruje powyższe koncepcje.
Przykład
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);
}
}
Wynik
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}
Używając JSON.simple, możemy zakodować tablicę JSON na następujące sposoby -
Encode a JSON Array - to String - Proste kodowanie.
Encode a JSON Array - Streaming - Wyjście może być używane do przesyłania strumieniowego.
Encode a JSON Array - Using List - Kodowanie przy użyciu listy.
Encode a JSON Array - Using List and Streaming - Kodowanie przy użyciu listy i do przesyłania strumieniowego.
Poniższy przykład ilustruje powyższe koncepcje.
Przykład
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);
}
}
Wynik
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]
W JSON.simple możemy łatwo połączyć dwa obiekty JSON przy użyciu metody JSONObject.putAll ().
Poniższy przykład ilustruje powyższą koncepcję.
Przykład
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);
}
}
Wynik
{"balance":1000.21,"is_vip":true,"num":100,"name":"foo"}
W JSON.simple możemy łatwo połączyć dwie tablice JSON za pomocą metody JSONArray.addAll ().
Poniższy przykład ilustruje powyższą koncepcję.
Przykład
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);
}
}
Wynik
["foo",100,1000.21,true,null]
Korzystając z obiektu JSONArray możemy stworzyć JSON składający się z prymitywów, obiektu i tablicy.
Poniższy przykład ilustruje powyższą koncepcję.
Przykład
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);
}
}
Wynik
{"list1":["foo",100],"balance":1000.21,"is_vip":true,"num":100,"list2":[1000.21,true,null],"name":"foo"}
Korzystając z obiektu JSONValue, możemy stworzyć JSON składający się z prymitywów, mapy i listy.
Poniższy przykład ilustruje powyższą koncepcję.
Przykład
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);
}
}
Wynik
[{"k11":"v11","k12":"v12","k13":"v13"},100]
Korzystając z obiektu JSONValue, możemy stworzyć JSON składający się z prymitywów, obiektu, mapy i listy.
Poniższy przykład ilustruje powyższą koncepcję.
Przykład
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);
}
}
Wynik
{"m1":{"k11":"v11","k12":"v12","k13":"v13"},"l1":[100]}
Możemy dostosować dane wyjściowe JSON na podstawie niestandardowej klasy. Jedynym wymaganiem jest implementacja interfejsu JSONAware.
Poniższy przykład ilustruje powyższą koncepcję.
Przykład
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();
}
}
Wynik
[{name:"Robert",rollNo:1},{name:"Julia",rollNo:2}]
Możemy dostosować dane wyjściowe przesyłania strumieniowego JSON na podstawie niestandardowej klasy. Jedynym wymaganiem jest implementacja interfejsu JSONStreamAware.
Poniższy przykład ilustruje powyższą koncepcję.
Przykład
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);
}
}
Wynik
[{name:"Robert",rollNo:1},{name:"Julia",rollNo:2}]