Konvertieren Sie JSON in XML Java Verwendung von Gson und JAXB

Was ist JSON?

JSON ist eine Abkürzung für JavaScript Object Notation (JSON) ist ein Datenformat, dessen Regeln von den meisten Programmiersprachen gelesen werden können. Es lässt sich problemlos in einer Datei speichern oder in einer Datenbank ablegen. Das JSON-Format verwendet Schlüssel-Wert-Paare zur Datenbeschreibung.

Im folgenden Beispiel definieren wir eine JSON-Zeichenkette, die persönliche Informationen speichert:

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

Die Syntax von JSON ist also sehr einfach. Jedes Datenelement besteht aus zwei Teilen, einem Schlüssel und einem Wert, die dem Feldnamen und seinem Wert in einem Datensatz entsprechen. Darüber hinaus gelten einige Regeln wie diese:

• Der JSON-String ist in geschweifte Klammern {} eingeschlossen.
• Die Schlüssel von JSON müssen in doppelte Anführungszeichen eingeschlossen werden, und auch die Zeichenkettenwerte müssen in Anführungszeichen gesetzt werden.
• Wenn mehr Daten vorhanden sind (mehr Schlüssel-Wert-Paare), verwenden wir Kommas (,), um sie zu trennen.
• JSON-Schlüssel sollten aus einfachen Buchstaben, Zahlen oder dem Unterstrich bestehen, ohne Leerzeichen, und das erste Zeichen sollte keine Zahl sein.

Was ist XML?

XML steht für Extensible Markup Language und wurde vom World Wide Web Consortium vorgeschlagen (https://www.w3.org/) zur Erstellung anderer Auszeichnungssprachen. 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 nützliche XML-Funktionen für verschiedene Systeme und Lösungen:

• XML ist erweiterbar: Mit XML können Sie Ihre eigenen benutzerdefinierten Tags erstellen, die zu Ihrer Anwendung passen.
• XML transportiert Daten, es zeigt sie nicht an: XML ermöglicht es Ihnen, Daten zu speichern, unabhängig davon, 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 hat ein öffnendes und ein schließendes Tag, wie folgt:

<node>content</node>

In welchem:

• ist ein offenes Tag, und der Name dieses Tags wird von Ihnen definiert.
• ist ein schließendes Tag, und der Name dieses Tags muss mit dem Namen des öffnenden Tags übereinstimmen.
• Inhalt ist der Inhalt dieses Tags.

Am Anfang jeder XML-Datei muss ein Tag deklariert werden, der die verwendete XML-Version angibt. Die Syntax des Anweisungstags lautet:

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

JSON vs. XML: Die wichtigsten Unterschiede

Beide Formate enthalten strukturierte Daten, und die folgende Tabelle zeigt, warum ein Projekt möglicherweise zwischen ihnen wechseln muss.

Was ist Gson?

Gson (https://github.com/google/gson) Ein Java Bibliothek, die es Benutzern ermöglicht, eine Java Objekt in einen JSON-String umwandeln und auch einen JSON-String wieder zurück in ein Objekt konvertieren Java Objekt. Gson kann mit beliebigen Java Objekte, einschließlich bestehender Objekte, deren Quellcode Ihnen nicht vorliegt.

Seit Version 1.6 führt Gson zwei Klassen ein, JsonReader und jsonWriter, um die Streaming-Verarbeitung von JSON-Daten zu ermöglichen.

• jsonWriter – Streaming-Schreiben in JSON. Wir erstellen ein jsonWriter Objekt. Um ein JSON-Objekt zu erstellen, verwenden wir die Funktionen. beginObject() und endObject()Zwischen diesen beiden Aufrufen schreiben wir Daten als Paare (Schlüssel => Wert).

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

• JsonReader – Streaming-Lesen von JSON-Daten. Wir erstellen ein JsonReader-Objekt. Um das Lesen eines JSON-Objekts zu starten und zu beenden, verwenden wir die Funktionen `beginObject()` und `endObject()`. Zwischen diesen beiden Aufrufen lesen wir die Daten als Paare (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 Streaming-Verarbeitung mit Gson ist schnell. Allerdings müssen Sie jedes Schlüssel-Wert-Paar der JSON-Daten selbst verarbeiten.

Was ist JAXB?

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

Bei JAXB verwenden wir häufig die folgenden grundlegenden Annotationen:

• @XmlRootElementDiese Annotation legt das äußerste Tag der XML-Datei fest und wird daher oberhalb einer Klasse deklariert.
• @XmlElementWrapper: Diese Annotation erstellt ein Wrapper-XML-Element um Sammlungen.
• @XmlElementDiese Annotation legt fest, dass eine Eigenschaft des Objekts zu einem Kind-Tag der XML-Datei wird.
• @XmlAttributeDiese Annotation legt fest, dass eine Eigenschaft des Objekts zu einem Attribut des umgebenden Tags wird.

Die allgemeine Implementierung sieht wie folgt aus. Zuerst initialisieren wir die JAXBContext Objekt mit dem Mein Objekt Zu konvertierende Klasse.

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

Dieser JAXBContext Das Objekt verfügt über eine Methode, die ein Objekt erstellt, welches XML-Inhalte in ein Java Objekt, das Unmarshaller.

Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();

Das Gleiche JAXBContext Das Objekt besitzt außerdem eine Methode, die das Objekt erstellt, welches ein konvertiert Java Objekt in XML-Inhalt, das Marschall.

Marshaller marshallerObj = jaxbContext.createMarshaller();

Wie konvertiert man XML in JSON?

Wir implementieren das Beispiel der XML-zu-JSON-Konvertierung auf der folgenden Plattform. Die unten aufgeführten Versionen wurden für die Screenshots verwendet. Neuere Versionen des JDK, Eclipseund Gson funktionieren auf die gleiche Weise, vorbehaltlich der oben genannten JAXB-Anmerkung.

• OpenJDK 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 einfliessen.

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

Schritt 3) Erstellen Sie einen Ordner.
Erstellen Sie den Ordner Dateneingabe die die beiden Dateien enthalten sample.xml und sample.json.

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

Die allgemeine Architektur sieht so aus: Eine Abteilung hat viele Rollen, und eine Rolle hat viele Personen. Das folgende Diagramm veranschaulicht diese Beziehungen.

<?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 das JSON, das dieselbe Idee ausdrückt. Beachten Sie, dass die flache Personenliste in ein verschachteltes Array innerhalb jeder Rolle umgewandelt wird, was genau der Transformation entspricht, die der Konvertierungscode durchführt.

{
	"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) Objekte definieren.
Definieren Sie die entsprechenden 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;
	}
}

Department.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) Richten Sie die Bibliothek ein.
Fügen Sie die Gson 2.8.5-Bibliothek hinzu und richten Sie sie ein in der Java Pfad erstellen.

Wenn das Projekt verwendet Maven Anstatt einer manuell hinzugefügten JAR-Datei werden dieselben Bibliotheken als Abhängigkeiten deklariert. Version 2.8.5 ist hier festgelegt, um mit den Screenshots übereinzustimmen, und jede spätere Gson-Version funktioniert für dieses Beispiel identisch:

<dependencies>
    <dependency>
        <groupId>com.google.code.gson</groupId>
        <artifactId>gson</artifactId>
        <version>2.8.5</version>
    </dependency>

    <!-- required on Java 11 and later -->
    <dependency>
        <groupId>jakarta.xml.bind</groupId>
        <artifactId>jakarta.xml.bind-api</artifactId>
    </dependency>
    <dependency>
        <groupId>org.glassfish.jaxb</groupId>
        <artifactId>jaxb-runtime</artifactId>
    </dependency>
</dependencies>

Konvertieren Sie XML-Nachrichten in Java Objekte mit JAXB

Zunächst definieren wir die ausführenden Klassen im Paket. service .

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

Das Unmarshalling ermöglicht einer Clientanwendung die Konvertierung von XML-Daten in JAXB-abgeleitete Daten. Java Objekte.

Wir definieren die Funktion getObjectFromXmlFile um unsere XML-Datei wieder in ein 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;
	}
}

Wir rufen den obigen Code in der Klasse 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();

An diesem Punkt ist die XML-Datei in drei Teile aufgeteilt. Java Objekte im Speicher. Im nächsten Schritt werden sie als JSON ausgegeben.

Konvertieren Java Objekte in JSON-Nachrichten mit Gson

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

Beachten Sie, dass wir zum Schreiben einer Liste von JSON-Objekten die Funktionen verwenden. beginArray() und endArray()Zwischen diesen beiden Aufrufen schreiben wir jedes JSON-Objekt.

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 in der Klasse auf. XmlToJsonService.

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

Das ist der erste Prozessschritt. Die innere Schleife gleicht jede Person mit der aktuellen Rollen-ID ab, wodurch die flache XML-Personenliste in ein verschachteltes JSON-Array umgewandelt wird.

Konvertieren Sie die JSON-Nachricht in Java Objekte mit Gson

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

Beachten Sie, dass wir zum Lesen einer Liste von JSON-Objekten die Funktionen verwenden. beginArray() und endArray()Zwischen diesen beiden Aufrufen lesen wir jedes JSON-Objekt.

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 in der Klasse auf. XmlToJsonService.

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

jsonService.getDataFromJsonFile(filePathIn, roles, persons);

Konvertieren Java Objekte in XML-Nachrichten mit JAXB

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

Marshalling ermöglicht einer Clientanwendung die Konvertierung eines JAXB-abgeleiteten Java Objektbaum in XML-Daten.

Wir definieren die Funktion parseObjectToXml um die Java Objekt zu einer 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 in der Klasse 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. Die generierte Datei stimmt mit der ursprünglichen sample.xml überein, was bestätigt, dass beim Datenaustausch alle Werte erhalten geblieben sind.

Wie konvertiert man JSON in XML? Java ohne eine Modellklasse?

Der oben beschriebene Ansatz ist die richtige Wahl, wenn die Struktur bekannt und stabil ist, da die annotierten Klassen die Struktur dokumentieren.tract. Wenn die Struktur unbekannt ist oder sich häufig ändert, ist ein generischer Konverter schneller.

Das org.json Die Bibliothek führt die Konvertierung in zwei Zeilen durch, ohne jegliche Modellklasse:

import org.json.JSONObject;
import org.json.XML;

public class QuickConverter {

    public static void main(String[] args) {
        String str = "{\"username\":\"guru99user\",\"email\":\"guru99user@mail.com\"}";

        JSONObject json = new JSONObject(str);
        String xml = XML.toString(json);

        System.out.println(xml);
    }
}

Ausgang:

<username>guru99user</username><email>guru99user@mail.com</email>

Beachten Sie, dass die generische Route kein Wurzelelement und keine Attribute erzeugt, XML.toString(json, "root") ist normalerweise erforderlich. Die folgende Tabelle stellt die beiden Vorgehensweisen einander gegenüber.

JAXB liest XML-Daten und Gson schreibt sie in JSON, und der umgekehrte Pfad verwendet Gson zum Lesen. JSON JAXB schreibt die Daten zurück in XML. Weitere Informationen finden Sie unter: XML Grundlagen, die breiteren Java Lernprogramm und JasperReports, das beide Formate als Berichtsdatenquellen nutzt.

Häufig gestellte Fragen