Java JSON Beispiel

Tutorials
Java

Willkommen zum Java JSON Beispiel Tutorial. JSON (JavaScript Object Notation) ist eine textbasierte, leichte Technologie zur Generierung von menschenlesbaren formatierten Daten. JSON repräsentiert Objektdaten in Form von Schlüssel-Wert-Paaren. Wir können auch verschachtelte JSON-Objekte haben, und es bietet eine einfache Möglichkeit, Arrays darzustellen.

Java JSON

JSON wird weitgehend in Webanwendungen oder als Serverantwort verwendet, weil es leichtgewichtig ist und kompakter als XML. JSON-Objekte sind einfach zu lesen und zu schreiben, und die meisten Technologien unterstützen JSON-Objekte. Deshalb sind JSON in Java-Webdiensten sehr beliebt. JSR353 hat es schließlich in Java EE 7 geschafft, und es ist die Java JSON-Verarbeitungs-API. jsonp ist die Referenzimplementierung für die Java JSON-Verarbeitungs-API. Wir können dies in einem Maven-Projekt verwenden, indem wir die folgende Abhängigkeit hinzufügen.

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

Wenn Sie GlassFish 4.0 verwenden, können Sie den Scope als „provided“ belassen, da es bereits im Server enthalten ist. Die JSON-API bietet zwei Möglichkeiten zur JSON-Verarbeitung:

  1. Objektmodell-API – Es ist ähnlich dem DOM-Parser und gut für kleine Objekte.
  2. Streaming API – Es ist ähnlich wie der StaX Parser und gut für große Objekte, bei denen Sie nicht das gesamte Objekt im Speicher behalten möchten.

Einige wichtige Schnittstellen der Java JSON-API sind:

  1. javax.json.JsonReader: Wir können dies verwenden, um ein JSON-Objekt oder ein Array in JsonObject zu lesen. Wir können JsonReader von der Json-Klasse oder JsonReaderFactory erhalten.
  2. javax.json.JsonWriter: Wir können dies verwenden, um ein JSON-Objekt in einen Ausgabestrom zu schreiben.
  3. javax.json.stream.JsonParser: Dies funktioniert als Pull-Parser und bietet Streaming-Unterstützung zum Lesen von JSON-Objekten.
  4. javax.json.stream.JsonGenerator: Wir können dies verwenden, um ein JSON-Objekt in einer Streaming-Weise an die Ausgabequelle zu schreiben.
  5. javax.json.Json: Dies ist die Fabrikkasse zum Erstellen von JSON-Verarbeitungsobjekten. Diese Klasse bietet die am häufigsten verwendeten Methoden zum Erstellen dieser Objekte und ihrer entsprechenden Fabriken. Die Fabrikklassen bieten alle verschiedenen Möglichkeiten, diese Objekte zu erstellen.
  6. javax.json.JsonObject: JsonObject repräsentiert einen unveränderlichen JSON-Objektwert.

Schauen wir uns die Verwendung der Java JSON-API mit einem einfachen Programm an, wir haben ein JSON-Objekt, das in einer Datei employee.txt gespeichert ist;

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

Wir haben Java-Bean-Klassen, die das obige JSON-Format darstellen.

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.

Java JSON Lesebeispiel

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);
		
		//JsonReader-Objekt erstellen
		JsonReader jsonReader = Json.createReader(fis);
		
		/**
		 * We can create JsonReader from Factory also
		JsonReaderFactory factory = Json.createReaderFactory(null);
		jsonReader = factory.createReader(fis);
		*/
		
		//JsonObject von JsonReader abrufen
		JsonObject jsonObject = jsonReader.readObject();
		
		//Wir können IO-Ressourcen und JsonReader jetzt schließen
		jsonReader.close();
		fis.close();
		
		//Daten aus JsonObject abrufen und Employee-Bean erstellen
		Employee emp = new Employee();
		
		emp.setId(jsonObject.getInt("id"));
		emp.setName(jsonObject.getString("name"));
		emp.setPermanent(jsonObject.getBoolean("permanent"));
		emp.setRole(jsonObject.getString("role"));
		
		//Lesen von Arrays aus 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);
		
		//Lesen von Inner-Object aus Json-Objekt
		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);
		
		//Mitarbeiter-Bean-Informationen ausgeben
		System.out.println(emp);
		
	}

}

Die Implementierung ist geradlinig und fühlt sich ähnlich an wie das Abrufen von Parametern aus HashMap. JsonReaderFactory implementiert das Factory Design Pattern. Sobald wir das obige Programm ausführen, erhalten wir folgende Ausgabe.

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

Java JSON Schreibbeispiel

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);
		
		//In Datei schreiben
		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;
	}

}

Nachdem wir die obige Anwendung ausgeführt haben, erhalten wir folgende Antwort:

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

Das JSON-Objekt wird auch in der Datei emp.txt gespeichert. JsonObjectBuilder implementiert das Builder-Muster, das es sehr einfach zu verwenden macht.

Java JSON Parser Beispiel

Java JsonParser ist ein Pull-Parser, und wir lesen das nächste Element mit der Methode next(), die ein Ereignisobjekt zurückgibt. javax.json.stream.JsonParser.Event ist ein Enum, das es typsicher und einfach zu verwenden macht. Wir können es in switch case verwenden, um unsere Java-Bean-Eigenschaften festzulegen.

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:
				// nichts setzen
				break;
			default:
				// wir suchen nicht nach anderen Ereignissen
			}
		}
		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);
		
		// Ressourcen schließen
		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);
				
		}
	}

}

Die Hauptkomplexität entsteht, wenn wir die Logik zum Analysieren der Daten schreiben müssen, und manchmal kann es komplex werden. Da wir dieselbe Datei wie JsonReader lesen, ist die Ausgabe dieselbe wie beim EmployeeJsonReader-Programm.

Java JsonGenerator Beispiel

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 ist sehr einfach zu verwenden und bietet eine gute Leistung für große Datenmengen. Das ist alles zur Java-JSON-Verarbeitungs-API. Wir haben Beispiele für das Lesen und Schreiben von Java JSON-Parsern gelernt. Sie können das Java-Projekt über den untenstehenden Link herunterladen und damit herumspielen.

Herunterladen des Java JSON-Projekts

Referenzen: JSONLint – Tolle Web-Tool zum Überprüfen von JSON-Daten JSON-Verarbeitungsreferenzimplementierung JSR353 JCP-Seite

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