Over a million developers have joined DZone.
{{announcement.body}}
{{announcement.title}}

Applying a Namespace During JAXB Unmarshal

DZone's Guide to

Applying a Namespace During JAXB Unmarshal

· Java Zone
Free Resource

Microservices! They are everywhere, or at least, the term is. When should you use a microservice architecture? What factors should be considered when making that decision? Do the benefits outweigh the costs? Why is everyone so excited about them, anyway?  Brought to you in partnership with IBM.

 For some an XML schema is a strict set of rules for how the XML document must be structured.  But for others it is a general guideline to indicate what the XML should look like.  This means that sometimes people want to accept input that doesn't conform to the XML schema for some reason.  In this example I will demonstrate how this can be done by leveraging a SAX XMLFilter.

Java Model

Below is the Java model that will be used for this example.

Customer
package blog.namespace.sax;
 
import javax.xml.bind.annotation.XmlRootElement;
 
@XmlRootElement
public class Customer {
 
    private String name;
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
}
package-info
We will use the package level @XmlSchema annotation to specify the namespace qualification for our model.
@XmlSchema(
        namespace="http://www.example.com/customer",
        elementFormDefault=XmlNsForm.QUALIFIED)
package blog.namespace.sax;
 
import javax.xml.bind.annotation.*;

XML Input (input.xml)

Even though our metadata specified that all the elements should be qualified with a namespace (http://www.example.com/customer) our input document is not namespace qualified.  An XMLFilter will be used to add the namespace during the unmarshal operation.
<?xml version="1.0" encoding="UTF-8"?>
<customer>
    <name>Jane Doe</name>
</customer>
XMLFilter (NamespaceFilter) 

The easiest way to create an XMLFilter is to extend XMLFilterImpl.  For our use case we will override the startElement and endElement methods.  In each of these methods we will call the corresponding super method passing in the default namespace as the URI parameter.
package blog.namespace.sax;
 
import org.xml.sax.*;
import org.xml.sax.helpers.XMLFilterImpl;
 
public class NamespaceFilter extends XMLFilterImpl {
 
    private static final String NAMESPACE = "http://www.example.com/customer";
 
    @Override
    public void endElement(String uri, String localName, String qName)
            throws SAXException {
        super.endElement(NAMESPACE, localName, qName);
    }
 
    @Override
    public void startElement(String uri, String localName, String qName,
            Attributes atts) throws SAXException {
        super.startElement(NAMESPACE, localName, qName, atts);
    }
 
}

Demo

In the demo code below we will do a SAX parse of the XML document.  The XMLReader will be wrapped in our XMLFilter.  We will leverage JAXB's UnmarshallerHandler as the ContentHandler.  Once the parse has been done we can ask the UnmarshallerHandler for the resulting Customer object.
package blog.namespace.sax;
 
import javax.xml.bind.*;
import javax.xml.parsers.*;
import org.xml.sax.*;
 
public class Demo {
 
    public static void main(String[] args) throws Exception {
        // Create the JAXBContext
        JAXBContext jc = JAXBContext.newInstance(Customer.class);
 
        // Create the XMLFilter
        XMLFilter filter = new NamespaceFilter();
 
        // Set the parent XMLReader on the XMLFilter
        SAXParserFactory spf = SAXParserFactory.newInstance();
        SAXParser sp = spf.newSAXParser();
        XMLReader xr = sp.getXMLReader();
        filter.setParent(xr);
 
        // Set UnmarshallerHandler as ContentHandler on XMLFilter
        Unmarshaller unmarshaller = jc.createUnmarshaller();
        UnmarshallerHandler unmarshallerHandler = unmarshaller
                .getUnmarshallerHandler();
        filter.setContentHandler(unmarshallerHandler);
 
        // Parse the XML
        InputSource xml = new InputSource("src/blog/namespace/sax/input.xml");
        filter.parse(xml);
        Customer customer = (Customer) unmarshallerHandler.getResult();
 
        // Marshal the Customer object back to XML
        Marshaller marshaller = jc.createMarshaller();
        marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
        marshaller.marshal(customer, System.out);
    }
 
}

Output

Below is the output from running the demo code.  Note how the output contains the namespace qualification based on the metadata.
<?xml version="1.0" encoding="UTF-8"?>
<customer xmlns="http://www.example.com/customer">
    <name>Jane Doe</name>
</customer>

Further Reading 

If you enjoyed this post then you may also be interested in:


Discover how the Watson team is further developing SDKs in Java, Node.js, Python, iOS, and Android to access these services and make programming easy. Brought to you in partnership with IBM.

Topics:

Published at DZone with permission of Blaise Doughan, DZone MVB. See the original article here.

Opinions expressed by DZone contributors are their own.

THE DZONE NEWSLETTER

Dev Resources & Solutions Straight to Your Inbox

Thanks for subscribing!

Awesome! Check your inbox to verify your email so you can start receiving the latest in tech news and resources.

X

{{ parent.title || parent.header.title}}

{{ parent.tldr }}

{{ parent.urlSource.name }}