Example usage for javax.xml.stream XMLEventFactory createNamespace

Introduction

In this page you can find the example usage for javax.xml.stream XMLEventFactory createNamespace.

Prototype

public abstract Namespace createNamespace(String namespaceURI);

Source Link

Document

Create a new default Namespace

Usage

From source file:org.omnaest.utils.xml.XMLNestedMapConverter.java

/**
 * @param nestedMap/*  w ww  . ja  va 2s  .  c o  m*/
 *          {@link Map}
 * @param outputStream
 *          {@link OutputStream}
 * @param includeDocumentHeader
 *          if true a xml document header is written out additionally
 */
private <K> void toXML(Map<K, Object> nestedMap, OutputStream outputStream,
        final ElementConverter<K, QName> keyElementConverter, boolean includeDocumentHeader) {
    //
    if (nestedMap != null && keyElementConverter != null && outputStream != null) {
        //
        try {
            //
            final XMLOutputFactory xmlOutputFactory = this.xmlInstanceContextFactory.newXmlOutputFactory();
            final XMLEventFactory xmlEventFactory = this.xmlInstanceContextFactory.newXmlEventFactory();
            Assert.isNotNull(xmlOutputFactory, "xmlOutputFactory must not be null");
            Assert.isNotNull(xmlEventFactory, "xmlEventFactory must not be null");

            //
            final XMLEventWriter xmlEventWriter = xmlOutputFactory.createXMLEventWriter(outputStream,
                    this.encoding);
            final ExceptionHandler exceptionHandler = this.exceptionHandler;

            //
            try {
                //
                class Helper {
                    /* ********************************************** Variables ********************************************** */
                    private List<String> namespaceStack = new ArrayList<String>();

                    /* ********************************************** Methods ********************************************** */

                    @SuppressWarnings("unchecked")
                    public void write(Map<K, Object> map) {
                        if (map != null) {
                            for (K key : map.keySet()) {
                                //
                                final QName tagName = keyElementConverter.convert(key);
                                final Object value = map.get(key);

                                //
                                if (value instanceof String) {
                                    //
                                    this.writeStartTag(tagName);

                                    //
                                    final String text = (String) value;
                                    this.writeText(text);

                                    //
                                    this.writeEndTag(tagName);
                                } else if (value instanceof Map) {
                                    //
                                    this.writeStartTag(tagName);

                                    //
                                    final Map<K, Object> subMap = (Map<K, Object>) value;
                                    this.write(subMap);

                                    //
                                    this.writeEndTag(tagName);
                                } else if (value instanceof List) {
                                    //
                                    final List<Object> valueList = (List<Object>) value;
                                    this.write(tagName, valueList);
                                }
                            }
                        }
                    }

                    /**
                     * @param tagName
                     */
                    private void writeStartTag(QName tagName) {
                        //
                        try {
                            //
                            final String namespaceURI = tagName.getNamespaceURI();

                            //            
                            final Iterator<?> attributes = null;
                            final Iterator<?> namespaces = StringUtils.isNotBlank(namespaceURI) && !StringUtils
                                    .equals(namespaceURI, ListUtils.lastElement(this.namespaceStack))
                                            ? IteratorUtils.valueOf(
                                                    xmlEventFactory.createNamespace(namespaceURI))
                                            : null;
                            StartElement startElement = xmlEventFactory.createStartElement(tagName, attributes,
                                    namespaces);
                            xmlEventWriter.add(startElement);

                            //
                            this.namespaceStack.add(namespaceURI);
                        } catch (Exception e) {
                            exceptionHandler.handleException(e);
                        }
                    }

                    /**
                     * @param tagName
                     */
                    private void writeEndTag(QName tagName) {
                        //
                        try {
                            //            
                            final Iterator<?> namespaces = null;
                            EndElement endElement = xmlEventFactory.createEndElement(tagName, namespaces);
                            xmlEventWriter.add(endElement);

                            //
                            ListUtils.removeLast(this.namespaceStack);
                        } catch (Exception e) {
                            exceptionHandler.handleException(e);
                        }
                    }

                    /**
                     * @param text
                     */
                    private void writeText(String text) {
                        //
                        try {
                            //            
                            final Characters characters = xmlEventFactory.createCharacters(text);
                            xmlEventWriter.add(characters);
                        } catch (Exception e) {
                            exceptionHandler.handleException(e);
                        }
                    }

                    /**
                     * @param tagName
                     * @param valueList
                     */
                    @SuppressWarnings("unchecked")
                    private void write(QName tagName, List<Object> valueList) {
                        if (valueList != null) {
                            for (Object value : valueList) {
                                //
                                if (value != null) {
                                    //
                                    this.writeStartTag(tagName);

                                    //
                                    if (value instanceof Map) {
                                        //
                                        final Map<K, Object> map = (Map<K, Object>) value;
                                        this.write(map);
                                    } else if (value instanceof String) {
                                        //
                                        final String text = (String) value;
                                        this.writeText(text);
                                    }

                                    //
                                    this.writeEndTag(tagName);
                                }
                            }
                        }
                    }
                }

                //
                if (includeDocumentHeader) {
                    xmlEventWriter.add(xmlEventFactory.createStartDocument());
                }

                //
                new Helper().write(nestedMap);

                //
                xmlEventWriter.add(xmlEventFactory.createEndDocument());
            } finally {
                xmlEventWriter.close();
                outputStream.flush();
            }
        } catch (Exception e) {
            if (this.exceptionHandler != null) {
                this.exceptionHandler.handleException(e);
            }
        }
    }
}

---