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

Was ist JSON?

JSON ist eine Abkürzung für Javascript Object Notation, eine Form von Daten, die einer bestimmten Regel folgt, die derzeit von den meisten Programmiersprachen lesbar ist. Wir können es einfach in einer Datei speichern oder in der Datenbank aufzeichnen. Das JSON-Format verwendet Schlüssel-Wert-Paare, um Daten zu beschreiben.

Im Anschluss an das Beispiel definieren wir eine JSON-Zeichenfolge, die persönliche Informationen speichert:

{
"username" : "guru99user",
"email" : "[email protected]"	
}

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 Sie weiter suchen, gibt es ein paar Dinge wie diese:

• Der JSON-String wird von geschweiften Klammern {}.
eingeschlossen
• Die Schlüssel und Werte von JSON müssen in Anführungszeichen {“}.
eingeschlossen werden
• Wenn es mehr Daten gibt (mehr Schlüssel => Wertpaare), verwenden wir Kommas (,) zur Trennung.
• JSON-Schlüssel sollten vorzeichenlose Buchstaben oder Zahlen, _, und keine Leerzeichen sein, das erste Zeichen sollte nicht auf Zahlen gesetzt werden.

In diesem Tutorial lernen Sie-

• Was ist JSON?
• Was ist XML?
• Was ist Gson?
• Was ist JAXB?
• Wie konvertiere ich XML in JSON?
• XML-Nachricht mit JAXB in Java-Objekte konvertieren
• Java-Objekte mit Gson in JSON-Nachrichten konvertieren
• JSON-Nachricht mit Gson in Java-Objekte konvertieren
• Java-Objekte mit JAXB in XML-Nachrichten konvertieren

Was ist XML?

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

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 Funktionen zur XML-Erstellung 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 transportiert Daten, 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 Tag und ein schließendes Tag wie folgt:

<node>content</node>

Wobei:

• ein offenes Tag ist, wird der Name dieses Tags von Ihnen bestimmt.
• ein geschlossenes Tag ist, 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, mit der Benutzer von einem Java-Objekt in eine JSON-Zeichenfolge und auch von einer JSON-Zeichenfolge in ein Java-Objekt konvertieren können. Gson kann mit beliebigen Java-Objekten arbeiten, einschließlich vorhandener Objekte, ohne dass Sie deren Quellcode haben.

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

• JsonWriter – Streaming in JSON schreiben. Die Syntax für die allgemeine Implementierung lautet wie folgt. Wir erstellen einen JsonWriter Objekt. Um die Erstellung eines JSON-Strings zu beginnen und abzuschließen, verwenden wir die Funktion beginObject() und endObject() . In der Mitte der Ausführung dieser beiden Funktionen 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(). In der Mitte der Ausführung dieser beiden Funktionen führen wir das Lesen von Daten mit Paaren durch (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 behandeln.

Was ist JAXB?

JAXB steht für Java Architecture for XML Binding, eine Bibliothek, die Annotationen verwendet, um Java-Objekte in XML-Inhalte umzuwandeln 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 die folgenden grundlegenden Anmerkungen, nämlich:

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

Die Syntax für die allgemeine Implementierung lautet wie folgt. Zuerst initialisieren wir den JAXBContext Objekt mit dem MyObject zu konvertierendes Objekt.

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

In diesem JAXBContext -Objekt, hat es eine Methode zum Erstellen eines Objekts, das XML-Inhalt in ein Java-Objekt umwandelt, Unmarshaller .

Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();

In diesem JAXBContext -Objekt, hat es eine Methode zum Erstellen des Objekts, das das Java-Objekt in den XML-Inhalt konvertiert, der Marshaller ist .

Marshaller marshallerObj = jaxbContext.createMarshaller();

Wie konvertiere ich 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.
Neues Java-Projekt erstellen.

Schritt 2 . Legen Sie den Projektnamen fest.
Der festgelegte Projektname ist XmlToJsonExample .

Schritt 3 . Erstellen Sie einen Ordner.
Erstellen Sie den Ordner data/input enthält zwei Dateien sample.xml und sample.json .

Lassen Sie uns zuerst unser XML mit department definieren , 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.
Entsprechende Objektklassen im Paket model definieren .

• Rolle.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.
Bibliothek Gson 2.8.5 in Java Build Path hinzufügen und einrichten.

XML-Nachricht mit JAXB in Java-Objekte konvertieren

Zunächst definieren wir die Leistungsklasse im Paket Service .

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

Un-Marshalling bietet einer Client-Anwendung die Möglichkeit, XML-Daten in von JAXB abgeleitete Java-Objekte zu konvertieren.

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

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 nennen den obigen Code in der Klasse 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.

Java-Objekte mit Gson in JSON-Nachrichten konvertieren

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

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

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 nennen den obigen Code in der Klasse XmlToJsonService .

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

Das ist der erste Prozess.

JSON-Nachricht mit Gson in Java-Objekte konvertieren

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

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

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 nennen den obigen Code in der Klasse XmlToJsonService .

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

jsonService.getDataFromJsonFile(filePathIn, roles, persons);

Wie konvertiere ich Json in XML Java?

JSON zu XML in JAVA wird mithilfe von JSONObject json =new JSONObject(str); Zeichenfolge xml =XML . Wenn Sie eine gültige dtd-Datei oder die XML-Datei haben, ist es sehr einfach, json in xml und auch xml in json umzuwandeln.

Dann gehen wir zum nächsten Schritt.

Java-Objekte mit JAXB in XML-Nachrichten konvertieren

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

Marshalling bietet einer Clientanwendung die Möglichkeit, einen von JAXB abgeleiteten Java-Objektbaum in XML-Daten zu konvertieren.

Wir definieren die Funktion parseObjectToXm, um ein Java-Objekt in eine XML-Nachricht zu marshallen. 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 nennen den obigen Code in der Klasse 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.

Schlussfolgerung

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 JSON-Daten liest und JAXB sie in XML schreibt.

Java-Programm zum Überprüfen der Primzahl Programm zum Drucken von Primzahlen von 1 bis 100 in Java