JAXBContext (EclipseLink 2.2.0, build 'v20110202-r8913' API Reference)

link管理

链接快照平台

输入网页链接，自动生成快照
标签化管理网页链接

Unmarshalling

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 contextPath The 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.

Discovery of JAXB implementation

When one of the newInstance methods is called, a JAXB implementation is discovered by the following steps. For each package/class explicitly passed in to the


       newInstance(java.lang.String)

method, in the order they are specified, jaxb.properties file is looked up in its package, by using the associated classloader — this is


      the owner class loader

for a


      Class

argument, and for a package the speified


      ClassLoader

. If such a file is discovered, it is


      loaded

as a property file, and the value of the


       JAXB_CONTEXT_FACTORY

key will be assumed to be the provider factory class. This class is then loaded by the associated classloader discussed above. This phase of the look up allows some packages to force the use of a certain JAXB implementation. (For example, perhaps the schema compiler has generated some vendor extension in the code.) If the system property


       JAXB_CONTEXT_FACTORY

exists, then its value is assumed to be the provider factory class. This phase of the look up enables per-JVM override of the JAXB implementation. Look for /META-INF/services/javax.xml.bind.JAXBContext file in the associated classloader. This file follows the standard service descriptor convention, and if such a file exists, its content is assumed to be the provider factory class. This phase of the look up is for automatic discovery. It allows users to just put a JAXB implementation in a classpath and use it without any furhter configuration. Finally, if all the steps above fail, then the rest of the look up is unspecified. That said, the recommended behavior is to simply look for some hard-coded platform default JAXB implementation. This phase of the look up is so that JavaSE can have its own JAXB implementation as the last resort. Once the provider factory class is discovered, its public static JAXBContext createContext(String,ClassLoader,Map) method (see


       newInstance(String, ClassLoader, Map)

for the parameter semantics.) or public static JAXBContext createContet(Class[],Map) method (see


       newInstance(Class[], Map)

for the parameter semantics) are invoked to create a


       JAXBContext

See Also:


        Marshaller


        Unmarshaller

, S 7.4.1.1 "Package Annotations" in Java Language Specification, 3rd Edition

Author:

Ryan Shoemaker, Sun Microsystems, Inc.
Kohsuke Kawaguchi, Sun Microsystems, Inc.
Joe Fialli, Sun Microsystems, Inc.

Since:

JAXB1.0


      static
      
       JAXBContext


      
       
        newInstance
       
      
      (java.lang.String contextPath,
            java.lang.ClassLoader classLoader,
            java.util.Map<java.lang.String,?> properties)

Obtain a new instance of a JAXBContext class. public static final java.lang.String JAXB_CONTEXT_FACTORY

The name of the property that contains the name of the class capable of creating new JAXBContext objects.

See Also:

Constant Field Values

public static JAXBContext newInstance (java.lang.String contextPath) throws JAXBException Obtain a new instance of a JAXBContext class. This is a convenience method to invoke the


       newInstance(String,ClassLoader)

method with the context class loader of the current thread.

Throws:


       
        JAXBException

- if an error was encountered while creating the JAXBContext such as

failure to locate either ObjectFactory.class or jaxb.index in the packages

an ambiguity among global elements contained in the contextPath

failure to locate a value for the context factory provider property

mixing schema derived packages from different providers on the same contextPath

public static JAXBContext newInstance (java.lang.String contextPath, java.lang.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 annotated JAXB mapped classes can be 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"). Every package listed on the contextPath must meet one or both of the following conditions otherwise a JAXBException will be thrown:

it must contain ObjectFactory.class

it must contain jaxb.index

Format for jaxb.index 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 jaxb.index file are:

Must not end with ".class".

Class names are resolved relative to package containing jaxb.index file. Only classes occuring directly in package containing jaxb.index file are allowed.

Fully qualified class names are not allowed. A qualified class name,relative to current package, is only allowed to specify a nested or inner class.

To maintain compatibility with JAXB 1.0 schema to java interface/implementation binding, enabled by schema customization the JAXB provider will ensure that each package on the context path has a jaxb.properties file which contains a value for the javax.xml.bind.context.factory property and that all values resolve to the same provider. This requirement does not apply to JAXB annotated classes. 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. The steps involved in discovering the JAXB implementation is discussed in the class javadoc.

Parameters:


       contextPath

- list of java package names that contain schema derived class and/or java to schema (JAXB-annotated) mapped classes


       classLoader

- This class loader will be used to locate the implementation classes.

Returns:

a new instance of a JAXBContext

Throws:


       
        JAXBException

- if an error was encountered while creating the JAXBContext such as

failure to locate either ObjectFactory.class or jaxb.index in the packages

an ambiguity among global elements contained in the contextPath

failure to locate a value for the context factory provider property

mixing schema derived packages from different providers on the same contextPath

public static JAXBContext newInstance (java.lang.String contextPath, java.lang.ClassLoader classLoader, java.util.Map<java.lang.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. Implementations should throw JAXBException if it finds properties that it doesn't understand.

Parameters:


       contextPath

- list of java package names that contain schema derived classes


       classLoader

- This class loader will be used to locate the implementation classes.


       properties

- provider-specific properties. Can be null, which means the same thing as passing in an empty map.

Returns:

a new instance of a JAXBContext

Throws:


       
        JAXBException

- if an error was encountered while creating the JAXBContext such as

failure to locate either ObjectFactory.class or jaxb.index in the packages

an ambiguity among global elements contained in the contextPath

failure to locate a value for the context factory provider property

mixing schema derived packages from different providers on the same contextPath

Since:

JAXB2.0

public static JAXBContext newInstance (java.lang.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 : class Foo { @XmlTransient FooBar c; Bar b; class Bar { int x; } class Zot extends Bar { int y; } class FooBar { } Therefore, a typical client application only needs to specify the top-level classes, but it needs to be careful. 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"). The steps involved in discovering the JAXB implementation is discussed in the class javadoc.

Parameters:


       classesToBeBound

- list of java classes to be recognized by the new


        JAXBContext

. Can be empty, in which case a


        JAXBContext

that only knows about spec-defined classes will be returned.

Returns:

A new instance of a JAXBContext . Always non-null valid object.

Throws:


       
        JAXBException

- if an error was encountered while creating the JAXBContext , such as (but not limited to):

No JAXB implementation was discovered

Classes use JAXB annotations incorrectly

Classes have colliding annotations (i.e., two classes with the same type name)

The JAXB implementation was unable to locate provider-specific out-of-band information (such as additional files generated at the development time.)


         java.lang.IllegalArgumentException

- if the parameter contains


         null

(i.e.,


         newInstance(null);

)

Since:

JAXB2.0

public static JAXBContext newInstance (java.lang.Class[] classesToBeBound, java.util.Map<java.lang.String,?> properties) throws JAXBException Obtain a new instance of a JAXBContext class. An overloading of


       newInstance(Class...)

to configure 'properties' for this instantiation of


       JAXBContext

. The interpretation of properties is up to implementations. Implementations should throw JAXBException if it finds properties that it doesn't understand.

Parameters:


       classesToBeBound

- list of java classes to be recognized by the new


        JAXBContext

. Can be empty, in which case a


        JAXBContext

that only knows about spec-defined classes will be returned.


       properties

- provider-specific properties. Can be null, which means the same thing as passing in an empty map.

Returns:

A new instance of a JAXBContext . Always non-null valid object.

Throws:


       
        JAXBException

- if an error was encountered while creating the JAXBContext , such as (but not limited to):

No JAXB implementation was discovered

Classes use JAXB annotations incorrectly

Classes have colliding annotations (i.e., two classes with the same type name)

The JAXB implementation was unable to locate provider-specific out-of-band information (such as additional files generated at the development time.)


         java.lang.IllegalArgumentException

- if the parameter contains


         null

(i.e.,


         newInstance(null,someMap);

)

Since:

JAXB2.0

Returns:

an Unmarshaller object

Throws:


       
        JAXBException

- if an error was encountered while creating the Unmarshaller object

Returns:

a Marshaller object

Throws:


       
        JAXBException

- if an error was encountered while creating the Marshaller object

Deprecated. since JAXB2.0


        Validator

has been made optional and deprecated in JAXB 2.0. Please refer to the javadoc for


        Validator

for more detail. Create a Validator object that can be used to validate a java content tree against its source schema.

Returns:

a Validator object

Throws:


       
        JAXBException

- if an error was encountered while creating the Validator object

public <T> Binder <T> createBinder (java.lang.Class<T> domType)

Creates a Binder object that can be used for associative/in-place unmarshalling/marshalling.

Parameters:


       domType

- select the DOM API to use by passing in its DOM Node class.

Returns:

always a new valid Binder object.

Throws:


       java.lang.UnsupportedOperationException

- if DOM API corresponding to domType is not supported by the implementation.

Since:

JAXB2.0

public JAXBIntrospector createJAXBIntrospector ()

Creates a JAXBIntrospector object that can be used to introspect JAXB objects.

Returns:

always return a non-null valid JAXBIntrospector object.

Throws:


       java.lang.UnsupportedOperationException

- Calling this method on JAXB 1.0 implementations will throw an UnsupportedOperationException.

Since:

JAXB2.0

public void generateSchema ( SchemaOutputResolver outputResolver) throws java.io.IOException

Generates the schema documents for this context.

Parameters:


       outputResolver

- this object controls the output to which schemas will be sent.

Throws:


       java.io.IOException

- if


        SchemaOutputResolver

throws an


       IOException


       java.lang.UnsupportedOperationException

- Calling this method on JAXB 1.0 implementations will throw an UnsupportedOperationException.

Since:

JAXB 2.0