Konwertuj JSON na XML Java używając Gsona i JAXB z przykładem
Jamesa Hartmana
Co to jest JSON?
JSON to skrót od Javascript Notacja obiektów, czyli forma danych, która podąża za pewną regułą, którą większość języków programowania jest obecnie czytelna. Możemy ją łatwo zapisać do pliku lub rekordu w bazie danych. Format JSON używa par klucz-wartość do opisu danych.
W poniższym przykładzie zdefiniujemy ciąg JSON przechowujący dane osobowe:
{
"username" : "guru99user",
"email" : "guru99user@mail.com"
}
Zatem składnia JSON jest bardzo prosta. Każda informacja o danych będzie składać się z dwóch części: klucza i wartości, które odpowiadają nazwie pola i jego wartości w określonym rekordzie. Ale patrząc głębiej, jest kilka takich rzeczy:
- Ciąg JSON jest ujęty w nawiasy klamrowe {}.
- Klucze i wartości JSON muszą być ujęte w cudzysłów {“}.
- Jeśli danych jest więcej (więcej par klucz => wartość), oddzielamy je przecinkami (,).
- Klucze JSON powinny składać się z liter lub cyfr bez znaku, znaku _ oraz żadnych spacji. Pierwszy znak nie powinien być cyfrą.
Co to jest XML?
XML oznacza eXtensible Markup Language, zwany także rozszerzalnym językiem znaczników zaproponowanym przez konsorcjum World Wide Web (https://www.w3.org/), aby utworzyć inne języki znaczników. Jest to prosty podzbiór, który może opisywać wiele różnych typów danych, dlatego jest bardzo przydatny przy udostępnianiu danych pomiędzy systemami.
Tagi w formacie XML często nie są predefiniowane, ale tworzone są zgodnie z konwencjami użytkownika. XML wprowadza nowe funkcje oparte na zaletach HTML.
Istnieje kilka bardziej przydatnych funkcji tworzenia XML w różnych systemach i rozwiązaniach:
- XML jest rozszerzalny: XML umożliwia tworzenie własnych, niestandardowych tagów pasujących do Twojej aplikacji.
- XML służy do przechowywania danych, a nie do ich wyświetlania: XML umożliwia przechowywanie danych niezależnie od sposobu ich wyświetlania.
- XML jest powszechnym standardem: XML został opracowany przez konsorcjum World Wide Web Consortium (W3C) i jest dostępny jako otwarty standard.
XML jest zbudowany na zagnieżdżonej strukturze węzłów. Każdy węzeł będzie miał znacznik otwierający i zamykający w następujący sposób:
<node>content</node>
W którym:
- jest tagiem otwartym, nazwa tego tagu jest definiowana przez Ciebie.
- jest tagiem zamkniętym, nazwa tego tagu musi odpowiadać nazwie tagu otwartego.
- zawartość jest zawartością tego tagu.
Na górze każdego pliku XML musisz zadeklarować znacznik wskazujący, która wersja XML jest używana. Składnia znacznika instrukcji:
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
Co to jest Gson?
Gson (https://github.com/google/gson) to biblioteka Java umożliwiająca użytkownikom konwersję z Java obiekt na ciąg JSON, a także przekonwertuj z ciągu JSON na Java obiekt. Gson może pracować z dowolnym Java obiekty, w tym istniejące obiekty, bez konieczności posiadania ich kodu źródłowego.
Od wersji 1.6 Gson wprowadza dwie nowe klasy – JsonReader oraz JsonWriter w celu zapewnienia przetwarzania strumieniowego danych JSON.
- JsonWriter – Zapis strumieniowy do JSON. Składnia ogólnej implementacji jest następująca. Tworzymy JsonWriter obiekt. Aby rozpocząć i zakończyć tworzenie ciągu JSON, używamy funkcji rozpocząćObiekt() oraz obiekt końcowy(). W połowie wykonywania tych dwóch funkcji dokonujemy zapisu danych parami (klucz => wartość).
JsonWriter writer = new JsonWriter();
writer.beginObject();
writer.name("key").value("value");
writer.endObject();
- JsonReader – Odczyt strumieniowy z JSON. Składnia ogólnej implementacji jest następująca. Tworzymy obiekt JsonReader. Aby rozpocząć i zakończyć tworzenie ciągu JSON, używamy funkcji BeginObject() i endObject(). W trakcie wykonywania tych dwóch funkcji dokonujemy odczytu danych parami (klucz => wartość).
JsonReader reader = new JsonReader();
reader.beginObject();
while (reader.hasNext()) {
String name = reader.nextName();
if (name.equals("key")) {
String value = reader.nextString();
}
}
reader.endObject();
Przetwarzanie strumieniowe Gson jest szybkie. Musisz jednak obsłużyć każdą parę (klucz => wartość) przetwarzania danych JSON.
Co to jest JAXB?
JAXB oznacza Java Architecture for XML Binding, która jest biblioteką korzystającą z adnotacji do konwersji Java obiektów do treści XML i odwrotnie. Ponieważ JAXB jest zdefiniowany poprzez specyfikację, możemy zastosować różne implementacje tego standardu.
W przypadku JAXB często stosujemy następujące podstawowe adnotacje, mianowicie:
- @XmlRootElement: Ta adnotacja określa, jaki jest najbardziej zewnętrzny znacznik pliku XML i dlatego jest on zadeklarowany na górze klasy.
- @XmlElementWrapper: Ta adnotacja tworzy element XML opakowania wokół kolekcji.
- @XmlElement: Ta adnotacja używana do deklarowania atrybutu obiektu jest znacznikiem pliku XML.
- @XmlAttribute: Ta adnotacja używana również do deklarowania atrybutu obiektu jest znacznikiem pliku XML.
Składnia ogólnej implementacji jest następująca. Najpierw zainicjujemy plik JAXBKontekst obiekt z MójObiekt obiekt do konwersji.
JAXBContext jaxbContext = JAXBContext.newInstance(MyObject.class);
W tym JAXBKontekst obiekt, posiada metodę tworzenia obiektu, który konwertuje zawartość XML na plik Java obiekt, Niemarshaller.
Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();
W tym JAXBKontekst obiekt, posiada metodę tworzenia obiektu, która konwertuje Java sprzeciw wobec treści XML Marshall.
Marshaller marshallerObj = jaxbContext.createMarshaller();
Jak przekonwertować XML na JSON?
Implementujemy przykładową konwersję XML – JSON na platformie:
- Otwórz JDK 8 dla Ubuntu 18.04 x64.
- Eclipse IDE 2019-03 (4.11.0) x64 Java Rozwój dla Ubuntu.
- Gson 2.8.5.
Krok 1) Utwórz projekt.
Stwórz nowy Java Projekt.
Krok 2) Ustaw nazwę projektu.
Ustaw nazwę projektu to Przykład XmlToJson.
Krok 3) Utwórz folder.
Utwórz folder wprowadzanie danych zawierający dwa pliki próbka.xml oraz próbka.json.
Najpierw zdefiniujmy nasz XML za pomocą dział, rola oraz osoba Właściwości.
Ogólna architektura jest następująca: ; .
<?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>
Po drugie, definiujemy JSON mając ten sam pomysł:
{
"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) Zdefiniuj obiekt.
Zdefiniuj odpowiednie klasy obiektów w pakiecie model.
- Rola.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;
}
}
- Osoba.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;
}
}
- Dział.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) Skonfiguruj bibliotekę.
Dodaj i skonfiguruj bibliotekę Gson 2.8.5 w Java Buduj ścieżkę.
Konwertuj wiadomość XML na Java obiekty przy użyciu JAXB
Po pierwsze, definiujemy wykonanie sklasyfikowane w pakiecie usługa.
W pierwszym kroku pierwszego procesu wykorzystujemy technikę Un-marshalling JAXB.
Un-marshalling zapewnia aplikacji klienckiej możliwość konwertowania danych XML na dane pochodzące z JAXB Java obiekty.
Definiujemy funkcję getObjectFromXmlFile aby cofnąć przekierowanie naszego pliku XML z powrotem do pliku Java obiekt. Ta funkcja jest zdefiniowana w klasie Usługa XML.
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;
}
}
Powyższy kod wywołujemy na zajęciach Usługa XmlToJson.
XMLService xmlService = new XMLService(); XMLModel xmlModel = xmlService.getObjectFromXmlFile(filePathIn); Department department = xmlModel.getDepartment(); List<Role> roles = department.getRoles(); List<Person> persons = department.getPersons();
Następnie przechodzimy do następnego kroku.
konwertować Java obiekty do wiadomości JSON przy użyciu Gsona
Na tym etapie definiujemy funkcję napiszDataToJsonFile do zapisu danych do pliku JSON. Ta funkcja jest zdefiniowana w klasie Usługa Json.
Zauważ, że do napisania listy ciągów JSON używamy funkcji początekArray() oraz tablica końcowa(). Pomiędzy tymi dwiema funkcjami piszemy każdy ciąg 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) {
}
}
Powyższy kod wywołujemy na zajęciach Usługa XmlToJson.
JsonService jsonService = new JsonService(); jsonService.writeDataToJsonFile(filePathOut, roles, persons);
To pierwszy proces.
Konwertuj wiadomość JSON na Java obiektów za pomocą Gsona
Na pierwszym etapie drugiego procesu definiujemy funkcję pobierz dane z pliku Json do odczytu danych z pliku JSON. Ta funkcja jest zdefiniowana w klasie Usługa Json.
Zauważ, że do odczytania listy ciągów JSON używamy funkcji początekArray() oraz tablica końcowa(). Pomiędzy tymi dwiema funkcjami czytamy każdy ciąg 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) {
}
}
Powyższy kod wywołujemy na zajęciach Usługa XmlToJson.
JsonService jsonService = new JsonService(); List<Role> roles = new ArrayList<>(); List<Person> persons = new ArrayList<>(); jsonService.getDataFromJsonFile(filePathIn, roles, persons);
Jak przekonwertować Jsona na XML Java?
JSON do XML in JAVA jest konwertowany przy użyciu JSONObject json = new JSONObject(str); Strunowy XML = XML. Jeśli masz prawidłowy plik dtd lub plik xml, bardzo łatwo jest przekształcić json w xml, a także xml w json.
Następnie przechodzimy do następnego kroku.
konwertować Java obiektów do wiadomości XML przy użyciu JAXB
Na tym etapie używamy techniki Marshalling of JAXB.
Marshalling zapewnia aplikacji klienckiej możliwość konwersji formatu pochodnego JAXB Java drzewo obiektów na dane XML.
Definiujemy funkcję parseObjectToXm do marshall Java obiekt do wiadomości XML. Ta funkcja jest zdefiniowana w klasie
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");
}
}
Powyższy kod wywołujemy na zajęciach Usługa XmlToJson.
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 drugi proces.
Wniosek
W tym samouczku pokrótce nauczyliśmy się jednego ze sposobów, w jaki JAXB może czytać dane XML, a Gson zapisywać je w JSON. Wręcz przeciwnie, widzieliśmy także sposób, w jaki czytał Gson JSON data, a JAXB zapisuje je w formacie XML.
