Converteer JSON naar XML Java met behulp van Gson en JAXB met voorbeeld

Wat is JSON?

JSON is een afkorting voor Javascript Object Notation, een vorm van data die een bepaalde regel volgt die de meeste programmeertalen momenteel leesbaar maken. We kunnen het eenvoudig opslaan in een bestand of record in de database. JSON-formaat gebruikt sleutel-waardeparen om data 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. Elke gegevensinformatie bestaat uit twee delen: sleutel en waarde die overeenkomen met de veldnaam en de waarde ervan in een bepaald record. Maar als je verder kijkt, zijn er een paar dingen zoals deze:

• De JSON-tekenreeks wordt omsloten door accolades {}.
• De sleutels en waarden van JSON moeten tussen aanhalingstekens staan ​​{“}.
• Als er meer gegevens zijn (meer sleutel => waardeparen), gebruiken we komma's (,) om te scheiden.
• JSON-sleutels moeten bestaan ​​uit ongetekende letters of cijfers, _, en geen spaties. Het eerste teken mag niet uit cijfers bestaan.

Wat is XML?

XML staat voor eXtensible Markup Language, ook wel de uitbreidbare markup-taal genoemd, voorgesteld door het World Wide Web Consortium (https://www.w3.org/) om andere opmaaktalen te maken. Dit is een eenvoudige subset die veel verschillende soorten gegevens kan beschrijven, dus het is erg handig bij 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 nog enkele nuttige functies voor het maken van XML in diverse systemen en oplossingen:

• XML is uitbreidbaar: met XML kunt u uw eigen aangepaste tags maken die bij uw toepassing passen.
• XML draagt ​​gegevens over, maar geeft ze niet weer: Met XML kunt u 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 gebouwd op een geneste knooppuntstructuur. Elk knooppunt heeft als volgt een openingstag en een sluitingstag:

<node>content</node>

Waarin:

• is een open tag, de naam van deze tag bepaalt u zelf.
• is een gesloten tag, de naam van deze tag moet overeenkomen met de naam van de open tag.
• content is de inhoud van deze tag.

Bovenaan elk XML-bestand moet u een tag declareren om aan te geven welke versie van XML in gebruik is. De syntaxis van de instructietag:

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

Wat is Gson?

Gson (https://github.com/google/gson) is een Java-bibliotheek waarmee gebruikers kunnen converteren van een Java object naar JSON-tekenreeks en ook converteren van een JSON-tekenreeks naar Java voorwerp. Gson kan met willekeurig werken Java objecten inclusief bestaande objecten zonder dat u over de broncode beschikt.

Sinds versie 1.6 introduceert Gson twee nieuwe klassen: JsonReader en JsonWriter om streamingverwerking op JSON-gegevens te bieden.

• JsonWriter – Streaming schrijven naar JSON. De syntaxis voor algemene implementatie is als volgt. Wij creëren een JsonWriter voorwerp. Om het maken van een JSON-string te starten en te voltooien, gebruiken we de functie beginObject() en endObject(). Tijdens het uitvoeren van deze twee functies voeren we het schrijven van gegevens met paren uit (sleutel => waarde).

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

• JsonReader – Streaming lezen vanuit JSON. De syntaxis voor algemene implementatie is als volgt. We maken een JsonReader-object. Om het maken van een JSON-string te starten en te voltooien, gebruiken we de functies beginObject() en endObject(). Tijdens het uitvoeren van deze twee functies lezen we gegevens met 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. U moet echter elk paar (sleutel => waarde) van het verwerken van JSON-gegevens afhandelen.

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 via een specificatie is gedefinieerd, kunnen we voor deze standaard verschillende implementaties gebruiken.

Met JAXB gebruiken we vaak de volgende basisannotaties, namelijk:

• @XmlRootElement: Deze annotatie specificeert wat de buitenste tag van het XML-bestand is en wordt daarom bovenaan een klasse gedeclareerd.
• @XmlElementWrapper: Deze annotatie creëert een wrapper XML-element rond collecties.
• @XmlElement: Deze annotatie die wordt gebruikt om een ​​attribuut van het object te declareren, is een tag van het XML-bestand.
• @XmlAttribuut: Deze annotatie die ook wordt gebruikt om een ​​attribuut van het object te declareren, is een tag van het XML-bestand.

De syntaxis voor algemene implementatie is als volgt. Eerst zullen we de JAXBContext object met de MijnObject voorwerp om te zetten.

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

In deze JAXBContext object, het heeft een methode om een ​​object te maken dat XML-inhoud converteert naar een Java voorwerp, Niet-marshaller.

Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();

In deze JAXBContext object, het heeft een methode om het object te maken dat de Java bezwaar maken tegen de XML-inhoud die dat wel is Marshallaar.

Marshaller marshallerObj = jaxbContext.createMarshaller();

Hoe XML naar JSON te converteren?

We implementeren het voorbeeld van XML – JSON-conversie op het platform:

• Open JDK 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) Projectnaam instellen.
Stel de projectnaam in op XmlToJsonVoorbeeld.

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

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

De algemene architectuur is: ; .

<?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 JSON met hetzelfde 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"
				}
			]
		}
	]	
}

Stap 4) Object definiëren.
Definieer 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) Bibliotheek opzetten.
Bibliotheek Gson 2.8.5 toevoegen en instellen Java Bouw pad.

Converteer XML-bericht naar Java objecten met behulp van JAXB

Ten eerste definiëren we presteren geclassificeerd in een pakket service.

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

Un-marshalling biedt een clienttoepassing de mogelijkheid om XML-gegevens om te zetten in afgeleide JAXB Java voorwerpen.

Wij definiëren de functie getObjectFromXmlFile om ons XML-bestand terug te rangschikken naar een Java voorwerp. 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 noemen de bovenstaande code in de klas XmlToJsonService.

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

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

Dan gaan we naar de volgende stap.

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

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

Houd er rekening mee dat we de functie gebruiken om een ​​lijst met JSON-tekenreeksen te schrijven beginArray() en endArray(). Tussen deze twee functies schrijven we elke JSON-tekenreeks.

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 noemen de bovenstaande code in de klas XmlToJsonService.

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

Dat is het eerste proces.

Converteer JSON-bericht naar Java objecten met behulp van Gson

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

Houd er rekening mee dat we de functie gebruiken om een ​​lijst met JSON-tekenreeksen te lezen beginArray() en endArray(). Tussen deze twee functies lezen we elke JSON-tekenreeks.

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 noemen de bovenstaande code in de klas XmlToJsonService.

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

jsonService.getDataFromJsonFile(filePathIn, roles, persons);

Dan gaan we naar de volgende stap.

Converteren Java objecten naar XML-bericht met behulp van JAXB

Bij deze stap gebruiken we de techniek Marshalling van JAXB.

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

We definiëren de functie parseObjectToXm om te marshallen Java bezwaar maken tegen 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 noemen de bovenstaande code in de klas 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.

Conclusie

In deze tutorial hebben we kort één manier geleerd waarop JAXB XML-gegevens kan lezen en Gson deze naar JSON kan schrijven. Integendeel, we zagen ook de manier waarop Gson las JSON gegevens en JAXB schrijft deze naar XML.