真正简化从 Java 对象转换到 XML 的过程
出处:ibm dw
Java™ 开发人员在序列化和反序列化可扩展标记语言(Extensible Markup Language,XML)对象时有多种不同的选择。Simple 就是这样的一个例子,并且它有很多超越其他竞争方案的优势。本文概要介绍如何在 XML 通信系统中使用 Simple。
Simple 是一个 Java 框架,用于简化序列化和反序列化 XML 的过程。使用 Simple,开发人员可以简化(名字由此而来)将简单老 Java 对象(POJO)转换成 XML 文档的过程 — 即所谓的序列化 (serialization)过程。Simple 也可促进相反的过程:开发人员可以将 XML 文档转换成 POJO — 即所谓的反 序列化(deserialization)过程。
Simple 名副其实,它使用注解来支持序列化和反序列化过程。根据相应的 XML 文档应该如何出现,对 POJO 进行注解。一些字段被注解为属性,另一些字段被注解为元素。类通常被注解为根元素。在序列化过程中,该框架处理冗长的解释注解和产生相应 XML 文档的过程。无足为奇,在 XML 文档被转换成 POJO 的反序列化过程中,注解也会被解释。
使用 Simple 有几个优势。首先,它促进快速应用程序开发。Simple 是如此简单,它支持开发人员快速实现健壮的、使用 XML 序列化和反序列化的应用程序,无需完成长长的学习曲线以及付出繁重的开发劳动。
其次,Simple 不需要配置。前面已经提到,Simple 使用注解。这些注解取代了基于 XML 的配置文件(其他框架一般都有这样的配置文件)。
最后,Simple 只让使用它的应用程序增加少量的内存占用。Java 归档(Java Archive,JAR)文件只有 239 KB。Simple 也不依赖于一系列其他 JAR 文件,而其他框架则通常不是这样的。
获得 Simple
必须首先访问 参 考资源 中列出的 Simple 网站下载归档文件,获得 Simple,然后才能使用它。但是关于这个过程,既有好消息,也有坏消息。好消息是,归档文件是免费的。坏消息是,归档文件是 .tar.gz 格式的。所以,您若是想用 Microsoft® Windows® 本机归档文件解压程序来打开这个归档文件的话,是会失望的。需要使用 WinZip 或其他类似的归档工具。
解压文件之后,注意在 jar 目录中有一个 JAR 文件(simple-xml-2.1.4.jar)。在编译时和运行时,类路径中需要有这个 JAR 文件。
序列化
将一个对象序列化成一个 XML 文档是一个相当简单的过程。涉及到两步:
- 创建具有适当注解的 POJO。
- 编写不多的几行代码,用于真正执行序列化过程。
为了本文目的,我们来回顾一下熟悉的鱼饵主题(当然只有读过我的文章的读者熟悉)。所以,清 单 1 是一个表示鱼饵信息的 POJO。
清单 1. Lure 类
@Root
public class Lure {
@Attribute
private String type;
@Element
private String company;
@Element
private int quantityInStock;
@Element
private String model;
public String getType {
return type;
}
public void setType(String type) {
this.type = type;
}
public String getCompany {
return company;
}
public void setCompany(String company) {
this.company = company;
}
public int getQuantityInStock {
return quantityInStock;
}
public void setQuantityInStock(int quantityInStock) {
this.quantityInStock = quantityInStock;
}
public String getModel {
return model;
}
public void setModel(String model) {
this.model = model;
}
}
|
这个 POJO 真的没有什么复杂的东西。其唯一可能初看起来不熟悉的部分是注解。同样,这是故意的。回想一下,Simple 框架的目的就是实现它名字的寓意。
@Root
注解描述 XML 文档的根元素。因为每个 XML 文档都需要一个根元素,所以一定要记得包含这个元素。
type
字段上面的 @Attribute
注解将该字段识别为属性。该属性被作为一个属性添加到根元素。
其余注解是 @Element
注解。这些注解位于以下 3 个字段的正上方:company
、quantityInStock
和 model
。这些字段代表 XML 文档中的元素。
根据 JavaBean 标准,该 POJO 的其余部分由访问器(accessor)方法和 修改器(mutator)方法组成。
既然 POJO 已经创建完成了,下面就该编写序列化代码了。参见 清 单 2 中的该代码。
清单 2. LureExample 类
public static void main(String[] args) {
try {
Serializer serializer = new Persister;
Lure lure = new Lure;
lure.setCompany("Donzai");
lure.setModel("Marlin Buster");
lure.setQuantityInStock(23);
lure.setType("Trolling");
File result = new File("lure.xml");
serializer.write(lure, result);
} catch (Exception e) {
e.printStackTrace;
}
}
|
第一件事就是实例化一个 Persister
对象。注意,该类是 Simple 框架的一部分,它实现 Serializer
接口。
接下来,实例化 Lure
对象并设置适当的字段。在本例中,制造鱼饵的公司名称是 Donzai
, 模型的名字是 Marlin Buster
,库存数量是 23
。最后,鱼饵的类型是 Trolling
。
再接下来,实例化一个 File
对象,它的名称是将成为 XML 文档的那个文件的名称。在本例中,该名称是 lure.xml。
最后,调用 serializer 来编写文件。write
方法中提供两个参数。第一个参数是 POJO,第二个参数是 File
对象。
现在可以执行该代码了。清 单 2 是一个 Java 应用程序,所以您可以使用自己喜欢的集成开发环境 (IDE) 来运行它。确保 simple-xml-2.1.4.jar 在类路径中。如果使用的是 Eclipse,只需在文件上右击,选择 Run As,再从出现 的菜单中选择 Java Application 即可。
如果一切正常(应该如此 — 这很简单,是不是?),那么产生的 XML 文档应该类似于 清 单 3。
清单 3. LureExample 的输出
注意关于 清 单 3 的几点。首先,注意 lure 类型是根元素的一个属性。这没有疑义,因为前面在 POJO 中是用 @Attribute
而不是 @Element
注解了 type
字段。
关于产生的 XML,另一个重点是元素名称遵循 JavaBean 标准。例如,根元素是 lure
,尽管类名称 是 Lure
。3 个子元素名称完全匹配字段名称。同样,这也是有意为之,因为您不想要首字母大写的根元素,而子元素名称则遵循另外的模式。
反序列化
序列化一个对象是如此地容易,那么反序列化对象也很容易,对不对?对!
回想一下,反序列化是将 XML 文档转换成 POJO 的过程。很不错的是,可以使用刚才创建的 XML 文档来进行反序列化。
清 单 4 展示了反序列化代码。
清单 4. LureExample2 类
public static void main(String[] args) {
try {
Serializer serializer = new Persister;
File source = new File("lure.xml");
Lure lure = serializer.read(Lure.class, source);
System.out.println(lure.getCompany);
System.out.println(lure.getModel);
System.out.println(lure.getQuantityInStock);
System.out.println(lure.getType);
} catch (Exception e) {
e.printStackTrace;
}
}
|
同样,首先是实例化一个实现 Serializer
接口的对象(Persister
)。
另一个类似行是 File
对象的实例化。但是,这里有一个明显的不同。在 清 单 3 中,是为一个不存在的文件实例化了 File
对象。此处假设(实际上必须这样)该文件已经存在。
接下来,通过从 Serializer
对象调用 read
方法,从而实例化 POJO。read
方法有两个参数:POJO 的类和 File
对象,后者代表包含数据的 XML 文件。
最后,从 POJO 输出所有的信息,确保所有内容都读取正确。
执行该代码时,输出应该类似于 清 单 5。
清单 5. LureExample2 的输出
Donzai
Marlin Buster
23
Trolling
|
全树序列化
至此,您所序列化和反序列化的 XML 文档都相当简单。
大多数 XML 文档要复杂多了。它们通常具有数层嵌套的元素,有时候还有一到多个重复的元素,每个元素又有几个子元素。
幸运的是,Simple 即使对于更复杂的文档也不违反它的名字的寓意。就像在一个 POJO 中嵌套又一个 POJO 那么简单。我们来看一下 清 单 6。
清单 6. AdvancedLure 类
@Attribute
private String type;
@Element
private String company;
@Element
private int quantityInStock;
@Element
private String model;
@Element
private ConfigurationScheme configurationScheme;
|
清 单 6 中的 AdvancedLure
类非常类似于 清 单 1 中描述的 Lure
类。一个例外之处是包含了另一个字段:configurationScheme
。 配置方案由另一个 POJO 表示,描述在 清 单 7 中。
清单 7. ConfigurationScheme 类
@Root
public class ConfigurationScheme {
@Element
private String color;
@Element
private int size;
|
为节省篇幅,我舍去了 accessor 方法和 mutator 方法。
清 单 7 中的注解应该看起来很熟悉。它们与 清 单 1 中使用的是相同的注解。
这又将我们引向 清 单 8。
清单 8. LureExample3 类
public static void main(String[] args) {
try {
Serializer serializer = new Persister;
AdvancedLure lure = new AdvancedLure;
lure.setCompany("Donzai");
lure.setModel("Marlin Buster");
lure.setQuantityInStock(23);
lure.setType("Trolling");
ConfigurationScheme configurationScheme = new ConfigurationScheme;
configurationScheme.setColor("Blue");
configurationScheme.setSize(3);
lure.setConfigurationScheme(configurationScheme);
File result = new File("advancedlure.xml");
serializer.write(lure, result);
} catch (Exception e) {
e.printStackTrace;
}
}
|
清 单 8 和 清 单 2 之间最大的差别是,您在 AdvancedLure
对象中实例化了一个 ConfigurationScheme
对象并设置了适当的字段。
运行该代码,输出应该类似于 清 单 9。
清单 9. LureExample3 的输出
Donzai
23
Marlin Buster
Blue
3
|
可以看到,嵌套的元素与预期那样地被序列化。
枚举
XML 文档经常包含某些元素的枚举。也就是说,相同的元素名称可以重复,只不过带有不同的子元素或属性数据而已。幸运的是,Simple 也能够处理这种情况。
为了演示该特性,我们创建一个新的类,名叫 Inventory
,其中包含仓库(储存库存的地方)的名称和在该库 存位置找到的鱼饵的列表,如 清 单 10 中所示。
清单 10. Inventory 类
@Root
public class Inventory {
@ElementList
private List lures;
@Attribute
private String warehouse;
|
注意,使用了一个新注解:@ElementList
。该注解告诉 Simple 框架:相应的 List
对象代表 XML 元素的枚举。
用于演示该 POJO 的序列化的代码跟用于序列化更简单的 POJO(比如说 清 单 2 中序列化的那个 POJO)的代码一样容易。唯一增加的复杂性来自于,为嵌套目的实例化了所有必需的对象。参见 清 单 11。
清单 11. LureExample4 类
Serializer serializer = new Persister;
AdvancedLure lure = new AdvancedLure;
lure.setCompany("Donzai");
lure.setModel("Marlin Buster");
lure.setQuantityInStock(23);
lure.setType("Trolling");
ConfigurationScheme configurationScheme = new ConfigurationScheme;
configurationScheme.setColor("Blue");
configurationScheme.setSize(3);
lure.setConfigurationScheme(configurationScheme);
AdvancedLure lure2 = new AdvancedLure;
lure2.setCompany("Ziggi");
lure2.setModel("Tuna Finder");
lure2.setQuantityInStock(44);
lure2.setType("Trolling");
ConfigurationScheme configurationScheme2 = new ConfigurationScheme;
configurationScheme2.setColor("Red");
configurationScheme2.setSize(5);
lure2.setConfigurationScheme(configurationScheme2);
List lures = new ArrayList;
lures.add(lure);
lures.add(lure2);
Inventory inventory = new Inventory;
inventory.setLures(lures);
inventory.setWarehouse("Midwest");
File result = new File("inventory.xml");
serializer.write(inventory, result);
|
执行该代码时,会创建一个叫做 inventory.xml 的 XML 文件。该文件的内容应该类似于 清 单 12。
清单 12. LureExample4 的输出
Donzai
23
Marlin Buster
Blue
3
Ziggi
44
Tuna Finder
Red
5
|
可以看到,输出完全模仿 清 单 11 中实例化及创建的 POJO。其中有两个 advancedLure
元素,它们各自包含用来填充相应 POJO 的数据。注意,嵌套也是允许的。
构造器
您的代码有可能使用永久不变的 POJO。在这种情况下,您可能会缺少用于修改字段属性的 setter 方法,相反,您依靠构造器来设置这些值。Simple 也能够处理这种情况。
在这种情况下,注解指定在构造器参数中,而不是放在字段名称上面。在适当 accessor 方法上面也需要注解。参见 清 单 13。
清单 13. Inventory2 类
public Inventory2(@ElementList(name="lures") List lures,
@Attribute(name="warehouse") String warehouse) {
this.lures = lures;
this.warehouse = warehouse;
}
@ElementList(name="lures")
public List getLures {
return lures;
}
@Attribute(name="warehouse")
public String getWarehouse {
return warehouse;
}
|
注意,在指定注解作为构造器参数的一部分时,也必须指定它对应的字段名称。对于第一个参数,字段名称是 lures
。 对于第二个参数,字段名称是 warehouse
。
然后提供 accessor 方法上面所匹配的注解和字段名称。在 lures
的 getter 方法的正上方,可以看到适当的注解,完全匹配构造器中使用的注解。类似地,warehouse
的 getter 方法上面的注解也完全匹配该注解。
要执行该代码,只需对 清 单 11 稍加修改,以包含 清 单 14 中的代码。
清单 14. LureExample5 类
Inventory2 inventory = new Inventory2(lures,"MidWest");
|
使用 清 单 14 中的代码,而不使用 清 单 11 中使用的 setter 方法。其余都保持不变。
模板过滤器
Simple 的另一个伟大特性是,在反序列化 XML 文档时能够使用模板过滤器或默认值。
回到初始的 lure.xml,但是稍微修改一下,如 清 单 15 所示。
清单 15. Lure2.xml 文档
${lure.company}
23
Marlin Buster
|
注意 company 元素怎么不是包含实际的公司名称,而是包含一个类似于 Apache Ant 的变量声明?在本例中,变量的名称是 lure.company
。
模板过滤器允许您用在运行时建立的实际的值代替变量声明。做到这一点最容易的一种方式是,利用一个 Map
对象将变量名与它的值相关联。然后使用该 Map
对象从 Simple 框架构造一个 Filter
对象。然后再使用该 Filter
对象构造 Persister
对象。我们来看一下 清 单 16。
清单 16. LureExample6 类
Map map = new HashMap;
map.put("lure.company", "Monmouth");
Filter filter = new MapFilter(map);
Serializer serializer = new Persister(filter);
File source = new File("lure2.xml");
Lure lure = serializer.read(Lure.class, source);
System.out.println(lure.getCompany);
System.out.println(lure.getModel);
System.out.println(lure.getQuantityInStock);
System.out.println(lure.getType);
|
清 单 16 与 清 单 2 并没有大的差别。主要差别是,实例化了一个 HashMap
,用于将一个 String
值与一个 String
键相关联。本例中的 String
键果然是 lure.company
, 即 清 单 15 中使用的变量名。这里给它分配的值是 Monmouth
,而不是前面 XML 文档中的 Donzai
。
执行该代码时,输出应该类似于 清 单 17。
清单 17. LureExample6 的输出
Monmouth
Marlin Buster
23
Trolling
|
可以看到,模板过滤器用 Map
对象中与该键名关联的实际值取代了变量名 lure.company
。 输出与预期完全一致。
结束语
如您所见,Simple 是一个健壮的 XML 序列化和反序列化框架。易于使用,无需配置,并且简化了开发工作。
Simple 有很多强大的特性,但是由于篇幅所限,这里只探讨了其中很少的几个特性。我强烈建议需要在软件开发项目中采用 XML 序列化和反序列化的开发人员考虑使用 Simple。
分享到:
相关推荐
XML序列化 同样,Simple-XML也可以方便地将Java对象序列化为XML: ```java Person person = new Person(); person.setName("John Doe"); person.setAge(30); Serializer serializer = new Persister(); File ...
2. **XML序列化**:对于Java对象,使用`SerializationHelper.serialize()`方法,可以将其转换为XML字符串。同样,也可以写入文件或输出流。 在实际项目中,Simple XML库可以用于处理配置文件、网络通信中的数据交换...
1. **序列化**:Simple-XML的序列化过程是将Java对象转换为XML文档。通过在类或字段上使用`@Element`、`@Attribute`等注解,可以指示哪些属性应当被转换为XML元素或属性。例如,一个`Person`类可以这样定义: ```...
该死的简单XML Dams Simple XML DSX经过优化,可以序列化JavaScript对象并反序列化以前从对象以其他编程语言(或通过DSX)进行序列化的XML元素。 DSX不能处理任何形式的自由格式XML文档。 DSX的内存占用量很小。 它...
使用 Simple,开发人员可以简化(名字由此而来)将简单老 Java 对象(POJO)转换成 XML 文档的过程 — 即所谓的序列化(serialization)过程。Simple 也可促进相反的过程:开发人员可以将 XML 文档转换成 POJO — 即...
4. 使用场景:XML二进制序列化和SOAP二进制编码通常应用于需要高效网络通信的场景,例如高并发的Web服务、移动设备应用或者低带宽环境。它们能够减少服务器负载,提高响应时间,提升用户体验。 5. 实现与库:许多...
总的来说,理解和掌握自定义XML操作类的使用对于IT专业人员来说非常重要,特别是在涉及跨平台数据交换、配置文件管理或者需要序列化Java对象为XML格式的场景下。通过这个简单的XML操作类,我们可以更高效地处理XML...
通过使用“simple-xml2object-1.0.0”,开发者可以避免手动编写XML解析代码,减少出错的可能性。例如,一个XML文档中的用户信息可以被转换为User对象,包括用户名、年龄等属性。 对象到XML的转换同样重要。当需要将...
Ksoap2支持对象的自动序列化和反序列化,简化了与Web服务的交互。在使用Ksoap2时,我们需要配置以下步骤: 1. **添加依赖**:首先,在项目的build.gradle文件中添加Ksoap2的依赖库。 2. **创建SOAP请求**:使用...
XML序列化与SOAP(Simple Object Access Protocol)的关系在于,XML序列化可以生成SOAP消息,而SOAP序列化则主要用于XML Web服务的方法调用,传递参数和返回值。 然而,XML序列化也有一些限制,例如它不能序列化...
简单XML库(Simple XML)是Java中一个轻量级、高效的XML序列化和反序列化库,非常适合处理XML格式的数据。 首先,让我们了解Retrofit的基本概念。Retrofit由Square公司开发,它允许开发者通过简单的注解将HTTP操作...
在Java开发中,XML(eXtensible Markup Language)是一种常用的数据交换格式,它具有良好的结构化和可读性,广泛应用于配置文件、数据传输、序列化等方面。本主题聚焦于Java与XML之间的相互转化,特别是如何利用XML...
7. **XML序列化与反序列化**:XMLHelper可能还提供了对象到XML和XML到对象的转换功能,方便数据的存储和恢复。这通常涉及到Java的JavaBeans、C#的XmlSerializer等技术。 8. **XPath和XSLT支持**:XPath用于在XML...
在Java等编程语言中,有许多库支持XML序列化,如Java的JAXB(Java Architecture for XML Binding)或DOM4J。这些库允许开发者将对象的状态转换为XML文档,以便于存储或传输。反序列化则能将XML恢复为可操作的对象,...
2. XML序列化与反序列化:在Java中,可以使用JAXB(Java Architecture for XML Binding)将对象转换为XML,反之亦然,实现数据的序列化和反序列化。 三、XML与Java 1. DOM(Document Object Model):Java中,XML...
XML序列化是将对象转换为XML格式的过程。在C#中,可以使用`System.Xml.Serialization`命名空间下的`XmlSerializer`类来进行序列化。 ```csharp Person person = new Person { Name = "John Doe", Age = 30 }; ...
例如,在开发SOAP(Simple Object Access Protocol)Web服务时,JAXB可以方便地处理XML消息的序列化和反序列化。 **进一步学习资源:** 1. Java官方文档:...
JAXB大大简化了XML数据的序列化和反序列化过程,对于XML数据的输入输出操作非常便捷。 4. DOM与SAX的比较 DOM解析器在内存效率上不如SAX,但提供了更直观的文档结构,易于操作;SAX则更适合处理大文件,但需要编写...
- 实现这些接口,包括解析XML、序列化XML、验证XML等操作。 - 提供文档说明,解释每个方法的功能和用法。 - 创建示例代码,展示SDK的典型应用。 5. **XML SDK的使用**:使用XML SDK时,开发者可以: - 通过SDK...