1. JAXB 2.0 |
Q: | Which version of Java SE does Eclipse Implementation of JAXB 4.0.3 require? |
A: | Java SE 11 or higher. |
Q: | Can I run my existing JAXB 1.x/2.x applications on the
Eclipse Implementation of JAXB runtime? |
A: | This is not supported. |
Q: | What if I want to port my JAXB 1.x/2.x application to Jakarta XML Binding runtime? |
A: | You need to replace references to javax.xml.bind
package by jakarta.xml.bind package, recompile your schema
with the newer xjc and modify your application code to work with
the new bindings. |
Q: | Where are schemagen and xjc command line scripts available? |
A: | They are included only in the zip distribution. |
Q: | Are the Jakarta XML Binding runtime API's thread safe? |
A: | The Jakarta XML Binding Specification currently does not address
the thread safety of any of the runtime classes. In the
case of the Eclipse Implementation of JAXB, the
JAXBContext class is thread safe, but the
Marshaller ,
Unmarshaller , and
Validator classes are not thread safe. For example, suppose you have a multi-thread server
application that processes incoming XML documents by Jakarta XML Binding.
In this case, for the best performance you should have
just one instance of JAXBContext in
your whole application like this: And each time you need to unmarshal/marshal/validate
a document. Just create a new
Unmarshaller /Marshaller /Validator
from this context, like this: This is the simplest safe way to use the Eclipse Implementation of JAXB
from multi-threaded applications. If you really care about the performance, and/or
your application is going to read a lot of small
documents, then creating Unmarshaller
could be relatively an expensive operation. In that case,
consider pooling Unmarshaller objects.
Different threads may reuse one
Unmarshaller instance, as long as you
don't use one instance from two threads at the same
time. |
Q: | Why can't I cast the unmarshalled object into the
generated type. |
A: | When you invoke
JAXBContext.newInstance("aaa.bbb.ccc") ,
it tries to load classes and resources using the same
classloader used to load the
JAXBContext class itself. This
classloader may be different from the classloader which
was used to load your application (see the picture Parent/Child classloader). In
this case, you'll see the above error. This problem is
often seen with application servers, Jakarta EE containers, Ant,
JUnit, and other applications that use sophisticated class
loading mechanisms.
With some applications, things get even more
complicated when the Jakarta XML Binding-generated code can be loaded by
either classloader. In this case,
JAXBContext.newInstance("aaa.bbb.ccc")
will work but the JVM ends up loading two copies of the
generated classes for each class loader. As a result,
unmarshalling works but an attempt to cast the returned
object into the expected type will fail, even though its
getClass().getName() returns the
expected name. The solution for both situations is to pass your
curent class loader like this: In general, if you are writing code that uses Jakarta XML Binding,
it is always better to explicitly pass in a class loader,
so that your code will work no matter where it is
deployed. |
Q: | Which jar files do I need to distribute with my
application that uses the Eclipse Implementation of JAXB? |
A: |
|
Q: | How can I cause the Marshaller to
generate CDATA blocks? |
A: | This functionality is not available from Eclipse Implementation of JAXB
directly, but you can configure an Apache Xerces-J
XMLSerializer to produce
CDATA blocks. Please review the JaxbCDATASample.java
sample app for more detail. |
Q: | Can I access <xs:any/> as a DOM node? |
A: | In Eclipse Implementation of JAXB, <xs:any/> is handled correctly
without any customization. If it's strict , it will map
to Object or
List<Object> and when you
unmarshal documents, you'll get objects that map to
elements (such as JAXBElements or
classes that are annotated with
XmlRootElement ). If it's skip , it will map
to org.w3c.dom.Element or
List<Element> and when you
unmarshal documents, you'll get DOM elements. If it's lax , it will map to
the same as with strict , and when
you unmarshal documents, you'll get either: JAXBElement s
classes that are annotated with
XmlRootElement DOM elements
|
Q: | How do I find out which version of the Eclipse Implementation of JAXB I'm
using? |
A: | Run the following command Alternatively, each Eclipse Implementation of JAXB jar has version information
in its META-INF/MANIFEST.MF , such as
this: |