java类javax.xml.stream.XMLEventWriter的实例源码

@Override
protected AbstractStaxHandler createStaxHandler(Result result)
        throws XMLStreamException {
    XMLOutputFactory outputFactory = XMLOutputFactory.newFactory();
    XMLEventWriter eventWriter = outputFactory.createXMLEventWriter(result);
    return new StaxEventHandler(eventWriter);
}

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

public void testEncodingXmlEventReader() throws Exception {
    TEST_XML_WITH_XML_HEADER_ISO_8859_1_AS_BYTE_ARRAY_STREAM.reset();
    XMLEventReader reader = null;
    XMLEventWriter writer = null;
    ByteArrayOutputStream output = null;
    try {
        // enter text encoded with Latin1
        reader = context.getTypeConverter().mandatoryConvertTo(XMLEventReader.class,
                TEST_XML_WITH_XML_HEADER_ISO_8859_1_AS_BYTE_ARRAY_STREAM);

        output = new ByteArrayOutputStream();
        // ensure UTF-8 encoding
        Exchange exchange = new DefaultExchange(context);
        exchange.setProperty(Exchange.CHARSET_NAME, UTF_8.toString());
        writer = context.getTypeConverter().mandatoryConvertTo(XMLEventWriter.class, exchange, output);
        while (reader.hasNext()) {
            writer.add(reader.nextEvent());
        }
    } finally {
        if (reader != null) {
            reader.close();
        }
        if (writer != null) {
            writer.close();
        }
    }
    assertNotNull(output);

    String result = new String(output.toByteArray(), UTF_8.name());
    // normalize the auotation mark
    if (result.indexOf('\'') > 0) {
        result = result.replace('\'', '"');
    }
    boolean equals = TEST_XML_WITH_XML_HEADER.equals(result) || TEST_XML_WITH_XML_HEADER_ISO_8859_1.equals(result);
    assertTrue("Should match header", equals);
}

private void marshalStaxResult(Marshaller jaxbMarshaller, Object graph, Result staxResult) throws JAXBException {
    XMLStreamWriter streamWriter = StaxUtils.getXMLStreamWriter(staxResult);
    if (streamWriter != null) {
        jaxbMarshaller.marshal(graph, streamWriter);
    }
    else {
        XMLEventWriter eventWriter = StaxUtils.getXMLEventWriter(staxResult);
        if (eventWriter != null) {
            jaxbMarshaller.marshal(graph, eventWriter);
        }
        else {
            throw new IllegalArgumentException("StAX Result contains neither XMLStreamWriter nor XMLEventConsumer");
        }
    }
}

@Test
public void marshalStaxResultXMLEventWriter() throws Exception {
    XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
    StringWriter writer = new StringWriter();
    XMLEventWriter eventWriter = outputFactory.createXMLEventWriter(writer);
    Result result = StaxUtils.createStaxResult(eventWriter);
    marshaller.marshal(flight, result);
    assertXMLEqual("Marshaller writes invalid StreamResult", EXPECTED_STRING, writer.toString());
}

@Test
public void marshalStaxResultEventWriter() throws Exception {
    XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
    StringWriter writer = new StringWriter();
    XMLEventWriter eventWriter = outputFactory.createXMLEventWriter(writer);
    Result result = StaxUtils.createStaxResult(eventWriter);
    marshaller.marshal(flights, result);
    assertXMLEqual("Marshaller writes invalid StreamResult", EXPECTED_STRING, writer.toString());
}

@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);
    assertXMLEqual("Marshaller writes invalid StreamResult", EXPECTED_STRING, writer.toString());
}

/**
 * Writes the processed {@link XMLEvent}s to an {@link OutputStream}.
 * @param outputStream The {@link OutputStream} to write the {@link XMLEvent}s to.
 * @return The {@link Stockpile} instance for chaining.
 * @throws XMLStreamException If an XML error occurs.
 */
public Stockpile write(OutputStream outputStream) throws XMLStreamException {
    XMLEventWriter writer = output.createXMLEventWriter(outputStream);

    try {
        addEventsTo(writer);
    } finally {
        writer.flush();
        writer.close();
    }

    return this;
}

/**
 * Adds a namespace mapping for [name] to [namespaces], if it doesn't already exist on [writer].
 */
private static boolean register(XMLEventWriter writer, List<Namespace> namespaces, QName name) {
    String nsUri = name.getNamespaceURI();
    if (nsUri != null && !nsUri.isEmpty()) {
        String existing = writer.getNamespaceContext().getNamespaceURI(name.getPrefix());
        Namespace ns = evtFactory.createNamespace(name.getPrefix(), nsUri);
        if ((existing == null || !existing.equals(nsUri)) && !namespaces.stream().anyMatch(n ->
            n.getPrefix().equals(ns.getPrefix())
        )) {
            namespaces.add(ns);
            return true;
        }
    }
    return false;
}

public <T> void write(T obj, Writer<XMLEvent,T> writer, OutputStream out) {
    try {
        XMLEventWriter xmlW = outFactory.createXMLEventWriter(out);
        writer.applyAndReset(obj).forEach(addTo(xmlW));
    } catch (XMLStreamException | FactoryConfigurationError e) {
        throw new IllegalArgumentException(e);
    }
}