JSON.simple - Guida rapida

JSON.simpleè un semplice toolkit basato su Java per JSON. Puoi utilizzare JSON.simple per codificare o decodificare i dati JSON.

Caratteristiche

Specification Compliant - JSON.simple è completamente conforme alla specifica JSON - RFC4627.
Lightweight - Ha pochissime classi e fornisce le funzionalità necessarie come codifica / decodifica e json di escape.
Reuses Collections - La maggior parte delle operazioni vengono eseguite utilizzando le interfacce Map / List aumentando la riutilizzabilità.
Streaming supported - Supporta lo streaming del testo di output JSON.
SAX like Content Handler - Fornisce un'interfaccia simile a SAX per lo streaming di grandi quantità di dati JSON.
High performance - Viene utilizzato un parser basato su heap e fornisce prestazioni elevate.
No dependency- Nessuna dipendenza da libreria esterna. Può essere incluso indipendentemente.
JDK1.2 compatible - Il codice sorgente e il binario sono compatibili con JDK1.2

Configurazione dell'ambiente locale

JSON.simple è una libreria per Java, quindi il primo requisito è che JDK sia installato sulla tua macchina.

Requisito del sistema

JDK	Memoria	Spazio sul disco	Sistema operativo
1.5 o superiore.	Nessun requisito minimo.	Nessun requisito minimo.	Nessun requisito minimo.

Passaggio 1: verifica l'installazione di Java sulla macchina

Prima di tutto, apri la console ed esegui un comando java basato sul sistema operativo su cui stai lavorando.

OS	Compito	Comando
finestre	Apri la Console di comando	c: \> java -version
Linux	Apri Terminale di comando	$ java -version
Mac	Apri Terminale	macchina: <joseph $ java -version

Verifichiamo l'output per tutti i sistemi operativi -

OS	Produzione
finestre	versione java "1.8.0_101" Java (TM) SE Runtime Environment (build 1.8.0_101)
Linux	versione java "1.8.0_101" Java (TM) SE Runtime Environment (build 1.8.0_101)
Mac	versione java "1.8.0_101" Java (TM) SE Runtime Environment (build 1.8.0_101)

Se non hai Java installato sul tuo sistema, scarica il Java Software Development Kit (SDK) dal seguente collegamento www.oracle.com . Stiamo assumendo Java 1.8.0_101 come versione installata per questo tutorial.

Passaggio 2: impostare l'ambiente JAVA

Impostare il JAVA_HOMEvariabile di ambiente in modo che punti alla posizione della directory di base in cui Java è installato sulla macchina. Per esempio.

OS	Produzione
finestre	Imposta la variabile d'ambiente JAVA_HOME su C: \ Program Files \ Java \ jdk1.8.0_101
Linux	export JAVA_HOME = / usr / local / java-current
Mac	export JAVA_HOME = / Library / Java / Home

Aggiungi la posizione del compilatore Java al percorso di sistema.

OS	Produzione
finestre	Aggiungi la stringa C:\Program Files\Java\jdk1.8.0_101\bin alla fine della variabile di sistema, Path.
Linux	export PATH = $ PATH: $ JAVA_HOME / bin /
Mac	non richiesto

Verifica l'installazione di Java utilizzando il comando java -version come spiegato sopra.

Passaggio 3: scarica JSON.simple Archive

Scarica l'ultima versione del file jar JSON.simple da json-simple @ MVNRepository . Al momento della stesura di questo tutorial, abbiamo scaricato json-simple-1.1.1.jar e copiato nella cartella C: \> JSON.

OS	Nome dell'archivio
finestre	json-simple-1.1.1.jar
Linux	json-simple-1.1.1.jar
Mac	json-simple-1.1.1.jar

Passaggio 4: impostare l'ambiente JSON_JAVA

Impostare il JSON_JAVAvariabile di ambiente in modo che punti alla posizione della directory di base in cui JSON.simple jar è archiviato sulla macchina. Supponiamo di aver archiviato json-simple-1.1.1.jar nella cartella JSON.

Suor n	Sistema operativo e descrizione
1	Windows Imposta la variabile d'ambiente JSON_JAVA su C: \ JSON
2	Linux esporta JSON_JAVA = / usr / local / JSON
3	Mac esporta JSON_JAVA = / Library / JSON

Passaggio 5: impostare la variabile CLASSPATH

Impostare il CLASSPATH variabile di ambiente in modo che punti alla posizione del jar JSON.simple.

Suor n	Sistema operativo e descrizione
1	Windows Imposta la variabile d'ambiente CLASSPATH su% 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 mappa le entità dal lato sinistro al lato destro durante la decodifica o l'analisi e mappa le entità da destra a sinistra durante la codifica.

JSON	Giava
corda	java.lang.String
numero	java.lang.Number
vero \| falso	java.lang.Boolean
nullo	nullo
Vettore	java.util.List
oggetto	java.util.Map

Sulla decodifica, la classe concreta predefinita di java.util.List è org.json.simple.JSONArray e la classe concreta predefinita di java.util.Map è org.json.simple.JSONObject .

I seguenti caratteri sono caratteri riservati e non possono essere utilizzati in JSON e devono essere adeguatamente sottoposti a escape per essere utilizzati nelle stringhe.

Backspace da sostituire con \ b
Form feed da sostituire con \ f
Newline da sostituire con \ n
Carriage return da sostituire con \ r
Tab da sostituire con \ t
Double quote da sostituire con \ "
Backslash da sostituire con \\

JSONObject.escape()può essere utilizzato per sfuggire a tali parole chiave riservate in una stringa JSON. Di seguito è riportato l'esempio:

Esempio

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

Produzione

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

JSONValue fornisce un metodo statico parse () per analizzare la stringa json data per restituire un JSONObject che può quindi essere utilizzato per ottenere i valori analizzati. Vedi l'esempio sotto.

Esempio

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

Produzione

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 () genera ParseException in caso di JSON non valido. L'esempio seguente mostra come gestire ParseException.

Esempio

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

Produzione

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

ContainerFactory può essere utilizzato per creare container personalizzati per oggetti / array JSON analizzati. Per prima cosa dobbiamo creare un oggetto ContainerFactory e quindi usarlo nel metodo di analisi di JSONParser per ottenere l'oggetto richiesto. Guarda l'esempio di seguito -

Esempio

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

Produzione

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

L'interfaccia ContentHandler viene utilizzata per fornire un'interfaccia simile a SAX per lo streaming del json di grandi dimensioni. Fornisce anche capacità bloccabili. L'esempio seguente illustra il concetto.

Esempio

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

Produzione

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

Usando JSON.simple, possiamo codificare un oggetto JSON usando i seguenti modi:

Encode a JSON Object - to String - Codifica semplice.
Encode a JSON Object - Streaming - L'output può essere utilizzato per lo streaming.
Encode a JSON Object - Using Map - Codifica preservando l'ordine.
Encode a JSON Object - Using Map and Streaming - Codifica preservando l'ordine e lo streaming.

L'esempio seguente illustra i concetti di cui sopra.

Esempio

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

Produzione

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}

Utilizzando JSON.simple, possiamo codificare un array JSON utilizzando i seguenti modi:

Encode a JSON Array - to String - Codifica semplice.
Encode a JSON Array - Streaming - L'output può essere utilizzato per lo streaming.
Encode a JSON Array - Using List - Codifica utilizzando l'elenco.
Encode a JSON Array - Using List and Streaming - Codifica utilizzando List e per lo streaming.

L'esempio seguente illustra i concetti di cui sopra.

Esempio

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

Produzione

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, possiamo unire facilmente due oggetti JSON utilizzando il metodo JSONObject.putAll ().