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