@Retention(value=RUNTIME) @Target(value={FIELD,METHOD}) public @interface XmlAnyElement
This annotation serves as a "catch-all" property while unmarshalling xml content into a instance of a JAXB annotated class. It typically annotates a multi-valued JavaBean property, but it can occur on single value JavaBean property. During unmarshalling, each xml element that does not match a static @XmlElement or @XmlElementRef annotation for the other JavaBean properties on the class, is added to this "catch-all" property.
@XmlAnyElement publicElement
[] others; // Collection ofElement
or JAXB elements. @XmlAnyElement(lax="true") publicObject
[] others; @XmlAnyElement private List<Element
> nodes; @XmlAnyElement privateElement
node;
This annotation is mutually exclusive with
XmlElement
, XmlAttribute
, XmlValue
,
XmlElements
, XmlID
, and XmlIDREF
.
There can be only one XmlAnyElement
annotated JavaBean property
in a class and its super classes.
This annotation can be used with XmlJavaTypeAdapter
, so that users
can map their own data structure to DOM, which in turn can be composed
into XML.
This annotation can be used with XmlMixed
like this:
// List of java.lang.String or DOM nodes. @XmlAnyElement @XmlMixed List<Object> others;
<xs:complexType name="foo">
<xs:sequence>
<xs:element name="a" type="xs:int" />
<xs:element name="b" type="xs:int" />
<xs:any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded" />
</xs:sequence>
</xs:complexType>
class Foo {
int a;
int b;
@XmlAnyElement
List<Element> any;
}
It can unmarshal instances like
<foo xmlns:e="extra">
<a>1</a>
<e:other /> // this will be bound to DOM, because unmarshalling is orderless
<b>3</b>
<e:other />
<c>5</c> // this will be bound to DOM, because the annotation doesn't remember namespaces.
</foo>
The following schema would produce the following Java class:
<xs:complexType name="bar">
<xs:complexContent>
<xs:extension base="foo">
<xs:sequence>
<xs:element name="c" type="xs:int" />
<xs:any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded" />
</xs:sequence>
</xs:extension>
</xs:complexType>
class Bar extends Foo { int c; // Foo.getAny() also represents wildcard content for type definition bar. }It can unmarshal instances like
<bar xmlns:e="extra">
<a>1</a>
<e:other /> // this will be bound to DOM, because unmarshalling is orderless
<b>3</b>
<e:other />
<c>5</c> // this now goes to Bar.c
<e:other /> // this will go to Foo.any
</bar>
XmlAnyElement
with XmlElementRef
The XmlAnyElement
annotation can be used with XmlElementRef
s to
designate additional elements that can participate in the content tree.
The following schema would produce the following Java class:
<xs:complexType name="foo">
<xs:choice maxOccurs="unbounded" minOccurs="0">
<xs:element name="a" type="xs:int" />
<xs:element name="b" type="xs:int" />
<xs:any namespace="##other" processContents="lax" />
</xs:choice>
</xs:complexType>
class Foo { @It can unmarshal instances likeXmlAnyElement
(lax="true") @XmlElementRefs
({ @XmlElementRef
(name="a", type="JAXBElement.class") @XmlElementRef
(name="b", type="JAXBElement.class") })List
<Object
> others; } @XmlRegistry class ObjectFactory { ... @XmlElementDecl(name = "a", namespace = "", scope = Foo.class)JAXBElement
<Integer> createFooA( Integer i ) { ... } @XmlElementDecl(name = "b", namespace = "", scope = Foo.class)JAXBElement
<Integer> createFooB( Integer i ) { ... }
<foo xmlns:e="extra">
<a>1</a>
// this will unmarshal to aJAXBElement
instance whose value is 1.<e:other />
// this will unmarshal to a DOMElement
.<b>3</b>
// this will unmarshal to aJAXBElement
instance whose value is 1.</foo>
@then the following document will unmarshal like this:XmlRootElement
class Foo { @XmlAnyElement(lax=true) publicObject
[] others; }
<foo>
<unknown />
<foo />
</foo>
Foo foo = unmarshal();
// 1 for 'unknown', another for 'foo'
assert foo.others.length==2;
// 'unknown' unmarshals to a DOM element
assert foo.others[0] instanceof Element;
// because of lax=true, the 'foo' element eagerly
// unmarshals to a Foo object.
assert foo.others[1] instanceof Foo;
Modifier and Type | Optional Element and Description |
---|---|
boolean |
lax
Controls the unmarshaller behavior when it sees elements
known to the current
JAXBContext . |
Class<? extends DomHandler> |
value
Specifies the
DomHandler which is responsible for actually
converting XML from/to a DOM-like data structure. |
public abstract boolean lax
JAXBContext
.
If false, all the elements that match the property will be unmarshalled to DOM, and the property will only contain DOM elements.
If true, when an element matches a property marked with XmlAnyElement
is known to JAXBContext
(for example, there's a class with
XmlRootElement
that has the same tag name, or there's
XmlElementDecl
that has the same tag name),
the unmarshaller will eagerly unmarshal this element to the JAXB object,
instead of unmarshalling it to DOM. Additionally, if the element is
unknown but it has a known xsi:type, the unmarshaller eagerly unmarshals
the element to a JAXBElement
, with the unknown element name and
the JAXBElement value is set to an instance of the JAXB mapping of the
known xsi:type.
As a result, after the unmarshalling, the property can become heterogeneous; it can have both DOM nodes and some JAXB objects at the same time.
This can be used to emulate the "lax" wildcard semantics of the W3C XML Schema.
public abstract Class<? extends DomHandler> value
DomHandler
which is responsible for actually
converting XML from/to a DOM-like data structure.Copyright © 2021 JBoss by Red Hat. All rights reserved.