Muunna JSON XML-muotoon Java käyttäen Gsonia ja JAXB:tä

Mikä on JSON?

JSON on lyhenne sanoista JavaScript Object Notation, joka on datamuoto, joka noudattaa useimpien ohjelmointikielten lukemia sääntöjä. Voimme helposti tallentaa sen tiedostoon tai tietokantaan. JSON-muoto käyttää avain-arvo-pareja datan kuvaamiseen.

Seuraavassa esimerkissä määrittelemme JSON-merkkijonon, joka tallentaa henkilötietoja:

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

JSONin syntaksi on siis hyvin yksinkertainen. Jokaisella dataelementillä on kaksi osaa, avain ja arvo, jotka vastaavat kentän nimeä ja sen arvoa tietueessa. Tarkemmin tarkasteltuna on olemassa muutamia sääntöjä, kuten tämä:

• JSON-merkkijono on suljettu aaltosulkeilla {}.
• JSON-avaimet on laitettava lainausmerkkeihin, ja merkkijonoarvot on myös laitettava lainausmerkkeihin.
• Jos dataa on enemmän (enemmän avain => arvo -pareja), käytämme pilkkuja (,) erottamaan ne.
• JSON-avainten tulisi käyttää tavallisia kirjaimia, numeroita tai alaviivaa ilman välilyöntejä, eikä ensimmäisen merkin tulisi olla numero.

Mikä on XML?

XML on lyhenne sanoista eXtensible Markup Language, jonka on ehdottanut World Wide Web Consortium (https://www.w3.org/) muiden merkintäkielten luomiseksi. Tämä on yksinkertainen osajoukko, joka voi kuvata monenlaisia ​​tietoja, joten se on erittäin hyödyllinen tietojen jakamiseen järjestelmien välillä.

XML-tunnisteet eivät usein ole ennalta määritettyjä, vaan ne luodaan käyttäjien käytäntöjen mukaisesti. XML esittelee uusia ominaisuuksia, jotka perustuvat HTML:n etuihin.

Erilaisille järjestelmille ja ratkaisuille on joitakin hyödyllisiä XML-ominaisuuksia:

• XML on laajennettavissa: XML:n avulla voit luoda omia mukautettuja tunnisteita sovellukseesi sopiviksi.
• XML kuljettaa dataa, se ei näytä sitä: XML:n avulla voit tallentaa dataa riippumatta siitä, miten se näytetään.
• XML on yleinen standardi: XML:n on kehittänyt World Wide Web Consortium (W3C), ja se on saatavana avoimena standardina.

XML perustuu sisäkkäisiin solmuihin. Jokaisella solmulla on avaus- ja lopputunniste seuraavasti:

<node>content</node>

Jossa:

• on avoin tagi, ja sinä määrität tämän tagin nimen.
• on sulkeva tagi, ja tämän tagin nimen on vastattava avaavan tagin nimeä.
• pitoisuus on tämän tunnisteen sisältö.

Jokaisen XML-tiedoston yläreunassa on oltava tunniste, joka ilmaisee käytössä olevan XML-version. Instruction-tunnisteen syntaksi:

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

JSON vs. XML: Keskeiset erot

Molemmat muodot sisältävät strukturoitua dataa, ja alla oleva taulukko näyttää, miksi projektin on ehkä siirryttävä niiden välillä.

Mikä on Gson?

Gson (https://github.com/google/gson) on Java kirjasto, jonka avulla käyttäjät voivat muuntaa Java objektin JSON-merkkijonoksi ja myös muuntaa JSON-merkkijonon takaisin Java esine. Gson voi työskennellä mielivaltaisen kanssa Java objektit, mukaan lukien olemassa olevat objektit, joiden lähdekoodia sinulla ei ole.

Versiosta 1.6 lähtien Gson esittelee kaksi luokkaa, JsonReader ja jsonWriter, JSON-datan suoratoistokäsittelyn tarjoamiseksi.

• jsonWriter – Kirjoita suoratoistona JSON-muotoon. Luomme jsonWriter objekti. JSON-objektin luomisen aloittamiseen ja lopettamiseen käytämme funktioita beginObject() ja endObject()Näiden kahden kutsun välillä kirjoitamme tiedot pareina (avain => arvo).

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

• JsonReader – JSON-tiedon suoratoisto. Luomme JsonReader-objektin. JSON-objektin lukemisen aloittamiseen ja lopettamiseen käytämme funktioita beginObject() ja endObject(). Näiden kahden kutsun välillä luemme dataa pareittain (avain => arvo).

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

Gson-suoratoiston käsittely on nopeaa. Sinun on kuitenkin käsiteltävä jokainen JSON-datan pari (avain => arvo) itse.

Mikä on JAXB?

JAXB tarkoittaa Java Architecture for XML Binding, joka on kirjasto, joka käyttää merkintöjä muuntamiseen Java objektit XML-sisältöön ja päinvastoin. Koska JAXB on määritelty spesifikaatiossa, voimme käyttää tämän standardin erilaisia ​​toteutuksia.

JAXB:n kanssa käytämme usein seuraavia perusmerkintöjä:

• @XmlRootElementTämä annotaatio määrittää XML-tiedoston uloimman tagin, ja se on siksi deklaroitu luokan yläpuolella.
• @XmlElementWrapper: Tämä merkintä luo kääre-XML-elementin kokoelmien ympärille.
• @XmlElementTämä merkintä määrittää, että objektin ominaisuudesta tulee XML-tiedoston alisäke.
• @XmlAttributeTämä annotaatio määrittää, että objektin ominaisuudesta tulee sitä ympäröivän tagin attribuutti.

Yleinen toteutus on seuraava. Ensin alustamme JAXBConteksti esine OmaObject luokka muunnettavaksi.

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

Tämä JAXBConteksti objektilla on metodi, joka luo objektin, joka muuntaa XML-sisällön muotoon Java esine Unmarshaller.

Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();

Sama JAXBConteksti objektilla on myös metodi, joka luo objektin, joka muuntaa Java objekti XML-sisältöön, Marshaller.

Marshaller marshallerObj = jaxbContext.createMarshaller();

Kuinka muuntaa XML JSONiksi?

Toteutamme XML-JSON-muunnoksen esimerkin seuraavalla alustalla. Alla olevia versioita käytetään kuvakaappauksissa. Uudemmat JDK-versiot, Eclipseja Gson toimivat samalla tavalla, yllä olevan JAXB-huomautuksen mukaisesti.

• OpenJDK 8:lle Ubuntu 18.04 x64.
• Eclipse IDE 2019-03 (4.11.0) x64 Java Kehitys varten Ubuntu.
• Gson 2.8.5.

Vaihe 1) Luo projekti.
Luoda uusi Java projekti.

Vaihe 2) Aseta projektin nimi.
Aseta projektin nimeksi XmlToJsonExample.

Vaihe 3) Luo kansio.
Luo kansio datan syöttö joka sisältää kaksi tiedostoa sample.xml ja sample.json.

Määritellään ensin XML-koodimme seuraavasti: osasto, roolija henkilö ominaisuudet.

Yleinen arkkitehtuuri on: yhdellä osastolla on useita rooleja ja yhdellä roolilla on useita henkilöitä. Alla oleva kaavio näyttää nämä suhteet.

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

Toiseksi määrittelemme saman idean ilmaisevan JSON-tiedoston. Huomaa, että flat person -luettelosta tulee sisäkkäinen taulukko jokaisen roolin sisällä, mikä on täsmälleen saman muunnoksen muunnoskoodi suorittaa.

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

Vaihe 4) Määrittele objektit.
Määrittele vastaavat objektiluokat paketissa malli.

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

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

}

Vaihe 5) Perusta kirjasto.
Lisää ja määritä Gson 2.8.5 -kirjasto Java Rakenna polku.

Jos projektissa käytetään Maven Manuaalisesti lisätyn jar-tiedoston sijaan samat kirjastot on ilmoitettu riippuvuuksina. Versio 2.8.5 on kiinnitetty tähän vastaamaan kuvakaappauksia, ja kaikki myöhemmät Gson-julkaisut toimivat tässä esimerkissä identtisesti:

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

Muunna XML-viesti muotoon Java objektit JAXB:n avulla

Ensin määrittelemme paketin suorittavat luokat palvelu.

Ensimmäisen prosessin ensimmäisessä vaiheessa käytämme JAXB:n purkutekniikkaa.

Purkaminen antaa asiakassovellukselle mahdollisuuden muuntaa XML-dataa JAXB-pohjaiseksi Java esineitä.

Määrittelemme funktion getObjectFromXmlFile XML-tiedostomme palauttamiseksi järjestelmään Java objekti. Tämä funktio on määritelty luokassa 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;
	}
}

Kutsumme luokassa yllä olevaa koodia XmlToJsonService.

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

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

Tässä vaiheessa XML-tiedostosta on tullut kolme Java muistissa olevia objekteja. Seuraava vaihe kirjoittaa ne JSON-muodossa.

Muuntaa Java vastustaa JSON-viestiä Gsonin avulla

Tässä vaiheessa määrittelemme funktion writeDataToJsonFile kirjoittaaksesi tietoja JSON-tiedostoon. Tämä funktio on määritelty luokassa JsonService.

Huomaa, että JSON-objektien luettelon kirjoittamiseen käytämme funktioita beginArray() ja endArray()Näiden kahden kutsun välissä kirjoitamme kunkin JSON-objektin.

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

Kutsumme yllä olevaa koodia luokassa XmlToJsonService.

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

Tämä on ensimmäinen prosessi. Sisäinen silmukka vertaa kutakin henkilöä nykyiseen rooli-id:hen, jolloin yksitasoisesta XML-henkilöluettelosta tulee sisäkkäinen JSON-taulukko.

Muunna JSON-viesti muotoon Java objektit Gsonin avulla

Toisen prosessin ensimmäisessä vaiheessa määrittelemme funktion getDataFromJsonFile lukeaksesi tietoja JSON-tiedostosta. Tämä funktio on määritelty luokassa JsonService.

Huomaa, että JSON-objektien luettelon lukemiseen käytämme funktioita beginArray() ja endArray()Näiden kahden kutsun välillä luemme jokaisen JSON-objektin.

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

	}
}

Kutsumme yllä olevaa koodia luokassa XmlToJsonService.

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

jsonService.getDataFromJsonFile(filePathIn, roles, persons);

Muuntaa Java objektit XML-viestiin JAXB:n avulla

Tässä vaiheessa käytämme JAXB:n järjestelytekniikkaa.

Marshalling tarjoaa asiakassovellukselle mahdollisuuden muuntaa JAXB:stä johdetun Java objektipuu XML-tietoihin.

Määrittelemme funktion parseObjectToXml marssia Java objekti XML-viestiin. Tämä funktio on määritelty luokassa 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");
	}
}

Kutsumme yllä olevaa koodia luokassa 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);

Tämä on toinen prosessi. Luotu tiedosto vastaa alkuperäistä sample.xml-tiedostoa, mikä vahvistaa, että edestakainen matka säilytti kaikki arvot.

Kuinka muuntaa JSON XML:ksi Java ilman malliluokkaa?

Yllä oleva lähestymistapa on oikea valinta, kun rakenne on tunnettu ja vakaa, koska annotoidut luokat dokumentoivat kontract. Kun rakenne on tuntematon tai muuttuu usein, geneerinen muunnin on nopeampi.

org.json kirjasto suorittaa muunnoksen kahdella rivillä ilman malliluokkaa:

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

lähtö:

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

Huomaa, että geneerinen reitti ei tuota juurielementtiä eikä attribuutteja, joten XML.toString(json, "root") on normaalisti pakollinen. Alla olevassa taulukossa on esitetty kaksi lähestymistapaa rinnakkain.

JAXB lukee XML-dataa ja Gson kirjoittaa sen JSON-muotoon, ja käänteinen polku käyttää Gsonia lukemiseen. JSON dataa, kun JAXB kirjoittaa sen takaisin XML-muotoon. Lisätietoja on kohdassa XML perusasiat, laajempi Java oppituntija JasperRaportit, joka käyttää molempia muotoja raporttitietolähteinä.

UKK