Konvertálja a JSON-t XML-re Java Gson és JAXB használatával a példával

Mi a JSON?

A JSON a szó rövidítése Javascript Object Notation, amely egy olyan adatforma, amely egy bizonyos szabályt követ, amely szerint a legtöbb programozási nyelv jelenleg olvasható. Könnyen elmenthetjük fájlba vagy rekordba az adatbázisban. A JSON formátum kulcs-érték párokat használ az adatok leírására.

A példát követve definiálunk egy JSON-karakterláncot, amely személyes adatokat tárol:

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

Tehát a JSON szintaxisa nagyon egyszerű. Minden adatinformáció két részből áll: kulcsból és értékből, amelyek megfelelnek a mező nevének és értékének egy bizonyos rekordban. De ha tovább nézzük, van néhány ehhez hasonló dolog:

• A JSON-karakterláncot kapcsos zárójelek veszik körül {}.
• A JSON kulcsait és értékeit idézőjelek közé kell tenni {“}.
• Ha több adat van (több kulcs => értékpár), akkor vesszőt (,) használunk az elválasztáshoz.
• A JSON-kulcsok előjel nélküli betűk vagy számok, _ karakterek, szóközök nélkül, az első karakter nem lehet szám.

Mi az XML?

Az XML az eXtensible Markup Language rövidítése, amelyet a World Wide Web Consortium által javasolt kiterjeszthető jelölőnyelvnek is neveznek (https://www.w3.org/) más jelölőnyelvek létrehozásához. Ez egy egyszerű részhalmaz, amely sok különböző típusú adatot leírhat, ezért nagyon hasznos a rendszerek közötti adatmegosztásban.

Az XML címkéi gyakran nincsenek előre definiálva, de a felhasználói konvencióknak megfelelően jönnek létre. XML új funkciókat vezet be a HTML előnyei alapján.

Van még néhány hasznos XML-készítési funkció a különféle rendszerekben és megoldásokban:

• Az XML bővíthető: az XML lehetővé teszi saját egyedi címkék létrehozását az alkalmazásnak megfelelően.
• Az XML adatokat hordoz, nem jeleníti meg: az XML lehetővé teszi az adatok tárolását, függetlenül attól, hogy hogyan jelennek meg.
• Az XML egy általános szabvány: az XML-t a World Wide Web Consortium (W3C) fejlesztette ki, és nyílt szabványként érhető el.

Az XML beágyazott csomóponti struktúrára épül. Minden csomópontnak lesz egy nyitó és egy záró címkéje az alábbiak szerint:

<node>content</node>

Amiben:

• egy nyitott címke, a címke nevét Ön határozza meg.
• zárt címke, a címke nevének meg kell egyeznie a nyitott címke nevével.
• tartalom ez a címke tartalma.

Minden XML-fájl tetején deklarálnia kell egy címkét, amely jelzi, hogy az XML verziója használatban van. Az utasításcímke szintaxisa:

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

Mi az a Gson?

Gson (https://github.com/google/gson) egy Java könyvtár, amely lehetővé teszi a felhasználók számára, hogy a Java objektumot JSON-karakterláncra, és konvertálhat JSON-karakterláncból a következőre Java objektum. A Gson tetszőlegesen tud dolgozni Java objektumok, beleértve a meglévő objektumokat anélkül, hogy rendelkezne a forráskódjukkal.

Az 1.6-os verzió óta a Gson két új osztályt vezet be – JsonReader és a JsonWriter a JSON-adatok adatfolyam-feldolgozásának biztosításához.

• JsonWriter – Streaming írás JSON-ba. Az általános megvalósítás szintaxisa a következő. Létrehozunk a JsonWriter tárgy. A JSON-karakterlánc létrehozásának megkezdéséhez és befejezéséhez a függvényt használjuk beginObject() és a endObject(). E két függvény végrehajtásának közepén páros adatírást végzünk (kulcs => érték).

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

• JsonReader – Streaming olvasás JSON-ból. Az általános megvalósítás szintaxisa a következő. Létrehozunk egy JsonReader objektumot. A JSON-karakterlánc létrehozásának megkezdéséhez és befejezéséhez a beginObject() és az endObject() függvényeket használjuk. E két funkció végrehajtása közben az adatok páros beolvasását végezzük (kulcs => érték).

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

A Gson streaming feldolgozása gyors. Azonban a JSON-adatok feldolgozásának minden párját (kulcs => érték) kezelnie kell.

Mi az a JAXB?

A JAXB jelentése Java ArchiTecture for XML Binding, amely egy olyan könyvtár, amely megjegyzéseket használ a konvertáláshoz Java objektumokat XML-tartalomra és fordítva. Mivel a JAXB specifikáción keresztül van definiálva, különböző implementációkat használhatunk ehhez a szabványhoz.

A JAXB esetében gyakran használjuk a következő alapvető megjegyzéseket, nevezetesen:

• @XmlRootElement: Ez a megjegyzés határozza meg, hogy mi az XML-fájl legkülső címkéje, és ezért az osztály tetején van deklarálva.
• @XmlElementWrapper: Ez a megjegyzés egy burkoló XML elemet hoz létre a gyűjtemények körül.
• @XmlElement: Ez az objektum attribútumának deklarálására használt annotáció az XML fájl címkéje.
• @XmlAttribute: Ezt a megjegyzést arra is használják, hogy az objektum attribútumaként deklarálják, hogy az XML-fájl címkéje.

Az általános megvalósítás szintaxisa a következő. Először inicializáljuk a JAXBContextus objektum a MyObject átalakítandó objektum.

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

Ebben JAXBContextus objektum, van egy metódusa olyan objektum létrehozására, amely az XML tartalmat a Java tárgy, Unmarshaller.

Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();

Ebben JAXBContextus objektum, van egy metódusa az objektum létrehozására, amely átalakítja a Java objektumot az adott XML-tartalomra Marshaller.

Marshaller marshallerObj = jaxbContext.createMarshaller();

Hogyan lehet XML-t JSON-ba konvertálni?

Az XML – JSON konverzió példáját valósítjuk meg a platformon:

• Nyissa meg a JDK 8-at Ubuntu 18.04 x64.
• Eclipse IDE 2019-03 (4.11.0) x64 Java Fejlesztés a Ubuntu.
• Gson 2.8.5.

Step 1) Projekt létrehozása.
Újat csinálni Java Project.

Step 2) Állítsa be a projekt nevét.
A projektnév beállítása XmlToJsonPélda.

Step 3) Hozzon létre egy mappát.
Mappa létrehozása adatbemenet két fájlt tartalmaz minta.xml és a sample.json.

Először határozzuk meg az XML-ünket ezzel osztály, szerep és a person tulajdonságait.

Az általános építészet a következő: ; .

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

Másodszor, meghatározzuk a JSON-t, amelynek ugyanaz az elképzelése:

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

Step 4) Határozza meg az objektumot.
Határozza meg a megfelelő objektumosztályokat a csomagban 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;
	}

}

Step 5) Állítsa be a könyvtárat.
A Gson 2.8.5 könyvtár hozzáadása és beállítása Java Építsd meg az útvonalat.

Konvertálja az XML-üzenetet Java objektumok JAXB használatával

Először is definiáljuk a csomagba sorolt ​​teljesítményt szolgáltatás.

Az első folyamat első lépésében a JAXB Un-marshalling technikáját használjuk.

A rendezetlenség lehetővé teszi az ügyfélalkalmazás számára, hogy az XML-adatokat JAXB-alapúvá konvertálja Java tárgyakat.

Meghatározzuk a funkciót getObjectFromXmlFile az XML-fájlunk visszaállításához a Java objektum. Ez a függvény az osztályban van definiálva 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;
	}
}

A fenti kódot hívjuk az órán XmlToJsonService.

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

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

Ezután megyünk a következő lépésre.

Megtérít Java objektumok a JSON-üzenethez a Gson használatával

Ebben a lépésben meghatározzuk a függvényt writeDataToJsonFile adatok írásához a JSON-fájlba. Ez a függvény az osztályban van definiálva JsonService.

Vegye figyelembe, hogy a JSON-karakterláncok listájának írásához a függvényt használjuk beginArray() és a endArray(). E két függvény közé minden JSON-karakterláncot írunk.

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

A fenti kódot hívjuk az órán XmlToJsonService.

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

Ez az első folyamat.

JSON-üzenet konvertálása erre: Java objektumok a Gson segítségével

A második folyamat első lépésében meghatározzuk a függvényt getDataFromJsonFile adatok olvasásához a JSON-fájlból. Ez a függvény az osztályban van definiálva JsonService.

Vegye figyelembe, hogy a JSON-karakterláncok listájának olvasásához a függvényt használjuk beginArray() és a endArray(). E két függvény között minden JSON-karakterláncot beolvasunk.

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

	}
}

A fenti kódot hívjuk az órán XmlToJsonService.

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

jsonService.getDataFromJsonFile(filePathIn, roles, persons);

Ezután megyünk a következő lépésre.

Megtérít Java objektumok XML-üzenetbe a JAXB használatával

Ennél a lépésnél a JAXB Marshalling technikáját használjuk.

A Marshalling biztosítja a kliens alkalmazás számára a JAXB származtatott konvertálásának lehetőségét Java objektumfát XML adatokká.

Meghatározzuk a parseObjectToXm függvényt a marshallhoz Java objektum az XML üzenetre. Ez a függvény az osztályban van definiálva

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

A fenti kódot hívjuk az órán 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);

Ez a második folyamat.

Összegzés

Ebben az oktatóanyagban röviden megtanultuk, hogyan tudja a JAXB XML-adatokat olvasni, a Gson pedig JSON-ba írhatja azokat. Ellenkezőleg, azt is láttuk, ahogy Gson olvasott JSON adatok és a JAXB XML-be írja.