Convertiți JSON în XML Java folosind Gson și JAXB cu Exemplu

Ce este JSON?

JSON este o abreviere pentru Javascript Object Notation, care este o formă de date care urmează o anumită regulă conform căreia majoritatea limbajelor de programare sunt în prezent lizibile. Îl putem salva cu ușurință într-un fișier sau înregistrare în baza de date. Formatul JSON utilizează perechi cheie-valoare pentru a descrie datele.

Urmând exemplul, definim un șir JSON care stochează informații personale:

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

Deci sintaxa JSON este foarte simplă. Fiecare informație de date va avea două părți: cheie și valoare care corespund numelui câmpului și valorii acestuia într-o anumită înregistrare. Dar, în continuare, există câteva lucruri ca acestea:

• Șirul JSON este închis de acolade {}.
• Cheile și valorile JSON trebuie să fie cuprinse între ghilimele {“}.
• Dacă există mai multe date (mai multe perechi cheie => valoare), folosim virgulele (,) pentru a separa.
• Cheile JSON trebuie să fie litere sau cifre fără semnătură, _ și fără spații, primul caracter nu trebuie setat la cifre.

Ce este XML?

XML înseamnă eXtensible Markup Language, numit și limbajul de markup extensibil propus de World Wide Web Consortium (https://www.w3.org/) pentru a crea alte limbaje de marcare. Acesta este un subset simplu care poate descrie multe tipuri diferite de date, deci este foarte util în partajarea datelor între sisteme.

Etichetele în XML nu sunt adesea predefinite, dar sunt create conform convențiilor utilizatorului. XML introduce noi caracteristici bazate pe avantajele HTML.

Există câteva caracteristici mai utile pentru crearea XML în diverse sisteme și soluții:

• XML este extensibil: XML vă permite să vă creați propriile etichete personalizate pentru a se potrivi aplicației dvs.
• XML transportă date, nu le afișează: XML vă permite să stocați date indiferent de modul în care vor fi afișate.
• XML este un standard comun: XML a fost dezvoltat de World Wide Web Consortium (W3C) și este disponibil ca standard deschis.

XML este construit pe o structură de noduri imbricate. Fiecare nod va avea o etichetă de deschidere și o etichetă de închidere, după cum urmează:

<node>content</node>

In care:

• este o etichetă deschisă, numele acestei etichete este definit de dvs.
• este o etichetă închisă, numele acestei etichete trebuie să se potrivească cu numele etichetei deschise.
• conţinut este conținutul acestei etichete.

În partea de sus a fiecărui fișier XML, trebuie să declarați o etichetă pentru a indica versiunea XML utilizată. Sintaxa etichetei de instrucțiune:

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

Ce este Gson?

Gson (https://github.com/google/gson) este o bibliotecă java care permite utilizatorilor să convertească dintr-un Java obiect în șir JSON și, de asemenea, convertiți dintr-un șir JSON în Java obiect. Gson poate lucra cu arbitrare Java obiecte, inclusiv obiecte existente fără să aveți codul sursă.

Începând cu versiunea 1.6, Gson introduce două clase noi - JsonReader si JsonWriter pentru a oferi procesare în flux pe date JSON.

• JsonWriter – Scriere în flux în JSON. Sintaxa pentru implementarea generală este următoarea. Creăm un JsonWriter obiect. Pentru a începe și a termina crearea unui șir JSON, folosim funcția beginObject() si endObject(). În mijlocul executării acestor două funcții, efectuăm scrierea datelor cu perechi (cheie => valoare).

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

• JsonReader – Citire în flux din JSON. Sintaxa pentru implementarea generală este următoarea. Creăm un obiect JsonReader. Pentru a începe și a termina crearea unui șir JSON, folosim funcția beginObject() și endObject(). În mijlocul executării acestor două funcții, efectuăm citirea datelor cu perechi (cheie => valoare).

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

Procesarea streaming Gson este rapidă. Cu toate acestea, trebuie să gestionați fiecare pereche (cheie => valoare) de procesare a datelor JSON.

Ce este JAXB?

JAXB înseamnă Java Architectura pentru XML Binding, care este o bibliotecă care utilizează adnotări pentru conversie Java obiecte la conținut XML și invers. Deoarece JAXB este definit printr-o specificație, putem folosi diferite implementări pentru acest standard.

Cu JAXB, folosim adesea următoarele adnotări de bază, și anume:

• @XmlRootElement: Această adnotare specifică care este eticheta cea mai exterioară a fișierului XML și, prin urmare, este declarată în partea de sus a unei clase.
• @XmlElementWrapper: Această adnotare creează un element XML wrapper în jurul colecțiilor.
• @XmlElement: Această adnotare folosită pentru a declara un atribut al obiectului este o etichetă a fișierului XML.
• @XmlAttribute: Această adnotare folosită și pentru a declara un atribut al obiectului este o etichetă a fișierului XML.

Sintaxa pentru implementarea generală este următoarea. În primul rând, vom inițializa fișierul JAXBContext obiect cu MyObject obiect de convertit.

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

În acest JAXBContext obiect, are o metodă de a crea un obiect care convertește conținut XML în a Java obiect, Unmarshaller.

Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();

În acest JAXBContext obiect, are o metodă de a crea obiectul care convertește Java obiect la conținutul XML care este Marshaller.

Marshaller marshallerObj = jaxbContext.createMarshaller();

Cum se convertesc XML în JSON?

Implementăm exemplul de conversie XML – JSON pe platformă:

• Deschideți JDK 8 pentru Ubuntu 18.04x64.
• Eclipse IDE 2019-03 (4.11.0) x64 Java Dezvoltare pentru Ubuntu.
• Gson 2.8.5.

Pas 1) Creați proiect.
Creaza un nou Java Proiect.

Pas 2) Setați numele proiectului.
Setați numele proiectului este XmlToJsonExample.

Pas 3) Creați un folder.
Creați un dosar introducere a datelor conținând două fișiere sample.xml si sample.json.

Să definim mai întâi XML-ul nostru cu departament, rol si persoană proprietăți.

Arhitectura generală este: ; .

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

În al doilea rând, definim JSON având aceeași 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"
				}
			]
		}
	]	
}

Pas 4) Definiți obiectul.
Definiți clasele de obiecte corespunzătoare în pachet 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;
	}
}

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

}

Pas 5) Configurați biblioteca.
Adăugați și configurați biblioteca Gson 2.8.5 în Java Construiește Calea.

Convertiți mesajul XML în Java obiecte folosind JAXB

În primul rând, definim performanțele clasificate în pachet serviciu.

La primul pas al primului proces, folosim tehnica Un-marshalling of JAXB.

Un-marshalling oferă unei aplicații client capacitatea de a converti datele XML în derivate JAXB Java obiecte.

Definim functia getObjectFromXmlFile pentru a dezactiva fișierul nostru XML înapoi la a Java obiect. Această funcție este definită în clasă 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;
	}
}

Numim codul de mai sus în clasă XmlToJsonService.

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

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

Apoi trecem la pasul următor.

Converti Java obiecte la mesajul JSON folosind Gson

La acest pas, definim funcția writeDataToJsonFile pentru a scrie date în fișierul JSON. Această funcție este definită în clasă JsonService.

Rețineți că pentru a scrie o listă de șiruri JSON, folosim funcția beginArray() si endArray(). Între aceste două funcții, scriem fiecare șir JSON.

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

Numim codul de mai sus în clasă XmlToJsonService.

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

Acesta este primul proces.

Convertiți mesajul JSON în Java obiecte folosind Gson

La prima etapă a celui de-al doilea proces, definim funcția getDataFromJsonFile pentru a citi datele din fișierul JSON. Această funcție este definită în clasă JsonService.

Rețineți că pentru a citi o listă de șiruri JSON, folosim funcția beginArray() si endArray(). Între aceste două funcții, citim fiecare șir JSON.

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

	}
}

Numim codul de mai sus în clasă XmlToJsonService.

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

jsonService.getDataFromJsonFile(filePathIn, roles, persons);

Apoi trecem la pasul următor.

Converti Java obiecte la mesaj XML folosind JAXB

La acest pas, folosim tehnica Marshalling de JAXB.

Marshalling oferă unei aplicații client capacitatea de a converti un derivat JAXB Java arborele de obiecte în date XML.

Definim funcția parseObjectToXm la Marshall Java obiect la mesajul XML. Această funcție este definită în clasă

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

Numim codul de mai sus în clasă 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);

Acesta este al doilea proces.

Concluzie

În acest tutorial, am învățat pe scurt un mod în care JAXB poate citi date XML și Gson le poate scrie în JSON. Dimpotrivă, am văzut și modul în care a citit Gson JSON date și JAXB le scrie în XML.