Konverter JSON til XML Java bruker Gson og JAXB

Hva er JSON?

JSON er en forkortelse for JavaSkriptobjektnotasjon, som er et dataformat som følger regler som de fleste programmeringsspråk kan lese. Vi kan enkelt lagre det i en fil eller lagre det i en database. JSON-formatet bruker nøkkelverdipar for å beskrive data.

I følgende eksempel definerer vi en JSON-streng som lagrer personlig informasjon:

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

Så syntaksen til JSON er veldig enkel. Hvert dataelement har to deler, en nøkkel og en verdi, som korresponderer med feltnavnet og verdien i en post. Ved nærmere ettersyn finnes det noen regler som denne:

• JSON-strengen er omsluttet av krøllete klammeparenteser {}.
• Nøklene til JSON må være omsluttet av doble anførselstegn, og strengverdier må også være i anførselstegn.
• Hvis det er mer data (flere nøkkel => verdipar), bruker vi komma (,) for å skille dem.
• JSON-nøkler skal bruke vanlige bokstaver, tall eller understrekingstegnet, uten mellomrom, og det første tegnet skal ikke være et tall.

Hva er XML?

XML står for eXtensible Markup Language, foreslått av World Wide Web Consortium (https://www.w3.org/) for å lage andre markupspråk. Dette er et enkelt delsett som kan beskrive mange forskjellige typer data, så det er veldig nyttig for å dele data mellom systemer.

Tagger i XML er ofte ikke forhåndsdefinert, men de er laget i henhold til brukerkonvensjoner. XML introduserer nye funksjoner basert på fordelene med HTML.

Det finnes noen nyttige XML-funksjoner for ulike systemer og løsninger:

• XML kan utvides: XML lar deg lage dine egne tilpassede tagger som passer til din applikasjon.
• XML bærer data, det viser dem ikke: XML lar deg lagre data uavhengig av hvordan de skal vises.
• XML er en vanlig standard: XML ble utviklet av World Wide Web Consortium (W3C) og er tilgjengelig som en åpen standard.

XML er bygget på en nestet nodestruktur. Hver node har en åpningstag og en avsluttende tag som følger:

<node>content</node>

Der:

• er en åpen tagg, og navnet på denne taggen defineres av deg.
• er en avsluttende tag, og navnet på denne taggen må samsvare med navnet på den åpne taggen.
• innhold er innholdet i denne taggen.

Øverst i hver XML-fil må du deklarere en tagg for å angi hvilken XML-versjon som er i bruk. Syntaksen til instruksjonstaggen:

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

JSON vs XML: Viktige forskjeller

Begge formatene inneholder strukturerte data, og tabellen nedenfor viser hvorfor et prosjekt kan trenge å veksle mellom dem.

Hva er Gson?

Gson (https://github.com/google/gson) Er en Java bibliotek som lar brukere konvertere en Java objekt til en JSON-streng, og også for å konvertere en JSON-streng tilbake til en Java gjenstand. Gson kan jobbe med vilkårlig Java objekter, inkludert eksisterende objekter med kildekode du ikke har.

Siden versjon 1.6 introduserer Gson to klasser, JsonReader og jsonWriter, for å tilby strømming av behandling av JSON-data.

• jsonWriter – Strømming av skriving til JSON. Vi lager en jsonWriter objekt. For å starte og fullføre oppretting av et JSON-objekt bruker vi funksjonene beginObject() og endObject()Mellom disse to kallene skriver vi data som par (nøkkel => verdi).

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

• JsonReader – Strømming av lesing fra JSON. Vi oppretter et JsonReader-objekt. For å starte og fullføre lesing av et JSON-objekt bruker vi funksjonene beginObject() og endObject(). Mellom disse to kallene leser vi data som par (nøkkel => verdi).

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

Gson-strømmeprosessering er rask. Du må imidlertid håndtere hvert par (nøkkel => verdi) av JSON-dataene selv.

Hva er JAXB?

JAXB står for Java Architecture for XML Binding, som er et bibliotek som bruker merknader for å konvertere Java objekter til XML-innhold og omvendt. Siden JAXB er definert av en spesifikasjon, kan vi bruke forskjellige implementeringer av denne standarden.

Med JAXB bruker vi ofte følgende grunnleggende annoteringer:

• @XmlRootElementDenne annotasjonen spesifiserer den ytterste taggen i XML-filen, og den er derfor deklarert over en klasse.
• @XmlElementWrapper: Denne merknaden lager et XML-omslagselement rundt samlinger.
• @XmlElementDenne annotasjonen erklærer at en egenskap til objektet blir en underordnet tagg til XML-filen.
• @XmlAttributeDenne annotasjonen erklærer at en egenskap ved objektet blir et attributt på den omkringliggende taggen.

Den generelle implementeringen er som følger. Først initialiserer vi JAXBContekst objektet med Mitt objekt klasse å konvertere.

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

Dette JAXBContekst objektet har en metode som oppretter et objekt som konverterer XML-innhold til en Java objektet, det Unmarshaller.

Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();

Det samme JAXBContekst objektet har også en metode som oppretter objektet som konverterer en Java objektet inn i XML-innhold, Marshaller.

Marshaller marshallerObj = jaxbContext.createMarshaller();

Hvordan konvertere XML til JSON?

Vi implementerer eksemplet på konvertering fra XML til JSON på følgende plattform. Versjonene nedenfor er de som brukes til skjermbildene. Nyere versjoner av JDK, Eclipse, og Gson fungerer på samme måte, med forbehold om JAXB-notatet ovenfor.

• OpenJDK 8 for Ubuntu 18.04 x64.
• Eclipse IDE 2019-03 (4.11.0) x64 Java Utvikling for Ubuntu.
• Gson 2.8.5.

Trinn 1) Lag prosjekt.
Lage en ny Java prosjekt.

Trinn 2) Angi prosjektnavn.
Sett prosjektnavnet til XmlToJsonEksempel.

Trinn 3) Opprett en mappe.
Opprett mappen data/inndata som inneholder de to filene sample.xml og sample.json.

La oss først definere XML-en vår med avdeling, rolleog person egenskaper.

Den generelle arkitekturen er: én avdeling har mange roller, og én rolle har mange personer. Diagrammet nedenfor viser disse relasjonene.

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

For det andre definerer vi JSON-en som uttrykker den samme ideen. Legg merke til at den flate personlisten blir en nestet matrise inni hver rolle, som er nøyaktig den transformasjonen konverteringskoden utfører.

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

Trinn 4) Definer objekter.
Definer de tilsvarende objektklassene i pakken modell.

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

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

}

Trinn 5) Sett opp biblioteket.
Legg til og konfigurer Gson 2.8.5-biblioteket i Java Bygg sti.

Hvis prosjektet bruker Maven I stedet for en manuelt lagt til jar-fil, deklareres de samme bibliotekene som avhengigheter. Versjon 2.8.5 er festet her for å matche skjermbildene, og eventuelle senere Gson-utgivelser fungerer identisk for dette eksemplet:

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

Konverter XML-melding til Java objekter som bruker JAXB

Først definerer vi utøvende klasser i pakken tjeneste.

I det første trinnet i den første prosessen bruker vi av-marshalling-teknikken JAXB.

Avmarshalling gir en klientapplikasjon muligheten til å konvertere XML-data til JAXB-avledede data. Java objekter.

Vi definerer funksjonen getObjectFromXmlFile å fjerne XML-filen vår fra marsjalen tilbake til en Java objekt. Denne funksjonen er definert i klassen 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;
	}
}

Vi kaller koden ovenfor i klassen XmlToJsonService.

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

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

På dette tidspunktet har XML-filen blitt tre Java objekter i minnet. Neste trinn skriver dem ut som JSON.

Konverter Java protesterer mot JSON-melding ved hjelp av Gson

I dette trinnet definerer vi funksjonen writeDataToJsonFile å skrive data til JSON-filen. Denne funksjonen er definert i klassen JsonService.

Merk at for å skrive en liste over JSON-objekter bruker vi funksjonene beginArray() og endArray()Mellom disse to kallene skriver vi hvert JSON-objekt.

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

Vi kaller koden ovenfor i klassen XmlToJsonService.

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

Det er den første prosessen. Den indre løkken matcher hver person mot gjeldende rolle-ID, og ​​det er slik den flate XML-personlisten blir en nestet JSON-matrise.

Konverter JSON-melding til Java objekter ved hjelp av Gson

I det første trinnet i den andre prosessen definerer vi funksjonen getDataFromJsonFile for å lese data fra JSON-filen. Denne funksjonen er definert i klassen JsonService.

Merk at for å lese en liste over JSON-objekter bruker vi funksjonene beginArray() og endArray()Mellom disse to kallene leser vi hvert JSON-objekt.

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

	}
}

Vi kaller koden ovenfor i klassen XmlToJsonService.

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

jsonService.getDataFromJsonFile(filePathIn, roles, persons);

Konverter Java objekter til XML-melding ved hjelp av JAXB

I dette trinnet bruker vi marshallingteknikken til JAXB.

Marshalling gir en klientapplikasjon muligheten til å konvertere en JAXB-avledet Java objekttreet til XML-data.

Vi definerer funksjonen parseObjectToXml å marsjere Java objekt til en XML-melding. Denne funksjonen er definert i klassen 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");
	}
}

Vi kaller koden ovenfor i klassen 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);

Det er den andre prosessen. Den genererte filen samsvarer med den opprinnelige sample.xml, som bekrefter at rundreisen bevarte alle verdiene.

Slik konverterer du JSON til XML i Java uten en modellklasse?

Tilnærmingen ovenfor er det riktige valget når strukturen er kjent og stabil, fordi de kommenterte klassene dokumenterer konsekvensene.tract. Når strukturen er ukjent eller endres ofte, er en generisk konverter raskere.

Ocuco org.json biblioteket utfører konverteringen på to linjer, uten noen modellklasse:

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

Utgang:

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

Merk at den generiske ruten ikke produserer noe rotelement og ingen attributter, så XML.toString(json, "root") er vanligvis nødvendig. Tabellen nedenfor viser de to tilnærmingene side om side.

JAXB leser XML-data og Gson skriver dem til JSON, og den omvendte banen bruker Gson til å lese JSON data mens JAXB skriver dem tilbake til XML. For å gå videre, se gjennom XML grunnleggende, det bredere Java tutorialog Jasper rapporterer, som bruker begge formatene som rapportdatakilder.

Spørsmål og svar