Konvertálja a JSON-t XML-re Java Gson és JAXB használatával a példával
James Hartman
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);
Hogyan lehet a Json-t XML-re konvertálni Java?
JSON-ból XML-be in JAVA a JSONObject használatával konvertálódik json = new JSONObject(str); Húr xml = XML. Ha van érvényes dtd fájlja vagy xml fájlja, akkor nagyon könnyű átalakítani a json fájlt xml-re és az xml-t is json-ra.
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.
