JSON.simple - Guía rápida

JSON.simplees un sencillo kit de herramientas basado en Java para JSON. Puede usar JSON.simple para codificar o decodificar datos JSON.

Caracteristicas

Specification Compliant - JSON.simple es totalmente compatible con la especificación JSON - RFC4627.
Lightweight - Tiene muy pocas clases y proporciona las funcionalidades necesarias como codificar / decodificar y escapar de json.
Reuses Collections - La mayoría de las operaciones se realizan mediante interfaces Mapa / Lista, lo que aumenta la reutilización.
Streaming supported - Admite la transmisión de texto de salida JSON.
SAX like Content Handler - Proporciona una interfaz similar a SAX para transmitir una gran cantidad de datos JSON.
High performance - Se utiliza un analizador basado en montón y proporciona un alto rendimiento.
No dependency- Sin dependencia de biblioteca externa. Se puede incluir de forma independiente.
JDK1.2 compatible - El código fuente y el binario son compatibles con JDK1.2

Configuración del entorno local

JSON.simple es una biblioteca para Java, por lo que el primer requisito es tener JDK instalado en su máquina.

Requisitos del sistema

JDK	Memoria	Espacio del disco	Sistema operativo
1,5 o superior.	Sin requisitos mínimos.	Sin requisitos mínimos.	Sin requisitos mínimos.

Paso 1: Verifique la instalación de Java en su máquina

En primer lugar, abra la consola y ejecute un comando java basado en el sistema operativo en el que está trabajando.

SO	Tarea	Mando
Ventanas	Abrir consola de comandos	c: \> java -version
Linux	Terminal de comando abierto	$ java -version
Mac	Terminal abierta	máquina: <joseph $ java -version

Verifiquemos la salida para todos los sistemas operativos:

SO	Salida
Ventanas	versión de Java "1.8.0_101" Entorno de ejecución Java (TM) SE (compilación 1.8.0_101)
Linux	versión de Java "1.8.0_101" Entorno de ejecución Java (TM) SE (compilación 1.8.0_101)
Mac	versión de Java "1.8.0_101" Entorno de ejecución Java (TM) SE (compilación 1.8.0_101)

Si no tiene Java instalado en su sistema, descargue Java Software Development Kit (SDK) desde el siguiente enlace www.oracle.com . Estamos asumiendo Java 1.8.0_101 como la versión instalada para este tutorial.

Paso 2: configurar el entorno JAVA

Selecciona el JAVA_HOMEvariable de entorno para apuntar a la ubicación del directorio base donde está instalado Java en su máquina. Por ejemplo.

SO	Salida
Ventanas	Establezca la variable de entorno JAVA_HOME en C: \ Archivos de programa \ Java \ jdk1.8.0_101
Linux	exportar JAVA_HOME = / usr / local / java-current
Mac	exportar JAVA_HOME = / Library / Java / Home

Agregue la ubicación del compilador de Java a la ruta del sistema.

SO	Salida
Ventanas	Añade la cadena C:\Program Files\Java\jdk1.8.0_101\bin al final de la variable del sistema, Path.
Linux	export PATH = $ PATH: $ JAVA_HOME / bin /
Mac	no requerido

Verifique la instalación de Java usando el comando java -version como se explicó anteriormente.

Paso 3: Descarga JSON.simple Archive

Descargue la última versión del archivo jar JSON.simple desde json-simple @ MVNRepository . En el momento de escribir este tutorial, hemos descargado json-simple-1.1.1.jar y lo hemos copiado en la carpeta C: \> JSON.

SO	Nombre de archivo
Ventanas	json-simple-1.1.1.jar
Linux	json-simple-1.1.1.jar
Mac	json-simple-1.1.1.jar

Paso 4: configurar el entorno JSON_JAVA

Selecciona el JSON_JAVAvariable de entorno para apuntar a la ubicación del directorio base donde JSON.simple jar se almacena en su máquina. Supongamos que hemos almacenado json-simple-1.1.1.jar en la carpeta JSON.

No Señor	SO y descripción
1	Windows Establezca la variable de entorno JSON_JAVA en C: \ JSON
2	Linux exportar JSON_JAVA = / usr / local / JSON
3	Mac exportar JSON_JAVA = / Library / JSON

Paso 5: Establecer la variable CLASSPATH

Selecciona el CLASSPATH variable de entorno para apuntar a la ubicación del jar JSON.simple.

No Señor	SO y descripción
1	Windows Establezca la variable de entorno CLASSPATH en% 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 mapea entidades del lado izquierdo al lado derecho mientras decodifica o analiza, y mapea entidades de derecha a izquierda mientras codifica.

JSON	Java
cuerda	java.lang.String
número	java.lang.Number
verdadero \| falso	java.lang.Boolean
nulo	nulo
formación	java.util.List
objeto	java.util.Map

Al decodificar, la clase concreta predeterminada de java.util.List es org.json.simple.JSONArray y la clase concreta predeterminada de java.util.Map es org.json.simple.JSONObject .

Los siguientes caracteres son caracteres reservados y no se pueden usar en JSON y se deben escapar correctamente para usarse en cadenas.

Backspace para ser reemplazado con \ b
Form feed para ser reemplazado con \ f
Newline para ser reemplazado por \ n
Carriage return para ser reemplazado con \ r
Tab para ser reemplazado con \ t
Double quote para ser reemplazado por \ "
Backslash para ser reemplazado con \\

JSONObject.escape()El método se puede utilizar para escapar de esas palabras clave reservadas en una cadena JSON. A continuación se muestra el ejemplo:

Ejemplo

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

Salida

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

JSONValue proporciona un método estático parse () para analizar la cadena json dada para devolver un JSONObject que luego se puede usar para analizar los valores. Vea el ejemplo a continuación.

Ejemplo

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

Salida

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 () arroja ParseException en caso de JSON no válido. El siguiente ejemplo muestra cómo manejar ParseException.

Ejemplo

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

Salida

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

ContainerFactory se puede utilizar para crear un contenedor personalizado para objetos / matrices JSON analizados. Primero necesitamos crear un objeto ContainerFactory y luego usarlo en el método de análisis de JSONParser para obtener el objeto requerido. Vea el ejemplo a continuación:

Ejemplo

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

Salida

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

La interfaz ContentHandler se utiliza para proporcionar una interfaz similar a SAX para transmitir el json grande. También proporciona una capacidad que se puede detener. El siguiente ejemplo ilustra el concepto.

Ejemplo

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

Salida

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, podemos codificar un objeto JSON usando las siguientes formas:

Encode a JSON Object - to String - Codificación simple.
Encode a JSON Object - Streaming - La salida se puede utilizar para la transmisión.
Encode a JSON Object - Using Map - Codificación conservando el orden.
Encode a JSON Object - Using Map and Streaming - Codificación conservando el orden y transmisión.

El siguiente ejemplo ilustra los conceptos anteriores.

Ejemplo

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

Salida

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}

Usando JSON.simple, podemos codificar una matriz JSON usando las siguientes formas:

Encode a JSON Array - to String - Codificación simple.
Encode a JSON Array - Streaming - La salida se puede utilizar para la transmisión.
Encode a JSON Array - Using List - Codificación utilizando la lista.
Encode a JSON Array - Using List and Streaming - Codificación usando List y para transmitir.

El siguiente ejemplo ilustra los conceptos anteriores.

Ejemplo

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