Konversi JSON ke XML Java menggunakan Gson dan JAXB dengan Contoh

Apa itu JSON?

JSON adalah singkatan dari Javascript Notasi Objek, yaitu suatu bentuk data yang mengikuti aturan tertentu yang saat ini dapat dibaca oleh sebagian besar bahasa pemrograman. Kita dapat dengan mudah menyimpannya ke dalam suatu berkas atau rekaman dalam basis data. Format JSON menggunakan pasangan kunci-nilai untuk mendeskripsikan data.

Dengan mengikuti contoh ini, kami mendefinisikan string JSON yang menyimpan informasi pribadi:

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

Jadi sintaks JSON sangat sederhana. Setiap informasi data akan memiliki dua bagian: kunci dan nilai yang sesuai dengan nama field dan nilainya dalam record tertentu. Namun jika ditilik lebih jauh, ada beberapa hal seperti ini:

• String JSON diapit oleh kurung kurawal {}.
• Kunci dan nilai JSON harus diapit tanda kutip {“}.
• Jika datanya lebih banyak (lebih banyak pasangan kunci => nilai), kita menggunakan koma (,) untuk memisahkannya.
• Kunci JSON harus berupa huruf atau angka yang tidak ditandatangani, _, dan tanpa spasi, karakter pertama tidak boleh disetel ke angka.

Apa itu XML?

XML adalah singkatan dari eXtensible Markup Language, juga disebut bahasa markup yang dapat diperluas yang diusulkan oleh World Wide Web Consortium (https://www.w3.org/) untuk membuat bahasa markup lainnya. Ini adalah subset sederhana yang dapat mendeskripsikan berbagai jenis data, sehingga sangat berguna dalam 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.

Ada beberapa fitur pembuatan XML yang lebih berguna dalam beragam 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, apa pun cara data tersebut 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 akan memiliki tag pembuka dan tag penutup sebagai berikut:

<node>content</node>

Di mana:

• adalah tag terbuka, nama tag ini ditentukan oleh Anda.
• merupakan tag tertutup, nama tag ini harus sesuai dengan nama tag terbuka.
• Konten adalah isi dari tag ini.

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

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

Apa itu Gson?

Gson (https://github.com/google/gson) adalah pustaka Java yang memungkinkan pengguna untuk mengonversi dari Java objek ke string JSON dan juga mengkonversi dari string JSON ke Java obyek. Gson dapat bekerja dengan sewenang-wenang Java objek termasuk objek yang sudah ada tanpa Anda memiliki kode sumbernya.

Sejak versi 1.6, Gson memperkenalkan dua kelas baru – JSONReader dan Penulis Json untuk menyediakan pemrosesan streaming pada data JSON.

• Penulis Json – Streaming tulis ke JSON. Sintaks implementasi umumnya adalah sebagai berikut. Kami membuat Penulis Json obyek. Untuk memulai dan menyelesaikan pembuatan string JSON, kami menggunakan fungsi tersebut mulaiObjek() dan objek akhir(). Di tengah eksekusi kedua fungsi tersebut, kita melakukan penulisan data berpasangan (key => value).

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

• JSONReader – Streaming baca dari JSON. Sintaks implementasi umum adalah sebagai berikut. Kita membuat objek JsonReader. Untuk memulai dan menyelesaikan pembuatan string JSON, kami menggunakan fungsibeginObject() dan endObject(). Di tengah eksekusi kedua fungsi tersebut, kita melakukan pembacaan data secara berpasangan (key => value).

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) pemrosesan data JSON.

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 melalui spesifikasi, kita dapat menggunakan implementasi berbeda untuk standar ini.

Dengan JAXB, kami sering menggunakan anotasi dasar berikut, yaitu:

• @XmlRootElement: Anotasi ini menentukan tag terluar dari file XML dan oleh karena itu dinyatakan di atas kelas.
• @XmlElementWrapper: Anotasi ini membuat elemen XML pembungkus di sekitar koleksi.
• @XmlElement: Anotasi ini digunakan untuk mendeklarasikan atribut objek sebagai tag file XML.
• @XmlAttribute: Anotasi ini juga digunakan untuk mendeklarasikan atribut objek sebagai tag file XML.

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

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

Dalam JAXBConteks objek, ia memiliki metode untuk membuat objek yang mengubah konten XML menjadi a Java obyek, Unmarshaller.

Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();

Dalam JAXBConteks objek, ia memiliki metode untuk membuat objek yang mengubah Java keberatan dengan konten XML itu Marshaller.

Marshaller marshallerObj = jaxbContext.createMarshaller();

Bagaimana cara mengubah XML ke JSON?

Kami menerapkan contoh konversi XML – JSON pada platform:

• Buka JDK 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 adalah Contoh XmlToJson.

Langkah 3) Buat folder.
Buat folder data/masukan berisi dua file sampel.xml dan sampel.json.

Pertama mari kita definisikan XML kita dengan departemen, peran dan orang properti.

Arsitektur umumnya adalah: Bahasa Indonesia: .

<?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, kami mendefinisikan JSON memiliki gagasan yang sama:

{
	"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) Tentukan objek.
Tentukan kelas objek yang sesuai dalam paket 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 Siapkan perpustakaan Gson 2.8.5 ke dalam Java Bangun Jalur.

Ubah pesan XML menjadi Java objek menggunakan JAXB

Pertama, kami mendefinisikan kinerja yang dikelaskan dalam paket layanan.

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

Un-marshalling memberi aplikasi klien kemampuan untuk mengubah data XML menjadi turunan JAXB Java benda.

Kami mendefinisikan fungsi getObjectFromXmlFile untuk membatalkan marshal file XML kita kembali ke a Java obyek. Fungsi ini didefinisikan di 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;
	}
}

Kami memanggil kode di atas di 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();

Lalu kita lanjutkan ke langkah berikutnya.

mengubah Java objek ke pesan JSON menggunakan Gson

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

Perhatikan bahwa untuk menulis daftar string JSON, kami menggunakan fungsi tersebut mulaiArray() dan array akhir(). Di antara kedua fungsi ini, kami menulis setiap string 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) {
	}
}

Kami memanggil kode di atas di kelas Layanan XmlToJson.

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

Itu proses pertama.

Ubah pesan JSON menjadi Java objek menggunakan Gson

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

Perhatikan bahwa untuk membaca daftar string JSON, kami menggunakan fungsi tersebut mulaiArray() dan array akhir(). Di antara kedua fungsi ini, kita membaca setiap string 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) {

	}
}

Kami memanggil kode di atas di kelas Layanan XmlToJson.

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

jsonService.getDataFromJsonFile(filePathIn, roles, persons);

Lalu kita lanjutkan ke langkah berikutnya.

mengubah Java objek ke pesan XML menggunakan JAXB

Pada langkah ini, kami menggunakan teknik Marshalling dari JAXB.

Marshalling menyediakan aplikasi klien kemampuan untuk mengkonversi turunan JAXB Java pohon objek menjadi data XML.

Kami mendefinisikan fungsi parseObjectToXm ke marshall Java objek ke pesan XML. Fungsi ini didefinisikan di kelas

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

Kami memanggil kode di atas di 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);

Itu proses kedua.

Kesimpulan

Dalam tutorial ini, kita mempelajari secara singkat salah satu cara JAXB membaca data XML dan Gson menulisnya ke JSON. Sebaliknya, kami juga melihat cara Gson membaca JSON data dan JAXB menulisnya ke XML.