JAXBContext XML/Java binding over integration layer

Marshalling & Unmarshalling is very crucial when we need to transfer java object over integration layer where we need to convert java object into xml and again convert back xml data into java objects.

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.

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