package de.consulting.bolte.xml;
 
import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;
import java.io.Writer;
 
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.JAXBIntrospector;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;
import javax.xml.bind.UnmarshallerHandler;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;
 
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.XMLFilter;
import org.xml.sax.XMLReader;
 
import com.sun.xml.internal.bind.marshaller.CharacterEscapeHandler;
 
/**
 * A utility class for converting between jaxb annotated objects and xml.
 */
public class EntityMarshallingUtils {
	/**
	 * <p>
	 * Unmarshals / deserializes a provided XML String into Java objects of
	 * provided class. The difference to the methods <code>unmarshal</code> is
	 * that this method is capable of parsing sub nodes from a XML document
	 * which are not annotated as root nodes in a JAXB project.
	 * </p>
	 *
	 * @param targetClass
	 *            - the class of a target type for a serialization.
	 * @param factoryPackagePath
	 *            - the Java package path a target class resides in.
	 * @param xml
	 *            - an XML String to be serialized.
	 * @return a deserialization of the XML into an object of type T of class
	 *         Class<T>
	 * @throws JAXBException
	 */
	@SuppressWarnings("unchecked")
	public static <T> T introspect(Class<T> targetClass, String factoryPackagePath, String xml) throws JAXBException {
		T ret;
 
		/*
		 * In order to unmarshal / deserialize nodes in an XML file, which are
		 * not annotated as a root node in a JAXB project, we have to provide
		 * the package in which the ObjectFactory created by JAXB resides.
		 */
		JAXBContext ctx = JAXBContext.newInstance(factoryPackagePath);
		Unmarshaller marshaller = ctx.createUnmarshaller();
		ret = (T) JAXBIntrospector.getValue(marshaller.unmarshal(new StringReader(xml)));
 
		return ret;
	}
 
	/**
	 * <p>
	 * Marshals / serializes a provided instance of a provided class into XML
	 * regarding to the XML target namespace maintained in the package-info.java
	 * of the package of the provided class.
	 * </p>
	 * <p>
	 * The XML output is formatted using the
	 * <code>Marshaller.JAXB_FORMATTED_OUTPUT</code> option.
	 * </p>
	 * <p>
	 * Uses the non API / Java internal class
	 * <code>CharacterEscapeHandler</code> in order to escape special characters
	 * causing trouble in XML. The code in question references the
	 * CharacterEscapeHandler class to set the property to a custom character
	 * escape handler. I did not find the proper way, without using the non API
	 * class to overwrite the Unmarshallers property for the escape handler to
	 * use during unmarshalling. Below the code in question.
	 * </p>
	 * <p>
	 * <code>
	 * marshaller.setProperty(CharacterEscapeHandler.class.getName(),
				new XmlEscapeHandler());
	 * </code>
	 * </p>
	 *
	 * @param c
	 *            - the class of the type to serialize.
	 * @param o
	 *            - the instance holding the data to serialize.
	 * @return a string representation of the data provided in handed instance.
	 * @throws Exception
	 */
	public static <T> String marshal(Class<T> c, Object o) throws Exception {
		JAXBContext ctx = JAXBContext.newInstance(c);
		Marshaller marshaller = ctx.createMarshaller();
		StringWriter entityXml = new StringWriter();
		/*
		 * Format the output in the XML file for readability.
		 */
		marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
		/*
		 * Switch the escape handler to a custom implementation for escaped XML
		 * code.
		 */
		marshaller.setProperty(CharacterEscapeHandler.class.getName(), new XmlEscapeHandler());
		marshaller.marshal(o, entityXml);
		String entityString = entityXml.toString();
 
		return entityString;
	}
 
	/**
	 * <p>
	 * Marshals / serializes a provided instance of a provided class into XML
	 * <b>ignoring</b> the XML target namespace maintained in the
	 * package-info.java of the package of the provided class.
	 * </p>
	 * <p>
	 * The XML output is formatted using the method transform in this class
	 * relying on a JDK implementation of Transformer.
	 * <code>Marshaller.JAXB_FORMATTED_OUTPUT</code> option is switched on, but
	 * does not work since the StringWriter is passed to a XMLStreamWriter,
	 * which simply ignores indentation and line breaks. The JDK implementation
	 * of XMLStreamWriter simply writes the XML in one line, which is why we
	 * need to rely on the Transformer to pretty print our XML. Annoying!
	 * </p>
	 * <p>
	 * Uses the non API / Java internal class
	 * <code>CharacterEscapeHandler</code> in order to escape special characters
	 * causing trouble in XML. The code in question references the
	 * CharacterEscapeHandler class to set the property to a custom character
	 * escape handler. I did not find the proper way, without using the non API
	 * class to overwrite the Unmarshallers property for the escape handler to
	 * use during unmarshalling. Below the code in question.
	 * </p>
	 * <code>
	 * marshaller.setProperty(CharacterEscapeHandler.class.getName(),
				new XmlEscapeHandler());
	 * </code>
	 *
	 * @param c
	 *            - the class of a type to serialize into XML.
	 * @param o
	 *            - the instance containing the data to serialize into XML.
	 * @return a XML representation of the data provided in handed instance o
	 *         without any namespace reference in the result String.
	 * @throws Exception
	 */
	public static <T> String marshalNoNamespace(Class<T> c, Object o) throws Exception {
		JAXBContext ctx = JAXBContext.newInstance(c);
		Marshaller marshaller = ctx.createMarshaller();
		StringWriter entityXml = new StringWriter();
		XMLStreamWriter xml = XMLOutputFactory.newFactory().createXMLStreamWriter(entityXml);
		String xmlText = null;
		/*
		 * Create a new instance of a custom implementation of the interface
		 * NamespaceContext.
		 */
		NoNameSpaceContext nsContext = new NoNameSpaceContext();
		xml.setNamespaceContext(nsContext);
 
		/*
		 * Format the output in the marshaled XML for readability.
		 */
		marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
		/*
		 * Switch the escape handler to a custom implementation for escaped XML
		 * code.
		 */
		marshaller.setProperty(CharacterEscapeHandler.class.getName(), new XmlEscapeHandler());
		/*
		 * Marshal and write the XML data from a provided instance into a
		 * XMLStreamWriter as well as a registered Writer.
		 */
		marshaller.marshal(o, xml);
		/*
		 * Ensure that the returned XML is pretty printed / has correct
		 * indentation.
		 */
		xmlText = transform(entityXml.toString());
		/*
		 * Return the output from a registered Writer as String (XML).
		 */
		return xmlText;
	}
 
	/**
	 * Uses the JDK implementation of <code>Transformer</code> in order to
	 * transform a provided XML String into pretty printed XML with correct
	 * indentation and line breaks.
	 *
	 * @param xml
	 *            - an XML without indentation or line breaks.
	 * @return an XML with correct indentation and line breaks.
	 * @throws XMLStreamException
	 * @throws TransformerException
	 */
	public static String transform(String xml) throws XMLStreamException, TransformerException {
		Transformer t = TransformerFactory.newInstance().newTransformer();
 
		t.setOutputProperty(OutputKeys.INDENT, "yes");
		// t.setOutputProperty("{http://xml.apache.org/xslt}indent-amount",
		// "2");
		Writer out = new StringWriter();
		t.transform(new StreamSource(new StringReader(xml)), new StreamResult(out));
 
		return out.toString();
	}
 
	/**
	 * <p>
	 * Unmarshals / deserializes a provided XML String into Java objects of
	 * provided class <b>regarding</b> the XML target namespace maintained in
	 * the package-info.java of the package of the provided class.
	 * </p>
	 *
	 * @param <T>
	 *            the type we want to convert XML into.
	 * @param c
	 *            the class of the parameterized type.
	 * @param xml
	 *            an instance XML description.
	 * @return a deserialization of the XML into an object of type T of class
	 *         Class<T>.
	 * @throws javax.xml.bind.JAXBException
	 */
	@SuppressWarnings("unchecked")
	public static <T> T unmarshal(Class<T> c, String xml) throws JAXBException {
		T res;
 
		if (c == xml.getClass()) {
			res = (T) xml;
		}
 
		else {
			JAXBContext ctx = JAXBContext.newInstance(c);
			Unmarshaller unmarshaller = ctx.createUnmarshaller();
			res = (T) unmarshaller.unmarshal(new StringReader(xml));
		}
 
		return res;
	}
 
	/**
	 * <p>
	 * Unmarshals / deserializes a provided XML String into Java objects of
	 * provided class <b>disregarding</b> the XML target namespace maintained in
	 * the package-info.java of the package of the provided class.
	 * </p>
	 * <p>
	 * Instead of the target namespcae maintained in a package-info
	 * corresponding provided class, the calling method can define the XML
	 * target namespace to be used.
	 * </p>
	 *
	 * @param <T>
	 *            the type we want to convert XML into.
	 * @param c
	 *            the class of the parameterized type.
	 * @param xml
	 *            an instance XML description.
	 * @return a deserialization of a provided XML into an object of type T of
	 *         provided class c.
	 * @throws javax.xml.bind.JAXBException
	 * @throws SAXException
	 * @throws ParserConfigurationException
	 * @throws IOException
	 */
	@SuppressWarnings("unchecked")
	public static <T> T unmarshal(Class<T> c, String xml, String targetNamespace)
			throws JAXBException, ParserConfigurationException, SAXException, IOException {
		T res;
 
		if (c == xml.getClass()) {
			res = (T) xml;
		} else {
			XMLFilter filter = new NamespaceFilter(targetNamespace);
 
			SAXParserFactory spf = SAXParserFactory.newInstance();
			SAXParser sp = spf.newSAXParser();
			XMLReader xr = sp.getXMLReader();
			filter.setParent(xr);
 
			JAXBContext ctx = JAXBContext.newInstance(c);
			Unmarshaller unMarshaller = ctx.createUnmarshaller();
			UnmarshallerHandler unmarshallerHandler = unMarshaller.getUnmarshallerHandler();
			filter.setContentHandler(unmarshallerHandler);
			InputSource data = new InputSource(new StringReader(xml));
			filter.parse(data);
			res = (T) unmarshallerHandler.getResult();
		}
 
		return res;
	}
 
}

package de.consulting.bolte.xml;
 
import org.xml.sax.SAXException;
import org.xml.sax.helpers.XMLFilterImpl;
 
/**
 * @author Alexander Bolte (Bolte Consulting)
 *         <p>
 *         A utility class used to override the XML target namespace defined in
 *         a Java package info created using JAXB. This is for example necessary
 *         when the XML target namespace in a read XML differs from the target
 *         namespace in the Java package info for JAXB generated classes.
 *         </p>
 *         <p>
 *         An XMLFilter sits as an extra, abstract layer between a real
 *         XMLReader and an application a reader delivers events and information
 *         to.
 *         </p>
 *         <p>
 *         This specific implementation of the interface XMLFilter simply
 *         ensures that JAXB is using a provided target namespace instead of the
 *         JAXB package info namespace. Simple but very useful.
 *         </p>
 */
public class NamespaceFilter extends XMLFilterImpl {
	private String namespace = "";
 
	public NamespaceFilter(String namespace) {
		this.namespace = namespace;
	}
 
	@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, org.xml.sax.Attributes atts)
			throws SAXException {
		super.startElement(namespace, localName, qName, atts);
	}
}

package de.consulting.bolte.xml;
 
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
 
import javax.xml.XMLConstants;
import javax.xml.namespace.NamespaceContext;
 
/**
 * @author Alexander Bolte
 *         <p>
 *         A utility class used to marshal Java objects into XML without
 *         providing any target namespace. Although this is considered bad
 *         practice you come across this in real life e.g. when a system expects
 *         an XML without any namespace.
 *         </p>
 */
public class NoNameSpaceContext implements NamespaceContext {
	private Map<String, String> urisByPrefix = new HashMap<String, String>();
 
	private Map<String, Set> prefixesByURI = new HashMap<String, Set>();
 
	public NoNameSpaceContext() {
		/*
		 * addNamespace(XMLConstants.XML_NS_PREFIX, XMLConstants.XML_NS_URI);
		 * addNamespace(XMLConstants.XMLNS_ATTRIBUTE,
		 * XMLConstants.XMLNS_ATTRIBUTE_NS_URI);
		 */
	}
 
	public synchronized void addNamespace(String prefix, String namespaceURI) {
		urisByPrefix.put(prefix, namespaceURI);
		if (prefixesByURI.containsKey(namespaceURI)) {
			(prefixesByURI.get(namespaceURI)).add(prefix);
		} else {
			Set<String> set = new HashSet<String>();
			set.add(prefix);
			prefixesByURI.put(namespaceURI, set);
		}
	}
 
	@Override
	public String getNamespaceURI(String prefix) {
		/*
		 * if (prefix == null) throw new IllegalArgumentException(
		 * "prefix cannot be null"); if (urisByPrefix.containsKey(prefix))
		 * return (String) urisByPrefix.get(prefix); else
		 */
		return XMLConstants.NULL_NS_URI;
	}
 
	@Override
	public String getPrefix(String namespaceURI) {
		if (!getPrefixes(namespaceURI).hasNext()) {
			return "";
		} else {
			return (String) getPrefixes(namespaceURI).next();
		}
 
	}
 
	@Override
	public Iterator getPrefixes(String namespaceURI) {
		/*
		 * if (namespaceURI == null) throw new IllegalArgumentException(
		 * "namespaceURI cannot be null"); if
		 * (prefixesByURI.containsKey(namespaceURI)) { return ((Set)
		 * prefixesByURI.get(namespaceURI)).iterator(); } else {
		 */
		return Collections.EMPTY_SET.iterator();
		// }
	}
}

/**
 *
 */
package de.consulting.bolte.xml;
 
import java.io.IOException;
import java.io.StringWriter;
import java.io.Writer;
 
import com.sun.xml.internal.bind.marshaller.CharacterEscapeHandler;
 
/**
 * This class is an implementation of the CharacterEscapeHandler interface
 * provided by JAXB in order to allow customization on how to escape characters
 * when marshaling Java objects into XML.
 *
 * @author Alexander Bolte (Bolte Consulting)
 */
public class XmlEscapeHandler implements CharacterEscapeHandler {
 
	/*
	 * (non-Javadoc)
	 *
	 * @see
	 * com.sun.xml.internal.bind.marshaller.CharacterEscapeHandler#escape(char
	 * [], int, int, boolean, java.io.Writer)
	 *
	 * @Remarks - this implementation of the interface CharacterEscapeHandler
	 * escapes special characters. This is useful, if your XML for example needs
	 * to support escaped XML code as values within XML tags.
	 */
	@Override
	public void escape(char[] buf, int start, int len, boolean isAttValue, Writer out) throws IOException {
		StringWriter buffer = new StringWriter();
 
		for (int i = start; i < start + len; i++) {
			buffer.write(buf[i]);
		}
 
		String st = buffer.toString();
 
		st = buffer.toString().replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;").replace("'", "&apos;")
				.replace("\"", "&quot;");
 
		out.write(st);
	}
}