javax.xml.stream.XMLOutputFactory Java Examples

public String toXML() {
    final XMLOutputFactory output = XMLOutputFactory.newInstance();
    output.setProperty("escapeCharacters", false);
    XMLStreamWriter xmlWriter;
    String xml;
    try {
        Writer strWriter = new StringWriter();
        xmlWriter = output.createXMLStreamWriter(strWriter);
        xmlWriter.writeCharacters("\r\n\t");
        xmlWriter.writeStartElement("api");

        xmlWriter.writeCharacters(this.rpc.toXML());
        xmlWriter.writeCharacters(this.zmq.toXML());
        xmlWriter.writeCharacters(this.nrg.toXML());

        xmlWriter.writeCharacters("\r\n\t");
        xmlWriter.writeEndElement();
        xml = strWriter.toString();
        strWriter.flush();
        strWriter.close();
        xmlWriter.flush();
        xmlWriter.close();
        return xml;
    } catch (IOException | XMLStreamException e) {
        e.printStackTrace();
        return "";
    }
}
 

/**
 * Reset this instance so that it can be re-used. Clears but does not
 * re-allocate internal data structures.
 *
 * @param resetProperties Indicates if properties should be read again
 */
void reset(boolean resetProperties) {
    if (!fReuse) {
        throw new java.lang.IllegalStateException(
            "close() Must be called before calling reset()");
    }

    fReuse = false;
    fNamespaceDecls.clear();
    fAttributeCache.clear();

    // reset Element/NamespaceContext stacks
    fElementStack.clear();
    fInternalNamespaceContext.reset();

    fStartTagOpened = false;
    fNamespaceContext.userContext = null;

    if (resetProperties) {
        Boolean ob = (Boolean) fPropertyManager.getProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES);
        fIsRepairingNamespace = ob.booleanValue();
        ob = (Boolean) fPropertyManager.getProperty(Constants.ESCAPE_CHARACTERS);
        setEscapeCharacters(ob.booleanValue());
    }
}
 

public static String getPolicyAsString(Policy policy) {
    ByteArrayOutputStream outBuffer = new ByteArrayOutputStream();
    try {
        XMLStreamWriter writer =
                XMLOutputFactory.newInstance().createXMLStreamWriter(outBuffer);
        policy.serialize(writer);
        writer.flush();
        ByteArrayInputStream bais = new ByteArrayInputStream(outBuffer.toByteArray());
        XMLPrettyPrinter xmlPrettyPrinter = new XMLPrettyPrinter(bais);
        return xmlPrettyPrinter.xmlFormat();

    } catch (XMLStreamException e) {
        throw new RuntimeException("Serialization of Policy object failed " + e);
    }

}
 

/**
 * Initialize an instance of this XMLStreamWriter. Allocate new instances
 * for all the data structures. Set internal flags based on property values.
 */
private void init() {
    fReuse = false;
    fNamespaceDecls = new ArrayList<>();
    fPrefixGen = new Random();
    fAttributeCache = new ArrayList<>();
    fInternalNamespaceContext = new NamespaceSupport();
    fInternalNamespaceContext.reset();
    fNamespaceContext = new NamespaceContextImpl();
    fNamespaceContext.internalContext = fInternalNamespaceContext;

    // Set internal state based on property values
    Boolean ob = (Boolean) fPropertyManager.getProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES);
    fIsRepairingNamespace = ob;
    ob = (Boolean) fPropertyManager.getProperty(Constants.ESCAPE_CHARACTERS);
    setEscapeCharacters(ob);
}
 

public Bufr2Xml(Message message, NetcdfFile ncfile, OutputStream os, boolean skipMissing) throws IOException {
  indent = new Indent(2);
  indent.setIndentLevel(0);

  try {
    XMLOutputFactory fac = XMLOutputFactory.newInstance();
    staxWriter = fac.createXMLStreamWriter(os, CDM.UTF8);

    staxWriter.writeStartDocument(CDM.UTF8, "1.0");
    // staxWriter.writeCharacters("\n");
    // staxWriter.writeStartElement("bufrMessage");

    writeMessage(message, ncfile);

    staxWriter.writeCharacters("\n");
    staxWriter.writeEndDocument();
    staxWriter.flush();

  } catch (XMLStreamException e) {
    throw new IOException(e.getMessage());
  }
}
 

/**
 * This method when called assumes the Framework Nar ClassLoader is in the
 * classloader hierarchy of the current context class loader.
 * @param dto the template dto to serialize
 * @return serialized representation of the DTO
 */
public static byte[] serialize(final TemplateDTO dto) {
    try {
        final ByteArrayOutputStream baos = new ByteArrayOutputStream();
        final BufferedOutputStream bos = new BufferedOutputStream(baos);

        JAXBContext context = JAXBContext.newInstance(TemplateDTO.class);
        Marshaller marshaller = context.createMarshaller();
        XMLOutputFactory xmlof = XMLOutputFactory.newInstance();
        XMLStreamWriter writer = new IndentingXMLStreamWriter(xmlof.createXMLStreamWriter(bos));
        marshaller.marshal(dto, writer);

        bos.flush();
        return baos.toByteArray(); //Note: For really large templates this could use a lot of heap space
    } catch (final IOException | JAXBException | XMLStreamException e) {
        throw new FlowSerializationException(e);
    }
}
 

/**
 * Initialize an instance of this XMLStreamWriter. Allocate new instances
 * for all the data structures. Set internal flags based on property values.
 */
private void init() {
    fReuse = false;
    fNamespaceDecls = new ArrayList();
    fPrefixGen = new Random();
    fAttributeCache = new ArrayList();
    fInternalNamespaceContext = new NamespaceSupport();
    fInternalNamespaceContext.reset();
    fNamespaceContext = new NamespaceContextImpl();
    fNamespaceContext.internalContext = fInternalNamespaceContext;

    // Set internal state based on property values
    Boolean ob = (Boolean) fPropertyManager.getProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES);
    fIsRepairingNamespace = ob.booleanValue();
    ob = (Boolean) fPropertyManager.getProperty(Constants.ESCAPE_CHARACTERS);
    setEscapeCharacters(ob.booleanValue());
}
 

/**
 * @param output
 * @throws FactoryConfigurationError
 */
private void writeCopyright(OutputStream output) throws FactoryConfigurationError {
    try {
	    XMLOutputFactory xmlOutputFactory = XMLOutputFactory.newFactory();
	    XMLStreamWriter xmlStreamWriter = xmlOutputFactory.createXMLStreamWriter(output);//;
	    try {
	        xmlStreamWriter.writeStartDocument(Charset.defaultCharset().name(), "1.0");
	        xmlStreamWriter.writeCharacters("\r\n");
	        xmlStreamWriter.writeComment("\r\n" + PROPRIETARY_COPYRIGHT);
	    } finally {
	        xmlStreamWriter.flush();
            xmlStreamWriter.close();
	    }
	} catch (XMLStreamException e) {
	    throw new EPSCommonException("A XML stream writer instance could not be created", e);
	}
}
 

public <T> String writeXml(final T model, final Schema schema, final ValidationEventHandler handler) {
    if (model == null) {
        throw new ConversionExeption("Can not serialize null");
    }
    try ( final StringWriter w = new StringWriter() ) {
        final JAXBIntrospector introspector = getJaxbContext().createJAXBIntrospector();
        final Marshaller marshaller = getJaxbContext().createMarshaller();
        marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
        marshaller.setProperty(Marshaller.JAXB_FRAGMENT, Boolean.TRUE);
        marshaller.setProperty(Marshaller.JAXB_ENCODING, "UTF-8");
        marshaller.setSchema(schema);
        marshaller.setEventHandler(handler);
        final XMLOutputFactory xof = XMLOutputFactory.newFactory();
        final XMLStreamWriter xmlStreamWriter = xof.createXMLStreamWriter(w);
        if (null == introspector.getElementName(model)) {
            final JAXBElement jaxbElement = new JAXBElement(createQName(model), model.getClass(), model);
            marshaller.marshal(jaxbElement, xmlStreamWriter);
        } else {
            marshaller.marshal(model, xmlStreamWriter);
        }
        xmlStreamWriter.flush();
        return w.toString();
    } catch (final JAXBException | IOException | XMLStreamException e) {
        throw new ConversionExeption(String.format("Error serializing Object %s", model.getClass().getName()), e);
    }
}
 

/**
 * Reset this instance so that it can be re-used. Clears but does not
 * re-allocate internal data structures.
 *
 * @param resetProperties Indicates if properties should be read again
 */
void reset(boolean resetProperties) {
    if (!fReuse) {
        throw new java.lang.IllegalStateException(
            "close() Must be called before calling reset()");
    }

    fReuse = false;
    fNamespaceDecls.clear();
    fAttributeCache.clear();

    // reset Element/NamespaceContext stacks
    fElementStack.clear();
    fInternalNamespaceContext.reset();

    fStartTagOpened = false;
    fNamespaceContext.userContext = null;

    if (resetProperties) {
        Boolean ob = (Boolean) fPropertyManager.getProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES);
        fIsRepairingNamespace = ob.booleanValue();
        ob = (Boolean) fPropertyManager.getProperty(Constants.ESCAPE_CHARACTERS);
        setEscapeCharacters(ob.booleanValue());
    }
}
 

/**
 * Initialize an instance of this XMLStreamWriter. Allocate new instances
 * for all the data structures. Set internal flags based on property values.
 */
private void init() {
    fReuse = false;
    fNamespaceDecls = new ArrayList();
    fPrefixGen = new Random();
    fAttributeCache = new ArrayList();
    fInternalNamespaceContext = new NamespaceSupport();
    fInternalNamespaceContext.reset();
    fNamespaceContext = new NamespaceContextImpl();
    fNamespaceContext.internalContext = fInternalNamespaceContext;

    // Set internal state based on property values
    Boolean ob = (Boolean) fPropertyManager.getProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES);
    fIsRepairingNamespace = ob.booleanValue();
    ob = (Boolean) fPropertyManager.getProperty(Constants.ESCAPE_CHARACTERS);
    setEscapeCharacters(ob.booleanValue());
}
 

public void writeTo(SOAPMessage saaj) throws SOAPException {
        try {
            // TODO what about in-scope namespaces
            // Not very efficient consider implementing a stream buffer
            // processor that produces a DOM node from the buffer.
            Transformer t = XmlUtil.newTransformer();
            SOAPHeader header = saaj.getSOAPHeader();
            if (header == null)
                header = saaj.getSOAPPart().getEnvelope().addHeader();
// TODO workaround for oracle xdk bug 16555545, when this bug is fixed the line below can be
// uncommented and all lines below, except the catch block, can be removed.
//            t.transform(epr.asSource(localName), new DOMResult(header));
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            XMLStreamWriter w = XMLOutputFactory.newFactory().createXMLStreamWriter(baos);
            epr.writeTo(localName, w);
            w.flush();
            ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
            DocumentBuilderFactory fac = DocumentBuilderFactory.newInstance();
            fac.setNamespaceAware(true);
            Node eprNode = fac.newDocumentBuilder().parse(bais).getDocumentElement();
            Node eprNodeToAdd = header.getOwnerDocument().importNode(eprNode, true);
            header.appendChild(eprNodeToAdd);
        } catch (Exception e) {
            throw new SOAPException(e);
        }
    }
 

public static OMElement getPolicyAsOMElement(Policy policy) {

        try {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            XMLStreamWriter writer = XMLOutputFactory.newInstance().createXMLStreamWriter(baos);
            policy.serialize(writer);
            writer.flush();
            ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
            XMLStreamReader xmlStreamReader =
                    XMLInputFactory.newInstance().createXMLStreamReader(bais);
            StAXOMBuilder staxOMBuilder =
                    (StAXOMBuilder) OMXMLBuilderFactory.createStAXOMBuilder(
                            OMAbstractFactory.getOMFactory(), xmlStreamReader);
            return staxOMBuilder.getDocumentElement();

        } catch (Exception ex) {
            throw new RuntimeException("can't convert the policy to an OMElement", ex);
        }
    }
 

private void convertAndWriteToFile( final InputStream inputStream, final File tmpFile ) throws IOException {
	try ( final LZ4BlockOutputStream out = new LZ4BlockOutputStream( new FileOutputStream( tmpFile ) ) ) {
		reset();

		final XMLInputFactory inputFactory = XMLInputFactory.newInstance();
		inputFactory.setProperty( XMLInputFactory.IS_SUPPORTING_EXTERNAL_ENTITIES, Boolean.FALSE );
		final XMLEventReader eventReader =
				inputFactory.createXMLEventReader( inputStream, StandardCharsets.UTF_8.name() );
		final XMLEventWriter eventWriter =
				XMLOutputFactory.newInstance().createXMLEventWriter( out, StandardCharsets.UTF_8.name() );

		while ( eventReader.hasNext() ) {
			final XMLEvent nextEvent = eventReader.nextEvent();
			convert( nextEvent, eventWriter );
		}
		eventReader.close();
		eventWriter.flush();
		eventWriter.close();

	} catch ( final XMLStreamException | FactoryConfigurationError e ) {
		throw new RuntimeException( e );
	}
}
 

/**
 * Reset this instance so that it can be re-used. Clears but does not
 * re-allocate internal data structures.
 *
 * @param resetProperties Indicates if properties should be read again
 */
void reset(boolean resetProperties) {
    if (!fReuse) {
        throw new java.lang.IllegalStateException(
            "close() Must be called before calling reset()");
    }

    fReuse = false;
    fNamespaceDecls.clear();
    fAttributeCache.clear();

    // reset Element/NamespaceContext stacks
    fElementStack.clear();
    fInternalNamespaceContext.reset();

    fStartTagOpened = false;
    fNamespaceContext.userContext = null;

    if (resetProperties) {
        Boolean ob = (Boolean) fPropertyManager.getProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES);
        fIsRepairingNamespace = ob.booleanValue();
        ob = (Boolean) fPropertyManager.getProperty(Constants.ESCAPE_CHARACTERS);
        setEscapeCharacters(ob.booleanValue());
    }
}
 

/**
 * Reset this instance so that it can be re-used. Clears but does not
 * re-allocate internal data structures.
 *
 * @param resetProperties Indicates if properties should be read again
 */
void reset(boolean resetProperties) {
    if (!fReuse) {
        throw new java.lang.IllegalStateException(
            "close() Must be called before calling reset()");
    }

    fReuse = false;
    fNamespaceDecls.clear();
    fAttributeCache.clear();

    // reset Element/NamespaceContext stacks
    fElementStack.clear();
    fInternalNamespaceContext.reset();

    fStartTagOpened = false;
    fNamespaceContext.userContext = null;

    if (resetProperties) {
        Boolean ob = (Boolean) fPropertyManager.getProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES);
        fIsRepairingNamespace = ob.booleanValue();
        ob = (Boolean) fPropertyManager.getProperty(Constants.ESCAPE_CHARACTERS);
        setEscapeCharacters(ob.booleanValue());
    }
}
 

public void needRewrite() throws XMLStreamException, IOException {
    Path configFile = getConfigFile();
    Files.deleteIfExists(configFile);
    try (BufferedWriter bw = Files.newBufferedWriter(configFile,
            StandardOpenOption.CREATE, StandardOpenOption.WRITE)) {
        try (FormattingXmlStreamWriter writer = new FormattingXmlStreamWriter(XMLOutputFactory.newInstance()
                .createXMLStreamWriter(bw))) {
            writer.writeStartDocument();
            writer.writeStartElement(ConfigXmlParser10.ROOT_1_0.getLocalPart());
            writer.writeDefaultNamespace(ConfigXmlParser10.NAMESPACE_1_0);
            maven.write(writer);
            writer.writeEndElement();
            writer.writeEndDocument();
        }
    }
}
 

/**
 * Reset this instance so that it can be re-used. Clears but does not
 * re-allocate internal data structures.
 *
 * @param resetProperties Indicates if properties should be read again
 */
void reset(boolean resetProperties) {
    if (!fReuse) {
        throw new java.lang.IllegalStateException(
            "close() Must be called before calling reset()");
    }

    fReuse = false;
    fNamespaceDecls.clear();
    fAttributeCache.clear();

    // reset Element/NamespaceContext stacks
    fElementStack.clear();
    fInternalNamespaceContext.reset();

    fStartTagOpened = false;
    fNamespaceContext.userContext = null;

    if (resetProperties) {
        Boolean ob = (Boolean) fPropertyManager.getProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES);
        fIsRepairingNamespace = ob.booleanValue();
        ob = (Boolean) fPropertyManager.getProperty(Constants.ESCAPE_CHARACTERS);
        setEscapeCharacters(ob.booleanValue());
    }
}
 

/**
 * Initialize an instance of this XMLStreamWriter. Allocate new instances
 * for all the data structures. Set internal flags based on property values.
 */
private void init() {
    fReuse = false;
    fNamespaceDecls = new ArrayList();
    fPrefixGen = new Random();
    fAttributeCache = new ArrayList();
    fInternalNamespaceContext = new NamespaceSupport();
    fInternalNamespaceContext.reset();
    fNamespaceContext = new NamespaceContextImpl();
    fNamespaceContext.internalContext = fInternalNamespaceContext;

    // Set internal state based on property values
    Boolean ob = (Boolean) fPropertyManager.getProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES);
    fIsRepairingNamespace = ob.booleanValue();
    ob = (Boolean) fPropertyManager.getProperty(Constants.ESCAPE_CHARACTERS);
    setEscapeCharacters(ob.booleanValue());
}
 

/**
 * Initialize an instance of this XMLStreamWriter. Allocate new instances
 * for all the data structures. Set internal flags based on property values.
 */
private void init() {
    fReuse = false;
    fNamespaceDecls = new ArrayList();
    fPrefixGen = new Random();
    fAttributeCache = new ArrayList();
    fInternalNamespaceContext = new NamespaceSupport();
    fInternalNamespaceContext.reset();
    fNamespaceContext = new NamespaceContextImpl();
    fNamespaceContext.internalContext = fInternalNamespaceContext;

    // Set internal state based on property values
    Boolean ob = (Boolean) fPropertyManager.getProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES);
    fIsRepairingNamespace = ob.booleanValue();
    ob = (Boolean) fPropertyManager.getProperty(Constants.ESCAPE_CHARACTERS);
    setEscapeCharacters(ob.booleanValue());
}
 

/**
 * Reset this instance so that it can be re-used. Clears but does not
 * re-allocate internal data structures.
 *
 * @param resetProperties Indicates if properties should be read again
 */
void reset(boolean resetProperties) {
    if (!fReuse) {
        throw new java.lang.IllegalStateException(
            "close() Must be called before calling reset()");
    }

    fReuse = false;
    fNamespaceDecls.clear();
    fAttributeCache.clear();

    // reset Element/NamespaceContext stacks
    fElementStack.clear();
    fInternalNamespaceContext.reset();

    fStartTagOpened = false;
    fNamespaceContext.userContext = null;

    if (resetProperties) {
        Boolean ob = (Boolean) fPropertyManager.getProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES);
        fIsRepairingNamespace = ob;
        ob = (Boolean) fPropertyManager.getProperty(Constants.ESCAPE_CHARACTERS);
        setEscapeCharacters(ob);
    }
}
 

@Test
public void testStreamWriterWithStAXResultNEventWriter() throws Exception {
    try {
        XMLOutputFactory ofac = XMLOutputFactory.newInstance();
        ByteArrayOutputStream buffer = new ByteArrayOutputStream();
        XMLEventWriter writer = ofac.createXMLEventWriter(buffer);
        StAXResult res = new StAXResult(writer);
        XMLStreamWriter swriter = ofac.createXMLStreamWriter(res);
        Assert.fail("Expected an Exception as XMLStreamWriter can't be created " + "with a StAXResult which has EventWriter.");
    } catch (Exception e) {
        System.out.println(e.toString());
    }
}
 

void generateAndReadXml(String content) throws Exception {
    ByteArrayOutputStream stream = new ByteArrayOutputStream();
    XMLOutputFactory factory = XMLOutputFactory.newInstance();
    OutputStreamWriter streamWriter = new OutputStreamWriter(stream);
    XMLStreamWriter writer = factory.createXMLStreamWriter(streamWriter);

    // Generate xml with selected stream writer type
    generateXML(writer, content);
    String output = stream.toString();
    System.out.println("Generated xml: " + output);
    // Read generated xml with StAX parser
    readXML(output.getBytes(), content);
}
 

@Test
public void isStaxResult() throws Exception {
	XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
	XMLStreamWriter streamWriter = outputFactory.createXMLStreamWriter(new StringWriter());
	Result result = StaxUtils.createCustomStaxResult(streamWriter);

	assertTrue("Not a StAX Result", StaxUtils.isStaxResult(result));
}
 

@BeforeMethod
public void setUp() {
    try {
        outputFactory = XMLOutputFactory.newInstance();
        inputFactory = XMLInputFactory.newInstance();
    } catch (Exception ex) {
        Assert.fail("Could not create XMLInputFactory");
    }
}
 

@Before
public void createStreamReader() throws Exception {
	stringWriter = new StringWriter();
	XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
	XMLEventWriter eventWriter = outputFactory.createXMLEventWriter(stringWriter);
	streamWriter = new XMLEventStreamWriter(eventWriter, XMLEventFactory.newInstance());
}
 

private Zephyr(XMLOutputFactory xof, Class clazz) throws NoSuchMethodException {
    this.xof = xof;

    zephyrClass = clazz;
    setOutputMethod = clazz.getMethod("setOutput", StreamResult.class, String.class);
    resetMethod = clazz.getMethod("reset");
}
 

public static Document toDOM(SAML11ResponseType response) throws ParserConfigurationException, XMLStreamException, ProcessingException {
    DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
    dbf.setNamespaceAware(true);

    XMLOutputFactory factory = XMLOutputFactory.newFactory();

    Document doc = dbf.newDocumentBuilder().newDocument();
    DOMResult result = new DOMResult(doc);
    XMLStreamWriter xmlWriter = factory.createXMLStreamWriter(result);
    SAML11ResponseWriter writer = new SAML11ResponseWriter(xmlWriter);
    writer.write(response);
    return doc;
}
 

@Test
public void marshalJaxp14StaxResultEventWriter() throws Exception {
	XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
	StringWriter writer = new StringWriter();
	XMLEventWriter eventWriter = outputFactory.createXMLEventWriter(writer);
	StAXResult result = new StAXResult(eventWriter);
	marshaller.marshal(flights, result);
	assertThat("Marshaller writes invalid StreamResult", writer.toString(), isSimilarTo(EXPECTED_STRING));
}
 

@Test
public void marshalJaxp14StaxResultEventWriter() throws Exception {
	XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
	StringWriter writer = new StringWriter();
	XMLEventWriter eventWriter = outputFactory.createXMLEventWriter(writer);
	StAXResult result = new StAXResult(eventWriter);
	marshaller.marshal(flights, result);
	assertThat("Marshaller writes invalid StreamResult", writer.toString(), isSimilarTo(EXPECTED_STRING));
}