JAXB:如何解组不同类型但具有共同父级的对象列表? [英] JAXB: how to unmarshal a List of objects of different types but with common parent?
问题描述
在我们的应用程序中有一个相当常见的模式.我们在 Xml 中配置了一组(或列表)对象，它们都实现了一个公共接口.启动时，应用程序读取 Xml 并使用 JAXB 创建/配置对象列表.我从来没有想过(在多次阅读各种帖子之后)只使用 JAXB 来做到这一点的正确方法".
例如，我们有一个接口Fee，和多个具体的实现类，它们有一些共同的属性，也有一些不同的属性，以及非常不同的行为.我们用来配置应用使用的费用列表的 Xml 是:
<费用><fee type="Commission" name="commission" rate="0.000125"/><fee type="FINRAPerShare" name="FINRA" rate="0.000119"/><fee type="SEC" name="SEC" rate="0.0000224"/><费用类型=路线"名称=路线"><路线><路线><name>NYSE</name><费率><billing code="2" rate="-.0014" normalized="A"/><billing code="1" rate=".0029" normalized="R"/></rates></路线></路线>...</费用></费用>在上面的 Xml 中，每个 type 属性提供有关要实例化的类型的信息，然后一旦实例化，JAXB 解组就会应用剩余 Xml 中的属性.
我总是不得不求助于做这样的事情:
private void addFees(TradeFeeCalculatorcalculator) throws Exception {NodeList feeElements = configDocument.getElementsByTagName("fee");for (int i = 0; i 在上述代码的最后，我们得到一个列表，其中包含在 Xml 中配置的任何类型.
有没有办法让 JAXB 自动执行此操作，而无需编写代码来迭代上述元素?
注意:我是EclipseLink JAXB (MOXy) 领导和成员 JAXB (JSR-222) 专家组.
如果您使用 MOXy 作为 JAXB 提供程序，那么您可以使用 MOXy 的 @XmlPaths 注释扩展标准 JAXB @XmlElements 注释以执行以下操作:
费用
import java.util.List;导入 javax.xml.bind.annotation.*;导入 org.eclipse.persistence.oxm.annotations.*;@XmlRootElement公开课费用{@XmlElements({@XmlElement(type=Commission.class),@XmlElement(type=FINRAPerShare.class),@XmlElement(type=SEC.class),@XmlElement(type=Route.class)})@XmlPaths({@XmlPath("费用[@type='佣金']"),@XmlPath("费用[@type='FINRAPerShare']"),@XmlPath("费用[@type='SEC']"),@XmlPath("费用[@type='Route']")})私人名单<费用>费用;}佣金
Fee 接口的实现会正常注释.
import javax.xml.bind.annotation.*;@XmlAccessorType(XmlAccessType.FIELD)公共类佣金实施费用{@XmlAttribute私人字符串名称；@XmlAttribute私人字符串率；}了解更多信息
- http://blog.bdoughan.com/2011/03/map-to-element-based-on-attribute-value.html
- http://blog.bdoughan.com/2010/10/jaxb-and-xsd-choice-xmlelements.html
- http://blog.bdoughan.com/2011/05/specifying-eclipselink-moxy-as-your.html
There is a fairly common pattern in our applications. We configure a configure a set (or list) of objects in Xml, which all implement a common interface. On start-up, the application reads the Xml and uses JAXB to create/configure a List of objects. I have never figured out (after reading various posts many times) the "right way" to do this using only JAXB.
For example, we have an interface Fee, and multiple concrete implementing classes which have some common properties, as well as some diverging properties, and very different behaviors. The Xml we use to configure the List of Fees used by application is:
<fees>
<fee type="Commission" name="commission" rate="0.000125" />
<fee type="FINRAPerShare" name="FINRA" rate="0.000119" />
<fee type="SEC" name="SEC" rate="0.0000224" />
<fee type="Route" name="ROUTES">
<routes>
<route>
<name>NYSE</name>
<rates>
<billing code="2" rate="-.0014" normalized="A" />
<billing code="1" rate=".0029" normalized="R" />
</rates>
</route>
</routes>
...
</fee>
</fees>
In the above Xml, each <fee> element corresponds to a concrete subclass of a Fee interface. The type attribute gives information about which type to instantiate, and then once it is instantiated, the JAXB unmarshalling applies the properties from the remaining Xml.
I always have to resort to doing something like this:
private void addFees(TradeFeeCalculator calculator) throws Exception {
NodeList feeElements = configDocument.getElementsByTagName("fee");
for (int i = 0; i < feeElements.getLength(); i++) {
Element feeElement = (Element) feeElements.item(i);
TradeFee fee = createFee(feeElement);
calculator.add(fee);
}
}
private TradeFee createFee(Element feeElement) {
try {
String type = feeElement.getAttribute("type");
LOG.info("createFee(): creating TradeFee for type=" + type);
Class<?> clazz = getClassFromType(type);
TradeFee fee = (TradeFee) JAXBConfigurator.createAndConfigure(clazz, feeElement);
return fee;
} catch (Exception e) {
throw new RuntimeException("Trade Fees are misconfigured, xml which caused this=" + XmlUtils.toString(feeElement), e);
}
}
In the above code, the JAXBConfigurator is just a simple wrapper around the JAXB objects for unmarshalling:
public static Object createAndConfigure(Class<?> clazz, Node startNode) {
try {
JAXBContext context = JAXBContext.newInstance(clazz);
Unmarshaller unmarshaller = context.createUnmarshaller();
@SuppressWarnings("rawtypes")
JAXBElement configElement = unmarshaller.unmarshal(startNode, clazz);
return configElement.getValue();
} catch (JAXBException e) {
throw new RuntimeException(e);
}
}
At the end, of the above code, we get a List which contains whichever types were configured in the Xml.
Is there a way to get JAXB to do this automatically without having to write the code to iterate the elements as above?
Note: I'm the EclipseLink JAXB (MOXy) lead and a member of the JAXB (JSR-222) expert group.
If you are using MOXy as your JAXB provider then you could use the MOXy's @XmlPaths annotation to extend the standard JAXB @XmlElements annotation to do the following:
Fees
import java.util.List;
import javax.xml.bind.annotation.*;
import org.eclipse.persistence.oxm.annotations.*;
@XmlRootElement
public class Fees {
@XmlElements({
@XmlElement(type=Commission.class),
@XmlElement(type=FINRAPerShare.class),
@XmlElement(type=SEC.class),
@XmlElement(type=Route.class)
})
@XmlPaths({
@XmlPath("fee[@type='Commission']"),
@XmlPath("fee[@type='FINRAPerShare']"),
@XmlPath("fee[@type='SEC']"),
@XmlPath("fee[@type='Route']")
})
private List<Fee> fees;
}
Commission
The implementations of the Fee interface would be annotated normally.
import javax.xml.bind.annotation.*;
@XmlAccessorType(XmlAccessType.FIELD)
public class Commission implements Fee {
@XmlAttribute
private String name;
@XmlAttribute
private String rate;
}
For More Information
- http://blog.bdoughan.com/2011/03/map-to-element-based-on-attribute-value.html
- http://blog.bdoughan.com/2010/10/jaxb-and-xsd-choice-xmlelements.html
- http://blog.bdoughan.com/2011/05/specifying-eclipselink-moxy-as-your.html
这篇关于JAXB:如何解组不同类型但具有共同父级的对象列表?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
