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

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

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

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

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

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

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

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

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

XML का मतलब एक्सटेंसिबल मार्कअप लैंग्वेज है, जिसे वर्ल्ड वाइड वेब कंसोर्टियम (WWW) द्वारा प्रस्तावित एक्सटेंसिबल मार्कअप लैंग्वेज भी कहा जाता है।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"?>

जीसन क्या है?

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

संस्करण 1.6 के बाद से, Gson ने दो नई कक्षाएं शुरू की हैं – जेसन रीडर और JsonWriter JSON डेटा पर स्ट्रीमिंग प्रसंस्करण प्रदान करने के लिए।

  • 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विशेषता: यह एनोटेशन ऑब्जेक्ट की विशेषता को घोषित करने के लिए भी उपयोग किया जाता है जो XML फ़ाइल का एक टैग है।

सामान्य कार्यान्वयन के लिए सिंटैक्स इस प्रकार है। सबसे पहले, हम आरंभ करेंगे 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 8 खोलें Ubuntu 18.04 x64.
  • Eclipse आईडीई 2019-03 (4.11.0) x64 Java के लिए विकास Ubuntu.
  • जीसन 2.8.5.

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

कोई नया बनाएं 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;
	}
}
  • व्यक्ति.जावा:
@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;
	}
}

XMLमॉडल.जावा:

@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 पथ बनाएँ

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

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

फिर हम अगले चरण पर जाते हैं।

में कनवर्ट करना 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);

यह पहली प्रक्रिया है।

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

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

जेएसओएन से एक्सएमएल in जावा JSONObject json = new JSONObject(str); String का उपयोग करके परिवर्तित किया जाता है एक्सएमएल = एक्सएमएलयदि आपके पास वैध dtd फ़ाइल या xml फ़ाइल है तो json को xml में और xml को json में बदलना बहुत आसान है।

फिर हम अगले चरण पर जाते हैं।

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

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

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

हम marshall के लिए parseObjectToXm फ़ंक्शन परिभाषित करते हैं 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");
	}
}

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

यह दूसरी प्रक्रिया है।

निष्कर्ष

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

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