Převést JSON na XML Java pomocí Gson a JAXB s příkladem
James Hartman
Co je JSON?
JSON je zkratka pro Javascript Object Notation, což je forma dat, která se řídí určitým pravidlem, že většina programovacích jazyků je v současnosti čitelná. Můžeme jej jednoduše uložit do souboru nebo zaznamenat do databáze. Formát JSON používá k popisu dat páry klíč–hodnota.
V následujícím příkladu definujeme řetězec JSON, který ukládá osobní údaje:
{
"username" : "guru99user",
"email" : "guru99user@mail.com"
}
Syntaxe JSON je tedy velmi jednoduchá. Každá datová informace bude mít dvě části: klíč a hodnotu, které odpovídají názvu pole a jeho hodnotě v určitém záznamu. Ale pokud se podíváme dále, existuje několik takových věcí:
- Řetězec JSON je uzavřen do složených závorek {}.
- Klíče a hodnoty JSON musí být uzavřeny v uvozovkách {“}.
- Pokud je dat více (více párů klíčů => hodnot), použijeme k oddělení čárky (,).
- Klíče JSON by měly být písmena nebo čísla bez znaménka, _ a žádné mezery, první znak by neměl být nastaven na čísla.
Co je XML?
XML je zkratka pro eXtensible Markup Language, také nazývaný rozšiřitelný značkovací jazyk navržený World Wide Web Consortium (https://www.w3.org/) k vytvoření dalších značkovacích jazyků. Jedná se o jednoduchou podmnožinu, která může popisovat mnoho různých typů dat, takže je velmi užitečná při sdílení dat mezi systémy.
Tagy v XML často nejsou předdefinované, ale jsou vytvářeny podle uživatelských konvencí. XML zavádí nové funkce založené na výhodách HTML.
V různých systémech a řešeních jsou některé užitečnější funkce pro vytváření XML:
- XML je rozšiřitelné: XML vám umožňuje vytvářet vlastní vlastní značky, které vyhovují vaší aplikaci.
- XML přenáší data, ne je zobrazuje: XML umožňuje ukládat data bez ohledu na to, jak budou zobrazena.
- XML je běžný standard: XML byl vyvinut konsorciem World Wide Web Consortium (W3C) a je k dispozici jako otevřený standard.
XML je postaveno na vnořené struktuře uzlů. Každý uzel bude mít úvodní značku a závěrečnou značku takto:
<node>content</node>
Ve kterém:
- je otevřená značka, název této značky definujete vy.
- je uzavřená značka, název této značky se musí shodovat s názvem otevřené značky.
- obsah je obsahem tohoto tagu.
V horní části každého souboru XML musíte deklarovat značku označující používanou verzi XML. Syntaxe značky instrukce:
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
Co je Gson?
Gson (https://github.com/google/gson) je java knihovna, která uživatelům umožňuje převádět z a Java objekt na řetězec JSON a také převést z řetězce JSON na Java objekt. Gson může pracovat s libovolným Java objekty včetně existujících objektů, aniž byste měli jejich zdrojový kód.
Od verze 1.6 zavádí Gson dvě nové třídy – JsonReader si JsonWriter k zajištění streamingového zpracování dat JSON.
- JsonWriter – Streamování zápisu do JSON. Syntaxe pro obecnou implementaci je následující. Vytváříme a JsonWriter objekt. K zahájení a dokončení vytváření řetězce JSON používáme funkci beginObject() si endObject(). Uprostřed provádění těchto dvou funkcí provedeme zápis dat s dvojicemi (klíč => hodnota).
JsonWriter writer = new JsonWriter();
writer.beginObject();
writer.name("key").value("value");
writer.endObject();
- JsonReader – Streamování čtení z JSON. Syntaxe pro obecnou implementaci je následující. Vytvoříme objekt JsonReader. K zahájení a dokončení vytváření řetězce JSON používáme funkce beginObject() a endObject(). Uprostřed provádění těchto dvou funkcí provádíme čtení dat s dvojicemi (klíč => hodnota).
JsonReader reader = new JsonReader();
reader.beginObject();
while (reader.hasNext()) {
String name = reader.nextName();
if (name.equals("key")) {
String value = reader.nextString();
}
}
reader.endObject();
Zpracování streamování Gson je rychlé. Musíte však zpracovat každý pár (klíč => hodnota) zpracování dat JSON.
Co je JAXB?
Zkratka JAXB znamená Java Architecture for XML Binding, což je knihovna, která ke konverzi používá anotace Java objektů k obsahu XML a naopak. Jelikož je JAXB definován pomocí specifikace, můžeme pro tento standard použít různé implementace.
U JAXB často používáme následující základní anotace, jmenovitě:
- @XmlRootElement: Tato anotace určuje, jaká je nejvzdálenější značka souboru XML, a proto je deklarována nad třídou.
- @XmlElementWrapper: Tato anotace vytvoří kolem kolekcí obalový prvek XML.
- @XmlElement: Tato anotace použitá k deklaraci atributu objektu je tag souboru XML.
- @XmlAttribute: Tato anotace se také používá k deklaraci atributu objektu jako tagu souboru XML.
Syntaxe pro obecnou implementaci je následující. Nejprve inicializujeme JAXBContext objekt s MůjObjekt objekt převést.
JAXBContext jaxbContext = JAXBContext.newInstance(MyObject.class);
V tomto JAXBContext objekt, má metodu k vytvoření objektu, který převádí obsah XML na a Java objekt, Unmarshaller.
Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();
V tomto JAXBContext objekt, má metodu k vytvoření objektu, který převádí Java objekt vůči obsahu XML, který je Marshaller.
Marshaller marshallerObj = jaxbContext.createMarshaller();
Jak převést XML na JSON?
Příklad převodu XML – JSON implementujeme na platformě:
- Otevřete JDK 8 pro Ubuntu 18.04 x64.
- Eclipse IDE 2019-03 (4.11.0) x64 Java Vývoj pro Ubuntu.
- Gson 2.8.5.
Krok 1) Vytvořit projekt.
Vytvoř nový Java Projekt.
Krok 2) Nastavit název projektu.
Nastavit Název projektu je XmlToJsonExample.
Krok 3) Vytvořte složku.
Vytvořit složku data/vstup obsahující dva soubory ukázka.xml si sample.json.
Pojďme nejprve definovat naše XML pomocí oddělení, role si člověk Vlastnosti.
Obecná architektura je: ; .
<?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>
Za druhé, definujeme JSON se stejnou myšlenkou:
{
"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"
}
]
}
]
}
Krok 4) Definujte objekt.
Definujte odpovídající třídy objektů v balíčku model.
- 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;
}
}
Krok 5) Nastavit knihovnu.
Přidejte a nastavte knihovnu Gson 2.8.5 do Java Vytvořit cestu.
Převést zprávu XML na Java objektů pomocí JAXB
Nejprve definujeme provádění klasifikované v balíčku servis.
V prvním kroku prvního procesu používáme techniku Un-marshalling JAXB.
Un-marshalling poskytuje klientské aplikaci schopnost převádět data XML na odvozená z JAXB Java objekty.
Definujeme funkci getObjectFromXmlFile zrušit zařazení našeho souboru XML zpět do a Java objekt. Tato funkce je definována ve třídě 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;
}
}
Ve třídě voláme výše uvedený kód XmlToJsonService.
XMLService xmlService = new XMLService(); XMLModel xmlModel = xmlService.getObjectFromXmlFile(filePathIn); Department department = xmlModel.getDepartment(); List<Role> roles = department.getRoles(); List<Person> persons = department.getPersons();
Poté přejdeme k dalšímu kroku.
Konvertovat Java objektů do zprávy JSON pomocí Gson
V tomto kroku definujeme funkci writeDataToJsonFile pro zápis dat do souboru JSON. Tato funkce je definována ve třídě JsonService.
Všimněte si, že k zápisu seznamu řetězců JSON používáme funkci beginArray() si endArray(). Mezi tyto dvě funkce zapíšeme každý řetězec JSON.
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) {
}
}
Výše uvedený kód nazýváme ve třídě XmlToJsonService.
JsonService jsonService = new JsonService(); jsonService.writeDataToJsonFile(filePathOut, roles, persons);
To je první proces.
Převést zprávu JSON na Java objektů pomocí Gson
V prvním kroku druhého procesu definujeme funkci getDataFromJsonFile pro čtení dat ze souboru JSON. Tato funkce je definována ve třídě JsonService.
Všimněte si, že ke čtení seznamu řetězců JSON používáme funkci beginArray() si endArray(). Mezi těmito dvěma funkcemi čteme každý řetězec JSON.
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) {
}
}
Výše uvedený kód nazýváme ve třídě XmlToJsonService.
JsonService jsonService = new JsonService(); List<Role> roles = new ArrayList<>(); List<Person> persons = new ArrayList<>(); jsonService.getDataFromJsonFile(filePathIn, roles, persons);
Jak převést Json do XML Java?
JSON do XML in JAVA se převede pomocí JSONObject json = new JSONObject(str); Tětiva xml = XML. Pokud máte platný soubor dtd nebo xml, je velmi snadné transformovat json na xml a také xml na json.
Poté přejdeme k dalšímu kroku.
Konvertovat Java objektů do zprávy XML pomocí JAXB
V tomto kroku používáme techniku Marshalling JAXB.
Marshalling poskytuje klientské aplikaci schopnost převádět odvozené JAXB Java objektový strom do XML dat.
Definujeme funkci parseObjectToXm pro marshall Java objekt ke zprávě XML. Tato funkce je definována ve třídě
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");
}
}
Výše uvedený kód nazýváme ve třídě 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);
To je druhý proces.
Závěr
V tomto tutoriálu jsme se krátce naučili jeden způsob, jak JAXB může číst data XML a Gson je zapisovat do JSON. Naopak jsme viděli i způsob, jakým Gson četl JSON data a JAXB je zapíše do XML.
