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 : 789Interfejs 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 endJSONUż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}]