JSON.simple - Guia rápido

JSON.simpleé um kit de ferramentas simples baseado em Java para JSON. Você pode usar JSON.simple para codificar ou decodificar dados JSON.

Características

  • Specification Compliant - JSON.simple é totalmente compatível com a especificação JSON - RFC4627.

  • Lightweight - Tem muito poucas classes e fornece as funcionalidades necessárias como codificar / decodificar e escapar de json.

  • Reuses Collections - A maioria das operações são feitas usando interfaces de Mapa / Lista aumentando a capacidade de reutilização.

  • Streaming supported - Suporta streaming de texto de saída JSON.

  • SAX like Content Handler - Fornece uma interface semelhante a SAX para transmitir uma grande quantidade de dados JSON.

  • High performance - O analisador baseado em heap é usado e fornece alto desempenho.

  • No dependency- Sem dependência de biblioteca externa. Pode ser incluído de forma independente.

  • JDK1.2 compatible - O código-fonte e o binário são compatíveis com JDK1.2

Configuração de ambiente local

JSON.simple é uma biblioteca para Java, então o primeiro requisito é ter o JDK instalado em sua máquina.

Requisitos do sistema

JDK Memória Espaço em disco Sistema operacional
1,5 ou superior. Sem requisitos mínimos. Sem requisitos mínimos. Sem requisitos mínimos.

Etapa 1: verifique a instalação do Java em sua máquina

Em primeiro lugar, abra o console e execute um comando java baseado no sistema operacional em que está trabalhando.

SO Tarefa Comando
janelas Abrir console de comando c: \> versão java
Linux Abra o terminal de comando $ java -version
Mac Terminal aberto máquina: <joseph $ java -version

Vamos verificar a saída de todos os sistemas operacionais -

SO Resultado
janelas

versão java "1.8.0_101"

Java (TM) SE Runtime Environment (build 1.8.0_101)

Linux

versão java "1.8.0_101"

Java (TM) SE Runtime Environment (build 1.8.0_101)

Mac

versão java "1.8.0_101"

Java (TM) SE Runtime Environment (build 1.8.0_101)

Se você não tiver o Java instalado em seu sistema, faça download do Java Software Development Kit (SDK) no seguinte link www.oracle.com . Estamos assumindo o Java 1.8.0_101 como a versão instalada para este tutorial.

Etapa 2: definir o ambiente JAVA

Colocou o JAVA_HOMEvariável de ambiente para apontar para o local do diretório base onde o Java está instalado em sua máquina. Por exemplo.

SO Resultado
janelas Defina a variável de ambiente JAVA_HOME para C: \ Program Files \ Java \ jdk1.8.0_101
Linux export JAVA_HOME = / usr / local / java-current
Mac export JAVA_HOME = / Library / Java / Home

Anexe a localização do compilador Java ao caminho do sistema.

SO Resultado
janelas Anexar a string C:\Program Files\Java\jdk1.8.0_101\bin no final da variável do sistema, Path.
Linux exportar PATH = $ PATH: $ JAVA_HOME / bin /
Mac não requerido

Verifique a instalação do Java usando o comando java -version conforme explicado acima.

Etapa 3: Baixe o arquivo JSON.simple

Baixe a versão mais recente do arquivo JSON.simple jar de json-simple @ MVNRepository . No momento de escrever este tutorial, baixamos json-simple-1.1.1.jar e o copiamos para a pasta C: \> JSON.

SO Nome do arquivo
janelas json-simple-1.1.1.jar
Linux json-simple-1.1.1.jar
Mac json-simple-1.1.1.jar

Etapa 4: definir o ambiente JSON_JAVA

Colocou o JSON_JAVAvariável de ambiente para apontar para o local do diretório base onde JSON.simple jar está armazenado em sua máquina. Vamos supor que armazenamos json-simple-1.1.1.jar na pasta JSON.

Sr. Não SO e descrição
1

Windows

Defina a variável de ambiente JSON_JAVA para C: \ JSON

2

Linux

export JSON_JAVA = / usr / local / JSON

3

Mac

export JSON_JAVA = / Library / JSON

Etapa 5: definir a variável CLASSPATH

Colocou o CLASSPATH variável de ambiente para apontar para o local do jar JSON.simple.

Sr. Não SO e descrição
1

Windows

Defina a variável de ambiente CLASSPATH como% 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 mapeia entidades do lado esquerdo para o lado direito durante a decodificação ou análise, e mapeia entidades da direita para a esquerda durante a codificação.

JSON Java
corda java.lang.String
número java.lang.Number
verdadeiro | falso java.lang.Boolean
nulo nulo
matriz java.util.List
objeto java.util.Map

Na decodificação, a classe concreta padrão de java.util.List é org.json.simple.JSONArray e a classe concreta padrão de java.util.Map é org.json.simple.JSONObject .

Os caracteres a seguir são reservados e não podem ser usados ​​em JSON e devem ter o escape adequado para serem usados ​​em strings.

  • Backspace a ser substituído por \ b

  • Form feed a ser substituído por \ f

  • Newline a ser substituído por \ n

  • Carriage return a ser substituído por \ r

  • Tab a ser substituído por \ t

  • Double quote a ser substituído por \ "

  • Backslash a ser substituído por \\

JSONObject.escape()método pode ser usado para escapar dessas palavras-chave reservadas em uma string JSON. A seguir está o exemplo -

Exemplo

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

Resultado

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

JSONValue fornece um método estático parse () para analisar a string json fornecida para retornar um JSONObject que pode então ser usado para obter os valores analisados. Veja o exemplo abaixo.

Exemplo

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

Resultado

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 () lança ParseException no caso de JSON inválido. O exemplo a seguir mostra como lidar com ParseException.

Exemplo

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

Resultado

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

A ContainerFactory pode ser usada para criar um contêiner personalizado para objetos / matrizes JSON analisados. Primeiro, precisamos criar um objeto ContainerFactory e, em seguida, usá-lo no método de análise de JSONParser para obter o objeto necessário. Veja o exemplo abaixo -

Exemplo

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

Resultado

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

A interface ContentHandler é usada para fornecer uma interface semelhante a SAX para transmitir o grande json. Ele também oferece capacidade de parar. O exemplo a seguir ilustra o conceito.

Exemplo

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

Resultado

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 um objeto JSON usando as seguintes maneiras -

  • Encode a JSON Object - to String - Codificação simples.

  • Encode a JSON Object - Streaming - A saída pode ser usada para streaming.

  • Encode a JSON Object - Using Map - Codificação preservando a ordem.

  • Encode a JSON Object - Using Map and Streaming - Codificação preservando a ordem e a transmissão.

O exemplo a seguir ilustra os conceitos acima.

Exemplo

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

Resultado

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 um array JSON usando as seguintes maneiras -

  • Encode a JSON Array - to String - Codificação simples.

  • Encode a JSON Array - Streaming - A saída pode ser usada para streaming.

  • Encode a JSON Array - Using List - Codificação usando a lista.

  • Encode a JSON Array - Using List and Streaming - Codificação usando List e to stream.

O exemplo a seguir ilustra os conceitos acima.

Exemplo

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

Resultado

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]

Em JSON.simple, podemos mesclar dois objetos JSON facilmente usando o método JSONObject.putAll ().

O exemplo a seguir ilustra o conceito acima.

Exemplo

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

Resultado

{"balance":1000.21,"is_vip":true,"num":100,"name":"foo"}

Em JSON.simple, podemos mesclar dois Arrays JSON facilmente usando o método JSONArray.addAll ().

O exemplo a seguir ilustra o conceito acima.

Exemplo

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

Resultado

["foo",100,1000.21,true,null]

Usando o objeto JSONArray, podemos criar um JSON que compreende primitivos, objeto e array.

O exemplo a seguir ilustra o conceito acima.

Exemplo

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

Resultado

{"list1":["foo",100],"balance":1000.21,"is_vip":true,"num":100,"list2":[1000.21,true,null],"name":"foo"}

Usando o objeto JSONValue, podemos criar um JSON que é composto por primitivos, Mapa e Lista.

O exemplo a seguir ilustra o conceito acima.

Exemplo

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

Resultado

[{"k11":"v11","k12":"v12","k13":"v13"},100]

Usando o objeto JSONValue, podemos criar um JSON que é composto por primitivos, Objeto, Mapa e Lista.

O exemplo a seguir ilustra o conceito acima.

Exemplo

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

Resultado

{"m1":{"k11":"v11","k12":"v12","k13":"v13"},"l1":[100]}

Podemos personalizar a saída JSON com base na classe personalizada. O único requisito é implementar a interface JSONAware.

O exemplo a seguir ilustra o conceito acima.

Exemplo

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

Resultado

[{name:"Robert",rollNo:1},{name:"Julia",rollNo:2}]

Podemos personalizar a saída de streaming JSON com base na classe personalizada. O único requisito é implementar a interface JSONStreamAware.

O exemplo a seguir ilustra o conceito acima.

Exemplo

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

Resultado

[{name:"Robert",rollNo:1},{name:"Julia",rollNo:2}]