Converteer JSON naar XML Java gebruikmakend van Gson en JAXB

Wat is JSON?

JSON is een afkorting voor JavaScript Object Notation (JSON) is een dataformaat dat voldoet aan de regels die de meeste programmeertalen kunnen lezen. We kunnen het eenvoudig opslaan in een bestand of in een database. Het JSON-formaat gebruikt sleutel-waardeparen om gegevens te beschrijven.

In het volgende voorbeeld definiëren we een JSON-string die persoonlijke informatie opslaat:

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

De syntaxis van JSON is dus heel eenvoudig. Elk gegevenselement bestaat uit twee delen: een sleutel en een waarde, die overeenkomen met de veldnaam en de bijbehorende waarde in een record. Verder zijn er een paar regels, zoals deze:

• De JSON-tekenreeks wordt omsloten door accolades {}.
• De sleutels van een JSON-object moeten tussen dubbele aanhalingstekens staan, en tekenreekswaarden moeten ook tussen aanhalingstekens worden geplaatst.
• Als er meer gegevens zijn (meer sleutel-waardeparen), gebruiken we komma's (,) om ze te scheiden.
• JSON-sleutels moeten bestaan ​​uit gewone letters, cijfers of het underscore-teken, zonder spaties, en het eerste teken mag geen cijfer zijn.

Wat is XML?

XML staat voor eXtensible Markup Language, een taal die is voorgesteld door het World Wide Web Consortium (https://www.w3.org/) om andere opmaaktalen te creëren. Dit is een eenvoudige subset die veel verschillende soorten gegevens kan beschrijven, waardoor het erg handig is voor het delen van gegevens tussen systemen.

Tags in XML zijn vaak niet vooraf gedefinieerd, maar worden gemaakt volgens gebruikersconventies. XML introduceert nieuwe functies gebaseerd op de voordelen van HTML.

Er zijn een aantal nuttige XML-functies voor uiteenlopende systemen en oplossingen:

• XML is uitbreidbaar: met XML kunt u uw eigen aangepaste tags maken die bij uw toepassing passen.
• XML transporteert gegevens, het geeft ze niet weer: met XML kun je gegevens opslaan, ongeacht hoe ze worden weergegeven.
• XML is een veelgebruikte standaard: XML is ontwikkeld door het World Wide Web Consortium (W3C) en is beschikbaar als open standaard.

XML is opgebouwd uit een geneste knooppuntstructuur. Elk knooppunt heeft een openingstag en een sluitingstag, zoals hieronder weergegeven:

<node>content</node>

Waarin:

• Dit is een open tag, en de naam van deze tag wordt door jou bepaald.
• is een sluitingslabel, en de naam van dit label moet overeenkomen met de naam van het openingslabel.
• content is de inhoud van deze tag.

Bovenaan elk XML-bestand moet u een tag declareren om de gebruikte XML-versie aan te geven. De syntaxis van de instructietag is als volgt:

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

JSON versus XML: Belangrijkste verschillen

Beide formaten bevatten gestructureerde gegevens en de onderstaande tabel laat zien waarom een ​​project mogelijk tussen beide formaten moet worden overgezet.

Wat is Gson?

Gson (https://github.com/google/gson) Is Java bibliotheek waarmee gebruikers een conversie kunnen uitvoeren Java een object omzetten naar een JSON-string, en ook een JSON-string terugzetten naar een object. Java voorwerp. Gson kan met willekeurig werken Java objecten, inclusief bestaande objecten waarvan u de broncode niet hebt.

Sinds versie 1.6 introduceert Gson twee klassen, JsonReader en jsonWriter, om streamingverwerking van JSON-gegevens mogelijk te maken.

• jsonWriter – Streaming schrijven naar JSON. We maken een jsonWriter object. Om het maken van een JSON-object te starten en te voltooien, gebruiken we de functies. beginObject() en endObject()Tussen die twee aanroepen schrijven we gegevens als paren (sleutel => waarde).

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

• JsonReader – Streaming lezen vanuit JSON. We maken een JsonReader-object aan. Om het lezen van een JSON-object te starten en te beëindigen, gebruiken we de functies beginObject() en endObject(). Tussen deze twee aanroepen lezen we de gegevens als paren (sleutel => waarde).

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

Gson streamingverwerking is snel. Je moet echter elk paar (sleutel => waarde) van de JSON-gegevens zelf verwerken.

Wat is JAXB?

JAXB staat voor Java Architecture voor XML Binding, een bibliotheek die annotaties gebruikt om te converteren Java objecten naar XML-inhoud en vice versa. Omdat JAXB is gedefinieerd door een specificatie, kunnen we verschillende implementaties van deze standaard gebruiken.

Met JAXB gebruiken we vaak de volgende basisannotaties:

• @XmlRootElementDeze annotatie specificeert de buitenste tag van het XML-bestand en wordt daarom boven een klasse gedeclareerd.
• @XmlElementWrapper: Deze annotatie creëert een wrapper XML-element rond collecties.
• @XmlElementDeze annotatie geeft aan dat een eigenschap van het object een sub-tag van het XML-bestand wordt.
• @XmlAttribuutDeze annotatie geeft aan dat een eigenschap van het object een attribuut wordt van de omringende tag.

De algemene implementatie is als volgt. Eerst initialiseren we de JAXBContext object met de MijnObject klasse om te converteren.

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

In deze JAXBContext Het object heeft een methode die een object creëert dat XML-inhoud omzet in een Java object, de Niet-marshaller.

Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();

Hetzelfde JAXBContext Het object heeft ook een methode die het object creëert dat een conversie uitvoert. Java object in XML-inhoud, de Marshallaar.

Marshaller marshallerObj = jaxbContext.createMarshaller();

Hoe XML naar JSON te converteren?

We implementeren het voorbeeld van XML naar JSON-conversie op het volgende platform. De onderstaande versies zijn de versies die voor de schermafbeeldingen zijn gebruikt. Nieuwere releases van de JDK, EclipseEn Gson werkt op dezelfde manier, met inachtneming van de bovenstaande opmerking van JAXB.

• OpenJDK 8 voor Ubuntu 18.04 x64.
• Eclipse IDE 2019-03 (4.11.0) x64 Java Ontwikkeling voor Ubuntu.
• Gson 2.8.5.

Stap 1) Project aanmaken.
Maak een nieuw Java project.

Stap 2) Stel de projectnaam in.
Stel de projectnaam in op XmlToJsonVoorbeeld.

Stap 3) Maak een map aan.
Maak de map gegevens/invoer met daarin de twee bestanden voorbeeld.xml en voorbeeld.json.

Laten we eerst onze XML definiëren met afdeling, rolen persoon eigenschappen.

De algemene structuur is als volgt: één afdeling heeft meerdere rollen, en één rol wordt door meerdere personen uitgevoerd. Het onderstaande diagram illustreert deze relaties.

<?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>

Ten tweede definiëren we de JSON die hetzelfde idee uitdrukt. Merk op dat de platte personenlijst een geneste array wordt binnen elke rol, wat precies de transformatie is die de conversiecode uitvoert.

{
	"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"
				}
			]
		}
	]
}

Stap 4) Objecten definiëren.
Definieer de overeenkomstige objectklassen in het pakket. model.

Rol.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;
	}
}

Persoon.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;
	}
}

Afdeling.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;
	}

}

Stap 5) Stel de bibliotheek in.
Voeg de Gson 2.8.5-bibliotheek toe en configureer deze in de Java Bouw pad.

Als het project gebruikmaakt van Maven In plaats van een handmatig toegevoegd JAR-bestand, worden dezelfde bibliotheken als afhankelijkheden gedeclareerd. Versie 2.8.5 is hier vastgezet om overeen te komen met de schermafbeeldingen, en elke latere Gson-release werkt identiek voor dit voorbeeld:

<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>

Converteer XML-bericht naar Java objecten met behulp van JAXB

Allereerst definiëren we de uitvoerende klassen in het pakket. service.

Bij de eerste stap van het eerste proces gebruiken we de unmarshalling-techniek van JAXB.

Unmarshalling biedt een clientapplicatie de mogelijkheid om XML-gegevens om te zetten in JAXB-afgeleide gegevens. Java voorwerpen.

We definiëren de functie getObjectFromXmlFile om ons XML-bestand terug te converteren naar een Java object. Deze functie is gedefinieerd in de klasse. 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;
	}
}

We roepen de bovenstaande code aan in de 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();

Op dit punt is het XML-bestand drie geworden. Java objecten in het geheugen. De volgende stap schrijft ze weg als JSON.

Converteren Java maakt bezwaar tegen een JSON-bericht met behulp van Gson

In deze stap definiëren we de functie. writeDataToJsonFile om gegevens naar het JSON-bestand te schrijven. Deze functie is gedefinieerd in de klasse. JsonService.

Merk op dat we voor het schrijven van een lijst met JSON-objecten de volgende functies gebruiken. beginArray() en endArray()Tussen deze twee aanroepen schrijven we elk JSON-object.

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) {
	}
}

We roepen de bovenstaande code aan in de klasse. XmlToJsonService.

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

Dat is het eerste proces. De binnenste lus vergelijkt elke persoon met de huidige rol-ID, waardoor de platte XML-lijst met personen een geneste JSON-array wordt.

Converteer JSON-bericht naar Java objecten met behulp van Gson

In de eerste stap van het tweede proces definiëren we de functie. getDataFromJsonFile om gegevens uit het JSON-bestand te lezen. Deze functie is gedefinieerd in de klasse. JsonService.

Merk op dat we voor het lezen van een lijst met JSON-objecten de volgende functies gebruiken. beginArray() en endArray()Tussen deze twee aanroepen lezen we elk JSON-object.

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) {

	}
}

We roepen de bovenstaande code aan in de klasse. XmlToJsonService.

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

jsonService.getDataFromJsonFile(filePathIn, roles, persons);

Converteren Java objecten naar XML-bericht met behulp van JAXB

In deze stap gebruiken we de marshallingtechniek van JAXB.

Marshalling biedt een clienttoepassing de mogelijkheid om een ​​JAXB-afgeleide code om te zetten. Java objectboom omzetten in XML-gegevens.

We definiëren de functie parseObjectToXml om de Java object naar een XML-bericht. Deze functie is gedefinieerd in de klasse. 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");
	}
}

We roepen de bovenstaande code aan in de 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);

Dat is het tweede proces. Het gegenereerde bestand komt overeen met het originele sample.xml, wat bevestigt dat alle waarden tijdens de heen-en-terugreis behouden zijn gebleven.

Hoe converteer je JSON naar XML? Java zonder een modelklasse?

De bovenstaande aanpak is de juiste keuze wanneer de structuur bekend en stabiel is, omdat de geannoteerde klassen de structuur documenteren.tract. Wanneer de structuur onbekend is of vaak verandert, is een generieke converter sneller.

De org.json De bibliotheek voert de conversie in twee regels uit, zonder modelklasse:

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);
    }
}

Output:

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

Merk op dat de generieke route geen root-element en geen attributen produceert, dus XML.toString(json, "root") is doorgaans vereist. De onderstaande tabel zet de twee benaderingen naast elkaar.

JAXB leest XML-gegevens en Gson schrijft deze naar JSON, en in omgekeerde richting gebruikt Gson de gegevens om te lezen. JSON data terwijl JAXB het terugschrijft naar XML. Om verder te gaan, bekijk XML basisprincipes, het bredere Java zelfstudieen Jasper Reports, die beide formaten als gegevensbronnen voor rapporten gebruikt.

Veelgestelde vragen