* 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. * *
* public void setTerm(JAXBElement); * public JAXBElement 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: *
See "Package Specification" in javax.xml.bind.package javadoc for * additional common information.
* *Example 1: Ant Task Example
* The following Java class hierarchy models an Ant build * script. An Ant task corresponds to a class in the class * hierarchy. The XML element name of an Ant task is indicated by the * @XmlRootElement annotation on its corresponding class. *
* @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); ** will produce the following XML output: *
* <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); ** will produce the following XML output: *
* <math> * <add>...</add> * </math> ** * * @author
* If the value is DEFAULT.class, the type is inferred from the * the type of the JavaBean property. */ Class type() default DEFAULT.class; /** * 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 "". * */ String namespace() default ""; /** * * @see #namespace() */ String name() default "##default"; /** * Used in {@link XmlElementRef#type()} to * signal that the type be inferred from the signature * of the property. */ static final class DEFAULT {} /** * Customize the element declaration to be required. *
* If required() is true, then Javabean property is mapped to * an XML schema element declaration with minOccurs="1". * maxOccurs is "1" for a single valued property and "unbounded" * for a multivalued property. * *
* If required() is false, then the Javabean property is mapped * to XML Schema element declaration with minOccurs="0". * maxOccurs is "1" for a single valued property and "unbounded" * for a multivalued property. * *
* For compatibility with JAXB 2.1, this property defaults to true, * despite the fact that {@link XmlElement#required()} defaults to false. * * @since 2.2 */ boolean required() default true; }