JSON को XML में बदलें Java Gson और JAXB का उपयोग करना

द्वारा: जेम्स हार्टमैन जेम्स हार्टमैन
Hours Updated

⚡ स्मार्ट सारांश

JSON को XML में बदलें Java मैप का उपयोग करके Gson और JAXB का उपयोग करनाping दोनों प्रारूपों को एक ही एनोटेटेड पर Java इस लेख में प्रत्येक प्रारूप को परिभाषित किया गया है, प्रोजेक्ट को सेट अप किया गया है, JAXB का उपयोग करके XML को अनमार्शल किया गया है, Gson का उपयोग करके JSON लिखा गया है, और पूरी प्रक्रिया को उलटा किया गया है।

  • ️ JSON संरचना: डेटा को कर्ली ब्रैकेट के अंदर कुंजी और मान युग्मों के रूप में संग्रहीत किया जाता है, जिसमें प्रत्येक प्रविष्टि को अल्पविराम से अलग किया जाता है।
  • ️ XML संरचना: डेटा को नेस्टेड नोड्स में संग्रहीत किया जाता है, जहां प्रत्येक ओपनिंग टैग के लिए एक मिलान करने वाला क्लोजिंग टैग आवश्यक होता है।
  • 🔗 साझा मॉडल: टिप्पणीयुक्त का एक सेट Java क्लासेस एक सेतु का काम करती हैं, इसलिए किसी भी फॉर्मेट को सीधे दूसरे में पार्स नहीं किया जाता है।
  • 📥 अनमार्शलिंग: JAXB एक XML फ़ाइल पढ़ता है और उसमें मौजूद मान लौटाता है। Java अनमार्शेलर क्लास के माध्यम से ऑब्जेक्ट ट्री।
  • 📤 स्ट्रीमिंग राइट: जीसन जेसनWriter यह beginObject, name, value और endObject कॉल के साथ JSON को क्रमिक रूप से उत्सर्जित करता है।
  • 🔄 Reverse पथ: JsonReader JSON से ऑब्जेक्ट्स को पुनर्निर्मित करता है, और JAXB Marshaller उन्हें XML के रूप में वापस लिखता है।
  • ⚠️ रनटाइम नोट: JAXB ने JDK को छोड़ दिया Java 11, इसलिए jakarta.xml.bind निर्भरता को स्पष्ट रूप से जोड़ा जाना चाहिए।
विस्तार में पढ़ें

JSON को XML में बदलें Java

जेएसओएन क्या है?

JSON एक संक्षिप्त नाम है Javaस्क्रिप्ट ऑब्जेक्ट नोटेशन (JSON) एक डेटा फॉर्मेट है जो ऐसे नियमों का पालन करता है जिन्हें अधिकांश प्रोग्रामिंग भाषाएँ पढ़ सकती हैं। इसे आसानी से किसी फ़ाइल में सहेजा जा सकता है या डेटाबेस में संग्रहीत किया जा सकता है। JSON फॉर्मेट डेटा का वर्णन करने के लिए कुंजी-मान युग्मों का उपयोग करता है।

निम्नलिखित उदाहरण में, हम एक JSON स्ट्रिंग को परिभाषित करते हैं जो व्यक्तिगत जानकारी को संग्रहीत करती है:

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

JSON का सिंटैक्स बहुत सरल है। डेटा के प्रत्येक आइटम के दो भाग होते हैं, एक कुंजी और एक मान, जो रिकॉर्ड में फ़ील्ड नाम और उसके मान के अनुरूप होते हैं। आगे देखें तो, कुछ नियम इस प्रकार हैं:

  • JSON स्ट्रिंग को घुंघराले ब्रेसेज़ {} द्वारा संलग्न किया गया है।
  • JSON की कुंजियों को दोहरे उद्धरण चिह्नों में बंद किया जाना चाहिए, और स्ट्रिंग मानों को भी उद्धरण चिह्नों में बंद किया जाना चाहिए।
  • यदि अधिक डेटा (अधिक कुंजी => मान युग्म) हैं, तो हम उन्हें अलग करने के लिए अल्पविराम (,) का उपयोग करते हैं।
  • JSON कुंजी में केवल अक्षर, संख्याएँ या अंडरस्कोर वर्ण का उपयोग किया जाना चाहिए, कोई रिक्त स्थान नहीं होना चाहिए, और पहला अक्षर संख्या नहीं होना चाहिए।

एक्सएमएल क्या है?

XML का पूरा नाम एक्सटेंसिबल मार्कअप लैंग्वेज है, जिसे वर्ल्ड वाइड वेब कंसोर्टियम द्वारा प्रस्तावित किया गया था।https://www.w3.org/अन्य मार्कअप भाषाओं को बनाने के लिए इसका उपयोग किया जाता है। यह एक सरल उपसमूह है जो कई अलग-अलग प्रकार के डेटा का वर्णन कर सकता है, इसलिए यह सिस्टमों के बीच डेटा साझा करने के लिए बहुत उपयोगी है।

XML में टैग प्रायः पूर्वनिर्धारित नहीं होते, बल्कि उन्हें उपयोगकर्ता की परम्पराओं के अनुसार बनाया जाता है। एक्सएमएल HTML के लाभों के आधार पर नई सुविधाएँ प्रस्तुत करता है।

विभिन्न प्रणालियों और समाधानों के लिए XML में कुछ उपयोगी विशेषताएं हैं:

  • XML एक्सटेंसिबल है: XML आपको अपने अनुप्रयोग के अनुरूप स्वयं के कस्टम टैग बनाने की अनुमति देता है।
  • XML डेटा को स्थानांतरित करता है, उसे प्रदर्शित नहीं करता: XML आपको डेटा को इस बात की परवाह किए बिना संग्रहीत करने की अनुमति देता है कि इसे कैसे प्रदर्शित किया जाएगा।
  • XML एक सामान्य मानक है: XML को वर्ल्ड वाइड वेब कंसोर्टियम (W3C) द्वारा विकसित किया गया था और यह एक खुले मानक के रूप में उपलब्ध है।

XML एक नेस्टेड नोड संरचना पर आधारित है। प्रत्येक नोड में एक ओपनिंग टैग और एक क्लोजिंग टैग होता है, जैसा कि नीचे दिखाया गया है:

<node>content</node>

जिसमें:

  • यह एक ओपन टैग है, और इस टैग का नाम आप द्वारा परिभाषित किया जाता है।
  • यह एक क्लोजिंग टैग है, और इस टैग का नाम ओपनिंग टैग के नाम से मेल खाना चाहिए।
  • सामग्री इस टैग की सामग्री है.

प्रत्येक XML फ़ाइल के शीर्ष पर आपको उपयोग में लाए जा रहे XML संस्करण को इंगित करने के लिए एक टैग घोषित करना होगा। निर्देश टैग का सिंटैक्स इस प्रकार है:

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

JSON बनाम XML: मुख्य अंतर

दोनों प्रारूप संरचित डेटा को संभालते हैं, और नीचे दी गई तालिका दर्शाती है कि किसी परियोजना को इन दोनों प्रारूपों के बीच स्विच करने की आवश्यकता क्यों हो सकती है।

प्राचल JSON एक्सएमएल
वाक्यविन्यास शैली कुंजी और मान जोड़े नेस्टेड टैग
जानकारी का प्रकार स्ट्रिंग, संख्या, बूलियन, नल, ऐरे, ऑब्जेक्ट केवल टेक्स्ट, टाइप स्कीमा से आते हैं
गुण समर्थित नहीं किसी भी तत्व पर समर्थित
टिप्पणियाँ समर्थित नहीं समर्थित
शब्दाडंबर सघन टैग दोहराए जाने के कारण अधिक विस्तृत।
स्कीमा सत्यापन JSON स्कीमा, वैकल्पिक डीटीडी और एक्सएसडी, परिपक्व
विशिष्ट उपयोग वेब एपीआई और कॉन्फ़िगरेशन एंटरप्राइज़ मैसेजिंग और दस्तावेज़

जीसन क्या है?

जीसन (https://github.com/google/gson) एक है Java एक लाइब्रेरी जो उपयोगकर्ताओं को किसी फ़ाइल को परिवर्तित करने की अनुमति देती है Java ऑब्जेक्ट को JSON स्ट्रिंग में परिवर्तित करना, और JSON स्ट्रिंग को वापस ऑब्जेक्ट में परिवर्तित करना। Java ऑब्जेक्ट. Gson मनमाने ढंग से काम कर सकता है Java उन वस्तुओं सहित, जिनमें मौजूदा वस्तुएं भी शामिल हैं जिनका स्रोत कोड आपके पास नहीं है।

संस्करण 1.6 के बाद से, Gson ने दो क्लास पेश किए हैं, जेसन रीडर और jsonWriterJSON डेटा की स्ट्रीमिंग प्रोसेसिंग प्रदान करने के लिए।

  • jsonWriter – स्ट्रीमिंग के माध्यम से JSON में लिखें। हम एक बनाते हैं jsonWriter JSON ऑब्जेक्ट बनाने की शुरुआत और समाप्ति के लिए, हम फ़ंक्शन का उपयोग करते हैं। आरंभऑब्जेक्ट() और अंतऑब्जेक्ट()उन दो कॉलों के बीच, हम डेटा को जोड़े (कुंजी => मान) के रूप में लिखते हैं।
JsonWriter writer = new JsonWriter();
writer.beginObject();
writer.name("key").value("value");
writer.endObject();
  • जेसन रीडर – 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 का मतलब है Java ArchiXML बाइंडिंग के लिए टेक्चर, जो एक लाइब्रेरी है जो कन्वर्ट करने के लिए एनोटेशन का उपयोग करती है Java ऑब्जेक्ट को XML सामग्री में और इसके विपरीत परिवर्तित किया जा सकता है। चूंकि JAXB एक विनिर्देश द्वारा परिभाषित है, इसलिए हम इस मानक के विभिन्न कार्यान्वयनों का उपयोग कर सकते हैं।

JAXB के साथ, हम अक्सर निम्नलिखित बुनियादी एनोटेशन का उपयोग करते हैं:

  • @Xmlरूटएलिमेंटयह एनोटेशन XML फ़ाइल के सबसे बाहरी टैग को निर्दिष्ट करता है, और इसलिए इसे एक क्लास के ऊपर घोषित किया जाता है।
  • @Xmlएलिमेंटरैपर: यह एनोटेशन संग्रह के चारों ओर एक आवरण XML तत्व बनाता है।
  • @XmlElement: यह एनोटेशन घोषित करता है कि ऑब्जेक्ट की एक प्रॉपर्टी XML फ़ाइल का चाइल्ड टैग बन जाती है।
  • @Xmlविशेषता: यह एनोटेशन घोषित करता है कि ऑब्जेक्ट का एक गुण आसपास के टैग पर एक विशेषता बन जाता है।

सामान्य कार्यान्वयन इस प्रकार है। सबसे पहले, हम आरंभ करते हैं JAXBसंदर्भ के साथ वस्तु मायऑब्जेक्ट परिवर्तित करने के लिए वर्ग।

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

इस JAXBसंदर्भ ऑब्जेक्ट में एक विधि है जो एक ऑब्जेक्ट बनाती है जो XML सामग्री को परिवर्तित करती है। Java वस्तु, अनमार्शलर.

Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();

वही JAXBसंदर्भ ऑब्जेक्ट में एक विधि भी होती है जो ऑब्जेक्ट बनाती है और उसे परिवर्तित करती है। Java ऑब्जेक्ट को XML सामग्री में परिवर्तित करना, मार्शलर.

Marshaller marshallerObj = jaxbContext.createMarshaller();

⚠️ चेतावनी: JAXB को JDK से हटा दिया गया था। Java 11. पर Java 11 और उसके बाद के संस्करणों में, API और रनटाइम कार्यान्वयन को प्रोजेक्ट में स्पष्ट रूप से जोड़ें, उदाहरण के लिए jakarta.xml.bind:jakarta.xml.bind-api साथ साथ org.glassfish.jaxb:jaxb-runtimeऔर एनोटेशन आयात करें jakarta.xml.bind.annotation के बजाय javax.xml.bind.annotation.

XML को JSON में कैसे बदलें?

हम निम्नलिखित प्लेटफ़ॉर्म पर XML को JSON में बदलने का उदाहरण लागू करते हैं। नीचे दिए गए संस्करण स्क्रीनशॉट के लिए उपयोग किए गए हैं। JDK के नए रिलीज़, Eclipseऔर Gson भी उपरोक्त JAXB नोट के अधीन, उसी तरह काम करते हैं।

  • ओपनजेडीके 8 के लिए Ubuntu 18.04 x64.
  • Eclipse आईडीई 2019-03 (4.11.0) x64 Java के लिए विकास Ubuntu.
  • जीसन 2.8.5.

चरण 1) प्रोजेक्ट बनाएं।
कोई नया बनाएं Java परियोजना.

कोई नया बनाएं 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;
	}
}

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

विभाग.जावा

@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 पथ का निर्माण करें.

लाइब्रेरी Gson सेट अप करें

लाइब्रेरी Gson 2.8.5 को इसमें जोड़ें Java पथ बनाएँ

यदि परियोजना उपयोग करती है Maven मैन्युअल रूप से जोड़ी गई जार फ़ाइल के बजाय, उन्हीं लाइब्रेरीज़ को डिपेंडेंसी के रूप में घोषित किया गया है। स्क्रीनशॉट से मिलान करने के लिए संस्करण 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 व्युत्पन्न डेटा में परिवर्तित करने की क्षमता प्रदान करता है। Java वस्तुओं।

हम फ़ंक्शन को परिभाषित करते हैं getObjectFromXmlफ़ाइल हमारी XML फ़ाइल को वापस अन-मार्शल करने के लिए Java ऑब्जेक्ट। यह फ़ंक्शन क्लास में परिभाषित है एक्सएमएलसर्विस.

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

हम उपरोक्त कोड को क्लास में कॉल करते हैं। XmlToJsonसेवा.

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 Gson का उपयोग करके JSON संदेश में ऑब्जेक्ट्स

इस चरण में, हम फ़ंक्शन को परिभाषित करते हैं। writeDataToJsonफ़ाइल JSON फ़ाइल में डेटा लिखने के लिए। यह फ़ंक्शन क्लास में परिभाषित है। JSON सेवा.

ध्यान दें कि JSON ऑब्जेक्ट की सूची लिखने के लिए, हम फ़ंक्शन का उपयोग करते हैं। आरम्भअरे() और अंतअरे()इन दोनों कॉलों के बीच, हम प्रत्येक 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) {
	}
}

हम उपरोक्त कोड को क्लास में कॉल करते हैं। XmlToJsonसेवा.

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

यह पहली प्रक्रिया है। आंतरिक लूप प्रत्येक व्यक्ति का मिलान वर्तमान भूमिका आईडी से करता है, जिससे फ्लैट XML व्यक्ति सूची एक नेस्टेड JSON ऐरे में बदल जाती है।

JSON संदेश को में बदलें Java Gson का उपयोग करने वाली वस्तुएँ

दूसरी प्रक्रिया के पहले चरण में, हम फ़ंक्शन को परिभाषित करते हैं। getDataFromJsonफ़ाइल JSON फ़ाइल से डेटा पढ़ने के लिए। यह फ़ंक्शन क्लास में परिभाषित है। JSON सेवा.

ध्यान दें कि JSON ऑब्जेक्ट की सूची पढ़ने के लिए, हम फ़ंक्शन का उपयोग करते हैं। आरम्भअरे() और अंतअरे()इन दोनों कॉलों के बीच, हम प्रत्येक 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) {

	}
}

हम उपरोक्त कोड को क्लास में कॉल करते हैं। XmlToJsonसेवा.

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

jsonService.getDataFromJsonFile(filePathIn, roles, persons);

में कनवर्ट करना Java JAXB का उपयोग करके ऑब्जेक्ट को XML संदेश में परिवर्तित करना

इस चरण में, हम JAXB की मार्शलिंग तकनीक का उपयोग करते हैं।

मार्शलिंग क्लाइंट एप्लिकेशन को JAXB से प्राप्त डेटा को परिवर्तित करने की क्षमता प्रदान करता है। Java ऑब्जेक्ट ट्री को XML डेटा में परिवर्तित करना।

हम फ़ंक्शन को परिभाषित करते हैं parseObjectToXml संगठित करने के लिए Java ऑब्जेक्ट को 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");
	}
}

हम उपरोक्त कोड को क्लास में कॉल करते हैं। 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);

यह दूसरी प्रक्रिया है। उत्पन्न फ़ाइल मूल sample.xml से मेल खाती है, जो इस बात की पुष्टि करती है कि राउंड ट्रिप के दौरान प्रत्येक मान संरक्षित रहा।

JSON को XML में कैसे परिवर्तित करें Java बिना मॉडल क्लास के?

उपरोक्त दृष्टिकोण तब सही विकल्प है जब संरचना ज्ञात और स्थिर हो, क्योंकि एनोटेटेड क्लास संरचना को दस्तावेजित करती हैं।tracजब संरचना अज्ञात हो या अक्सर बदलती रहती हो, तो एक सामान्य कनवर्टर अधिक तेज़ होता है।

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

आउटपुट:

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

ध्यान दें कि जेनेरिक रूट कोई रूट एलिमेंट और कोई एट्रीब्यूट उत्पन्न नहीं करता है, इसलिए XML.toString(json, "root") सामान्यतः आवश्यक होता है। नीचे दी गई तालिका दोनों दृष्टिकोणों को साथ-साथ दर्शाती है।

कसौटी जेएएक्सबी के साथ जीसन org.json जेनेरिक रूपांतरण
आवश्यक मॉडल क्लास हाँ नहीं
संरचना पर नियंत्रण विशेषताओं सहित पूर्ण सीमित, केवल तत्व
रेशाping तिथि यह संभव है, जैसा कि नेस्टेड व्यक्तियों के साथ दिखाया गया है। संभव नहीं
कोड की पंक्तियाँ बहुत दो
के लिए सबसे अच्छा स्थिर, प्रलेखित योजनाएँ तदर्थ या अज्ञात संरचनाएँ

JAXB XML डेटा पढ़ता है और Gson इसे JSON में लिखता है, और इसके विपरीत प्रक्रिया में भी Gson का उपयोग डेटा पढ़ने के लिए किया जाता है। JSON JAXB डेटा को XML में वापस लिखते समय डेटा की समीक्षा करें। अधिक जानकारी के लिए, समीक्षा करें। एक्सएमएल बुनियादी बातें, व्यापक Java ट्यूटोरियल, तथा JasperReportsजो रिपोर्ट डेटा स्रोतों के रूप में दोनों प्रारूपों का उपयोग करता है।

अक्सर पूछे जाने वाले प्रश्न

JAXB को JDK से हटा दिया गया था। Java 11. jakarta.xml.bind API को jaxb-runtime जैसे रनटाइम के साथ जोड़ें, और इंपोर्ट को javax से jakarta में अपडेट करें।

नहीं। Gson केवल JSON को ही हैंडल करता है। XML को पहले प्रोसेस करना होगा। Java Gson द्वारा इसे सीरियलाइज़ करने से पहले, JAXB या Jackson XML जैसे किसी अन्य पार्सर के माध्यम से ऑब्जेक्ट्स को पार्स किया जाना चाहिए।

XmlElement एक चाइल्ड टैग बनाता है जिसमें मान होता है, जबकि XmlAttribute मान को पैरेंट टैग के ओपनिंग टैग के अंदर रखता है। एट्रीब्यूट में नेस्टेड संरचनाएं नहीं हो सकतीं।

स्ट्रीमिंग से मेमोरी का उपयोग कम रहता है और आउटपुट संरचना इनपुट क्लास से भिन्न हो सकती है, जो कि ठीक वैसा ही होता है जब व्यक्ति यहां भूमिकाओं के भीतर समाहित होते हैं।

हाँ, एक नमूना XML दस्तावेज़ से। संग्रहों पर रैपर एनोटेशन की जाँच करें, क्योंकि जनित क्लास अक्सर XmlElementWrapper को छोड़ देते हैं और एक सपाट संरचना उत्पन्न करते हैं।

JSON और इसका लाइन-डिलिमिटेड वेरिएंट प्रमुख हैं, क्योंकि वे सीधे मैप करते हैं। Python शब्दकोशों का उपयोग करें और डेटा को कुशलतापूर्वक स्ट्रीम करें। जहां पुराने एंटरप्राइज़ सिस्टम स्रोत डेटा प्रदान करते हैं, वहां XML अभी भी दिखाई देता है।

इस पोस्ट को संक्षेप में इस प्रकार लिखें: