Exemple Java JSON

Tutoriels
Java

Bienvenue dans le tutoriel de l’exemple Java JSON. JSON (JavaScript Object Notation) est une technologie légère basée sur du texte pour générer des données formatées lisibles par l’homme. JSON représente des données d’objet sous forme de paires clé-valeur. Nous pouvons également avoir des objets JSON imbriqués et il fournit un moyen facile de représenter des tableaux.

Java JSON

JSON est largement utilisé dans les applications web ou en tant que réponse du serveur car il est léger et plus compact que XML. Les objets JSON sont faciles à lire et à écrire et la plupart des technologies prennent en charge les objets JSON. C’est pourquoi JSON dans les services web Java est très populaire. JSR353 a finalement été intégré à Java EE 7 et c’est l’API de traitement JSON de Java. jsonp est l’implémentation de référence pour l’API de traitement JSON de Java. Nous pouvons l’utiliser dans un projet Maven en ajoutant la dépendance suivante.

<dependency>
	<groupId>org.glassfish</groupId>
  	<artifactId>javax.json</artifactId>
  	<version>1.0.2</version>
</dependency>

Si vous utilisez GlassFish 4.0, vous pouvez conserver la portée comme « fournie » car elle est déjà incluse dans le serveur. L’API JSON offre deux façons de traiter le JSON :

  1. API du modèle d’objet – C’est similaire à un parseur DOM et convient aux petits objets.
  2. API de diffusion en continu – Il est similaire à StaX Parser et convient aux gros objets où vous ne voulez pas conserver l’ensemble de l’objet en mémoire.

Quelques interfaces importantes de l’API JSON de Java sont:

  1. javax.json.JsonReader: Nous pouvons utiliser ceci pour lire un objet JSON ou un tableau en JsonObject. Nous pouvons obtenir JsonReader à partir de la classe Json ou JsonReaderFactory.
  2. javax.json.JsonWriter: Nous pouvons utiliser ceci pour écrire un objet JSON dans un flux de sortie.
  3. javax.json.stream.JsonParser: Cela fonctionne comme un analyseur par tirage et fournit une prise en charge du streaming pour la lecture d’objets JSON.
  4. javax.json.stream.JsonGenerator: Nous pouvons utiliser ceci pour écrire un objet JSON dans une source de sortie de manière continue.
  5. javax.json.Json: C’est la classe d’usine pour la création d’objets de traitement JSON. Cette classe fournit les méthodes les plus couramment utilisées pour créer ces objets et leurs usines correspondantes. Les classes d’usine fournissent toutes les différentes façons de créer ces objets.
  6. javax.json.JsonObject: JsonObject représente une valeur d’objet JSON immuable.

Examinons l’utilisation de l’API JSON de Java avec un programme simple, nous avons un objet JSON stocké dans un fichier employee.txt comme suit;

{
	"id":123,
	"name":"Pankaj Kumar",
	"permanent":true,
	"address":{
			"street":"El Camino Real",
			"city":"San Jose",
			"zipcode":95014
		},
	"phoneNumbers":[9988664422, 1234567890],
	"role":"Developer"
}

Nous avons des classes de bean Java qui représentent le format JSON ci-dessus comme suit:

package com.journaldev.model;

import java.util.Arrays;

public class Employee {

	private int id;
	private String name;
	private boolean permanent;
	private Address address;
	private long[] phoneNumbers;
	private String role;
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public boolean isPermanent() {
		return permanent;
	}
	public void setPermanent(boolean permanent) {
		this.permanent = permanent;
	}
	public Address getAddress() {
		return address;
	}
	public void setAddress(Address address) {
		this.address = address;
	}
	public long[] getPhoneNumbers() {
		return phoneNumbers;
	}
	public void setPhoneNumbers(long[] phoneNumbers) {
		this.phoneNumbers = phoneNumbers;
	}
	public String getRole() {
		return role;
	}
	public void setRole(String role) {
		this.role = role;
	}
	
	@Override
	public String toString(){
		StringBuilder sb = new StringBuilder();
		sb.append("***** Employee Details *****\n");
		sb.append("ID="+getId()+"\n");
		sb.append("Name="+getName()+"\n");
		sb.append("Permanent="+isPermanent()+"\n");
		sb.append("Role="+getRole()+"\n");
		sb.append("Phone Numbers="+Arrays.toString(getPhoneNumbers())+"\n");
		sb.append("Address="+getAddress());
		sb.append("\n*****************************");
		
		return sb.toString();
	}
}

package com.journaldev.model;

public class Address {
	
	private String street;
	private String city;
	private int zipcode;
	
	public String getStreet() {
		return street;
	}
	public void setStreet(String street) {
		this.street = street;
	}
	public String getCity() {
		return city;
	}
	public void setCity(String city) {
		this.city = city;
	}
	public int getZipcode() {
		return zipcode;
	}
	public void setZipcode(int zipcode) {
		this.zipcode = zipcode;
	}
	
	@Override
	public String toString(){
		return getStreet() + ", "+getCity()+", "+getZipcode();
	}
}

I have overridden the toString() method to return human readable String representation that we will use in our JSON implementation classes.

Exemple de lecture JSON en Java

package com.journaldev.json;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

import javax.json.Json;
import javax.json.JsonArray;
import javax.json.JsonObject;
import javax.json.JsonReader;
import javax.json.JsonValue;

import com.journaldev.model.Address;
import com.journaldev.model.Employee;

public class EmployeeJSONReader {

	public static final String JSON_FILE="employee.txt";
	
	public static void main(String[] args) throws IOException {
		InputStream fis = new FileInputStream(JSON_FILE);
		
		//créer un objet JsonReader
		JsonReader jsonReader = Json.createReader(fis);
		
		/**
		 * We can create JsonReader from Factory also
		JsonReaderFactory factory = Json.createReaderFactory(null);
		jsonReader = factory.createReader(fis);
		*/
		
		//obtenir JsonObject à partir de JsonReader
		JsonObject jsonObject = jsonReader.readObject();
		
		//nous pouvons maintenant fermer la ressource IO et JsonReader
		jsonReader.close();
		fis.close();
		
		//Récupérer les données de JsonObject et créer un objet Employee
		Employee emp = new Employee();
		
		emp.setId(jsonObject.getInt("id"));
		emp.setName(jsonObject.getString("name"));
		emp.setPermanent(jsonObject.getBoolean("permanent"));
		emp.setRole(jsonObject.getString("role"));
		
		//lecture des tableaux à partir de json
		JsonArray jsonArray = jsonObject.getJsonArray("phoneNumbers");
		long[] numbers = new long[jsonArray.size()];
		int index = 0;
		for(JsonValue value : jsonArray){
			numbers[index++] = Long.parseLong(value.toString());
		}
		emp.setPhoneNumbers(numbers);
		
		//lecture de l'objet interne de l'objet json
		JsonObject innerJsonObject = jsonObject.getJsonObject("address");
		Address address = new Address();
		address.setStreet(innerJsonObject.getString("street"));
		address.setCity(innerJsonObject.getString("city"));
		address.setZipcode(innerJsonObject.getInt("zipcode"));
		emp.setAddress(address);
		
		//imprimer les informations de l'objet employé
		System.out.println(emp);
		
	}

}

L’implémentation est simple et semble similaire à l’obtention de paramètres à partir d’une HashMap. JsonReaderFactory implémente le modèle de conception Factory. Une fois que nous exécutons le programme ci-dessus, nous obtenons la sortie suivante.

***** Employee Details *****
ID=123
Name=Pankaj Kumar
Permanent=true
Role=Developer
Phone Numbers=[9988664422, 1234567890]
Address=El Camino Real, San Jose, 95014
*****************************

Exemple d’écriture JSON en Java

package com.journaldev.json;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.OutputStream;

import javax.json.Json;
import javax.json.JsonArrayBuilder;
import javax.json.JsonObject;
import javax.json.JsonObjectBuilder;
import javax.json.JsonWriter;

import com.journaldev.model.Address;
import com.journaldev.model.Employee;

public class EmployeeJSONWriter {

	public static void main(String[] args) throws FileNotFoundException {

		Employee emp = createEmployee();

		JsonObjectBuilder empBuilder = Json.createObjectBuilder();
		JsonObjectBuilder addressBuilder = Json.createObjectBuilder();
		JsonArrayBuilder phoneNumBuilder = Json.createArrayBuilder();

		for (long phone : emp.getPhoneNumbers()) {
			phoneNumBuilder.add(phone);
		}
		
		addressBuilder.add("street", emp.getAddress().getStreet())
						.add("city", emp.getAddress().getCity())
							.add("zipcode", emp.getAddress().getZipcode());
		
		empBuilder.add("id", emp.getId())
					.add("name", emp.getName())
						.add("permanent", emp.isPermanent())
							.add("role", emp.getRole());
		
		empBuilder.add("phoneNumbers", phoneNumBuilder);
		empBuilder.add("address", addressBuilder);
		
		JsonObject empJsonObject = empBuilder.build();
		
		System.out.println("Employee JSON String\n"+empJsonObject);
		
		//écrire dans un fichier
		OutputStream os = new FileOutputStream("emp.txt");
		JsonWriter jsonWriter = Json.createWriter(os);
		/**
		 * We can get JsonWriter from JsonWriterFactory also
		JsonWriterFactory factory = Json.createWriterFactory(null);
		jsonWriter = factory.createWriter(os);
		*/
		jsonWriter.writeObject(empJsonObject);
		jsonWriter.close();
	}
	

	public static Employee createEmployee() {

		Employee emp = new Employee();
		emp.setId(100);
		emp.setName("David");
		emp.setPermanent(false);
		emp.setPhoneNumbers(new long[] { 123456, 987654 });
		emp.setRole("Manager");

		Address add = new Address();
		add.setCity("Bangalore");
		add.setStreet("BTM 1st Stage");
		add.setZipcode(560100);
		emp.setAddress(add);

		return emp;
	}

}

Une fois que nous exécutons l’application ci-dessus, nous obtenons la réponse suivante :

Employee JSON String
{"id":100,"name":"David","permanent":false,"role":"Manager","phoneNumbers":[123456,987654],"address":{"street":"BTM 1st Stage","city":"Bangalore","zipcode":560100}}

L’objet JSON est également enregistré dans le fichier emp.txt. JsonObjectBuilder implémente le modèle de construction qui le rend très facile à utiliser.

Exemple de parseur JSON Java

Le parseur Java JsonParser est un analyseur à tirage et nous lisons l’élément suivant avec la méthode next() qui renvoie un objet Event. javax.json.stream.JsonParser.Event est un Enum qui le rend sûr et facile à utiliser. Nous pouvons l’utiliser dans switch case pour définir les propriétés de notre bean java.

package com.journaldev.json;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;

import javax.json.Json;
import javax.json.stream.JsonParser;
import javax.json.stream.JsonParser.Event;

import com.journaldev.model.Address;
import com.journaldev.model.Employee;

public class EmployeeJSONParser {

	public static final String FILE_NAME = "employee.txt";

	public static void main(String[] args) throws IOException {
		InputStream fis = new FileInputStream(FILE_NAME);

		JsonParser jsonParser = Json.createParser(fis);

		/**
		 * We can create JsonParser from JsonParserFactory also with below code
		 * JsonParserFactory factory = Json.createParserFactory(null);
		 * jsonParser = factory.createParser(fis);
		 */

		Employee emp = new Employee();
		Address address = new Address();
		String keyName = null;
		List phoneNums = new ArrayList();
		
		while (jsonParser.hasNext()) {
			Event event = jsonParser.next();
			switch (event) {
			case KEY_NAME:
				keyName = jsonParser.getString();
				break;
			case VALUE_STRING:
				setStringValues(emp, address, keyName, jsonParser.getString());
				break;
			case VALUE_NUMBER:
				setNumberValues(emp, address, keyName, jsonParser.getLong(), phoneNums);
				break;
			case VALUE_FALSE:
				setBooleanValues(emp, address, keyName, false);
				break;
			case VALUE_TRUE:
				setBooleanValues(emp, address, keyName, true);
				break;
			case VALUE_NULL:
				// ne rien définir
				break;
			default:
				// nous ne recherchons pas d'autres événements
			}
		}
		emp.setAddress(address);
		long[] nums = new long[phoneNums.size()];
		int index = 0;
		for(Long l :phoneNums){
			nums[index++] = l;
		}
		emp.setPhoneNumbers(nums);
		
		System.out.println(emp);
		
		//fermer les ressources
		fis.close();
		jsonParser.close();
	}

	private static void setNumberValues(Employee emp, Address address,
			String keyName, long value, List phoneNums) {
		switch(keyName){
		case "zipcode":
			address.setZipcode((int)value);
			break;
		case "id":
			emp.setId((int) value);
			break;
		case "phoneNumbers":
			phoneNums.add(value);
			break;
		default:
			System.out.println("Unknown element with key="+keyName);	
		}
	}

	private static void setBooleanValues(Employee emp, Address address,
			String key, boolean value) {
		if("permanent".equals(key)){
			emp.setPermanent(value);
		}else{
			System.out.println("Unknown element with key="+key);
		}
	}

	private static void setStringValues(Employee emp, Address address,
			String key, String value) {
		switch(key){
		case "name":
			emp.setName(value);
			break;
		case "role":
			emp.setRole(value);
			break;
		case "city":
			address.setCity(value);
			break;
		case "street":
			address.setStreet(value);
			break;
		default:
			System.out.println("Unknown Key="+key);
				
		}
	}

}

La complexité majeure survient lorsque nous devons écrire la logique pour analyser les données et parfois cela peut devenir complexe. Étant donné que nous lisons le même fichier que JsonReader, la sortie est la même que le programme EmployeeJsonReader.

Exemple de générateur JSON Java

package com.journaldev.json;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

import javax.json.Json;
import javax.json.stream.JsonGenerator;

import com.journaldev.model.Employee;

public class EmployeeJSONGenerator {

	public static void main(String[] args) throws IOException {
		OutputStream fos = new FileOutputStream("emp_stream.txt");
		JsonGenerator jsonGenerator = Json.createGenerator(fos);
		/**
		 * We can get JsonGenerator from Factory class also
		 * JsonGeneratorFactory factory = Json.createGeneratorFactory(null);
		 * jsonGenerator = factory.createGenerator(fos);
		 */
		
		Employee emp = EmployeeJSONWriter.createEmployee();
		jsonGenerator.writeStartObject(); // {
		jsonGenerator.write("id", emp.getId()); // "id":123
		jsonGenerator.write("name", emp.getName());
		jsonGenerator.write("role", emp.getRole());
		jsonGenerator.write("permanent", emp.isPermanent());
		
		jsonGenerator.writeStartObject("address") //start of address object
			.write("street", emp.getAddress().getStreet())
			.write("city",emp.getAddress().getCity())
			.write("zipcode",emp.getAddress().getZipcode())
			.writeEnd(); //end of address object
		
		jsonGenerator.writeStartArray("phoneNumbers"); //start of phone num array
		for(long num : emp.getPhoneNumbers()){
			jsonGenerator.write(num);
		}
		jsonGenerator.writeEnd(); // end of phone num array
		jsonGenerator.writeEnd(); // }
		
		jsonGenerator.close();
		
	}

}

JsonGenerator est très facile à utiliser et offre de bonnes performances pour les données volumineuses. C’est tout pour l’API de traitement JSON en Java. Nous avons appris les exemples de parseur, de lecture et d’écriture de JSON en Java. Vous pouvez télécharger le projet java depuis le lien ci-dessous et y jouer.

Télécharger le projet Java JSON

Références: JSONLint – Excellent outil web pour valider les données JSON Implémentation de référence du traitement JSON Page JCP JSR353

Source:
https://www.digitalocean.com/community/tutorials/java-json-example