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

Ce este JSON?

JSON este o abreviere pentru JavaNotația obiectelor de script, care este un format de date care respectă regulile pe care majoritatea limbajelor de programare le pot citi. Îl putem salva cu ușurință într-un fișier sau îl putem stoca într-o bază de date. Formatul JSON folosește perechi cheie-valoare pentru a descrie datele.

În exemplul următor, definim un șir JSON care stochează informații personale:

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

Deci, sintaxa JSON este foarte simplă. Fiecare element de date are două părți, o cheie și o valoare, care corespund numelui câmpului și valorii sale dintr-o înregistrare. Privind mai departe, există câteva reguli de genul acesta:

• Șirul JSON este închis de acolade {}.
• Cheile JSON trebuie să fie incluse între ghilimele duble, iar valorile șirurilor de caractere trebuie, de asemenea, să fie între ghilimele.
• Dacă există mai multe date (mai multe perechi cheie => valoare), folosim virgule (,) pentru a le separa.
• Cheile JSON trebuie să utilizeze litere simple, cifre sau caracterul de subliniere, fără spații, iar primul caracter nu trebuie să fie un număr.

Ce este XML?

XML este prescurtarea de la eXtensible Markup Language (Limbaj de marcare 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 pentru 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 XML utile pentru 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 acestea 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 are o etichetă de deschidere și o etichetă de închidere, după cum urmează:

<node>content</node>

In care:

• este o etichetă deschisă, iar numele acestei etichete este definit de dvs.
• este o etichetă de închidere, iar numele acestei etichete trebuie să corespundă cu numele etichetei de deschidere.
• 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"?>

JSON vs. XML: Diferențe cheie

Ambele formate conțin date structurate, iar tabelul de mai jos arată de ce un proiect ar putea necesita trecerea de la unul la altul.

Ce este Gson?

Gson (https://github.com/google/gson) Este o Java bibliotecă ce permite utilizatorilor să convertească o Java obiect la un șir JSON și, de asemenea, pentru a converti un șir JSON înapoi într-un Java obiect. Gson poate lucra cu arbitrare Java obiecte, inclusiv obiecte existente al căror cod sursă nu îl aveți.

Încă de la versiunea 1.6, Gson introduce două clase, JsonReader și jsonWriter, pentru a oferi procesare în flux continuu a datelor JSON.

• jsonWriter – Scriere în flux continuu în JSON. Creăm un jsonWriter obiect. Pentru a începe și a termina crearea unui obiect JSON, folosim funcțiile beginObject() și endObject()Între aceste două apeluri, scriem datele ca perechi (cheie => valoare).

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

• JsonReader – Citire în flux continuu din JSON. Creăm un obiect JsonReader. Pentru a începe și a termina citirea unui obiect JSON, folosim funcțiile beginObject() și endObject(). Între aceste două apeluri, citim datele ca 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 fluxului Gson este rapidă. Cu toate acestea, trebuie să gestionați personal fiecare pereche (cheie => valoare) 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 către conținut XML și invers. Deoarece JAXB este definit printr-o specificație, putem utiliza diferite implementări ale acestui standard.

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

• @XmlRootElementAceastă adnotare specifică eticheta cea mai exterioară a fișierului XML și, prin urmare, este declarată deasupra unei clase.
• @XmlElementWrapper: Această adnotare creează un element XML wrapper în jurul colecțiilor.
• @XmlElementAceastă adnotare declară că o proprietate a obiectului devine o etichetă copil a fișierului XML.
• @XmlAttributeAceastă adnotare declară că o proprietate a obiectului devine un atribut pe eticheta înconjurătoare.

Implementarea generală este următoarea. Mai întâi, inițializăm JAXBContext obiect cu MyObject clasă de convertit.

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

Aceasta JAXBContext obiectul are o metodă care creează un obiect ce convertește conținutul XML într-un Java obiect, cel/cea/cei/cele Unmarshaller.

Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();

La fel JAXBContext obiectul are și o metodă care creează obiectul și convertește un Java obiect în conținut XML, Marshaller.

Marshaller marshallerObj = jaxbContext.createMarshaller();

Cum se convertesc XML în JSON?

Implementăm exemplul de conversie XML în JSON pe următoarea platformă. Versiunile de mai jos sunt cele utilizate pentru capturi de ecran. Versiuni mai noi ale JDK-ului, Eclipseși Gson funcționează în același mod, sub rezerva notei JAXB de mai sus.

• OpenJDK 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 la XmlToJsonExample.

Pas 3) Creați un folder.
Creați folderul introducere a datelor care conține cele două fișiere sample.xml și sample.json.

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

Arhitectura generală este următoarea: un departament are mai multe roluri, iar un rol are mai multe persoane. Diagrama de mai jos prezintă aceste relații.

<?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-ul care exprimă aceeași idee. Observați că lista de persoane devine un array imbricat în interiorul fiecărui rol, ceea ce reprezintă exact transformarea pe care o efectuează codul de conversie.

{
	"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 obiecte.
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;
	}
}

Persoană.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;
	}
}

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

Dacă proiectul folosește Maven În loc de un fișier jar adăugat manual, aceleași biblioteci sunt declarate ca dependențe. Versiunea 2.8.5 este fixată aici pentru a se potrivi cu capturile de ecran, iar orice versiune ulterioară de Gson funcționează identic pentru acest exemplu:

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

Convertiți mesajul XML în Java obiecte folosind JAXB

În primul rând, definim clasele performante din pachet serviciu.

În primul pas al primului proces, folosim tehnica de un-marshalling a JAXB.

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

Definim functia getObjectFromXmlFile pentru a anula transformarea fișierului nostru XML înapoi într-un Java obiect. Această funcție este definită în clasa 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;
	}
}

Apelăm codul de mai sus în clasa XmlToJsonService.

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

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

În acest moment, fișierul XML a devenit trei Java obiecte în memorie. Următorul pas le scrie ca JSON.

Converti Java obiecte la mesajul JSON folosind Gson

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

Rețineți că pentru a scrie o listă de obiecte JSON, folosim funcțiile beginArray() și endArray()Între aceste două apeluri, scriem fiecare obiect 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) {
	}
}

Apelăm codul de mai sus în clasa XmlToJsonService.

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

Acesta este primul proces. Bucla interioară potrivește fiecare persoană cu ID-ul rolului curent, acesta fiind modul în care lista de persoane XML plată devine un array JSON imbricat.

Convertiți mesajul JSON în Java obiecte folosind Gson

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

Rețineți că pentru a citi o listă de obiecte JSON, folosim funcțiile beginArray() și endArray()Între aceste două apeluri, citim fiecare obiect 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) {

	}
}

Apelăm codul de mai sus în clasa XmlToJsonService.

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

jsonService.getDataFromJsonFile(filePathIn, roles, persons);

Converti Java obiecte la mesaj XML folosind JAXB

În acest pas, folosim tehnica de marshalling a JAXB.

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

Definim functia parseObjectToXml a organiza Java obiect la un mesaj XML. Această funcție este definită în clasa 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");
	}
}

Apelăm codul de mai sus în clasa 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. Fișierul generat se potrivește cu sample.xml-ul original, ceea ce confirmă că traseul dus-întors a păstrat fiecare valoare.

Cum se convertește JSON în XML în Java fără o clasă model?

Abordarea de mai sus este alegerea corectă atunci când structura este cunoscută și stabilă, deoarece clasele adnotate documentează contract. Când structura este necunoscută sau se schimbă des, un convertor generic este mai rapid.

org.json biblioteca efectuează conversia în două linii, fără nicio clasă de model:

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

ieșire:

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

Rețineți că ruta generică nu produce niciun element rădăcină și niciun atribut, deci XML.toString(json, "root") este în mod normal necesar. Tabelul de mai jos prezintă cele două abordări una lângă alta.

JAXB citește datele XML, iar Gson le scrie în JSON, iar calea inversă folosește Gson pentru a citi. JSON date în timp ce JAXB le scrie înapoi în XML. Pentru a continua, consultați XML fundamentale, cu atât mai larg Java tutorial și JasperReports, care consumă ambele formate ca surse de date pentru rapoarte.

Întrebări frecvente