All Downloads are FREE. Search and download functionalities are using the official Maven repository.

javax.xml.bind.annotation.XmlElementRef Maven / Gradle / Ivy

There is a newer version: 2.4.0-b180830.0359
Show newest version
/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright (c) 2004-2014 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
 * http://glassfish.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<? 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

* 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 1.6, JAXB 2.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 1.7, JAXB 2.2 */ boolean required() default true; }





© 2015 - 2024 Weber Informatics LLC | Privacy Policy