Konversi JSON ke XML Java menggunakan Gson dan JAXB

Apa itu JSON?

JSON adalah singkatan dari JavaScript Object Notation (JSON), yaitu format data yang mengikuti aturan yang dapat dibaca oleh sebagian besar bahasa pemrograman. Kita dapat dengan mudah menyimpannya ke dalam file atau menyimpannya di dalam basis data. Format JSON menggunakan pasangan kunci-nilai untuk mendeskripsikan data.

Pada contoh berikut, kita mendefinisikan string JSON yang menyimpan informasi pribadi:

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

Jadi, sintaks JSON sangat sederhana. Setiap item data memiliki dua bagian, kunci dan nilai, yang sesuai dengan nama field dan nilainya dalam sebuah record. Lebih lanjut, ada beberapa aturan seperti ini:

• String JSON diapit oleh kurung kurawal {}.
• Kunci JSON harus diapit oleh tanda kutip ganda, dan nilai string juga harus diapit oleh tanda kutip.
• Jika terdapat lebih banyak data (lebih banyak pasangan kunci => nilai), kita menggunakan koma (,) untuk memisahkannya.
• Kunci JSON harus menggunakan huruf, angka, atau karakter garis bawah (_) tanpa spasi, dan karakter pertama tidak boleh berupa angka.

Apa itu XML?

XML adalah singkatan dari eXtensible Markup Language, yang diusulkan oleh World Wide Web Consortium (https://www.w3.org/) untuk membuat bahasa markup lainnya. Ini adalah subset sederhana yang dapat menggambarkan berbagai jenis data, sehingga sangat berguna untuk berbagi data antar sistem.

Tag dalam XML seringkali tidak ditentukan sebelumnya, namun dibuat sesuai dengan konvensi pengguna. XML memperkenalkan fitur-fitur baru berdasarkan keunggulan HTML.

Terdapat beberapa fitur XML yang berguna untuk berbagai sistem dan solusi:

• XML dapat diperluas: XML memungkinkan Anda membuat tag khusus sendiri agar sesuai dengan aplikasi Anda.
• XML membawa data, bukan menampilkannya: XML memungkinkan Anda menyimpan data tanpa memperhatikan bagaimana data tersebut akan ditampilkan.
• XML adalah standar umum: XML dikembangkan oleh World Wide Web Consortium (W3C) dan tersedia sebagai standar terbuka.

XML dibangun di atas struktur node bersarang. Setiap node memiliki tag pembuka dan tag penutup sebagai berikut:

<node>content</node>

Di mana:

• adalah tag terbuka, dan nama tag ini ditentukan oleh Anda.
• adalah tag penutup, dan nama tag ini harus sesuai dengan nama tag pembuka.
• Konten adalah isi dari tag ini.

Di bagian atas setiap file XML, Anda harus mendeklarasikan sebuah tag untuk menunjukkan versi XML yang digunakan. Sintaks tag instruksi adalah:

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

JSON vs XML: Perbedaan Utama

Kedua format tersebut memuat data terstruktur, dan tabel di bawah ini menunjukkan mengapa sebuah proyek mungkin perlu berpindah antar format tersebut.

Apa itu Gson?

Gson (https://github.com/google/gson) Adalah Java perpustakaan yang memungkinkan pengguna untuk mengkonversi Java mengkonversi objek ke string JSON, dan juga mengkonversi string JSON kembali ke objek. Java obyek. Gson dapat bekerja dengan sewenang-wenang Java objek, termasuk objek yang sudah ada yang kode sumbernya tidak Anda miliki.

Sejak versi 1.6, Gson memperkenalkan dua kelas, JSONReader ke jsonWriter, untuk menyediakan pemrosesan streaming data JSON.

• jsonWriter – Streaming menulis ke JSON. Kita membuat sebuah jsonWriter Untuk memulai dan menyelesaikan pembuatan objek JSON, kita menggunakan fungsi-fungsi berikut. mulaiObjek() ke objek akhir()Di antara kedua panggilan tersebut, kami menulis data sebagai pasangan (kunci => nilai).

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

• JSONReader – Membaca data secara streaming dari JSON. Kita membuat objek JsonReader. Untuk memulai dan mengakhiri pembacaan objek JSON, kita menggunakan fungsi beginObject() dan endObject(). Di antara kedua panggilan tersebut, kita membaca data sebagai pasangan (kunci => nilai).

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

Pemrosesan streaming Gson cepat. Namun, Anda perlu menangani setiap pasangan (kunci => nilai) data JSON sendiri.

Apa itu JAXB?

JAXB adalah singkatan dari Java Architekstur untuk XML Binding, yang merupakan perpustakaan yang menggunakan anotasi untuk mengonversi Java objek ke konten XML dan sebaliknya. Karena JAXB didefinisikan oleh spesifikasi, kita dapat menggunakan implementasi standar ini yang berbeda.

Dengan JAXB, kita sering menggunakan anotasi dasar berikut:

• @XmlRootElementAnotasi ini menentukan tag terluar dari file XML, dan oleh karena itu dideklarasikan di atas sebuah kelas.
• @XmlElementWrapper: Anotasi ini membuat elemen XML pembungkus di sekitar koleksi.
• @XmlElementAnotasi ini menyatakan bahwa properti dari objek tersebut menjadi tag anak dari file XML.
• @XmlAttributeAnotasi ini menyatakan bahwa properti dari objek tersebut menjadi atribut pada tag yang mengelilinginya.

Implementasi umumnya adalah sebagai berikut. Pertama, kita menginisialisasi JAXBConteks keberatan dengan objek saya kelas yang akan dikonversi.

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

Kredensial mikro JAXBConteks Objek tersebut memiliki metode yang membuat objek yang mengubah konten XML menjadi sebuah Java objek, itu Unmarshaller.

Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();

Sama JAXBConteks Objek tersebut juga memiliki metode yang membuat objek yang mengkonversi sebuah Java objek menjadi konten XML, Marshaller.

Marshaller marshallerObj = jaxbContext.createMarshaller();

Bagaimana cara mengubah XML ke JSON?

Kami mengimplementasikan contoh konversi XML ke JSON pada platform berikut. Versi di bawah ini adalah versi yang digunakan untuk tangkapan layar. Rilis JDK yang lebih baru, Eclipse, dan Gson bekerja dengan cara yang sama, dengan memperhatikan catatan JAXB di atas.

• OpenJDK 8 untuk Ubuntu 18.04 x64.
• Eclipse IDE 2019-03 (4.11.0)x64 Java Pengembangan untuk Ubuntu.
• Gson 2.8.5.

Langkah 1) Buat proyek.
Buat yang baru Java proyek.

Langkah 2) Tetapkan nama proyek.
Tetapkan nama proyek menjadi Contoh XmlToJson.

Langkah 3) Buat folder.
Buat foldernya data/masukan berisi dua berkas sampel.xml ke sampel.json.

Mari kita definisikan XML kita terlebih dahulu dengan departemen, peran, dan orang properti.

Secara umum, arsitekturnya adalah: satu departemen memiliki banyak peran, dan satu peran memiliki banyak orang. Diagram di bawah ini menunjukkan hubungan tersebut.

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

Kedua, kita mendefinisikan JSON yang mengekspresikan ide yang sama. Perhatikan bahwa daftar orang yang datar menjadi array bersarang di dalam setiap peran, yang persis sama dengan transformasi yang dilakukan oleh kode konversi.

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

Langkah 4) Mendefinisikan objek.
Definisikan kelas objek yang sesuai dalam paket tersebut. model.

Peran.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;
	}
}

Orang.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;
	}
}

Departemen.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;
	}

}

Langkah 5) Siapkan perpustakaan.
Tambahkan dan atur pustaka Gson 2.8.5 di Java Bangun Jalur.

Jika proyek tersebut menggunakan Maven Alih-alih menambahkan jar secara manual, pustaka yang sama dideklarasikan sebagai dependensi. Versi 2.8.5 disematkan di sini agar sesuai dengan tangkapan layar, dan rilis Gson yang lebih baru berfungsi identik untuk contoh ini:

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

Ubah pesan XML menjadi Java objek menggunakan JAXB

Pertama, kita mendefinisikan kelas-kelas pelaksana dalam paket tersebut. layanan.

Pada langkah pertama dari proses pertama, kami menggunakan teknik un-marshalling dari JAXB.

Unmarshalling memberikan kemampuan kepada aplikasi klien untuk mengkonversi data XML menjadi data turunan JAXB. Java benda.

Kita mendefinisikan fungsi tersebut getObjectFromXmlFile untuk menguraikan kembali file XML kita menjadi sebuah Java Objek. Fungsi ini didefinisikan dalam kelas. Layanan 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;
	}
}

Kita memanggil kode di atas di dalam kelas. Layanan XmlToJson.

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

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

Pada titik ini, file XML telah menjadi tiga bagian. Java Objek-objek tersebut tersimpan dalam memori. Langkah selanjutnya adalah menuliskannya sebagai JSON.

mengubah Java objek ke pesan JSON menggunakan Gson

Pada langkah ini, kita mendefinisikan fungsi tersebut. tulisDataToJsonFile untuk menulis data ke file JSON. Fungsi ini didefinisikan dalam kelas tersebut. Layanan JSON.

Perhatikan bahwa untuk menulis daftar objek JSON, kita menggunakan fungsi-fungsi berikut. mulaiArray() ke array akhir()Di antara kedua panggilan ini, kita menulis setiap objek 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) {
	}
}

Kita memanggil kode di atas di dalam kelas. Layanan XmlToJson.

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

Itulah proses pertama. Perulangan dalam mencocokkan setiap orang dengan ID peran saat ini, yang merupakan cara daftar orang XML datar menjadi array JSON bersarang.

Ubah pesan JSON menjadi Java objek menggunakan Gson

Pada langkah pertama dari proses kedua, kita mendefinisikan fungsi tersebut. dapatkanDataDariJsonFile untuk membaca data dari file JSON. Fungsi ini didefinisikan dalam kelas tersebut. Layanan JSON.

Perlu dicatat bahwa untuk membaca daftar objek JSON, kita menggunakan fungsi-fungsi berikut. mulaiArray() ke array akhir()Di antara kedua panggilan ini, kita membaca setiap objek 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) {

	}
}

Kita memanggil kode di atas di dalam kelas. Layanan XmlToJson.

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

jsonService.getDataFromJsonFile(filePathIn, roles, persons);

mengubah Java objek ke pesan XML menggunakan JAXB

Pada langkah ini, kita menggunakan teknik marshalling dari JAXB.

Marshalling memberikan kemampuan kepada aplikasi klien untuk mengkonversi data yang berasal dari JAXB. Java pohon objek menjadi data XML.

Kita mendefinisikan fungsi tersebut menguraiObjekKeXml untuk mengerahkan Java Objek ke pesan XML. Fungsi ini didefinisikan dalam kelas tersebut. Layanan XML.

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

Kita memanggil kode di atas di dalam kelas. Layanan 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);

Itulah proses kedua. File yang dihasilkan sesuai dengan sample.xml asli, yang menegaskan bahwa proses bolak-balik tersebut mempertahankan setiap nilai.

Cara Mengonversi JSON ke XML di Java tanpa Kelas Model?

Pendekatan di atas adalah pilihan yang tepat ketika strukturnya diketahui dan stabil, karena kelas-kelas yang diberi anotasi mendokumentasikan struktur tersebut.tract. Ketika strukturnya tidak diketahui atau sering berubah, konverter generik lebih cepat.

The org.json library melakukan konversi dalam dua baris, tanpa kelas model apa pun:

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

Keluaran:

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

Perhatikan bahwa rute generik tidak menghasilkan elemen akar dan tidak ada atribut, jadi XML.toString(json, "root") biasanya diperlukan. Tabel di bawah ini menyajikan kedua pendekatan tersebut secara berdampingan.

JAXB membaca data XML dan Gson menuliskannya ke JSON, dan jalur sebaliknya menggunakan Gson untuk membaca JSON data tersebut kemudian ditulis kembali ke XML oleh JAXB. Untuk mempelajari lebih lanjut, tinjau XML dasar-dasar, yang lebih luas Java tutorial, dan Laporan Jasperyang menggunakan kedua format tersebut sebagai sumber data laporan.

Pertanyaan Umum Demo Slot