blocks|key|3049076|text|JAXB+(javax.xml.bind)可以做您想做的所有事情，尽管有些部分比其他部分更简单。为简单起见，我假设所有的XML文件都有一个名称空间--如果没有名称空间就比较麻烦了，但是可以使用StAX+API解决这个问题。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3049077|<list+xmlns="http://example.com/cars">

++++<brand+id="1">
++++++++Volvo
++++</brand>

++++<car>
++++++++<brand>BMW</brand>
++++++++<v12engine+horsePowers="300"+/>
++++</car>

++++<car>
++++++++<brand+refId="1"+/>
++++++++<v6engine+fuel="unleaded"+/>
++++</car>

</list>|code-block|syntax|javascript|3049078|并假设相应的package-info.java为|3049079|@XmlSchema(namespace+=+"http://example.com/cars",
+++++++++++elementFormDefault+=+XmlNsForm.QUALIFIED)
package+cars;
import+javax.xml.bind.annotation.*;|3049080|按元素名称划分的引擎类型|3049081|这很简单，使用@XmlElementRef|3049082|package+cars;
import+javax.xml.bind.annotation.*;

@XmlRootElement
@XmlAccessorType(XmlAccessType.FIELD)
public+class+Car+{
++++String+brand;
++++@XmlElementRef
++++Engine+engine;
}

@XmlRootElement
abstract+class+Engine+{
}

@XmlRootElement(name+=+"v12engine")
@XmlAccessorType(XmlAccessType.FIELD)
class+V12Engine+extends+Engine+{
++++@XmlAttribute
++++int+horsePowers;
}

@XmlRootElement(name+=+"v6engine")
@XmlAccessorType(XmlAccessType.FIELD)
class+V6Engine+extends+Engine+{
++++//+override+the+default+attribute+name,+which+would+be+fuelType
++++@XmlAttribute(name+=+"fuel")
++++String+fuelType;
}|3049083|各种类型的Engine都是带注释的@XmlRootElement，并标有适当的元素名称。在解组时，将使用XML中的元素名称来决定要使用哪个Engine子类。因此，给定XML的|3049084|<car+xmlns="http://example.com/cars">
++++<brand>BMW</brand>
++++<v12engine+horsePowers="300"+/>
</car>|3049085|和解组代码|3049086|JAXBContext+ctx+=+JAXBContext.newInstance(Car.class,+V6Engine.class,+V12Engine.class);
Unmarshaller+um+=+ctx.createUnmarshaller();
Car+c+=+(Car)um.unmarshal(new+File("file.xml"));

assert+"BMW".equals(c.brand);
assert+c.engine+instanceof+V12Engine;
assert+((V12Engine)c.engine).horsePowers+==+300;|3049087|要添加新类型的Engine，只需创建新的子类，根据需要用@XmlRootElement注释它，然后将这个新类添加到传递给JAXBContext.newInstance()的列表中。|3049088|品牌的交叉引用|3049089|JAXB有一个基于@XmlID和@XmlIDREF的交叉引用机制，但是这些机制要求ID属性是一个有效的XML，即一个XML名，尤其是不能完全由数字组成。但是，只要不需要“前向”引用(即引用尚未“声明”的<brand>的<car>+)，自己跟踪交叉引用就不是太难了。|3049090|第一步是定义一个JAXB类来表示<brand>|3049091|package+cars;

import+javax.xml.bind.annotation.*;

@XmlRootElement
public+class+Brand+{
++@XmlValue+//+i.e.+the+simple+content+of+the+<brand>+element
++String+name;

++//+optional+id+and+refId+attributes+(optional+because+they're
++//+Integer+rather+than+int)
++@XmlAttribute
++Integer+id;

++@XmlAttribute
++Integer+refId;
}|3049092|现在我们需要一个“类型适配器”来在Brand对象和Car所需的String之间进行转换，并维护id/ref映射|3049093|package+cars;

import+javax.xml.bind.annotation.adapters.*;
import+java.util.*;

public+class+BrandAdapter+extends+XmlAdapter<Brand,+String>+{
++private+Map<Integer,+Brand>+brandCache+=+new+HashMap<Integer,+Brand>();

++public+Brand+marshal(String+s)+{
++++return+null;
++}


++public+String+unmarshal(Brand+b)+{
++++if(b.id+!=+null)+{
++++++//+this+is+a+<brand+id="...">+-+cache+it
++++++brandCache.put(b.id,+b);
++++}
++++if(b.refId+!=+null)+{
++++++//+this+is+a+<brand+refId="...">+-+pull+it+from+the+cache
++++++b+=+brandCache.get(b.refId);
++++}

++++//+and+extract+the+name
++++return+(b.name+==+null)+?+null+:+b.name.trim();
++}
}|3049094|我们使用另一个注释将适配器链接到Car的brand字段：|3049095|@XmlRootElement
@XmlAccessorType(XmlAccessType.FIELD)
public+class+Car+{
++++@XmlJavaTypeAdapter(BrandAdapter.class)
++++String+brand;
++++@XmlElementRef
++++Engine+engine;
}|3049096|难题的最后一部分是确保在顶层找到的<brand>元素保存在缓存中。下面是一个完整的示例|3049097|package+cars;

import+javax.xml.bind.*;
import+java.io.File;
import+java.util.*;

import+javax.xml.stream.*;
import+javax.xml.transform.stream.StreamSource;

public+class+Main+{
++public+static+void+main(String[]+argv)+throws+Exception+{
++++List<Car>+cars+=+new+ArayList<Car>();

++++JAXBContext+ctx+=+JAXBContext.newInstance(Car.class,+V12Engine.class,+V6Engine.class,+Brand.class);
++++Unmarshaller+um+=+ctx.createUnmarshaller();

++++//+create+an+adapter,+and+register+it+with+the+unmarshaller
++++BrandAdapter+ba+=+new+BrandAdapter();
++++um.setAdapter(BrandAdapter.class,+ba);

++++//+create+a+StAX+XMLStreamReader+to+read+the+XML+file
++++XMLInputFactory+xif+=+XMLInputFactory.newFactory();
++++XMLStreamReader+xsr+=+xif.createXMLStreamReader(new+StreamSource(new+File("file.xml")));

++++xsr.nextTag();+//+root+<list>+element
++++xsr.nextTag();+//+first+<brand>+or+<car>+child

++++//+read+each+<brand>/<car>+in+turn
++++while(xsr.getEventType()+==+XMLStreamConstants.START_ELEMENT)+{
++++++Object+obj+=+um.unmarshal(xsr);

++++++//+unmarshal+from+an+XMLStreamReader+leaves+the+reader+pointing+at
++++++//+the+event+*after*+the+closing+tag+of+the+element+we+read.++If+there
++++++//+was+a+text+node+between+the+closing+tag+of+this+element+and+the+opening
++++++//+tag+of+the+next+then+we+will+need+to+skip+it.
++++++if(xsr.getEventType()+!=+XMLStreamConstants.START_ELEMENT+&&+xsr.getEventType()+!=+XMLStreamConstants.END_ELEMENT)+xsr.nextTag();

++++++if(obj+instanceof+Brand)+{
++++++++//+top-level+<brand>+-+hand+it+to+the+BrandAdapter+so+it+can+be
++++++++//+cached+if+necessary
++++++++ba.unmarshal((Brand)obj);
++++++}
++++++if(obj+instanceof+Car)+{
++++++++cars.add((Car)obj);
++++++}
++++}
++++xsr.close();

++++//+at+this+point,+cars+contains+all+the+Car+objects+we+found,+with
++++//+any+<brand>+refIds+resolved.
++}
}|3049098|entityMap^0|6|E|0|0|6|H|0|0|0|7|E|0|0|5|6|H|F|1X|6|0|0|0|0|7|6|S|F|1O|P|0|0|9|6|G|9|2T|7|31|5|0|G|7|0|0|H|5|P|3|V|6|0|0|G|3|K|5|0|0|H|7|0|0^^$0|@$1|2|3|4|5|6|7|1Q|8|@$9|1R|A|1S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|1T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1U|8|@$9|1V|A|1W|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|1X|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1Y|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1Z|8|@$9|20|A|21|B|C]]|D|@]|E|$]]|$1|S|3|T|5|H|7|22|8|@]|D|@]|E|$I|J]]|$1|U|3|V|5|6|7|23|8|@$9|24|A|25|B|C]|$9|26|A|27|B|C]|$9|28|A|29|B|C]]|D|@]|E|$]]|$1|W|3|X|5|H|7|2A|8|@]|D|@]|E|$I|J]]|$1|Y|3|Z|5|6|7|2B|8|@]|D|@]|E|$]]|$1|10|3|11|5|H|7|2C|8|@]|D|@]|E|$I|J]]|$1|12|3|13|5|6|7|2D|8|@$9|2E|A|2F|B|C]|$9|2G|A|2H|B|C]|$9|2I|A|2J|B|C]]|D|@]|E|$]]|$1|14|3|15|5|6|7|2K|8|@]|D|@]|E|$]]|$1|16|3|17|5|6|7|2L|8|@$9|2M|A|2N|B|C]|$9|2O|A|2P|B|C]|$9|2Q|A|2R|B|C]|$9|2S|A|2T|B|C]]|D|@]|E|$]]|$1|18|3|19|5|6|7|2U|8|@$9|2V|A|2W|B|C]]|D|@]|E|$]]|$1|1A|3|1B|5|H|7|2X|8|@]|D|@]|E|$I|J]]|$1|1C|3|1D|5|6|7|2Y|8|@$9|2Z|A|30|B|C]|$9|31|A|32|B|C]|$9|33|A|34|B|C]]|D|@]|E|$]]|$1|1E|3|1F|5|H|7|35|8|@]|D|@]|E|$I|J]]|$1|1G|3|1H|5|6|7|36|8|@$9|37|A|38|B|C]|$9|39|A|3A|B|C]]|D|@]|E|$]]|$1|1I|3|1J|5|H|7|3B|8|@]|D|@]|E|$I|J]]|$1|1K|3|1L|5|6|7|3C|8|@$9|3D|A|3E|B|C]]|D|@]|E|$]]|$1|1M|3|1N|5|H|7|3F|8|@]|D|@]|E|$I|J]]|$1|1O|3|-4|5|6|7|3G|8|@]|D|@]|E|$]]]|1P|$]]

JAXB (<code>javax.xml.bind</code>) can do everything you're after, though some bits are easier than others. For the sake of simplicity I'm going to assume that all your XML files have a namespace - it's trickier if they don't but can be worked around using the StAX APIs.

<pre><code>&lt;list xmlns="http://example.com/cars"&gt;

 &lt;brand id="1"&gt;
 Volvo
 &lt;/brand&gt;

 &lt;car&gt;
 &lt;brand&gt;BMW&lt;/brand&gt;
 &lt;v12engine horsePowers="300" /&gt;
 &lt;/car&gt;

 &lt;car&gt;
 &lt;brand refId="1" /&gt;
 &lt;v6engine fuel="unleaded" /&gt;
 &lt;/car&gt;

&lt;/list&gt;
</code></pre>

and assume a corresponding <code>package-info.java</code> of

<pre><code>@XmlSchema(namespace = "http://example.com/cars",
 elementFormDefault = XmlNsForm.QUALIFIED)
package cars;
import javax.xml.bind.annotation.*;
</code></pre>

<h2>Engine type by element name</h2>

This is simple, using <code>@XmlElementRef</code>:

<pre><code>package cars;
import javax.xml.bind.annotation.*;

@XmlRootElement
@XmlAccessorType(XmlAccessType.FIELD)
public class Car {
 String brand;
 @XmlElementRef
 Engine engine;
}

@XmlRootElement
abstract class Engine {
}

@XmlRootElement(name = "v12engine")
@XmlAccessorType(XmlAccessType.FIELD)
class V12Engine extends Engine {
 @XmlAttribute
 int horsePowers;
}

@XmlRootElement(name = "v6engine")
@XmlAccessorType(XmlAccessType.FIELD)
class V6Engine extends Engine {
 // override the default attribute name, which would be fuelType
 @XmlAttribute(name = "fuel")
 String fuelType;
}
</code></pre>

The various types of <code>Engine</code> are all annotated <code>@XmlRootElement</code> and marked with appropriate element names. At unmarshalling time the element name found in the XML is used to decide which of the <code>Engine</code> subclasses to use. So given XML of

<pre><code>&lt;car xmlns="http://example.com/cars"&gt;
 &lt;brand&gt;BMW&lt;/brand&gt;
 &lt;v12engine horsePowers="300" /&gt;
&lt;/car&gt;
</code></pre>

and unmarshalling code

<pre><code>JAXBContext ctx = JAXBContext.newInstance(Car.class, V6Engine.class, V12Engine.class);
Unmarshaller um = ctx.createUnmarshaller();
Car c = (Car)um.unmarshal(new File("file.xml"));

assert "BMW".equals(c.brand);
assert c.engine instanceof V12Engine;
assert ((V12Engine)c.engine).horsePowers == 300;
</code></pre>

To add a new type of <code>Engine</code> simply create the new subclass, annotate it with <code>@XmlRootElement</code> as appropriate, and add this new class to the list passed to <code>JAXBContext.newInstance()</code>.

<h2>Cross-references for brands</h2>

JAXB has a cross-referencing mechanism based on <code>@XmlID</code> and <code>@XmlIDREF</code> but these require that the ID attribute be a valid XML ID, i.e. an XML name, and in particular not entirely consisting of digits. But it's not too difficult to keep track of the cross references yourself, as long as you don't require "forward" references (i.e. a <code>&lt;car&gt;</code> that refers to a <code>&lt;brand&gt;</code> that has not yet been "declared").

The first step is to define a JAXB class to represent the <code>&lt;brand&gt;</code>

<pre><code>package cars;

import javax.xml.bind.annotation.*;

@XmlRootElement
public class Brand {
 @XmlValue // i.e. the simple content of the &lt;brand&gt; element
 String name;

 // optional id and refId attributes (optional because they're
 // Integer rather than int)
 @XmlAttribute
 Integer id;

 @XmlAttribute
 Integer refId;
}
</code></pre>

Now we need a "type adapter" to convert between the <code>Brand</code> object and the <code>String</code> required by <code>Car</code>, and to maintain the id/ref mapping

<pre><code>package cars;

import javax.xml.bind.annotation.adapters.*;
import java.util.*;

public class BrandAdapter extends XmlAdapter&lt;Brand, String&gt; {
 private Map&lt;Integer, Brand&gt; brandCache = new HashMap&lt;Integer, Brand&gt;();

 public Brand marshal(String s) {
 return null;
 }


 public String unmarshal(Brand b) {
 if(b.id != null) {
 // this is a &lt;brand id="..."&gt; - cache it
 brandCache.put(b.id, b);
 }
 if(b.refId != null) {
 // this is a &lt;brand refId="..."&gt; - pull it from the cache
 b = brandCache.get(b.refId);
 }

 // and extract the name
 return (b.name == null) ? null : b.name.trim();
 }
}
</code></pre>

We link the adapter to the <code>brand</code> field of <code>Car</code> using another annotation:

<pre><code>@XmlRootElement
@XmlAccessorType(XmlAccessType.FIELD)
public class Car {
 @XmlJavaTypeAdapter(BrandAdapter.class)
 String brand;
 @XmlElementRef
 Engine engine;
}
</code></pre>

The final part of the puzzle is to ensure that <code>&lt;brand&gt;</code> elements found at the top level get saved in the cache. Here is a complete example

<pre><code>package cars;

import javax.xml.bind.*;
import java.io.File;
import java.util.*;

import javax.xml.stream.*;
import javax.xml.transform.stream.StreamSource;

public class Main {
 public static void main(String[] argv) throws Exception {
 List&lt;Car&gt; cars = new ArayList&lt;Car&gt;();

 JAXBContext ctx = JAXBContext.newInstance(Car.class, V12Engine.class, V6Engine.class, Brand.class);
 Unmarshaller um = ctx.createUnmarshaller();

 // create an adapter, and register it with the unmarshaller
 BrandAdapter ba = new BrandAdapter();
 um.setAdapter(BrandAdapter.class, ba);

 // create a StAX XMLStreamReader to read the XML file
 XMLInputFactory xif = XMLInputFactory.newFactory();
 XMLStreamReader xsr = xif.createXMLStreamReader(new StreamSource(new File("file.xml")));

 xsr.nextTag(); // root &lt;list&gt; element
 xsr.nextTag(); // first &lt;brand&gt; or &lt;car&gt; child

 // read each &lt;brand&gt;/&lt;car&gt; in turn
 while(xsr.getEventType() == XMLStreamConstants.START_ELEMENT) {
 Object obj = um.unmarshal(xsr);

 // unmarshal from an XMLStreamReader leaves the reader pointing at
 // the event *after* the closing tag of the element we read. If there
 // was a text node between the closing tag of this element and the opening
 // tag of the next then we will need to skip it.
 if(xsr.getEventType() != XMLStreamConstants.START_ELEMENT &amp;&amp; xsr.getEventType() != XMLStreamConstants.END_ELEMENT) xsr.nextTag();

 if(obj instanceof Brand) {
 // top-level &lt;brand&gt; - hand it to the BrandAdapter so it can be
 // cached if necessary
 ba.unmarshal((Brand)obj);
 }
 if(obj instanceof Car) {
 cars.add((Car)obj);
 }
 }
 xsr.close();

 // at this point, cars contains all the Car objects we found, with
 // any &lt;brand&gt; refIds resolved.
 }
}
</code></pre>

blocks|key|203126|text|这里有一个使用XStream的解决方案，因为您似乎已经熟悉它，而且它是一个非常灵活的工具。这是用Groovy完成的，因为它比Java好得多。移植到Java将是相当简单的。请注意，我选择了对结果进行一些后处理，而不是试图让XStream为我做所有的工作。具体地说，“品牌引用”是在事后处理的。我可以在编组中这样做，但我认为这种方法更简洁，并为将来的修改留下了更多的选择余地。此外，这种方法允许在整个文档中的任何地方出现“品牌”元素，包括在引用它们的汽车之后--我认为如果您在动态地进行替换，则无法实现这一点。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|203127|使用注释的解决方案|offset|length|style|BOLD|203128|import+com.thoughtworks.xstream.XStream
import+com.thoughtworks.xstream.annotations.*
import+com.thoughtworks.xstream.converters.*
import+com.thoughtworks.xstream.converters.extended.ToAttributedValueConverter
import+com.thoughtworks.xstream.io.*
import+com.thoughtworks.xstream.mapper.Mapper

//+The+classes+as+given,+plus+toString()'s+for+readable+output+and+XStream
//+annotations+to+support+unmarshalling.+Note+that+with+XStream's+flexibility,
//+all+of+this+is+possible+with+no+annotations,+so+no+code+modifications+are
//+actually+required.

@XStreamAlias("car")
//+A+custom+converter+for+handling+the+oddities+of+parsing+a+Car,+defined
//+below.
@XStreamConverter(CarConverter)
class+Car+{
++++String+brand
++++Engine+engine
++++String+toString()+{+"Car{brand='$brand',+engine=$engine}"+}
}

abstract+class+Engine+{
}

@XStreamAlias("v12engine")
class+V12Engine+extends+Engine+{
++++@XStreamAsAttribute+int+horsePowers
++++String+toString()+{+"V12Engine{horsePowers=$horsePowers}"+}
}

@XStreamAlias("v6engine")
class+V6Engine+extends+Engine+{
++++@XStreamAsAttribute+@XStreamAlias("fuel")+String+fuelType
++++String+toString()+{+"V6Engine{fuelType='$fuelType'}"+}
}

//+The+given+input:
String+xml+=+"""\
++++<list>
++++++++<brand+id="1">
++++++++++++Volvo
++++++++</brand>
++++++++<car>
++++++++++++<brand>BMW</brand>
++++++++++++<v12engine+horsePowers="300"+/>
++++++++</car>
++++++++<car>
++++++++++++<brand+refId="1"+/>
++++++++++++<v6engine+fuel="unleaded"+/>
++++++++</car>
++++</list>"""

//+The+solution:

//+A+temporary+Brand+class+to+hold+the+relevant+information+needed+for+parsing
@XStreamAlias("brand")
//+An+out-of-the-box+converter+that+uses+a+single+field+as+the+value+of+an
//+element+and+makes+everything+else+attributes:+a+perfect+match+for+the+given
//+"brand"+XML.
@XStreamConverter(value=ToAttributedValueConverter,+strings="name")
class+Brand+{
++++Integer+id
++++Integer+refId
++++String+name
++++String+toString()+{+"Brand{id=$id,+refId=$refId,+name='$name'}"+}
}

//+Reads+Car+instances,+figuring+out+the+engine+type+and+storing+appropriate
//+brand+info+along+the+way.
class+CarConverter+implements+Converter+{
++++Mapper+mapper

++++//+A+Mapper+can+be+injected+auto-magically+by+XStream+when+converters+are
++++//+configured+via+annotation.
++++CarConverter(Mapper+mapper)+{
++++++++this.mapper+=+mapper
++++}

++++Object+unmarshal(HierarchicalStreamReader+reader,
+++++++++++++++++++++UnmarshallingContext+context)+{
++++++++Car+car+=+new+Car()
++++++++reader.moveDown()
++++++++Brand+brand+=+context.convertAnother(car,+Brand)
++++++++reader.moveUp()
++++++++reader.moveDown()
++++++++//+The+mapper+knows+about+registered+aliases+and+can+tell+us+which
++++++++//+engine+type+it+is.
++++++++Class+engineClass+=+mapper.realClass(reader.getNodeName())
++++++++def+engine+=+context.convertAnother(car,+engineClass)
++++++++reader.moveUp()
++++++++//+Set+the+brand+name+if+available+or+a+placeholder+for+later+
++++++++//+reference+if+not.
++++++++if+(brand.name)+{
++++++++++++car.brand+=+brand.name
++++++++}+else+{
++++++++++++car.brand+=+"#{$brand.refId}"
++++++++}
++++++++car.engine+=+engine
++++++++return+car
++++}

++++boolean+canConvert(Class+type)+{+type+==+Car+}

++++void+marshal(Object+source,+HierarchicalStreamWriter+writer,
+++++++++++++++++MarshallingContext+context)+{
++++++++throw+new+UnsupportedOperationException("Don't+need+this+right+now")
++++}
}

//+Now+exercise+it:

def+x+=+new+XStream()
//+As+written,+this+line+would+have+to+be+modified+to+add+new+engine+types,
//+but+if+this+isn't+desirable,+classpath+scanning+or+some+other+kind+of
//+auto-registration+could+be+set+up,+but+not+through+XStream+that+I+know+of.
x.processAnnotations([Car,+Brand,+V12Engine,+V6Engine]+as+Class[])
//+Parsing+will+create+a+List+containing+Brands+and+Cars
def+brandsAndCars+=+x.fromXML(xml)
List<Brand>+brands+=+brandsAndCars.findAll+{+it+instanceof+Brand+}
//+XStream+doesn't+trim+whitespace+as+occurs+in+the+sample+XML.+Maybe+it+can
//+be+made+to?
brands.each+{+it.name+=+it.name.trim()+}
Map<Integer,+Brand>+brandsById+=+brands.collectEntries{+[it.id,+it]+}
List<Car>+cars+=+brandsAndCars.findAll{+it+instanceof+Car+}
//+Regex+match+brand+references+and+replace+them+with+brand+names.
cars.each+{
++++def+brandReference+=+it.brand+=~+/#\{(.*)\}/
++++if+(brandReference)+{
++++++++int+brandId+=+brandReference[0][1].toInteger()
++++++++it.brand+=+brandsById.get(brandId).name
++++}
}
println+"Brands:"
brands.each{+println+"++$it"+}
println+"Cars:"
cars.each{+println+"++$it"+}|code-block|syntax|javascript|203129|输出|203130|Brands:
++Brand{id=1,+refId=null,+name='Volvo'}
Cars:
++Car{brand='BMW',+engine=V12Engine{horsePowers=300}}
++Car{brand='Volvo',+engine=V6Engine{fuelType='unleaded'}}|203131|不带注释的解决方案|203132|附言:仅供大家笑一笑，这里是没有注释的同样的东西。这一切都是一样的，除了不是注释类，而是在new+XStream()下面有几行额外的代码行，它们执行之前注释所做的所有工作。输出是相同的。|CODE|203133|import+com.thoughtworks.xstream.XStream
import+com.thoughtworks.xstream.converters.*
import+com.thoughtworks.xstream.converters.extended.ToAttributedValueConverter
import+com.thoughtworks.xstream.io.*
import+com.thoughtworks.xstream.mapper.Mapper

class+Car+{
++++String+brand
++++Engine+engine
++++String+toString()+{+"Car{brand='$brand',+engine=$engine}"+}
}

abstract+class+Engine+{
}

class+V12Engine+extends+Engine+{
++++int+horsePowers
++++String+toString()+{+"V12Engine{horsePowers=$horsePowers}"+}
}

class+V6Engine+extends+Engine+{
++++String+fuelType
++++String+toString()+{+"V6Engine{fuelType='$fuelType'}"+}
}

String+xml+=+"""\
++++<list>
++++++++<brand+id="1">
++++++++++++Volvo
++++++++</brand>
++++++++<car>
++++++++++++<brand>BMW</brand>
++++++++++++<v12engine+horsePowers="300"+/>
++++++++</car>
++++++++<car>
++++++++++++<brand+refId="1"+/>
++++++++++++<v6engine+fuel="unleaded"+/>
++++++++</car>
++++</list>"""

class+Brand+{
++++Integer+id
++++Integer+refId
++++String+name
++++String+toString()+{+"Brand{id=$id,+refId=$refId,+name='$name'}"+}
}

class+CarConverter+implements+Converter+{
++++Mapper+mapper

++++CarConverter(Mapper+mapper)+{
++++++++this.mapper+=+mapper
++++}

++++Object+unmarshal(HierarchicalStreamReader+reader,
+++++++++++++++++++++UnmarshallingContext+context)+{
++++++++Car+car+=+new+Car()
++++++++reader.moveDown()
++++++++Brand+brand+=+context.convertAnother(car,+Brand)
++++++++reader.moveUp()
++++++++reader.moveDown()
++++++++Class+engineClass+=+mapper.realClass(reader.getNodeName())
++++++++def+engine+=+context.convertAnother(car,+engineClass)
++++++++reader.moveUp()
++++++++if+(brand.name)+{
++++++++++++car.brand+=+brand.name
++++++++}+else+{
++++++++++++car.brand+=+"#{$brand.refId}"
++++++++}
++++++++car.engine+=+engine
++++++++return+car
++++}

++++boolean+canConvert(Class+type)+{+type+==+Car+}

++++void+marshal(Object+source,+HierarchicalStreamWriter+writer,
+++++++++++++++++MarshallingContext+context)+{
++++++++throw+new+UnsupportedOperationException("Don't+need+this+right+now")
++++}
}

def+x+=+new+XStream()
x.alias('car',+Car)
x.alias('brand',+Brand)
x.alias('v6engine',+V6Engine)
x.alias('v12engine',+V12Engine)
x.registerConverter(new+CarConverter(x.mapper))
x.registerConverter(new+ToAttributedValueConverter(Brand,+x.mapper,+x.reflectionProvider,+x.converterLookup,+'name'))
x.useAttributeFor(V12Engine,+'horsePowers')
x.aliasAttribute(V6Engine,+'fuelType',+'fuel')
x.useAttributeFor(V6Engine,+'fuelType')
def+brandsAndCars+=+x.fromXML(xml)
List<Brand>+brands+=+brandsAndCars.findAll+{+it+instanceof+Brand+}
brands.each+{+it.name+=+it.name.trim()+}
Map<Integer,+Brand>+brandsById+=+brands.collectEntries{+[it.id,+it]+}
List<Car>+cars+=+brandsAndCars.findAll{+it+instanceof+Car+}
cars.each+{
++++def+brandReference+=+it.brand+=~+/#\{(.*)\}/
++++if+(brandReference)+{
++++++++int+brandId+=+brandReference[0][1].toInteger()
++++++++it.brand+=+brandsById.get(brandId).name
++++}
}
println+"Brands:"
brands.each{+println+"++$it"+}
println+"Cars:"
cars.each{+println+"++$it"+}|203134|附言:如果你安装了Gradle，你可以把它放到一个build.gradle中，把上面的一个脚本放到src/main/groovy/XStreamExample.groovy中，然后用gradle+run命令来查看结果：|203135|apply+plugin:+'groovy'
apply+plugin:+'application'

mainClassName+=+'XStreamExample'

dependencies+{
++++groovy+'org.codehaus.groovy:groovy:2.0.5'
++++compile+'com.thoughtworks.xstream:xstream:1.4.3'
}

repositories+{
++++mavenCentral()
}|203136|entityMap^0|0|5|4|0|0|0|2|0|0|0|9|0|0|2L|19|D|0|0|0|31|P|C|1D|11|2J|A|0|0^^$0|@$1|2|3|4|5|6|7|13|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|14|8|@$D|15|E|16|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|17|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|18|8|@$D|19|E|1A|F|G]]|9|@]|A|$]]|$1|O|3|P|5|J|7|1B|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|1C|8|@$D|1D|E|1E|F|G]]|9|@]|A|$]]|$1|S|3|T|5|6|7|1F|8|@$D|1G|E|1H|F|G]|$D|1I|E|1J|F|U]]|9|@]|A|$]]|$1|V|3|W|5|J|7|1K|8|@]|9|@]|A|$K|L]]|$1|X|3|Y|5|6|7|1L|8|@$D|1M|E|1N|F|G]|$D|1O|E|1P|F|U]|$D|1Q|E|1R|F|U]|$D|1S|E|1T|F|U]]|9|@]|A|$]]|$1|Z|3|10|5|J|7|1U|8|@]|9|@]|A|$K|L]]|$1|11|3|-4|5|6|7|1V|8|@]|9|@]|A|$]]]|12|$]]

Here's a solution with XStream, since you seem to already be familiar with it and since it's an incredibly flexible XML tool. It's done in Groovy because it's just so much nicer than Java. Porting to Java would be fairly trivial. Note that I opted to do a little post-processing of the result instead of trying to make XStream do all the work for me. Specifically, the "brand references" are handled after the fact. I could do it inside the marshalling, but I think this approach is cleaner and leaves your options more open for future modification. In addition, this approach allows "brand" elements to occur anywhere throughout the document, including after cars that refer to them--something I don't think you could accomplish if you were doing replacements on the fly.

Solution with annotations

<pre><code>import com.thoughtworks.xstream.XStream
import com.thoughtworks.xstream.annotations.*
import com.thoughtworks.xstream.converters.*
import com.thoughtworks.xstream.converters.extended.ToAttributedValueConverter
import com.thoughtworks.xstream.io.*
import com.thoughtworks.xstream.mapper.Mapper

// The classes as given, plus toString()'s for readable output and XStream
// annotations to support unmarshalling. Note that with XStream's flexibility,
// all of this is possible with no annotations, so no code modifications are
// actually required.

@XStreamAlias("car")
// A custom converter for handling the oddities of parsing a Car, defined
// below.
@XStreamConverter(CarConverter)
class Car {
 String brand
 Engine engine
 String toString() { "Car{brand='$brand', engine=$engine}" }
}

abstract class Engine {
}

@XStreamAlias("v12engine")
class V12Engine extends Engine {
 @XStreamAsAttribute int horsePowers
 String toString() { "V12Engine{horsePowers=$horsePowers}" }
}

@XStreamAlias("v6engine")
class V6Engine extends Engine {
 @XStreamAsAttribute @XStreamAlias("fuel") String fuelType
 String toString() { "V6Engine{fuelType='$fuelType'}" }
}

// The given input:
String xml = """\
 &lt;list&gt;
 &lt;brand id="1"&gt;
 Volvo
 &lt;/brand&gt;
 &lt;car&gt;
 &lt;brand&gt;BMW&lt;/brand&gt;
 &lt;v12engine horsePowers="300" /&gt;
 &lt;/car&gt;
 &lt;car&gt;
 &lt;brand refId="1" /&gt;
 &lt;v6engine fuel="unleaded" /&gt;
 &lt;/car&gt;
 &lt;/list&gt;"""

// The solution:

// A temporary Brand class to hold the relevant information needed for parsing
@XStreamAlias("brand")
// An out-of-the-box converter that uses a single field as the value of an
// element and makes everything else attributes: a perfect match for the given
// "brand" XML.
@XStreamConverter(value=ToAttributedValueConverter, strings="name")
class Brand {
 Integer id
 Integer refId
 String name
 String toString() { "Brand{id=$id, refId=$refId, name='$name'}" }
}

// Reads Car instances, figuring out the engine type and storing appropriate
// brand info along the way.
class CarConverter implements Converter {
 Mapper mapper

 // A Mapper can be injected auto-magically by XStream when converters are
 // configured via annotation.
 CarConverter(Mapper mapper) {
 this.mapper = mapper
 }

 Object unmarshal(HierarchicalStreamReader reader,
 UnmarshallingContext context) {
 Car car = new Car()
 reader.moveDown()
 Brand brand = context.convertAnother(car, Brand)
 reader.moveUp()
 reader.moveDown()
 // The mapper knows about registered aliases and can tell us which
 // engine type it is.
 Class engineClass = mapper.realClass(reader.getNodeName())
 def engine = context.convertAnother(car, engineClass)
 reader.moveUp()
 // Set the brand name if available or a placeholder for later 
 // reference if not.
 if (brand.name) {
 car.brand = brand.name
 } else {
 car.brand = "#{$brand.refId}"
 }
 car.engine = engine
 return car
 }

 boolean canConvert(Class type) { type == Car }

 void marshal(Object source, HierarchicalStreamWriter writer,
 MarshallingContext context) {
 throw new UnsupportedOperationException("Don't need this right now")
 }
}

// Now exercise it:

def x = new XStream()
// As written, this line would have to be modified to add new engine types,
// but if this isn't desirable, classpath scanning or some other kind of
// auto-registration could be set up, but not through XStream that I know of.
x.processAnnotations([Car, Brand, V12Engine, V6Engine] as Class[])
// Parsing will create a List containing Brands and Cars
def brandsAndCars = x.fromXML(xml)
List&lt;Brand&gt; brands = brandsAndCars.findAll { it instanceof Brand }
// XStream doesn't trim whitespace as occurs in the sample XML. Maybe it can
// be made to?
brands.each { it.name = it.name.trim() }
Map&lt;Integer, Brand&gt; brandsById = brands.collectEntries{ [it.id, it] }
List&lt;Car&gt; cars = brandsAndCars.findAll{ it instanceof Car }
// Regex match brand references and replace them with brand names.
cars.each {
 def brandReference = it.brand =~ /#\{(.*)\}/
 if (brandReference) {
 int brandId = brandReference[0][1].toInteger()
 it.brand = brandsById.get(brandId).name
 }
}
println "Brands:"
brands.each{ println " $it" }
println "Cars:"
cars.each{ println " $it" }
</code></pre>

Output

<pre><code>Brands:
 Brand{id=1, refId=null, name='Volvo'}
Cars:
 Car{brand='BMW', engine=V12Engine{horsePowers=300}}
 Car{brand='Volvo', engine=V6Engine{fuelType='unleaded'}}
</code></pre>

Solution without annotations

P.S. Just for grins, here's the same thing with no annotations. It's all the same except that instead of annotating the classes, there are several additional lines under the <code>new XStream()</code> that do everything the annotations were doing before. The output is identical.

<pre><code>import com.thoughtworks.xstream.XStream
import com.thoughtworks.xstream.converters.*
import com.thoughtworks.xstream.converters.extended.ToAttributedValueConverter
import com.thoughtworks.xstream.io.*
import com.thoughtworks.xstream.mapper.Mapper

class Car {
 String brand
 Engine engine
 String toString() { "Car{brand='$brand', engine=$engine}" }
}

abstract class Engine {
}

class V12Engine extends Engine {
 int horsePowers
 String toString() { "V12Engine{horsePowers=$horsePowers}" }
}

class V6Engine extends Engine {
 String fuelType
 String toString() { "V6Engine{fuelType='$fuelType'}" }
}

String xml = """\
 &lt;list&gt;
 &lt;brand id="1"&gt;
 Volvo
 &lt;/brand&gt;
 &lt;car&gt;
 &lt;brand&gt;BMW&lt;/brand&gt;
 &lt;v12engine horsePowers="300" /&gt;
 &lt;/car&gt;
 &lt;car&gt;
 &lt;brand refId="1" /&gt;
 &lt;v6engine fuel="unleaded" /&gt;
 &lt;/car&gt;
 &lt;/list&gt;"""

class Brand {
 Integer id
 Integer refId
 String name
 String toString() { "Brand{id=$id, refId=$refId, name='$name'}" }
}

class CarConverter implements Converter {
 Mapper mapper

 CarConverter(Mapper mapper) {
 this.mapper = mapper
 }

 Object unmarshal(HierarchicalStreamReader reader,
 UnmarshallingContext context) {
 Car car = new Car()
 reader.moveDown()
 Brand brand = context.convertAnother(car, Brand)
 reader.moveUp()
 reader.moveDown()
 Class engineClass = mapper.realClass(reader.getNodeName())
 def engine = context.convertAnother(car, engineClass)
 reader.moveUp()
 if (brand.name) {
 car.brand = brand.name
 } else {
 car.brand = "#{$brand.refId}"
 }
 car.engine = engine
 return car
 }

 boolean canConvert(Class type) { type == Car }

 void marshal(Object source, HierarchicalStreamWriter writer,
 MarshallingContext context) {
 throw new UnsupportedOperationException("Don't need this right now")
 }
}

def x = new XStream()
x.alias('car', Car)
x.alias('brand', Brand)
x.alias('v6engine', V6Engine)
x.alias('v12engine', V12Engine)
x.registerConverter(new CarConverter(x.mapper))
x.registerConverter(new ToAttributedValueConverter(Brand, x.mapper, x.reflectionProvider, x.converterLookup, 'name'))
x.useAttributeFor(V12Engine, 'horsePowers')
x.aliasAttribute(V6Engine, 'fuelType', 'fuel')
x.useAttributeFor(V6Engine, 'fuelType')
def brandsAndCars = x.fromXML(xml)
List&lt;Brand&gt; brands = brandsAndCars.findAll { it instanceof Brand }
brands.each { it.name = it.name.trim() }
Map&lt;Integer, Brand&gt; brandsById = brands.collectEntries{ [it.id, it] }
List&lt;Car&gt; cars = brandsAndCars.findAll{ it instanceof Car }
cars.each {
 def brandReference = it.brand =~ /#\{(.*)\}/
 if (brandReference) {
 int brandId = brandReference[0][1].toInteger()
 it.brand = brandsById.get(brandId).name
 }
}
println "Brands:"
brands.each{ println " $it" }
println "Cars:"
cars.each{ println " $it" }
</code></pre>

P.P.S. If you have Gradle installed, you can drop this into a <code>build.gradle</code> and one of the above scripts into <code>src/main/groovy/XStreamExample.groovy</code>, and then just <code>gradle run</code> it to see the result:

<pre><code>apply plugin: 'groovy'
apply plugin: 'application'

mainClassName = 'XStreamExample'

dependencies {
 groovy 'org.codehaus.groovy:groovy:2.0.5'
 compile 'com.thoughtworks.xstream:xstream:1.4.3'
}

repositories {
 mavenCentral()
}
</code></pre>

blocks|key|2836380|text|您可以尝试参考here来获得一些想法。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2836381|就我个人而言，我会使用DOM+Parser来获取XML文件的内容。|2836382|示例：|2836383|import+java.io.*;
import+javax.xml.parsers.*;

import+org.w3c.dom.*;

public+class+DOMExample+{

++public+static+void+main(String[]+args)+throws+Exception+{

++++DocumentBuilder+builder+=+DocumentBuilderFactory.newInstance().newDocumentBuilder();

++++File+file+=+new+File("filename.xml");
++++Document+doc+=+builder.parse(file);

++++NodeList+carList+=+doc.getElementsByTagName("car");
++++for+(int+i+=+0;+i+<+carList.getLength();+%2B%2Bi)+{

++++++++Element+carElem+=+(Element)carList.item(i);

++++++++Element+brandElem+=+(Element)carElem.getElementsByTagName("brand").item(0);
++++++++Element+engineElem+=+(Element)carElem.getElementsByTagName("v12engine").item(0);

++++++++String+brand=+brandElem.getTextContent();
++++++++String+engine=+engineElem.getTextContent();

++++++++System.out.println(brand%2B+",+"+%2B+engine);

++++++++//+TODO+Do+something+with+the+desired+information.
++++}+++++++
++}
}|code-block|syntax|javascript|2836384|如果您知道标记名的可能内容，这将非常有效。有许多方法可以解析XML文件。希望你能想出一些对你有用的东西。祝好运!|2836385|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/7507073/java-dom-parser-xml|1|http://www.java-samples.com/showtutorial.php?tutorialid=152^0|7|4|0|0|B|A|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|6|7|12|8|@]|9|@$A|13|B|14|1|15]]|C|$]]|$1|F|3|G|5|6|7|16|8|@]|9|@]|C|$]]|$1|H|3|I|5|J|7|17|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|18|8|@]|9|@]|C|$]]|$1|O|3|-4|5|6|7|19|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]|W|$5|R|S|T|C|$U|X]]]]

You can try referencing <a href="https://stackoverflow.com/questions/7507073/java-dom-parser-xml">here</a> to get some ideas.

Personally, I would use a <a href="http://www.java-samples.com/showtutorial.php?tutorialid=152" rel="nofollow noreferrer">DOM Parser</a> to get the contents of the XML file. 

Example:

<pre><code>import java.io.*;
import javax.xml.parsers.*;

import org.w3c.dom.*;

public class DOMExample {

 public static void main(String[] args) throws Exception {

 DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();

 File file = new File("filename.xml");
 Document doc = builder.parse(file);

 NodeList carList = doc.getElementsByTagName("car");
 for (int i = 0; i &lt; carList.getLength(); ++i) {

 Element carElem = (Element)carList.item(i);

 Element brandElem = (Element)carElem.getElementsByTagName("brand").item(0);
 Element engineElem = (Element)carElem.getElementsByTagName("v12engine").item(0);

 String brand= brandElem.getTextContent();
 String engine= engineElem.getTextContent();

 System.out.println(brand+ ", " + engine);

 // TODO Do something with the desired information.
 } 
 }
}
</code></pre>

If you know the possible contents of the tag names, this would work pretty well. There are many ways to parse through an XML file. Hopefully you can come up with something that works for you. Good luck!

I have to deal with (a variation of) the following scenario. My model classes are:

<pre><code>class Car {
 String brand;
 Engine engine;
}

abstract class Engine {
}

class V12Engine extends Engine {
 int horsePowers;
}

class V6Engine extends Engine {
 String fuelType;
}
</code></pre>

And I have to deserialize (no need for serialization support ATM) the following input:

<pre><code>&lt;list&gt;

 &lt;brand id="1"&gt;
 Volvo
 &lt;/brand&gt;

 &lt;car&gt;
 &lt;brand&gt;BMW&lt;/brand&gt;
 &lt;v12engine horsePowers="300" /&gt;
 &lt;/car&gt;

 &lt;car&gt;
 &lt;brand refId="1" /&gt;
 &lt;v6engine fuel="unleaded" /&gt;
 &lt;/car&gt;

&lt;/list&gt;
</code></pre>

What I've tried / issues:

I've tried using XStream, but it expects me to write tags such as:

<pre><code>&lt;engine class="cars.V12Engine"&gt;
 &lt;horsePowers&gt;300&lt;/horsePowers&gt;
&lt;/engine&gt;
</code></pre>

etc. (I don't want an <code>&lt;engine&gt;</code>-tag, I want a <code>&lt;v6engine&gt;</code>-tag or a <code>&lt;v12engine&gt;</code>-tag.

Also, I need to be able to refer back to "predefined" brands based on identifiers, as shown with the brand-id above. (For instance by maintaining a <code>Map&lt;Integer, String&gt; predefinedBrands</code> during the deserialization). I don't know if XStream is well suited for such scenario.

I realize that this could be done "manually" with a push or pull parser (such as SAX or StAX) or a DOM-library. I would however prefer to have some more automation. Ideally, I should be able to add classes (such as new <code>Engine</code>s) and start using them in the XML right away. (XStream is by no means a requirement, the most elegant solutions wins the bounty.)

Parsing XML with references to previous tags, and with children corresponding to subtypes of some class

Java

我必须处理以下场景(其变体)。我的模型类是：class Car {    String brand;    Engine engine;}abstract class Engine {}class V12Engine extends Engine {    int horsePowers;}class V6Engine...

问解析XML，引用前面的标记，并使用与某个类的子类型相对应的子类
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问解析XML，引用前面的标记，并使用与某个类的子类型相对应的子类EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问解析XML，引用前面的标记，并使用与某个类的子类型相对应的子类
EN