java.lang.Object javax.xml.bind.JAXBContext
public abstract class JAXBContext
The JAXBContext class provides the client's entry point to the JAXB API. It provides an abstraction for managing the XML/Java binding information necessary to implement the JAXB binding framework operations: unmarshal, marshal and validate.
A client application normally obtains new instances of this class using one of these two styles for newInstance methods, although there are other specialized forms of the method available:
SPEC REQUIREMENT: the provider must supply an implementation class containing the following method signatures:public static JAXBContext createContext( String contextPath, ClassLoader classLoader, Mapproperties ) throws JAXBException public static JAXBContext createContext( Class[] classes, Map properties ) throws JAXBException The following JAXB 1.0 requirement is only required for schema to java interface/implementation binding. It does not apply to JAXB annotated classes. JAXB Providers must generate a jaxb.properties file in each package containing schema derived classes. The property file must contain a property named javax.xml.bind.context.factory whose value is the name of the class that implements the createContext APIs.
The class supplied by the provider does not have to be assignable to javax.xml.bind.JAXBContext , it simply has to provide a class that implements the createContext APIs.
In addition, the provider must call the DatatypeConverter.setDatatypeConverter api prior to any client invocations of the marshal and unmarshal methods. This is necessary to configure the datatype converter that will be used during these operations.
The Unmarshaller class provides the client application the ability to convert XML data into a tree of Java content objects. The unmarshal method allows for any global XML element declared in the schema to be unmarshalled as the root of an instance document. Additionally, the unmarshal method allows for an unrecognized root element that has an xsi:type attribute's value that references a type definition declared in the schema to be unmarshalled as the root of an instance document. The JAXBContext object allows the merging of global elements and type definitions across a set of schemas (listed in the contextPath ). Since each schema in the schema set can belong to distinct namespaces, the unification of schemas to an unmarshalling context should be namespace independent. This means that a client application is able to unmarshal XML documents that are instances of any of the schemas listed in the contextPath . For example:JAXBContext jc = JAXBContext.newInstance( "com.acme.foo:com.acme.bar" ); Unmarshaller u = jc.createUnmarshaller(); FooObject fooObj = (FooObject)u.unmarshal( new File( "foo.xml" ) ); // ok BarObject barObj = (BarObject)u.unmarshal( new File( "bar.xml" ) ); // ok BazObject bazObj = (BazObject)u.unmarshal( new File( "baz.xml" ) ); // error, "com.acme.baz" not in contextPathThe client application may also generate Java content trees explicitly rather than unmarshalling existing XML data. For all JAXB-annotated value classes, an application can create content using constructors. For schema-derived interface/implementation classes and for the creation of elements that are not bound to a JAXB-annotated class, an application needs to have access and knowledge about each of the schema derived ObjectFactory classes that exist in each of java packages contained in the contextPath . For each schema derived java class, there is a static factory method that produces objects of that type. For example, assume that after compiling a schema, you have a package com.acme.foo that contains a schema derived interface named PurchaseOrder . In order to create objects of that type, the client application would use the factory method like this:
com.acme.foo.PurchaseOrder po = com.acme.foo.ObjectFactory.createPurchaseOrder();Once the client application has an instance of the the schema derived object, it can use the mutator methods to set content on it.
For more information on the generated ObjectFactory classes, see Section 4.2 Java Package of the specification.
SPEC REQUIREMENT: the provider must generate a class in each package that contains all of the necessary object factory methods for that package named ObjectFactory as well as the static newInstance( javaContentInterface ) method
Marshalling
The Marshaller class provides the client application the ability to convert a Java content tree back into XML data. There is no difference between marshalling a content tree that is created manually using the factory methods and marshalling a content tree that is the result an unmarshal operation. Clients can marshal a java content tree back to XML data to a java.io.OutputStream or a java.io.Writer . The marshalling process can alternatively produce SAX2 event streams to a registered ContentHandler or produce a DOM Node object. Client applications have control over the output encoding as well as whether or not to marshal the XML data as a complete document or as a fragment.Here is a simple example that unmarshals an XML document and then marshals it back out:
JAXBContext jc = JAXBContext.newInstance( "com.acme.foo" ); // unmarshal from foo.xml Unmarshaller u = jc.createUnmarshaller(); FooObject fooObj = (FooObject)u.unmarshal( new File( "foo.xml" ) ); // marshal to System.out Marshaller m = jc.createMarshaller(); m.marshal( fooObj, System.out );
Validation
Validation has been changed significantly since JAXB 1.0. The Validator class has been deprecated and made optional. This means that you are advised not to use this class and, in fact, it may not even be available depending on your JAXB provider. JAXB 1.0 client applications that rely on Validator will still work properly when deployed with the JAXB 1.0 runtime system. In JAXB 2.0, the Unmarshaller has included convenince methods that expose the JAXP 1.3 javax.xml.validation framework. Please refer to the Unmarshaller.setSchema(javax.xml.validation.Schema) API for more information.
JAXB Runtime Binding Framework Compatibility
The following JAXB 1.0 restriction only applies to binding schema to interfaces/implementation classes. Since this binding does not require a common runtime system, a JAXB client application must not attempt to mix runtime objects ( JAXBContext, Marshaller , etc. ) from different providers. This does not mean that the client application isn't portable, it simply means that a client has to use a runtime system provided by the same provider that was used to compile the schema.
Field Summary | |
---|---|
static String |
JAXB_CONTEXT_FACTORY
The name of the property that contains the name of the class capable of creating new JAXBContext objects. |
Constructor Summary | |
---|---|
protected |
JAXBContext
() |
Method Summary | ||
---|---|---|
Binder < Node > |
createBinder
() Creates a Binder for W3C DOM. |
|
|
createBinder
(
Class
<T> domType) Creates a Binder object that can be used for associative/in-place unmarshalling/marshalling. |
|
JAXBIntrospector |
createJAXBIntrospector
() Creates a JAXBIntrospector object that can be used to introspect JAXB objects. |
|
abstract Marshaller |
createMarshaller
() Create a Marshaller object that can be used to convert a java content tree into XML data. |
|
abstract Unmarshaller |
createUnmarshaller
() Create an Unmarshaller object that can be used to convert XML data into a java content tree. |
|
abstract Validator |
createValidator
() Deprecated. since JAXB2.0 |
|
void |
generateSchema
(
SchemaOutputResolver
outputResolver) Generates the schema documents for this context. |
|
static JAXBContext |
newInstance
(
Class
... classesToBeBound) Obtain a new instance of a JAXBContext class. |
|
static JAXBContext |
newInstance
(
Class
[] classesToBeBound,
Map
<
String
,?> properties) Obtain a new instance of a JAXBContext class. |
|
static JAXBContext |
newInstance
(
String
contextPath) Obtain a new instance of a JAXBContext class. |
|
static JAXBContext |
newInstance
(
String
contextPath,
ClassLoader
classLoader) Obtain a new instance of a JAXBContext class. |
|
static JAXBContext |
newInstance
(
String
contextPath,
ClassLoader
classLoader,
Map
<
String
,?> properties) Obtain a new instance of a JAXBContext class. |
Methods inherited from class java.lang. Object |
---|
clone , equals , finalize , getClass , hashCode , notify , notifyAll , toString , wait , wait , wait |
Field Detail |
---|
public static final String JAXB_CONTEXT_FACTORY
Constructor Detail |
---|
protected JAXBContext()
Method Detail |
---|
public static JAXBContext newInstance(String contextPath) throws JAXBException
Obtain a new instance of a JAXBContext class.
This is a convenience method for the newInstance method. It uses the context class loader of the current thread. To specify the use of a different class loader, either set it via the Thread.setContextClassLoader() api or use the newInstance method.
public static JAXBContext newInstance(String contextPath, ClassLoader classLoader) throws JAXBException
Obtain a new instance of a JAXBContext class.
The client application must supply a context path which is a list of colon (':', \u003A) separated java package names that contain schema-derived classes and/or
fully qualified
JAXB-annotated classes. Schema-derived code is registered with the JAXBContext by the ObjectFactory.class generated per package.
Alternatively than being listed in the context path, programmer
Programmer
annotated JAXB mapped classes
can be
are
listed in a
jaxb.index
resource file, format described below. Note that a java package can contain both schema-derived classes and user annotated JAXB classes. Additionally, the java package may contain JAXB package annotations that must be processed. (see JLS 3rd Edition, Section 7.4.1. "Package Annotations").
The file should contain a newline-separated list of class names. Space and tab characters, as well as blank lines, are ignored. The comment character is '#' (0x23); on each line all characters following the first comment character are ignored. The file must be encoded in UTF-8. Classes that are reachable, as defined innewInstance(Class[]), from the listed classes are also registered with JAXBContext.
Every package listed on the contextPath must meet one or both of the following conditions otherwise a JAXBException will be thrown:
The file contains a newline-separated list of class names. Space and tab characters, as well as blank lines, are ignored. The comment character is '#' (0x23); on each line all characters following the first comment character are ignored. The file must be encoded in UTF-8. Classes that are reachable, as defined in newInstance(Class...) , from the listed classes are also registered with JAXBContext.
Constraints on class name occuring in a
In the case of schema to java interface/implementation binding, the JAXB provider will ensure that each package on the context path has a
jaxb.index
file are:
To maintain compatibility with JAXB 1.0 schema to java interface/implementation binding, enabled by schema customization
If there are any global XML element name collisions across the various packages listed on the contextPath , a JAXBException will be thrown.
Mixing generated interface/impl bindings from multiple JAXB Providers in the same context path may result in a JAXBException being thrown.
public static JAXBContext newInstance(String contextPath, ClassLoader classLoader, Map<String,?> properties) throws JAXBException
Obtain a new instance of a JAXBContext class.
This is mostly the same as newInstance(String, ClassLoader) , but this version allows you to pass in provider-specific properties to configure the instanciation of JAXBContext .
The interpretation of properties is up to implementations.
public static JAXBContext newInstance(Class... classesToBeBound) throws JAXBException
Obtain a new instance of a JAXBContext class.
The client application must supply a list of classes that the new context object needs to recognize. Not only the new context will recognize all the classes specified, but it will also recognize any classes that are directly/indirectly referenced statically from the specified classes. Subclasses of referenced classes nor @XmlTransient referenced classes are not registered with JAXBContext. For example, in the following Java code, if you do newInstance(Foo.class) , the newly created JAXBContext will recognize both Foo and Bar , but not Zot or FooBar :
Therefore, a typical client application only needs to specify the top-level classes, but it needs to be careful.class Foo { @XmlTransient FooBar c; Bar b; } class Bar { int x; } class Zot extends Bar { int y; } class FooBar { }
Note that for each java package registered with JAXBContext, when the optional package annotations exist, they must be processed. (see JLS 3rd Edition, Section 7.4.1. "Package Annotations").
public static JAXBContext newInstance(Class[] classesToBeBound, Map<String,?> properties) throws JAXBException
Obtain a new instance of a JAXBContext class.
An overloading of
newInstance(Class...)
This is mostly the same as
newInstance(Class[])
to configure 'properties' for this instantiation of
JAXBContext
, but this version allows you to pass in an implementation-specific 'properties' to configure the instanciation of
JAXBContext
.
The interpretation of properties is
implementation specific.
up to implementations.
public abstract Unmarshaller createUnmarshaller() throws JAXBException
public abstract Marshaller createMarshaller() throws JAXBException
public abstract Validator createValidator() throws JAXBException
Create a Validator object that can be used to validate a java content tree against its source schema.
public <T> Binder<T> createBinder(Class<T> domType)
public Binder<Node> createBinder()
public JAXBIntrospector createJAXBIntrospector()
public void generateSchema(SchemaOutputResolver outputResolver) throws IOException