javax.xml.bind.annotation.XmlElementRef Maven / Gradle / Ivy
/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright (c) 2004-2011 Oracle and/or its affiliates. All rights reserved.
*
* The contents of this file are subject to the terms of either the GNU
* General Public License Version 2 only ("GPL") or the Common Development
* and Distribution License("CDDL") (collectively, the "License"). You
* may not use this file except in compliance with the License. You can
* obtain a copy of the License at
* https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
* or packager/legal/LICENSE.txt. See the License for the specific
* language governing permissions and limitations under the License.
*
* When distributing the software, include this License Header Notice in each
* file and include the License file at packager/legal/LICENSE.txt.
*
* GPL Classpath Exception:
* Oracle designates this particular file as subject to the "Classpath"
* exception as provided by Oracle in the GPL Version 2 section of the License
* file that accompanied this code.
*
* Modifications:
* If applicable, add the following below the License Header, with the fields
* enclosed by brackets [] replaced by your own identifying information:
* "Portions Copyright [year] [name of copyright owner]"
*
* Contributor(s):
* If you wish your version of this file to be governed by only the CDDL or
* only the GPL Version 2, indicate your decision by adding "[Contributor]
* elects to include this software in this distribution under the [CDDL or GPL
* Version 2] license." If you don't indicate a single choice of license, a
* recipient has the option to distribute your version of this file under
* either the CDDL, the GPL Version 2 or to extend the choice of license to
* its licensees as provided above. However, if you add GPL Version 2 code
* and therefore, elected the GPL Version 2 license, then the option applies
* only if the new code is made subject to such option by the copyright
* holder.
*/
package javax.xml.bind.annotation;
import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.METHOD;
/**
*
* 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
* XML Schema allows a XML document author to use XML element names
* that were not statically specified in the content model of a
* schema using substitution groups. Schema derived code provides
* support for substitution groups using an element property,
* (section 5.5.5, "Element Property" of JAXB 2.0 specification). An
* element property method signature is of the form:
*
* 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:
*
* - 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
* 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 - Kohsuke Kawaguchi, Sun Microsystems,Inc.
- Sekhar Vajjhala, Sun Microsystems, Inc.
* @see XmlElementRefs
* @since JAXB2.0
*/
@Retention(RUNTIME)
@Target({FIELD,METHOD})
public @interface XmlElementRef {
/**
* The Java type being referenced.
*
* 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;
}