Konvertera JSON till XML Java med hjälp av Gson och JAXB

Vad är JSON?

JSON är en förkortning för JavaScript Object Notation, ett dataformat som följer regler som de flesta programmeringsspråk kan läsa. Vi kan enkelt spara det till en fil eller lagra det i en databas. JSON-formatet använder nyckel-värde-par för att beskriva data.

I följande exempel definierar vi en JSON-sträng som lagrar personlig information:

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

Så syntaxen för JSON är mycket enkel. Varje dataelement har två delar, en nyckel och ett värde, som motsvarar fältnamnet och dess värde i en post. Vidare finns det några regler som denna:

• JSON-strängen är omgiven av hängslen {}.
• JSON-nycklarna måste omges av dubbla citattecken, och strängvärden måste också omges av citationstecken.
• Om det finns mer data (fler nyckel => värdepar) använder vi kommatecken (,) för att separera dem.
• JSON-nycklar ska använda vanliga bokstäver, siffror eller understreck, utan mellanslag, och det första tecknet ska inte vara ett nummer.

Vad är XML?

XML står för eXtensible Markup Language, föreslaget av World Wide Web Consortium (https://www.w3.org/) för att skapa andra markupspråk. Detta är en enkel delmängd som kan beskriva många olika typer av data, så den är mycket användbar för att dela data mellan system.

Taggar i XML är ofta inte fördefinierade, utan de skapas enligt användarkonventioner. XML introducerar nya funktioner baserade på fördelarna med HTML.

Det finns några användbara XML-funktioner för olika system och lösningar:

• XML är utbyggbart: XML låter dig skapa dina egna anpassade taggar som passar din applikation.
• XML bär data, det visar den inte: XML låter dig lagra data oavsett hur den kommer att visas.
• XML är en vanlig standard: XML utvecklades av World Wide Web Consortium (W3C) och är tillgänglig som en öppen standard.

XML är byggt på en kapslad nodstruktur. Varje nod har en öppningstagg och en avslutande tagg enligt följande:

<node>content</node>

I vilken:

• är en öppen tagg, och namnet på denna tagg bestäms av dig.
• är en avslutande tagg, och namnet på denna tagg måste matcha namnet på den öppna taggen.
• innehåll är innehållet i denna tagg.

Överst i varje XML-fil måste du deklarera en tagg som anger vilken XML-version som används. Syntaxen för instruktionstaggen:

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

JSON vs XML: Viktiga skillnader

Båda formaten innehåller strukturerad data, och tabellen nedan visar varför ett projekt kan behöva växla mellan dem.

Vad är Gson?

Gson (https://github.com/google/gson) Är en Java bibliotek som låter användare konvertera en Java objekt till en JSON-sträng, och även för att konvertera en JSON-sträng tillbaka till en Java objekt. Gson kan arbeta med godtyckliga Java objekt, inklusive befintliga objekt vars källkod du inte har.

Sedan version 1.6 introducerar Gson två klasser, JsonReader och JsonWriter, för att tillhandahålla strömmande bearbetning av JSON-data.

• JsonWriter – Strömmande skrivning till JSON. Vi skapar en JsonWriter objekt. För att börja och avsluta skapandet av ett JSON-objekt använder vi funktionerna beginObject() och endObject()Mellan dessa två anrop skriver vi data som par (nyckel => värde).

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

• JsonReader – Strömmande läsning från JSON. Vi skapar ett JsonReader-objekt. För att börja och avsluta läsningen av ett JSON-objekt använder vi funktionerna beginObject() och endObject(). Mellan dessa två anrop läser vi data som par (nyckel => värde).

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ömningsbehandling är snabb. Du måste dock hantera varje par (nyckel => värde) av JSON-data själv.

Vad är JAXB?

JAXB står för Java Architecture for XML Binding, som är ett bibliotek som använder anteckningar för att konvertera Java objekt till XML-innehåll och vice versa. Eftersom JAXB definieras av en specifikation kan vi använda olika implementeringar av denna standard.

Med JAXB använder vi ofta följande grundläggande annoteringar:

• @XmlRootElementDenna annotering anger den yttersta taggen i XML-filen, och den deklareras därför ovanför en klass.
• @XmlElementWrapper: Den här anteckningen skapar ett XML-omslagselement runt samlingar.
• @XmlElementDenna annotering deklarerar att en egenskap för objektet blir en underordnad tagg till XML-filen.
• @XmlAttributeDenna annotering deklarerar att en egenskap för objektet blir ett attribut på den omgivande taggen.

Den allmänna implementeringen är som följer. Först initierar vi JAXBContext objekt med MyObject klass att konvertera.

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

Detta JAXBContext objektet har en metod som skapar ett objekt som konverterar XML-innehåll till en Java objektet, det Unmarshaller.

Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();

Det samma JAXBContext objektet har också en metod som skapar objektet som konverterar en Java objekt till XML-innehåll, Marshaller.

Marshaller marshallerObj = jaxbContext.createMarshaller();

Hur konverterar man XML till JSON?

Vi implementerar exemplet på konvertering från XML till JSON på följande plattform. Versionerna nedan är de som används för skärmdumparna. Nyare versioner av JDK, Eclipse, och Gson fungerar på samma sätt, med förbehåll för JAXB-noten ovan.

• OpenJDK 8 för Ubuntu 18.04 x64.
• Eclipse IDE 2019-03 (4.11.0) x64 Java Utveckling för Ubuntu.
• Gson 2.8.5.

Steg 1) Skapa projekt.
Skapa en ny Java projektet.

Steg 2) Ange projektnamn.
Sätt projektnamnet till XmlToJsonExempel.

Steg 3) Skapa en mapp.
Skapa mappen dataingång som innehåller de två filerna sample.xml och sample.json.

Låt oss först definiera vår XML med avdelning, rolloch personen egenskaper.

Den allmänna arkitekturen är: en avdelning har många roller och en roll har många personer. Diagrammet nedan visar dessa relationer.

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

För det andra definierar vi JSON:en som uttrycker samma idé. Observera att den platta personlistan blir en kapslad array inuti varje roll, vilket är exakt den transformation som konverteringskoden utför.

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

Steg 4) Definiera objekt.
Definiera motsvarande objektklasser i paketet modell.

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

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

}

Steg 5) Ställ in biblioteket.
Lägg till och konfigurera Gson 2.8.5-biblioteket i Java Bygg väg.

Om projektet använder Maven istället för en manuellt tillagd jar-fil deklareras samma bibliotek som beroenden. Version 2.8.5 är fäst här för att matcha skärmdumparna, och alla senare Gson-utgåvor fungerar identiskt för detta exempel:

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

Konvertera XML-meddelande till Java objekt med JAXB

Först definierar vi de utförande klasserna i paketet service.

I det första steget i den första processen använder vi av-marshalling-tekniken JAXB.

Avmarshalling ger en klientapplikation möjligheten att konvertera XML-data till JAXB-härledda data. Java föremål.

Vi definierar funktionen getObjectFromXmlFile att avregistrera vår XML-fil tillbaka till en Java objekt. Denna funktion är definierad 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 anropar koden ovan 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();

Vid det här laget har XML-filen blivit tre Java objekt i minnet. Nästa steg skriver ut dem som JSON.

Konvertera Java invänder mot JSON-meddelanden med Gson

I detta steg definierar vi funktionen writeDataToJsonFile för att skriva data till JSON-filen. Denna funktion definieras i klassen JsonService.

Observera att för att skriva en lista med JSON-objekt använder vi funktionerna beginArray() och endArray()Mellan dessa två anrop skriver vi varje 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 anropar ovanstående kod i klassen XmlToJsonService.

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

Det är den första processen. Den inre loopen matchar varje person mot det aktuella roll-ID:t, vilket är hur den platta XML-personlistan blir en kapslad JSON-array.

Konvertera JSON-meddelande till Java objekt med Gson

I det första steget i den andra processen definierar vi funktionen getDataFromJsonFile för att läsa data från JSON-filen. Denna funktion definieras i klassen JsonService.

Observera att för att läsa en lista med JSON-objekt använder vi funktionerna beginArray() och endArray()Mellan dessa två anrop läser vi varje 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 anropar ovanstående kod i klassen XmlToJsonService.

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

jsonService.getDataFromJsonFile(filePathIn, roles, persons);

Konvertera Java invänder mot XML-meddelanden med JAXB

I det här steget använder vi marshallingtekniken JAXB.

Marshalling ger en klientapplikation möjligheten att konvertera en JAXB-härledd Java objektträd till XML-data.

Vi definierar funktionen parseObjectToXml att marskala Java objekt till ett XML-meddelande. Denna funktion definieras 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 anropar ovanstående kod 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 är den andra processen. Den genererade filen matchar den ursprungliga sample.xml, vilket bekräftar att returprocessen bevarade alla värden.

Hur man konverterar JSON till XML i Java utan en modellklass?

Ovanstående tillvägagångssätt är rätt val när strukturen är känd och stabil, eftersom de annoterade klasserna dokumenterar konsekvensen.tract. När strukturen är okänd eller ändras ofta är en generisk konverterare snabbare.

Ocuco-landskapet org.json biblioteket utför konverteringen på två rader, utan någon modellklass:

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

Produktion:

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

Observera att den generiska rutten inte producerar något rotelement och inga attribut, så XML.toString(json, "root") krävs normalt. Tabellen nedan visar de två metoderna sida vid sida.

JAXB läser XML-data och Gson skriver den till JSON, och den omvända sökvägen använder Gson för att läsa JSON data medan JAXB skriver tillbaka den till XML. För att gå vidare, granska XML grunderna, det bredare Java handledningoch Jasper, som använder båda formaten som rapportdatakällor.

Vanliga frågor