JAXB生成XML时指定以子类的结构生成XML
假设现在有这样一项任务，要求你写两个关于获取User和Dept的接口出来，它们对外提供的数据是XML格式，分别对应如下格式。
<response>
<errorCode>0</errorCode>
<errorMessage>成功</errorMessage>
<data>
<dept>
<id>100</id>
<name>财务部</name>
<parentId>10</parentId>
<no>A001</no>
</dept>
</data>
</response>
<response>
<errorCode>0</errorCode>
<errorMessage>成功</errorMessage>
<data>
<user>
<id>1000</id>
<name>张三</name>
<parentId>100</parentId>
<username>zhangsan</username>
</user>
</data>
</response>
从response到data那部分其实是系统中对外接口的通用格式，所不同的内容都是data元素里面包含的内容，不单是上面两个接口的响应格式，其它接口也是一样的。通用格式如下所示：
<response>
<errorCode>0</errorCode>
<errorMessage>成功</errorMessage>
<data>
<!--特性的内容-->
</data>
</response>
关于User和Dept接口对应的Java类，系统中已经存在了相应的定义，定义如下：
/**
* 抽象的组织机构，提取出公用的id、父级id和名称
*/
public abstract class AbstractOrg {
public static final int TYPE_DEPT = 1;
public static final int TYPE_USER = 2;
private Integer id;
private Integer parentId;
private String name;
/**
* 区分组织类型的，1是Dept，2是User
*/
private final int type;
protected AbstractOrg(int type) {
this.type = type;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getParentId() {
return parentId;
}
public void setParentId(Integer parentId) {
this.parentId = parentId;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getType() {
return type;
}
}
public class Dept extends AbstractOrg {
private String no;
public Dept() {
super(AbstractOrg.TYPE_DEPT);
}
public String getNo() {
return no;
}
public void setNo(String no) {
this.no = no;
}
}
public class User extends AbstractOrg {
private String username;
public User() {
super(AbstractOrg.TYPE_USER);
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
}
为了满足上述的接口需求，通用的格式对应的Java类定义我们可能会定义如下，定义了Response类和ResultData类，真实的data部分将由ResultData持有。
/**
* 根节点
*/
@XmlRootElement
@XmlType(propOrder= {"errorCode", "errorMessage", "data"})
public class Response {
private String errorCode;
private String errorMessage;
private ResultData data;
public String getErrorCode() {
return errorCode;
}
public void setErrorCode(String errorCode) {
this.errorCode = errorCode;
}
public String getErrorMessage() {
return errorMessage;
}
public void setErrorMessage(String errorMessage) {
this.errorMessage = errorMessage;
}
public ResultData getData() {
return data;
}
public void setData(ResultData data) {
this.data = data;
}
}
/**
* data节点包装对象的包装类
*/
public class ResultData {
private Object realData;
public ResultData() {}
public ResultData(Object realData) {
this.realData = realData;
}
public void setRealData(Object realData) {
this.realData = realData;
}
@XmlElement
public Object getRealData() {
return realData;
}
}
这样Dept对应的接口生成的XML可以进行类似如下的调用，在创建对应的JAXBContext时必须传递realData对应的真实Class，因为通过Response关联到的ResultData中定义的realData的类型是java.lang.Object。不传递realData的真实类型时，JAXB遇到realData会不知道如何去解析它。
@Test
public void testMarshalDept() throws Exception {
Dept dept = new Dept();
dept.setId(100);
dept.setParentId(10);
dept.setName("财务部");
dept.setNo("A001");
this.marshal(dept);
}
private void marshal(Object realData) throws Exception {
JAXBContext jaxbContext = JAXBContext.newInstance(Response.class, realData.getClass());
Marshaller marshaller = jaxbContext.createMarshaller();
marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
Response response = new Response();
response.setErrorCode("0");
response.setErrorMessage("成功");
ResultData data = new ResultData(realData);
response.setData(data);
marshaller.marshal(response, System.out);
}
上面的测试代码生成的XML如下：
<response>
<errorCode>0</errorCode>
<errorMessage>成功</errorMessage>
<data>
<realData xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="dept">
<id>100</id>
<name>财务部</name>
<parentId>10</parentId>
<no>A001</no>
</realData>
</data>
</response>
从生成的XML我们可以看到生成的XML的结构确实是按照传递的realData的真实类型的结构生成的，比如上面就是按照传递的Dept类型的对应的结构生成的。但是有两个问题，一是realData节点上多了namespace的引用，二是realData节点的名称不是我们想要的dept，而是默认的realData。对于问题一来说，因为顺着根节点类型Response是没有直接关联Dept的，相对于Response来说，Dept是外部引入的，不是它内部直接关联的，所以在realData节点上有了类型的声明。对于问题二有三种解决方案，这三种解决方案都可以同时解决问题一和问题2，本文将介绍其中的两种方案，第三种方案在后续介绍动态根据对象属性生成节点名称时会讲到。
方案一
可能有读者会想到@XmlElement可以用来指定生成XML时元素的名称，而不是使用默认的属性名称。可能会想我们可以把ResultData上的@XmlElement改为@XmlElement(name="dept")，这样生成的节点名称就是dept了。
public class ResultData {
private Object realData;
public ResultData() {}
public ResultData(Object realData) {
this.realData = realData;
}
public void setRealData(Object realData) {
this.realData = realData;
}
@XmlElement(name="dept")
public Object getRealData() {
return realData;
}
}
调整后生成的XML如下：
<response>
<errorCode>0</errorCode>
<errorMessage>成功</errorMessage>
<data>
<dept xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="dept">
<id>100</id>
<name>财务部</name>
<parentId>10</parentId>
<no>A001</no>
</dept>
</data>
</response>
这样看着好像是解决了节点名称的问题，实际上还是不可行的，上述我们把节点名称写死了，已经明确的指定为dept了，如果realData传递的是User类型的对象，生成的节点名称也会是dept，而不是我们期望的user。所以这么做肯定是不行的。需要动态的使用节点的名称。这个时候我们就可以把@XmlElement和@XmlElements一起使用，即定义多个@XmlElement，指定在realData为Dept类型时，生成的节点名称为dept，realData为User类型时，生成的节点名称为user。对ResultData的realData配置调整如下。
public class ResultData {
private Object realData;
public ResultData() {}
public ResultData(Object realData) {
this.realData = realData;
}
public void setRealData(Object realData) {
this.realData = realData;
}
@XmlElements({ @XmlElement(name = "dept", type = Dept.class), @XmlElement(name = "user", type = User.class) })
public Object getRealData() {
return realData;
}
}
这时候生成出来的XML就是我们期望的样子。传递Dept对象生成的结果如下：
<response>
<errorCode>0</errorCode>
<errorMessage>成功</errorMessage>
<data>
<dept>
<id>100</id>
<name>财务部</name>
<parentId>10</parentId>
<no>A001</no>
</dept>
</data>
</response>
传递User对象生成的结果如下：
<response>
<errorCode>0</errorCode>
<errorMessage>成功</errorMessage>
<data>
<user>
<id>1000</id>
<name>张三</name>
<parentId>100</parentId>
<username>zhangsan</username>
</user>
</data>
</response>
此方案的完整配置如下：
/**
* 根节点
*/
@XmlRootElement
@XmlType(propOrder= {"errorCode", "errorMessage", "data"})
public class Response {
private String errorCode;
private String errorMessage;
private ResultData data;
public String getErrorCode() {
return errorCode;
}
public void setErrorCode(String errorCode) {
this.errorCode = errorCode;
}
public String getErrorMessage() {
return errorMessage;
}
public void setErrorMessage(String errorMessage) {
this.errorMessage = errorMessage;
}
public ResultData getData() {
return data;
}
public void setData(ResultData data) {
this.data = data;
}
}
/**
* data节点包装对象的包装类
*/
public class ResultData {
private Object realData;
public ResultData() {}
public ResultData(Object realData) {
this.realData = realData;
}
public void setRealData(Object realData) {
this.realData = realData;
}
@XmlElements({ @XmlElement(name = "dept", type = Dept.class), @XmlElement(name = "user", type = User.class) })
public Object getRealData() {
return realData;
}
}
/**
* 抽象的组织机构，提取出公用的id、父级id和名称
*/
public abstract class AbstractOrg {
public static final int TYPE_DEPT = 1;
public static final int TYPE_USER = 2;
private Integer id;
private Integer parentId;
private String name;
/**
* 区分组织类型的，1是Dept，2是User
*/
private final int type;
protected AbstractOrg(int type) {
this.type = type;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getParentId() {
return parentId;
}
public void setParentId(Integer parentId) {
this.parentId = parentId;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getType() {
return type;
}
}
public class Dept extends AbstractOrg {
private String no;
public Dept() {
super(AbstractOrg.TYPE_DEPT);
}
public String getNo() {
return no;
}
public void setNo(String no) {
this.no = no;
}
}
public class User extends AbstractOrg {
private String username;
public User() {
super(AbstractOrg.TYPE_USER);
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
}
使用此方案时我们在创建JAXBContext时可以不用再传递realData真实的类型了，因为它们都已经通过getRealData()方法上的@XmlElements注解定义了，JAXBContext通过ResultData就可以识别它们了。另外此方案在realData的类型比较少的时候可以很方便的进行配置，如果在一个比较大型的接口系统中，realData会有好几百或更多的可能性，把它们都定义在realData上有点不太现实。幸好接下来要介绍的方案二可以解决这种问题。
方案二
方案二是使用@XmlElementRef注解，使用该注解标注在getRealData()方案上可以使用JAXB在生成XML时自动使用当前定义类型的实际子类型的结构来生成。但是它标注的属性或方法的返回类型不能是java.lang.Object，需要是更加具体的类型。通常这种情况下我们会定义一个抽象类来供所有的realData类型继承，这个类型只是一个标示作用，可以是空的，即没有任何属性定义在其中。这里为了简便起见，我们使用Dept和User的父类AbstractOrg来代替。调整后的ResultData定义如下：
public class ResultData {
private AbstractOrg realData;
public ResultData() {}
public ResultData(AbstractOrg realData) {
this.realData = realData;
}
public void setRealData(AbstractOrg realData) {
this.realData = realData;
}
@XmlElementRef
public AbstractOrg getRealData() {
return realData;
}
}
使用@XmlElementRef后整个节点的生成都将依赖于实际的子类型，包括根节点的名称，此时的根节点名称需要在子类型上通过@XmlRootElement来指定，而不再默认使用持有它的对象对应的属性的名称，即不再是默认的realData。
@XmlRootElement(name="dept")
public class Dept extends AbstractOrg {
private String no;
public Dept() {
super(AbstractOrg.TYPE_DEPT);
}
public String getNo() {
return no;
}
public void setNo(String no) {
this.no = no;
}
}
@XmlRootElement
public class User extends AbstractOrg {
private String username;
public User() {
super(AbstractOrg.TYPE_USER);
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
}
采用@XmlElementRef的方式时节点名称只能在子类上通过@XmlRootElement指定，不能再在对应的属性上通过@XmlElement来指定其它名称了，即上述的示例中不能在getRealData()方法上既有@XmlElementRef，又有@XmlElement，因为@XmlElementRef和@XmlElement是互斥的。
采用此种方式在创建JAXBContext时也需要传递本次进行XML和Java对象相互转换使用到的realData的实际类型，否则具体的实际类型将不被识别。如果期望JAXBContext时不传递realData的实际类型，也可以在JAXBContext能够识别的Class上通过@XmlSeeAlso来引入。通常是加在父类上的。
@XmlSeeAlso({Dept.class, User.class})
public abstract class AbstractOrg {
public static final int TYPE_DEPT = 1;
public static final int TYPE_USER = 2;
private Integer id;
private Integer parentId;
private String name;
/**
* 区分组织类型的，1是Dept，2是User
*/
private final int type;
protected AbstractOrg(int type) {
this.type = type;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getParentId() {
return parentId;
}
public void setParentId(Integer parentId) {
this.parentId = parentId;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getType() {
return type;
}
}
这种方式也不是万能的。有的时候我们的Java类是有继承关系的，在生成XML时也期望可以按照子类的结构生成XML，也使用了@XmlElementRef，但是我们期望生成的XML的节点的名称都是相同的，比如上述示例如果期望无论是Dept还是User，对应的节点名称都是org。这时候如果我们有通过XML转换为Java对象的需求，那么XML的org节点将转换为Java的Dept对象还是User对象呢？实际上这时候JAXB将按照定义的顺序来，后面的将具有更高的优先级，但是这很明显不满足我们的需求。所以此种情形下我们要避免使用@XmlSeeAlso把所有的子类型都引入，具体的子类型还是在创建JAXBContext时老老实实的传入。
如果需要反过来通过XML生成Java对象也是可以的，JAXB也能正确的识别需要创建的对象。为了验证这个问题，笔者做了如下实验。把marshal的结果，即通过Java对象生成的XML保存起来，然后再通过unmarshal把对应的XML转换为Java对象，即Response对象，再通过Response.getData().getRealData()获取到转换后的realData，把转换后的realData和转换前的realData做比较。注意这时候不能用==，需要使用equals，因为它们肯定是两个不同的对象。
@Test
public void testMarshalUser() throws Exception {
User user = new User();
user.setId(1000);
user.setParentId(100);
user.setName("张三");
user.setUsername("zhangsan");
String xml = this.marshal(user);
Response response = JAXB.unmarshal(new StringReader(xml), Response.class);
AbstractOrg realData = response.getData().getRealData();
Assert.assertEquals(user, realData);
}
@Test
public void testMarshalDept() throws Exception {
Dept dept = new Dept();
dept.setId(100);
dept.setParentId(10);
dept.setName("财务部");
dept.setNo("A001");
String xml = this.marshal(dept);
Response response = JAXB.unmarshal(new StringReader(xml), Response.class);
AbstractOrg realData = response.getData().getRealData();
Assert.assertEquals(dept, realData);
}
private String marshal(AbstractOrg realData) throws Exception {
JAXBContext jaxbContext = JAXBContext.newInstance(Response.class);
Marshaller marshaller = jaxbContext.createMarshaller();
marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
Response response = new Response();
response.setErrorCode("0");
response.setErrorMessage("成功");
ResultData data = new ResultData(realData);
response.setData(data);
StringWriter writer = new StringWriter();
marshaller.marshal(response, writer);
return writer.toString();
}
为了使上述的测试结果能够顺利通过，还必须重写对应的Dept和User的equals方法，还需要在父类AbstractOrg上定义一个类似于equals那样比较所有属性值的方法以供子类在进行equals比较时调用。使用@XmlElementRef方式的并验证Java对象和XML能够完美相互转换的完整配置代码如下：
/**
* 根节点
*/
@XmlRootElement
@XmlType(propOrder= {"errorCode", "errorMessage", "data"})
public class Response {
private String errorCode;
private String errorMessage;
private ResultData data;
public String getErrorCode() {
return errorCode;
}
public void setErrorCode(String errorCode) {
this.errorCode = errorCode;
}
public String getErrorMessage() {
return errorMessage;
}
public void setErrorMessage(String errorMessage) {
this.errorMessage = errorMessage;
}
public ResultData getData() {
return data;
}
public void setData(ResultData data) {
this.data = data;
}
}
/**
* data节点包装对象的包装类
*/
public class ResultData {
private AbstractOrg realData;
public ResultData() {}
public ResultData(AbstractOrg realData) {
this.realData = realData;
}
public void setRealData(AbstractOrg realData) {
this.realData = realData;
}
@XmlElementRef
public AbstractOrg getRealData() {
return realData;
}
}
/**
* 抽象的组织机构，提取出公用的id、父级id和名称
*/
@XmlSeeAlso({Dept.class, User.class})
public abstract class AbstractOrg {
public static final int TYPE_DEPT = 1;
public static final int TYPE_USER = 2;
private Integer id;
private Integer parentId;
private String name;
/**
* 区分组织类型的，1是Dept，2是User
*/
private final int type;
protected AbstractOrg(int type) {
this.type = type;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getParentId() {
return parentId;
}
public void setParentId(Integer parentId) {
this.parentId = parentId;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getType() {
return type;
}
protected boolean superEquals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
AbstractOrg other = (AbstractOrg) obj;
if (id == null) {
if (other.id != null)
return false;
} else if (!id.equals(other.id))
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
if (parentId == null) {
if (other.parentId != null)
return false;
} else if (!parentId.equals(other.parentId))
return false;
if (type != other.type)
return false;
return true;
}
}
@XmlRootElement(name="dept")
public class Dept extends AbstractOrg {
private String no;
public Dept() {
super(AbstractOrg.TYPE_DEPT);
}
public String getNo() {
return no;
}
public void setNo(String no) {
this.no = no;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Dept other = (Dept) obj;
if (no == null) {
if (other.no != null)
return false;
} else if (!no.equals(other.no))
return false;
if (!this.superEquals(obj)) {//父结构不能equals
return false;
}
return true;
}
}
@XmlRootElement
public class User extends AbstractOrg {
private String username;
public User() {
super(AbstractOrg.TYPE_USER);
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
User other = (User) obj;
if (username == null) {
if (other.username != null)
return false;
} else if (!username.equals(other.username))
return false;
if (!this.superEquals(obj)) {//父结构不能equals
return false;
}
return true;
}
}
以上就是以子类结构绑定XML的两种方式。
相关推荐
在给定的例子中，我们将深入理解如何使用JAXB注解来生成XML。 1. **@XmlType**: 这个注解用于定义类的属性在XML输出中的顺序。在`WriterXml`类中，propOrder 属性指定了"id", "name", "age", "book"这四个属性的...
**使用JAXB根据XSD生成XML文档** 在Java开发中，XML文档的生成与解析是一项常见的任务，特别是在处理数据交换和存储时。JAXB（Java Architecture for XML Binding）是Java平台标准的一部分，它提供了一种将Java对象...
2. **注解**：在描述中提到的"JAXB注解"是用于标记Java类和类成员的关键元素，以指示它们如何在XML中表示。例如，`@XmlRootElement`注解标识一个类作为XML文档的根元素，`@XmlElement`注解用于将类的属性映射到XML...
### 使用JAXB生成XML文档详解 #### 一、前言 在现代软件开发过程中，XML（可扩展标记语言）作为一种重要的数据交换格式，被广泛应用于各种应用场景中。特别是在J2EE（Java Platform, Enterprise Edition）领域，...
1. **复杂性**：对于非常复杂的XML结构，JAXB可能变得难以管理，因为生成的Java类可能会很庞大。 2. **内存消耗**：在处理大型XML文档时，JAXB可能会占用大量内存，因为它会将整个文档加载到内存中。 3. **灵活性**...
3. **根据XML Schema生成XML**：在知道XML Schema的结构后，可以编写符合该结构的XML文档，或者使用工具自动生成。例如，有的XML编辑器（如oXygen、XML Spy等）支持从XSD生成XML模版，方便快速构建文档。 4. **利用...
在Java开发中，JAXB提供了一种方便的方式，允许开发者通过XML Schema (XSD) 文件来生成对应的Java类，从而简化XML处理的工作流程。 1. **XML Schema (XSD) 文件**： - XML Schema是一种W3C标准，用于定义XML文档的...
如果不希望手动添加注解，可以使用JAXB的绑定工具（如`xjc`）从XML Schema (XSD)文件生成对应的Java类。这一步骤将创建带有正确注解的Java类，以便JAXB理解XML结构。 (3) **实例化Java对象** 创建Java对象并填充...
1. **创建Java类模型**：基于XML Schema定义的结构，JAXB可以自动生成Java类，或者你可以手动编写符合XML结构的Java类。 2. **设置上下文（Context）**：使用`JAXBContext`类创建一个JAXB上下文，它包含了所有需要...
XML是一种可扩展标记语言，它通过标签来定义元素和数据，允许数据以层次结构表示。嵌套子节点意味着一个元素内包含其他元素，这在XML中很常见。 使用JAXB解析XML时，我们首先需要创建一个Java类模型，这个模型反映...
总结来说，JAXB虽然主要用于对象绑定，但在处理XML数据时，我们可以通过自定义实现将XML数据转换为Map，以适应更灵活的数据处理需求。这个过程涉及XML的解析、节点遍历以及Map的构建。虽然JAXB不直接提供这个功能，...
在实际项目中，你可能需要根据具体需求对上述代码进行调整，比如添加注解以控制XML的生成方式，或者处理集合类型的属性等。在处理大量数据时，还应考虑性能优化，例如使用流式处理或分批次序列化。 总的来说，Java...
1. 自动化：JAXB自动生成Java类和XML之间的映射，大大减少了手动编码的工作量。 2. 高效：JAXB提供了高性能的序列化和反序列化机制。 3. 标准化：作为Java EE的一部分，JAXB遵循了Java社区的开放标准，确保了广泛的...
在Java开发中，当处理XML数据时，通常需要将XML结构映射到Java对象以便于操作。XJC命令就是用来实现这一过程的。它可以从XML Schema文件中自动生成Java源代码，这些源代码包含了符合Schema定义的Java类，它们具有...
除了注解方式，JAXB还支持使用XML Schema（XSD）文件生成Java类。通过`xjc`工具，可以将XSD转换为Java源代码，这使得模型和XML结构更加清晰地分离。 JAXB的另一个重要特性是它支持XML绑定的定制，包括命名空间处理...
首先，XML Schema定义了XML文档的结构和约束，而JAXB则根据这个Schema生成对应的Java类。当解析XML文档时，JAXB会根据Schema创建相应的Java对象；反之，当需要将Java对象转换为XML时，JAXB会生成符合Schema的XML文档...
标题“用jaxb自动生成xsd对像”指的是利用JAXB的XJC（XSD到Java绑定编译器）工具，从XML Schema文件生成对应的Java类。这使得你可以直接操作Java对象，而无需直接处理XML的细节。 描述中的“简单易用”意味着通过...
Java中的JAXB（Java Architecture for XML Binding）是一个用于在Java对象和XML文档之间进行映射的标准API。这个技术使得开发者可以方便地将XML数据转换为Java对象，反之亦然。在给定的压缩包文件中，可能包含了实现...
JAXB的优势在于其自动化程度高，只需通过注解或配置文件，就能轻松地映射XML结构到Java对象。 结合StAX和JAXB，可以在解析XML时充分利用两者的优点。首先，使用StAX逐个读取XML事件，然后利用JAXB将这些事件转换为...
1. 编译器：读入 DTD 或者 XML Schema，生成相等结构的 Java Object Model。 2. 操作 API：提供了统一的基本操作（如 marshalling,unmarshalling），隐藏了 JAXB 内部操作的实现代码。 JAXB 的基本操作 -----------...