使用 Gson 和 JAXB 通过示例将 JSON 转换为 XML Java
James Hartman 什么是JSON？
JSON 是 Javascript Object Notation 的缩写，它是一种数据形式，遵循大多数编程语言目前都能读懂的特定规则。我们可以轻松地将其保存到文件或数据库记录中。JSON 格式使用键值对来描述数据。
在接下来的示例中，我们定义了一个存储个人信息的 JSON 字符串
{
"username" : "guru99user",
"email" : "guru99user@mail.com"
}
所以 JSON 的语法非常简单。每条数据信息都将包含两个部分：键和值，它们对应于某个记录中的字段名称及其值。但进一步查看，还有一些方面是这样的：
- JSON 字符串用花括号 {} 括起来。
- JSON 的键和值都必须用引号 {}“” 括起来。
- 如果有更多数据（更多的键值对），我们使用逗号 (,) 分隔。
- JSON 键应该是无符号的字母或数字、下划线，不允许有空格，首字符不能是数字。
什么是 XML？
XML 是 eXtensible Markup Language 的缩写，也称为可扩展标记语言，由万维网联盟 (World Wide Web Consortium) (https://www.w3.org/) 提出，用于创建其他标记语言。这是一个简单的子集，可以描述多种不同类型的数据，因此在系统之间共享数据时非常有用。
XML 中的标签通常不是预定义的，而是根据用户约定创建的。 XML 在 HTML 的优势基础上引入了新功能。
在各种系统和解决方案中，还有一些更有用的 XML 创建功能。
- XML 是可扩展的：XML 允许您创建自己的自定义标签以适应您的应用程序。
- XML 承载数据，不显示数据：XML 允许您存储数据，而不考虑如何显示。
- XML 是通用标准：XML 由万维网联盟 (W3C) 开发，并作为开放标准提供。
XML 构建在嵌套节点结构上。每个节点将有一个开始标签和一个结束标签，如下所示：
<node>content</node>
其中
- <node> 是一个开始标签，该标签的名称由您定义。
- </node> 是一个结束标签，该标签的名称必须与开始标签的名称匹配。
- content 是该标签的内容。
在每个 XML 文件的顶部，您必须声明一个标签来指示 XML 的使用版本。指令标签的语法是：
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
什么是 Gson？
Gson (https://github.com/google/gson) 是一个 Java 库，允许用户将 Java 对象转换为 JSON 字符串，也允许将 JSON 字符串转换为 Java 对象。Gson 可以处理任意 Java 对象，包括您没有其源代码的现有对象。
从 1.6 版本开始，Gson 引入了两个新类 – JsonReader 和 JsonWriter，用于对 JSON 数据提供流式处理。
- JsonWriter – 流式写入 JSON。通用实现的语法如下。我们创建一个 JsonWriter 对象。要开始和结束创建 JSON 字符串，我们使用 beginObject() 和 endObject() 函数。在执行这两个函数之间，我们使用键值对执行数据写入。
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 for XML Binding 的缩写，它是一个使用注解将 Java 对象转换为 XML 内容并反之亦然的库。由于 JAXB 通过规范定义，我们可以为该标准使用不同的实现。
使用 JAXB，我们通常使用以下基本注解：
- @XmlRootElement：此注解指定 XML 文件的最外层标签是什么，因此它声明在类之上。
- @XmlElementWrapper：此注解在集合周围创建一个包装器 XML 元素。
- @XmlElement：此注解用于声明对象的属性是 XML 文件的标签。
- @XmlAttribute：此注解也用于声明对象的属性是 XML 文件的标签。
通用实现的语法如下。首先，我们将使用 MyObject 对象初始化 JAXBContext 对象进行转换。
JAXBContext jaxbContext = JAXBContext.newInstance(MyObject.class);
在这个 JAXBContext 对象中，它有一个方法可以创建一个将 XML 内容转换为 Java 对象的对象，即 Unmarshaller。
Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();
在这个 JAXBContext 对象中，它有一个方法可以创建将 Java 对象转换为 XML 内容的对象，即 Marshaller。
Marshaller marshallerObj = jaxbContext.createMarshaller();
如何将 XML 转换为 JSON？
我们在平台上实现了 XML – JSON 转换的示例。
- Open JDK 8 for Ubuntu 18.04 x64。
- Eclipse IDE 2019-03 (4.11.0) x64 Java Development for Ubuntu。
- Gson 2.8.5。
步骤 1) 创建项目。
创建一个新的 Java 项目。
步骤 2) 设置项目名称。
将项目名称设置为 XmlToJsonExample。
步骤 3) 创建文件夹。
创建文件夹 data/input，其中包含两个文件 sample.xml 和 sample.json。
让我们首先定义包含 department、role 和 person 属性的 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) 定义对象。
在 model 包中定义相应的对象类。
- 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;
}
}
步骤 5) 设置库。
将 Gson 2.8.5 库添加到 Java 构建路径并进行设置。
使用 JAXB 将 XML 消息转换为 Java 对象
首先，我们在 service 包中定义执行类。
在第一个过程的第一步中，我们使用 JAXB 的解组 (Un-marshalling) 技术。
解组为客户端应用程序提供了将 XML 数据转换为 JAXB 派生 Java 对象的能力。
我们定义了 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();
然后我们进行下一步。
使用 Gson 将 Java 对象转换为 JSON 消息
在此步骤中，我们定义了 writeDataToJsonFile 函数，用于将数据写入 JSON 文件。此函数定义在 JsonService 类中。
请注意，要写入 JSON 字符串列表，我们使用 beginArray() 和 endArray() 函数。在这两个函数之间，我们写入每个 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);
这就是第一个过程。
使用 Gson 将 JSON 消息转换为 Java 对象
在第二个过程的第一步中，我们定义了 getDataFromJsonFile 函数，用于从 JSON 文件读取数据。此函数定义在 JsonService 类中。
请注意，要读取 JSON 字符串列表，我们使用 beginArray() 和 endArray() 函数。在这两个函数之间，我们读取每个 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？
JAVA 中的 JSON 到 XML 转换是通过使用 JSONObject json = new JSONObject(str); String xml = XML. 来实现的。如果您有一个有效的 DTD 文件或 XML 文件，那么将 JSON 转换为 XML 和 XML 转换为 JSON 非常容易。
然后我们进行下一步。
使用 JAXB 将 Java 对象转换为 XML 消息
在此步骤中，我们使用 JAXB 的编组 (Marshalling) 技术。
编组为客户端应用程序提供了将 JAXB 派生 Java 对象树转换为 XML 数据的能力。
我们定义了 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");
}
}
我们在 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 的方法。
