แปลง JSON เป็น XML Java โดยใช้ Gson และ JAXB

JSON คืออะไร?

JSON เป็นคำย่อของ JavaJSON (Script Object Notation) เป็นรูปแบบข้อมูลที่ปฏิบัติตามกฎที่ภาษาโปรแกรมส่วนใหญ่สามารถอ่านได้ เราสามารถบันทึกเป็นไฟล์หรือจัดเก็บในฐานข้อมูลได้อย่างง่ายดาย รูปแบบ JSON ใช้คู่คีย์-ค่าเพื่ออธิบายข้อมูล

ในตัวอย่างต่อไปนี้ เราจะกำหนดสตริง JSON ที่เก็บข้อมูลส่วนบุคคล:

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

ดังนั้นไวยากรณ์ของ JSON จึงง่ายมาก ข้อมูลแต่ละรายการประกอบด้วยสองส่วน คือ คีย์และค่า ซึ่งสอดคล้องกับชื่อฟิลด์และค่าของฟิลด์นั้นในระเบียน เมื่อพิจารณาให้ละเอียดขึ้น จะมีกฎเกณฑ์อีกสองสามข้อดังนี้:

• สตริง JSON ถูกปิดด้วยเครื่องหมายปีกกา {}
• คีย์ของ JSON ต้องอยู่ภายในเครื่องหมายอัญประกาศคู่ และค่าสตริงก็ต้องอยู่ภายในเครื่องหมายอัญประกาศเช่นกัน
• หากมีข้อมูลเพิ่มเติม (คู่คีย์ => ค่ามากกว่า 1 คู่) เราจะใช้เครื่องหมายจุลภาค (,) เพื่อคั่นข้อมูลเหล่านั้น
• คีย์ JSON ควรใช้ตัวอักษร ตัวเลข หรือเครื่องหมายขีดล่าง (_) เท่านั้น โดยไม่มีช่องว่าง และอักขระตัวแรกไม่ควรเป็นตัวเลข

XML คืออะไร?

XML ย่อมาจาก eXtensible Markup Language ซึ่งเสนอโดย World Wide Web Consortium (https://www.w3.org/) เพื่อสร้างภาษามาร์กอัปอื่นๆ นี่เป็นส่วนย่อยที่เรียบง่ายซึ่งสามารถอธิบายข้อมูลประเภทต่างๆ ได้มากมาย ดังนั้นจึงมีประโยชน์มากสำหรับการแบ่งปันข้อมูลระหว่างระบบ

แท็กใน XML มักไม่ได้กำหนดไว้ล่วงหน้า แต่ถูกสร้างขึ้นตามแบบแผนของผู้ใช้ XML แนะนำคุณสมบัติใหม่ตามข้อดีของ HTML

มีคุณสมบัติ XML ที่มีประโยชน์สำหรับระบบและโซลูชันที่หลากหลาย:

• XML สามารถขยายได้: XML ช่วยให้คุณสร้างแท็กที่คุณกำหนดเองเพื่อให้เหมาะกับแอปพลิเคชันของคุณ
• XML ใช้สำหรับจัดเก็บข้อมูล ไม่ใช่สำหรับการแสดงผล: XML ช่วยให้คุณจัดเก็บข้อมูลได้โดยไม่คำนึงถึงวิธีการแสดงผล
• XML เป็นมาตรฐานทั่วไป: XML ได้รับการพัฒนาโดย World Wide Web Consortium (W3C) และมีให้บริการในรูปแบบมาตรฐานเปิด

XML สร้างขึ้นบนโครงสร้างโหนดแบบซ้อนกัน โดยแต่ละโหนดจะมีแท็กเปิดและแท็กปิดดังนี้:

<node>content</node>

ซึ่งใน:

• เป็นแท็กแบบเปิด และคุณสามารถกำหนดชื่อของแท็กนี้ได้เอง
• เป็นแท็กปิด และชื่อของแท็กนี้ต้องตรงกับชื่อของแท็กเปิด
• เนื้อหา คือเนื้อหาของแท็กนี้

ที่ด้านบนของไฟล์ XML แต่ละไฟล์ คุณต้องประกาศแท็กเพื่อระบุเวอร์ชัน XML ที่ใช้งานอยู่ ไวยากรณ์ของแท็กคำสั่งมีดังนี้:

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

JSON กับ XML: ความแตกต่างที่สำคัญ

ทั้งสองรูปแบบมีข้อมูลที่มีโครงสร้าง และตารางด้านล่างแสดงให้เห็นว่าเหตุใดโครงการจึงอาจจำเป็นต้องเปลี่ยนไปใช้รูปแบบข้อมูลอื่นระหว่างสองรูปแบบนี้

Gson คืออะไร?

ซอน (https://github.com/google/gson) คือ Java ไลบรารีที่อนุญาตให้ผู้ใช้แปลง Java แปลงออบเจ็กต์เป็นสตริง JSON และแปลงสตริง JSON กลับเป็นออบเจ็กต์อีกครั้ง Java วัตถุ. Gson สามารถทำงานตามอำเภอใจได้ Java รวมถึงวัตถุที่มีอยู่แล้วซึ่งคุณไม่มีซอร์สโค้ด

ตั้งแต่เวอร์ชัน 1.6 เป็นต้นมา Gson ได้เพิ่มคลาสใหม่สองคลาส JsonReader และ เจสันWriterเพื่อให้สามารถประมวลผลข้อมูล JSON แบบสตรีมมิ่งได้

• เจสันWriter – การเขียนข้อมูลแบบสตรีมมิ่งไปยัง JSON เราสร้าง JSON ขึ้นมา เจสันWriter อ็อบเจ็กต์ ในการเริ่มต้นและสิ้นสุดการสร้างอ็อบเจ็กต์ JSON เราใช้ฟังก์ชันต่างๆ เริ่มต้นวัตถุ() และ สิ้นสุดวัตถุ()ระหว่างการเรียกใช้ฟังก์ชันทั้งสองครั้ง เราจะเขียนข้อมูลเป็นคู่ (คีย์ => ค่า)

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

• JsonReader – การอ่านข้อมูลแบบสตรีมมิ่งจาก JSON เราสร้างอ็อบเจ็กต์ JsonReader ขึ้นมา เพื่อเริ่มต้นและสิ้นสุดการอ่านอ็อบเจ็กต์ JSON เราใช้ฟังก์ชัน beginObject() และ endObject() ระหว่างการเรียกใช้ฟังก์ชันทั้งสองนี้ เราจะอ่านข้อมูลเป็นคู่ (คีย์ => ค่า)

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

การประมวลผลข้อมูลแบบสตรีมมิ่งของ Gson นั้นรวดเร็ว อย่างไรก็ตาม คุณต้องจัดการแต่ละคู่ (คีย์ => ค่า) ของข้อมูล JSON ด้วยตนเอง

JAXB คืออะไร?

JAXB ย่อมาจาก Java Architecture สำหรับ XML Binding ซึ่งเป็นไลบรารีที่ใช้คำอธิบายประกอบในการแปลง Java แปลงอ็อบเจ็กต์เป็นเนื้อหา XML และในทางกลับกัน เนื่องจาก JAXB ถูกกำหนดโดยข้อกำหนด เราจึงสามารถใช้การใช้งานที่แตกต่างกันของมาตรฐานนี้ได้

ในการใช้งาน JAXB เรามักใช้คำอธิบายประกอบพื้นฐานดังต่อไปนี้:

• @XmlRootElement: คำอธิบายประกอบนี้ระบุแท็กภายนอกสุดของไฟล์ XML ดังนั้นจึงถูกประกาศไว้เหนือคลาส
• @XmlElementWrapper: คำอธิบายประกอบนี้จะสร้างองค์ประกอบ XML แบบ wrapper รอบคอลเล็กชัน
• @XmlElement: คำอธิบายประกอบนี้ประกาศว่าคุณสมบัติของวัตถุนั้นจะกลายเป็นแท็กย่อยของไฟล์ XML
• @XmlAttribute: คำอธิบายประกอบนี้ประกาศว่าคุณสมบัติของวัตถุจะกลายเป็นแอตทริบิวต์บนแท็กที่ล้อมรอบอยู่

โดยทั่วไปแล้ว การดำเนินการมีขั้นตอนดังนี้ ขั้นแรก เราจะเริ่มต้นค่า JAXBบริบท วัตถุที่มี วัตถุของฉัน คลาสที่จะแปลง

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

แจกันดอกไม้โรแมนติกนี้ JAXBบริบท อ็อบเจ็กต์นี้มีเมธอดที่สร้างอ็อบเจ็กต์ซึ่งแปลงเนื้อหา XML เป็น Java วัตถุ, ยกเลิกมาร์แชลเลอร์.

Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();

เหมือน JAXBบริบท อ็อบเจ็กต์นี้ยังมีเมธอดที่สร้างอ็อบเจ็กต์ซึ่งแปลงค่าได้อีกด้วย Java แปลงวัตถุเป็นเนื้อหา XML มาร์แชลเลอร์.

Marshaller marshallerObj = jaxbContext.createMarshaller();

วิธีแปลง XML เป็น JSON?

เราได้นำตัวอย่างการแปลง XML เป็น JSON มาใช้บนแพลตฟอร์มต่อไปนี้ เวอร์ชันด้านล่างเป็นเวอร์ชันที่ใช้ในการแสดงภาพหน้าจอ เวอร์ชันใหม่กว่าของ JDK Eclipseและ Gson ก็ทำงานในลักษณะเดียวกัน โดยอยู่ภายใต้หมายเหตุ JAXB ข้างต้น

• OpenJDK 8 สำหรับ Ubuntu 18.04x64.
• Eclipse IDE 2019-03 (4.11.0) x64 Java การพัฒนาสำหรับ Ubuntu.
• จีสัน 2.8.5

ขั้นตอน 1) สร้างโครงการ
สร้างใหม่ Java โครงการ

ขั้นตอน 2) กำหนดชื่อโปรเจ็กต์
ตั้งชื่อโปรเจ็กต์เป็น ตัวอย่าง XmlToJson.

ขั้นตอน 3) สร้างโฟลเดอร์
สร้างโฟลเดอร์ ป้อนข้อมูล ซึ่งประกอบด้วยไฟล์สองไฟล์ ตัวอย่าง.xml และ ตัวอย่าง. json.

ก่อนอื่นเรามากำหนด XML ของเราด้วย แผนก, บทบาทและ คน สรรพคุณ

โครงสร้างโดยทั่วไปคือ หนึ่งแผนกมีหลายบทบาท และหนึ่งบทบาทมีหลายคน แผนภาพด้านล่างแสดงความสัมพันธ์เหล่านั้น

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

ประการที่สอง เรากำหนด JSON ที่แสดงแนวคิดเดียวกัน สังเกตว่ารายการบุคคลแบบแบนราบจะกลายเป็นอาร์เรย์ซ้อนกันภายในแต่ละบทบาท ซึ่งเป็นการแปลงที่โค้ดการแปลงดำเนินการอย่างแม่นยำ

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

ขั้นตอน 4) กำหนดนิยามของวัตถุ
กำหนดคลาสอ็อบเจ็กต์ที่เกี่ยวข้องในแพ็กเกจ แบบ.

บทบาท.จาวา

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

บุคคล.จาวา

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

แผนก.จาวา

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

}

ขั้นตอน 5) จัดตั้งห้องสมุด
เพิ่มและตั้งค่าไลบรารี Gson 2.8.5 ใน Java สร้างเส้นทาง.

หากโครงการใช้ Maven แทนที่จะเพิ่มไฟล์ jar ด้วยตนเอง ไลบรารีเดียวกันจะถูกประกาศเป็น dependency เวอร์ชัน 2.8.5 ถูกระบุไว้ที่นี่เพื่อให้ตรงกับภาพหน้าจอ และ Gson เวอร์ชันที่ใหม่กว่าใด ๆ ก็ใช้งานได้เหมือนกันสำหรับตัวอย่างนี้:

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

แปลงข้อความ XML เป็น Java วัตถุที่ใช้ JAXB

ขั้นแรก เราจะกำหนดคลาสที่ทำหน้าที่ในแพ็กเกจ บริการ.

ในขั้นตอนแรกของกระบวนการแรก เราใช้เทคนิคการแยกข้อมูลแบบ JAXB

การแปลงข้อมูลจาก XML เป็น JAXB (Un-marshalling) ช่วยให้แอปพลิเคชันไคลเอ็นต์สามารถแปลงข้อมูล XML เป็นข้อมูลที่ได้จาก JAXB ได้ Java วัตถุ

เรากำหนดฟังก์ชัน getObjectFromXmlFile.getObjectFromXmlFile เพื่อแปลงไฟล์ XML ของเรากลับเป็น Java วัตถุ ฟังก์ชันนี้ถูกกำหนดไว้ในคลาส 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;
	}
}

เราเรียกใช้โค้ดข้างต้นในคลาส XmlToJsonService.

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

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

ณ จุดนี้ ไฟล์ XML ได้กลายเป็นสามส่วนแล้ว Java วัตถุต่างๆ ถูกจัดเก็บไว้ในหน่วยความจำ ขั้นตอนต่อไปคือการเขียนวัตถุเหล่านั้นออกมาในรูปแบบ JSON

แปลง Java วัตถุข้อความ JSON โดยใช้ Gson

ในขั้นตอนนี้ เราจะกำหนดฟังก์ชัน เขียน DataToJsonFile เพื่อเขียนข้อมูลลงในไฟล์ JSON ฟังก์ชันนี้ถูกกำหนดไว้ในคลาส JsonService.

โปรดทราบว่าในการเขียนรายการของอ็อบเจ็กต์ JSON เราจะใช้ฟังก์ชันต่างๆ startArray() และ สิ้นสุดอาร์เรย์()ระหว่างการเรียกใช้ฟังก์ชันทั้งสองนี้ เราจะเขียนอ็อบเจ็กต์ 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) {
	}
}

เราเรียกใช้โค้ดข้างต้นในคลาส XmlToJsonService.

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

นั่นคือกระบวนการแรก วงวนภายในจะจับคู่แต่ละคนกับรหัสบทบาทปัจจุบัน ซึ่งเป็นวิธีที่ทำให้รายการบุคคลในรูปแบบ XML กลายเป็นอาร์เรย์ JSON แบบซ้อนกัน

แปลงข้อความ JSON เป็น Java วัตถุโดยใช้ Gson

ในขั้นตอนแรกของกระบวนการที่สอง เราจะกำหนดฟังก์ชัน getDataFromJsonFile.getDataFromJsonFile เพื่ออ่านข้อมูลจากไฟล์ JSON ฟังก์ชันนี้ถูกกำหนดไว้ในคลาส JsonService.

โปรดทราบว่าในการอ่านรายการอ็อบเจ็กต์ JSON เราจะใช้ฟังก์ชันต่างๆ startArray() และ สิ้นสุดอาร์เรย์()ระหว่างการเรียกใช้ทั้งสองครั้งนี้ เราจะอ่านอ็อบเจ็กต์ 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) {

	}
}

เราเรียกใช้โค้ดข้างต้นในคลาส XmlToJsonService.

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

jsonService.getDataFromJsonFile(filePathIn, roles, persons);

แปลง Java วัตถุเป็นข้อความ XML โดยใช้ JAXB

ในขั้นตอนนี้ เราจะใช้เทคนิคการจัดเรียงข้อมูลแบบ JAXB

มาร์แชลลิ่งช่วยให้แอปพลิเคชันไคลเอ็นต์สามารถแปลงข้อมูลที่ได้มาจาก JAXB ได้ Java ต้นไม้วัตถุลงในข้อมูล XML

เรากำหนดฟังก์ชัน การแยกวัตถุเป็น XML เพื่อรวบรวม Java แปลงอ็อบเจ็กต์เป็นข้อความ XML ฟังก์ชันนี้ถูกกำหนดไว้ในคลาส 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");
	}
}

เราเรียกใช้โค้ดข้างต้นในคลาส 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);

นั่นคือขั้นตอนที่สอง ไฟล์ที่สร้างขึ้นตรงกับไฟล์ sample.xml ต้นฉบับ ซึ่งยืนยันว่าการแปลงไปมาระหว่างไฟล์นั้นรักษาค่าทุกอย่างไว้ได้

วิธีการแปลง JSON เป็น XML ใน Java โดยไม่มีคลาสโมเดลใช่ไหม?

แนวทางข้างต้นเป็นทางเลือกที่เหมาะสมเมื่อโครงสร้างเป็นที่รู้จักและมีความเสถียร เนื่องจากคลาสที่มีคำอธิบายประกอบจะช่วยบันทึกความสัมพันธ์นั้นtract. เมื่อโครงสร้างไม่เป็นที่รู้จักหรือเปลี่ยนแปลงบ่อย ตัวแปลงทั่วไปจะเร็วกว่า

การขอ org.json ไลบรารีนี้ทำการแปลงข้อมูลด้วยบรรทัดโค้ดเพียงสองบรรทัด โดยไม่ต้องใช้คลาสโมเดลใดๆ:

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

Output:

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

โปรดทราบว่าเส้นทางทั่วไปจะไม่สร้างองค์ประกอบรากและไม่มีแอตทริบิวต์ใดๆ ดังนั้น XML.toString(json, "root") โดยปกติแล้วจำเป็นต้องมี ตารางด้านล่างแสดงวิธีการทั้งสองแบบเปรียบเทียบกัน

JAXB อ่านข้อมูล XML และ Gson เขียนข้อมูลนั้นลงใน JSON ส่วนในเส้นทางย้อนกลับ Gson จะอ่านข้อมูล XML อีกครั้ง JSON ข้อมูลในขณะที่ JAXB เขียนข้อมูลนั้นกลับไปยัง XML สำหรับข้อมูลเพิ่มเติม โปรดตรวจสอบ XML พื้นฐานในวงกว้าง Java เกี่ยวกับการสอนและ แจสเปอร์รีพอร์ตส์ซึ่งใช้ทั้งสองรูปแบบเป็นแหล่งข้อมูลสำหรับรายงาน

คำถามที่พบบ่อย