將 JSON 轉換為 XML Java 使用 Gson 和 JAXB 的示例

由： 詹姆斯·哈特曼 詹姆斯·哈特曼
Hours 更新

什么是 JSON？

JSON 是 Javascript 对象表示法（Object Notation），是一种遵循一定规则的数据形式，目前大多数编程语言都可读。我们可以很容易地将其保存到文件或记录在数据库中。JSON 格式使用键值对来描述数据。

在下面的例子中，我们定义一个存储个人信息的 JSON 字符串：

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

JSON 的语法其实很简单，每条数据信息都会有 key 和 value 两个部分，分别对应某条记录的字段名和字段值。但进一步看，有这么几件事：

  • JSON 字符串被花括号 {} 括起来。
  • JSON的键和值都必须用引号{“}括起来。
  • 如果有更多数据（更多键 => 值对），我们使用逗号（,）来分隔。
  • JSON 键应为无符号字母或数字、_，且不能有空格，第一个字符不应设置为数字。

什么是 XML？

XML 代表可扩展标记语言，也称为万维网联盟提出的可扩展标记语言（https://www.w3.org/) 来创建其他标记语言。这是一个简单的子集，可以描述许多不同类型的数据，因此在系统间共享数据时非常有用。

XML 中的标签通常没有预定义，而是根据用户约定创建的。 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"?>

Gson 是什么？

格森（https://github.com/google/gson) 是一个 Java 库，它允许用户从 Java 对象转换为 JSON 字符串，也可以从 JSON 字符串转换为 Java 对象。Gson 可以处理任意 Java 对象包括现有对象，但您无需拥有其源代码。

从 1.6 版开始，Gson 引入了两个新类 - JsonReader 和 JSONWriter 提供对JSON数据的流式处理。

  • JSONWriter – 流式写入 JSON。一般实现的语法如下。我们创建一个 JSONWriter 对象。要开始和完成创建 JSON 字符串，我们使用函数 开始对象（） 和 结束对象（）. 在执行这两个函数的过程中，我们以（key => value）对的形式执行写入数据的操作。
JsonWriter writer = new JsonWriter();
writer.beginObject();
writer.name("key").value("value");
writer.endObject();
  • JsonReader – 从 JSON 流式读取。一般实现的语法如下。我们创建一个 JsonReader 对象。要开始和完成创建 JSON 字符串，我们使用函数 beginObject() 和 endObject()。在执行这两个函数的过程中，我们使用成对的 (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();

Gson 流处理速度很快。但是您需要处理 JSON 数据的每一对 (key => value)。

相关文章

什么是 JAXB？

JAXB 代表 Java ArchiXML Binding 的结构，它是一个使用注释进行转换的库 Java 对象转换为 XML 内容，反之亦然。由于 JAXB 是通过规范定义的，因此我们可以针对此标准使用不同的实现。

使用 JAXB 时，我们经常使用以下基本注解，即：

  • @XmlRootElement：此批注指定 XML 文件的最外层标签是什么，因此它在类的顶部声明。
  • @XmlElementWrapper：此注释在集合周围创建一个包装 XML 元素。
  • @XmlElement：该注解用于声明对象的一个​​属性，是XML文件的一个标签。
  • @XmlAttribute：此注解也用于声明对象的一个​​属性，是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 IDE 2019-03 (4.11.0) x64 Java 开发为 Ubuntu.
  • Gson 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） 定义对象。
在包中定义相应的对象类 模型.

定义对象类

定义对象类。

  • 角色.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;
	}
}
  • 部门.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;
	}
}

XML模型.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 构建路径

将库 Gson 2.8.5 添加到 Java 构建路径。

将 XML 消息转换为 Java 使用 JAXB 的对象

首先，我们在包中定义执行类 服务.

定义执行类

定义执行类别。

在第一个过程的第一步中，我们使用JAXB的Un-marshalling技术。

解组功能为客户端应用程序提供了将 XML 数据转换为 JAXB 派生数据的能力 Java 对象。

我们定义函数 从XmlFile获取对象 将 XML 文件解组为 Java 对象。此函数在类中定义 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;
	}
}

我们在课堂上调用上面的代码 XmlToJsonService.

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

在此步骤中，我们定义函数 写入数据到Json文件 将数据写入 JSON 文件。此函数定义在类中 JsonService.

请注意，要写入 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) {
	}
}

我们在课堂上调用上述代码 XmlToJsonService.

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

这是第一个过程。

将 JSON 消息转换为 Java 使用 Gson 的对象

在第二个过程的第一步，我们定义函数 从JsonFile获取数据 从 JSON 文件中读取数据。此函数定义在类中 JsonService.

请注意，要读取 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) {

	}
}

我们在课堂上调用上述代码 XmlToJsonService.

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

jsonService.getDataFromJsonFile(filePathIn, roles, persons);

如何将 Json 转换为 XML Java?

JSON 到 XML in JAVA 通过使用 JSONObject json = new JSONObject(str); String 进行转换 xml = XML。如果您有一个有效的 dtd 文件或 xml 文件，那么将 json 转换为 xml 以及将 xml 转换为 json 都非常容易。

然后我们进入下一步。

转化率 Java 使用 JAXB 将对象转换为 XML 消息

在这一步，我们使用JAXB的Marshalling技术。

编组为客户端应用程序提供了将 JAXB 派生的 Java 对象树转化为 XML 数据。

我们定义函数 parseObjectToXm 来 marshall 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);

这是第二个过程。

总结

在本教程中，我们简要了解了 JAXB 读取 XML 数据以及 Gson 将其写入 JSON 的一种方式。相反，我们还了解了 Gson 读取 JSON 数据，JAXB 将其写入 XML。

你可能会喜欢：