Konvertera JSON till XML Java använder Gson och JAXB med Exempel

Vad är JSON?

JSON är en förkortning för Javascript Object Notation, som är en form av data som följer en viss regel att de flesta programmeringsspråk för närvarande är läsbara. Vi kan enkelt spara det till en fil eller post i databasen. JSON-formatet använder nyckel-värdepar för att beskriva data.

När vi följer exemplet definierar vi en JSON-sträng som lagrar personlig information:

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

Så syntaxen för JSON är väldigt enkel. Varje datainformation kommer att ha två delar: nyckel och värde som motsvarar fältnamnet och dess värde i en viss post. Men när man tittar vidare finns det några saker som detta:

• JSON-strängen är omgiven av hängslen {}.
• Nycklarna och värdena för JSON måste omges av citattecken {“}.
• Om det finns mer data (mer nyckel => värdepar) använder vi kommatecken (,) för att separera.
• JSON-nycklar ska vara osignerade bokstäver eller siffror, _, och inga mellanslag, det första tecknet ska inte vara inställt på siffror.

Vad är XML?

XML står för eXtensible Markup Language, även kallat det extensible markup language som föreslås av World Wide Web Consortium (https://www.w3.org/) för att skapa andra märkningsspråk. Detta är en enkel delmängd som kan beskriva många olika typer av data, så det är mycket användbart 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 mer användbara funktioner för att skapa XML i 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, inte visar det: XML låter dig lagra data oavsett hur det 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 kommer att ha en öppningstagg och en avslutande tagg enligt följande:

<node>content</node>

I vilken:

• är en öppen tagg, namnet på denna tagg definieras av dig.
• är en stängd tagg, måste namnet på denna tagg 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 för att indikera vilken version av XML som används. Syntaxen för instruktionstaggen:

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

Vad är Gson?

Gson (https://github.com/google/gson) är ett java-bibliotek som tillåter användare att konvertera från en Java objekt till JSON-sträng och även konvertera från en JSON-sträng till Java objekt. Gson kan arbeta med godtyckliga Java objekt inklusive befintliga objekt utan att du har deras källkod.

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

• JsonWriter – Strömmande skriv till JSON. Syntaxen för generell implementering är följande. Vi skapar en JsonWriter objekt. För att börja och avsluta skapa en JSON-sträng använder vi funktionen beginObject() och endObject(). Mitt under exekveringen av dessa två funktioner utför vi skrivning av data med 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. Syntaxen för generell implementering är följande. Vi skapar ett JsonReader-objekt. För att börja och avsluta skapa en JSON-sträng använder vi funktionen beginObject() och endObject(). Mitt under exekveringen av dessa två funktioner utför vi läsning av data med 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 streaming bearbetning är snabb. Du måste dock hantera varje par (nyckel => värde) för bearbetning av JSON-data.

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 invänder mot XML-innehåll och vice versa. Eftersom JAXB definieras via en specifikation kan vi använda olika implementeringar för denna standard.

Med JAXB använder vi ofta följande grundläggande kommentarer, nämligen:

• @XmlRootElement: Den här anteckningen anger vad den yttersta taggen i XML-filen är och därför deklareras den överst i en klass.
• @XmlElementWrapper: Den här anteckningen skapar ett XML-omslagselement runt samlingar.
• @XmlElement: Denna annotering som används för att deklarera ett attribut för objektet är en tagg för XML-filen.
• @XmlAttribute: Den här anteckningen som också används för att deklarera att ett attribut för objektet är en tagg för XML-filen.

Syntaxen för generell implementering är följande. Först kommer vi att initiera JAXBContext objekt med MyObject objekt att konvertera.

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

I detta JAXBContext objekt har den en metod för att skapa ett objekt som konverterar XML-innehåll till ett Java objekt, Unmarshaller.

Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();

I detta JAXBContext objekt, har det en metod för att skapa objektet som konverterar Java invända mot XML-innehållet Marshaller.

Marshaller marshallerObj = jaxbContext.createMarshaller();

Hur konverterar man XML till JSON?

Vi implementerar exemplet med XML – JSON-konvertering på plattformen:

• Öppna JDK 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 Project.

Steg 2) Ange projektnamn.
Ange projektnamn är XmlToJsonExempel.

Steg 3) Skapa en mapp.
skapa mapp dataingång som innehåller två filer sample.xml och sample.json.

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

Den allmänna arkitekturen är: ; .

<?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 med samma idé:

{
	"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.

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

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

}

Steg 5) Konfigurera bibliotek.
Lägg till och konfigurera bibliotek Gson 2.8.5 till Java Bygg väg.

Konvertera XML-meddelande till Java objekt med JAXB

För det första definierar vi prestanda klassat i paket service.

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

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

Vi definierar funktion getObjectFromXmlFile för att ta bort vår XML-fil tillbaka till en Java objekt. Denna funktion är definierad i klass 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 kallar 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();

Sedan går vi till nästa steg.

Konvertera Java invänder mot JSON-meddelanden med Gson

I detta steg definierar vi funktion writeDataToJsonFile för att skriva data till JSON-filen. Denna funktion är definierad i klass JsonService.

Observera att för att skriva en lista med JSON-strängar använder vi funktionen beginArray() och endArray(). Mellan dessa två funktioner skriver vi varje JSON-sträng.

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 kallar ovanstående kod i klassen XmlToJsonService.

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

Det är den första processen.

Konvertera JSON-meddelande till Java objekt med Gson

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

Observera att för att läsa en lista med JSON-strängar använder vi funktionen beginArray() och endArray(). Mellan dessa två funktioner läser vi varje JSON-sträng.

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

Sedan går vi till nästa steg.

Konvertera Java invänder mot XML-meddelanden med JAXB

I detta steg använder vi tekniken Marshalling av JAXB.

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

Vi definierar funktionen parseObjectToXm till marshall Java objekt mot XML-meddelande. Denna funktion är definierad i klass

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

Slutsats

I den här handledningen lärde vi oss kortfattat ett sätt på vilket JAXB kan läsa XML-data och Gson skriva det till JSON. Tvärtom såg vi också hur Gson läste JSON data och JAXB skriver det till XML.