A JAXB Tutorial

Wolfgang Laun
Thales Rail Signalling Solutions GesmbH

1 Introduction 1.1 About JAXB 1.2 Overview 1.3 Hello World 2 Writing an XML Schema for JAXB 2.1 XML Schema Types 2.2 JAXB Examples 2.2.1 Defining an Integer Range Type 2.2.2 Numeric Types 2.2.3 Defining a String with Length Limits 2.2.4 Defining a String Type Restricted By Pattern 2.2.5 Date and Time 2.2.6 Binary Data 2.2.7 Defining a List of Integers 2.2.8 Defining Other Lists 2.2.9 Defining an Enumeration 2.2.10 Defining a Type Union 2.2.11 Defining Types for XML Elements Without Content 2.2.12 Defining Types for XML Elements With Content 2.2.12.1 Content: A Value 2.2.12.2 Content: An Ordered Set of Elements 2.2.12.3 Content: An Unordered Set of Elements 2.2.12.4 Content: Alternative Elements 2.2.12.5 Content: A Homogeneous List of Elements 2.2.12.6 Content: A Mixed List of Elements 2.2.12.7 Mixed Content 2.2.12.8 No Value 2.2.13 Defining Subtypes 2.2.14 Substitution Groups 2.2.15 Referring to Another XML Element 2.2.16 Elements With Any Type 2.2.16.1 DOM Elements 2.2.16.2 Another Content Tree as Element 2.2.17 Image Data 2.3 Hints on Writing XML Schemas 2.3.1 Don't Use Anonymous Types 2.3.2 Common Schema Definitions 2.3.3 A Note on Groups 2.3.4 Conserving Compatibility 2.3.5 Spurious Classes 2.3.6 Avoid Unnecessary JAXBElement<?> 3 Unmarshalling and Using the Data 3.1 Unmarshalling 3.2 Using the Element Tree 3.3 Validation 3.4 Validation Event Handling 3.5 The JAXB Context 4 Building and Marshalling an XML Document 4.1 The Object Factory 4.2 Assembling Document Tree Nodes 4.3 Assembling Data with Links (ID, IDREF) 4.3.1 One Element per Identification

4.3.2 Preserving Object Identity 4.4 Last Resort: Assembling a Java Object 4.5 Calling marshal 5 Customizing 5.1 Reasons for Customizing 5.2 Defining Package Names 5.3 Overriding Names 5.4 Adding Documentation 5.5 Interning Strings 5.6 Overriding the Datatype 5.6.1 Replacing the Conversions 5.6.2 Replacing a Simple Type 6 JAXB Annotations 6.1 How a Schema Mapping Is Implemented 6.2 A Survey Of JAXB Annotations 6.2.1 Top-level Elements: XmlRootElement 6.2.2 Annotation for Classes: XmlType 6.2.3 Annotations for the Schema: XmlSchema 6.2.4 The Object Factory: XmlRegistry, XmlElementDecl 6.2.5 Controlling Element Selection: XmlAccessorType, XmlTransient 6.2.6 Class Inclusion: XmlSeeAlso 6.2.7 Annotations for Fields 6.2.7.1 The Annotation XmlElement 6.2.7.2 The Annotation XmlList 6.2.7.3 Class Fields as Attributes: XmlAttribute 6.2.7.4 Mapping a Class to Simple Content or Simple Type: XmlValue 6.2.7.5 Collecting Unspecified Attributes: XmlAnyAttribute 6.2.7.6 Collecting Unspecified Elements: XmlAnyElement 6.2.7.7 Wrapping Repeated Elements: XmlElementWrapper 6.2.7.8 Annotations for Mixed Content: XmlElementRef, XmlMixed 6.2.8 Annotations for Enums: XmlEnum, XmlEnumValue 6.2.9 Type Adapters: XmlJavaTypeAdapter 6.2.10 Type Mapping: XmlSchemaType 6.2.11 Annotations for Object References: XmlID, XmlIDREF

an attribute. which contain attributes and the content as instance variables and refer to child elements by object references.1 Introduction 1. It constitutes a convenient framework for processing XML documents. provides methods for unmarshalling a document from various sources as well as for marshalling a content tree to various destinations. The application can then navigate through the tree in memory to access the data it needs. with individual node objects containing an element. supported with the code generated by the Binding Compiler. It should be noted that the XML Schema language is capable of defining XML structures that cannot be bound by a schema compiler.) 1. The JAXB runtime library. providing significant benefits as compared to previously available methods such as the one following the Document Object Model (DOM). Versions from 2. JAXB also supports marshalling and unmarshalling for SAX. The resulting set of classes defines the types required for accessing elements. Lists of values and certain element groupings are mapped to Java's java. the Simple API for XML. the parser creates a tree of objects that represents the content and organization of data in the document. linked according to the XML document's structure. a CDATA section. Version 2. Adding such annotations to existing Java classes prepares them for being used by JAXB's runtime.1 About JAXB JAXB is an acronym derived from Java Architecture for XML Binding. as compared to version 1. In many of these cases it is possible to circumnavigate the problem by adding binding declarations to direct the schema compiler in some specific way to achieve a successful binding. JAXB uses Java's annotations for augmenting the generated classes with additional information that bridges the gap between what is decribed by an XML schema and the information available (via Java's reflection mechanisms) from a set of Java class definitions.2 Overview The chapter Writing an XML Schema for JAXB discusses how JAXB represents the . Unmarshalling an XML document with the appropriate JAXB method also results in a tree of objects. usually written in the W3C XML Schema Language.1. however. In the DOM approach. As of the time of this writing (March 2009) JAXB is available as version 2. using the JAXB Binding Compiler xjc. is contained in objects of a single type. attributes and other content in a typesafe way. The most convenient way to obtain the Java type information describing the node elements is by compiling an XML schema. The scalar datatypes of the XML Schema Language are mapped to Java data types. Schemas written in the XML Schema Language can describe structural relationships and data types. with the significant difference being that the nodes in this tree correspond to XML elements. was a big step ahead and has brought JAXB to a mature level.util. etc. DOM data.List. (JAXB version 1 should not be used any more.10. Values are invariably provided as strings.0 on contain bug fixes and minor additions. with a very high level of distinctiveness.

Some features rely on specific implementations of JAXB. -. influencing several aspects of the generated Java code.w3. The intention of this tutorial is to provide you with examples and guidelines for the essential features of JAXB.various XML Schema language constructs in Java. it's just here to give you the overall picture.com/xml/ns/jaxb" jxb:version="2. Chapters Unmarshalling and Using the Data and Building and Marshalling an XML Document describe how to convert XML document data into a content tree and vice versa.0" encoding="UTF-8"?> <xsd:schema xmlns:xsd="http://www.The XML Schema generator schemagen. which is to contain a series of salutations. 1.The XML Schema compiler xjc may be extended with plugins . each of which contains a greeting (such as "Hello world") and an attribute for registering the language of the salutation.0"> <xsd:element name="Greetings" type="GreetingListType"/> <xsd:complexType name="GreetingListType"> <xsd:sequence> <xsd:element name="Greeting" type="GreetingType" maxOccurs="unbounded"/> </xsd:sequence> </xsd:complexType> <xsd:complexType name="GreetingType"> <xsd:sequence> <xsd:element name="Text" type="xsd:string"/> </xsd:sequence> . The XML Schema on hello. Much of what can be done with JAXB is not covered here.obviously an area for experts.org/2001/XMLSchema" xmlns:jxb="http://java. <?xml version="1.3 Hello World We'll stick with the tradition and use a sort of "Hello World" XML document to illustrate the typical scenario for creating the Java classes and their use to marshal a document. which derives a schema from a set of Java classes.sun. The chapter JAXB Annotations presents the most important JAXB annotations and examples using them on hand-written Java classes. The examples illustrate how a schema should be written to produce easy-to-use Java code. Customizing discusses the various options for augmenting and modifying schema information. A good place for digging up remarkable tricks is the archives of Kohsuke Kawaguchi's Blog. -. We'll not discuss any details in this subsection.xsd defines the structure of our document. Some of these features are: -.

setText( t ).<xsd:attribute name="language" type="xsd:language"/> </xsd:complexType> </xsd:schema> Now we can call the JAXB schema compiler. and the resulting XML document is written to the standard output stream. grList = of.e. import java.createMarshaller().. Here's a sequence of these calls: . JAXBContext jc = JAXBContext.xsd This generates several classes in the subdirectory hello.newInstance( "hello" ). private GreetingListType grList. Marshaller m = jc. } catch( JAXBException jbe ){ // . g. xjc -p hello hello. grList.*.*.createGreetingListType().. } } } The constructor uses a method from the object factory to create an object of the document's top level XML element type. GreetingListType.createGreetings( grList ).setLanguage( l ).marshal( gl. g.xml. } public void make( String t. System. with a call to marshal. m. public class Hello { private ObjectFactory of..util. import hello.*. The class Hello shows how to use them. String l ){ GreetingType g = of.bind.add( g ). Finally.out ).getGreeting(). the list is wrapped in its XML element. public Hello(){ of = new ObjectFactory(). defining the package name hello for the generated classes.createGreetingType(). } public void marshal() { try { JAXBElement<GreetingListType> gl = of. import javax. The make method adds another salutation with its text element and the language attribute. i.

h. h. h. "fr" ). madame".0" encoding="UTF-8" standalone="yes"?> <Greetings> <Greeting language="fr"> <Text>Bonjour. for better readability.Hello h = new Hello(). you".make( "Hey. madame</Text> </Greeting> <Greeting language="en"> <Text>Hey.make( "Bonjour. The output is shown below. "en" ). you</Text> </Greeting> </Greetings> . <?xml version="1. formatted.marshal().

An XML element of some complex type may have child elements or attributes or both. URIs. to limit the precision. strings. structure (or record) and union. <xsd:union>.. where examples of XML Schema language constructs are related to the Java code that the JAXB compiler uses for their representation. Other facets. The XML Schema language provides the elementary data types for numbers.sun. Only by using these features will you receive the full benefit of JAXB.e. and for references and other XML constructs. We'll discuss schema structuring and typing concepts in more detail in the next section. the composition of document nodes. with the intent of defining one or more hierarchical types defining XML documents.0" encoding="UTF-8"?> <xsd:schema xmlns:xsd="http://www.0"> 2.w3. the schema's element grouping facilites <xsd:all>.org/2001/XMLSchema" xmlns:jxb="http://java.2 JAXB Examples This chapter discusses various XML Schema constructs and how they are bound by .1 XML Schema Types A schema describes data types. it should generally not be defined as String in the Java classes derived from a schema. i. Both is done in the schema element of the XML schema: <?xml version="1. This (or some other name. which will not only take care of all the necessary conversions to or from the textual representation in XML but also with the transformation of XML structures to Java data patterns.. xs) identifier must be bound to the URI identifying the XML Schema language. The XML Schema Language offers a rich set of features to achieve the required structuring and typing. which are available to set lower or upper bounds for values or string lengths. This is done by adding so-called facets. dates and times. User-defined data types can be derived from any elementary type by adding one or more restrictions. Type information deals with the definition of structure. however. list. are ignored by the Schema Compiler. to enumerate all legal values. JAXB uses enumerations restricting strings to define an enum type.com/xml/ns/jaxb" jxb:version="2. Please notice that the tags of schema elements are presented in the qualified form. provided by the World Wide Web Consortium (W3C). booleans. (Section Validation explains how to enable facet checking. and to define a pattern for a string type. and the classification of scalar (or list) values for content and attributes.g. For child elements. Although all data in XML is text. also the jxb namespace prefix must be bound. with xsd as the namespace identifier. such as lists or maps. e.2 Writing an XML Schema for JAXB 2. <xsd:choice> and <xsd:sequence> in combination with repetition limit attributes let you define XML structures that are the equivalent of the classic concepts of array. A good introduction to the XML Schema language is the XML Schema Part 0: Primer. If used.) Data structuring concepts are expressed by using the complex type construct of the schema language.

If you peek into one of these class definitions.. } public void setGroup(int value) { this. perhaps.BigDecimal. We'll discuss them briefly in this subsection. // . We'll discuss this in the section on Validation. required = true) protected int group. The JAXB compiler will simply fall back to int (or Integer) in all the places where GroupType is used.2.xml. we .. the root of the tree is given by xsd:decimal. the resulting Java code is generally shown without the annotations. you'll see simple get and set methods.. There is one Java type providing just that: java..Schema object. For brevity and clarity.math. 2. you might ask. like in this class derived from a schema type where an element has an attribute with name Group and type GroupType: public class ElementType { // .the JAXB schema compiler xjc. According to the XML Schema definition.. JAXB expects you to request detailed validation explicitly by passing a javax. 2.1 Defining an Integer Range Type The XML Schema snippet shown below defines an integer type. <xsd:simpleType name="GroupType"> <xsd:restriction base="xsd:int"> <xsd:minInclusive value="1"/> <xsd:maxInclusive value="255"/> </xsd:restriction> </xsd:simpleType> A simple type restricting xsd:int will not result in a separate Java class being generated. disappointing anwer is that there is no such code. the code that ensures that the integer value is between the bounds? The short and. @XmlAttribute(name = "Group". this data type represents decimal numbers with an unspecified range of fractional and total digits.2. Doing away with fractional digits.group = value.validation. } Where is.. created from your XML schema.2 Numeric Types The schema language features a multi-tiered type hierarchy of built-in numeric datatypes. to the marshaller or unmarshaller used for handling your data. } // . public int getGroup() { return group. limiting permissible values to the range 1 to 255. Leaving double and float aside.

Below the integer type. and therefore this type maps to java. the tree branches off into a hierarchy of non-negative integers. xsd:unsignedShort and xsd:unsignedByte. the non-positive integers and the traditional line of integer types representing the typical two's complement ranges.. there is no fitting simple type. The types long down to byte are normally mapped to Java's eponymous simple types. it has to be represented by java. short for xsd:unsignedByte. long _long. The following schema snippet contains a selection of the types discussed so far. e.e. Java provides null as a convenient value for this abstract nil value . the Java code generated by JAXB does not reflect any of this. too. Exceptions result from the property nillable being set to true for an element or attribute. . public class NumericZooType { protected protected protected protected protected BigDecimal decimal. Since xsd:nonNegativeInteger is defined as a restriction of xsd:integer. nil. <xsd:complexType name="NumericZooType"> <xsd:sequence> <xsd:element name="decimal" type="xsd:decimal"/> <xsd:element name="integer" type="xsd:integer"/> <xsd:element name="long" type="xsd:long"/> <xsd:element name="int" type="xsd:int" default="42"/> <xsd:element name="short_nil" type="xsd:short" nillable="true"/> <xsd:element name="byte" type="xsd:byte" default="13" nillable="true"/> <xsd:element name="nonNegative" type="xsd:nonNegativeInteger"/> <xsd:element name="unsignedLong" type="xsd:unsignedLong"/> <xsd:element name="unsignedInt" type="xsd:unsignedInt"/> </xsd:sequence> </xsd:complexType> And here is the resulting Java code. int _int. hence java.. Although both types can be constrained using facets to delimit the number of digits or the value range.math. Short shortNil. This adds another value to the set of possible values. from xsd:unsignedLong down to xsd:unsignedByte.but only for descendants of Object.arrive at xsd:integer.BigInteger. For xsd:unsignedLong. which still has an unspecified number of digits. simplified for better readability. The non-negative types comprise xsd:nonNegativeInteger and the unsigned variations of the binary integer types.BigInteger.g.math.BigInteger must be used. JAXB reverts to simple types. using the smallest type capable of holding all values. another one for their obscure cousins.math. indicating that the element or attribute is simply absent. i. BigInteger integer. With xsd:unsignedInt.

<xsd:simpleType name="ShortNameType"> <xsd:restriction base="xsd:string"> <xsd:minLength value="1"/> . JAXB simply generates the type suitable for the base type of the restriction.counter = value.2. <xsd:element name="counter" type="CounterType"/> No separate Java class is generated for CounterType. } public void setDecimal(BigDecimal value) { this. So. it's quite a zoo indeed. } // All other getters and setters follow the same pattern. limiting string lengths to the range 1 to 3. } 2. BigInteger unsignedLong.protected protected protected protected Byte _byte. public int getCounter() { return counter. For some element such as counter. long unsignedInt. Although applications dealing with monetary quantities prosper on BigDecimal. the question is: can you retain the more convenient simple types while defining suitable value range limits? The answer is yes. <xsd:simpleType name="CounterType"> <xsd:restriction base="xsd:int"> <xsd:minInclusive value="0"/> </xsd:restriction> </xsd:simpleType> .decimal = value. and it's demonstrated in the schema snippet shown below.. // . schema designers who just want to express a simple integer counter (with a moderate upper limit) are not at all pleased when one of the "Big" types crops up in the generated Java code.. of course. } public void setCounter(int value) { this. } Well... where a simple type is defined as a restriction of the built-in type xsd:int. BigInteger nonNegative. public BigDecimal getDecimal() { return decimal. protected int counter.3 Defining a String with Length Limits The XML Schema snippet shown below defines a string type.

The XML schema snippet shown below defines an element containing sub-elements with xsd:date and xsd:time.xml. The example below defines a type for strings of arbitrary length consisting of 'L' and 'R' only.datatype.) There is a convenient set of methods for getting at the various components such as year or day or minute. We'll illustrate this with a simple example for marshalling date and time. (Do not confuse this with java. <xsd:simpleType name="DirType"> <xsd:restriction base="xsd:string"> <xsd:pattern value="[LR]*"/> </xsd:restriction> </xsd:simpleType> The syntax for regular expressions in pattern facets provides the basics for repetition.<xsd:maxLength value="3"/> </xsd:restriction> </xsd:simpleType> Again. no Java class is required for DirType. public XMLGregorianCalendar getDate() { return date.util.4 Defining a String Type Restricted By Pattern A string type may also be restricted by a pattern facet. <xsd:complexType name="DateTimeType"> <xsd:sequence> <xsd:element name="Date" type="xsd:date"/> <xsd:element name="Time" type="xsd:time"/> </xsd:sequence> </xsd:complexType> The generated class contains the usual getters and setters: public class DateTimeType { protected XMLGregorianCalendar date. alternatives and grouping. This class is in the package javax. It should be noted that a regular expression is always matched against the entire string value.GregorianCalendar. protected XMLGregorianCalendar time. 2. Once more. Java's own java. But creating any of these values isn't quite so simple because XMLGregorianCalendar is an abstract class. this simple type doesn't warrant a class definition of its own. . and the length restriction isn't checked unless you request it.2. xsd:time and xsd:dateTime to XMLGregorianCalendar.5 Date and Time JAXB binds all three of the schema types xsd:date.String is used.lang.2. 2.

} public void setTime(XMLGregorianCalendar value) { this. // Insert sub-elements into the DateTimeType element.get( Calendar.SECOND ). It is.get( Calendar. now.FIELD_UNDEFINED ). meta. You may have noticed the null argument in the method constructing an XMLGregorianCalendar with the time. // Create a DateTimeType element for the current time and date. // Obtain a DatatypeFactory instance.setTime( gcTime ).YEAR ). // Create an XMLGregorianCalendar with the current time.newXMLGregorianCalendarTime( now.createDateTimeType(). It's the class DatatypeFactory that provides the methods with which we can create the XMLGregorianCalendar objects.MONTH ).newInstance().setDate( gcDate ). null.FIELD_UNDEFINED ).newXMLGregorianCalendarDate( now. DatatypeFactory df = DatatypeFactory. XMLGregorianCalendar gcDate = df.get( Calendar. some work remains to be done before we can call either setter. now. not possible to omit seconds entirely. however.HOUR_OF_DAY ).} public void setDate(XMLGregorianCalendar value) { this.time = value. ObjectFactory of = new ObjectFactory(). // Create an XMLGregorianCalendar with the current date. // no fraction DatatypeConstants. XMLGregorianCalendar gcTime = df. DatatypeConstants. } public XMLGregorianCalendar getTime() { return time.MINUTE ). meta.get( Calendar. The XML element produced by this code will look like this: . DateTimeType meta = of. now.date = value. } } However.DAY_OF_MONTH ).get( Calendar.get( Calendar. now. GregorianCalendar now = new GregorianCalendar(). This indicates that we don't care about fractions of seconds.

so again no Java class has to be generated for this simple type. <xsd:simpleType name="NumberListType"> <xsd:list itemType="xsd:int"/> </xsd:simpleType> The Java type used for this schema type will be List<Integer>. still be represented in printable characters. <xsd:complexType name="BinaryType"> <xsd:sequence> <xsd:element name="data" type="xsd:hexBinary"/> </xsd:sequence> </xsd:complexType> The Java class produced by JAXB contains a convenient pair of getter and setter methods for accessing the instance variable (called data) that stores the binary data. All conversions are handled by JAXB. as shown below. for inclusion in an XML file.6 Binary Data Data that has no "natural" representation with printable characters must. Its type and the type for passing the binary data is byte[].<DateTime> <Date>2008-07-23</Date> <Time>18:42:24</Time> </DateTime> You should notice that the date and time representations follow ISO 8601. The simple technique for this consists in converting the binary byte values to their hexadecimal representations.7 Defining a List of Integers To obtain a simple type that can be used for XML element values as well as for attribute values consisting of a simple series of values. } public void setData(byte[] value) { this.2. Using NumberListType as an attribute . public byte[] getData() { return data. use an xsd:list.data = ((byte[]) value). A sample schema declaration is shown below. 2. The XML Schema datatype to use in this case is xsd:hexBinary. public class BinaryType { protected byte[] data.2. } } 2.

. 2. enumerating all the values as you would in a Java enum type. unless you can be very sure that your strings are free from spaces or any other white space.2.. } return this...or child type results in an instance variable and a getter method in the parent class: public class ListsType { // . public List<Integer> getNumbers() { if (numbers == null) { numbers = new ArrayList<Integer>()."/>.numbers. } // . .9 Defining an Enumeration If you want a data type that enumerates discrete values you should use a restriction of the schema type xsd:string. but the names of the enum constants are transformed so that they conform to the style commonly accepted in the Java community.2. Below is the (somewhat shortened) Java code. There is no corresponding setter which means that all additions or deletions of list elements have to be made on the "live" list. don't use anything like <xsd:simpleType name="StringListType"> <xsd:list itemType="xsd:string"/> <!-. use a complex type that contains a sequence of string elements. } The code in the getter method ensures that the List<Integer> is created.dangerous! --> </xsd:simpleType> To be on the safe side. <xsd:simpleType name="IXLType"> <xsd:restriction base="xsd:string"> <xsd:enumeration value="eStwA"/> <xsd:enumeration value="eStwS"/> <xsd:enumeration value="SpDrL"/> <xsd:enumeration value="SpDrS"/> <xsd:enumeration value="VGS80"/> </xsd:restriction> </xsd:simpleType> The JAXB compiler generates a Java enum. 2. The XML representation would be a list of values of that type. // .. And right here is a potential catch: what if one of these values contains a blank? Therefore. separated by white space. protected List<Integer> numbers..8 Defining Other Lists You can use any other atomic simple type definition or built-in primitive datatype in <xsd:list itemType="...

VGS80. } } If you want to use the original identifiers as enum constant names.public enum IXLType { E_STW_A("eStwA"). } public String value() { return value. <xsd:simpleType name="IXLType"> <xsd:restriction base="xsd:string"> <xsd:enumeration value="eStwA"/> <xsd:annotation><xsd:appinfo> <jxb:typesafeEnumMember name="eStwA"/> </xsd:appinfo></xsd:annotation> . eStwS. E_STW_S("eStwS"). private final String value. </xsd:restriction> </xsd:simpleType> The generated enum class will now contain enum constant names that exactly match the original strings. for each enum constant name. public String value() { return name(). public enum IXLType { eStwA.. SpDrL. } . VGS_80("VGS80"). you may resort to an explicit specification of the binding.. and method value may now simply call name() to obtain the stringified .. IXLType(String v) { value = v. SP_DR_S("SpDrS"). as shown below. } There is no need now to store the XML representations along with each enum constant.. SpDrS. SP_DR_L("SpDrL").

Try to avoid xsd:union. <xsd:complexType name="RouteType"> <xsd:attribute name="Pos" type="xsd:int" use="optional" default="1"/> <xsd:attribute name="Dir" type="DirType" use="required"/> </xsd:complexType> The compiler generates a class RouteType with getters and setters for the attributes. even if they do not have content. protected String dir. public int getPos() { if (pos == null) { return 1.2. .2.10 Defining a Type Union A simple type may also be constructed as a union of two or more simple types. The JAXB compiler simply inserts Java's String type wherever the union type is used and leaves it up to the application programmer to handle the rest.11 Defining Types for XML Elements Without Content Types for XML elements are constructed using xsd:complexType. } } public void setPos(Integer value) { this. 2.pos = value.value. there is no convenient way of expressing unions of simple types. <xsd:simpleType name="SpeedOrNumberType"> <xsd:union> <xsd:simpleType> <xsd:restriction base="xsd:int"> </xsd:restriction> </xsd:simpleType> <xsd:simpleType> <xsd:restriction base="xsd:string"> <xsd:pattern value="+?d+"/> </xsd:restriction> </xsd:simpleType> </xsd:union> </xsd:simpleType> In Java. public class RouteType { protected Integer pos. The snippet below defines a simple element with two attributes and no sub-elements. } else { return pos. 2.

2. Let's look at an XML element with a value of some type. the one describing the containing element.12. i. public JAXBElement<DocType> createDoc(DocType value) { .e. this element itself and its siblings. such an element cannot be part of yet another type definition describing the structure of an enclosing element.dir = value. This is defined by a schema construct like this: <xsd:element name="Quantity" type="xsd:int"/> This does not define another type. but it may occur as some part of a complex type definition that describes the structure and attributes of the containing element. Method getPos takes care of supplying the default value if the variable is null. } public void setDir(String value) { this.} public String getDir() { return dir..12 Defining Types for XML Elements With Content 2.. or even a combination of both. Obviously. or one or more subordinate elements. and it consists of the declaration of an instance variable. So.2. An element definition like this may also be provided for specifying the root element of an XML document. a setter method (here: void setQuantity(int value)). The code generated for a stand-alone element definition can be found in the class ObjectFactory which is generated along with all the classes derived from your schema's type definitions. except for list types. //. so that an example of this XML element is bound to look like this: <Quantity>144</Quantity> The Java code resulting from such an embedded element definition is part of some class definition. simply because there is no such element. from any stand-alone element definition that looks like this <xsd:element name="Doc" type="DocType"/> you may expect the generated class ObjectFactory to contain public class ObjectFactory { private final static QName _Doc_QNAME = new QName("". "Doc").2.1 Content: A Value The content of an XML element may be some value. The xsd:element defines the XML tag. } } The absence of a value for the optional attribute Pos is represented by an object where the instance variable pos remains at null.. a getter method (here: int getQuantity()) and.

y = value. } // . public int getX() { return x. value).x = value. null.) Notice that you are not restricted to a single document root element.12. 2.) The following complex type defines a set of two coordinates. } public void setX(int value) { this. public class PointType { protected int x. The following subsections describe the structuring facilities of the XML Schema language for defining element content.2 Content: An Ordered Set of Elements The schema element xsd:sequence defines that the enclosed set of elements should occur in the given order and according to the specified minimum and maximum repetition counts. <xsd:complexType name="PointType"> <xsd:sequence> <xsd:element name="X" type="xsd:int"/> <xsd:element name="Y" type="xsd:int"/> </xsd:sequence> </xsd:complexType> The resulting Java code is straightforward.2. protected int y.3 Content: An Unordered Set of Elements Content consisting of a set of elements that may occur in any order within its parent . } } 2. } (We'll have a closer look at the other methods in this factory class in the section The Object Factory.. } public void setY(int value) { this.. } public int getY() { return y.return new JAXBElement<DocType>(_Doc_QNAME.class. (The default for both is 1. DocType.2.12.

the generated Java class provides instance variables and getters and setters for all alternatives. There is. } public void setStarter( String value ) { this. 2. entree. but you may omit all courses except for the main dish.12. a severe restriction: the maxOccurs may not have a value greater than 1. Here is the definition for an XML element describing the courses of a dinner which does not permit repetitions of any course. dessert.(more getters and setters) } Here. <xsd:complexType name="CommType"> <xsd:choice> <xsd:element name="SMS" type="xsd:string"/> <xsd:element name="MMS" type="xsd:string"/> <xsd:element name="Email" type="xsd:string"/> </xsd:choice> </xsd:complexType> Although only one out of the three elements will actually be present. <xsd:complexType name="DinnerType"> <xsd:all> <xsd:element name="Starter" type="xsd:string" minOccurs="0"/> <xsd:element name="Soup" type="xsd:string" minOccurs="0"/> <xsd:element name="Entree" type="xsd:string"/> <xsd:element name="Dessert" type="xsd:string" minOccurs="0"/> </xsd:all> </xsd:complexType> The generated Java conforms to the structure of a JavaBean: public class LunchType { protected protected protected protected String String String String starter.XML element can be defined by using the schema element xsd:all. the getters for the optional child elements may return null to distinguish "not present" from any possible value. public String getStarter() { return starter. .4 Content: Alternative Elements The schema element xsd:choice lets you define a type for an XML element which has a content of exactly one element from a given set of alternatives. however... } // .starter = value. soup.2.

sms = value. public String getSMS() { return sms. and for all similar element lists.public class CommType { protected String sms. or a fixed number. Object oriented languages have no unions because a set of alternative structures is meant to be implemented by a set of subclasses. Here. may contain any number of elements. public List<PointType> getPoints() { if (points == null) { . Also.List is used. Therefore the generated code will always be as simple as the one shown below.5 Content: A Homogeneous List of Elements To define an element where some sub-element occurs repeatedly. There is.. a java. This topic is discussed in the section Defining Subtypes. using such a class may easily lead to errors that are hard to track down. permitting the definition of a list that may be empty.util. protected String mms. public class PolygonType { protected List<PointType> points. for instance. a Java class like this just doesn't have a nice feeling about it. Various combinations are possible. } // . } public void setSMS(String value) { this.) <xsd:complexType name="PolygonType"> <xsd:sequence> <xsd:element name="Points" type="PointType" minOccurs="2" maxOccurs="unbounded"/> </xsd:sequence> </xsd:complexType> The resulting Java code does not express the required minimum of two points in a polygon.(more getters and setters) } Although a handful of unused references isn't all that expensive. (PointType is shown in subsection Content: An Ordered Set of Elements. The definition of an unbounded list with at least two elements is given below. nothing in the generated code that will keep you from calling more than one setter.2.12. 2. protected String email.. we make use of the optional attributes minOccurs and maxOccurs.

points. code like this polygon. or you may use addAll for bulk additions.add( new PointType( 4. . The list can be added to one by one. } return this.lang. adds another point. public List<Object> getTextOrNumberOrPoint() { if (textOrNumberOrPoint == null) { textOrNumberOrPoint = new ArrayList<Object>().List may be applied to the returned value. therefore. All methods defined in java.getPoints().util. Sometimes only java. } } The Javadoc documentation (omitted here) emphasizes that getPoints returns a reference to the actual list while making sure that the list is created.6 Content: A Mixed List of Elements To define an element type where the element should have a content consisting of a mixed list of elements use the schema element xsd:choice with the attribute maxOccurs="unbounded" or some value greater than 1. } return this.textOrNumberOrPoint.12. 2. 9 ) ).) <xsd:complexType name="MixType"> <xsd:choice maxOccurs="unbounded"> <xsd:element name="Text" type="xsd:string"/> <xsd:element name="Number" type="xsd:int"/> <xsd:element name="Point" type="PointType"/> </xsd:choice> </xsd:complexType> The generated Java class has an instance variable for a mixed list of such elements. in the same Java code. With all of these possibilities there is just no need for a setter for the entire list. Other possibilities are java. the generic parameter of the List object must refer to some superclass of all the element types.points = new ArrayList<PointType>(). Obviously.Most importantly. } } Note well that this technique does not retain an indication of the XML tag in the objects created during unmarshalling as long as the types of the choices are distinct.2. public class MixType { protected List<Object> textOrNumberOrPoint. and you could remove or even clear to delete elements. (Using xsd:choice as the sole element within a xsd:sequence would result in the same structure definition and.Object will do.lang. or a user-defined type from which all the types in the choice set have been derived by subclassing.Serializable.

say.: for( Object o: mix. Section Using the Element Tree contains a detailed example illustrating this approach. cast o to Point and process } else { throw new IllegalArgumentException( "class " + o. (Notice that the agglomeation of the list field's name stops..JAXBElement as a container for each of the elements within MixType. Also.getTextOrNumberOrPoint() ){ if( o instanceof String ){ // . The class Mix4Type reflects this by the generic list type being <JAXBElement<?>>.xml.. type xsd:string.. after the third sub-element. Writing lengthy if statement cascades like this isn't considered to be good object oriented style..You must distinguish individual elements by testing a list element with the instanceof operator.g. the schema definition might then look like this: <xsd:complexType name="Mix4Type"> <xsd:choice maxOccurs="unbounded"> <xsd:element name="Text" type="xsd:string"/> <xsd:element name="Number" type="xsd:int"/> <xsd:element name="Point" type="PointType"/> <xsd:element name="Token" type="xsd:string"/> </xsd:choice> </xsd:complexType> Now the JAXB compiler is forced to use an artificial construct of type javax.. For one thing.getClass() ). e. public List<JAXBElement<?>> getTextOrNumberOrPoint() { if (textOrNumberOrPoint == null) { textOrNumberOrPoint = new ArrayList<JAXBElement<?>>(). } } It's a good idea to use a third test to guard against the class not being one of the three expected ones. the instanceof test avoids the compiler warning. mercifully.bind. even though a failure of the cast would show that something went wrong.) public class Mix4Type { protected List<JAXBElement<?>> textOrNumberOrPoint.. If we add another element of. cast o to String and process } else if( o instanceof Integer ){ // . cast o to Integer and process } else if( o instanceof Point ){ // . The preferred implementation technique is to map element classes to distinct objects created from subclasses of some element handler class hierarchy. } . we can produce a more significant error message in the exception we throw in the final else branch.

(process) } else if( "Number".getTextOrNumberOrPoint() ){ String tag = je. See section Using the Element Tree for a better way of dealing with tags to distinguish between elements. where parts of a paragraph's text value might have some specific property such as boldface or italic. 2...equals( Tag ) ){ String text = (String)je.getName(). // . <xsd:complexType name="ChunkType" mixed="true"> <xsd:choice maxOccurs="unbounded"> <xsd:element name="B" type="ChunkType"/> <xsd:element name="I" type="ChunkType"/> <xsd:element name="U" type="ChunkType"/> </xsd:choice> </xsd:complexType> .textOrNumberOrPoint.getValue(). One example for the natural application of mixed content would be the representation of text. // . in italics or underlined.. the cascading if statements aren't exactly the bee's knees. These stretches are best represented as children of the paragraph element. The complex type ChunkType has its attribute mixed set to true since we'll want to have plain text as well. we define a schema for our very simple text markup language. We'll have chunks of text that may be used as an entire paragraph as well as part of a paragraph...getLocalPart(). to be rendered in boldface. if( "Text".return this.getValue(). where the tag and the value are retrieved from the container of type JAXBElement<?>. and an unbounded repetition of choices as child elements.7 Mixed Content Mixed content lets you embed child elements into the value of an element. </P> To see how JAXB handles mixed content.equals( Tag ) ){ Integer number = (Integer)je. a pass through the list would have to be changed as shown below. // . (process) } else if( //..12. (other alternatives) } } Again.. } } Consequently. for( JAXBElement je: mix.2. Here is an example written in some simple markup similar to HTML: <P> <B>Mixed content</B> lets you embed <I>child elements</I> into the value of an element..

Having penetrated this slight obfuscation.getName(). } } public class ChunkType { protected List<Serializable> content. ChunkType chunk = (ChunkType)((JAXBElement)s). and.out.getContent() ){ if( s instanceof String ){ System. this is the wrapper class JAXB uses whenever elements have to be distinguished by their tags. public List<Serializable> getContent() { if (content == null) { content = new ArrayList<Serializable>(). As we already know. we did use ChunkType with B. public List<ChunkType> getP() { if (p == null) { p = new ArrayList<ChunkType>(). The generic list type now happens to be java.out.getValue().out. } } The documentation JAXB generates is kind enough to inform us that the elements in the list returned by getContent are either of type String or of type JAXBElement<ChunkType>. which is just another way of saying "(almost) anything goes". public class TextType { protected List<ChunkType> p. indeed. as ChunkType features just one method getContent.content. private static void dumpChunk( ChunkType c ){ for( Serializable s: c. } return this. I and U.print( "(" + tag + ":" ). System.getLocalPart(). } . dumpChunk( chunk ). we can now write code to process a text as a list of paragraphs. } else { String tag = ((JAXBElement)s).<xsd:complexType name="TextType"> <xsd:sequence> <xsd:element name="P" type="ChunkType" maxOccurs="unbounded"/> </xsd:sequence> </xsd:complexType> The generated Java code is somewhat opaque.p. } return this. System. apparently the Swiss army knife for slicing a chunk of text.print( (String)s ).lang.Serializable.print( ":" + tag + ")" ). The content list of a text chunk yields plain and decorated chunks in any order.

in accordance with the attribute minOccurs="0".. Yet another possibility is shown with element <C>.12. However. we'll have a peek at the crucial ones right now. where its absence can be expressed by simply omitting it from its parent element.(process a text) TextType text = . @XmlElement(name = "B") protected String b. required = true. and the getters and setters for all three fields are identical. Let's look at the complex type defined like this: <xsd:complexType name="DemoType"> <xsd:sequence> <xsd:element name="A" type="xsd:string"/> <xsd:element name="B" type="xsd:string" minOccurs="0"/> <xsd:element name="C" type="xsd:string" nillable="true"/> </xsd:sequence> </xsd:complexType> Element <A> must be present. even though its value could be the empty string..} } //. the characterless thing. public class DemoType { @XmlElement(name = "A". Although we are going to discuss annotations in more detail later on. @XmlElement(name = "C". not a good idea. nillable = true) protected String c. } 2.org/2001/XMLSchema-instance. required = true) protected String a. using the empty string as an indication for the absence of a value is. in general.w3.. for( ChunkType c: text. .8 No Value XML can express the absence of a value in different ways.2. but its attribute nillable="true" permits the usage of an XML element that doesn't even contain the empty string but uses the attribute xsi:nil. JAXB distinguishes between the three representations by attaching suitable annotations. as shown in this valid example for a DemoType element: (The prefix xsi must be bound to http://www.no element <B> here --> <C xsi:nil="true"/> </demo> The declarations..) <demo> <A></A> <!-. A better solution is provided by the definition of element <B>.. which can not be omitted.getP() ){ dumpChunk( c ).

13 Defining Subtypes Although object orientation isn't a key feature of XML or the XML Schema language. } public void setA(String value) { this.a = value. radio buttons and sub-menus. (more getters and setters like this) } 2. it's still possible to apply the fundamental OO paradigm when designing a schema: inheritance.2... } // .public String getA() { return a. check boxes. The example given below presents the components for defining a simple menu (this time it's for a graphical user interface) where menu entries may come in several flavours: simple items. <xsd:complexType name="EntryType"> <xsd:attribute name="Text" type="xsd:string"/> </xsd:complexType> <xsd:complexType name="ItemType"> <xsd:complexContent> <xsd:extension base="EntryType"> <xsd:sequence> <xsd:element name="Command" type="xsd:string"/> </xsd:sequence> </xsd:extension> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="CheckBoxType"> <xsd:complexContent> <xsd:extension base="ItemType"> <xsd:attribute name="State" type="xsd:boolean"/> </xsd:extension> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="RadioButtonType"> <xsd:complexContent> <xsd:extension base="ItemType"> <xsd:attribute name="Group" type="xsd:string"/> <xsd:attribute name="State" type="xsd:boolean"/> <xsd:attribute name="Value" type="xsd:string"/> </xsd:extension> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="MenuType"> . This is based on the schema element xsd:extension which lets you add both child elements and attributes to some elsewhere defined type acting as the base type.

including itself. After all the pains taken to establish this little class hierarchy. A look at the (much abbreviated) code shows the expected inheritance structure. setState) } public class RadioButtonType extends ItemType { .MenuType reflects the recursive structure of menus by being both another subclass of ItemType (so that it may represent cascades) as well as a container for all kinds of menu entries.. we should note that the definition of MenuType isn't quite what an OO aficionado would expect.. Group is the button group's identification.(getText. // . however.. public class EntryType { protected String text. Using just the supertype EntryType in an xsd:sequence would result in very dull menus. setText) } public class ItemType extends EntryType { protected String command. -. setCommand) } public class CheckBoxType extends ItemType { protected Boolean state.(isState.ItemType adds a command definition to the base type.(getCommand. // ..RadioButtonType is another extension of ItemType..<xsd:complexContent> <xsd:extension base="EntryType"> <xsd:choice maxOccurs="unbounded"> <xsd:element name="Item" type="ItemType"/> <xsd:element name="CheckBox" type="CheckBoxType"/> <xsd:element name="RadioButton" type="RadioButtonType"/> <xsd:element name="Menu" type="MenuType"/> </xsd:choice> </xsd:extension> </xsd:complexContent> </xsd:complexType> The base class EntryType is extended in several ways: -. and Value defines the string to be used for indicating the selection. The JAXB compiler. Before we look at the generated Java code. again adding some attributes. inheriting the command and adding an attribute for the initial state of the check box. rewards you with a set of class definitions that uses extends wherever we have xsd:extension in the schema.CheckBoxType extends ItemType. -. -. // .. one still must explicitly put all the subclasses into the choice list.

public List<EntryType> getItemOrCheckBoxOrRadioButton() { if (itemOrCheckBoxOrRadioButton == null) { itemOrCheckBoxOrRadioButton = new ArrayList<EntryType>(). } } 2. public class BinopType { protected List<JAXBElement<String>> content. protected String operator.2. public class MenuType extends EntryType { protected List<EntryType> itemOrCheckBoxOrRadioButton.(getters and setters) } Finally there is MenuType. reverse engineered the common superclass.protected String group. the field content must act as a portmanteau for all possible operand pairs. which contains a java. defining a complex type for a binary arithmetic operation. Below is a simple example. .itemOrCheckBoxOrRadioButton.List<EntryType>. literally. } return this. A reminder that the list is a mixture is embedded in the name of the getter which is made up from the first three tags. The substitution group is headed by the global operand element. The generated Java code shouldn't surprise you.. which is referenced from the group members constant and variable. // . JAXB has briefly reflected upon the element types bunched into the choice and has..util. <xsd:complexType name="BinopType"> <xsd:sequence> <xsd:element ref="operand"/> <xsd:element ref="operand"/> </xsd:sequence> <xsd:attribute name="operator" type="xsd:string"/> </xsd:complexType> <xsd:element name="operand" type="xsd:string"/> <xsd:element name="constant" type="xsd:string" substitutionGroup="operand"/> <xsd:element name="variable" type="xsd:string" substitutionGroup="operand"/> <xsd:element name="binop" type="BinopType"/> The benefit of this schema definition is that it permits you to create binop elements consisting of any combination of constant and variable elements. and that's why we have to be content with a list.14 Substitution Groups A substitution group lets you write schema structures that reference one element but permit the substitution of any other element from the substitution group in an instance document. protected Boolean state. protected String value.

14</constant> <variable>d</variable> </binop> Another example illustrates the usage of a substitution group with complex schema types. } return this.createBinopType().newInstance( "generated" ). JAXBElement<String> op2 = of. where ItemType is the base type and BookType and DiskType are the subtypes.public List<JAXBElement<String>> getContent() { if (content == null) { content = new ArrayList<JAXBElement<String>>(). BinopType bt = of. A typical scenario would be the use of a base type in the head element and various extensions for the other elements. but they must be derived from the same base type. which should be expressed by the attribute setting abstract="true".content. m. A PosType element represents a position in an order.createVariable( "d" ). JAXBElement<String> op1 = of.operator = value. JAXBContext ctxt = JAXBContext. } public String getOperator() { return operator.setProperty( Marshaller. The elements of the group may have different types.14" ). Marshaller m = ctxt.marshal( jbe. And here is the resulting instance document: <?xml version="1.add( op2 ). is conceptually an abstract type.createMarshaller().setOperator( "*" ).out ). } } Creating an element from a substitution group is slightly more complex now because such elements have to be represented by an object from some parameterized JAXBElement<?> class. either by restriction or by extension. .getContent().JAXB_FORMATTED_OUTPUT.createBinop( bt ). JAXBElement<BinopType> jbe = of.add( op1 ). ObjectFactory of = new ObjectFactory(). System. It is defined as containing one element of ItemType. } public void setOperator(String value) { this. This type.createConstant( "3. bt. m.getContent(). This is what we have in the example. however. bt. true ). This is illustrated in the Java code snippet shown below that demonstrates the assembly of a well-known formula. bt.0" encoding="UTF-8" standalone="yes"?> <binop operator="*"> <constant>3.

com/xml/ns/jaxb" jaxb:version="2.org/2001/XMLSchema" xmlns:jaxb="http://java.0"> <xs:annotation> <xs:appinfo> <jaxb:schemaBindings> <jaxb:package name="acme.<?xml version="1.item"/> </jaxb:schemaBindings> </xs:appinfo> </xs:annotation> <xs:element name="item" type="ItemType"/> <xs:element name="book" type="BookType" substitutionGroup="item"/> <xs:element name="disk" type="DiskType" substitutionGroup="item"/> <xs:complexType name="ItemType" abstract="true"> <xs:sequence> <xs:element name="title" type="xs:string"/> <xs:element name="price" type="xs:int"/> </xs:sequence> </xs:complexType> <xs:complexType name="BookType"> <xs:complexContent> <xs:extension base="ItemType"> <xs:sequence> <xs:element name="pages" type="xs:int"/> </xs:sequence> </xs:extension> </xs:complexContent> </xs:complexType> <xs:complexType name="DiskType"> <xs:complexContent> <xs:extension base="ItemType"> <xs:sequence> <xs:element name="duration" type="xs:int"/> </xs:sequence> </xs:extension> </xs:complexContent> </xs:complexType> <xs:complexType name="PosType"> <xs:sequence> <xs:element ref="item"/> <xs:element name="quantity" type="xs:int"/> </xs:sequence> </xs:complexType> <xs:complexType name="OrderType"> <xs:sequence> .0" encoding="UTF-8"?> <xs:schema xmlns:xs="http://www.w3.sun.

The ObjectFactory provides create methods for a surprisingly large number of elements. } public void setItem(JAXBElement<? extends ItemType> value) { this... Also... where the wildcard ? is suitably restricted to subtypes of ItemType. (more getters and setters) } Once again. we can create an element by calling a method that returns an object of type JAXBElement. returning an object whose type is ItemType. (getters and setters) } public class PosType { protected JAXBElement<? extends ItemType> item. There are methods returning elements of one of the plain types BookType and DiskType. public JAXBElement<? extends ItemType> getItem() { return item. Here is the skeleton of this class: . protected int quantity.. // . (getters and setters) } public class BookType extends ItemType { protected int pages. // . And finally there is createItem.. public abstract class ItemType { protected String title.<xs:element name="pos" type="PosType" maxOccurs="unbounded"/> </xs:sequence> </xs:complexType> <xs:element name="order" type="OrderType"/> </xs:schema> The interesting sections of the generated code are outlined below... // . and its use as the generic type parameter. element construction is a tad more complicated. protected int price. } // .item = ((JAXBElement<? extends ItemType> ) value). (getters and setters) } public class DiskType extends ItemType { protected int duration. parameterized with BookType or DiskType. We see the abstract base class ItemType with its extensions for books and disks. each of which requires an argument of the parameter type.

createBookType(). bk. // Order a disk. } public OrderType createOrderType() { .... bk.setTitle( "The Joy of JAXB" ).. BookType bk = of.createPosType(). listPos. listPos.. dk.setItem() Looking at this table. } public JAXBElement<ItemType> createItem(ItemType value) { .setItem() PosType.createItem( bk ) ). } public JAXBElement<OrderType> createOrder(OrderType value) { .setTitle( "Keyclick Calypso" ).createDisk( dk ) ).setPrice( 120 ).setPrice( 20 ). p1. } public DiskType createDiskType() { .setQuantity( 2 )...setItem( of.createPosType().public class ObjectFactory { public ObjectFactory() { } public BookType createBookType() { ..setQuantity( 1 ). DiskType dk = of.createOrderType(). } public JAXBElement<DiskType> createDisk(DiskType value) { .add( p1 ).setItem( of. PosType p2 = of.createDiskType().. you may wonder why there are three methods to create an item in a PosType element. } public JAXBElement<BookType> createBook(BookType value) { . .. // createDisk p2. bk.add( p2 )... p2. List<PosType> listPos = st. Method createBookType createDiskType createBook createDisk createItem Result Type BookType DiskType JAXBElement<BookType> JAXBElement<DiskType> JAXBElement<ItemType> Use as argument of createBook() createDisk() PosType.. dk. } } The table below shows where each of these lements can be used.. PosType p1 = of.setDuration( 50 ). // createItem for BookType p1. Some experimenting exhibits that indeed all three can be used: ObjectFactory of = new ObjectFactory(). // Create an order OrderType st = of.setItem() PosType. // Order two copies of a book.setPages( 832 ). dk.getPos(). } public PosType createPosType() { ...

getQuantity() ).getValue().out. System. The tag is represented as an object of class javax. .getTitle() + " " + p.getPos() ){ ItemType item = p.getValue().println( item. } In addition to using the standard Java technique for determining an object's class we can also extract the tag by calling method getName() on the JAXBElement containing the ItemType object.println( tag + " " + item. for( PosType p: order.0" encoding="UTF-8" standalone="yes"?> <order> <pos> <item xmlns:xsi="http://www.JAXBElement<OrderType> jbe = of.xml" ) ).getItem().getLocalPart(). System. but common subelements can be accessed via calls of ItemType methods.getItem().out.w3. OrderType order = (OrderType)jbe. substitution groups are an adequate technique for representing object hierarchies. The marshalled XML text shows that the generic element tag item can indeed be instantiated (even though its schema type ItemType is abstract) but at a price: The actual type of the element has to be specified using the XML instance attribute xsi:type="BookType". along with the lengthy namespace declaration. <?xml version="1. String tag = p.org/2001/XMLSchema-instance" xsi:type="BookType"> <title>Inside JAXB</title> <price>120</price> <pages>832</pages> </item> <quantity>2</quantity> </pos> <pos> <disk> <title>Keyclick Calypso</title> <price>20</price> <duration>50</duration> </disk> <quantity>1</quantity> </pos> </order> Unmarshalling requires an additional call to get at the value wrapped in a JAXBElement<? extends ItemType>. In spite of the restrictions and the slightly more complex element construction.getClass(). JAXBElement<?> jbe = (JAXBElement<?>)u.xml.QName which contains the simple name as well as the namespace prefix.getSimpleName() ).namespace.createOrder( st ). The subtype element tagged disk does not require this burden as its tag is unambiguous.getName().unmarshal( new FileInputStream( "order.

Our first example uses references for factoring out frequently occuring elements. whenever you need linkage in addition to the natural parent-tochild relationship. <xsd:complexType name="AirportType"> <xsd:attribute name="LocId" type="xsd:ID" use="required"/> <xsd:attribute name="Name" type="xsd:string" use="required"/> </xsd:complexType> <xsd:complexType name="FlightType"> <xsd:all> <xsd:element name="From" type="xsd:IDREF"/> <xsd:element name="To" type="xsd:IDREF"/> <xsd:element name="Carrier" type="xsd:string"/> <xsd:element name="DepTime" type="xsd:time"/> <xsd:element name="ArrTime" type="xsd:time"/> </xsd:all> <xsd:attribute name="Number" type="xsd:int" use="required"/> </xsd:complexType> <xsd:complexType name="TimetableType"> . Below is a schema snippet defining XML elements dealing with airports and flights.2. and a reference is inserted for the From and To sub-elements of FlightType where the original element was. which are scheduled from one airport to another one.2.15 Referring to Another XML Element Among the data types of the XML Schema language there is an inseparable pair of types operating complementary to each other: xsd:ID and xsd:IDREF.e. bundling the actual AirportType elements and the list of flights. Our document type should be defined along the lines of TimetableType. aren't they) into all places where it is used. They let you represent references to XML elements. in full. An AirportType element is presented only once. i. This can be put to good use in several circumstances.. A naive schema definition would simply have two AirportType sub-elements for each flight: <xsd:complexType name="AirportType"> <xsd:attribute name="LocId" type="xsd:string" use="required"/> <xsd:attribute name="Name" type="xsd:string" use="required"/> </xsd:complexType> <xsd:complexType name="FlightType"> <xsd:all> <xsd:element name="From" type="AirportType"/> <xsd:element name="To" type="AirportType"/> <xsd:element name="Carrier" type="xsd:string"/> <xsd:element name="DepTime" type="xsd:time"/> <xsd:element name="ArrTime" type="xsd:time"/> </xsd:all> <xsd:attribute name="Number" type="xsd:int" use="required"/> </xsd:complexType> Instead of copying an element of class AirportType (biggish. we'll now change our schema to employ element linkage.

(If there is no attribute that could serve as an identification right away.getTo()).(more getters and setters) } The elements From and To are now represented as Object references. Otherwise you'll just have to use some synthetic key. public Object getFrom() { return from. XMLGregorianCalendar arrTime.<xsd:sequence> <xsd:element name="Airports" type="AirportType" maxOccurs="unbounded"/> <xsd:element name="Flight" type="FlightType" maxOccurs="unbounded"/> </xsd:sequence> </xsd:complexType> The only change required within AirportType is the definition of the attribute Id as xsd:ID.to = value.getLocId() Don't blame JAXB for not making the From and To sub-elements AirportType . XMLGregorianCalendar depTime.) The resulting Java code for AirportType has the usual JavaBean layout.. So. Object to. to retrieve the origin of some flight.from = value.getFrom() The destination's IATA Location Identifier is obtained by ((AirportType)flight. } public void setTo(Object value) { this. } public Object getTo() { return to. all you'll have to code is (AirportType)flight. We'll continue to use the IATA Location Identifier. String carrier. and FlightType has xsd:IDREF as the type for From and To. } // . as the string implementing the XML link. it may very well be possible to compose one from the element's other attributes. More interesting is the code for the class FlightType: public class FlightType { protected protected protected protected protected protected Object from.. which we would have used as an airport identification anyway. } public void setFrom(Object value) { this. int number.

references. the ones of xsd:IDREF) to be unique across all of your XML document. It demonstrates how a track layout can be represented by linking elements such as sets of points (or switches) and tracks to each other. Keep in mind that XML requires the values of xsd:ID (or. Nevertheless. graphs. lists or. we could now define this value pair as a couple of attributes. As soon as we begin to think about adding bookings to our XML data. The XML type xsd:ID is a universal reference type. Another excellent reason for using references is the representation of linked data structures such as trees. flight identifiers would have to make their appearance as another class of values for xsd:ID. same thing. creating the graph that represents the topology of a shunting yard. but you'd better research this thoroughly before you commit yourself. in general. The example given below is for railway buffs. saving you the hassle of establishing this linkage yourself.) <xsd:simpleType name="GroupType"> <xsd:restriction base="xsd:string"> <xsd:enumeration value="SWITCH"/> <xsd:enumeration value="TRACK"/> </xsd:restriction> </xsd:simpleType> <xsd:complexType name="ElementType"> <xsd:attribute name="Id" type="xsd:ID" use="required"/> <xsd:attribute name="Group" type="GroupType" use="required"/> <xsd:attribute name="Number" type="xsd:int" use="required"/> <xsd:attribute name="Name" type="xsd:string" use="optional" default=""/> </xsd:complexType> <xsd:complexType name="PointLeftRightType"> <xsd:complexContent> <xsd:extension base="ElementType"> <xsd:attribute name="point" type="xsd:IDREF"/> <xsd:attribute name="left" type="xsd:IDREF"/> <xsd:attribute name="right" type="xsd:IDREF"/> </xsd:extension> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="EastWestType"> <xsd:complexContent> <xsd:extension base="ElementType"> <xsd:attribute name="east" type="xsd:IDREF"/> <xsd:attribute name="west" type="xsd:IDREF"/> </xsd:extension> . (Signals are omitted for brevity's sake. Notice that by dropping the necessity to have a full-blown XML element for From and To. There is a good chance that location identifiers and flight identifiers (a concatenation of the carrier id and some number) don't clash. and xsd:IDREF is the union of all reference values. unmarshalling will automatically create FlightType objects that are actually linked to their airports.

} public void setWest(Object value) { this. i. but this makes it difficult to discriminate an inadvertently dropped element from an intentionally omitted one.e.</xsd:complexContent> </xsd:complexType> <xsd:complexType name="ShuntingYardType"> <xsd:choice maxOccurs="unbounded"> <xsd:element name="Switch" type="PointLeftRightType"/> <xsd:element name="Track" type="EastWestType"/> </xsd:choice> </xsd:complexType> From the generated classes. public Object getEast() { return east. perhaps in a category of its own.west = value. public class EastWestType extends ElementType { protected Object east. line tracks? We'll need some sort of replacement for Java's null. by definition. we select EastWestType for a closer inspection. One solution that avoids this ambiguity is to use a single artificial element. protected Object west. because. Simply using "null" or "" as an IDREF value will cause problems as soon as the XML is validated. as the "null" element. We extend ShuntingYardType accordingly: <xsd:complexType name="NullType"> <xsd:attribute name="Id" type="xsd:ID" use="required"/> </xsd:complexType> <xsd:complexType name="ShuntingYardType"> <xsd:choice maxOccurs="unbounded"> <xsd:element name="Switch" type="PointLeftRightType"/> <xsd:element name="Track" type="EastWestType"/> <xsd:element name="Null" type="NullType"/> </xsd:choice> . } public Object getWest() { return west. there must be some element where that string is an id value.what do we do with dead-end tracks? Or with tracks that lead out of the shunting yard. there is Object as the type used in the getters and setters for the attributes linking to the neighbours. Again..east = value. One solution would be to define all the link attributes as optional. } } But wait . } public void setEast(Object value) { this.

this is no typesetting accident: this class is indeed empty because it doesn't need any additions to its base class.g. <xsd:complexType name="BagType"> <xsd:sequence> <xsd:element name="Content" type="xsd:anyType"/> </xsd:sequence> </xsd:complexType> The class that is generated by JAXB shouldn't come as a surprise: public class BagType { protected Object content.2. public Object getContent() { return content.1 DOM Elements The XML Schema language provides xsd:anyType which is the equivalent of java. <Track Id="TRACK_168" Group="TRACK" Number="168" Name="b101" east="SWITCH_42" west="null"/> <Null Id="null" Group="NULL" Number="0"/> The generic element attributes Group and Number could be set to arbitrary values. it can be envisaged as the base type from which all simple and complex types are derived.</xsd:complexType> This will give you a class NullType.if not java. e.Object. but we might just as well use some null values there.e.perhaps Id="null" .lang. } public void setContent(Object value) { this.16 Elements With Any Type 2. Here is the Java code JAXB generates for it: public class NullType extends ElementType { } No.content = value.2. too.. and one element of that type with an arbitrary Id value . } } But what will be the class of the Content . i. To see how this is handled in JAXB. we define the complex type BagType which is nothing but a wrapper for any content.lang..Object (which would be .16. In the XML file you would have one extra element. Its name is distinction enough. the Null element as shown below. 2.provides a null element that is comfortably distinguishable from all the actual trackside equipment by class as well as by its Id value.

i. // .w3c.w3c.dom. (The comm subelement of CommType has the type java.Node.dom.ElementNSImpl. class apache. ObjectFactory of = new ObjectFactory(). Sun's JAXB currently uses the implementation from Apache's Xerces.g.2 Another Content Tree as Element It's also possible to insert an arbitrary content tree as an element.getContent().e..internal. then what? Well. This means that.getChildNodes().dom. like this: <xsd:complexType name="HearsayType"> <xsd:sequence> <xsd:element name="text" type="xsd:string"/> </xsd:sequence> </xsd:complexType> <xsd:complexType name="GrapevineType"> <xsd:sequence> <xsd:element name="text" type="xsd:string"/> </xsd:sequence> </xsd:complexType> <xsd:complexType name="RumourType"> <xsd:sequence> <xsd:element name="text" type="xsd:string"/> </xsd:sequence> </xsd:complexType> We want any of these nice documents to be envelopped by a container document: <xsd:complexType name="CommType"> <xsd:sequence> <xsd:element name="source" type="xsd:string"/> <xsd:element name="comm" type="xsd:anyType"/> </xsd:sequence> </xsd:complexType> There is no surprise in the classes generated by the JAXB compiler.2. Node<List> = content.obtuse).dom. If you need to marshal arbitrary content you'll have to create a content tree according to org. ..Element.16.the important thing is that it implements org.getTagName(). which is a subinterface of org.: Element content = (Element)bag.w3c. 2.. if you really have to. the actual class doesn't really matter .) So we can write some code to marshal such an XML communication.lang.xerces.Object.more DOM accesses. e. String tag = content.. We'll assume that we have several document definitions.. you can leave the cushy and plushy JAXB environment and continue with traditional DOM processing methods.

. // Let's have some hearsay.getComm().class.createHearsayType().getComm() instanceof HearsayType ){ HearsayType hearsay = (HearsayType)comm.getValue(). ready for marshalling.17 Image Data An element containing a JPEG image has an XML schema definition like this: <?xml version="1. // Prepare a JAXBElement.0" encoding="UTF-8" standalone="yes"?> <comm> <source>Ms Jones</source> <comm xmlns:xsi="http://www. comm ). CommType comm = (CommType)je. } else { // .org/2001/XMLSchema-instance" xsi:type="HearsayType"> <text>Mr. all you have to do to get this document unmarshalled into a content tree and to access the nested contents is this: File f = new File( . Harper does naughty things.w3. In fact. if( comm..w3.setSource( "Ms Jones" ). CommType.. CommType comm = of.com/know-type" xmlns:xmime="http://www.(investigate other possibilities).org/2005/05/xmlmime" schemaLocation="http://www..org/2001/XMLSchema" xmlns:tns="http://example. JAXBElement<CommType> je = (JAXBElement<CommType>)u.setComm( hearsay ).w3. JAXBElement<CommType> je = new JAXBElement<CommType>( qn. HearsayType hearsay = of.com/know-type"> <xs:import namespace="http://www.setText( "Mr. Harper does naughty things. } 2.w3. The JAXBElement is now ready to be passed to a Marshaller.org/2005/05/xmlmime"/> . hearsay.</text> </comm> </comm> It should be satsifying to note that JAXB has annotated the comm element with xsi:type="HearsayType" which is going to help a lot during the inverse process.0"?> <xs:schema xmlns:xs="http://www..2.unmarshal( f ).// Create the container object." ).. comm.org/2005/05/xmlmime" targetNamespace="http://example. ). QName qn = new QName( "comm" ).w3. comm.createCommType(). The resulting XML text looks like this: <?xml version="1.

this means that you will be able to re-use the type within your schema. // Create the Item element and store the image reference ItemType itemEl = of.getJPEGPicture(). Image img = jbe. You extract the Image object from its parent element and call Graphics.. Consider the following XML schema snippet: <xsd:complexType name="PurchaseOrderType"> <xsd:sequence> . For one thing.1 Don't Use Anonymous Types The XML Schema language lets you define XML types anonymously. -1. The schema type xs:base64binary is the type best suited for representing image data.getValue().. it's preferable to define all schema types explicitly..3. JAXBElement<ItemType> jbe = of. To create XML content and to marshal an instance document containing an image you can write code to create an object of type Image and set its reference in the appropriate element of the content tree: BufferedImage bimg = ImageIO. Unmarshalling is just as simple. anonymous types result in some inner class.createPicture( itemEl ). g. and here she is: <<<picture deleted>>> 2.getScaledInstance( 512. Moreover.createItemType().3 Hints on Writing XML Schemas 2. Image..drawImage() with this object as the first argument. // Draw it Graphics g = .SCALE_DEFAULT ). JAXB appears to "know" about this namespace.setJPEGPicture( img ).<xs:complexType name="ItemType"> <xs:sequence> <xs:element name="JPEGPicture" type="xs:base64Binary" xmime:expectedContentTypes="image/jpeg"/> </xs:sequence> </xs:complexType> <xs:element name="Picture" type="ItemType"/> </xs:schema> The <xs:import> element is not required.drawImage( img. the resulting Java class will be given the name defined in the schema rather than a name selected by JAXB. 0. Image img = bimg. But when you're using JAXB to generate Java classes.read( imgFile ). null ). More importantly.. Well. 0. JAXBElement<ItemType> jbe = . itemEl. // Get the image from the content tree..

<xsd:element name="shipTo" type="AddressType"/> <xsd:element name="billTo" type="AddressType"/> <xsd:element name="item" minOccurs="0" maxOccurs="unbounded"> <xsd:complexType> <xsd:sequence> <xsd:element name="productName" type="xsd:string"/> <xsd:element name="quantity" type="xsd:positiveInteger"/> <xsd:element name="price" type="xsd:decimal"/> </xsd:sequence> <xsd:attribute name="partNum" type="xsd:string" use="required"/> </xsd:complexType> </xsd:element> </xsd:sequence> <xsd:attribute name="orderDate" type="xsd:date"/> </xsd:complexType> The relevant parts of the generated class PurchaseOrderType are presented below. } public static class Item { protected String productName. protected AddressType billTo. If the documents share common XML types... and re-used from there wherever they are required. . protected List<PurchaseOrderType. } return this.Item is the somewhat unwieldy name of the class for an order item as it results from an inlined schema type. The XML schema snippets given below illustrate this approach. protected BigDecimal price. in a separate schema file.Item> getItem() { if (item == null) { item = new ArrayList<PurchaseOrderType..Item> item. they should be written once.Item>().item.(getters and setters) } 2. // . The common definitions could be assembled into a namespace of their own. protected String partNum. // . protected XMLGregorianCalendar orderDate. to avoid any conflicts with type or element names in the schemas where they are used.2 Common Schema Definitions Different document types (within one project) require different schemas..3. protected BigInteger quantity. Note that PurchaseOrderType. public class PurchaseOrderType { protected AddressType shipTo.(getters and setters) public List<PurchaseOrderType.

org/common" targetNamespace="http://astronomy.0" encoding="utf-8"?> <xsd:schema xmlns:xsd="http://www.w3.org/common"> <xsd:complexType name="BodyType"> </xsd:sequence> <xsd:element name="name" type="xsd:ID"> <xsd:element name="mass" type="xsd:float"> <xsd:element name="radius" type="xsd:float"> </xsd:sequence> </xsd:complexType> </xsd:schema> The definitions from this schema can be used by importing the schema file.astronomy.w3.solarsystem. and you may have as many as you like within a single schema.org/solarsystem"> <xsd:import namespace="http://astronomy.<?xml version="1.> .org/solarsystem" xmlns:ss="http://astronomy.org/2001/XMLSchema" targetNamespace="http://astronomy.common and org. The previous schema snippet might be extended with the following element definitions: <xsd:schema .org/common" schemaLocation="common. e..astronomy.g. Any top-level element definition (by some xsd:element schema element) is a candidate for a root element..org/2001/XMLSchema" xmlns:ast="http://astronomy. It should also be noted that it is not necessary to have one schema file for each document type. .: <?xml version="1.org/common" xmlns:ast="http://astronomy.0" encoding="utf-8"?> <xsd:schema xmlns:xsd="http://www..xsd"/> <xsd:complexType name="MoonType"> <xsd:extension base="ast:BodyType"> </xsd:sequence> <xsd:element name="planet" type="xsd:IDREF"> </xsd:sequence> </xsd:complexType> <xsd:complexType name="PlanetType"> <xsd:extension base="ast:BodyType"> </xsd:sequence> <xsd:element name="moon" type="ss:MoonType" minOccurs="0" maxOccurs="unbounded"/> </xsd:sequence> </xsd:complexType> </xsd:schema> The schema compiler derives the package names from the URIs given in the namespace definitions. resulting in org..

m.. e. They let you put a name to a structured group of elements or attributes.4 Conserving Compatibility One of the advantages of XML is that data may be omitted wherever a default is acceptable.. SolarSystem sol = of. This may be regretted.. To insert the elements or attributes in some other place. Add planets. 2.g. use the attribute ref=". since groups or group combinations might provide a basis for adding interface definitions to the generated set of classes.solarsystem.createPlanet( planet ). 2. //. //.. you have the option of making existing XML files compatible with the new version. it is possible to define .3.5 Spurious Classes It's not necessary to define a separate type for a list resulting from a maxOccurs="unbounded" attribute attached to some element if this element occurs in an xsd:sequence group. 2.. Given the complex type ItemType. // Create a solar system. System. This feature is useful if your elements have common subsets of elements or attributes.<xsd:element name="planet" type="ss:PlanetType"/> <xsd:element name="solarSystem"> <xsd:complexType> <xsd:sequence> <xsd:element name="planet" type="ss:PlanetType" maxOccurs="unbounded"/> </xsd:sequence> </xsd:complexType> </xsd:element> </xsd:schema> Marshalling either element is possible with a marshaller created from the context based on the package org.createPlanetType(). Add attributes and moons JAXBElement<PlanetType> jbe = of.astronomy. respectively. // Create a single planet instance document.marshal( sol.out ). PlanetType planet = of.3 A Note on Groups The XML Schema language provides the constructs xs:group and xs:attributeGroup.createMarshaller(). by defining new attributes with use="optional" and providing a default..marshal( jbe. ObjectFactory of = new ObjectFactory().out ).createSolarSystem().3. If an XML schema is extended. m." specifying the group's given name. Marshaller m = context.. System. but it does not affect the Java code generated by JAXB's schema compiler xjc.3.

another type, say ItemListType, as a list of items. <xsd:complexType name="ItemType"> <xsd:sequence> ... </xsd:sequence> </xsd:complexType> <xsd:complexType name="ItemListType"> <xsd:sequence> <xsd:element name="Items" type="ItemType" minOccurs="0" maxOccurs="unbounded"/> </xsd:sequence> </xsd:complexType> Within some other type definition it is equally possible to use either ItemListType, or ItemType with the attribute maxOccurs="unbounded": <xsd:complexType name="WrapItemType"> <xsd:sequence> <xsd:element name="Items" type="ItemType" maxOccurs="unbounded"/> </xsd:sequence> </xsd:complexType> <xsd:complexType name="WrapItemListType"> <xsd:sequence> <xsd:element name="ItemList" type="ItemListType"/> </xsd:sequence> </xsd:complexType> The code for WrapItemType contains a list of ItemType objects, providing immediate access to the list: public class WrapItemType { protected List<ItemType> items; public List<ItemType> getItems() { if (items == null) { items = new ArrayList<ItemType>(); } return this.items; } } With the additional type definition in the schema you get an additional Java class. public class ItemListType { protected List<ItemType> items; public List<ItemType> getItems() { if (item == null) { item = new ArrayList<ItemType>(); }

return this.item; } } public class WrapItemListType { protected ItemListType itemList; public ItemListType getItemList() { return itemList; } public void setItemList(ItemListType value) { this.itemList = value; } } The additional class layer requires an additional getter call to retrieve an item, e.g., a.getItemList().getItems(). We note that the XML text is verboser, too. The additional type and class requires an additional tag, bracketing the list. <A> <ItemList> <Item>...</Item> <Item>...</Item> ... </ItemList> </A> This isn't required in the simpler variant: <B> <Item>...</Item> <Item>...</Item> ... </B> Notice, however, that having the <ItemList> element in place has some advantages, too. For one thing, even an empty list of items appears visibly, and may evoke some processing triggered by the empty wrapper element. Also, it is now possible to insert a complete item list in one fell swoop into the parent element, since now there is a setItemList setter. This may help when one object tree is assembled from another one. 2.3.6 Avoid Unnecessary JAXBElement<?> Try to avoid JAXBElement<?> as type of list elements. JAXB has to use this auxiliary type for elements if you have a complex element that contains a sequence consisting of elements with different tags but identical types. But you can always create distinct subtypes for each tag, even if the extension does not add anything. This means that, at the price of a few additional empty type definitions in your schema, you can avoid the bother resulting from distiguishing elements retrieved from a list not only by their class but also by their tag.

3 Unmarshalling and Using the Data 3.1 Unmarshalling A simple approach for unmarshalling an XML document consists of the creation of a JAXB context and the call to unmarshal the document. A JAXBContext object provides the entry point to the JAXB API and maintains the binding information between XML and Java. One way of creating a context instance is by calling the static method newInstance with a list of colon separated names of the packages containing the JAXB schema-derived classes. From this context, an Unmarshaller object is obtained, which functions as the driver for processing an XML text to create the equivalent set of Java objects. It offers several unmarshal methods, accepting a wide range of object types as the source for XML text data. The method shown below illustrates this with a single package containing the class of the type defining the top level element of the XML document. public <T> T unmarshal( Class<T> docClass, InputStream inputStream ) throws JAXBException { String packageName = docClass.getPackage().getName(); JAXBContext jc = JAXBContext.newInstance( packageName ); Unmarshaller u = jc.createUnmarshaller(); JAXBElement<T> doc = (JAXBElement<T>)u.unmarshal( inputStream ); return doc.getValue(); } The return value of the call to JAXB's unmarshal is a representation of the root node of the parsed XML document in an instance of JAXBElement<T>. If we're not interested in the tag of the root element we might just as well return the extracted content value. 3.2 Using the Element Tree The javadoc contained within the classes generated from an XML schema documents all the getters for accessing an XML element's attributes and child elements. A good approach is to implement a set of handler classes, one for each schema element type. Its handle method retrieves attributes and child elements, for which it invokes the handle method in turn. This corresponds to a depth-first traversal of the document tree.The example assumes that there is a simple set of schema types: <xsd:complexType name="PersonType"> <xsd:sequence> <xsd:element name="Name" type="NameType"> <xsd:element name="Addr" type="AddrType" minOccurs="0"> <xsd:element name="Child" type="ChildType" minOccurs="0" maxOccurs="unbounded"> </xsd:sequence> <xsd:attribute name="resident" type="xsd:boolean"/> </xsd:complexType> <xsd:complexType name="ChildType"> <xsd:complexContent> <xsd:extension base="PersonType"/>

if( p.getChild ). } } Not all subclasses of Handler will be quite so simple.class. } } } protected <T> void processList( List<T> list ){ for( T obj: list ){ Handler h = this. new NameHandler() ).getName() ).class. } } } class PersonHandler extends Handler { public void handle( Object o ){ PersonType p = (PersonType)o.class.put( ourClass2Conv. There is one noteworthy complication that arises if subordinate elements have to be distinguished by their tag. ChildType. NameType.. } processList( p. static { ourClass2Conv. .handle( obj ).</xsd:complexContent> </xsd:complexType> Below is the essential Java code for a handler class hierachy.isResident() ){ process( p.getAddr() ). AddrType.process( obj ). public abstract void handle( Object o ). Note that delegation to some handler for a sub-element or attribute depends on the item having a specific class. h.put( ourClass2Conv.Handler> ourClass2Conv = new HashMap<Class<?>.get( obj. new ChildHandler() ).put( ourClass2Conv. process( p. if( h != null ){ h. protected void process( Object obj ){ if( obj != null ){ Handler h = ourClass2Conv.getClass() ).class. Let's assume a small change in the definition of PersonType.getHandler( obj ).put( //. new PersonHandler() ). } PersonType..Handler>(). abstract class Handler { protected static Map<Class<?>. new AddrHandler() ).

This is best put into the handler class hosting the list. you create this schema object by setting up a schema factory for the schema language of your choice. If you want to validate your document before it is unmarshalled. enabling the programmer to restrict the basic datatypes. if the tag is required for processing as well. because XML tags need not be unique across the various element types. All we have to do is a slight extension of the generic method processList.getValue().W3C_XML_SCHEMA_NS_URI ). The value is obtained by a call of the JAXBElement method getName(). First. protected <T> void processList( List<T> list ){ for( T obj: list ){ if( obj instanceof JAXBElement ){ obj = ((JAXBElement<?>)obj). the methods process and handle would have to be extended by an additional String parameter. We have seen that the JAXB compiler doesn't care much about these facets as it just translates the basic datatype into one of Java's built-in types.newInstance( XMLConstants.Schema to the Unmarshaller object. Then you create the Schema object by calling the factory's method newSchema: Schema mySchema. try { . Don't make such a map global. we now have (in class PersonType) a method getBoyOrGirl(). } } Finally. to access the JAXBElement object and continue to use its value attribute instead of the object obtained from the list.validation.3 Validation A considerable part of the XML Schema language deals with facets.xml. } Handler h = this. 3. SchemaFactory sf = SchemaFactory.getHandler( obj ). JAXB lets you request validation by passing an object of the class javax. A meticulous interpretation of these facets for checking that the XML data meets the constraints must be done during a schema validation. h.process( obj ). that returns a List<JAXBElement<ChildType>>.<xsd:complexType name="PersonType"> <xsd:sequence> <xsd:element name="Name" type="xsd:string"/> <xsd:element name="Addr" type="xsd:string" minOccurs="0"/> <xsd:choice minOccurs="0" maxOccurs="unbounded"> <xsd:element name="Boy" type="ChildType"/> <xsd:element name="Girl" type="ChildType"/> </xsd:choice> </xsd:sequence> <xsd:attribute name="resident" type="xsd:boolean"/> </xsd:complexType> To get at a person's children. An additional lookup table mapping tag names to handlers might be required as well.

4 Validation Event Handling The interface javax. an UnmarshalException (from javax. If the XML data validation fails. If you'd like to create your own error messages." + column + ": " + msg ). the Unmarshaller method setEventHandler is called. Implementing classes must provide a single method to catch a ValidationEvent as we've seen it in the previous section. int column = vel. you'll have to catch all errors with a ValidationEventHandler. Basically that's all there is to it. Insert these lines before you call the unmarshal method: ValidationEventCollector vec = new ValidationEventCollector(). The best place for checking the event collector is in the finally phrase of the try statement wrapping all of this: if( vec != null && vec.ValidationEventHandler is quite simple.println( origin + ": " + line + ". ValidationEventLocator vel = ve. you can pass a ValidationEventCollector to the unmarshaller which will store validation events into it so that you can retrieve an event and query its individual attributes.getLocator().getMessage(). System.hasEvents() ){ for( ValidationEvent ve: vec. } After the Unmarshaller object has been established. If you want to continue as long as possible.. boolean handleEvent( ValidationEvent event ) To register. Make sure to let the user of your program see the exception message so that the problem can be fixed.xml.bind.getEvents() ){ String msg = ve. If the calling object is implementing the event handler interface.getColumnNumber().(error handling) mySchema = null. or at least as many as possible but.newSchema( file ). } catch( SAXException saxe ){ // . as explained in the next section.xml.. 3. you pass it the schema.bind) is thrown.getLineNumber(). JAXBContext jc = JAXBContext.mySchema = sf. alas. u. Unmarshaller u = jc. u.setEventHandler( vec ).newInstance( packagePath ). } } Now this looks as if the validation process would be kind enough to present you with all the errors in your XML document.err.createUnmarshaller(). we might write: . it appears that the validation process throws an exception as soon as the first deviation is detected.setSchema( mySchema ). int line = vel.

Usually.foo. For JAXB annotated Java code.newInstance( "some foo:more. and therefore this form of newInstance is usually used in connection with schema derived classes. Subclasses.foo. u.Foo. recursively. such as the types of instance variables.setEventHandler( this ).g. earlier in this chapter. . JAXBContext ctxt = JAXBContext.index resource file containing a list of the class names to be considered by JAXB.: # package some.class. you may use the package path form as well. One way is to create a context from a colon separated list of packages. An ObjectFactory class is generated by the XML schema compiler. the packages or classes associated with a JAXB context also determine the namespace declarations written as attributes into the top-level element of the generated XML document. (But see the section Class Inclusion: XmlSeeAlso about the annotation XmlSeeAlso. Bar.bar" ).Boo Foo.5 The JAXB Context As we have seen.Boo An alternative form of the newInstance method lists all classes that the new context should recognize.newInstance( Foo.Unmarshaller u = jc. 3. which provides a way of extending the closure of recognized classes.foo # class some. either with a hand-written ObjectFactory class or with a jaxb.Foo Foo # inner class some. Each package must contain its own class ObjectFactory or a file named jaxb. are not included. e.class ). JAXBContext ctxt = JAXBContext. all static references. This file simply lists the class names relative to the package where it occurs. however. an object of the class JAXBContext must be constructed as a starting point for other operations.createUnmarshaller().) If packages or classes are associated with namespaces.index. the top level classes are sufficient since JAXB will follow.

createFooBarTypeBar( bar ).</foo> JAXBElement<FooBarType> fooElem = objFact. // Add it to its parent's list. // create a "bar" element FooBarType bar = objFact. FooBarListType fblElem = objFact. fbList. A JAXBElement<?> is also required for element sequences containing elements of the same type but with differing tags. fbList.1 The Object Factory Usually hidden in the middle of the list of the classes derived from the types defined in an XML schema there will be one class called ObjectFactory..createRulebase( rulebase )..getFooOrBar(). It's convenient to use the methods of this class because they provide an easy way of creating elements that have to be represented by a JAXBElement<?> object.4 Building and Marshalling an XML Document 4. A possible sequence of calls is shown in the Java code below.. // .(add attributes and components to bar) // Create the element <bar>.createFooBarTypeFoo( foo ). one such doument object can be created by code as shown below.add( barElem ).. // . ObjectFactory objFact = new ObjectFactory().add( fooElem ). JAXBElement<RulebaseType> doc = objFact. . // Add it to its parent's list. // create a "foo" element FooBarType foo = objFact.. RulebaseType rulebase = objFact. A simple element that does not require a JAXBElement<?> wrapper is created by a straightforward method call.. ModuleType module = objFact.(add attributes and components to foo) // Create the element <foo>.createFooBarListType().createModuleType().createRulebaseType().</bar> JAXBElement<FooBarType> barElem = objFact.createFooBarType(). List<JAXBElement<FooBarType>> fbList = fblElem. Given that the top-level element of a document is represented as a JAXBElement<RulebaseType> with the tag "rulebase"... Here is a schema snippet: <xsd:complexType name="FooBarListType"> <xsd:sequence> <xsd:choice minOccurs="0" maxOccurs="unbounded"> <xsd:element name="foo" type="FooBarType"/> <xsd:element name="bar" type="FooBarType"/> </xsd:choice> </xsd:sequence> </xsd:complexType> The ObjectFactory would now contain several methods for creating a FooBarListType and its offsprings.createFooBarType().

If. insert and fill the elements as you traverse the existing structure. Usually it will be the structure of the input material that advocates some specific approach. you might use a stack to keep assembled XML elements until their parent element becomes eligible for construction. (The single exception is the set of factory methods creating a JAXBElement<?>. <xsd:complexType name="CustomerType"> <xsd:sequence> <xsd:element name="id" type="xsd:int"/> <xsd:element name="name" type="xsd:string"/> </xsd:sequence> </xsd:complexType> <xsd:complexType name="ItemType"> <xsd:sequence> <xsd:element name="id" type="xsd:string"/> <xsd:element name="quantity" type="xsd:int"/> </xsd:sequence> </xsd:complexType> <xsd:complexType name="OrderType"> <xsd:sequence> <xsd:element name="customer" type="CustomerType"/> <xsd:element name="items" type="ItemType" maxOccurs="unbounded"/> </xsd:sequence> </xsd:complexType> <xsd:element name="folder"> <xsd:complexType> <xsd:sequence> <xsd:element name="orders" </xsd:sequence> </xsd:complexType> type="OrderType" maxOccurs="unbounded"/> . as you can create. the data is in post-order. 4.You may avoid these complications by subtyping FooBarType into identical types FooType and BarType. The frequently used construction method that proceeds from the tree root towards the leaves may be written according to two typical scenarios for the construction of an element.2 Assembling Document Tree Nodes Neither the methods of the element object factory nor the constructors of the classes derived from the types defined in the XML schema require that you have any of an element's child elements or attributes at the time of the call.) This gives you maximum freedom to design your tree-building algorithm. If the data isn't arranged in one of the tree traversal orders you could set up two or more "cursors" that point into the emerging tree so that you might add to several places in parallel. but their arguments may be "empty" element objects. Sequential orderings that correspond to one of the basic tree traversal orders can be handled with elementary techniques. Building the document tree from comparable hierarchical structures is the easiest way. without any actual XML content. for instance. We'll illustrate these with a skeleton layout for a product order.

for( Item item: items ){ ItemType itemElem = objFact.createOrderType().. we extend this algorithmic outline somewhat: Create the subordinate element xElem via a call to factory method createX.id ). You should now have no problems understanding the Java code that creates an order element according to the previously given schema snippet. Obtain the reference to the subordinate List<X>.qtty ).createCustomerType().getX(). itemElem.. For each subordinate element: Create it using the factory method createX. } . // Complete customer.. simply to be repeated for other child elements..setName( custName ). Make the new element the current element and repeat this process recursively for the new element's offsprings.. itemList. custElem. If the subordinate element occurs repeatedly. This is.. String custName = . // Create and insert the customer element. the sequence for adding a solitary subordinate element of type X goes like this: Create the subordinate element xElem via a call to factory method createX. Item[] items = .setQuantity( item. Append (add) it to the List<X>. itemElem.. CustomerType custElem = objFact. List<ItemType> itemList = orderElem. Add this object to the current element.. with a call to the getter current.getOrders().add( itemElem ).</xsd:element> Assuming that we are about to add the content for a "current" element. orderElem.setId( custId ).setCustomer( custElem ). // Create order and insert in top-level document.add( orderElem ).createItemType(). of course. custElem. It reduces the risk that this essential operation is left out.setX( xElem ). // Data for an order int custId = . It may be a good strategy to insert a newly created element immediately after its creation. folder. Make the new element the current element and repeat this process recursively for the new element's offsprings. with a setter call current.setId( item.getItems(). a list of orders OrderType orderElem = objFact.. // Create and add item elements.

. on the other hand.1 One Element per Identification It is not unusual that the data that is to be represented as XML contains elements repeatedly that are either identical or equal.e. We now have getters and setters for a CustomerType. There will be duplicated objects when the unmarshalled data is transferred into application objects. (In the example there is ItemType and Item. we have the classes representing XML elements. i. inline customer element. On the one hand. IDREF) 4. and their classes are bound to have names that aren't entirely different from the ones coming from the schema. 4.3. decide to emit each of these occurrences in full. Our example is a variation of the order data. or a reference to a customer element that is in some other place. <xsd:complexType name="CustomerType"> <xsd:sequence> <xsd:element name="id" type="xsd:ID"/> <xsd:element name="name" type="xsd:string"/> </xsd:sequence> </xsd:complexType> <xsd:complexType name="OrderType"> <xsd:sequence> <xsd:choice> <xsd:element name="customer" type="CustomerType"/> <xsd:element name="custref" type="xsd:IDREF"/> </xsd:choice> <xsd:element name="items" type="ItemType" maxOccurs="unbounded"/> </xsd:sequence> </xsd:complexType> The Java code for OrderType deserves a quick inspection. which we've already discussed in the section Referring to Another XML Element. we'll proceed to discuss the techniques for assembling a document tree where elements are linked in this way. You may. of course. even though . The XML Schema language provides the schema data types xsd:ID and xsd:IDREF. The Java type JAXB uses for the reference is plain Object. the full.3 Assembling Data with Links (ID.) The counter-strategy to adopt here is to enforce a rigid naming convention which should not only deal with class names but also include naming rules for the temporary variables referencing objects of classes from either group. Recalling briefly that a key element or attribute with type xsd:ID has to be added to the element that is to be referenced from elsewhere and that a simple element or attribute with type xsd:IDREF is used in place of occurrences of the full element. an order may either contain a full customer XML element. or for a customer reference. the data for the XML document is likely to be around in a more or less similar set of objects. but this has obvious disadvantages: It increases the volume of the XML text.Another thing that can be gleaned from these lines is the danger of confusion. Here. and.

custref = value. String custId. Map<String.items. .get( custId ). protected Object custref. } public Object getCustref() { return custref. public class OrderType { protected CustomerType customer. protected List items. we'll look at a method that adds the customer to an order. public CustomerType getCustomer() { return customer. private ObjectFactory oFact = new ObjectFactory().setId( custId ).setCustomer( cust ). } public void setCustref(Object value) { this. Notice that "first occurrence" is not necessarily the foremost element in the final XML text.CustomerType>(). where we'll use the second method. // complete customer cust.createCustomerType(). } } The XML element may contain full elements and references in two slightly different arrangements. cust = oFact. Continuing our example. } return this.CustomerType> id2cust = new HashMap<String. } public void setCustomer(CustomerType value) { this. and in a way that is not to be confused with the actual document. if( cust == null ){ // Create and insert customer. too. public void addCust( OrderType order. order.customer = value. } public List getItems() { if (items == null) { items = new ArrayList(). String custName ){ CustomerType cust = id2cust. Both ways you'll have to keep track of the association between keys and element references. The first possibility replaces all occurrences with references. This means that the full elements must be added separately.we'll only use objects of type CustomerType here. The other option is to leave the first occurrence of a specific element in place and replace all duplicates.

2 Preserving Object Identity In the previous section we have tacitly assumed that there is one and only one object with a certain identification which is readily available from the object. changing them magically to the corresponding string values. // save in map id2cust.the convenient material for references . <?xml version="1. and make sure that the assembly of this element includes a call to the setter for the key element. Memory addresses . the "id" string. we simply use the object reference value of the full element as an argument to the alternative setter for the custref element. } else { order. This key is also used as a key in the map. where we keep that element for future reference.e.aren't useful in an XML text file. JAXB takes care of generating the XML text representing the reference.setCustref( cust ). We create a CustomerType object. Here is a look into a folder containing two orders to the same customer. then we meet a customer for the first time. hides this as long as possible by letting you handle references implemented as addresses.setName( custName ).put( custId.cust. JAXB. 4..3. But . however.0" encoding="UTF-8" standalone="yes"?> <folder> <orders> <customer> <id>c12789</id> <name>Smith</name> </customer> <items> <id>12</id> <quantity>1</quantity> </items> <items> <id>24</id> <quantity>100</quantity> </items> </orders> <orders> <custref>c12789</custref> <items> <id>35</id> <quantity>10</quantity> </items> </orders> </folder> Don't be confused when you look at the generated XML code and detect that the value in the "custref" element is nothing but a string. } } If the lookup in the mapping of customer ids to customer elements returns null. If the customer lookup returns an object. i. cust ).

we assume that we have addresses in objects of type Address. once for a shipping address and once for a billing address. This map uses the object's default hash code. Keeping a list of marshalled elements and searching through it isn't attractive. . we have to add an (artificial) identification to our objects as this is required as the xsd:ID value.util) to register marshalled elements.AddressType>().of type AddressType.what do you do if there is no such identification? Generating synthetic identifications isn't a problem. Also. To see how this works. The code below creates another XML element for AddressType from an Address object. Object identity can be tested by applying the operator == to any two objects. Luckily there is a better way: we can use an instance of an IdentityHashMap (from java.AddressType> pojo2elem = new IdentityHashMap<Address. Map<Address. even if hashCode has been overridden. <xsd:complexType name="AddressType"> <xsd:sequence> <xsd:element name="street" type="xsd:string"/> <xsd:element name="city" type="xsd:string"/> <xsd:element name="country" type="xsd:string"/> <xsd:element name="zip" type="xsd:int"/> </xsd:sequence> <xsd:attribute name="id" type="xsd:ID"/> </xsd:complexType> <xsd:complexType name="AddrOrRefType"> <xsd:choice> <xsd:element name="addr" type="AddressType"/> <xsd:element name="addrRef" type="xsd:IDREF"/> </xsd:choice> </xsd:complexType> <xsd:complexType name="OrderType"> <xsd:sequence> <xsd:choice> <xsd:element name="customer" type="CustomerType"/> <xsd:element name="custref" type="xsd:IDREF"/> </xsd:choice> <xsd:element name="shipTo" type="AddrOrRefType"/> <xsd:element name="billTo" type="AddrOrRefType"/> <xsd:element name="items" type="ItemType" maxOccurs="unbounded"/> </xsd:sequence> </xsd:complexType> The generated class AddrOrRefType enables us to choose between an address in full or a reference to such an XML element. but how does this help to avoid generating full XML text for each occurrence? Should we use the equals(Object o) method for identifying objects that deserve the same synthetic identifier? The answer is that with a little extra effort you can still preserve object identity so that the same number of objects can be reconstructed when the XML data is read and unmarshalled back into memory. For an example we extend the schema describing orders with an additional AddressType and use this.

arElem.setId( makeNextId() ). } else { // We've had this one before: insert its reference. The schema snippet shows a simple container for some such object. provided that the class of the object implements the java. which is just what . Special dumps of application data..).setAddr( addrElem ). // Set the xsd:ID attribute.createAddrOrRefType(). 4.and insert it into its parent. For an encore. } public AddrOrRefType makeAddrOrRefElement( ObjectFactory objFact.. arElem. Whenever we encounter a new object of class Address. All in all. Address addrPojo ){ AddrOrRefType arElem = objFact.id pair in the identity hash map. AddressType addrElem = pojo2elem.Serializable interface.createAddressType(). we map these to assembled AddressType objects...int refcount = 0. addrElem = objFact..4 Last Resort: Assembling a Java Object With all the features XML schema provides and JAXB translates you might think that including arbitrary Java objects in an XML document won't ever be necessary.setAddrRef( addrElem ). may have to use this rather extreme technique. But the need does arise occasionally. it is surprisingly simple. we enter it into the map and generate an AddrOrRef element containing the full AddressType element.util. addrElem..put( addrPojo. private String makeNextId(){ return "a" + refcount++. addrElem ). if( addrElem == null ){ // First time: generate the full XML element.. The schema element that is to contain the serialized binary data should be declared with a type of xsd:hexBinary.(Copy attributes from addrPojo into addrElem. the AddrOrRef receives the reference to the previously created AddressType element.get( addrPojo ).. } Using Address objects as keys. pojo2elem. <xsd:complexType name="JavaObjectType"> <xsd:sequence> <xsd:element name="data" type="xsd:hexBinary"/> </xsd:sequence> </xsd:complexType> <xsd:element name="container" type="JavaObjectType"/> The generated Java class JavaObjectType has a field byte[] data. // . // . // Register the object . } return arElem. for instance.

0" encoding="UTF-8" standalone="yes"?> <container xmlns:xsi="http://www. Then. ObjectOutputStream ooStream = new ObjectOutputStream( baos ). as defined by your schema.flush(). } The generated XML text is verbose and lengthy.getData() ). String pathname ) . ooStream.writeObject( pojo ).we need for calling the java. JavaObjectType joElem = objFact. ClassNotFoundException { ByteArrayInputStream bais = new ByteArrayInputStream( joElem. JavaObjectType makePojoElem( ObjectFactory objFact.ObjectOutputStream methods writeObject and readObject. ooStream. import java. omitting a few hundred hexadecimal digits: <?xml version="1..createJavaObjectType().w3. oiStream.setData( baos.* void writeDocument( Object document.close(). } 4. The code required to serialize a Java object into a XML element is shown below. First you obtain a Marshaller from a JAXBContext..io. Object getPojo( JavaObjectType joElem ) throws IOException.io. Other properties concern the inclusion of a schema location as an attribute in the top-level element.*.close(). Object pojo = oiStream.readObject().5 Calling marshal Only a handful of source code lines is required to make a JAXB Marshaller object write a document tree as an XML file. Object pojo ) throws IOException { ByteArrayOutputStream baos = new ByteArrayOutputStream(). joElem. or a JAXBElement<?>. return joElem. Here it is.toByteArray() ). such as the one that's used below.xsd"> <data>ACED00057372. ooStream. The first argument must be an object that is either a root element. or the encoding in the XML prolog.bind.7878</data> </container> The reverse process is even simpler. import javax.xml. return pojo. The byte array returned by the getter for the data element is fed to the ObjectInputStream which smartly returns the original object. you might set a number of properties. ObjectInputStream oiStream = new ObjectInputStream( bais ). since all object data required for a full reconstruction is included in the serialized data.org/2001/XMLSchema-instance" xsi:schemaLocation="serial. which requests nice formatting of the XML text.

. } Sometimes marshalling needs to be done not only for one or two root documents but for objects of many different schema types. @SuppressWarnings( "unchecked" ) JAXBElement<T> jbe = new JAXBElement( qtag. Class<?> clazz = o.getClass(). String tag. o ). JAXBContext context = JAXBContext. A generic solution is presented below.marshal( jbx. IOException { Class<T> clazz = document. You could. Marshaller m = context. you must create a context capable of handling all the classes that might crop up as instantiations for T. Boolean. . m. "someTag".getValue().marshal( document. <T> JAXBElement<T> wrap( String ns. but this is cumbersome.createMarshaller(). m.newInstance( clazz.out ). new FileOutputStream( pathname ) ).TRUE ). T o ){ QName qtag = new QName( ns.JAXB_FORMATTED_OUTPUT.setProperty( Marshaller.) With a Marshaller m obtained from this context. add xsd:element definitions for all of them to the top level xsd:schema element. m.getPackage(). return jbe.throws JAXBException.acme. st ).getClass(). tag ). the application of wrap is as simple as this: SomeType st = .getName() ).. (Creating a JAXBContext for several packages or classes is explained in section The JAXB Context.com". } To use it. clazz. System.. The method wraps an arbitrary element of some type T into a JAXBElement<T>. of course. JAXBElement<SomeType> jbx = wrap( "http://www.

The main reasons for customizing are: providing meaningful package names overriding the default class name (to avoid name clashes) overriding the default names for enum constants adding documentation associating a specific Java class with an XML Schema built-in type Customizing can be added inline to the schema. Several customizing features are provided for adding information to the compiler's output.ruleml"/> </jaxb:schemaBindings> </xsd:appinfo> </xsd:annotation> If you don't want to burden your XML schema with these annotations you can collect this and other customizing directives in a separate file. Its outermost element is jaxb:bindings.xjb. This XML file uses elements from the jaxb namespace. By default.. </jaxb:bindings> .5 Customizing 5.: xjc -p jess.xsd This. or it can be written on a separate file that is passed to the schema compiler.1 Reasons for Customizing It may not always be possible for the JAXB Schema compiler to determine all details of the generated Java code from the XML schema alone. in addition to the option defining the root directory for the generated source files. however. You can set a more appropriate package name in the call of the JAXB compiler. JAXB uses the somewhat unimaginative package name generated. 5. A better place would be in the schema file itself where you may write an xsd:annotation element containing an xsd:appinfo sub-element: <xsd:annotation> <xsd:appinfo> <jaxb:schemaBindings> <jaxb:package name="jess. We'll see these techniques in the succeeding subsections.0"> . where you would indicate the namespace URI: <?xml version="1.com/xml/ns/jaxb" version="2.sun.0" encoding="UTF-8"?> <jaxb:bindings xmlns:jaxb="http://java.2 Defining Package Names Some Java entities don't have a counterpart in an XML schema. and for overriding the compiler's defaults for binding schema definitions to Java classes. ususally of file type .ruleml -d gen-src RuleML.. is neither flexible enough nor easy to maintain. One of these things is the package name.

Usually it is more convenient to fix the XML schema.sun.xsd" node="/xsd:schema"> <jaxb:schemaBindings> <jaxb:package name="travel.com/xml/ns/jaxb" version="2.xjb -d gen-src RuleML. The value of the node attribute is an XPath expression referring to that outermost element.org/2001/XMLSchema" jaxb:version="2.xsd" node="/xsd:schema"> <jaxb:schemaBindings> <jaxb:package name="travel.0"> <jaxb:schemaBindings> <jaxb:package name="jess. with the inner ones being associated with some xsd:schema element.ruleml"/> </jaxb:schemaBindings> </jaxb:bindings> A slightly more complicated element structure is necessary if you want to compile several schema files in one run and the classes resulting from different schemata should emerge in separate packages. the outermost element of an XML schema.com/xml/ns/jaxb" xmlns:xsd="http://www.flight"/> </jaxb:schemaBindings> </jaxb:bindings> <jaxb:bindings schemaLocation="Hotel.sun. Let's assume that you have a schema where a complex type has been given the uninspired name List: <xsd:complexType name="List"> <xsd:sequence> .0"> <jaxb:bindings schemaLocation="Flight.You pass the file name to the schema compiler: xjc -b RuleML.hotel"/> </jaxb:schemaBindings> </jaxb:bindings> </jaxb:bindings> Now we have nested jaxb:bindings elements. Here is an example: <?xml version="1. but you may not always be at liberty to do so.0" encoding="UTF-8"?> <jaxb:bindings xmlns:jaxb="http://java. 5. Notice that it's necessary to define the mapping of the XML Schema namespace prefix (here: xsd) to its URI in the top-level jaxb:bindings element.0" encoding="UTF-8"?> <jaxb:bindings xmlns:jaxb="http://java.xsd To put all of your classes into the same package you define the package name in a jaxb:schemaBindings element at the outermost level: <?xml version="1.w3.3 Overriding Names Overriding the name of a class or of an element's child is something you may have to do to avoid name clashes.

util..) <xsd:complexType name="ClassType"> <xsd:sequence> <xsd:element name="grade" type="xsd:string" minOccurs="0"/> </xsd:sequence> <xsd:attribute name="grade" type="xsd:string" use="optional"/> </xsd:complexType> . believe me. JAXB's workaround is the standard programmer's choice. But. i. like this: <xsd:complexType name="School"> <xsd:sequence> <xsd:element name="class" type="ClassType"> <xsd:annotation> <xsd:appinfo> <jxb:property name="klass"/> </xsd:appinfo> </xsd:annotation> </xsd:element> </xsd:sequence> </xsd:complexType> Other Java keywords won't constitute a problem. To avoid having to use the full class name for one of these two classes. you can request your own substitute. Yet another reason for changing a name arises from the use of the same name for a sub-element and an attribute within the same complex type definition. If you don't fancy this.e.List.util. required within the generated class code for declaring the field items. it is replaced by Clazz. you might override the class name for the generated class: <xsd:complexType name="List"> <xsd:annotation> <xsd:appinfo> <jxb:class name="MyListType"/> </xsd:appinfo> </xsd:annotation> <xsd:sequence> <xsd:element name="items" type="ItemType" minOccurs="0" maxOccurs="unbounded"/> </xsd:sequence> </xsd:complexType> Another unlucky choice for the name of an element or attribute would be Class.<xsd:element name="items" type="ItemType" minOccurs="0" maxOccurs="unbounded"/> </xsd:sequence> </xsd:complexType> JAXB's schema compiler circumnavigates the threatening name clash between this class and java. The instance variable will be given a name consisting of an underscore followed by the letters of the keyword. But wherever this class is used it is potentially in conflict with its namesake from java. using an jxb:property element. For this one. it does happen. (Arguably this isn't good XML design.

<?xml version="1. by renaming either element: . as part of the type definition in your schema.sun. this time by specifying the property name in the bindings file.w3.We'll resolve this conflict by renaming the attribute to gradeAttr. 5.0" encoding="UTF-8"?> <jaxb:bindings xmlns:jxb="http://java. Documentation is probably best written inline. <xsd:element name="taga" type="xsd:string"> <xsd:annotation> <xsd:appinfo> <jxb:property name="taga2"/> </xsd:appinfo> </xsd:annotation> </xsd:element> .0"> <jxb:bindings schemaLocation="School.com/xml/ns/jaxb" xmlns:xsd="http://www. You must help the schema compiler to resolve this conflict. Here is one way of adding some documentation for a class derived from a complex type definition: . it conveys nothing about the intentions behind the schema itself.4 Adding Documentation Both the readers of your XML schema and the users of the generated Java classes will be more than grateful for each morsel of documentation... JAXB does a good job by providing most if not all of the Javadoc that can be generated automatically..xsd" node="/xsd:schema"> <jxb:bindings node="//xsd:attribute[@name='grade']"> <jxb:property name="gradeAttr"/> </jxb:bindings> </jxb:bindings> </jxb:bindings> XML Schema even lets you define a sequence where two individual elements have the same tag <xsd:complexType name="StrangeType"> <xsd:sequence> <xsd:element name="taga" type="xsd:string"/> <xsd:element name="tagb" type="xsd:string"/> <xsd:element name="taga" type="xsd:string"/> </xsd:sequence> </xsd:complexType> There is no such thing as a Java class that has two distinct fields with the same name. This way it remains close to the schema text it refers to and documents (not quite perfectly) the XML schema itself..org/2001/XMLSchema" jxb:version="2. While this is good at describing the relation between the generated Java code and the originating chunks of the XML schema.

(Another possibility is writing the text as a CDATA section." and "&amp. . see below..e. The variable name must begin and end with an asterisk ('*'). It can be written at the outermost level of the schema. i. you add a child as shown in the example below. <xsd:element name="elemA" type="xsd:string"> <xsd:annotation> <xsd:appinfo> <jxb:property> <jxb:javadoc> This documents a property which happens to be an XML Schema element. For either of these schema components. <xsd:schema> . Your browser will show you this text as the head of the documentation for the class GlobalType: public class GlobalType extends AssignmentType A GlobalType object represents a single defglobal variable definition. The variable name must begin and end with an asterisk ('*').code>GlobalType&lt."..) The text is added up front to the Javadoc text JAXB will provide anyway./code> object represents a single defglobal variable definition.<xsd:complexType name="GlobalType"> <xsd:annotation> <xsd:appinfo> <jxb:class> <jxb:javadoc> A &lt. </jxb:javadoc> </jxb:property> </xsd:appinfo> </xsd:annotation> </xsd:element> Finally. "<" and "&" must be written as "&lt. Java class for GlobalType complex type.. we'll look at a snippet as it might be included to appear as package level documentation. </jxb:javadoc> </jxb:class> </xsd:appinfo> </xsd:annotation> <xsd:complexContent> <xsd:extension base="AssignmentType"/> </xsd:complexContent> </xsd:complexType> Notice that any XML markup requires the escaping of all less-than and ampersand characters. Documentation for elements and attributes is added in a similar manner.

First. 5.jessml"> <jxb:javadoc> <![CDATA[<body>This package contains classes derived from the XML schema JessML2_0. Calling the intern() method on a String returns a string that has the same contents as this string. we customize a small change for the mapping of xsd:string to String. including their subordinate elements. but is guaranteed to be from a pool of unique strings. This may reduce your memory footprint considerably. } .jessrules. Two documents are supported: <ol> <li>rulebase documents containing Jess constructs and function calls <li>fact-list documents containing the result of a call to <code>save-facts-xml</code> </ol> </body>]]> </jxb:javadoc> </jxb:package> </jxb:schemaBindings> </xsd:appinfo> </xsd:annotation> This example features the XML technique for including arbitrary content as a CDATA section..xml. So.5 Interning Strings If your XML data contains a large number of strings with many repetitions it may be well worth interning these strings..parseStringToString"/> </jaxb:globalBindings> The other thing is to write the class StringInterner which contains a tiny wrapper for the method parseString from DatatypeConverter: package faststring.StringInterner. is there a simple method for interning all strings resulting from unmarshalling? There is only two things to do. to sneak in our own method for parsing the XML string data to a Java string. <jaxb:globalBindings> <jaxb:javaType name="String" xmlType="xsd:string" parseMethod="faststring.intern(). <xsd:annotation> <xsd:appinfo> <jxb:schemaBindings> <jxb:package name="com. It enables you to write HTML tags in a more readable way. public class StringInterner { public static String parseStringToString( String value ){ return DatatypeConverter.parseString( value ). import javax.DatatypeConverter. They represent XML element content for Jess constructs and function calls..bind.

100. 500 ).Map. for( Map. and the standard conversion of values between binary and string is just what you need.1 Replacing the Conversions Most of the time JAXB's mapping of XML Schema types to Java datatypes will meet your expectations. 1 }.) Although the XML type is xsd:string. entry.put( 'L'.HashMap. For this. 5 ).put( 'D'. 500. package util. we'd like to have these values represented by Java's int.6 Overriding the Datatype 5.util.put( 'M'.Character> int2rom = new HashMap<Integer. it is possible to customize the datatype binding. private static int[] digits = new int[]{ 1000. rom2int. In those rare cases where this is not adequate.put( 'C'. } .put( 'I'. 100 ).Integer> entry: rom2int.put( 'V'. private static Map<Integer. 50 ). 1000 ).Integer> rom2int = new HashMap<Character.6. as in the next example. This means that we'll also have to supply the conversions between the Roman number as a string of letters and as an integer value.getKey() ).put( 'X'. 10 ). public class RomanNumberConverter { private static Map<Character. we have to write a simple class like the one given below. 1 ). 5. rom2int.Character>().} Peeking at the implementation of DatatypeConverter reveals that parseString just returns its argument. rom2int. 10.put( entry.entrySet() ){ int2rom. rom2int. We'll illustrate this by a simple example where a xsd:simpleType for roman numbers is defined like this: <xsd:simpleType name="RomanNumberType"> <xsd:restriction base="xsd:string"> <xsd:pattern value="M*D?C{. rom2int.4}V?I{.Entry<Character.util. static { rom2int. 5.getValue(). rom2int. import java.Integer>().roman. But its a good strategy to go by the book and call the basic conversion except when we are prepared to do it all on our own.4}"/> <xsd:minLength value="1"/> </xsd:restriction> </xsd:simpleType> (The pattern does not cover the subtractive notation which wasn't used in ancient times anyway.4}L?X{. import java. 50.

bind. i++ ){ result += rom2int. <?xml version="1. .RomanNumberConverter.DatatypeConverter provides a rich set of methods that come in handy whenever the XML representation must follow the specifications in XML Schema Part 2: Datatypes.} public static int parseStringToInt( String value ){ int result = 0. The customizing entry supplied in a bindings file should then look like the one given below.get( value. for( int d: digits ){ while( value > d ){ value -= d.roman.length().w3.com/xml/ns/jaxb" xmlns:xsd="http://www.org/2001/XMLSchema" jaxb:version="1.0"> <jaxb:bindings schemaLocation="roman.parseStringToInt" printMethod="util. with a threefold nesting of <jaxb:bindings> providing the level where you define the schema position with an XPATH expression.append( int2rom.2 Replacing a Simple Type Replacing a simple schema type such as string by some user defined Java type is a little more complicated than what we have seen in the previous section. } public static String printIntToString( int value ){ StringBuilder sb = new StringBuilder(). i < value. We'll discuss the proceedings on the basis of this type definition of a complex type meant to describe integer variables. } } return sb. sb.charAt( i ) ). for( int i = 0. } } There is a useful class that supports the writing of convertes such as this one: javax.xsd" node="/xsd:schema"> <jaxb:bindings node="//xsd:simpleType[@name='RomanNumberType']"> <jaxb:javaType name="int" parseMethod="util. You may choose any names you like.sun.roman.get( d ) ).RomanNumberConverter.xml. but the methods must be static. The essential methods are the ones we'll have to announce to JAXB. so that it will call our methods for the to and fro between the representations.printIntToString"/> </jaxb:bindings> </jaxb:bindings> </jaxb:bindings> 5.toString().6.0" encoding="UTF-8"?> <jaxb:bindings xmlns:jaxb="http://java. } return result.

<xsd:complexType name="VariableType"> <xsd:sequence> <xsd:element name="Value" type="xsd:int"/> </xsd:sequence> <xsd:attribute name="Impl" type="xsd:string"/> </xsd:complexType> The type we want to replace by customization is the one for the attribute Impl which is to be represented by the following enum type. package impl; public enum ImplType { UINT8( 1, false ), INT8( 1, true ), // ... UINT64(4,false), INT3644,true); private final int bytes; private final boolean signed; ImplType( int b, boolean s ) { bytes = b; signed = s; } } The utility class providing the conversions between a string representation and the enum constants is easy. package impl; import java.util.*; public class ImplConv { public static ImplType parseStringToEnum( String value ){ return ImplType.valueOf( ImplType.class, value ); } public static String printEnumToString( ImplType impl ){ return impl.toString(); } } Now we are prepared to set up the bindings file such as the one shown below, in full. Notice the progressive restriction of the scope for the binding specifications, first restricted to a specific schema (i.e., signal.xsd, then to the complex type definition for VariableType, and finally to its Impl attribute node. Also, the binding syntax requires that now, when we're substituting a type of our own for a base type, the <jaxb:javaType> element must be enclosed in a <jaxb:baseType>, and this, in turn, must be wrapped by a <jaxb:property element. <?xml version="1.0" encoding="UTF-8"?> <jaxb:bindings xmlns:jaxb="http://java.sun.com/xml/ns/jaxb" xmlns:xsd="http://www.w3.org/2001/XMLSchema" jaxb:version="2.0"> <jaxb:bindings schemaLocation="signal.xsd" node="/xsd:schema"> <jaxb:schemaBindings>

<jaxb:package name="signal"/> </jaxb:schemaBindings> <jaxb:bindings node="//xsd:complexType[@name='VariableType']"> <jaxb:bindings node="./xsd:attribute[@name='Impl']"> <jaxb:property> <jaxb:baseType> <jaxb:javaType name="impl.ImplType" parseMethod="impl.ImplConv.parseStringToEnum" printMethod="impl.ImplConv.printEnumToString"/> </jaxb:baseType> </jaxb:property> </jaxb:bindings> </jaxb:bindings> </jaxb:bindings> </jaxb:bindings> You can glean the reward of your pains from looking at the generated code for the impl field of VariableType which lets you now deal with this attribute via ImplType enums, e.g.,: ObjectFactory of = new ObjectFactory(); VariableType var = of.createVariableType(); var.setValue( 42 ); var.setImpl( ImplType.INT16 );

6 JAXB Annotations 6.1 How a Schema Mapping Is Implemented The Java code generated by the JAXB schema compiler contains annotations providing metadata on packages, classes, fields and methods. Together, this metadata is intended to reflect the information contained in an XML schema, of which only a very small part can be expressed by the actual Java code. Annotations can be easily retrieved from their target construct with methods contained in classes such as java.lang.Class or java.lang.reflect.Field. Each annotation type has its own set of attributes, which are accessed in the usual way. Given some class, an annotation of type XmlType can be retrieved with Class clazz = ...; XmlType typeAnn = clazz.getAnnotation( XmlType.class ); If the result of the annotation getter is not null, annotation element values may be obtained by calling methods on the returned XmlType object. To retrieve the name of the corresponding XML Schema type you would write String schemaName = typeAnn.name(); Classes that can be used for marshalling and unmarshalling XML need not be generated by the JAXB schema compiler. It is equally possible to write these classes by hand, adding the JAXB annotations. We'll discuss some basic annotations in the next section. 6.2 A Survey Of JAXB Annotations 6.2.1 Top-level Elements: XmlRootElement A class that describes an XML element that is to be a top-level element, i.e., one that can function as an XML document, should be annotated with XmlRootElement. Its optional elements are name and namespace. By default, the class name is used as the name. This annotation corresponds to an xsd:element construct being used at the outermost level of an XML schema. The sequence of Java, XML and schema snippets given below illustrates this relation. @XmlRootElement( name="doc" ) public class Document { @XmlElement protected Foo foo; // ... } <?xml version="1.0" encoding="UTF-8"?> <doc> <foo>...</foo> </doc>

datetime = datetime.Map.program = program. public XMLGregorianCalendar datetime.util. that is even capable of marshalling a Map<K.util.V>. String program ){ this.artists = artists.EntryType> key2entry = new HashMap<KeyType. public KeyType(){} public KeyType( String event.datatype.*. XMLGregorianCalendar datetime ){ this.0" encoding="UTF-8"?> <xsd:complexType name="Foo"> ..*. this.bind.<?xml version="1. public EntryType(){} public EntryType( String artists.xml. import java. import javax. XmlRootElement may be the only annotation you have to make! Here's a small set of classes.xml. you could produce XML data like so: <doc> . } } Applying the usual incantations for creating and marshalling content. </xsd:complexType> <xsd:complexType name="Document"> <xsd:sequence> <xsd:element name="foo" type="Foo"/> </xsd:sequence> </xsd:complexType> <xsd:element name="doc" type="Document"/> It's a surprising fact that if all of your Java classes permit a straightforward mapping to XML Schema. public class KeyType { public String event.EntryType>(). } } public class EntryType { public String program. import java.. public String artists.event = event. public DocType(){ } } import javax.annotation. this.HashMap. @XmlRootElement(name="doc") public class DocType { public Map<KeyType.

2. requesting that the elements title. It defines parameters that are derived from the xsd:schema element.laune.XmlSchema( namespace = "http://www.3 Annotations for the Schema: XmlSchema This annotation can only be used with a package. "items". but isn't implied by a Java class declaration.annotation. according to the Schema Datatypes specification. Below is an example. but you'd have to do something similar if you'd design it yourself. The annotation has several attributes: factoryClass and factoryMethod define the class containing a no-argument method for creating an instance of this class as the equivalent of an empty XML element.. It must be written on a file package-info. @javax.. and key data from value data.java situated in the package.) Here is an example for XmlType. . "cluster" } ) public class Document { . items and cluster should appear in the given order: @XmlRootElement @XmlType( propOrder={ "title". The attribute name provides the XML schema name if you don't want to use the class name. The namespace attribute provides the name of the target namespace.bind.2. The string array value defined by propOrder establishes an ordering of the subelements.E. specifying the namespace and elementFormDefault elements. and the 'T' between the date and the time is just right.xml.<key2entry> <entry> <key> <event>Soiree</event> <datetime>2008-08-23T20:00:00</datetime> </key> <value> <program>Man on the Moon</program> <artists>R. } 6.at/hospital". You can see that JAXB had to "invent" a few tag names for the intermediary element levels separating map entries from each other.2 Annotation for Classes: XmlType This annotation adds information that would be available from a schema type. (It's pretty obvious that there can't be a connection between the textual order of items in a class definition and the order its fields are returned by reflection methods. 6.M</artists> </value> </entry> </key2entry> </doc> The XMLGregorianCalendar is mapped to xsd:dateTime.

} Most objects require nothing but a simple create method.4 The Object Factory: XmlRegistry.0" > For defining namespace prefixes you use the xmlns element of the XmlSchema annotation. The previous example is extended with a namespace definition for the prefix med: @javax..xml. This method is then annotated with XmlElementDecl.annotation.bind.bind. This corresponds to using xmlns:med="http://www. TreeType..xml.at/hospital".at/med" as an attribute in the xs:schema element. an additional factory method for wrapping the "pure" Java object of some class Foo into an element of class JAXBElement<Foo> must be provided.XmlSchema( namespace = "http://www.XmlNsForm. But whenever an element has to be represented as a JAXBElement<?>.laune.bind.annotation.laune. each of which contains a prefix and a namespaceURI element.at/hospital" xmlns:xs="http://www.XmlNs( prefix = "med". annotated with XmlRegistry. This annotation is equivalent to an xs:schema element <xs:schema elementFormDefault="qualified" targetNamespace="http://www. elementFormDefault = javax.org/2001/XMLSchema" version="1.QUALIFIED) package hospital. the unmarshaller must have an object factory with methods for creating all sorts of objects. This is a snippet from some object factory where an element of TreeType is wrapped into a JAXBElement<TreeType>: @XmlElementDecl(namespace = "".at/med" ) }.bind. value).annotation.2.xml. XmlElementDecl To be able to create objects from XML elements.at/hospital" xmlns:tns="http://www.QUALIFIED) package hospital.laune. 6. It contains an array of XmlNs annotations.w3. Therefore. xmlns = { @javax. @XmlRegistry public class ObjectFactory { .xml.elementFormDefault = javax. namespaceURI = "http://www.annotation.XmlNsForm. name = "tree") public JAXBElement<TreeType> createTree( TreeType value) { return new JAXBElement<TreeType>(_Tree_QNAME.class.laune. each package containing JAXB classes must contain one class ObjectFactory. null. } . providing the components of the element's tag name through the attributes namespace and name.laune.

package-visible or private member is bound if it is annotated with a suitable annotation such as XmlElement or XmlAttribute.e. or public fields.6.2. The first class illustrates a class that restricts the set of XML elements from an accessor type setting of PUBLIC_MEMBER. PROPERTY instructs JAXB to do this for getter and setter pairs. } public void setA( String value ){ . It shows a class with the most restrictive accessor type setting.. with one member explicitly annotated as an element... A class without this annotation inherits the XmlAccessorType setting either from its superclass or from the package setting. Any protected. } @XmlTransient public String getB(){ . setting its value element to one of the enum constants FIELD. PUBLIC_MEMBER or NONE. NONE suppresses bind except for explicitly annotated fields or properties. The other annotation to be mentioned in this context is XmlTransient. } public String getA(){ ..... This is also useful if you have a name clash resulting from a public field.NONE ) . } public void setB( String value ){ . @XmlAccessorType( XmlAccessType. all public members will be bound. public getter and setter pairs. then. public SomeClass(){ . by default... XmlTransient If JAXB binds a class to XML. and methods getFoo and setFoo. It suppresses binding for its target which can be an entire class or a field or a method. PROPERTY. You can annotate a package or a top level class with XmlAccessorType. If FIELD is set every non static. private String b. @XmlAccessorType( XmlAccessType. Member getB is blocked from being bound.PUBLIC_MEMBER ) public class SomeClass { private String a.. You have several possibilities to influence this default behaviour.5 Controlling Element Selection: XmlAccessorType. } } The corresponding XML schema type definition looks like this: <xs:complexType name="someClass"> <xs:sequence> <xs:element name="a" type="xs:string" minOccurs="0"/> </xs:sequence> </xs:complexType> The second example illustrates the reverse process. non transient field will be automatically bound.. i. say foo.

. with changes being made on the list object. } } The generated complex type features both elements.. } @XmlElement public List<String> getB(){ if( b == null ) b = new ArrayList<String>().. which doesn't have its setB spouse..public class OtherClass { private String a.. <xs:complexType name="specialClass"> <xs:sequence> <xs:element name="a" type="xs:string" minOccurs="0"/> ... First..) @XmlAccessorType( XmlAccessType.. private String b. } @XmlElement( required = true ) public String getB(){ ... } public String getA(){ . return b. Second. XmlTransient is used on the public field to avoid the name clash with the method pair... public OtherClass(){ . } public void setA( String value ){ .. (The getter follows the standard pattern of the JAXB generated Java code for elements bound to List<?>. the generated schema snippet is slightly different: <xs:complexType name="otherClass"> <xs:sequence> <xs:element name="b" type="xs:string"/> </xs:sequence> </xs:complexType> The final example for this topic demonstrates using these annotations in somewhat special circumstances. } public void setB( String value ){ .PUBLIC_MEMBER ) public class SpecialClass { @XmlTransient public String a. } public String getA(){ ... } } Since we have set the annotation element required to true. private List<String> b. } public void setA( String value ){ . XmlElement is used to request binding for getB. public SpecialClass(){ .

e. This strategy may be generally permissive. 6.2. there is a gap between what can be defined in an XML schema and the information available from field definitions within a Java class...g.class. as shown in the example below: @XmlSeeAlso( {Dog.6 Class Inclusion: XmlSeeAlso The annotation XmlSeeAlso instructs JAXB to include the specified classes in the set of recognized classes. The typical case where this is required is for the subclasses of some class that is included.<xs:element name="b" type="xs:string" maxOccurs="unbounded" minOccurs="0"/> </xs:sequence> </xs:complexType> Taken together. required = true) protected List<SysWorkplaceType> workplace. @XmlElement(name = "Preamble". You use XmlSeeAlso on some class. or restrictive. this means that you can. the namespace. <xsd:sequence> <xsd:element name="Preamble" type="com:PreambleType"/> <xsd:element name="Workplace" type="SysWorkplaceType" minOccurs="1" maxOccurs="unbounded"/> </xsd:sequence> If a field has some collection type. respectively. Cat. i. or you may inhibit bindings using the XmlTransient annotation.2.1 The Annotation XmlElement The basic annotation for a field that's intended to be an element is XmlElement. and below is the corresponding schema snippet. @XmlElement(name = "Workplace". 6. required = true) protected PreambleType preamble. you may extend a restrictive setting by adding XmlElement or XmlAttribute.. Once more. This requires that these annotations are assembled in a XmlElements (not the plural "s") annotation that merely acts as a container. whether it is optional or nillable.7. in contrast to those classes that are statically referenced. e. more than one @XmlElement may have to be associated with this field. permitting nothing by default. oriented on fields or properties. a default value and the Java class. } 6. It permits you to define the XML element name.class} ) class Animal { //.. In the . because they are used as types for a field.2.7 Annotations for Fields Fields of a class may correspond to XML elements. Here are two annotated fields. define the strategy for all classes within the package or for all subclasses. Within a class. the ones that are bound to schema elements. either at package level or at some superclass.

class). type = ItemType. the field entryOrChoiceOrCascade is a collection composed from objects of three different classes. } results in <sentence> <word>This is terse</word> </sentence> Needless to say. the addition of XmlList @XmlType class Sentence { @XmlElement @XmlList List<String> word. The annotated class Sentence @XmlType class Sentence { @XmlElement List<String> word.2 The Annotation XmlList The attribute XmlList instructs JAXB that a list value is to be represented as a blank separated list of values of some simple type rather than a list of individual child elements.7. } produces XML such as <sentence> <word>This</word> <word>is</word> <word>verbose</word> </sentence> In contrast.class definition below.2. type = MenuType. 6. } As a bonus you may avoid the complicated name for the list element that JAXB concocts from the first three possibles. @XmlElement(name = "Menu". using the XML representation of lists for strings is risky unless you . @XmlElement(name = "CheckBox". @XmlType(name = "MenuType") public class MenuType extends ItemType { @XmlElements({ @XmlElement(name = "Item".class).class) }) protected List entryList. type = CheckBoxType.

remember the restriction for XML Schema's xsd:list. which is only valid for types that are simple according to XML Schema rules. Also. then the simple answer is: "Do it yourself. the default being the class field's name. Now consider this simple Java class with a single instance variable: public class Price { private BigDecimal amount. with one element or attribute for each field. is a good example.4 Mapping a Class to Simple Content or Simple Type: XmlValue Usually a Java class results in a complex type. -. of course. } is bound to fail as soon as JAXB inspects the annotations.2.7.can be sure that no string value contains a blank. the schema describing the XML Schema language itself.3 Class Fields as Attributes: XmlAttribute Provided that XML lets you represent a data item as a single value. If you ask about some way for defining the equivalent for the XML Schema attribute default="value". This has the same effect as an XML Schema definition where the attribute element's attribute fixed is set to that value. (The Java compiler has no way of knowing that something is amiss here. (If you look for guidance.) JAXB. The annotation for creating an XML attribute is XmlAttribute.7. @XmlAttribute final static int answer = 42.A "true" value of required is the same as using the XML Schema definition's attribute use="required". It's possible to annotate a static final field with XmlAttribute. there is no cutand-dried rule for deciding between using an element or an attribute." Just write the getter so that it returns the default value if the field's value is null. List<Sentence> word. -.Sentence isn't a simple type. A class such as Paragraph @XmlType class Paragraph { @XmlElement @XmlList // Not valid . 6.2. Its elements correspond to what can be defined in an XML schema: -. making judicious use of both.name defines the namestring for the attribute.namespace specifies the XML target namespace to be used for the attribute's name. has to be told when to make a field into an XML attribute.) 6. public Price(){} @XmlElement .

e. too.. } This is now equivalent to this simple type definition: <xs:simpleType name="price"> <xs:restriction base="xs:decimal"/> </xs:simpleType> The XML data is pleasantly reduced to: <price>123.45</price> Notice that fields of type Price could now be mapped to an XML attribute.5 Collecting Unspecified Attributes: XmlAnyAttribute An XML element may carry attributes which aren't defined in the XML schema. @XmlValue public BigDecimal getAmount(){ return amount.2.7. This is done by annotating the single field amount with XmlValue instead of XmlElement: public class Price { // .: <price> <amount>123. . the result will be according to this XML Schema type definition: <xs:complexType name="price"> <xs:sequence> <xs:element name="amount" type="xs:decimal" minOccurs="0"/> </xs:sequence> </xs:complexType> The marshalled XML data is unnecessarily complicated due to an addtional element layer. or have no explicit mapping to some field in the Java class defining the element type. } public void setAmount( BigDecimal value ){ this. 6.amount = value..45</amount> </price> What is required here is a way of telling JAXB to map class Price to a simple schema type. } } If this type is used for some field. } // ...public BigDecimal getAmount(){ return amount.g.

public MixtureType(){} @XmlAnyAttribute public Map<QName.println( "Title: " + mix. Here is an example using the annotation XmlAnyAttribute: public class MixtureType { private Map<QName.unmarshal( new File( "mixture.out.getValue() + """ ).println( e. } } Let's assume that the top level element of type DocumentType contains nothing but one MixtureType element.xml" ) ).Object>. System.Object> any.getMixture(). } This is the resulting output: A mixture of elements foo="a foo attribute" . } @XmlElement public String getTitle(){ return title. Map<QName. an XML data file that can be unmarshalled into an object of this class would look like this: <document> <mixture foo="a foo attribute" bar="attribute of bar"> <title>A mixture of elements</title> </mixture> </document> After unmarshalling this into a DocumentType object.getValue().Object> amap = mix. the sub-element and its spurious attributes can be extracted like this: JAXBElement<DocumentType> jbe = (JAXBElement)u. } return any. MixtureType mix = doc.entrySet() ){ System.Entry<QName. for( Map.getTitle() ).getAny(). Then.Object>().getKey() + "="" + e.Object> getAny(){ if( any == null ){ any = new HashMap<QName.out.It's possible to collect these unspecified attributes into a map with the type Map<QName. DocumentType doc = jbe. } public void setTitle( String value ){ title = value.Object> e: amap. private String title.

*.getAnimals() ){ System. DocumentType doc = (DocumentType)u.annotation. Unmarshaller u = jc.dom.out.6 Collecting Unspecified Elements: XmlAnyElement Arbitrary content is indicated by the XML Schema type xsd:anyType. (We have already seen that this corresponds to an object of type org. cf. public ZooType(){ } @XmlAnyElement public List<Element> getAnimals(){ if( animals == null ) animals = new ArrayList<Element>().) The annotation XmlAnyElement instructs JAXB to map a field to a DOM Element object. defining the structure of the element tagged zoo as a list of DOM elements: import java.getTextContent() ). for( Element el: doc.bind.Element.w3c. import org.*.util.2.dom. or an array or list of such elements. public class ZooType { protected List<Element> animals.xml.createUnmarshaller(). import javax. } } Unmarshalling and accessing this data is done like this: JAXBContext jc = JAXBContext. return animals. Let's say that we want to unmarshal XML data with arbitrary tags and some text content.: <document> <zoo> <a>Anaconda</a> <b>Buffalo</b> <c>Chameleon</c> <d>Dromedar</d> </zoo> </document> The interesting class is ZooType. } .getZoo().Element.newInstance( DocumentType.g. e.println( el. subsection DOM Elements.7.w3c.getNodeName() + "->" + el. } public void setAnimals( List value ){ animals = value.bar="attribute of bar" 6.unmarshal( f ).class ).

XmlMixed An XML complex type with mixed content. as indicated in the XML snippet below.2. JAXB binds such a type to a class containing a single list attribute typed List<JAXBElement>. for the repeated element. or "wrapping". @XmlType( name="ParentType" ) public class ParentType { protected List item.8 Annotations for Mixed Content: XmlElementRef. you need some additional element bracketing. <parent> <wrapper> <item>A</item> <item>B</item> <item>C</item> </wrapper> </parent> You instruct JAXB to generate this additional element by adding the annotation XmlElementWrapper to a collection type attribute.7 Wrapping Repeated Elements: XmlElementWrapper With a repeatable XML element you may want to distinguish between a list that is absent and an empty list. child elements embedded in the element's own data. Here is a schema snippet for a complex type with mixed content: <xs:complexType name="MessageType" mixed="true"> <xs:sequence> <xs:element name="id" type="xs:int"/> <xs:element name="code" type="CodeType"/> </xs:sequence> </xs:complexType> .7.7. } @XmlElement( name="item" ) @XmlElementWrapper( name="wrapper" ) public List getItem(){ if( item == null ) item = new ArrayList()..2. i..e.The resulting output looks like this: a->Anaconda b->Buffalo c->Chameleon d->Dromedar 6. } } 6. For this. cannot be bound to a class in the usual bean style. Doing so would lose the order of the sub-elements and the chunks of content text wherein they are embedded. public ParentType(){ .. with one field for each element and attribute. and another one for the content text. return item.

@XmlElementRef(name = "id".class). A similar but rarely encountered situation is created by duplicating an element in a sequence. type = JAXBElement.class). type = JAXBElement.class). type = JAXBElement.To achieve the same effect with an annotated class. which doesn't have mixed content any more. you'll have to distinguish between JAXBElement objects for the sub-elements and String objects for the chunks of the content of the element itself. propOrder = { "content" } ) public class Message { @XmlElementRefs({ @XmlElementRef(name = "id". slightly more specific than Object.FIELD) @XmlType(name = "MessageType". @XmlElementRef(name = "code". } return this. @XmlAccessorType(XmlAccessType. propOrder = { "content" }) public class MessageType { @XmlElementRefs( { @XmlElementRef(name = "code".class) }) protected List<JAXBElement<?>> content. you would write an annotated Java class like this: @XmlAccessorType(XmlAccessType. Below is a slightly modified version of the schema snippet for the complex type MessageType.FIELD) @XmlType(name = "Message".content. When you process the elements of the content list after unmarshalling. type = JAXBElement. but contains a repetition of element id (ours not to worry why): <xs:complexType name="MessageType"> <xs:sequence> <xs:element name="id" type="xs:int"/> <xs:element name="code" type="CodeType"/> <xs:element name="id" type="xs:int"/> </xs:sequence> </xs:complexType> The annotated Java code would be similar to the one shown previously. except that XmlMixed is omitted and the generic parameter for List should be JAXBElement<?>. type = JAXBElement. @XmlElementRef(name = "id". } } The generic parameter for the content list is Serializable.class) }) @XmlMixed protected List<Serializable> content. public List<JAXBElement<?>> getContent() { . public List<Serializable> getContent() { if (content == null) { content = new ArrayList<Serializable>().

.. // . } public static SubElemType fromValue(String v) { . are equally possible. } public String value() { return value.2.content.lang. If it might be useful for the Java application to have support for the conversion between Java values and XML representations as well. even numeric ones. provide a getter for the XML string and perhaps even a lookup function (fromValue) to convert a string to the enum constant.. For a straightforward enum type. 6. this is java. and by default. Its required element defines the XML representation string. This is defined with an @XmlEnumValue annotation that is attached to individual enum constants. with arbitrary alternations of all three elements. } return this. Such a deluxe version of an enum type is shown below. Usually. XmlEnumValue An enum type is annotated with XmlEnum. @XmlEnumValue("Track1") TRACK_1("Track1"). marshal or unmarshal many more sub-element sequences than the one shown in the schema snippet.Class which defines the class used for the values used in the XML representation. in fact. this is sufficient: @XmlEnum public enum SubElemType { //.8 Annotations for Enums: XmlEnum.(enum definition) } Individual enum constants have to be annotated if there is a difference between the Java name and the string used to represent the value in XML. } } This does. SubElemType(String v) { value = v.lang.String but other types. It has an optional element value of type java.. the enum type might define the XML representation as a parameter for the constructor.(more enum constant definitions) private final String value. @XmlEnum public enum SubElemType { @XmlEnumValue("PrMaSig") PR_MA_SIG("PrMaSig").if (content == null) { content = new ArrayList<JAXBElement<?>>().

45" id="c1"> <name>Course 1</name> </course> <course price="123. <?xml version="1.45" id="c0"> <name>Course 0</name> </course> </brochure> </ns:training> The course elements could be represented as a list or array. i. The annotation XmlJavaTypeAdapter is provided for announcing the adapter in the desired place.annotation.0" encoding="UTF-8" standalone="yes"?> <ns:training xmlns:ns="http://foo/bar"> <brochure> <course price="123.value. public Training(){} public Training( Brochure b ){ brochure = b. we write a class Brochure containing the map we have in mind and declare that this is the one that has to be adapted to something JAXB knows how to handle. the class Courses containing a simple array of Course objects.class) .values()) { if (c.bind. } } @XmlJavaTypeAdapter(BrochureAdapter. } } 6. Such mappings require an adapter class.e. @XmlRootElement(name="training") public class Training { @XmlElement public Brochure brochure.ApplType> from the package javax. Although JAXB is capable of handling maps. To achieve our goal. } } throw new IllegalArgumentException(v.2. Here is an XML example of the data we have to deal with.. you may want to represent Java types in a way that is entirely different from what JAXB is apt to do.xml.adapters. written as an extension of XmlAdapter<XmlType. We'll illustrate adapters by defining a substitution of a map for an array.9 Type Adapters: XmlJavaTypeAdapter For some Java container types JAXB has no built-in mapping to an XML structure.equals(v)) { return c.toString()).for (SubElemType c: SubElemType. but we would like to process this data in our application as a map of the id attribute to the Course object. we have seen (in section Top-level Elements: XmlRootElement) that the resulting XML structure isn't as simple as possible. Also.

} Class Brochure is annotated with XmlJavaTypeAdapter.size()]). and this is. return b. .put( c.Brochure> { @Override public Brochure unmarshal( Courses value ){ Brochure b = new Brochure(). } @Override public Courses marshal( Brochure b ){ Courses courses = new Courses(). } } public class Courses { @XmlElement(name="course") public Course[] carray. whereas application programming uses the Map type field courses in class Brochure. public class BrochureAdapter extends XmlAdapter<Courses. Collection<Course> c = b. @XmlElement String name. The reverse marshalling process has to convert a Brochure object with its map to a Courses object. } public class Course { @XmlAttribute String id. we convert the data to a structure according to the desired class Brochure with its map. courses.public class Brochure { Map<String. Course>(). which is easily done by putting the map values into an array.courses. return courses. It has to override methods unmarshal and marshal. the interesting class.carray = c. of course.id. } } Courses is a class JAXB knows how to handle with respect to XML data.Course> courses. defining class BrochureAdapter as its adapter.toArray(new Course[c. In this method. c ). @XmlAttribute Price price.carray ) b. public Brochure() { courses = new HashMap<String. for( Course c : value. and the result of JAXB's innate capabilities is passed to the adaption for unmarshalling. To summarize: XML binding happens against the class Courses.values().courses.

text. If you need multiple mappings at package level.6. i. XmlJavaTypeAdapter. but every now and then an alternative may be more convenient.toString(). } public class String2StrBuf extends XmlAdapter<String.2. TextType elements are now StringBuffers. } } Within the Java code that unmarshals or marshals an instance document. Two annotations instruct JAXB to use references: XmlID must define a field of some class with type java. Both annotations may be used in addition to XmlElement. 6. and XmlIDREF is attached to any field that references objects of that class.strbuf = new StringBuffer( "This is the house" ). one defining TextType as a container for a string. text. you'll have to bundle the XmlSchemaType annotations in an XmlSchemaTypes (note the plural) annotation. public class TextType { @XmlElement @XmlSchemaType(name="string") @XmlJavaTypeAdapter( String2StrBuf.10 Type Mapping: XmlSchemaType The annotation XmlSchemaType defines a mapping between an arbitrary Java type and a simple schema built-in type.11 Annotations for Object References: XmlID. Below are the essential Java classes.: TextType text = new TextType(). Most of the time the default mapping is satisfactory.strbuf.String that is suited to be used as a key. which is the default mapping for xs:string.. Notice that the latter class is specified in a separate annotation. XmlIDREF The section Referring to Another XML Element describes the usefulness of using references rather than repeatedly serialized content. Such a type mapping can be defined either for an individual element or for all occurrences within a package. } @Override public StringBuffer unmarshal( String string ){ return new StringBuffer( string ). // . and the type adapter class for the simple conversion between String and StringBuffer. Let's assume that the processing of chunks of text requires their extension.e.g. For this." ). either after unmarshalling or before the emitting marshalling. a StringBuffer is better than String. and the XmlJavaTypeAdapter annotiations are packed into a single XmlJavaTypeAdapters annotation. .append( " that Jack built..lang.class ) public StringBuffer strbuf.2..StringBuffer> { @Override public String marshal( StringBuffer strbuf ){ return strbuf. e.

bind.ArrayList. } } import java. } } package elset. public Cluster(){ .*.annotation.bind.. } public void setId( String value ){ . import java.xml.*... } public void setName( String value ){ .We'll illustrate an application of these annotations in a somewhat more sophisticated pattern resulting from the possibility of attaching XmlIDREF to a field of some collection type.. import javax. private String title.util.xml. @XmlRootElement public class Document { .*. public class Cluster { private Set<Item> items. } @XmlIDREF public Set<Item> getItems(){ . private String name.util.bind. public class Item { private String id.util. The latter contains a list of existing items and a Cluster object that wraps a Set<Item> field containing references to some of the items from the list.List..annotation...xml. import java.HashSet....util. import javax. the collection item type must contain an id field.annotation. } @XmlElement public String getName(){ . Below is a group of Java classes defining an Item class and a Document class.Set. import java. import javax.. In this case.. public Item(){} @XmlID public String getId(){ .

... } public void setTitle( String value ){ .. public Document(){ .. } } --. private String title.. } @XmlElement public Cluster getCluster(){ . } @XmlElement public List<Item> getItems(){ . } public void setCluster( Cluster value ){ . private List<Item> items.....private Cluster cluster. } @XmlElement public String getTitle(){ .END --- ...

Sign up to vote on this title
UsefulNot useful