javax.xml.bind.annotation
annotation XmlElementRef

java.lang.annotation.Annotation javax.xml.bind.annotation.XmlElementRef

public interface annotation XmlElementRef
extends Annotation

Maps a JavaBean property to a XML element derived from property's type.

Usage

@XmlElementRef annotation can be used with a JavaBean property or from within {@link XmlElementRefs}

This annotation dynamically associates an XML element name with the JavaBean property. When a JavaBean property is annotated with {@link XmlElement}, the XML element name is statically derived from the JavaBean property name. However, when this annotation is used, the XML element name is derived from the instance of the type of the JavaBean property at runtime.

XML Schema substitution group support

     public void setTerm(JAXBElement<? extends Operator>);
     public JAXBElement<? extends Operator> getTerm();
 

An element factory method annotated with {@link XmlElementDecl} is used to create a JAXBElement instance, containing an XML element name. The presence of @XmlElementRef annotation on an element property indicates that the element name from JAXBElement instance be used instead of deriving an XML element name from the JavaBean property name.

The usage is subject to the following constraints:

• If the collection item type (for collection property) or property type (for single valued property) is {@link javax.xml.bind.JAXBElement}, then @XmlElementRef}.name() and @XmlElementRef.namespace() must point an element factory method with an @XmlElementDecl annotation in a class annotated with @XmlRegistry (usually ObjectFactory class generated by the schema compiler) :
  • @XmlElementDecl.name() must equal @XmlElementRef.name()
  • @XmlElementDecl.namespace() must equal @XmlElementRef.namespace().
• If the collection item type (for collection property) or property type (for single valued property) is not {@link javax.xml.bind.JAXBElement}, then the type referenced by the property or field must be annotated with {@link XmlRootElement}.
• This annotation can be used with the following annotations: {@link XmlElementWrapper}, {@link XmlJavaTypeAdapter}.

See "Package Specification" in javax.xml.bind.package javadoc for additional common information.

Example 1: Ant Task Example

     @XmlRootElement(name="target")
     class Target {
         // The presence of @XmlElementRef indicates that the XML
         // element name will be derived from the @XmlRootElement 
         // annotation on the type (for e.g. "jar" for JarTask). 
         @XmlElementRef
         List<Task> tasks;
     }

     abstract class Task {
     }

     @XmlRootElement(name="jar")
     class JarTask extends Task {
         ...
     }

     @XmlRootElement(name="javac")
     class JavacTask extends Task {
         ...
     }

     <!-- XML Schema fragment -->
     <xs:element name="target" type="Target">
     <xs:complexType name="Target">
       <xs:sequence>
         <xs:choice maxOccurs="unbounded">
           <xs:element ref="jar">
           <xs:element ref="javac">
         </xs:choice>
       </xs:sequence>
     </xs:complexType>

 

Thus the following code fragment:

     Target target = new Target();
     target.tasks.add(new JarTask());
     target.tasks.add(new JavacTask());
     marshal(target);
 

     <target>
       <jar>
         ....
       </jar>
       <javac>
         ....
       </javac>
     </target>
 

It is not an error to have a class that extends Task that doesn't have {@link XmlRootElement}. But they can't show up in an XML instance (because they don't have XML element names).

Example 2: XML Schema Susbstitution group support

The following example shows the annotations for XML Schema substitution groups. The annotations and the ObjectFactory are derived from the schema.

     @XmlElement
     class Math {
         //  The value of {@link #type()}is 
         //  JAXBElement.class , which indicates the XML
         //  element name ObjectFactory - in general a class marked
         //  with @XmlRegistry. (See ObjectFactory below)
         //  
         //  The {@link #name()} is "operator", a pointer to a
         // factory method annotated with a
         //  {@link XmlElementDecl} with the name "operator". Since
         //  "operator" is the head of a substitution group that
         //  contains elements "add" and "sub" elements, "operator"
         //  element can be substituted in an instance document by
         //  elements "add" or "sub". At runtime, JAXBElement
         //  instance contains the element name that has been
         //  substituted in the XML document.
         // 
         @XmlElementRef(type=JAXBElement.class,name="operator")
         JAXBElement<? extends Operator> term;
     }

     @XmlRegistry
     class ObjectFactory {
         @XmlElementDecl(name="operator")
         JAXBElement<Operator> createOperator(Operator o) {...}
         @XmlElementDecl(name="add",substitutionHeadName="operator")
         JAXBElement<Operator> createAdd(Operator o) {...}
         @XmlElementDecl(name="sub",substitutionHeadName="operator")
         JAXBElement<Operator> createSub(Operator o) {...}
     }

     class Operator {
         ...
     }
 

Thus, the following code fragment

     Math m = new Math();
     m.term = new ObjectFactory().createAdd(new Operator());
     marshal(m);
 

     <math>
       <add>...</add>
     </math>
 

name

public String name()

namespace

public String namespace()

This parameter and {@link #name()} are used to determine the XML element for the JavaBean property.

If type() is JAXBElement.class , then namespace() and name() point to a factory method with {@link XmlElementDecl}. The XML element name is the element name from the factory method's {@link XmlElementDecl} annotation or if an element from its substitution group (of which it is a head element) has been substituted in the XML document, then the element name is from the {@link XmlElementDecl} on the substituted element.

If {@link #type()} is not JAXBElement.class, then the XML element name is the XML element name statically associated with the type using the annotation {@link XmlRootElement} on the type. If the type is not annotated with an {@link XmlElementDecl}, then it is an error.

If type() is not JAXBElement.class, then this value must be "".

type

public Class type()

The Java type being referenced.

If the value is DEFAULT.class, the type is inferred from the the type of the JavaBean property.