Converteer JSON naar XML Java met Gson en JAXB met voorbeeld

Wat is JSON?

JSON is een afkorting voor Javascript Object Notation, een vorm van gegevens die een bepaalde regel volgt dat de meeste programmeertalen momenteel leesbaar zijn. We kunnen het eenvoudig opslaan in een bestand of record in de database. De JSON-indeling gebruikt sleutel-waardeparen om gegevens te beschrijven.

In vervolgwing In het voorbeeld definiëren we een JSON-string waarin persoonlijke informatie wordt opgeslagen:

{
"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 niet-ondertekende letters of cijfers, _, en mogen geen spaties bevatten. Het eerste teken mag niet zijn ingesteld op cijfers.

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 deze niet weer: met XML kunt u gegevens opslaan, ongeacht hoe deze 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 van een Java-object naar een JSON-string kunnen converteren en ook van een JSON-string naar een Java-object kunnen converteren. Gson kan met willekeurige Java-objecten werken, 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 for XML Binding, een bibliotheek die annotaties gebruikt om Java-objecten naar XML-inhoud te converteren en omgekeerd. Omdat JAXB via een specificatie is gedefinieerd, kunnen we voor deze standaard verschillende implementaties gebruiken.

Bij JAXB gebruiken we vaak following 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 omzet naar een Java-object, Niet-marshaller.

Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();

In deze JAXBContext object, het heeft een methode om het object te maken dat het Java-object converteert naar de XML-inhoud die dat 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.

Maak een nieuw Java-project.
Maak een nieuw Java-project.

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

Projectnaam instellen

Projectnaam instellen.

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

Mapgegevens maken

Mapgegevens/invoer maken.

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

De algemene architectuur is: ; .

Objectrelaties

Objectrelaties.

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

Objectklassen definiëren

Objectklassen definiëren.

  • 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 in Java Build Path.

Bibliotheek Gson opzetten

Voeg bibliotheek Gson 2.8.5 toe aan Java Build Path

Voeg bibliotheek Gson 2.8.5 toe aan Java Build Path.

Converteer XML-berichten naar Java-objecten met behulp van JAXB

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

Definieer prestatieklassen

Definieer prestatieklassen.

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 van JAXB afgeleide Java-objecten.

Wij definiëren de functie getObjectFromXmlFile om ons XML-bestand terug te koppelen 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 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.

Converteer Java-objecten naar 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);

Hoe JSON naar XML Java converteren?

JSON naar XML in JAVA wordt geconverteerd met behulp van JSONObject json = new JSONObject(str); Snaar xml = XML. Als je een geldig dtd-bestand of het xml-bestand hebt, is het heel eenvoudig om json naar xml en ook xml naar json te transformeren.

Dan gaan we naar de volgende stap.

Converteer Java-objecten naar XML-berichten met behulp van JAXB

Bij deze stap gebruiken we de techniek Marshalling van JAXB.

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

We definiëren de functie parseObjectToXm om het Java-object in een XML-bericht te plaatsen. 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.