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

Mi a JSON?

A JSON a szó rövidítése JavaA Script Object Notation egy olyan adatformátum, amely a legtöbb programozási nyelv által olvasható szabályokat követi. Könnyen elmenthetjük fájlba vagy tárolhatjuk adatbázisban. A JSON formátum kulcs-érték párokat használ az adatok leírására.

A következő példában egy személyes adatokat tároló JSON karakterláncot definiálunk:

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

Tehát a JSON szintaxisa nagyon egyszerű. Minden adatelem két részből áll, egy kulcsból és egy értékből, amelyek megfelelnek a mező nevének és értékének egy rekordban. Továbbtekintve, van néhány szabály, mint ez:

• A JSON-karakterláncot kapcsos zárójelek veszik körül {}.
• A JSON kulcsait dupla idézőjelek közé kell tenni, a karakterlánc értékeket is idézőjelek közé.
• Ha több adat van (több kulcs => érték pár), akkor vesszővel (,) választjuk el őket.
• A JSON-kulcsoknak sima betűket, számokat vagy aláhúzás karaktert kell használniuk, szóközök nélkül, és 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 javasolt (https://www.w3.org/) más jelölőnyelvek létrehozásához. Ez egy egyszerű részhalmaz, amely sokféle adattípust képes leírni, így nagyon hasznos a rendszerek közötti adatmegosztáshoz.

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 néhány hasznos XML funkció a különféle rendszerekhez és megoldásokhoz:

• 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 megjeleníti azokat: az XML lehetővé teszi az adatok tárolását attól függetlenül, hogy azok 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ópontstruktúrára épül. Minden csomópontnak van egy nyitó és egy záró címkéje, az alábbiak szerint:

<node>content</node>

Amiben:

• egy nyitott címke, és a címke nevét Ön határozza meg.
• egy záró címke, és ennek a címkenek a nevének meg kell egyeznie a nyitó címke nevével.
• tartalom ez a címke tartalma.

Minden XML fájl tetején deklarálni kell egy címkét, amely jelzi a használt XML verziót. Az utasításcímke szintaxisa:

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

JSON vs. XML: Főbb különbségek

Mindkét formátum strukturált adatokat hordoz, és az alábbi táblázat bemutatja, hogy miért kell egy projektnek átváltania közöttük.

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 egy konvertálást Java objektum JSON karakterlánccá alakítása, valamint egy JSON karakterlánc visszaalakítása Java objektum. A Gson tetszőlegesen tud dolgozni Java objektumok, beleértve azokat a meglévő objektumokat is, amelyek forráskódja nem áll rendelkezésére.

Az 1.6-os verzió óta a Gson két osztályt vezet be, JsonReader és a jSONWriter, a JSON-adatok streamelt feldolgozásának biztosításához.

• jSONWriter – JSON-ba streamelt írás. Létrehozunk egy jSONWriter objektum. Egy JSON objektum létrehozásának megkezdéséhez és befejezéséhez a következő függvényeket használjuk: beginObject() és a endObject()E két hívás között párokként írjuk az adatokat (kulcs => érték).

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

• JsonReader – JSON-ból való folyamatos olvasás. Létrehozunk egy JsonReader objektumot. Egy JSON objektum beginObject() és endObject() függvényekkel indítjuk és fejezzük be az olvasást. E két hívás között párokként olvassuk be az adatokat (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 streamelés gyors. Azonban a JSON adatok minden egyes (kulcs => érték) párját Önnek kell kezelnie.

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 objektumok XML tartalomra és fordítva. Mivel a JAXB-t egy specifikáció definiálja, a szabvány különböző implementációit használhatjuk.

A JAXB esetében gyakran a következő alapvető annotációkat használjuk:

• @XmlRootElementEz az annotáció az XML fájl legkülső címkéjét határozza meg, ezért egy osztály felett deklarálják.
• @XmlElementWrapper: Ez a megjegyzés egy burkoló XML elemet hoz létre a gyűjtemények körül.
• @XmlElementEz a megjegyzés deklarálja, hogy az objektum egy tulajdonsága az XML fájl gyermekcímkéjévé válik.
• @XmlAttributeEz az annotáció deklarálja, hogy az objektum egy tulajdonsága attribútummá válik a környező címkén.

Az általános megvalósítás a következő. Először inicializáljuk a JAXBContextus objektum a MyObject osztály a konvertáláshoz.

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

Ez a JAXBContextus az objektumnak van egy metódusa, amely létrehoz egy objektumot, amely XML tartalmat konvertál egy Java tárgy, a Unmarshaller.

Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();

Ugyanaz JAXBContextus egy objektumnak van egy metódusa is, amely létrehozza az objektumot, amely egy konvertálja a Java objektum XML tartalomba, a Marshaller.

Marshaller marshallerObj = jaxbContext.createMarshaller();

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

Az XML-ről JSON-ra konvertálás példáját a következő platformon valósítjuk meg. Az alábbi verziókat használtuk a képernyőképekhez. A JDK újabb kiadásai, Eclipse, és a Gson ugyanúgy működnek, a fenti JAXB megjegyzésnek megfelelően.

• OpenJDK 8-hoz 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 projektet.

Step 2) Projekt nevének beállítása.
Állítsa be a projekt nevét erre: XmlToJsonPélda.

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

Először definiáljuk az XML-t a következővel: osztály, szerepés person tulajdonságait.

Az általános architektúra a következő: egy osztálynak sok szerepköre van, és egy szerepkörnek sok személye. Az alábbi ábra ezeket a kapcsolatokat mutatja.

<?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, definiáljuk a JSON-t, amely ugyanezt az elképzelést fejezi ki. Figyeljük meg, hogy a lapos személylista beágyazott tömbbé válik minden szerepkörön belül, ami pontosan az a transzformáció, amelyet a konverziós kód végrehajt.

{
	"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) Objektumok definiálása.
Definiálja a csomagban található megfelelő objektumosztályokat 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;
	}
}

Osztály.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.
Adja hozzá és állítsa be a Gson 2.8.5 könyvtárat a Java Építsd meg az útvonalat.

Ha a projekt felhasználja Maven A manuálisan hozzáadott jar fájl helyett ugyanazok a függvénykönyvtárak vannak függőségekként deklarálva. A 2.8.5-ös verzió itt van rögzítve a képernyőképekhez igazodva, és minden későbbi Gson-kiadás azonosan működik ebben a példában:

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

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

Először is definiáljuk a csomagban található teljesítő osztályokat. szolgáltatás.

Az első folyamat első lépésében a JAXB szétválasztási technikáját alkalmazzuk.

Az un-marshalling lehetővé teszi a kliensalkalmazások számára, hogy XML adatokat JAXB-ből származó formátumba konvertáljanak. Java tárgyakat.

Definiáljuk a függvényt getObjectFromXmlFile hogy az XML fájlunkat visszaállítsuk egy 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 az osztályban hívjuk meg. XmlToJsonService.

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

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

Ezen a ponton az XML fájl három részből áll. Java objektumok a memóriában. A következő lépés JSON formátumban írja ki őket.

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

Ebben a lépésben definiáljuk a függvényt writeDataToJsonFile adatok JSON fájlba írásához. Ez a függvény a következő osztályban van definiálva: JsonService.

Megjegyzendő, hogy JSON objektumok listájának írásához a következő függvényeket használjuk: beginArray() és a endArray()E két hívás között írjuk meg az egyes JSON objektumokat.

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 az osztályban hívjuk meg. XmlToJsonService.

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

Ez az első folyamat. A belső ciklus minden személyt összevet az aktuális szerepkör-azonosítóval, így válik a sima XML személylista beágyazott JSON tömbbé.

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

A második folyamat első lépésében definiáljuk a függvényt getDataFromJsonFile JSON fájlból adatokat olvas be. Ez a függvény a következő osztályban van definiálva: JsonService.

Megjegyzendő, hogy JSON objektumok listájának beolvasásához a következő függvényeket használjuk: beginArray() és a endArray()E két hívás között beolvassuk az egyes JSON objektumokat.

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 az osztályban hívjuk meg. XmlToJsonService.

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

jsonService.getDataFromJsonFile(filePathIn, roles, persons);

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

Ebben a lépésben a JAXB rendező technikáját alkalmazzuk.

A Marshalling lehetővé teszi a kliensalkalmazások számára, hogy JAXB-ből származó adatokat konvertáljanak Java objektumfát XML adatokká.

Definiáljuk a függvényt parseObjectToXml hogy felvonultassa Java objektum egy XML üzenethez. 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 az osztályban hívjuk meg. 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. A létrehozott fájl megegyezik az eredeti sample.xml fájllal, ami megerősíti, hogy az oda-vissza út minden értéket megőrizett.

Hogyan konvertáljunk JSON-t XML-be? Java modell osztály nélkül?

A fenti megközelítés a helyes választás, ha a struktúra ismert és stabil, mivel az annotált osztályok dokumentálják a kontrasztot.tract. Ha a szerkezet ismeretlen vagy gyakran változik, egy generikus konverter gyorsabb.

Az org.json A könyvtár két sorban, modellosztály nélkül végzi el a konverziót:

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

output:

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

Megjegyzendő, hogy az általános útvonal nem hoz létre gyökérelemet és attribútumokat, tehát XML.toString(json, "root") általában szükséges. Az alábbi táblázat egymás mellett mutatja be a két megközelítést.

A JAXB XML adatokat olvas, a Gson pedig JSON-ba írja, a fordított útvonal pedig Gson-t használ az olvasáshoz. JSON adatokat, miközben a JAXB visszaírja azokat XML-be. További információkért tekintse át XML alapok, a tágabb Java oktatóiés JasperReports, amely mindkét formátumot jelentésadat-forrásként használja.

GYIK