Java StAXUtils.createXMLStreamWriter方法代码示例

import org.apache.axiom.om.util.StAXUtils; //导入方法依赖的package包/类
/**
 * Util method to convert the pullstream to a string
 *
 * @param reader
 * @return
 */
private String getStringXML(XMLStreamReader reader) throws XMLStreamException {
    //the returned pullparser starts at an Element rather than the start
    //document event. This is somewhat disturbing but since an ADBBean
    //denotes an XMLFragment, it is justifiable to keep the current event
    //at the Start-element rather than the start document
    //What it boils down to is that we need to wrap the reader in a
    //stream wrapper to get a fake start-document event

    StreamingOMSerializer ser = new StreamingOMSerializer();
    ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
    XMLStreamWriter writer = StAXUtils.createXMLStreamWriter(byteArrayOutputStream);
    ser.serialize(
            new StreamWrapper(reader),
            writer);
    writer.flush();
    return byteArrayOutputStream.toString();
}
 

import org.apache.axiom.om.util.StAXUtils; //导入方法依赖的package包/类
protected Object[] getInputObject(List inputObjects, Operation operation)
        throws XMLStreamException, XmlSerializingException, XmlParsingException {
    StringWriter inputStringWriter = new StringWriter();
    XMLStreamWriter inputXmlStreamWriter = StAXUtils.createXMLStreamWriter(inputStringWriter);
    this.javaObjectSerializer.serializeInputElement(inputObjects.toArray(),
            operation.getInputElement(),
            operation.getInputParameters(),
            inputXmlStreamWriter);
    inputXmlStreamWriter.flush();
    String inputXmlString = inputStringWriter.toString();

    System.out.println("input Xml String ==> " + inputXmlString);

    XMLStreamReader xmlReader = StAXUtils.createXMLStreamReader(new ByteArrayInputStream(inputXmlString.getBytes()));
    Object[] objects = this.xmlStreamParser.getInputParameters(xmlReader, operation);
    return objects;
}
 

import org.apache.axiom.om.util.StAXUtils; //导入方法依赖的package包/类
protected Object getReturnObject(Object returnObject, Operation operation)
        throws XMLStreamException, XmlSerializingException, XmlParsingException {
    // get the response xml serializer
    StringWriter outputStringWriter = new StringWriter();
    XMLStreamWriter outputXMLStringWriter = StAXUtils.createXMLStreamWriter(outputStringWriter);

    this.javaObjectSerializer.serializeOutputElement(returnObject,
            operation.getOutPutElement(),
            operation.getOutputParameter(),
            outputXMLStringWriter);
    outputXMLStringWriter.flush();
    String outputXmlString = outputStringWriter.toString();
    System.out.println("output Xml String ==> " + outputXmlString);

    XMLStreamReader outputXmlReader =
            StAXUtils.createXMLStreamReader(new ByteArrayInputStream(outputXmlString.getBytes()));

    return this.xmlStreamParser.getOutputObject(outputXmlReader, operation);
}
 

import org.apache.axiom.om.util.StAXUtils; //导入方法依赖的package包/类
public void testMappedSerialize3() throws XMLStreamException {
    String jsonString = getMappedJSONString();
    ByteArrayOutputStream outStream = new ByteArrayOutputStream();
    XMLStreamWriter writer = StAXUtils.createXMLStreamWriter(outStream);
    JSONDataSource source = getMappedDataSource(jsonString);
    source.serialize(writer);
    writer.flush();
    assertEquals(
            "<?xml version='1.0' encoding='UTF-8'?><mapping><inner><first>test string one</first></inner><inner>test string two</inner><name>foo</name></mapping>",
            new String(outStream.toByteArray()));
}
 

import org.apache.axiom.om.util.StAXUtils; //导入方法依赖的package包/类
public void testBadgerfishSerialize3() throws XMLStreamException, JSONException, IOException,
        ParserConfigurationException, SAXException {
    String jsonString = getBadgerfishJSONString();
    ByteArrayOutputStream outStream = new ByteArrayOutputStream();
    XMLStreamWriter writer = StAXUtils.createXMLStreamWriter(outStream);
    JSONBadgerfishDataSource source = getBadgerfishDataSource(jsonString);
    source.serialize(writer);
    writer.flush();
    assertXMLEqual(
            "<?xml version='1.0' encoding='UTF-8'?><p xmlns=\"http://def.ns\" xmlns:bb=\"http://other.nsb\" xmlns:aa=\"http://other.ns\"><sam att=\"lets\">555</sam></p>",
            new String(outStream.toByteArray()));
}
 

import org.apache.axiom.om.util.StAXUtils; //导入方法依赖的package包/类
public void serialize(Writer writerTarget, OMOutputFormat format) throws XMLStreamException {
    MTOMXMLStreamWriter writer =
        new MTOMXMLStreamWriter(StAXUtils.createXMLStreamWriter(writerTarget));
    writer.setOutputFormat(format);
    serialize(writer);
    writer.flush();
    writer.close();
}
 

import org.apache.axiom.om.util.StAXUtils; //导入方法依赖的package包/类
/**
 * Utility method to write the reader contents to a String
 * @return String
 */
public String getAsString() throws XMLStreamException {
    StringWriter sw = new StringWriter();
    XMLStreamWriter writer = StAXUtils.createXMLStreamWriter(sw);

    // Write the reader to the writer
    outputTo(writer);

    // Flush the writer and get the String
    writer.flush();
    sw.flush();
    String str = sw.toString();
    writer.close();
    return str;
}
 

import org.apache.axiom.om.util.StAXUtils; //导入方法依赖的package包/类
public void serialize(Writer writerTarget, OMOutputFormat format) throws XMLStreamException {
    MTOMXMLStreamWriter writer =
            new MTOMXMLStreamWriter(StAXUtils.createXMLStreamWriter(writerTarget));
    writer.setOutputFormat(format);
    serialize(writer);
    writer.flush();
    writer.close();
}
 

import org.apache.axiom.om.util.StAXUtils; //导入方法依赖的package包/类
private static void testSerializeDeserializeWrapped(Object bean, Object expectedResult) throws Exception {
    StringWriter sw = new StringWriter();
    XMLStreamWriter writer = StAXUtils.createXMLStreamWriter(sw);
    writer.writeStartElement("", "root", "urn:test");
    writer.writeDefaultNamespace("urn:test");
    ADBBeanUtil.serialize(bean, writer);
    writer.writeEndElement();
    writer.flush();
    OMElement omElement3 = new StAXOMBuilder(StAXUtils.createXMLStreamReader(new StringReader(sw.toString()))).getDocumentElement();
    assertBeanEquals(expectedResult, ADBBeanUtil.parse(bean.getClass(), omElement3.getFirstElement().getXMLStreamReader()));
}
 

import org.apache.axiom.om.util.StAXUtils; //导入方法依赖的package包/类
public void serialize(OutputStream outputStream,
                      OMOutputFormat omOutputFormat) throws XMLStreamException {
    XMLStreamWriter xmlStreamWriter = StAXUtils.createXMLStreamWriter(outputStream);
    serialize(xmlStreamWriter);
    xmlStreamWriter.flush();
}
 

import org.apache.axiom.om.util.StAXUtils; //导入方法依赖的package包/类
/**
 * The writer is created lazily. 
 * If only the output stream is used, then the writer is never created.
 */
private void createWriter() throws XMLStreamException {
    if (writer == null) {
        writer =  StAXUtils.createXMLStreamWriter(os, charSetEncoding);
    }
}
 

import org.apache.axiom.om.util.StAXUtils; //导入方法依赖的package包/类
/**
 * @param output
 * @param format
 * @throws XMLStreamException
 * @see OMDataSource#serialize(java.io.OutputStream, org.apache.axiom.om.OMOutputFormat)
 */
public void serialize(OutputStream output, OMOutputFormat format) throws XMLStreamException {
    XMLStreamWriter xmlStreamWriter = StAXUtils.createXMLStreamWriter(output);
    serialize(xmlStreamWriter);
    xmlStreamWriter.flush();
}
 

import org.apache.axiom.om.util.StAXUtils; //导入方法依赖的package包/类
/**
 * @param output
 * @param format
 * @throws javax.xml.stream.XMLStreamException
 *
 * @see OMDataSource#serialize(java.io.OutputStream, org.apache.axiom.om.OMOutputFormat)
 */
public void serialize(OutputStream output, OMOutputFormat format) throws XMLStreamException {
    XMLStreamWriter xmlStreamWriter = StAXUtils.createXMLStreamWriter(output);
    serialize(xmlStreamWriter);
    xmlStreamWriter.flush();
}