Muunna JSON XML-muotoon Java käyttämällä Gsonia ja JAXB:tä esimerkin kanssa

by: James Hartman James Hartman
Hours Päivitetty

Mikä on JSON?

JSON on lyhenne sanoista Javascript Object Notation, joka on tietomuoto, joka noudattaa tiettyä sääntöä, jonka mukaan useimmat ohjelmointikielet ovat tällä hetkellä luettavissa. Voimme tallentaa sen helposti tiedostoon tai tallentaa tietokantaan. JSON-muoto käyttää avain-arvo-pareja tietojen kuvaamiseen.

Seuraavassa esimerkissä määritämme JSON-merkkijonon, joka tallentaa henkilökohtaisia ​​tietoja:

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

Joten JSONin syntaksi on hyvin yksinkertainen. Jokaisessa tietotiedossa on kaksi osaa: avain ja arvo, jotka vastaavat kentän nimeä ja sen arvoa tietyssä tietueessa. Mutta tarkemmin katsottuna on muutamia tämän kaltaisia ​​asioita:

  • JSON-merkkijono on suljettu aaltosulkeilla {}.
  • JSON-avaimet ja arvot on suljettava lainausmerkeissä {“}.
  • Jos dataa on enemmän (enemmän avainta => arvopareja), käytämme pilkkuja (,) erottamiseen.
  • JSON-avaimien tulee olla allekirjoittamattomia kirjaimia tai numeroita, _, eikä välilyöntejä, ensimmäinen merkki ei saa olla numeroita.

Mikä on XML?

XML on lyhenne sanoista eXtensible Markup Language, jota kutsutaan myös World Wide Web Consortiumin ehdottamaksi laajennettavaksi merkintäkieleksi (https://www.w3.org/) luodaksesi muita sivunkuvauskieliä. Tämä on yksinkertainen osajoukko, joka voi kuvata monia erityyppisiä tietoja, joten se on erittäin hyödyllinen tietojen jakamisessa järjestelmien välillä.

XML-tunnisteet eivät usein ole ennalta määritettyjä, vaan ne luodaan käyttäjien käytäntöjen mukaisesti. XML esittelee uusia ominaisuuksia, jotka perustuvat HTML:n etuihin.

Useissa eri järjestelmissä ja ratkaisuissa on hyödyllisiä XML-valmistusominaisuuksia:

  • XML on laajennettavissa: XML:n avulla voit luoda omia mukautettuja tunnisteita sovellukseesi sopiviksi.
  • XML kuljettaa tietoja, ei näytä sitä: XML antaa sinun tallentaa tietoja riippumatta siitä, miten ne näytetään.
  • XML on yleinen standardi: XML:n on kehittänyt World Wide Web Consortium (W3C), ja se on saatavana avoimena standardina.

XML on rakennettu sisäkkäiseen solmurakenteeseen. Jokaisella solmulla on aloittava ja sulkeva tagi seuraavasti:

<node>content</node>

Jossa:

  • on avoin tunniste, määrität tämän tunnisteen nimen.
  • on suljettu tunniste, tämän tunnisteen nimen on vastattava avoimen tagin nimeä.
  • pitoisuus on tämän tunnisteen sisältö.

Jokaisen XML-tiedoston yläosassa on ilmoitettava tunniste, joka ilmaisee käytössä olevan XML-version. Ohjetunnisteen syntaksi:

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

Mikä on Gson?

Gson (https://github.com/google/gson) on Java-kirjasto, jonka avulla käyttäjät voivat muuntaa a Java objekti JSON-merkkijonoksi ja muuntaa myös JSON-merkkijonosta muotoon Java esine. Gson voi työskennellä mielivaltaisen kanssa Java objektit mukaan lukien olemassa olevat objektit ilman niiden lähdekoodia.

Versiosta 1.6 lähtien Gson esittelee kaksi uutta luokkaa – JsonReader ja jsonWriter JSON-tietojen suoratoistokäsittelyn tarjoamiseen.

  • jsonWriter – Suoratoistokirjoitus JSONiin. Yleisen toteutuksen syntaksi on seuraava. Luomme a jsonWriter esine. Aloitamme ja lopetamme JSON-merkkijonon luomisen funktiolla beginObject() ja endObject(). Näiden kahden toiminnon suorittamisen aikana kirjoitamme dataa pareittain (avain => arvo).
JsonWriter writer = new JsonWriter();
writer.beginObject();
writer.name("key").value("value");
writer.endObject();
  • JsonReader – Suoratoisto JSONista. Yleisen toteutuksen syntaksi on seuraava. Luomme JsonReader-objektin. Aloitamme ja lopetamme JSON-merkkijonon luomisen funktioilla beginObject() ja endObject(). Näiden kahden toiminnon suorittamisen aikana luemme dataa pareittain (avain => arvo).
JsonReader reader = new JsonReader();
reader.beginObject();
while (reader.hasNext()) {
	String name = reader.nextName();
	if (name.equals("key")) {
		String value = reader.nextString();
	}
}
reader.endObject();

Gson-suoratoiston käsittely on nopeaa. Sinun on kuitenkin käsiteltävä jokainen JSON-tietojen käsittelypari (avain => arvo).

AIHEESEEN LIITTYVÄT ARTIKKELIT

Mikä on JAXB?

JAXB tarkoittaa Java Architecture for XML Binding, joka on kirjasto, joka käyttää merkintöjä muuntamiseen Java objektit XML-sisältöön ja päinvastoin. Koska JAXB on määritelty spesifikaation kautta, voimme käyttää erilaisia ​​toteutuksia tälle standardille.

JAXB:ssä käytämme usein seuraavia perusmerkintöjä, nimittäin:

  • @XmlRootElement: Tämä huomautus määrittää, mikä on XML-tiedoston uloin tunniste, ja siksi se ilmoitetaan luokan päällä.
  • @XmlElementWrapper: Tämä merkintä luo kääre-XML-elementin kokoelmien ympärille.
  • @XmlElement: Tämä huomautus, jota käytetään määrittämään objektin attribuutti, on XML-tiedoston tunniste.
  • @XmlAttribute: Tätä huomautusta käytetään myös ilmoittamaan, että objektin attribuutti on XML-tiedoston tunniste.

Yleisen toteutuksen syntaksi on seuraava. Ensin alustetaan JAXBConteksti esine OmaObject muutettava kohde.

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

Tässä JAXBConteksti objekti, sillä on menetelmä luoda objekti, joka muuntaa XML-sisällön a Java esine, Unmarshaller.

Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();

Tässä JAXBConteksti objekti, sillä on menetelmä luoda objekti, joka muuntaa Java vastustaa sitä XML-sisältöä Marshaller.

Marshaller marshallerObj = jaxbContext.createMarshaller();

Kuinka muuntaa XML JSONiksi?

Toteutamme esimerkin XML-JSON-muunnoksesta alustalla:

  • Avaa JDK 8 varten Ubuntu 18.04 x64.
  • Eclipse IDE 2019-03 (4.11.0) x64 Java Kehitys varten Ubuntu.
  • Gson 2.8.5.

Vaihe 1) Luo projekti.
Luoda uusi Java Projekti.

Luoda uusi Java Projekti.
Luoda uusi Java Projekti.

Vaihe 2) Aseta projektin nimi.
Aseta projektin nimi XmlToJsonExample.

Aseta projektin nimi

Aseta projektin nimi.

Vaihe 3) Luo kansio.
luo kansio datan syöttö sisältää kaksi tiedostoa sample.xml ja sample.json.

Luo kansion tiedot

Luo kansion tiedot/syöttö.

Määritetään ensin XML:mme osasto, rooli ja henkilö ominaisuudet.

Yleinen arkkitehtuuri on: ; .

Objektisuhteet

Objektisuhteet.

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

Toiseksi määrittelemme JSONin, jolla on sama idea:

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

Vaihe 4) Määrittele objekti.
Määrittele paketissa vastaavat objektiluokat malli.

Määrittele objektiluokat

Määrittele objektiluokat.

  • Role.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;
	}
}
  • 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;
	}
}
  • Department.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;
	}

}

Vaihe 5) Määritä kirjasto.
Lisää ja määritä kirjasto Gson 2.8.5 Java Rakenna polku.

Asenna Gson-kirjasto

Lisää kirjasto Gson 2.8.5 Java Rakennuspolku

Lisää kirjasto Gson 2.8.5 Java Rakenna polku.

Muunna XML-viesti muotoon Java objektit JAXB:n avulla

Ensinnäkin määrittelemme suorituksen paketissa palvelu.

Määrittele suoriutuvat luokat

Määrittele suoriutuvat luokat.

Ensimmäisen prosessin ensimmäisessä vaiheessa käytämme JAXB:n Un-marshalling-tekniikkaa.

Marshalling tarjoaa asiakassovellukselle mahdollisuuden muuntaa XML-tiedot JAXB-pohjaisiksi Java esineitä.

Määrittelemme toiminnon getObjectFromXmlFile purkaa XML-tiedostomme takaisin a Java esine. Tämä funktio on määritelty luokassa 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;
	}
}

Kutsumme yllä olevaa koodia luokassa XmlToJsonService.

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

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

Sitten siirrytään seuraavaan vaiheeseen.

Muuntaa Java vastustaa JSON-viestiä Gsonin avulla

Tässä vaiheessa määrittelemme funktion writeDataToJsonFile kirjoittaaksesi tietoja JSON-tiedostoon. Tämä funktio on määritelty luokassa JsonService.

Huomaa, että JSON-merkkijonojen luettelon kirjoittamiseen käytämme funktiota beginArray() ja endArray(). Näiden kahden funktion väliin kirjoitamme jokaisen JSON-merkkijonon.

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

Kutsumme yllä olevaa koodia luokassa XmlToJsonService.

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

Se on ensimmäinen prosessi.

Muunna JSON-viesti muotoon Java objektit Gsonin avulla

Toisen prosessin ensimmäisessä vaiheessa määritämme funktion getDataFromJsonFile lukeaksesi tietoja JSON-tiedostosta. Tämä funktio on määritelty luokassa JsonService.

Huomaa, että JSON-merkkijonojen luettelon lukemiseen käytämme funktiota beginArray() ja endArray(). Näiden kahden funktion välillä luemme jokaisen JSON-merkkijonon.

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

	}
}

Kutsumme yllä olevaa koodia luokassa XmlToJsonService.

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

jsonService.getDataFromJsonFile(filePathIn, roles, persons);

Kuinka muuntaa Json XML:ksi Java?

JSON XML:ksi in JAVA muunnetaan komennolla JSONObject json = new JSONObject(str); merkkijono xml = XML. Jos sinulla on kelvollinen dtd-tiedosto tai xml-tiedosto, on erittäin helppo muuntaa json xml:ksi ja myös xml jsoniksi.

Sitten siirrytään seuraavaan vaiheeseen.

Muuntaa Java objektit XML-viestiin JAXB:n avulla

Tässä vaiheessa käytämme JAXB:n tekniikkaa.

Marshalling tarjoaa asiakassovellukselle mahdollisuuden muuntaa JAXB-johdannaisen Java objektipuu XML-tietoihin.

Määrittelemme funktion parseObjectToXm marshallille Java vastustaa XML-viestiä. Tämä funktio on määritelty luokassa

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

Kutsumme yllä olevaa koodia luokassa 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);

Se on toinen prosessi.

Yhteenveto

Tässä opetusohjelmassa opimme lyhyesti yhden tavan, jolla JAXB voi lukea XML-tietoja ja Gson kirjoittaa sen JSONiin. Päinvastoin, näimme myös tavan, jolla Gson luki JSON data ja JAXB kirjoittaa sen XML:ään.

Tiivistä tämä viesti seuraavasti: