Konvertieren Sie JSON in XML Java Verwendung von Gson und JAXB mit Beispiel

Was ist JSON?

JSON ist eine Abkürzung für Javascript Objektnotation, eine Datenform, die einer bestimmten Regel folgt und die derzeit von den meisten Programmiersprachen gelesen werden kann. Wir können sie einfach in einer Datei oder einem Datensatz in der Datenbank speichern. Das JSON-Format verwendet Schlüssel-Wert-Paare zur Beschreibung von Daten.

Im folgenden Beispiel definieren wir eine JSON-Zeichenfolge, in der persönliche Informationen gespeichert werden:

{
"username" : "guru99user",
"email" : "guru99user@mail.com"	
}

Die Syntax von JSON ist also sehr einfach. Jede Dateninformation besteht aus zwei Teilen: Schlüssel und Wert, die dem Feldnamen und seinem Wert in einem bestimmten Datensatz entsprechen. Aber wenn man genauer hinschaut, gibt es ein paar Dinge wie diese:

• Der JSON-String ist in geschweifte Klammern {} eingeschlossen.
• Die Schlüssel und Werte von JSON müssen in Anführungszeichen {“} eingeschlossen werden.
• Wenn mehr Daten vorhanden sind (mehr Schlüssel => Wertepaare), verwenden wir zur Trennung Kommas (,).
• JSON-Schlüssel sollten vorzeichenlose Buchstaben oder Zahlen und „_“ sowie keine Leerzeichen enthalten. Das erste Zeichen sollte nicht aus Zahlen bestehen.

Was ist XML?

XML steht für eXtensible Markup Language und wird auch als erweiterbare Auszeichnungssprache bezeichnet, die vom World Wide Web Consortium vorgeschlagen wird (https://www.w3.org/), um andere Auszeichnungssprachen zu erstellen. Dies ist eine einfache Teilmenge, die viele verschiedene Datentypen beschreiben kann und daher sehr nützlich für den Datenaustausch zwischen Systemen ist.

Tags in XML sind oft nicht vordefiniert, sondern werden nach Benutzerkonventionen erstellt. XML führt neue Funktionen ein, die auf den Vorteilen von HTML basieren.

Es gibt einige weitere nützliche XML-Erstellungsfunktionen in verschiedenen Systemen und Lösungen:

• XML ist erweiterbar: Mit XML können Sie Ihre eigenen benutzerdefinierten Tags erstellen, die zu Ihrer Anwendung passen.
• XML überträgt Daten, nicht zeigt sie an: XML ermöglicht Ihnen, Daten unabhängig davon zu speichern, wie sie angezeigt werden.
• XML ist ein allgemeiner Standard: XML wurde vom World Wide Web Consortium (W3C) entwickelt und ist als offener Standard verfügbar.

XML basiert auf einer verschachtelten Knotenstruktur. Jeder Knoten verfügt über ein öffnendes und ein schließendes Tag wie folgt:

<node>content</node>

In welchem:

• ist ein offenes Tag, der Name dieses Tags wird von Ihnen definiert.
• Da es sich um ein geschlossenes Tag handelt, muss der Name dieses Tags mit dem Namen des offenen Tags übereinstimmen.
• Inhalt ist der Inhalt dieses Tags.

Am Anfang jeder XML-Datei müssen Sie ein Tag deklarieren, um anzugeben, welche XML-Version verwendet wird. Die Syntax des Anweisungs-Tags:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>

Was ist Gson?

Gson (https://github.com/google/gson) ist eine Java-Bibliothek, die es Benutzern ermöglicht, von einem Java Objekt in JSON-String und auch von einem JSON-String in Java Objekt. Gson kann mit beliebigen Java Objekte, einschließlich vorhandener Objekte, ohne dass Sie über deren Quellcode verfügen.

Seit Version 1.6 führt Gson zwei neue Klassen ein – JsonReader und JsonWriter um Streaming-Verarbeitung für JSON-Daten bereitzustellen.

• JsonWriter – Streaming-Schreiben in JSON. Die Syntax für die allgemeine Implementierung lautet wie folgt. Wir erstellen eine JsonWriter Objekt. Um die Erstellung eines JSON-Strings zu beginnen und abzuschließen, verwenden wir die Funktion beginObject() und endObject(). Während wir diese beiden Funktionen ausführen, schreiben wir Daten mit Paaren (Schlüssel => Wert).

JsonWriter writer = new JsonWriter();
writer.beginObject();
writer.name("key").value("value");
writer.endObject();

• JsonReader – Streaming aus JSON gelesen. Die Syntax für die allgemeine Implementierung lautet wie folgt: Wir erstellen ein JsonReader-Objekt. Um die Erstellung eines JSON-Strings zu beginnen und abzuschließen, verwenden wir die Funktionen beginObject() und endObject(). Während wir diese beiden Funktionen ausführen, lesen wir Daten mit Paaren (Schlüssel => Wert).

JsonReader reader = new JsonReader();
reader.beginObject();
while (reader.hasNext()) {
	String name = reader.nextName();
	if (name.equals("key")) {
		String value = reader.nextString();
	}
}
reader.endObject();

Die Gson-Streaming-Verarbeitung ist schnell. Sie müssen jedoch jedes Paar (Schlüssel => Wert) der Verarbeitung von JSON-Daten verarbeiten.

Was ist JAXB?

JAXB steht für Java Architecture for XML Binding, eine Bibliothek, die Annotationen verwendet, um Java Objekte in XML-Inhalte und umgekehrt. Da JAXB über eine Spezifikation definiert ist, können wir verschiedene Implementierungen für diesen Standard verwenden.

Bei JAXB verwenden wir häufig folgende grundlegende Annotationen, nämlich:

• @XmlRootElement: Diese Annotation gibt an, was das äußerste Tag der XML-Datei ist, und wird daher über einer Klasse deklariert.
• @XmlElementWrapper: Diese Annotation erstellt ein Wrapper-XML-Element um Sammlungen.
• @XmlElement: Diese Annotation, die zum Deklarieren eines Attributs des Objekts verwendet wird, ist ein Tag der XML-Datei.
• @XmlAttribute: Diese Annotation wird auch zum Deklarieren eines Attributs des Objekts als Tag der XML-Datei verwendet.

Die Syntax für die allgemeine Implementierung lautet wie folgt. Zuerst werden wir die initialisieren JAXBContext Objekt mit dem Mein Objekt Objekt zum Konvertieren.

JAXBContext jaxbContext = JAXBContext.newInstance(MyObject.class);

In diesem JAXBContext Objekt, es verfügt über eine Methode zum Erstellen eines Objekts, das XML-Inhalte in ein Java Objekt, Unmarshaller.

Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();

In diesem JAXBContext Objekt, es hat eine Methode zum Erstellen des Objekts, das konvertiert die Java Objekt für den XML-Inhalt, der Marschall.

Marshaller marshallerObj = jaxbContext.createMarshaller();

Wie konvertiert man XML in JSON?

Wir implementieren das Beispiel der XML-JSON-Konvertierung auf der Plattform:

• Öffnen Sie JDK 8 für Ubuntu 18.04 x64.
• Eclipse IDE 2019-03 (4.11.0) x64 Java Entwicklung für Ubuntu.
• Gson 2.8.5.

Schritt 1) Projekt erstellen.
Erstelle eine neue Java Projekt.

Schritt 2) Legen Sie den Projektnamen fest.
Legen Sie den Projektnamen fest XmlToJsonExample.

Schritt 3) Erstellen Sie einen Ordner.
Ordner erstellen Dateneingabe enthält zwei Dateien sample.xml und sample.json.

Definieren wir zunächst unser XML mit Abteilung, Rolle und person Eigenschaften.

Die allgemeine Architektur ist: ; .

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<root>
	<department>
		<roles>
			<role id="1">
				<position>head</position>
				<salary>10k</salary>
			</role>
			<role id="2">
				<position>manager</position>
				<salary>8k</salary>
			</role>
			<role id="3">
				<position>employee</position>
				<salary>5k</salary>
			</role>
		</roles>
		<persons>
			<person id="1">
				<name>Red</name>
				<role>1</role>
			</person>
			<person id="2">
				<name>Green</name>
				<role>2</role>
			</person>
			<person id="3">
				<name>Blue</name>
				<role>2</role>
			</person>
			<person id="4">
				<name>Yellow</name>
				<role>3</role>
			</person>
			<person id="5">
				<name>Brown</name>
				<role>3</role>
			</person>
		</persons>
	</department>
</root>

Zweitens definieren wir JSON mit der gleichen Idee:

{
	"roles": [
		{
			"id": "1",
			"position": "head",
			"salary": "10k",
			"persons": [
				{
					"id": "1",
					"name": "Red"
				}
			]
		},
		{
			"id": "2",
			"position": "manager",
			"salary": "8k",
			"persons": [
				{
					"id": "2",
					"name": "Green"
				},
				{
					"id": "3",
					"name": "Blue"
				}
			]
		},
		{
			"id": "3",
			"position": "employee",
			"salary": "5k",
			"persons": [
				{
					"id": "4",
					"name": "Yellow"
				},
				{
					"id": "5",
					"name": "Brown"
				}
			]
		}
	]	
}

Schritt 4) Objekt definieren.
Definieren Sie entsprechende Objektklassen im Paket Modell.

• Role.java:

@XmlRootElement(name = "role")
public class Role {
	private String id;
	private String position;
	private String salary;
	public Role() {
		super();
	}
	public Role(String id, String position, String salary) {
		super();
		this.id = id;
		this.position = position;
		this.salary = salary;
	}
	@XmlAttribute(name = "id")
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	@XmlElement(name = "position")
	public String getPosition() {
		return position;
	}
	public void setPosition(String position) {
		this.position = position;
	}
	@XmlElement(name = "salary")
	public String getSalary() {
		return salary;
	}
	public void setSalary(String salary) {
		this.salary = salary;
	}
}

• Person.java:

@XmlRootElement(name = "person")
public class Person {
	private String id;
	private String name;
	private String role;
	public Person() {
		super();
	}
	public Person(String id, String name, String role) {
		super();
		this.id = id;
		this.name = name;
		this.role = role;
	}
	@XmlAttribute(name = "id")
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	@XmlElement(name = "name")
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	@XmlElement(name = "role")
	public String getRole() {
		return role;
	}
	public void setRole(String role) {
		this.role = role;
	}
}

• Abteilung.java:

@XmlRootElement(name = "department")
public class Department {
	private List<Role> roles;
	private List<Person> persons;
	public Department() {
		super();
	}
	public Department(List<Role> roles, List<Person> persons) {
		super();
		this.roles = roles;
		this.persons = persons;
	}
	@XmlElementWrapper(name = "roles")
	@XmlElement(name = "role")
	public List<Role> getRoles() {
		return roles;
	}
	public void setRoles(List<Role> roles) {
		this.roles = roles;
	}
	@XmlElementWrapper(name = "persons")
	@XmlElement(name = "person")
	public List<Person> getPersons() {
		return persons;
	}
	public void setPersons(List<Person> persons) {
		this.persons = persons;
	}
}

XMLModel.java:

@XmlRootElement(name = "root")
public class XMLModel {

	private Department department;

	public XMLModel() {
		super();
	}

	public XMLModel(Department department) {
		super();
		this.department = department;
	}

	@XmlElement(name = "department")
	public Department getDepartment() {
		return department;
	}

	public void setDepartment(Department department) {
		this.department = department;
	}

}

Schritt 5) Bibliothek einrichten.
Hinzufügen und Einrichten der Bibliothek Gson 2.8.5 in Java Pfad erstellen.

Konvertieren Sie XML-Nachrichten in Java Objekte mit JAXB

Zunächst definieren wir die Ausführung der Klasse im Paket .

Im ersten Schritt des ersten Prozesses verwenden wir die Technik Un-Marshalling von JAXB.

Durch das Unmarshalling kann eine Client-Anwendung XML-Daten in JAXB-abgeleitete Java Objekte.

Wir definieren Funktion getObjectFromXmlFile um unsere XML-Datei wieder in eine Java Objekt. Diese Funktion ist in der Klasse definiert XMLService.

public XMLModel getObjectFromXmlFile(String filePath) {
	try {
		File file = new File(filePath);
		JAXBContext jaxbContext = JAXBContext.newInstance(XMLModel.class);

		Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();
		XMLModel root = (XMLModel) jaxbUnmarshaller.unmarshal(file);

		return root;
	} catch (JAXBException e) {
		e.printStackTrace();
		return null;
	}
}

Den obigen Code rufen wir im Unterricht auf XmlToJsonService.

XMLService xmlService = new XMLService();
XMLModel xmlModel = xmlService.getObjectFromXmlFile(filePathIn);

Department department = xmlModel.getDepartment();
List<Role> roles = department.getRoles();
List<Person> persons = department.getPersons();

Dann gehen wir zum nächsten Schritt.

Konvertieren Java Objekte in JSON-Nachrichten mit Gson

In diesem Schritt definieren wir die Funktion writeDataToJsonFile um Daten in die JSON-Datei zu schreiben. Diese Funktion ist in der Klasse definiert JsonService.

Beachten Sie, dass wir zum Schreiben einer Liste von JSON-Strings die Funktion verwenden beginArray() und endArray(). Zwischen diesen beiden Funktionen schreiben wir jede JSON-Zeichenfolge.

public void writeDataToJsonFile(String filePath, List<Role> roles, List<Person> persons) {
	try {
		JsonWriter writer = new JsonWriter(new FileWriter(filePath));
		writer.setIndent("    ");
		writer.beginObject();
		writer.name("roles");
		writer.beginArray();
		for (Role role : roles) {
			writer.beginObject();
			writer.name("id").value(role.getId());
			writer.name("position").value(role.getPosition());
			writer.name("salary").value(role.getSalary());
			writer.name("persons");
			writer.beginArray();
			for (Person person : persons) {
				if (person.getRole().equalsIgnoreCase(role.getId())) {
					writer.beginObject();
					writer.name("id").value(person.getId());
					writer.name("name").value(person.getName());
					writer.endObject();
				}
			}
			writer.endArray();
			writer.endObject();
		}
		writer.endArray();
		writer.endObject();
		writer.close();
	} catch (IOException e) {
	}
}

Wir rufen den obigen Code im Unterricht auf XmlToJsonService.

JsonService jsonService = new JsonService();
jsonService.writeDataToJsonFile(filePathOut, roles, persons);

Das ist der erste Prozess.

Konvertieren Sie die JSON-Nachricht in Java Objekte mit Gson

Im ersten Schritt des zweiten Prozesses definieren wir die Funktion getDataFromJsonFile um Daten aus einer JSON-Datei zu lesen. Diese Funktion ist in der Klasse definiert JsonService.

Beachten Sie, dass wir zum Lesen einer Liste von JSON-Strings die Funktion verwenden beginArray() und endArray(). Zwischen diesen beiden Funktionen lesen wir jede JSON-Zeichenfolge.

public void getDataFromJsonFile(String filePath, List<Role> roles, List<Person> persons) {
	try {
		JsonReader reader = new JsonReader(new FileReader(filePath));
		reader.beginObject();
		while (reader.hasNext()) {
			String nameRoot = reader.nextName();
			if (nameRoot.equals("roles")) {
				reader.beginArray();
				while (reader.hasNext()) {
					reader.beginObject();
					Role role = new Role();
					while (reader.hasNext()) {
						String nameRole = reader.nextName();
						if (nameRole.equals("id")) {
							role.setId(reader.nextString());
						} else if (nameRole.equals("position")) 
					        { role.setPosition(reader.nextString());
						} else if (nameRole.equals("salary")) {
						  role.setSalary(reader.nextString());
						} else if (nameRole.equals("persons")) {
							reader.beginArray();
							while (reader.hasNext()) {
								reader.beginObject();

Person person = new Person();

						person.setRole(role.getId());

						while (reader.hasNext()) {
						String namePerson = reader.nextName();

							if (namePerson.equals("id")) {
						person.setId(reader.nextString());
						} else if (namePerson.equals("name")) {
						person.setName(reader.nextString());
							}
						}
								persons.add(person);
								reader.endObject();
							}
							reader.endArray();
						}
					}
					roles.add(role);
					reader.endObject();
				}
				reader.endArray();
			}
		}
		reader.endObject();
		reader.close();
	} catch (IOException e) {

	}
}

Wir rufen den obigen Code im Unterricht auf XmlToJsonService.

JsonService jsonService = new JsonService();
List<Role> roles = new ArrayList<>();
List<Person> persons = new ArrayList<>();

jsonService.getDataFromJsonFile(filePathIn, roles, persons);

Dann gehen wir zum nächsten Schritt.

Konvertieren Java Objekte in XML-Nachrichten mit JAXB

In diesem Schritt verwenden wir die Marshalling-Technik von JAXB.

Marshalling bietet einer Client-Anwendung die Möglichkeit, eine von JAXB abgeleitete Java Objektbaum in XML-Daten.

Wir definieren die Funktion parseObjectToXm zum Marshallen Java Objekt in XML-Nachricht. Diese Funktion ist in der Klasse definiert

XMLService.
public void parseObjectToXml(String filePath, XMLModel xmlModel) {
	try {
		JAXBContext contextObj = JAXBContext.newInstance(XMLModel.class);

		Marshaller marshallerObj = contextObj.createMarshaller();
		marshallerObj.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);

		marshallerObj.marshal(xmlModel, new FileOutputStream(filePath));
	} catch (JAXBException je) {
		System.out.println("JAXBException");
	} catch (IOException ie) {
		System.out.println("IOException");
	}
}

Wir rufen den obigen Code im Unterricht auf XmlToJsonService.

XMLService xmlService = new XMLService();
XMLModel xmlModel = new XMLModel();

Department department = new Department();
department.setRoles(roles);
department.setPersons(persons);

xmlModel.setDepartment(department);

xmlService.parseObjectToXml(filePathOut, xmlModel);

Das ist der zweite Prozess.

Fazit

In diesem Tutorial haben wir kurz eine Möglichkeit kennengelernt, wie JAXB XML-Daten lesen und Gson sie in JSON schreiben kann. Im Gegenteil, wir haben auch gesehen, wie Gson las JSON Daten und JAXB schreiben sie in XML.