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