Jakarta XML Binding

date of generation of schema-derived class. Value must follow the ISO 8601 standard.

Specification: Jakarta XML Binding

Version: 4.0

Status: Final Release

Release: February 21, 2022
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <xsd:element name="purchaseOrder" type="PurchaseOrderType"/>
  <xsd:element name="comment" type="xsd:string"/>
  <xsd:complexType name="PurchaseOrderType">
    <xsd:sequence>
      <xsd:element name="shipTo"    type="USAddress"/>
      <xsd:element name="billTo"    type="USAddress"/>
      <xsd:element ref="comment"    minOccurs="0"/>
      <xsd:element name="items"     type="Items"/>
    </xsd:sequence>
    <xsd:attribute name="orderDate" type="xsd:date"/>
  </xsd:complexType>

  <xsd:complexType name="USAddress">
    <xsd:sequence>
      <xsd:element name="name"      type="xsd:string"/>
      <xsd:element name="street"    type="xsd:string"/>
      <xsd:element name="city"      type="xsd:string"/>
      <xsd:element name="state"     type="xsd:string"/>
      <xsd:element name="zip"       type="xsd:decimal"/>
    </xsd:sequence>
    <xsd:attribute name="country"   type="xsd:NMTOKEN" fixed="US"/>
  </xsd:complexType>

  <xsd:complexType name="Items" >
    <xsd:sequence>
      <xsd:element name="item" minOccurs="1" maxOccurs="unbounded">
        <xsd:complexType>
          <xsd:sequence>
            <xsd:element name="productName" type="xsd:string"/>
            <xsd:element name="quantity" >
              <xsd:simpleType>
                <xsd:restriction base="xsd:positiveInteger">
                  <xsd:maxExclusive value="100"/>
                </xsd:restriction>
              </xsd:simpleType>
            </xsd:element>
            <xsd:element name="USPrice"  type="xsd:decimal"/>
            <xsd:element ref="comment"   minOccurs="0"/>
            <xsd:element name="shipDate" type="xsd:date" minOccurs="0"/>
          </xsd:sequence>
          <xsd:attribute name="partNum"  type="SKU" use="required"/>
        </xsd:complexType>
      </xsd:element>
    </xsd:sequence>
  </xsd:complexType>

  <!-- Stock Keeping Unit, a code for identifying products -->
  <xsd:simpleType name="SKU" >
    <xsd:restriction base="xsd:string">
      <xsd:pattern value="\d{3}-[A-Z]{2}"/>
    </xsd:restriction
  </xsd:simpleType>
</xsd:schema>
import javax.xml.datatype.XMLGregorianCalendar; import java.util.List;
public class PurchaseOrderType {
    USAddress    getShipTo() {...}      void setShipTo(USAddress) {...}
    USAddress    getBillTo() {...}      void setBillTo(USAddress) {...}
    /** Optional to set Comment property. */
    String       getComment() {...}     void setComment(String) {...}
    Items        getItems() {...}       void setItems(Items) {...}
    XMLGregorianCalendar getOrderDate() void setOrderDate(XMLGregorianCalendar)
};
public class USAddress {
    String       getName() {...}        void setName(String) {...}
    String       getStreet() {...}      void setStreet(String) {...}
    String       getCity() {...}        void setCity(String) {...}
    String       getState() {...}       void setState(String) {...}
    int          getZip() {...}         void setZip(int) {...}
    static final String COUNTRY=”USA”;^[2]
};
public class Items  {
    public class ItemType {
        String   getProductName() {...} void setProductName(String) {...}
        /** Type constraint on Quantity setter value 0..99.^[3] */
        int      getQuantity() {...}    void setQuantity(int) {...}
        float    getUSPrice() {...}     void setUSPrice(float) {...}
        /** Optional to set Comment property. */
        String   getComment() {...}     void setComment(String) {...}
        XMLGregorianCalendar getShipDate(); void setShipDate(XMLGregorianCalendar);
        /** Type constraint on PartNum setter value "\d{3}-[A-Z]{2}".^[2] */
        String   getPartNum() {...}       void setPartNum(String) {...}
    };

    /** Local structural constraint 1 or more instances of Items.ItemType */
    List<Items.ItemType> getItem() {...}
}
public class ObjectFactory  {
    // type factories
    Object newInstance(Class javaInterface) {...}
    PurchaseOrderType createPurchaseOrderType() {...}
    USAddress create USAddress() {...}
    Items createItems() {...}
    Items.ItemType createItemsItemType() {...}
    // element factories
    JAXBElement<PurchaseOrderType> createPurchaseOrder(PurchaseOrderType) {...}
    JAXBElement<String> createComment(String value) {...}
}
public abstract class JAXBContext {
    static final String JAXB_CONTEXT_FACTORY;
    static JAXBContext newInstance(String contextPath);
    static JAXBContext newInstance(String contextPath,
                                   ClassLoader contextPathCL);
    static JAXBContext newInstance(Class... classesToBeBound);
    abstract Unmarshaller createUnmarshaller();
    abstract Marshaller createMarshaller();
    abstract JAXBIntrospector createJAXBIntrospector();
    <T> Binder<T> createBinder(Class<T> domType);
    Binder<org.w3c.dom.Node> createBinder();
    void generateSchema(SchemaOutputResolver);
}
        JAXBContext jc =
            JAXBContext.newInstance( "com.acme.foo:com.acme.bar" );
        JAXBContext jc =
            JAXBContext.newInstance( POElement.class );
    @XmlRootElement class Foo { Bar b; }^[5]
    @XmlType class Bar { FooBar fb; }
    @XmlType class FooBar { int x; }
public interface Unmarshaller {
    ValidationEventHandler getEventHandler()
    void setEventHandler(ValidationEventHandler)

    java.lang.Object getProperty(java.lang.String name)
    void setProperty(java.lang.String name, java.lang.Object value)

    void setSchema(javax.xml.validation.Schema schema)
    javax.xml.validation.Schema getSchema()

    UnmarshallerHandler getUnmarshallerHandler()

    void setListener(Unmarshaller.Listener)
    Unmarshaller.Listener getListener()

    java.lang.Object unmarshal(java.io.File)
    java.lang.Object unmarshal(java.net.URL)
    java.lang.Object unmarshal(java.io.InputStream)
    java.lang.Object unmarshal(org.xml.sax.InputSource)
    java.lang.Object unmarshal(org.w3c.dom.Node)

    java.lang.Object unmarshal(javax.xml.transform.Source)
    java.lang.Object unmarshal(javax.xml.stream.XMLStreamReader)
    java.lang.Object unmarshal(javax.xml.stream.XMLEventReader)

    <T> JAXBElement<T> unmarshal(org.w3c.dom.Node,
                                 Class<T> declaredType)
    <T> JAXBElement<T> unmarshal(javax.xml.transform.Source,
                                 Class<T> declaredType)
    <T> JAXBElement<T> unmarshal(javax.xml.stream.XMLStreamReader,
                                 Class<T> declaredType)
    <T> JAXBElement<T> unmarshal(javax.xml.stream.XMLEventReader,
                                 Class<T> declaredType)
}
interface Marshaller {
    string JAXB_ENCODING;
    string JAXB_FORMATTED_OUTPUT;
    string JAXB_SCHEMA_LOCATION;
    string JAXB_NO_NAMESPACE_SCHEMA_LOCATION;
    string JAXB_FRAGMENT;

    <PROTENTIALLY MORE PROPERTIES...>

    java.lang.Object getProperty(java.lang.String name)
    void setProperty(java.lang.String name, java.lang.Object value)

    void setEventHandler(ValidationEventHandler handler)
    ValidationEventHandler getEventHandler()

    void setSchema(javax.xml.validation.Schema schema)
    javax.xml.validation.Schema getSchema()

    void setListener(Unmarshaller.Listener)
    Unmarshaller.Listener getListener()

    void marshal(java.lang.Object e, java.io.Writer writer)
    void marshal(java.lang.Object e, java.io.OutputStream os)
    void marshal(java.lang.Object e, org.xml.sax.ContentHandler)
    void marshal(java.lang.Object e, javax.xml.transform.Result)
    void marshal(java.lang.Object e, org.w3c.dom.Node)
    void marshal(java.lang.Object e,
                 javax.xml.stream.XMLStreamWriter writer)

    org.w3c.dom.Node getNode(java.lang.Object contentTree)
}
public abstract class JAXBIntrospector {
    public boolean isElement(Object jaxbObj);
    public QName getElementName(Object jaxbElement);
    public static Object getValue(Object jaxbElement);
}
public abstract class Binder<XmlNode> {
    // Create two views of XML content, infoset view and JAXB view.
    public abstract Object unmarshal(XmlNode xmlNode)
    <T> JAXBElement<T> unmarshal(XmlNode xmlNode,
                                 Class<T> declaredType)
    public abstract void marshal(Object jaxbObject, XmlNode xmlNode)

    // Navigation between xml infoset view and JAXB view.
    public abstract XmlNode getXMLNode(Object jaxbObject);
    public abstract Object getJAXBNode(XmlNode xmlNode);

    // Synchronization methods
    public abstract XmlNode updateXML(Object jaxbObject)
    public abstract XmlNode updateXML(Object jaxbObject, XmlNode xmlNode)
        throws JAXBException;
    public abstract Object updateJAXB(XmlNode xmlNode)
        throws JAXBException;

    // Enable optional validation
    public abstract void setSchema(Schema schema);
    public abstract Schema getSchema();
    public abstract void setEventHandler(ValidationEventHandler handler)
        throws JAXBException;
    public abstract ValidationEventHandler getEventHandler()
        throws JAXBException;

    // Marshal/Unmarshal properties
    public abstract void setProperty(String name, Object value)
        throws PropertyException;
    public abstract Object getProperty(String name)
        throws PropertyException;
}
public Foo createFoo();
public JAXBElement<T> createFoo(T elementValue);
public Object newInstance(Class javaContentInterface);
java.lang.Object getProperty(String name);
void setProperty(String name, Object value);
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
            xmlns:po="http://www.example.com/PO1"
            targetNamespace="http://www.example.com/PO1">
  <xs:element name="purchaseOrder" type="po:PurchaseOrderType"/>
  <xs:element name="comment"       type="xs:string"/>
  <xs:complexType name="PurchaseOrderType"/>
  ...
</xs:schema>
package com.example.PO1;
import jakarta.xml.bind.JAXBElement;
public class PurchaseOrderType {...};
public Comment { String getValue() {...} void setValue(String) {...} }
...
public class ObjectFactory {
    PurchaseOrderType createPurchaseOrderType();
    JAXBElement<PurchaseOrderType> createPurchaseOrder(PurchaseOrderType elementValue);
    Comment createComment(String value);
    ...
}
Bar.Foo createBarFoo() {...}
        public Type getId();
        public void setId(Type value);
    <xs:attribute name="partNum" type="SKU" use="required"/>
    public String getPartNum();
    public void setPartNum(String x);
        public Type[] getId();
        public void setId(Type[] value);
        public void setId(int index, Type value);
        public Type getId(int index);
        public int getIdLength();
    <xs:complexType name="Items">
      <xs:sequence>
        <xs:element name="item" minOccurs="1" maxOccurs="unbounded">
          <xs:complexType>...</xs:complexType>
      </xs:element>
    </xs:complexType>
    public Items.ItemType[] getItem();
    public void setItem(Items.ItemType[] value);
    public void setItem(int index, Items.ItemType value);
    public Items.ItemType getItem(int index);
    public int getItemLength();
        public List<Type> getId();
    public List<Item> getItem();
        public static final Type ID = <fixedValue>;
        public boolean isSetId();
        public void unsetId();
    <xs:attribute name="partNum" type = "SKU" use="required"/>
        public String getPartNum();
        public void setPartNum(String skuValue);
        public boolean isSetPartNum();
        public void unsetPartNum();
        public void setId(JAXBElement<? extends Type> value);
        public JAXBElement<? extends Type> getId();
        package elementDeclarationTargetNamespace;
        class ObjectFactory {
            jakarta.xml.bind.JAXBElement<ElementType>
                                        createElementName(ElementType value);
        }
    <xs:schema targetNamespace=”a” xmlns:a=”a”/>
    <xs:element name=”Foo” type=”xsd:int”/>

    class ObjectFactory {
        // returns JAXBElement with its name set to QName(“a”, “Foo”).
        JAXBElement<Integer> createFoo(Integer value);
    }
JAXBElement<Integer> createBarFoo(Integer value)
    <xs:complexType name="AComplexType" mixed="true">
      <xs:sequence>
        <xs:element name="ASimpleElement" type="xs:int"/>
      </xs:sequence>
    </xs:complexType>
    public value class AComplexType {
        public class ASimpleElement extends
                            jakarta.xml.bind.JAXBElement<Integer> {
        }
        ...
    };
    class ObjectFactory {
        AComplexType createAComplexType();
        JAXBElement<Integer>
                createAComplexTypeASimpleElement(Integer value);
        ...
    }
        <xs:element name=”foo” type=”fooType”/>
    <xs:simpleType name="productCode">
      <xs:restriction base="xs:string">
        <xs:length value="8" fixed="true"/>
      </xs:restriction>
    </xs:simpleType>
<xs:schema targetNamespace="http://e.org" xmlns:e="http://e.org"
            xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:notation name="jpeg" public="image/jpeg" system="jpeg.exe"/>
  <xs:notation name="png" public="image/png" system="png.exe"/>
  <xs:simpleType name="pictureType">
    <xs:restriction base="xs:NOTATION">
      <xs:enumeration value="e:jpeg"/>
      <xs:enumeration value="e:png"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:complexType name="Picture">
    <xs:simpleContent>
      <xs:extension base="xs:hexBinary">
        <xs:attribute name="format" type="e:pictureType"/>
      </xs:extension>
    </xs:simpleContent>
  </xs:complexType>
</xs:schema>
package org.e;
import javax.xml.namespace.QName;
public class Picture {
    void setValue(byte[] value) {...}
    byte[] getValue() {...}
    void setFormat(QName value)\{...}
    QName getFormat() {...}
}
    Picture pic = ...;
    pic.setFormat(new QName("http://e.org","jpeg"));
    <xs:simpleType name="productCode">
      <xs:restriction base="xs:string">
        <xs:length value="8" fixed="true"/>
      </xs:restriction>
    </xs:simpleType>
    @XmlType(name="productCode")
    public class ProductCode {
        @XmlValue
        String getValue();
        void setValue(String value);
    }
    <xs:simpleType name="USState">
      <xs:restriction base="xs:NCName">
        <xs:enumeration value="AK"/>
        <xs:enumeration value="AL"/>
      </xs:restriction>
    </xs:simpleType>
    public enum USState {
        AK, AL;
        public String value() { return name(); }
        public static USState fromValue(String value) {...}
    };
public        type         value();
public static enumTypeName fromValue(type value);
public enum enumType {
    EnumConstantName1(EnumConstantValue1),
    ...
    EnumConstantNameX(EnumConstantValueX);
    public EnumConstantValueType value() { return value; }
    public static enumType fromValue(EnumConstantValueType val)
        {...}

    final private EnumConstantValueType value;
    private enumType(EnumConstantValueType value) {
        this.value = value;
    }
}
public enum enumType {
    EnumConstantName1, ..., EnumConstantNameX;
    public String^[18] value() { return name(); }
    public static enumType fromValue(String value) {...}
}
    <xs:simpleType name="Coin">
      <!-- Assume jaxb customization that binds Coin to an enumType -->
      <xs:restriction base="xs:int"> +
        <!-- Assume jaxb customization specifying enumConstantName -->
        <xs:enumeration value="1"/> <!-- name="penny"-->
        <xs:enumeration value="5"/> <!-- name="nickel"-->
        <xs:enumeration value="10"/><!-- name="dime"-->
        <xs:enumeration value="25"/><!-- name="quarter-->
      </xs:restriction>
    </xs:simpleType>
    @XmlEnum(value="java.lang.Integer.class")
    public enum Coin {
        @XmlEnumValue("1") PENNY(1),
        @XmlEnumValue("5") NICKEL(5),
        @XmlEnumValue("10") DIME(10),
        @XmlEnumValue("25") QUARTER(25);

        public int value() { return value; }
        public static Coin fromValue(int value) {...}

        private final Integer value;
        Coin(int value) { this.value = value; }
    }
    <xs:simpleType name="xs:USStateList">
      <xs:list itemType="xs:string"/>
    </xs:simpleType>
        public Type getId();
        public void setId(Type value);
    <xs:complexType name="CTType">
      <xs:attribute name="state" type="ZipOrName"/>
    </xs:complexType>
    <xs:simpleType name="ZipOrName"
                   memberTypes="xs:integer xs:string"/>
public class CTType {
    String getState() {...}
    void setState(String value) {...}
}
public class Ci1 extends Ci2 {
    .....
}
    <xs:complexType name="Address">
      <xs:sequence>
        <xs:element name="name" type="xs:string"/>
        <xs:element name="street" type="xs:string"/>
        <xs:element name="city" type="xs:string"/>
      </xs:sequence>
    </xs:complexType>
    <xs:complexType name="USAddress">
      <xs:complexContent>
        <xs:extension base="ipo:Address">
          <xs:sequence>
            <xs:element name="state" type="xs:string"/>
            <xs:element name="zip" type="xs:integer"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
    public class Address {
        String getName() {...}
        void setName(String) {...}
        String getStreet() {...}
        void setStreet(String) {...}
        void getCity() {...}
        void setCity(String) {...}
    }

    import java.math.BigInteger;

    public class USAdress extends Address {
        String getState() {...}
        void setState(String) {...} {
        BigInteger getZip() {...}
        void setZip(BigInteger) {...}
    }

    class ObjectFactory {
        Address createAddress() {...}
        USAddress createUSAddress() {...}
    }
    <xs:complexType name="internationalPrice">
      <xs:simpleContent>
        <xs:extension base="xs:decimal">
          <xs:attribute name="currency" type="xs:string"/>
        </xs:extension>
      </xs:simpleContent>
    </xs:complexType>
    class InternationalPrice {
        /** Java property for simple content */
        @XmlValue
        java.math.BigDecimal getValue() {...}
        void setValue(java.math.BigDecimal value) {...}

        /** Java property for attribute */
        String getCurrency() {...}
        void setCurrency(String) {...}
    }
    <xs:element name="anyContent/> <!-- @type defaults to xs:anyType -->
    <xs:complexType name="base">
      <xs:sequence>
        <xs:element ref="anyContent/>
        <xs:element name="anyContentAgain" type="xs:anyType"/>
      </xs:sequence>
    </xs:complexType>
    public class Base {
        void setAnyContent(Object obj);
        Object getAnyContent();
        void setAnyContentAgain(Object obj);
        Object getAnyContentAgain();
    }
    <xs:group name="AModelGroup">
      <xs:choice>
        <xs:element name="A" type="xs:int"/>
        <xs:element name="B" type="xs:float"/>
      </xs:choice>
    </xs:group>

    <xs:complexType name="foo">
      <xs:sequence>
        <xs:group ref="AModelGroup" maxOccurs="unbounded"/>
        <xs:element name="C" type="xs:float"/>
      </xs:sequence>
    </xs:complexType>
    public class Foo {
        /** A valid general content property of AModelGroup content model.*/
        @XmlElements({
            @XmlElement(type=Integer.class, name="A"),
            @XmlElement(type=Float.class, name="B")})
        java.util.List<Object> getAModelGroup() {...}

        float getC() {...}
        void setC(float value) {...}
    };
    <xs:schema targetNamespace="http://e.org" xmlns:a="http://e.org">
      <xs:attribute name="isOpen" type="xs:boolean"/>
    </xs:schema>
    package org.e;
    public class ObjectFactory {
        /** <xs:attribute name="{http://e.org}isOpen" type="xs:boolean"/> */
        public static final javax.xml.namespace.QName IS_OPEN =
                    new QName("http://e.org", "isOpen");
    ...
    }
    <xs:complexType name="chair_kind">
      <xs:sequence>
        <xs:element name="has_arm_rest" type="xs:boolean"/>
      </xs:sequence>
    </xs:complexType>
    public class ChairKind {
        boolean isHasArmRest() {...}
        void setHasArmRest(boolean value) {...}
    }
    <xs:complexType name="chair_kind">
      <xs:sequence>
        <xs:any/>
      </xs:sequence>
    </xs:complexType>
    public class ChairKind {
        @XmlAnyElement(lax="true")
        java.lang.Object getAny() {...}
        void setAny(java.lang.Object elementOrValue) {...}
    }
        JAXBElement<Integer> createBarFoo(Integer value) {...}
    <xs:element name="foo">
      <xs:complexType>
        <xs:sequence>
          <xs:element name="bar" type="xs:int"/>
        </xs:sequence>
      </xs:complexType>
    </xs:element>
    /* Value class representing element
    declaration with an anonymous complex type definition. */
    @XmlType(name="")
    @XmlRootElement(namespace="", name="foo")
    public class Foo {
        int getBar() {...}
        void setBar(int value) {...}
    };
    class ObjectFactory {
        // type factory method
        Foo              createFoo() {...}
        // element factory method
        JAXBElement<Foo> createFoo(Foo value) {...}
    }
    <xs:element name="foo" nillable="true">
      <xs:complexType>
        <xs:sequence>
          <xs:element name="bar" type="xs:int"/>
        </xs:sequence>
      </xs:complexType>
    </xs:element>
    /* Value class representing anonymous complex type definition. */
    @XmlType(name="")
    public class Foo {
        int getBar() {...}
        void setBar(int value) {...}
    };
    @XmlRegistry
    class ObjectFactory {
        // type factory method
        Foo              createFoo() {...}
        // element factory method
        @XmlElementDecl(name="foo", namespace="", nillable="true")
        JAXBElement<Foo> createFoo(Foo value) {...}
    }
    <xs:schema targetNamespace="travel:acme" xmlns:a="travel:acme">

      <!-- Define type definition derivation hierarchy -->
      <xs:complexType name="TransportType">...</xs:complexType>
      <xs:complexType name="PlaneType">
        <xs:extension base="a:TransportType">...</xs:complexType>
      <xs:complexType name="AutoType">
        <xs:extension base="a:TransportType">...</xs:complexType>
      <xs:complexType name="SUV">
        <xs:extension base="a:AutoType">...</xs:complexType>

      <xs:complexType name="itinerary">
        <xs:sequence>
          <!-- Type substitution possible for "transport". -->
          <xs:element name="transport" type="TransportType"/>
        </xs:sequence>
      </xs:complexType>
    </xs:schema>
    package travel.acme;

    // Type derivation hierarchy from schema is preserved in Java binding.
    public class TransportType {...}
    public class PlaneType extends TransportType {...}
    public class AutoType extends TransportType {...}
    public class SUV extends AutoType {...}

    public class ObjectFactory {
        // Type Factories
        TransportType createTransportType() {...}
        AutoType createAutoType() {...}
        PlaneType createPlaneType() {...}
        TrainType createSUV() {...}
    }

    public class Itinerary {
        // Simple property supports type substitution.
        TransportType getTransport() {...}
        void setTransport(TransportType value)
    }
        ObjectFactory of = ...;
        Itinerary itinerary = of.createItinerary();
        itinerary.setTransport(of.createTransportType); // Typical Use

        // Type Substitution
        // transport marshalled as <e:transport xsi:type="e:AutoType">
        itinerary.setTransport(of.createAutoType());

        // transport marshalled as <e:transport xsi:type="e:PlaneType">
        itinerary.setTransport(of.createPlaneType());
    <xsd:element name="Price">
      <xsd:complexType>
        <xsd:sequence>
          <xsd:element name="name" type="xsd:string"/>
          <!-- element price subject to type substitution -->
          <xsd:element name="price" type="xsd:int"/>
        </xsd:sequence>
      </xsd:complexType>
    </xsd:element>
    <xsd:complexType name="AmountType">
      <xsd:simpleContent> <!-- type substitutable for xs:int -->
        <xsd:extension base="xsd:int">
          <xsd:attribute name="currency" type="xsd:string"/>
        </xsd:extension>
      </xsd:simpleContent>
    </xsd:complexType>
    <xsd:simpleType name="AppInt">
      <xsd:restriction base="xsd:int"/>
    </xsd:simpleType>
    <product>
      <name>hotdog</name>
      <price>3</price>
    </product>

    <product>
      <name>peanuts</name>
      <price xsi:type="short">4</price>
    </product>

    <product>
      <name>popcorn</name>
      <price xsi:type="AppInt">5</price>
    </product>

    <product>
      <name>sushi</name>
      <price xsi:type="AmountType" currency="yen">500</price>
    </product>
    public class AmountType {
        @XmlValue
        int getValue() {...} void setValue(int value) {...}
        String getCurrency() {...} void setCurrency(String value) {...}
    }

    @XmlRootElement(namespace="", name="product")
    public class Product {
        int getPrice() {...} void setPrice(int value) {...}
        int getName() {...} void setName(String value) {...}
    }
    <jaxb:bindings schemaLocation="CODE EXAMPLE"
            node="//xsd:element[@name=’price’]">
      <jaxb:property>
        <jaxb:baseType name="java.lang.Object" />
      </jaxb:property>
    </jaxb:bindings>
    public class AmountType {
        @XmlValue
        int getValue() {...} void setValue(int value) {...}
        String getCurrency() {...} void setCurrency(String value) {...}
    }

    public class AppInt {
        @XmlValue
        int getValue() {...} void setValue(int value) {...}
    }

    public class Product {
        // enable simple type substitution with base type of Object
        @XmlElement(type=java.lang.Integer.class)
        Object getPrice() {...} void setPrice(Object value) {...}
        int getName() {...} void setName(String value) {...}
    }
    <xs:schema targetNamespace="travel:acme" xmlns:a="travel:acme">

      <!-- See type definition derivation hierarchy defined in CODE EXAMPLE for
    complexType definitions TransportType, PlaneType, AutoType and SUV.-->
      <!-- Define element substitution group. a:transport is head element. -->
      <xs:element name="transport" type="a:TransportType"/>
      <xs:element name="plane" type="a:PlaneType" substitutionGroup="a:transport" />
      <xs:element name="auto" type="a:AutoType" substitutionGroup="a:transport" />

      <xs:complexType name="itinerary">
        <xs:sequence>
          <!-- Global element reference.
               References head element of element substitution group. -->
          <xs:element ref="a:transport"/>
        </xs:sequence>
      </xs:complexType>
    </xs:schema>
    package travel.acme;
    public class ObjectFactory {
        // Type Factories
        TransportType createTransportType();
        AutoType createAutoType();
        PlaneType createPlaneType();
        TrainType createSUVType();

        // Element Instance Factories
        JAXBElement<AutoType> createAuto(AutoType value);
        JAXBElement<PlaneType> createPlane(PlaneType value);
        JAXBElement<TransportType> createTrain(TransportType value);
    }

    // See Java binding of type derivation hierarchy in CODE EXAMPLE 6-5

    public class Itinerary {
        // Element substitution supported by See [Element Property]
        JAXBElement<? extends TransportType> getTransport();
        void setTransport(JAXBElement<? extends TransportType> value);
    }
        ObjectFactory of = ...;
        Itinerary itinerary = of.createItinerary();
        itinerary.setTransport(of.createTransportType()); // Typical use.

        // Element substitution:
        // Substitute <e:auto> for schema specified <e:transport>.
        itinerary.setTransport(of.createAuto(of.createAutoType()));

        // Substitute <e:plane> for schema specified <e:transport>
        itinerary.setTransport(of.createPlane(of.createPlaneType()));

        // Combination of element and type substitution:
        // Substitutes <e:auto xsi:type="e:SUV"> for <e:transport>
        itinerary.setTransport(of.createAuto(of.createSUV()));
    <!-- Add elements not part of element substitution group. -->
    <xs:element name="apple" type="xsd:string"/>
    <xs:complexType name="spaceShuttle">
      <xs:extension base="a:TransportType">...</xs:complexType>
    <xs:element name="spaceShuttle" type="a:spaceShuttleType">
        ObjectFactory of = ...;
        Itinerary itinerary = of.createItinerary();
        // Invalid element substitution
        // compile time error: method not found
        // Element apple of type JAXBElement<String> does not match
        // bounded wildcard JAXBElement<? extends TransportType>.
        itinerary.setTransport(of.createApple("granny smith"));

        // Invalid element substitution detected by validation.
        // Element spaceShuttle not part of substitution group.
        // Adding substitutionGroup="transport" to line 4 fixes this.
        itinerary.setTranport(
        of.createSpaceShuttle(of.createSpaceShuttleType()));
    <!--deleted schema that remains same -->
    <xs:complexType name="itinerary">
      <xs:sequence>
        <!-- Repeating occurance to substitutable global element reference. -->
        <xs:element ref="a:transport" maxOccurs="unbounded" />
      </xs:sequence>
    </xs:complexType>
    public class Itinerary {
        List<JAXBElement<? extends TransportType>> getTransport();
    }
    <xs:complexType name="USAddress">
      <xs:attribute name="country" type="xs:string"/>
    </xs:complexType>
    public class USAddress {
        @XmlAttribute(name="country", targetNamespace="", required="false");
        public String getCountry() {...}
        public void setCountry(String value) {...}
    }
    <xs:annotation><xs:appinfo>
      <jaxb:globalBindings fixedAttributeAsConstantProperty="true"/>
    </xs:appinfo></xs:annotation>
    <xs:complexType name="USAddress">
      <xs:attribute name="country" type="xs:NMTOKEN" fixed="US"/>
    </xs:complexType>
    public class USAddress {
        @XmlAttribute
        public static final String COUNTRY="US";
        ...
    }
    <xs:complexType name="Book">
      <xs:sequence>
        <xs:element name="author" type="xs:IDREF"/>
        <!-- ... -->
      </xs:sequence>
    </xs:complexType>
    <xs:complexType name="AuthorBio">
      <xs:sequence> <!-- ... --> </xs:sequence>
      <xs:attribute name="name" type="xs:ID"/>
    </xs:complexType>
    public class Book {
        @XmlIDREF
        java.lang.Object getAuthor() {...}

        /** Parameter referencedObj should have an attribute or
         * child element with base type of xs:ID by validation
         * or marshal time.
         */
        void setAuthor(java.lang.Object referencedObj) {...}
    }
    public class AuthorBio {
        @XmlID
        String getName() {...}
        void setName(String value) {...}
    }
        Book book = ...;
        AuthorBio authorBio = ...;
        book.setAuthor(authorBio);
        authorBio.setName("<some author’s name>");
        // The content instance root used to validate or marshal book must
        // also include "authorBio" as a child element somewhere.
        // A Java content instance is not included
        // Return, by reference, a mapping of
        attribute QName and String. +
        Map<QName, String> getOtherAttributes();
    <xs:schema targetNamespace="http://a.org">
      <xs:complexType name="widget">
        <xs:anyAttribute/>
        <xs:attribute name="color" type="xs:string"/>
      </xs:complexType>
    </xs:schema>
    package org.a;
    import javax.xml.namespace.QName;
    import java.util.Map;
    public class Widget  {
        String getColor() {...}
        void setColor(String value) {...}
        @XmlAnyAttribute Map<QName, String> getOtherAttributes () {...}
    }
    import jakarta.xml.bind.DatatypeConverter;
    Widget w = ...;
    Map attrs = w.getOtherAttributes();

    // access schema-defined global attribute associated with
    // complexType defintion widget via attribute wildcard.
    QName IS_OPEN = new QName("http://example.org", "isOpen");
    boolean isOpen = DatatypeConverter.parseBoolean(attrs.get(IS_OPEN));

    // set wildcard attribute value
    attrs.put(IS_OPEN, DatatypeConverter.printBoolean(false));

    // semantically the same results setting attribute use via
    // dynamic or static setter for attribute use.
    attrs.put(new QName("color"), "red");

    // iterate over wildcard attributes
    for (Map.Entry<QName,String> e: attrs.entrySet()) {
    System.out.println("Attribute: " + e.getKey() +
                       " Value:" + e.getValue());
    }
    File: v1.xsd:
    <!-- Extracted from Section 4.2.2 of [XSD1] -->
    <xs:complexType name="personName">
      <xs:sequence>
        <xs:element name="title" type="xs:string" minOccurs="0"/>
        <xs:element name="forename" type="xs:string"
                    minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
    </xs:complexType>

    File: v2.xsd:
    <xs:redefine schemaLocation="v1.xsd">
      <xs:complexType name="personName">
        <xs:complexContent>
          <xs:extension base="personName">
            <xs:sequence>
              <xs:element name="generation" minOccurs="0"/>
            </xs:sequence>
          </xs:extension>
        </xs:complexContent>
      </xs:complexType>
    </xs:redefine>
    // binding of file v1.xsd complex type definition for personName
    @XmlType(name="_PersonName")
    public class _PersonName {
        void setTitle(String value); String getTitle();
        List<String> getForename();
    }
    // binding of v2.xsd redefinition for complex type personName
    @XmlType(name="PersonName")
    public class PersonName extends _PersonName {
        void setGeneration(Object value); Object getGeneration();
    }
    <xs:choice maxOccurs="unbounded"> ... </xs:choice>
    <xs:sequence maxOccurs="unbounded"> ... </xs:sequence>
    <xs:complexType name="Base">
      <xs:choice maxOccurs="unbounded">
        <xs:element name="A" type="xs:string"/>
        <xs:element name="B" type="xs:string"/>
        <xs:element name="C" type="xs:int"/>
      </xs:choice>
    </xs:complexType>
    public class ObjectFactory \{
        // Element instance factories.
        JAXBElement<String> createBaseA(String value) {...}
        JAXBElement<String> createBaseB(String value) {...}
        JAXBElement<Integer> createBaseC(Integer value) {...}
        // Type factories
        Base createBase() {...}
    }

    public class Base {
        /**
         * A general content list that can contain
         * element instances representing A, B and/or C.
         */
        @XmlElementRefs({
            @XmlElementRef(name="A", value=JAXBElement.class),
            @XmlElementRef(name="B", value=JAXBElement.class),
            @XmlElementRef(name="C", value=JAXBElement.class)})
        List<JAXBElement> getAOrBOrC()\{...}
    }
    <xs:complexType name="AType"/>
    <xs:complexType name="BType"/>
    <xs:complexType name="FooBar">
      <xs:choice maxOccurs="unbounded">
        <xs:element name="foo" type="AType"/>
        <xs:element name="bar" type="BType"/>
      </xs:choice>
    </xs:complexType>
    public class AType {...}
    public class BType {...}

    class ObjectFactory {
        // element instance factories only
        JAXBElement<AType> createFooBarFoo(AType value);
        JAXBElement<BType> createFooBarBar(BType value);
    }

    public class FooBar {
        /** Collection of element types: AType and BType. */
        @XmlElements({
            @XmlElement(value=AType.class, name="Foo"),
            @XmlElement(value=BType.class, name="Bar")})
        List<Object> getFooOrBar() {...}
    };
    <xs:element name="letterBody">
      <xs:complexType mixed="true">
        <xs:sequence>
          <xs:element name="name" type="xs:string"/>
          <xs:element name="quantity" type="xs:positiveInteger"/>
          <xs:element name="productName" type="xs:string"/>
          <!-- etc. -->
        </xs:sequence>
      </xs:complexType>
    </xs:element>
    import java.math.BigInteger;
    class ObjectFactory {
        // element instance factories only
        JAXBElement<LetterBody> createLetterBody(LetterBody value);
        JAXBElement<String> createLetterBodyName(String value);
        JAXBElement<BigInteger> createLetterBodyQuantity(BigInteger value);
        JAXBElement<String> createLetterBodyProductName(String value);
    }

    public class LetterBody implements JAXBElement<LetterBody> {
        /** Mixed content can contain instances of Element classes
            Name, Quantity and ProductName. Text data is represented as
            java.util.String for text. */
        @XmlMixed
        @XmlElementRefs( {
            @XmlElementRef(name="productName", type=JAXBElement.class),
            @XmlElementRef(name="quantity", type=JAXBElement.class),
            @XmlElementRef(name="name", type=JAXBElement.class)})
        List getContent() {...}
    }
    <letterBody>
    Dear Mr.<name>Robert Smith</name>
    Your order of <quantity>1</quantity> <productName>Baby
    Monitor</productName> shipped from our warehouse. ....
    </letterBody>
    LetterBody lb = ObjectFactory.createLetterBody(null);
    List gcl = lb.getContent();
    gcl.add("Dear Mr.");
    gcl.add(ObjectFactory.createLetterBodyName("Robert Smith"));
    gcl.add("Your order of ");
    gcl.add(ObjectFactory.
        createLetterBodyQuantity(new BigInteger("1")));
    gcl.add(ObjectFactory.createLetterBodyProductName("Baby Monitor"));
    gcl.add("shipped from our warehouse");
    <xs:sequence>
      <xs:choice>
        <xs:element ref="ns1:bar"/> (A)
        <xs:element ref="ns2:bar"/> (B)
      </xs:choice>
      <xs:element ref="ns1:bar"/> (C)
    </xs:sequence>
    <xs:complexType name="Base">
      <xs:sequence>
        <xs:element name="A" type="xs:int"/>
        <xs:element name="B" type="xs:int"/>
      </xs:sequence>
    </xs:complexType>

    <xs:complexType name="Derived">
      <xs:complexContent>
        <xs:extension base="Base">
          <xs:sequence>
            <xs:element name="A" type="xs:int"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
    public class Base {
        int getA() {...} void setA(int) {...}
        int getB() {...} void setB(int) {...}
    }

    public class Derived extends Base {
        /**
         * Instances of Derived.A must be placed in this general
         * content propert that represents the rest of the content
         * model. */
        List getRest() {...}
    }

    class ObjectFactory {
        // element instance factories only
        JAXBElement<Integer> createDerivedA(Integer value) {...}
    }
    <xs:choice>
      <xs:element name="foo" type="xs:int"/>
      <xs:element name="bar" type="xs:string"/>
    </xs:choice>
        void setFooOrBar(Object) {...}
        Object getFooOrBar() {...}
    <jaxb: binding declaration>
    <xs:annotation>
      <xs:appinfo>
        <binding declaration>
      </xs:appinfo>
    </xs:annotation>
    <jaxb:bindings [schemaLocation = "xs:anyURI"]>
        <jaxb:bindings [node = "xs:string"]>
            <binding declaration>
        <jaxb:bindings>
    </jaxb:bindings>
    <xs:schema jaxb:version="3.0">
    <jaxb:bindings version="3.0" ... />
    <jaxb:bindings jaxb:version="3.0" ... />
    <globalBindings
        [ collectionType = "collectionType" ]
        [ fixedAttributeAsConstantProperty = "true" | "false" | "1" | "0" ]
        [ generateIsSetMethod = "true" | "false" | "1" | "0" ]
        [ enableFailFastCheck = "true" | "false" | "1" | "0" ]
        [ choiceContentProperty = "true" | "false" | "1" | "0" ]
        [ underscoreBinding = "asWordSeparator" | "asCharInWord" ]
        [ typesafeEnumBase = "typesafeEnumBase" ]
        [ typesafeEnumMemberName = "skipGeneration" |
                                   "generateName" | "generateError" ]
        [ typesafeEnumMaxMembers = “xxxx”]
        [ enableJavaNamingConventions = "true" | "false" | "1" | "0" ]
        [ generateElementClass = "false" | "true" | "0" | "1" ]
        [ generateElementProperty = "false" | "true" | "0" | "1" ]
        [ generateValueClass = "true" | "true" | "0" | "1" ]
        [ optionalProperty = "wrapper" | "primitive" | "isSet" ]
        [ mapSimpleTypeDef = "true" | "false" | "1" | "0" ]
        [ localScoping = "nested" | "toplevel" ] >
        [ <javaType> ... </javaType> ]*
        [ <serializable uid=”xxxx”/> ]*
    </globalBindings>
    <xs:complexType name="USAddress">
      <xs:attribute name="City" type="xs:string"/>
    </xs:complexType>
    public class USAddress {
        public USAddress() {...}
        public String getCity() {...}
        public void setCity(String value) {...}
        ...
    }
    public interface USAddress {
        String getCity();
        void setCity(String value);
    }
    <xs:element name="Address" type="USAddress"/>
    // Default Java binding of global element to element instance factory
    public ObjectFactory {
        JAXBElement<USAddress> createAddress(USAddress value);
    }
    public class Address extends JAXBElement<USAddress> {
    }
    private static final long serialVersionUID = <value of @uid>;
    <schemaBindings [ map="boolean" ] >
        [ <package> package </package> ]
        [ <nameXmlTransform> ... </nameXmlTransform>]*
    </schemaBindings>

    <package [ name = "packageName" ]
        [ <javadoc> ... </javadoc> ]
    </package>

    <nameXmlTransform>
        [ <typeName           [ suffix="suffix" ]
                              [ prefix="prefix" ] /> ]
        [ <elementName        [ suffix="suffix" ]
                              [ prefix="prefix" ] /> ]
        [ <modelGroupName     [ suffix="suffix" ]
                              [ prefix="prefix" ] /> ]
        [ <anonymousTypeName  [ suffix="suffix" ]
                              [ prefix="prefix" ] /> ]
    </nameXmlTransform>
    <jaxb:schemaBindings>
        <jaxb:package name = "org.example.po" />
    </jaxb:schemaBindings>
    <xs:element name="bindingTemplate" type="uddi:bindingTemplate"/>
    <class [ name = "className" ]
           [ implClass = "implClass" ]
           [ ref = "className" ] >
           [ <javadoc> ... </javadoc> ]
    </class>
    <xs:complexType name="USAddress">
      <xs:annotation><xs:appinfo>
        <jaxb:class name="MyAddress" />
      </xs:appinfo></xs:annotation>
      <xs:sequence>...</xs:sequence>
      <xs:attribute name="country" type="xs:string"/>
    </xs:complexType>
    // public class USAddress { // Default Code
    public class MyAddress { // Customized Code
        public String getCountry() {...}
        public void setCountry(String value) {...}
        ...
    }
    <xs:simpleType name="SKU">
      <xs:annotation><xs:appinfo>
        <jaxb:class/>
      </xs:appinfo></xs:annotation>
      <xs:restriction base=”xs:int”/>
    </xs:simpleType>
    public class SKU {
        @XmlValue
        public int getValue() {...}
        public void setValue(int value) {...}
        ...
    }
    <xs:complexType name="AComplexType">
      <xs:sequence>
        <xs:element name="A" type="xs:int"/>
        <xs:element name="B" type="xs:string"/>
      </xs:sequence>
    </xs:complexType>

    <xs:element name="AnElement" type="AComplexType">
      <xs:annotation><xs:appinfo>
        <jaxb:class name="MyElement"/>
      </xs:appinfo></xs:annotation>
    </xs:element>
    // following class is generated because of customization

    public class AComplexType {
        void setA(int value) {...}
        int getA() {...}
        void setB(String value) {...}
        String getB() {...}
    }

    public class MyElement extends JAXBElement<AComplexType> {...}

    public class ObjectFactory {

        // Default code
        // JAXBElement<AnElement> createAnElement(AnElement)\{...}

        // Customized code
        MyElement createMyElement(AnElement) {...}
        ... other factory methods ...

    }
    <xs:complexType name="Base">
      <xs:choice maxOccurs="unbounded">
        <xs:element name="A" type="xs:string">
          <xs:annotation><xs:appinfo>
            <jaxb:class name="Bar"/>
          </xs:appinfo></xs:annotation>
        </xs:element>
        <xs:element name="B" type="xs:string"/>
        <xs:element name="C" type="xs:int"/>
      </xs:choice>
    </xs:complexType>
    import jakarta.xml.bind.JAXBElement;
    public class ObjectFactory {
        // element instance factories only
        // JAXBElement<String> createBaseA(String value); // default code
        JAXBElement<String> createBaseBar(String value); // Customized
        JAXBElement<String> createBaseB(String value);
        JAXBElement<Integer> createBaseC(Integer value);
    }
    public class Base {
        static public class Bar extends JAXBElement<String> {...} // Customized code
        /**
         * A general content list that can contain element
         * instances of JAXBElement<String> or JAXBElement<Integer>.
         */
        List<Object> getBarOrBOrC() {...}
    }
    <property [ name = "propertyName" ]
        [ collectionType = "propertyCollectionType" ]
        [ fixedAttributeAsConstantProperty = "true" | "false" | "1" | "0" ]
        [ generateIsSetMethod = "true" | "false" | "1" | "0" ]
        [ enableFailFastCheck = "true" | "false" | "1" | "0" ]
        [ generateElementProperty = "true" | "false" | "1" | "0" ]
        [ attachmentRef = "resolve" | "doNotResolve" | "default" ] >
        [ <baseType name = "fully qualified Java class"> ... </baseType> ]
        [ <javadoc> ... </javadoc> ]
    </property>

    <baseType name=”fully qualified Java class”>
        <javaType> ... </javaType>
    </baseType>
    <baseType name="fully qualified Java class>">
        <javaType> ... </javaType>
    </baseType>
    <xs:complexType name="Book">
      <xs:sequence>
        <xs:element name="author" type="xs:IDREF"/>
          <xs:annotation><xs:appinfo>
            <jaxb:property>
              <jaxb:baseType name=”AuthorBio.class”/>
            </jaxb:property>
          </xs:appinfo></xs:annotation>
        <!-- ... -->
      </xs:sequence>
    </xs:complexType>
    <xs:complexType name="AuthorBio">
      <xs:sequence><!-- ... --> </xs:sequence>
      <xs:attribute name="name" type="xs:ID"/>
    </xs:complexType>
    public class Book {
        @XmlIDREF
        AuthorBio getAuthor() {...}
        void setAuthor(AuthorBio referencedObj) {...}
    }
    public class AuthorBio {
        @XmlID
        String getName() {...}
        void setName(String value) {...}
    }
    <xs:complexType name="internationalPrice">
      ....
      <xs:attribute name="currency" type="xs:string">
        <xs:annotation><xs:appinfo>
          <jaxb:property>
            <jaxb:baseType>
              <jaxb:javaType name="java.math.BigDecimal"
        parseMethod="jakarta.xml.bind.DatatypeConverter.parseInteger"
        printMethod="jakarta.xml.bind.DatatypeConverter.printInteger"/>
            </jaxb:baseType>
          </jaxb:property>
        </xs:appinfo></xs:annotation>
      </xs:attribute>
    </xs:complexType>
    public class InternationalPrice {
        // String getCurrency(); default
        java.math.BigDecimal getCurrency() {...} //customized
        public void setCurrency(java.math.BigDecimal val) {...} // customized
    }
    <xs:complexType name="USAddress">
      <xs:attribute name="country" type="xs:NMTOKEN" fixed="US">
        <xs:annotation><xs:appinfo>
          <jaxb:property name="MY_COUNTRY"
                         fixedAttributeAsConstantProperty="true"/>
        </xs:appinfo></xs:annotation>
      </xs:attribute>
    </xs:complexType>
    public class USAddress {
        public static final String MY_COUNTRY = "US"; // Customized Code
    }
    <xs:complexType name="USAddress"> +
      <xs:attribute name="country" type="xs:string">
        <xs:annotation><xs:appinfo>
          <jaxb:property name="MyCountry"/>
        </xs:appinfo></xs:annotation>
      </xs:attribute>
    </xs:complexType>
    public class USAddress {
        // public getString getCountry(); // DefaultCode
        // public void setCountry(string value);//Default Code
        public String getMyCountry() {...} //Customized Code
        public void setMyCountry(String value) {...}// Customized Code
    }
    <xs:attribute name="account" type = "xs:int">
      <xs:annotation><xs:appinfo>
        <jaxb:property generateIsSetMethod="true"/>
      </xs:appinfo></xs:annotation>
    </xs:attribute>
    public int getAccount();
    public void setAccount(int account);
    public boolean isSetAccount(); // Customizedcode
    public void unsetAccount(); // Customizedcode
    <xs:complexType name="businessEntityExt">
      <xs:sequence>
        <xs:any namespace="##other"
                processContents="strict"
                minOccurs="1" maxOccurs="unbounded">
          <xs:annotation><xs:appinfo>
            <jaxb:property name="Extension"/>
          </xs:appinfo></xs:annotation>
        </xs:any>
        ....
      </xs:sequence>
    </xs:complexType>
    public class BusinessEntityExt {
        ...
        // List getAny(); // Default Code
        List getExtension() {...} // Customized Code
    }
    <xs:annotation><xs:appinfo>
      <jaxb:globalBindings choiceContentProperty="true"/>
    </xs:appinfo></xs:annotation>
    <xs:complexType name=”AType”>
      <xs:choice>
        <xs:element name="foo" type="xs:int"/>
        <xs:element name="bar" type="xs:string"/>
      </xs:choice>
    </xs:complexType>
    class ObjectFactory {
        JAXBElement<Integer> createAtypeFoo(Integer value);
        JAXBElement<String>  createAtypeBar(String value);
    }
    public class AType {
        void setFooOrBar(Object o) {...}    //customized code
        Object getFooOrBar() {...}          //customized code
    }
    <xs:complexType name="Base">
      <xs:choice maxOccurs="unbounded">
        <xs:annotation><xs:appinfo>
          <jaxb:property name="items" />
        </xs:appinfo></xs:annotation>
        <xs:element name="A" type="xs:string"/>
        <xs:element name="B" type="xs:string"/>
        <xs:element name="C" type="xs:int"/>
      </xs:choice>
    </xs:complexType>
    public class Base {
        /**
         * A general content list that can contain
         * instances of Base.A, Base.B and Base.C.
         */
        // List getAOrBOrC(); - default
        List getItems() {...} // Customized Code
    }
    <xs:complexType name="USAddress"/>
    <xs:complexType name="PurchaseOrderType">
      <xs:sequence>
        <xs:choice>
          <xs:group ref="shipAndBill"/>
          <xs:element name="singleUSAddress" type="USAddress">
            <xs:annotation><xs:appinfo>
              <jaxb:property name="address"/>
            </xs:appinfo></xs:annotation>
          </xs:element>
        </xs:choice>
      </xs:sequence>
    </xs:complexType>
    <xs:group name="shipAndBill">
      <xs:sequence>
        <xs:element name="shipTo" type="USAddress">
          <xs:annotation><xs:appinfo>
            <jaxb:property name="shipAddress"/>
          </appinfo></annotation>
        </xs:element>
        <xs:element name="billTo" type="USAddress">
          <xs:annotation><xs:appinfo>
            <jaxb:property name="billAddress"/>
          </xs:appinfo></xs:annotation>
        </xs:element>
      </xs:sequence>
    </xs:group>
    public interface PurchaseOrderType {
        USAddress getShipAddress(); void setShipAddress(USAddress);
        USAddress getBillAddress(); void setBillAddress(USAddress);
        USAddress getAddress(); void setAddress(USAddress);
    }
    <javaType name="javaType"
                [ xmlType = "xmlType" ]
                [ parseMethod = "parseMethod" ]
                [ printMethod = "printMethod" ]>
    <jaxb:globalBindings>
        <jaxb:javaType name="long" xmlType="xs:date"
                    parseMethod="pkg.MyDatatypeConverter.myParseDate"
                    printMethod="pkg.MyDatatypeConverter.myPrintDate"/>
        </jaxb:javaType>
    </jaxb:globalBindings>
    package pkg;
    import jakarta.xml.bind.DatatypeConverter;
    public class MyDatatypeConverter {
    public static long myParseDate(String s) {
        java.util.Calendar d = DatatypeConverter.parse(s);
        long result= cvtCalendarToLong(d) ; // userdefined method
        return result;
        }
        public static String myPrintDate(long l) {
            java.util.Calendar d = cvtLongToCalendar(l);//user defined
            return DatatypeConverter.print(d);
        }
    }
    <xs:simpleType name="foo" type="xs:long">
      <xs:annotation><xs:appinfo>
        <jaxb:javaType name="int"/>
      </xs:appinfo></xs:annotation>
    </xs:simpleType>
    <xs:element name="partNumber" type="xs:int"/>
    <jaxb:globalBindings>
        ....
        <jaxb:javaType name="long"
                    xmlType="xs:int"/>
    </jaxb:globalBindings>
        int j = (int) DataTypeConverter.parseLong(string);
    <typesafeEnumClass>
        [ name = "enumClassName" ]
        [ map = "true" | "false" | "1" | "0" ]
        [ ref = "enumClassName" ]
        [ <typesafeEnumMember> ... </typesafeEnumMember> ]*
        [ <javadoc> enumClassJavadoc </javadoc> ]
    </typesafeEnumClass>

    <typesafeEnumMember name = "enumMemberName">
                      [ value = "enumMemberValue"]
        [ <javadoc> enumMemberJavadoc </javadoc> ]
    </typesafeEnumMember>
    <xs:simpleType name="USState">
      <xs:annotation><xs:appinfo>
        <jaxb:typesafeEnumClass name="USStateAbbr"/>
      </xs:appinfo></xs:annotation>
      <xs:restriction base="xs:NCName">
        <xs:enumeration value="AK">
          <xs:annotation><xs:appinfo>
            <jaxb:typesafeEnumMember name="STATE_AK"/>
          </xs:appinfo></xs:annotation>
        </xs:enumeration>
        <xs:enumeration value="AL">
          <xs:annotation><xs:appinfo>
            <jaxb:typesafeEnumMember name="STATE_AL"/>
          </xs:appinfo></xs:annotation>
        </xs:enumeration>
      </xs:restriction>
    </xs:simpleType>
    public enum USStateAbbr {
        STATE_AL, STATE_AK;
        public String value() { return name(); }
        public static USStateAbbr fromValue(String value) {...}
    };
    <jaxb:typesafeEnumClass name="USStateAbbr">
        <jaxb:typesafeEnumMember name="STATE_AK" value="AK"/>
        <jaxb:typesafeEnumMember name="STATE_AL" value="AL"/>
    </jaxb:typesafeEnumClass>
    <xs:simpleType name="USState">
      <xs:annotation><xs:appinfo>
        <jaxb:typesafeEnumClass name="USStateAbbr">
          <jaxb:typesafeEnumMember name="STATE_AK" value="AK"/>
          <jaxb:typesafeEnumMember name="STATE_AL" value="AL"/>
        </jaxb:typesafeEnumClass>
      </xs:appinfo></xs:annotation>
      <xs:restriction base="xs:NCName">
        <xs:enumeration value="AK"/>
        <xs:enumeration value="AL"/>
      </xs:restriction>
    </xs:simpleType>
    <javadoc>
        Contents in &lt;b>Javadoc&lt;\b> format.
    </javadoc>
    <javadoc>
        <<![CDATA[
        Contents in <b>Javadoc<\b> format
        ]]>
    </javadoc>
    <dom [ [type= "w3c" | otherDomRepresentations ] />
    <xs:complexType name=”foo”>
      <xs:sequence>
        <xs:any maxOccurs="unbounded" processContents="lax">
          <xs:annotation><xs:appinfo>
            <jaxb:dom/>
          </xs:appinfo></xs:annotation>
        </xs:any>
      </xs:sequence>
    </xs:complexType>
    import org.w3c.dom.Element;
    public class Foo {
        @XmlAnyElement(lax=”false”)
        List<Element> getContent() {...}
    }
    import org.w3c.dom.Element;
    public class Foo {
        /* Element content is represented org.w3c.dom.Element.
         * Character data information is represented as instances of
         * java.lang.String. */
        @XmlMixed
        @XmlAnyElement(lax=”false”)
        List<Object> getContent() {...}
    }
    <inlineBinaryData/>
    <factoryMethod name=”BaseForFactoryMethodName”/>
    <xs:element name = "Customer">
      <xs:complexType>
        <xs:element ref = "Name"/>
        <xs:element ref = "Address" />
      </xs:complexType>
    </xs:element>
    //Example: code fragment
    int[] names;
    <!--XML Serialization Form 1 (Unwrapped collection)
      Element name is derived from property or field name-->
    <names> ... </names>
    <names> ... </names>
    ...
    <!--XML Serialization Form 2 (Wrapped collection)
      Element name of wrapper is derived from property or field name
      Element name of each item in collection is also derived from
      property name-->
    <names>
      <names> value-of-item </names>
      <names> value-of-item </names>
      ....
    </names>
    public int item;
    public int getItem();
    public void setItem(int val);
TypeParameter:
    TypeVariable TypeBound_opt

TypeBound:
    extends ClassOrInterfaceType AdditionalBoundList_opt
    // code fragment
    public class Shape <T> {
        public T xshape;
        public Shape() {};
        public Shape(T f) {
            xshape = f;
        }
    }
  <!-- XML Schema -->
  <xs:complexType name="shape">
    <xs:sequence>
      <xs:element name="xshape" type="xs:anyType" minOccurs="0"/>
    </xs:sequence>
  </xs:complexType>
TypeArguments:
    <ActualTypeArgumentList>

ActualTypeArgumentList:
    ActualTypeArgument
    ActualTypeArgumentList, ActualTypeArgument

ActualTypeArgument:
    ReferenceType
    Wildcard

Wildcard:
?WildcardBounds

WildcardBounds:
    extends ReferenceType
    super ReferenceType
    /**
     * EXAMPLE : WildcarType Mapping
     */
    // Code fragment
    public class Shape {...}

    public class Rectangle extends Shape {...}
    public class Circle extends Shape {...}

    public class Foo {
        public java.util.List<? extends Shape> shapes;
    }
  <!-- XML Schema fragment -->
  <xs:complexType name="shape">
    ...
  </xs:complexType>

  <xs:complexType name="circle">
    <xs:complexContent>
      <xs:extension base="shape">
        ...
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>

  <xs:complexType name="rectangle">
    <xs:complexContent>
      <xs:extension base="shape">
        ...
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>

  <xs:complexType name="foo">
    <xs:sequence>
      <xs:element name="shapes" type="shape" nillable="true"
                  maxOccurs="unbounded" minOccurs="0"/>
    </xs:sequence>
  </xs:complexType>
    public enum XmlNsForm {UNQUALIFIED, QUALIFIED, UNSET}

    @Retention(RUNTIME) @Target({})
    public @interface XmlNs {...}

    @Retention(RUNTIME) @Target({PACKAGE})
    public @interface XmlSchema {
        XmlNs[] xmlns() default {};
        String namespace() default "";
        String location() default "";
        XmlNsForm elementFormDefault() default XmlNsForm.UNSET;
        XmlNsForm attributeFormDefault() default XmlNsForm.UNSET;
    }
    @Inherited @Retention(RUNTIME) @Target({PACKAGE, TYPE})
    public @interface XmlAccessorType {
        XmlAccessType value() default XmlAccessType.PUBLIC_MEMBER;
    }

    public enum XmlAccessType { NONE, PROPERTY, FIELD, PUBLIC_MEMBER }
    @Inhertited @Retention(RUNTIME)
    @Target({PACKAGE, TYPE})
    public @interface XmlAccessorOrder {
        XmlAccessOrder value() default XmlAccessOrder.UNDEFINED;
    }

    public enum XmlAccessOrder { UNDEFINED, ALPHABETICAL }
    @Retention(RUNTIME)
    @Target({FIELD, METHOD, PACKAGE})
    public @interface XmlSchemaType {
        String name();
        String namespace() default "http://www.w3.org/2001/XMLSchema";
        Class type() default DEFAULT.class;
        final class DEFAULT {}
    }
    // @XmlSchemaType can specify any one of the eight calendar types
    // that map to XMLGregorianCalendar.
    @XmlSchemaType(name="date")
    XMLGregorianCalendar foo;
    // Example: change the default mapping at package level
    package foo;
    @jakarta.xml.bind.annotation.XmlSchemaType
        (name="date",
         type=javax.xml.datatype.XMLGregorianCalendar.class)
    // XMLGregorianCalendar will be mapped to XML Schema type "date"
    XMLGregorianCalendar cal;
    // Example: Following code maps to a repeating element with
    // XML Schema type of "date".
    List<XMLGregorianCalendar> bar;
    // Maps XMLGregorianCalendar to XML Schema type "date""
    @XmlSchemaType(name="date")
    public XMLGregorianCalendar cal;
    // Example: Following code maps to a repeating element with
    // XML Schema type of "date".
    @XmlSchemaType(name="date")
    List<XMLGregorianCalendar> bar;
    @Retention(RUNTIME) @Target({PACKAGE})
    public @interface XmlSchemaTypes {
        // Collection of @{@link XmlSchemaType} annotations
        XmlSchemaType[] value();
    }
    @Retention(RUNTIME) @Target({TYPE})
    public @interface XmlType {
        String name() default "##default";
        String[] propOrder() default {""};
        String namespace() default "##default";
        Class factoryClass() default DEFAULT.class;
        final class DEFAULT {};
        String factoryMethod() default "";
    }
    @Retention(RUNTIME) @Target({TYPE}
    public @interface XmlRootElement {
        String name() default "##default";
        String namespace() default "##default";
    }
    @Retention(RUNTIME) @Target(TYPE)
    public @interface XmlTransient {}
    @Retention(RUNTIME) @Target(TYPE)
    public @interface XmlRootElement {
        Class[] value();
    }
    @Retention(RUNTIME) @Target({TYPE})
    public @interface XmlEnum {
        // Java type that is mapped to a XML simple type
        Class <?> value() default String.class;
    }
    @Retention(RUNTIME) @Target({FIELD}
    public @interface XmlEnumValue {
        String value();
    }
    @Retention(RUNTIME) @Target({TYPE})
    public @interface XmlType {
        String name() default "##default";
        String namespace() default "##default";
        String[] propOrder() default {""};
        Class factoryClass() default DEFAULT.class;
        final class DEFAULT {};
        String factoryMethod() default "";
    }
     // Example 1:
     // Both the field "x" and property getX/setX are mapped by
     // default. However, the decapitalized name property getX/setX
     // is also "x" which collides with the field name "x".
    public class Foo {
        public int x;
        public int getX {...};
        public void setX {...};
     }
    @Retention(RUNTIME) @Target({FIELD, METHOD}
    public @interface XmlElement {
        String name() default "##default"; // name for XML element
        boolean nillable() default false;
        boolean required() default false;
        String namespace() default "##default";
        Class type() default DEFAULT.class;
        String defaultValue() default "\u0000";
        static final class DEFAULT {}
    }
    // Code fragment
    @XmlRootElement
    @XmlType(name="")
    class Foo {
        Foo foo;
    }
  <schema>
    <element name="foo">
      <complexType>
        <sequence>
          <element name="foo" minOccurs="0">
            <complexType>
              ... infinite recursion ...
  <schema>
    <element name="foo">
      <complexType>
        <sequence>
          <element ref="foo" minOccurs="0">
    @Retention(RUNTIME) @Target({FIELD,METHOD})
    public @interface XmlElements {
        XmlElement[] value(); // collection of @XmlElement annotations
    }
    @Retention(RUNTIME) @Target({FIELD, METHOD}
    public @interface XmlElementRef {
        String name() default "##default"; // name for XML element
        String namespace() default "##default";
        Class type() default DEFAULT.class;
        static final class DEFAULT {}
    }
    @Retention(RUNTIME) @Target({FIELD,METHOD})
    public @interface XmlElementRefs {
        XmlElementRef[] value();
    }
    @Retention(RUNTIME) @Target({FIELD, METHOD}
    public @interface XmlElementWrapper {
        String name() default "##default" ; // name for XML element
        String namespace() default "##default";
        boolean nillable() default false;
        boolean required() default false;
    }
    @Retention(RUNTIME) @Target({FIELD, METHOD})
    public @interface XmlAnyElement {
        boolean lax() default false;
        Class<? extends DomHandler> value() default W3CDomHandler.class;
    }
    @Retention(RUNTIME) @Target({FIELD, METHOD})
    public @interface XmlAttribute {
        String name() default "##default";
        boolean required() default false;
        String namespace() default "##default";
    }
    @XmlAttribute List<Integer> foo; // legal
    @XmlAttribute List<Bar> foo;     // illegal if Bar does not map to a
                                     // schema simple type
    @XmlAttribute int foo;  // legal
    @XmlAttribute Foo foo;  // illegal if Foo does not map to a schema
                            // simple type
  <xs:attribute ref="xml:lang"/>
    @Retention(RUNTIME) @Target({FIELD, METHOD})
    public @interface XmlAnyAttribute{}
    @Retention(RUNTIME) @Target({FIELD, METHOD, TYPE})
    public @interface XmlTransient {}
    @Retention(RUNTIME) @Target({FIELD, METHOD})
    public @interface XmlValue {}
    // Examples (not exhaustive): Legal usage of @XmlValue
    @XmlValue List<Integer> foo; // int maps to xs:int
    @XmlValue String[] foo;      // String maps to xs:string
    @XmlValue List<Bar> foo;     // only if Bar maps to a simple
                                 // schema type
    @Retention(RUNTIME) @Target({FIELD, METHOD})
    public @interface XmlID {}
    @Retention(RUNTIME) @Target({FIELD, METHOD})
    public @interface XmlIDREF {}
    @Retention(RUNTIME) @Target({FIELD, METHOD, PARAMETER})
    public @interface XmlList {}
    // Examples: Legal usage of @XmlList
    @XmlList List<Integer> foo; // int maps to xs:int
    @XmlList String[] foo; // String maps to xs:string
    @XmlList List<Bar> foo; // only if Bar maps to a simple type

    // Example: Illegal usage of @XmlList
    public class Foo {
        // @XmlValue maps List to a XML Schema listsimple type
        @XmlValue List<Integer> a;
    }

    class Bar {
        // Use of @XmlList is illegal since Fooitself mapped
        // to a XML Schema list simple type; XMLSchema list simple
        // type can't derive from another XML Schemalist simple type
        @XmlList List<Foo> y;
    }
    @Retention(RUNTIME) @Target({FIELD, METHOD})
    public @interface XmlMixed {}
    @Retention(RUNTIME)
    @Target({FIELD,METHOD,PARAMETER})
    public @interface XmlMimeType {
        // Textual representation of the MIME type,such as "image/jpeg"
        // "image/*", "text/xml; charset=iso-8859-1"and so on.
        String value();
    }
    @Retention(RUNTIME) @Target({FIELD,METHOD,PARAMETER})
    public @interface XmlAttachmentRef {}
    @Retention(RUNTIME) @Target({FIELD,METHOD,TYPE})
    public @interface XmlInlineBinaryData {
    }
    @Retention(RUNTIME) @Target({METHOD})
    public @interface XmlElementDecl {
        Class scope() default GLOBAL.class;

        // XML namespace of element
        String namespace() default "##default";

        String name(); // local name of element

        //XML namespace name of a substitution group's head element.
        String substitutionHeadNamespace() default "##default";

        //XML local name of a substitution group's head element.
        String substitutionHeadName() default "";
        final class GLOBAL {}
    }
    public abstract class XmlAdapter<ValueType,BoundType> {
        // Do-nothing constructor for the derivedclasses.
        protected XmlAdapter() {}

        // Convert a value type to a bound type.
        public abstract BoundType unmarshal(ValueType v);

        // Convert a bound type to a value type.
        public abstract ValueType marshal(BoundType v);
    }
    @Retention(RUNTIME) @Target({PACKAGE,FIELD,METHOD,TYPE,PARAMETER})
    public @interface XmlJavaTypeAdapter {
        Class<? extends XmlAdapter> value();
        Class type() default DEFAULT.class;
        final class DEFAULT {}
    }
    // Adapts Foo type to MyFoo type
    FooAdapter extends XmlAdapter<MyFoo, Foo>

    // FooAdapter is installed at the package level - example.po
    @XmlJavaTypeAdapter(value=FooAdapter.class, type=Foo.class)
    // Foo will be adapted to MyFoo
    Foo foo;
    // List<Foo> will be adapted to List<MyFoo>
    Foo foo;
    // Adapts Foo type to MyFoo type
    FooAdapter extends XmlAdapter<MyFoo, Foo>

    // FooAdapter is specified on class, interface or enum type.
    @XmlJavaTypeAdapter(FooAdapter.class)
    public class Foo {...}
    // Foo will be adapted to MyFoo
    Foo foo;
    // List<Foo> will be adapted to List<MyFoo>
    List<Foo> foo;
    //Example:
    @XmlJavaTypeAdapter(...) public class Foo {...}
    ...
    public class DerivedFoo extends Foo {...}
    ...
    public class Bar {
        // XmlJavaTypeAdapter applies to foo;
        public Foo foo;
        ...
        // XmlJavaTypeAdaper DOES NOT apply to derivedFoo;
        public DerivedFoo derivedFoo;
    }
    // Foo will be adapted to MyFoo
    @XmlJavaTypeAdapter(FooAdapter.class) Foo foo;
    // List<Foo> will be adapted to List<MyFoo>
    List<Foo> foo;
    // PtoQAdapter is applied first and therefore converts type Q to P
    // Next foo is mapped with a type of P (not Q) subject to the
    // mapping constraints specified in@XmlElements.
    @XmlJavaTypeAdapter(PtoQAdapter)
    @XmlElements({
        @XmlElement(name="x",type=PX.class),
        @XmlElement(name="y",type=PY.class)
    })
    Q foo;

    @XmlType abstract class P {}
    @XmlType class PX extends P {}
    @XmlType class PY extends P {}
    //Example: code fragment
    @XmlJavaTypeAdapter(...) BaseClass {...}
    public SubClass extends BaseClass {...}
    public BaseClass foo;
    public SubClass subFoo = new SubClass();
    foo = subFoo;
    <foo xsi:type="subClass"/>
    // Example: Code fragment
    BaseClass {...}
    ...
    @XmlJavaTypeAdapter(...) SubClass extends BaseClass {...}

    public class Bar {
        public BaseClass foo;
        public SubClass subFoo = new SubClass();

        // marshal, unmarshal of foo will fail
        foo = subFoo;

        // marshal, unmarshal of subFoo will succeed
    }
    @Retention(RUNTIME) @Target({PACKAGE})
    public @interface XmlJavaTypeAdapters {
        // Collection of @{@link XmlJavaTypeAdapter}annotations
        XmlJavaTypeAdapter[] value();
    }
  <!-- Default XML Schema mapping for Map<K,V> -->
  <xs:complexType>
    <xs:sequence>
      <xs:element name="entry"
                  minOccurs ="0" maxOccurs="unbounded">
        <xs:complexType>
          <xs:sequence>
            <xs:element name="key" type="xs:anyType"
                        minOccurs="0"/>
            <xs:element name="value" type="xs:anyType"
                        minOccurs="0"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>
    </xs:sequence>
  </xs:complexType>

  <!-- Default XML Schema mapping for Map<String, Integer> -->
  <xs:complexType>
    <xs:sequence>
      <xs:element name="entry"
                  minOccurs="0" maxOccurs="unbounded">
        <xs:complexType>
          <xs:sequence>
            <xs:element name="key" type="xs:string"
                        minOccurs="0"/>
            <xs:element name="value" type="xs:int"
                        minOccurs="0"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>
    </xs:sequence>
  </xs:complexType>
    <xs:element name="item"
                type=schematype minOccurs="0"
                maxOccurs="unbounded" nillable="true"/>
    // Code fragment
    public class USStateList {
        @XmlValue List <int> items;
    }
    <xs:simpleType name="USStateList">
      <xs:list itemType="int"/>
    </xs:simpleType>
    jakarta.xml.bind.Unmarshaller.unmarshal(...)
    jakarta.xml.bind.Binder.unmarshal(...)
    jakarta.xml.bind.Unmarshaller.unmarshal(..., java.lang.Class<T> declaredType)
    jakarta.xml.bind.Binder.unmashal(..., java.lang.Class<T> declaredType)
    public class ObjectFactory {
        @XmlElementDecl(...)
        public JAXBElement<T> createFoo(T elementValue);
        ...
     }
    @XmlRootElement(...)
    public class Foo {...}
    @XmlElementDecl(name = "bar", namespace = "")
    public JAXBElement<Foo> createBar(Foo value) {
        return new JAXBElement<Foo>(
            _Bar_QNAME, ((Class) Foo.class), null, value);
    }
    @XmlRootElement(...)
    public class Foo {...}
    <unknownElement xsi:type="PurchaseOrder"/>
boundType = @XmlJavaTypeAdapter.value().unmarshal(valueType)
EII.boundtype = @XmlJavaTypeAdapter.value().unmarshal(EII.valuetype)
EII.boundtype = EII.valuetype
AII.boundtype = @XmlJavaTypeAdapter.value().unmarshal(AII.valuetype)
AII.boundtype = AII.valuetype
  <!-- local element with simple type -->
  <xs:element name="foo" type="xs:int"/>

  <!-- complex type for substituting the simple type -->
  <xs:complexType name="MyInt">
    <xs:extension xs:int>
    ...add attributes
    </xs:extends>
  </xs:complexType>
    public int getFoo();
    public void setFoo(int);
    public class MyInt {...}
  <foo xsi:type="MyInt"/>
  <!-- Example: XML Schema fragment -->
  <xs:element name="foo" type="xs:int"/>
  <!-- Example: XML instance.
       Data is not parseable into type xs:int;
       however unmarshal will still succeed. -->
  <foo> SUN </foo>
    Marshaller.marshal(Object jaxbElement, ...) throws JAXBException;
    Binder.marshal(Object jaxbObject, ...) throws JAXBException;
  <foo xsi:nil attr1="1"/>
  <foo xsi:type="MyAddrType"/>
  valueType = @XmlJavaTypeAdapter.value().marshal(boundType)
  <foo xsi:type="MyAddrType"/>
    @XmlElement(required="...", nillable="...")
    foo;
  <!-- Example: Generated schema -->
  <xs:element name="foo" minOccurs="1" ...>
    ...
  </xs:element>
  <!-- Example: Generated schema -->
  <xs:element name="foo" minOccurs="1" nillable="true" ...>
    ...
  </xs:element>

  <!-- marshalled XML representation for null value -->
  <foo xsi:nil="true" .../>
  <!-- Example: Generated schema -->
  <xs:element name="foo" minOccurs="0" ...>
    ...
  </xs:element>

  <!-- Example: marshalled XML representation for null value -->
  <foo xsi:nil="true" .../>
  <!-- Example: Generated schema -->
  <xs:element name="foo" minOccurs="0" ...>
    ...
  </xs:element>

  <!-- Example: null value for foo not marshalled -->
    public java.util.List getFoo();
    // public void setFoo(..) not required
<xs:schema
   targetNamespace = "https://jakarta.ee/xml/ns/jaxb"
   xmlns:jaxb = "https://jakarta.ee/xml/ns/jaxb"
   xmlns:xs = "http://www.w3.org/2001/XMLSchema"
   elementFormDefault = "qualified"
   attributeFormDefault = "unqualified">
  <xs:annotation>
    <xs:documentation>
      This is the XML Schema for the Jakarta XML Binding binding
      customization descriptor.
      All binding customization descriptors must indicate
      the descriptor schema by using the Jakarta XML Binding namespace:

      https://jakarta.ee/xml/ns/jaxb

      and by indicating the version of the schema by
      using the version element as shown below:

        <bindings xmlns="https://jakarta.ee/xml/ns/jaxb"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="https://jakarta.ee/xml/ns/jaxb
              https://jakarta.ee/xml/ns/jaxb/bindingschema_3_0.xsd"
          version="3.0">
          ...
        </bindings>

      The instance documents may indicate the published version of
      the schema using the xsi:schemaLocation attribute for Jakarta XML Binding
      namespace with the following location:

      https://jakarta.ee/xml/ns/jaxb/bindingschema_3_0.xsd
    </xs:documentation>
  </xs:annotation>
  <xs:group name = "declaration">
    <xs:annotation>
      <xs:documentation>
        Model group that represents a binding declaration. Each new binding
        declaration added to the jaxb namespace that is not restricted to
        globalBindings should be added as a child element to this model group.
      </xs:documentation>
    </xs:annotation>
    <xs:choice>
      <xs:element ref = "jaxb:globalBindings"/>
      <xs:element ref = "jaxb:schemaBindings"/>
      <xs:element ref = "jaxb:class"/>
      <xs:element ref = "jaxb:property"/>
      <xs:element ref = "jaxb:typesafeEnumClass"/>
      <xs:element ref = "jaxb:typesafeEnumMember"/>
      <xs:element ref = "jaxb:javaType"/>
      <xs:element ref = "jaxb:dom"/>
      <xs:element ref = "jaxb:inlineBinaryData"/>
      <xs:any namespace = "##other" processContents = "lax"/>
    </xs:choice>
  </xs:group>
  <xs:attribute name = "version" type="xs:token" >
    <xs:annotation>
      <xs:documentation>
        Used to specify the version of the binding schema on the schema element for
        inline annotations or jaxb:bindings for external binding.
      </xs:documentation>
    </xs:annotation>
  </xs:attribute>
  <xs:attributeGroup name = "propertyAttributes">
      <xs:annotation><xs:documentation>
        Attributes used for property customization. The attribute group can be
        referenced either from the globalBindings declaration or from the
        property declaration. The following defaults are defined by the JAXB
        specification in global scope only. Thus they apply when the
        propertyAttributes group is referenced from the globalBindings declaration
        but not when referenced from the property declaration.
          collectionType            a class that implements java.util.List.
          fixedAttributeAsConstantProperty  false
          enableFailFastCheck        false
          generateIsSetMethod        false
          optionalProperty           wrapper
          generateElementProperty    false
          attachmentRef              default
      </xs:documentation></xs:annotation>
    <xs:attribute name = "collectionType" type="jaxb:referenceCollectionType"/>
    <xs:attribute name = "fixedAttributeAsConstantProperty" type = "xs:boolean"/>
    <xs:attribute name = "enableFailFastCheck" type = "xs:boolean"/>
    <xs:attribute name = "generateIsSetMethod" type = "xs:boolean"/>
    <xs:attribute name = "optionalProperty">
      <xs:simpleType>
        <xs:restriction base="xs:NCName">
          <xs:enumeration value="wrapper"/>
          <xs:enumeration value="primitive"/>
          <xs:enumeration value="isSet"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
    <xs:attribute name = "generateElementProperty" type="xs:boolean"/>
    <xs:attribute name = "attachmentRef">
      <xs:simpleType>
        <xs:restriction base="xs:NCName">
          <xs:enumeration value="resolve"/>
          <xs:enumeration value="doNotResolve"/>
          <xs:enumeration value="default"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
  </xs:attributeGroup>
  <xs:attributeGroup name = "XMLNameToJavaIdMappingDefaults">
    <xs:annotation>
      <xs:documentation>Customize XMLNames to Java id mapping
      </xs:documentation>
    </xs:annotation>
    <xs:attribute name = "underscoreBinding" default = "asWordSeparator" type = "jaxb:underscoreBindingType"/>
  </xs:attributeGroup>
  <xs:attributeGroup name = "typesafeEnumClassDefaults">
    <xs:attribute name = "typesafeEnumMemberName" default = "skipGeneration" type = "jaxb:typesafeEnumMemberNameType"/>
    <xs:attribute name = "typesafeEnumBase" default = "xs:string" type = "jaxb:typesafeEnumBaseType"/>
    <xs:attribute name = "typesafeEnumMaxMembers" type="xs:int" default="256"/>
  </xs:attributeGroup>
  <xs:element name = "globalBindings">
    <xs:annotation>
      <xs:documentation>Customization values defined in global scope.</xs:documentation>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence minOccurs = "0">
        <xs:element ref = "jaxb:javaType" minOccurs = "0" maxOccurs = "unbounded"/>
        <xs:element ref = "jaxb:serializable" minOccurs = "0"/>
        <xs:any namespace = "##other" processContents = "lax">
          <xs:annotation>
            <xs:documentation>allows extension binding declarations to be specified.</xs:documentation>
          </xs:annotation>
        </xs:any>
      </xs:sequence>
      <xs:attributeGroup ref = "jaxb:XMLNameToJavaIdMappingDefaults"/>
      <xs:attributeGroup ref = "jaxb:typesafeEnumClassDefaults"/>
      <xs:attributeGroup ref = "jaxb:propertyAttributes"/>
      <xs:attribute name="generateValueClass" type="xs:boolean"
                    default= "true"/>
      <xs:attribute name="generateElementClass" type="xs:boolean"
                    default= "false"/>
      <xs:attribute name="mapSimpleTypeDef" type="xs:boolean"
                    default= "false"/>
      <xs:attribute name="localScoping" default= "nested">
        <xs:simpleType>
          <xs:restriction base="xs:NCName">
            <xs:enumeration value="nested"/>
            <xs:enumeration value="toplevel"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:attribute>
      <xs:attribute name = "enableJavaNamingConventions" default = "true" type = "xs:boolean"/>
      <xs:attribute name = "choiceContentProperty" default = "false" type = "xs:boolean"/>
    </xs:complexType>
  </xs:element>
  <xs:element name = "schemaBindings">
    <xs:annotation>
      <xs:documentation>Customization values with schema scope</xs:documentation>
    </xs:annotation>
    <xs:complexType>
      <xs:all>
        <xs:element name = "package" type = "jaxb:packageType" minOccurs = "0"/>
        <xs:element name = "nameXmlTransform" type = "jaxb:nameXmlTransformType" minOccurs = "0"/>
      </xs:all>
    </xs:complexType>
  </xs:element>
  <xs:element name = "class">
    <xs:annotation>
      <xs:documentation>Customize interface and implementation class.</xs:documentation>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element name = "javadoc" type = "xs:string" minOccurs = "0"/>
      </xs:sequence>
      <xs:attribute name = "name" type = "jaxb:javaIdentifierType">
        <xs:annotation>
          <xs:documentation>Java class name without package prefix.</xs:documentation>
        </xs:annotation>
      </xs:attribute>
      <xs:attribute name = "implClass" type = "jaxb:javaIdentifierType">
        <xs:annotation>
          <xs:documentation>Implementation class name including package prefix.</xs:documentation>
        </xs:annotation>
      </xs:attribute>
      <xs:attribute name="generateValueClass" type="xs:boolean">
        <xs:annotation>
          <xs:documentation>Default value derived from [jaxb:globalBindings]@generateValueClass.</xs:documentation>
        </xs:annotation>
      </xs:attribute>
    </xs:complexType>
  </xs:element>
  <xs:element name = "property">
    <xs:annotation>
      <xs:documentation>Customize property.</xs:documentation>
    </xs:annotation>
    <xs:complexType>
      <xs:all>
        <xs:element name = "javadoc" type = "xs:string" minOccurs="0"/>
        <xs:element name = "baseType" type="jaxb:propertyBaseType" minOccurs="0"/>
      </xs:all>
      <xs:attribute name = "name" type = "jaxb:javaIdentifierType"/>
      <xs:attributeGroup ref = "jaxb:propertyAttributes"/>
    </xs:complexType>
  </xs:element>
  <xs:element name = "javaType">
    <xs:annotation>
      <xs:documentation>Data type conversions; overriding builtins</xs:documentation>
    </xs:annotation>
    <xs:complexType>
      <xs:attribute name = "name" use = "required" type = "jaxb:javaIdentifierType">
        <xs:annotation>
          <xs:documentation>name of the java type to which xml type is to be bound.</xs:documentation>
        </xs:annotation>
      </xs:attribute>
      <xs:attribute name = "xmlType" type = "xs:QName">
        <xs:annotation>
          <xs:documentation> xml type to which java datatype has to be bound.Must be present when javaType is scoped to globalBindings</xs:documentation>
        </xs:annotation>
      </xs:attribute>
      <xs:attribute name = "parseMethod" type = "jaxb:javaIdentifierType"/>
      <xs:attribute name = "printMethod" type = "jaxb:javaIdentifierType"/>
      <xs:attribute name = "hasNsContext" default = "false" type = "xs:boolean" >
        <xs:annotation>
          <xs:documentation>
            If true, the parsMethod and printMethod must reference a method
            signtature that has a second parameter of type NamespaceContext.
          </xs:documentation>
        </xs:annotation>
      </xs:attribute>
    </xs:complexType>
  </xs:element>
  <xs:element name = "typesafeEnumClass">
    <xs:annotation>
      <xs:documentation> Bind to a type safe enumeration class.</xs:documentation>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element name = "javadoc" type = "xs:string" minOccurs = "0"/>
        <xs:element ref = "jaxb:typesafeEnumMember" minOccurs = "0" maxOccurs = "unbounded"/>
      </xs:sequence>
      <xs:attribute name = "name" type = "jaxb:javaIdentifierType"/>
      <xs:attribute name = "map" type = "xs:boolean" default = "true"/>
    </xs:complexType>
  </xs:element>
  <xs:element name = "typesafeEnumMember">
    <xs:annotation>
      <xs:documentation> Enumeration member name in a type safe enumeration class.</xs:documentation>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element name = "javadoc" type = "xs:string" minOccurs = "0"/>
      </xs:sequence>
      <xs:attribute name = "value" type="xs:anySimpleType"/>
      <xs:attribute name = "name" use = "required" type = "jaxb:javaIdentifierType"/>
    </xs:complexType>
  </xs:element>

  <!-- TYPE DEFINITIONS -->

  <xs:complexType name = "propertyBaseType">
    <xs:all>
      <xs:element ref = "jaxb:javaType" minOccurs = "0"/>
    </xs:all>
    <xs:attribute name = "name" type = "jaxb:javaIdentifierType">
      <xs:annotation>
        <xs:documentation>
          The name attribute for [baseType] enables more precise control over the actual base type for a JAXB property. This customization enables specifying a more general base type than the property's default base type. The name attribute value must be a fully qualified Java class name. Additionally, this Java class must be a super interface/class of the default Java base type for the property. When the default base type is a primitive type, consider the default Java base type to be the Java wrapper class of that primitive type.This customization is useful to enable simple type substitution for a JAXB property representing with too restrictive of a default base type.
        </xs:documentation>
      </xs:annotation>
    </xs:attribute>
  </xs:complexType>

  <xs:complexType name = "packageType">
    <xs:sequence>
      <xs:element name = "javadoc" type = "xs:string" minOccurs = "0"/>
    </xs:sequence>
    <xs:attribute name = "name" type = "jaxb:javaIdentifierType"/>
  </xs:complexType>
  <xs:simpleType name = "underscoreBindingType">
    <xs:annotation>
      <xs:documentation>Treate underscore  in XML Name to Java identifier mapping.</xs:documentation>
    </xs:annotation>
    <xs:restriction base = "xs:string">
      <xs:enumeration value = "asWordSeparator"/>
      <xs:enumeration value = "asCharInWord"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name = "typesafeEnumBaseType">
    <xs:annotation>
      <xs:documentation>
        XML types or types derived from them which have enumeration facet(s)
        which are be mapped to typesafeEnumClass by default.
        The following types cannot be specified in this list:
         "xsd:QName", "xsd:base64Binary", "xsd:hexBinary",
         "xsd:date", "xsd:time", "xsd:dateTime", "xsd:duration",
         "xsd:gDay", "xsd:gMonth", "xsd:Year", "xsd:gMonthDay", "xsd:YearMonth"
      </xs:documentation>
    </xs:annotation>
    <xs:list itemType = "xs:QName"/>
  </xs:simpleType>
  <xs:simpleType name = "typesafeEnumMemberNameType">
    <xs:annotation>
      <xs:documentation>Used to customize how to handle name collisions.</xs:documentation>
    </xs:annotation>
    <xs:restriction base = "xs:string">
      <xs:enumeration value = "generateName"/>
      <xs:enumeration value = "generateError"/>
      <xs:enumeration value = "skipGeneration"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name = "javaIdentifierType">
    <xs:annotation>
      <xs:documentation>Placeholder type to indicate Legal Java identifier.</xs:documentation>
    </xs:annotation>
    <xs:list itemType = "xs:NCName"/>
  </xs:simpleType>
  <xs:complexType name = "nameXmlTransformRule">
    <xs:annotation>
      <xs:documentation>Rule to transform an Xml name into another Xml name</xs:documentation>
    </xs:annotation>
    <xs:attribute name = "prefix" type = "xs:string">
      <xs:annotation>
        <xs:documentation>prepend the string to QName.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name = "suffix" type = "xs:string">
      <xs:annotation>
        <xs:documentation>Append the string to QName.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
  </xs:complexType>
  <xs:complexType name = "nameXmlTransformType">
    <xs:annotation>
      <xs:documentation>Allows transforming an xml name into another xml name. Use case UDDI 2.0 schema.</xs:documentation>
    </xs:annotation>
    <xs:all>
      <xs:element name = "typeName" type = "jaxb:nameXmlTransformRule" minOccurs = "0">
        <xs:annotation>
          <xs:documentation>Mapping rule for type definitions.</xs:documentation>
        </xs:annotation>
      </xs:element>
      <xs:element name = "elementName" type = "jaxb:nameXmlTransformRule" minOccurs = "0">
        <xs:annotation>
          <xs:documentation>Mapping rule for elements</xs:documentation>
        </xs:annotation>
      </xs:element>
      <xs:element name = "modelGroupName" type = "jaxb:nameXmlTransformRule" minOccurs = "0">
        <xs:annotation>
          <xs:documentation>Mapping rule  for model group</xs:documentation>
        </xs:annotation>
      </xs:element>
      <xs:element name = "anonymousTypeName" type = "jaxb:nameXmlTransformRule" minOccurs = "0">
        <xs:annotation>
          <xs:documentation>Mapping rule for class names generated for an anonymous type.</xs:documentation>
        </xs:annotation>
      </xs:element>
    </xs:all>
  </xs:complexType>
  <xs:attribute name = "extensionBindingPrefixes">
    <xs:annotation>
      <xs:documentation>
        A binding compiler only processes this attribute when it occurs on an
        an instance of xs:schema element.  The value of this attribute is a
        whitespace-separated list of namespace prefixes.  The namespace bound
        to each of the prefixes is designated as a customization declaration
        namespace.
      </xs:documentation>
    </xs:annotation>
    <xs:simpleType>
      <xs:list itemType = "xs:normalizedString"/>
    </xs:simpleType>
  </xs:attribute>
  <xs:element name = "bindings">
    <xs:annotation>
      <xs:documentation>
        Binding declaration(s) for a remote schema.
        If attribute node is set, the binding declaraions
        are associated with part of the remote schema
        designated by schemaLocation attribute. The node
        attribute identifies the node in the remote schema
        to associate the binding declaration(s) with.
      </xs:documentation>
    </xs:annotation>
    <!-- a <bindings> element can contain arbitrary number of binding declarations or nested <bindings> elements -->
    <xs:complexType>
      <xs:sequence>
        <xs:choice minOccurs = "0" maxOccurs = "unbounded">
          <xs:group ref = "jaxb:declaration"/>
          <xs:element ref = "jaxb:bindings"/>
        </xs:choice>
      </xs:sequence>
      <xs:attribute name = "schemaLocation" type = "xs:anyURI">
        <xs:annotation>
          <xs:documentation>
            Location of the remote schema to associate binding declarations with.
          </xs:documentation>
        </xs:annotation>
      </xs:attribute>
      <xs:attribute name = "node" type = "xs:string">
        <xs:annotation>
          <xs:documentation>
            The value of the string is an XPATH 1.0 compliant string that
            resolves to a node in a remote schema to associate
            binding declarations with. The remote schema is specified
            by the schemaLocation attribute occuring in the current
            element or in a parent of this element.
          </xs:documentation>
        </xs:annotation>
      </xs:attribute>
      <xs:attribute name = "version" type = "xs:token">
        <xs:annotation>
          <xs:documentation>
            Used to indicate the version of binding declarations. Only valid on root level bindings element.
            Either this or "jaxb:version" attribute but not both may be specified.
          </xs:documentation>
        </xs:annotation>
      </xs:attribute>
      <xs:attribute ref = "jaxb:version">
        <xs:annotation>
          <xs:documentation>
            Used to indicate the version of binding declarations. Only valid on root level bindings element.
            Either this attribute or "version" attribute but not both may be specified.
          </xs:documentation>
        </xs:annotation>
      </xs:attribute>
    </xs:complexType>
  </xs:element>
  <xs:simpleType name="referenceCollectionType">
    <xs:union>
      <xs:simpleType>
        <xs:restriction base="xs:string">
          <xs:enumeration value="indexed"/>
        </xs:restriction>
      </xs:simpleType>
      <xs:simpleType>
        <xs:restriction base="jaxb:javaIdentifierType"/>
      </xs:simpleType>
    </xs:union>
  </xs:simpleType>
  <xs:element name="dom">
    <xs:complexType>
      <xs:attribute name = "type" type="xs:NCName" default="w3c">
        <xs:annotation>
          <xs:documentation>Specify DOM API to bind to JAXB property to.</xs:documentation>
        </xs:annotation>
      </xs:attribute>
    </xs:complexType>
  </xs:element>
  <xs:element name="inlineBinaryData">
    <xs:annotation>
      <xs:documentation>
        Disable MTOM/XOP encoding for this binary data. Annotation can be placed on a type definition that
        derives from a W3C XSD binary data type or on an element that has a type that is
        or derives from a W3C XSD binary data type.
      </xs:documentation>
    </xs:annotation>
  </xs:element>
  <xs:element name = "serializable">
    <xs:complexType>
      <xs:attribute name="uid" type="xs:long" default="1"/>
    </xs:complexType>
  </xs:element>
</xs:schema>
  <xs:choice>
    <xs:sequence>
      <xs:element ref="A"/>
      <xs:any processContents="strict"/>
    </xs:sequence>
    <xs:element ref="C"/>
  </xs:choice>
//www.acme.com/go/espeak.xsd
//www.acme.com/go/espeak
{"www.acme.com", "go", "espeak"}
{"www.acme.com", "go", "espeak"}
{"com", "acme", "go", "espeak"}
{"com", "acme", "go", "espeak"}
{"com", "acme", "go", "espeak"}
Final package name: "com.acme.go.espeak".
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
           xmlns:ens="http://example.com/ns"
           targetNamespace="http://example.com/ns">
  <xs:complexType name="aType">
    <xs:sequence>
      <xs:element name="foo" type="xs:int"/>
    </xs:sequence>
    <xs:attribute name="bar" type="xs:int"/>
  </xs:complexType>
  <xs:element name="root" type="ens:aType"/>
</xs:schema>
<jaxb:bindings xmlns:jaxb="https://jakarta.ee/xml/ns/jaxb"
               xmlns:xs="http://www.w3.org/2001/XMLSchema"
               version="3.0">
  <jaxb:bindings schemaLocation="A.xsd">
    <jaxb:bindings node="//xs:complexType[@name=’aType’]">
      <jaxb:class name="customNameType"/>
      <jaxb:bindings node=".//xs:element[@name=’foo’]">
        <jaxb:property name="customFoo"/>
      </jaxb:bindings>
      <jaxb:bindings node="./xs:attribute[@name=’bar’]">
        <jaxb:property name="customBar"/>
      </jaxb:bindings>
     </jaxb:bindings>
   </jaxb:bindings>
</jaxb:bindings>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
           xmlns:ens="http://example.com/ns"
           targetNamespace="http://example.com/ns"
           xmlns:jaxb="https://jakarta.ee/xml/ns/jaxb"
           jaxb:version="3.0">
  <xs:complexType name="aType">
    <xs:annotation>
      <xs:appinfo>
        <jaxb:class name="customNameType"/>
      </xs:appinfo>
    </xs:annotation>
    <xs:sequence>
      <xs:element name="foo" type="xs:int">
        <xs:annotation>
          <xs:appinfo>
            <jaxb:property name="customFoo"/>
          </xs:appinfo>
        </xs:annotation>
      </xs:element>
    </xs:sequence>
    <xs:attribute name="bar" type="xs:int">
      <xs:annotation>
        <xs:appinfo>
          <jaxb:property name="customBar"/>
        </xs:appinfo>
      </xs:annotation>
    </xs:attribute>
  </xs:complexType>
  <xs:element name="root" type="ens:aType"/>
</xs:schema>
  <?xml version="1.0" ?>
  <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
             xmlns:tns="http://example.com/know-type"
             xmlns:xmime="http://www.w3.org/2005/05/xmlmime"
             targetNamespace="http://example.com/know-type">
    <xs:import namespace="http://www.w3.org/2005/05/xmlmime"
               schemaLocation="http://www.w3.org/2005/05/xmlmime"/>
    <xs:element name="JPEGPicture"
                type="xs:base64binary"
                xmime:expectedContentTypes="image/jpeg"/>
  </xs:schema>
    import java.awt.Image;
    @XmlRegistry
    class ObjectFactory {
        @XmlElementDecl(...)
        @XmlMimeType("image/jpeg")
        JAXBELement<Image> createJPEGPicture(Image value);
    }
  <?xml version="1.0" ?>
  <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
             xmlns:tns="http://example.com/know-type"
             xmlns:xmime="http://www.w3.org/2005/05/xmlmime"
             targetNamespace="http://example.com/know-type">
    <xs:import namespace="http://www.w3.org/2005/05/xmlmime"
               schemaLocation="http://www.w3.org/2005/05/xmlmime"/>
    <xs:complexType name="Item">
      <xs:sequence>
        <xs:element name="JPEGPicture"
                    type="xs:base64Binary"
                    xmime:expectedContentTypes="image/jpeg"/>
      </xs:sequence>
    </xs:complexType>
  </xs:schema>
    import java.awt.Image;
    public class Item {
        @XmlMimeType("image/jpeg")
        Image getJPEGPicture();
        void setJPEGPicture(Image value);
    }
    public abstract class AttachmentUnmarshaller {
    public boolean isXOPPackage();
    public abstract DataHandler getAttachmentAsDataHandler(String cid);
    public abstract byte[] getAttachmentAsByteArray(String cid);
    }
    public abstract class AttachmentMarshaller {
    public boolean isXOPPackage();
    public abstract String addMtomAttachment(
                        DataHandler data,
                        String elementNamespace,
                        String elementLocalName);
    public abstract String addMtomAttachment(
                        byte[] data,
                        String elementNamespace,
                        String elementLocalName);
    public abstract String addSwaRefAttachment(DataHandler data);
    }

XML Schema Datatype	Java Datatype
xsd:string	java.lang.String
xsd:integer	java.math.BigInteger
xsd:int	int
xsd:long	long
xsd:short	short
xsd:decimal	java.math.BigDecimal
xsd:float	float
xsd:double	double
xsd:boolean	boolean
xsd:byte	byte
xsd:QName	javax.xml.namespace.QName ^[15]
xsd:dateTime	javax.xml.datatype.XMLGregorianCalendar ^[15]
xsd:base64Binary	byte[]
xsd:hexBinary	byte[]
xsd:unsignedInt	long
xsd:unsignedShort	int
xsd:unsignedByte	short
xsd:time	javax.xml.datatype.XMLGregorianCalendar ^[15]
xsd:date	javax.xml.datatype.XMLGregorianCalendar ^[15]
xsd:g*	javax.xml.datatype.XMLGregorianCalendar ^[15]
xsd:anySimpleType (for xsd:element of this type)^[16]	java.lang.Object
xsd:anySimpleType (for xsd:attribute of this type)	java.lang.String
xsd:duration	javax.xml.datatype.Duration ^[15]
xsd:NOTATION	javax.xml.namespace.QName ^[15]

@XmlEnum element	@XmlEnum value
name	simple type definition’s {name}
namespace	{target namespace}
value	the java type binding of the simple type definition’s {base type definition}

@XmlType element	@XmlType value
name	complex type definition’s {name}
namespace	{target namespace}
propOrder a	When \{content type} is element-only {content model} and top-level {compositor} is xs:sequence, ordered list of JAXB property names representing order of xs:elements in {content model}. All other cases do not need to set propOrder.

@XmlElementDecl element	@XmlElementDecl value
name	element declaration’s {name}
namespace	{target namespace}
scope	If {scope} is global, `JAXBElement.GlobalScope.class` else the JAXB Java value class representing the {scope}ing complex type definition.
substitutionHeadName	If optional {substitution group affiliation} exists, its local name.
substitutionHeadNamespace	If optional {substitution group affiliation} exists, its namespace.

@XmlRootElement element	@XmlRootElement value
namespace	When element declaration {target namespace} is absent, (i.e. unqualified local element declaration), @XmlElement.namespace() is not set. Otherwise, set @XmlElement.namespace() to value of {target namespace}. (either a qualified local element declaration or a reference to a global element) Note: same result could be achieved with package level annotation of @XmlSchema and not setting @XmlElement.namespace.
name	element declaration {name}

document xsi:type	Product.name value	Product.price value	Product.price type
	hotdog	3	int
xs:short	peanuts	4	int
AppInt	popcorn	5	int
AmountType	sushi	500	int

document xsi:type	Product.name value	Product. price value	Product. price Java type	Marshal Product. price xsi:type
	hotdog	3	Integer
xs:short	peanuts	4	Short	xs:short
AppInt	popcorn	5	AppInt	AppInt
AmountType	sushi	{value=500, currency=”yen”}	AmountType	AmountType

@XmlElementRef element	@XmlElementRef value
value	jakarta.xml.bind.JAXBElement.class
namespace	referenced element declaration {target namespace}
name	referenced element declaration {name}

@XmlAttribute element	@XmlAttribute value
name	attribute declaration’s {name}
namespace	if attribute declaration’s {target namespace} absent, set to “” otherwise, set to {target namespace}
required	attribute use’s {required}

@XmlAnyElement element	@XmlAnyElement element value
lax	If wildcard schema component’s {process contents} is `lax` or `strict_`, set `@XmlAnyElement.lax()` to `true`. else if {process contents} is `skip`, set `@XmlAnyElement.lax()` to `false`.
value	`jakarta.xml.bind.annotation.W3CDomHandler.class`

@Generated element	@Generated element value
value	fully qualified class name of schema compiler
date	date of generation of schema-derived class. Value must follow the ISO 8601 standard.
comment	optional. Is implementation specific.

XML Schema	Java Representation
Schema targetNamespace	Package
Global Element Declaration with named type definition	ObjectFactory.elementInstanceFactory method returning JAXBElement<T> Value must follow the ISO 8601 standard.
Global Complex Type Definition (Named)	value class/class + ObjectFactory.typeInstanceFactory method
Global Simple Type Definition derive base of string has @enum facet(s)	enum type
SimpleType facets	ConstraintPredicate
Attribute Uses Local Element Declaration	Property
facet @maxOccurs > 1 xsd:list	PropertyStyle List
@fixedPropertyStyle	Constant
Global Element Declaration with anonymous type definition	value class for anonymous type + ObjectFactory.typeInstanceFactory + ObjectFactory.elementInstanceFactory method
Element reference to SubstitutionGroup Head maxOccurs = “1”	Simple + Element property
Element reference to SubstitutionGroup Head maxOccurs > “1”	List<JAXBElement<T>>

Java Primitive Type	XML data type
boolean	xs:boolean
byte	xs:byte
short	xs:short
int	xs:int
long	xs:long
float	xs:float
double	xs:double

Java Class	XML data type
java.lang.String	xs:string
java.math.BigInteger	xs:integer
java.math.BigDecimal	xs:decimal
java.util.Calendar	xs:dateTim
java.util.Date	xs:dateTime
javax.xml.namespace.QName	xs:QName
java.net.URI	xs:string
javax.xml.datatype.XMLGregorianCalendar	xs:anySimpleType
javax.xml.datatype.Duration	xs:duration
java.lang.Object	xs:anyType
java.awt.Image	xs:base64Binary
jakarta.activation.DataHandler	xs:base64Binary
javax.xml.transform.Source	xs:base64Binary
java.util.UUID	xs:string

`targetNamespace`	if `@XmlSchema.namespace()` is "", then `absent;` otherwise `@XmlSchema.namespace()`
`elementFormDefault`	if the value of @XmlSchema.elementFormDefault() is `@XmlNsForm.UNSET, then `absent;` otherwise, the value of `@XmlSchema.elementFormDefault()`
`attributeFormDefault`	if the value of `@XmlSchema.attributeFormDefault()` is `@XmlNsForm.UNSET`, then `absent;` otherwise, the value of `@XmlSchema.attributeFormDefault()`
`Namespace prefixes`	if `@XmlSchema.xmlns()` is {} then implementation defined; otherwise `@XmlSchema.xmlns()`

`{compositor}`	if `@XmlType.propOrder()` is {} then `xs:all`; otherwise `xs:sequence`. The ordering of particles is: if `@XmlType.propOrder()` is not "", then the order in which properties/fields are listed in `@XmlType.propOrder()`. if `@XmlType.propOrder()` is "" && class is annotated with `@XmlAccessorOrder(XmlAcessOrder.ALPHABETICAL)` or `@XmlAccessorOrder(XmlAccessOrder.ALPHABETICAL)` is specified at the package level and class is not annotated with `@XmlAccessorOrder(XmlAccessOrder.UNDEFINED)`, then alphabetical order as specified in @XmlAccessorOrder. otherwise order is unspecified.
`{particles}`	Set of properties or fields mapped to particles. See `{compositor}` mapping above for ordering of particles.
`{annotation}`	`unspecified`

`{name}`	if `@XmlType.name()` is "", then absent otherwise if `@XmlType.name()` is `##default`, then the XML name derived from the class name as specified in Java Identifier To XML Name otherwise `@XmlType.name()`
`{target namespace}`	if `@XmlType.namespace()` is `##default` && `@XmlType.name()` is "" and class is annotated with `@XmlRootElement`, then the `{target namespace}` as specified in Table 8-7 Mapping: Class to Element Declaration otherwise if `@XmlType.namespace()` is `##default` && `@XmlType.name()` is "" and class is not annotated with `@XmlRootElement`, then the `{target namespace}` of the attribute or element to which the property or field, from where this class is referenced, is mapped. otherwise if `@XmlType.namespace()` is `##default` && `@XmlType.name()` is not "", then the namespace to which the package, in which class is defined, is mapped as specified in Table 8-3 Mapping: Package to XML target namespace otherwise `@XmlType.namespace()`
`{base type definition}`	ur-type definition, `xs:anyType`. NOTE: This is subject to the mapping constraints on XmlType. See Mapping.
`{facets}`	`empty set`
`{fundamental facets}`	derived
`{final}`	`empty set`. A subset of `{extension, list, restriction, union}`.
`{variety}`	Must be mapped as shown below
	atomic `{primitive type definition}`	if property or field type is one of: primitive type wrapper class reference type mapped to a simple atomic type.
	list `{item type definition}`	if the property or field type is one of the following collection types: generic list indexed property single dimensional array @XmlType: List simple type
	union `{member type definitions}`	Not mapped.
`{annotation}`	`unspecified`

`{min occurs}`	if `@XmlElement.required()` is `true`, then `1` otherwise if the property type is a primitive type or a multi dimensional array with a primitive type then `1` otherwise `0`
`{max occurs}`	if the type of the property/field is not a collection type, then `1`; otherwise `unbounded`.
`{term}`	must be mapped as specified in Table 8-14 Mapping: Property/field to Element declaration.

`{name}`	if `@XmlElement.name()` is `"##default"`, then the XML name derived from the property or field name as specified in Java Identifier To XML Name; otherwise `@XmlElement.name()`
`{target namespace}`	if `@XmlElement.namespace()` is `"##default"`, then if the enclosing package has `@XmlSchema` annotation and is `@XmlSchema.elementFormDefault` is `@XmlNsForm.QUALIFIED`, then the namespace of the enclosing class. otherwise "" (which produces unqualified element in the default namespace). otherwise, `@XmlElement.namespace()`
`{type definition}`	Note: The order of type inference below is significant. if `@XmlElement.type()` is not `DEFAULT.class`, then the schema type to which `@XmlElement.type()` is mapped. otherwise if annotated with `@XmlList`, schema type derived by mapping as specified in @XmlList otherwise if annotated with `@XmlValue`, schema type derived by mapping as specified in @XmlValue otherwise if annotated with `@XmlID`, the schema type derived by mapping as specified in @XmlID otherwise if annotated with `@XmlIDREF`, the schema type derived by mapping as specified in @XmlIDREF otherwise if the property or field is a collection type, then the schema type derived by mapping the collection item type. otherwise the schema type to which the type of the property is mapped.
`{scope}`	complex type to which the property’s or the field’s containing class is mapped as specified in @XmlSchema.
`{value constraint}`	if `@XmlElement.defaultValue()` is `"\u0000"` then `absent` otherwise default value with the value `@XmlElement.defaultvalue()`.
`{nillable}`	`@XmlElement.nillable()`
`{identity-constraint definitions}`	`absent`
`{substitution group affiliation}`	`absent`
`{substitution group exclusions}`	{`extension`, `restriction`}
`{disallowed substitution}`	{`extension`, `restriction`, `substitution`}
`{abstract}`	`false`
`{annotation}`	`unspecified`

`{min occurs}`	`0`
`{max occurs}`	`unbounded`
`{term}`	If `{particles}` row in Table 8-16 Mapping: List of types to choice model group of elements results in a single particle, then that single particle. Otherwise mapped as specified in Table 8-16 Mapping: List of types to choice model group of elements

`{compositor}`	`choice`
`{particles}`	set obtained by mapping each `@XmlElement` in `@XmlElements.value()` as specified in Table 8-14 Mapping: Property/field to Element declaration.
`{annotation}`	`unspecified`

`{min occurs}`	if `@XmlElementRef.required()` is `true` ,then `1`; otherwise `0`
`{max occurs}`	`1`
`{term}`	must be mapped as specified in Table 8-18 Mapping: Property/field to Element declaration with ref attribute.

`{name}`	if `@XmlElementRef.type()` is `@XmlElementRef.DEFAULT.class` and the property type is not `jakarta.xml.bind.JAXBElement`, then the XML name `@XmlRootElement.name()` on the type being referenced. otherwise if `@XmlElementRef.type()` is `@XmlElementRef.DEFAULT.class` and the parametric type or the property type (for single valued property) is a `jakarta.xml.bind.JAXBElement`, then the `@XmlElementRef.name()`
`{target namespace}`	if `@XmlElementRef.type()` is `@XmlElementRef.DEFAULT.class` and the property type is not `jakarta.xml.bind.JAXBElement`, then the XML namespace of the type being referenced. otherwise if `@XmlElementRef.type()` is `@XmlElementRef.DEFAULT.class` and the property type is single valued and is `jakarta.xml.bind.JAXBElement`, then the `@XmlElementRef.namespace()`
`{annotation}`	`unspecified`

`{min occurs}`	if `@XmlElementWrapper.nillable()` is `true` or `@XmlElementWrapper.required()` is `true`, then `1`; otherwise `0`
`{max occurs}`	`1`
`{term}`	must be mapped as specified in Table 8-24 Mapping: Property/field to Element Declaration for Element Wrapper.

`{name}`	if `@XmlElementWrapper.name()` is `"##default"`, then the XML name derived from the property or field name as specified in Java Identifier To XML Name; otherwise `@XmlElementWrapper.name()`
`{target namespace}`	if `@XmlElementWrapper.namespace()` is `"##default"`, if the enclosing package has `@XmlSchema` annotation and is `@XmlSchema.elementFormDefault` is `@XmlNsForm.QUALIFIED`, then the namespace of the enclosing class. otherwise "" (which produces unqualified element in the default namespace). otherwise `@XmlElementWrapper.namespace()`
`{type definition}`	if property/field is annotated with `@XmlElementRef` or `@XmlElementRefs` then the schema type as specified in Table 8-21 Mapping: List of element instances to choice particle otherwise if property/field is annotated with `@XmlElement` or `@XmlElements` then the schema type as specified Table 8-15 Mapping: List of types to choice particle.
`{scope}`	complex type to which the property’s or the field’s containing class is mapped.
`{value constraint}`	`absent`
`{nillable}`	`@XmlElementWrapper.nillable()`
`{identity-constraint definitions}`	`absent`
`{substitution group affiliation}`	`absent`
`{substitution group exclusions}`	{`extension`, `restriction`}
`{disallowed substitution}`	{`extension`, `restriction`, `substitution`}
`{abstract}`	`false`
`{annotation}`	`unspecified`

Jakarta XML Binding

Eclipse Foundation Specification License

Disclaimers

Scope

1. Introduction

1.1. Data binding

1.2. Goals

1.3. Non-Goals

1.4. Conventions

1.5. Expert Group Members

1.6. Acknowledgements

1.7. Acknowledgements for Jakarta XML Binding

2. Requirements

2.1. XML Schema to Java

2.1.1. W3C XML Schema support

2.1.2. Default Bindings

2.1.3. Customized Binding Schema

2.1.4. Overriding default binding behavior

2.1.5. Jakarta XML Web Services

2.1.5.1. Backward Compatibility

2.1.5.2. Binding XML Schema to schema derived classes

2.1.5.3. Accessing MIME content stored as an attachment

2.1.5.4. Serializable

2.1.5.5. Disabling Databinding

2.2. Java to XML Schema

2.2.1. Default Mapping

2.2.2. Customized Mapping

2.2.3. Jakarta XML Web Services

2.2.3.1. WSDL <types>

2.2.3.2. Backward Compatibility

2.3. Binding Framework

2.3.1. Disabling schema validation

3. Architecture

3.1. Introduction

3.2. Overview

3.3. Java Representation

3.3.1. Binding Declarations

3.3.2. Mapping Annotations

3.4. Annotations

3.5. Binding Framework

3.5.1. Unmarshalling

3.5.1.1. Invalid XML Content

3.5.2. Validation

3.5.2.1. Validation Re architecture

3.5.2.2. Unmarshal validation

3.5.2.3. Marshal Validation

3.5.2.4. Handling Validation Failures

3.6. An example

4. The Binding Framework

4.1. Annotation-driven Binding Framework

4.2. JAXBContext

4.3. General Validation Processing

4.4. Unmarshalling

4.4.1. Unmarshal event callbacks

4.4.1.1. Class-defined

4.4.1.2. External Listener

4.4.2. Unmarshalling Modes

4.4.3. Structural Unmarshalling

4.4.4. Flexible Unmarshalling

4.5. Marshalling

4.5.1. Marshal event callbacks

4.5.1.1. Class-defined

4.5.1.2. External Listener

4.5.2. Marshalling Properties

4.6. JAXBIntrospector

4.7. Validation Handling

4.8. DOM and Java representation Binding

4.8.1. Use Cases

4.8.2. jakarta.xml.bind.Binder

4.9. Implementation discovery

5. Java Representation of XML Content

5.1. Mapping between XML Names and Java Identifiers

5.2. Java Package

5.3. Enum Type

5.4. Content Representation

5.4.1. Value Class

5.4.2. Java Content Interface

5.5. Properties

5.5.1. Simple Property

5.5.2. Collection Property

5.5.4. `isSet` Property Modifier

`{namespace constraint}`	`##other`
`{process contents}`	`"lax"` if `lax()` is `true` otherwise `"skip"`
`{annotation}`	`unspecified`

`{required}`	`@XmlAttribute.required()`
`{attribute declaration}`	attribute declaration whose `{name}` is `@XmlAttribute.name()` and `{target namespace}` is `@XmlAttribute.namespace()`. For e.g. `<xs:attribute ref="xml:lang"/>`
`{value constraint}`	`absent`
`{annotation}`	`unspecified`

`{name}`	if `@XmlAttribute.name()` is `"##default"`, then the XML name derived from the property or field name as specified in Java Identifier To XML Name; otherwise `@XmlAttribute.name()`.
`{target namespace}`	if `@XmlAttribute.namespace()` is `"##default"`, then value of targetNamespace in Table 8-3 Mapping: Package to XML target namespace; otherwise `@XmlAttribute.namespace()`
`{type definition}`	if annotated with `@XmlList`, schema type derived by mapping as specified in @XmlList otherwise if annotated with `@XmlID`, the schema type derived by mapping as specified in @XmlID otherwise if annotated with `@XmlIDREF`, the schema type derived by mapping as specified in @XmlIDREF otherwise if the type of the property is a collection type, then the schema type derived by mapping the collection item type. otherwise the schema type to which the type of the property is mapped.
`{scope}`	complex type of the containing class
`{value constraint}`	if field has access modifiers static and final then `fixed` otherwise `absent`
`{annotation}`	`unspecified`

`{name}`	`"expectedContentTypes"`
`{target namespace}`	`"http://www.w3.org/2005/05/xmlmime"`
`attribute value`	`@XmlMimeType.value()`

`{name}`	`@XmlElementDecl.name()`
`{target namespace}`	if `@XmlElementDecl.namespace()` is `"##default"`, then the value of the `targetNamespace` to which the package of the class containing the factory method is mapped as specified in Table 8-3 Mapping: Package to XML target namespace otherwise `@XmlElementDecl.namespace()`
`{type definition}`	schema type to which the class is mapped as specified in @XmlType.
`{scope}`	`global` if `@XmlElementDecl.scope()` is `@XmlElementDecl.GLOBAL` otherwise the complex type definition to which the class containing the object factory method is mapped.
`{value constraint}`	`absent`
`{nillable}`	`false`
`{identity-constraint definitions}`	`empty set`
`{substitution group affiliation}`	element declaration derived from `@XmlElementDecl.name()` and `@XmlElementDecl.substitutionHeadName()`
`{substitution group exclusions}`	`{}`
`{disallowed substitution}`	`{}`
`{abstract}`	`false`
`{annotation}`	`unspecified`

`{name}`	If the basetype is a primitive type (e.g. `int[][]`) or its corresponding wrapper class (e.g. `Integer[][]`), then the name is basetype concatenated with `"Array"` (e.g. `intArray`). otherwise if the basetype is a reference type (e.g. `Foo[][]`), then the XML name to which the reference type is mapped (e.g. `foo`) concatenated with `"Array"` (e.g. `fooArray`).
`{target namespace}`	if the basetype is a primitive or its corresponding wrapper class then `"http://jaxb.dev.java.net/array"` otherwise the namespace to which the reference type is mapped (e.g. for `Foo[][]`, the namespace of the XML type to which `Foo` is mapped).
`{base type definition}`	`xs:anyType`
`{derivation method}`	`restriction`
`{final}`	`#all`
`{abstract}`	`false`
`{attribute uses}`	`empty set`
`{attribute wildcard}`	`absent`
`{content type}`	element-only content
`{prohibited substitutions}`	`empty set`
`{annotations}`	`absent`

`{compositor}`	`xs:sequence`
`{particles}`	A repeating element defined as follows: `<xs:element name="item" type=schematype minOccurs="0" maxOccurs="unbounded" nillable="true"/>` where schematype is the schema to which the array’s component type is mapped (e.g. `int[][]`, then `"xs:int"`; `Foo[][]` then `"foo"` assuming `Foo` is mapped to the schema type `foo`.
`{annotation}`	`unspecified`

Java Standard Classes	printMethod	parseMethod
`java.lang.String`	`printString`	`parseString`
`java.util.Calendar`	`printDateTime`	`parseDateTime`
`java.util.Date`	`printDateTime`	`parseDateTime`
`java.net.URI`	`URI.toString()`	`URI(String str)`
`javax.xml.datatype.XMLGregorianCalendar`	`XMLGregorianCalendar .toXMLFormat()`	`DatatypeFactory. newXMLGregorianCalendar(String lexicalRepresentation)`
`javax.xml.datatype.Duration`	`Duration.toString()`	`DatatypeFactory.newDuration(String lexicalRepresentation)`
`java.util.UUID`	`UUID.toString()`	`UUID.fromString()`

Prefix	Separator	Suffix	Example
`[^punct]`	`punct+` ^[28]	`[^punct]`	`foo\|--\|bar`
`digit`		`[^digit]`	`foo\|22\|bar`
`[^digit]`		`digit`	`foo\|22`
`lower`		`[^lower]`	`foo\|Bar`
`upper`		`upper lower`	`FOO\|Bar`
`letter`		`[^letter]`	`Foo\|\u2160`
`[^letter]`		`letter`	`\u2160\|Foo`
`uncased`		`[^uncased]`
`[^uncased]`		`uncased`

XML Name	Class Name	Method Name	Constant Name
mixedCaseName	MixedCaseName	getMixedCaseName	MIXED_CASE_NAME
Answer42	Answer42	getAnswer42	ANSWER_42
name-with-dashes	NameWithDashes	getNameWithDashes	NAME_WITH_DASHES
other_punct-chars	OtherPunctChars	getOtherPunctChars	OTHER_PUNCT_CHARS