使用 Simple 简化 XML 序列化
真正简化从 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，然后才能使用它。但是关于这个过程，既有好消息，也有坏消息。好消息是，归档文件是免费的。坏消息是，归档文件是 .tar.gz 格式的。所以，您若是想用 Microsoft® Windows® 本机归档文件解压程序来打开这个归档文件的话，是会失望的。需要使用 WinZip 或其他类似的归档工具。
解压文件之后，注意在 jar 目录中有一个 JAR 文件（simple-xml-2.1.4.jar）。在编译时和运行时，类路径中需要有这个 JAR 文件。
将一个对象序列化成一个 XML 文档是一个相当简单的过程。涉及到两步：
- 创建具有适当注解的 POJO。
- 编写不多的几行代码，用于真正执行序列化过程。
为了本文目的，我们来回顾一下熟悉的鱼饵主题（当然只有读过我的文章的读者熟悉）。所以，清 单 1 是一个表示鱼饵信息的 POJO。
@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 中的该代码。
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。
Donzai 23 Marlin Buster |
注意关于 清 单 3 的几点。首先，注意 lure 类型是根元素的一个属性。这没有疑义，因为前面在 POJO 中是用 @Attribute 而不是 @Element 注解了 type 字段。
关于产生的 XML，另一个重点是元素名称遵循 JavaBean 标准。例如，根元素是 lure，尽管类名称 是 Lure。3 个子元素名称完全匹配字段名称。同样，这也是有意为之，因为您不想要首字母大写的根元素，而子元素名称则遵循另外的模式。
序列化一个对象是如此地容易，那么反序列化对象也很容易，对不对？对！
回想一下，反序列化是将 XML 文档转换成 POJO 的过程。很不错的是，可以使用刚才创建的 XML 文档来进行反序列化。
清 单 4 展示了反序列化代码。
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。
Donzai Marlin Buster 23 Trolling |
至此，您所序列化和反序列化的 XML 文档都相当简单。
大多数 XML 文档要复杂多了。它们通常具有数层嵌套的元素，有时候还有一到多个重复的元素，每个元素又有几个子元素。
幸运的是，Simple 即使对于更复杂的文档也不违反它的名字的寓意。就像在一个 POJO 中嵌套又一个 POJO 那么简单。我们来看一下 清 单 6。
@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 中。
@Root
public class ConfigurationScheme {
@Element
private String color;
@Element
private int size; |
为节省篇幅，我舍去了 accessor 方法和 mutator 方法。
清 单 7 中的注解应该看起来很熟悉。它们与 清 单 1 中使用的是相同的注解。
这又将我们引向 清 单 8。
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。
Donzai
23
Marlin Buster
Blue
3 |
可以看到，嵌套的元素与预期那样地被序列化。
XML 文档经常包含某些元素的枚举。也就是说，相同的元素名称可以重复，只不过带有不同的子元素或属性数据而已。幸运的是，Simple 也能够处理这种情况。
为了演示该特性，我们创建一个新的类，名叫 Inventory，其中包含仓库（储存库存的地方）的名称和在该库 存位置找到的鱼饵的列表，如 清 单 10 中所示。
@Root
public class Inventory {
@ElementList
private List lures;
@Attribute
private String warehouse; |
注意，使用了一个新注解：@ElementList。该注解告诉 Simple 框架：相应的 List 对象代表 XML 元素的枚举。
用于演示该 POJO 的序列化的代码跟用于序列化更简单的 POJO（比如说 清 单 2 中序列化的那个 POJO）的代码一样容易。唯一增加的复杂性来自于，为嵌套目的实例化了所有必需的对象。参见 清 单 11。
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。
Donzai
23
Marlin Buster
Blue
3
Ziggi
44
Tuna Finder
Red
5 |
可以看到，输出完全模仿 清 单 11 中实例化及创建的 POJO。其中有两个 advancedLure 元素，它们各自包含用来填充相应 POJO 的数据。注意，嵌套也是允许的。
您的代码有可能使用永久不变的 POJO。在这种情况下，您可能会缺少用于修改字段属性的 setter 方法，相反，您依靠构造器来设置这些值。Simple 也能够处理这种情况。
在这种情况下，注解指定在构造器参数中，而不是放在字段名称上面。在适当 accessor 方法上面也需要注解。参见 清 单 13。
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 中的代码。
Inventory2 inventory = new Inventory2(lures,"MidWest"); |
使用 清 单 14 中的代码，而不使用 清 单 11 中使用的 setter 方法。其余都保持不变。
Simple 的另一个伟大特性是，在反序列化 XML 文档时能够使用模板过滤器或默认值。
回到初始的 lure.xml，但是稍微修改一下，如 清 单 15 所示。
${lure.company}
23
Marlin Buster |
注意 company 元素怎么不是包含实际的公司名称，而是包含一个类似于 Apache Ant 的变量声明？在本例中，变量的名称是 lure.company。
模板过滤器允许您用在运行时建立的实际的值代替变量声明。做到这一点最容易的一种方式是，利用一个 Map 对象将变量名与它的值相关联。然后使用该 Map 对象从 Simple 框架构造一个 Filter 对象。然后再使用该 Filter 对象构造 Persister 对象。我们来看一下 清 单 16。
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。
Monmouth Marlin Buster 23 Trolling |
可以看到，模板过滤器用 Map 对象中与该键名关联的实际值取代了变量名 lure.company。 输出与预期完全一致。
如您所见，Simple 是一个健壮的 XML 序列化和反序列化框架。易于使用，无需配置，并且简化了开发工作。
Simple 有很多强大的特性，但是由于篇幅所限，这里只探讨了其中很少的几个特性。我强烈建议需要在软件开发项目中采用 XML 序列化和反序列化的开发人员考虑使用 Simple。