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> {
    }

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>>

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