import org.apache.cxf.staxutils.StaxUtils; //导入依赖的package包/类
@Override
protected RouteBuilder createRouteBuilder() {
    return new RouteBuilder() {
        public void configure() {
            from(fromURI).process(new Processor() {
                public void process(final Exchange exchange) throws Exception {
                    QName faultCode = new QName("http://schemas.xmlsoap.org/soap/envelope/", "Server");
                    SoapFault fault = new SoapFault("Get the null value of person name", faultCode);
                    Element details = StaxUtils.read(new StringReader(DETAILS)).getDocumentElement();
                    fault.setDetail(details);
                    exchange.setException(fault);
                    
                }
            });
        }
    };
}
 

import org.apache.cxf.staxutils.StaxUtils; //导入依赖的package包/类
@Override
public void writeTo(OutputStream os) throws IOException {
    // no body no write
    if (getBodySources().size() == 0) {
        return;
    }
    Source body = getBodySources().get(0);
    if (body instanceof StreamCache) {
        ((StreamCache) body).writeTo(os);
    } else {
        try {
            StaxUtils.copy(body, os);
        } catch (XMLStreamException e) {
            throw new IOException("Transformation failed", e);
        }
    }
}
 

import org.apache.cxf.staxutils.StaxUtils; //导入依赖的package包/类
@Override
protected RouteBuilder createRouteBuilder() {
    return new RouteBuilder() {
        public void configure() {
            from(fromURI).process(new Processor() {
                public void process(final Exchange exchange) throws Exception {
                    Element details = StaxUtils.read(new StringReader(FAULTS)).getDocumentElement();
                    List<Element> outElements = new ArrayList<Element>();
                    outElements.add(details);
                    CxfPayload<SoapHeader> responsePayload = new CxfPayload<SoapHeader>(null, outElements);
                    exchange.getOut().setBody(responsePayload);
                    exchange.getOut().setFault(true);
                }
            });
            
        }
    };
}
 

import org.apache.cxf.staxutils.StaxUtils; //导入依赖的package包/类
public SOAPMessage invokeStream(InputStream in) {
    SOAPMessage response = null;
    try {
        Document doc = StaxUtils.read(in);
        if (doc.getElementsByTagNameNS(greetMe.getNamespaceURI(), 
                                       sayHi.getLocalPart()).getLength() == 1) {
            response = sayHiResponse;
        } else if (doc.getElementsByTagNameNS(greetMe.getNamespaceURI(), 
                                              greetMe.getLocalPart()).getLength() == 1) {
            response = greetMeResponse;
        }
    } catch (Exception ex) {
        ex.printStackTrace();
    }
    return response;
}
 

import org.apache.cxf.staxutils.StaxUtils; //导入依赖的package包/类
@Override
protected RouteBuilder createRouteBuilder() {
    return new RouteBuilder() {
        public void configure() {
            from(fromURI).process(new Processor() {
                public void process(final Exchange exchange) throws Exception {
                    JAXBContext context = JAXBContext.newInstance("org.apache.camel.wsdl_first.types");
                    QName faultCode = new QName("http://schemas.xmlsoap.org/soap/envelope/", "Server");
                    SoapFault fault = new SoapFault("Get the null value of person name", faultCode);
                    Element details = StaxUtils.read(new StringReader(DETAILS)).getDocumentElement();
                    UnknownPersonFault unknowPersonFault = new UnknownPersonFault();
                    unknowPersonFault.setPersonId("");
                    context.createMarshaller().marshal(unknowPersonFault, details);
                    fault.setDetail(details);
                    exchange.getOut().setBody(fault);
                    exchange.getOut().setFault(true);
                }
            });
            
        }
    };
}
 

import org.apache.cxf.staxutils.StaxUtils; //导入依赖的package包/类
public void process(Exchange exchange) throws Exception {
    List<SoapHeader> soapHeaders = CastUtils.cast((List<?>)exchange.getIn().getHeader(Header.HEADER_LIST));
   
    // Insert a new header
    String xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?><outofbandHeader "
        + "xmlns=\"http://cxf.apache.org/outofband/Header\" hdrAttribute=\"testHdrAttribute\" "
        + "xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\" soap:mustUnderstand=\"1\">"
        + "<name>New_testOobHeader</name><value>New_testOobHeaderValue</value></outofbandHeader>";
    
    SoapHeader newHeader = new SoapHeader(soapHeaders.get(0).getName(),
                                          StaxUtils.read(new StringReader(xml)).getDocumentElement());
    // make sure direction is IN since it is a request message.
    newHeader.setDirection(Direction.DIRECTION_IN);
    //newHeader.setMustUnderstand(false);
    soapHeaders.add(newHeader);
    
}
 

import org.apache.cxf.staxutils.StaxUtils; //导入依赖的package包/类
@Test
public void testConsumer() throws Exception {
    if (MtomTestHelper.isAwtHeadless(logger, null)) {
        return;
    }

    context.createProducerTemplate().send("cxf:bean:consumerEndpoint", new Processor() {

        public void process(Exchange exchange) throws Exception {
            exchange.setPattern(ExchangePattern.InOut);
            assertEquals("Get a wrong Content-Type header", "application/xop+xml", exchange.getIn().getHeader("Content-Type"));
            List<Source> elements = new ArrayList<Source>();
            elements.add(new DOMSource(StaxUtils.read(new StringReader(getRequestMessage())).getDocumentElement()));
            CxfPayload<SoapHeader> body = new CxfPayload<SoapHeader>(new ArrayList<SoapHeader>(),
                elements, null);
            exchange.getIn().setBody(body);
            exchange.getIn().addAttachment(MtomTestHelper.REQ_PHOTO_CID, 
                new DataHandler(new ByteArrayDataSource(MtomTestHelper.REQ_PHOTO_DATA, "application/octet-stream")));

            exchange.getIn().addAttachment(MtomTestHelper.REQ_IMAGE_CID, 
                new DataHandler(new ByteArrayDataSource(MtomTestHelper.requestJpeg, "image/jpeg")));
        }
    });
}
 

import org.apache.cxf.staxutils.StaxUtils; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public void process(Exchange exchange) throws Exception {
    CxfPayload<SoapHeader> in = exchange.getIn().getBody(CxfPayload.class);
    
    // verify request
    Assert.assertEquals(1, in.getBody().size());
    
    DataHandler dr = exchange.getIn().getAttachment(MtomTestHelper.REQ_PHOTO_CID);
    Assert.assertEquals("application/octet-stream", dr.getContentType());
    MtomTestHelper.assertEquals(MtomTestHelper.REQ_PHOTO_DATA, IOUtils.readBytesFromStream(dr.getInputStream()));
       
    dr = exchange.getIn().getAttachment(MtomTestHelper.REQ_IMAGE_CID);
    Assert.assertEquals("image/jpeg", dr.getContentType());
    MtomTestHelper.assertEquals(MtomTestHelper.requestJpeg, IOUtils.readBytesFromStream(dr.getInputStream()));

    // create response
    List<Source> elements = new ArrayList<Source>();
    elements.add(new DOMSource(StaxUtils.read(new StringReader(MtomTestHelper.MTOM_DISABLED_RESP_MESSAGE)).getDocumentElement()));
    CxfPayload<SoapHeader> body = new CxfPayload<SoapHeader>(new ArrayList<SoapHeader>(),
        elements, null);
    exchange.getOut().setBody(body);
    exchange.getOut().addAttachment(MtomTestHelper.RESP_PHOTO_CID, 
        new DataHandler(new ByteArrayDataSource(MtomTestHelper.RESP_PHOTO_DATA, "application/octet-stream")));

    exchange.getOut().addAttachment(MtomTestHelper.RESP_IMAGE_CID, 
        new DataHandler(new ByteArrayDataSource(MtomTestHelper.responseJpeg, "image/jpeg")));

}
 

import org.apache.cxf.staxutils.StaxUtils; //导入依赖的package包/类
public synchronized Node getNode() {
	Node nd = super.getNode();
	if (nd == null) {
		try {
			InputSource src = new InputSource(resource.openStream());
			src.setSystemId(this.getSystemId());
			src.setPublicId(publicId);
			Document doc = StaxUtils.read(src);
			setNode(doc);
			nd = super.getNode();
		} catch (Exception ex) {
			throw new RuntimeException(ex);
		}
	}
	return nd;
}
 

import org.apache.cxf.staxutils.StaxUtils; //导入依赖的package包/类
public String getPrefixForNamespace(String ns) {
    try {
        String pfx = writer.getPrefix(ns);

        if (pfx == null) {
            pfx = StaxUtils.getUniquePrefix(writer);

            writer.setPrefix(pfx, ns);
            writer.writeNamespace(pfx, ns);
        }

        return prefix;
    } catch (XMLStreamException e) {
        throw new DatabindingException("Error writing document.", e);
    }
}
 

import org.apache.cxf.staxutils.StaxUtils; //导入依赖的package包/类
/**
 * @param is
 * @throws javax.xml.stream.XMLStreamException
 */
public ElementReader(InputStream is) throws XMLStreamException {
    // XMLInputFactory factory = XMLInputFactory.newInstance();
    // XMLStreamReader xmlReader = factory.createXMLStreamReader(is);
    XMLStreamReader xmlReader = StaxUtils.createXMLStreamReader(is, null);

    xmlReader.nextTag();

    this.root = new DepthXMLStreamReader(xmlReader);
    this.localName = root.getLocalName();
    this.name = root.getName();
    this.namespace = root.getNamespaceURI();

    extractXsiType();

    depth = root.getDepth();
}
 

import org.apache.cxf.staxutils.StaxUtils; //导入依赖的package包/类
@Override
public void writeObject(Object object, MessageWriter writer, 
                        Context context) throws DatabindingException {
    Document doc = (Document)object;

    try {
        Element docElement = doc.getDocumentElement();
        if (docElement == null) {
            if (isNillable()) {
                writer.writeXsiNil();
            } else {
                throw new DatabindingException("Could not write xml: null document element.");
            }
        } else {
            StaxUtils.writeElement(docElement, ((ElementWriter)writer).getXMLStreamWriter(), false);
        }
    } catch (XMLStreamException e) {
        throw new DatabindingException("Could not write xml.", e);
    }
}
 

import org.apache.cxf.staxutils.StaxUtils; //导入依赖的package包/类
protected void write(Source object, XMLStreamWriter writer) throws FactoryConfigurationError,
    XMLStreamException, DatabindingException {
    if (object == null) {
        return;
    }

    if (object instanceof DOMSource) {
        DOMSource ds = (DOMSource)object;

        Element element = null;
        if (ds.getNode() instanceof Element) {
            element = (Element)ds.getNode();
        } else if (ds.getNode() instanceof Document) {
            element = ((Document)ds.getNode()).getDocumentElement();
        } else {
            throw new DatabindingException("Node type " + ds.getNode().getClass()
                                           + " was not understood.");
        }

        StaxUtils.writeElement(element, writer, false);
    } else {
        StaxUtils.copy(object, writer);
    }
}
 

import org.apache.cxf.staxutils.StaxUtils; //导入依赖的package包/类
@Test
public void publishEndpointWithMtom() throws Exception {

    jaxwsEnvironment.publishEndpoint(
            new EndpointBuilder("local://path", service)
                    .enableMtom());

    verify(mockInvokerBuilder).create(any(), any(Invoker.class));

    byte[] response = testutils.invokeBytes("local://path", LocalTransportFactory.TRANSPORT_ID, soapRequest.getBytes());

    verify(mockInvoker).invoke(any(Exchange.class), any());

    MimeMultipart mimeMultipart = new MimeMultipart(new ByteArrayDataSource(response,
            "application/xop+xml; charset=UTF-8; type=\"text/xml\""));
    assertThat(mimeMultipart.getCount(), equalTo(1));
    testutils.assertValid("/soap:Envelope/soap:Body/a:fooResponse",
            StaxUtils.read(mimeMultipart.getBodyPart(0).getInputStream()));
}
 

import org.apache.cxf.staxutils.StaxUtils; //导入依赖的package包/类
@Override
public void handleMessage(SoapMessage message) throws Fault
{
	String mappedNamespace = message.getExchange().getService().getName().getNamespaceURI();
	InputStream in = message.getContent(InputStream.class);
	if( in != null )
	{
		// ripped from StaxInInterceptor
		String contentType = (String) message.get(Message.CONTENT_TYPE);
		if( contentType == null )
		{
			// if contentType is null, this is likely a an empty
			// post/put/delete/similar, lets see if it's
			// detectable at all
			Map<String, List<String>> m = CastUtils.cast((Map<?, ?>) message.get(Message.PROTOCOL_HEADERS));
			if( m != null )
			{
				List<String> contentLen = HttpHeaderHelper.getHeader(m, HttpHeaderHelper.CONTENT_LENGTH);
				List<String> contentTE = HttpHeaderHelper.getHeader(m, HttpHeaderHelper.CONTENT_TRANSFER_ENCODING);
				if( (StringUtils.isEmpty(contentLen) || "0".equals(contentLen.get(0)))
					&& StringUtils.isEmpty(contentTE) )
				{
					return;
				}
			}
		}

		// Inject our LegacyPythonHack
		XMLStreamReader reader = StaxUtils.createXMLStreamReader(in);
		message.setContent(XMLStreamReader.class, new LegacyPythonClientXMLStreamReader(reader, mappedNamespace));
	}
}
 

import org.apache.cxf.staxutils.StaxUtils; //导入依赖的package包/类
@Override
	public void write(Object obj, MessagePartInfo part, XMLStreamWriter output) {
		QName rootElement = part.getElementQName();
		Element serialized;
		try {
			serialized = prismContex.domSerializer().serializeAnyData(obj, rootElement);
			StaxUtils.copy(serialized, output);
//			output.writeCharacters(serialized);
		} catch (SchemaException | XMLStreamException e) {
			// TODO Auto-generated catch block
			throw new Fault(e);
		}
		
		
	}
 

import org.apache.cxf.staxutils.StaxUtils; //导入依赖的package包/类
public void handleMessage(Message message) throws Fault {

        Document doc = (Document)message.get(RawMessageWSDLGetInterceptor.DOCUMENT_HOLDER);
        if (doc == null) {
            return;
        }
        message.remove(RawMessageWSDLGetInterceptor.DOCUMENT_HOLDER);

        OutputStream out = message.getContent(OutputStream.class);

        String enc = null;
        try {
            enc = doc.getXmlEncoding();
        } catch (Exception ex) {
            //ignore - not dom level 3
        }
        if (enc == null) {
            enc = "utf-8";
        }

        XMLStreamWriter writer = StaxUtils.createXMLStreamWriter(out, enc);
        try {
            StaxUtils.writeNode(doc, writer, true);
            writer.flush();
        } catch (XMLStreamException e) {
            throw new Fault(e);
        }

    }
 

import org.apache.cxf.staxutils.StaxUtils; //导入依赖的package包/类
public void handleMessage(Message message) throws Fault {
    XMLStreamWriter xmlWriter = getXMLStreamWriter(message);
    try {
        // put the payload source as a document
        Source source = message.getContent(Source.class);
        if (source != null) {
            XMLStreamReader xmlReader = StaxUtils.createXMLStreamReader(source);
            StaxUtils.copy(xmlReader, xmlWriter);
        }
    } catch (XMLStreamException e) {
        throw new Fault(new org.apache.cxf.common.i18n.Message("XMLSTREAM_EXCEPTION", JUL_LOG, e), e);
    }
}
 

import org.apache.cxf.staxutils.StaxUtils; //导入依赖的package包/类
public void handleMessage(Message message) throws Fault {
    DepthXMLStreamReader xmlReader = getXMLStreamReader(message);
    try {
        // put the payload source as a document
        Document doc = StaxUtils.read(xmlReader);
        message.setContent(Source.class, new DOMSource(doc));
    } catch (XMLStreamException e) {
        throw new Fault(new org.apache.cxf.common.i18n.Message("XMLSTREAM_EXCEPTION", JUL_LOG), e);
    }
}
 

import org.apache.cxf.staxutils.StaxUtils; //导入依赖的package包/类
private static String getXMLString(Element el) {
    try {
        return StaxUtils.toString(el);
    } catch (Throwable t) {
        //ignore
    }
    return "unknown content";
}