第 78 章 CXF

cxf: 组件提供与 Apache CXF 的集成，用于连接到 CXF 上托管的 JAX-WS 服务。

Maven 用户需要将以下依赖项添加到其 pom.xml 中：

<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-cxf</artifactId>
    <version>x.x.x</version>
    <!-- use the same version as your Camel core version -->
</dependency>

该组件受到 EAP (Wildfly Camel)框架的 Camel 支持，该框架在红帽 JBoss 企业应用平台(JBoss EAP)容器上提供简化的部署模型。

CXF 组件与使用 Apache CXF 的 JBoss EAP Webservices susbsystem 集成。如需更多信息，请参阅 JAX-WS。

cxf:bean:cxfEndpoint[?options]

其中 cxfEndpoint 代表一个 bean ID，它引用 Spring bean registry 中的 bean。使用这个 URI 格式，大多数端点详情都在 bean 定义中指定。

cxf://someAddress[?options]

其中 someAddress 指定 CXF 端点的地址。使用这个 URI 格式，大多数端点详情都使用选项来指定。

对于以上任意样式，您可以在 URI 中附加选项，如下所示：

cxf:bean:cxfEndpoint?wsdlURL=wsdl/hello_world.wsdl&dataFormat=PAYLOAD

serviceName 和 portName s 为 QNames，因此如果您提供它们，请务必将它们前缀为 {namespace}，如上例所示。

您可以通过检索交换属性 CamelCXFDataFormat 来确定交换的数据模型。Exchange key constant 在 org.apache.camel.component.cxfConstants.DATA_FORMAT_PROPERTY 中定义。

从 Camel 2.8 开始，支持为您的 CXF 端点使用 Aries 蓝图依赖项注入。这个架构与 Spring 模式类似，因此转换非常透明。

例如：

 <blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0"
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xmlns:cm="http://aries.apache.org/blueprint/xmlns/blueprint-cm/v1.0.0"
            xmlns:camel-cxf="http://camel.apache.org/schema/blueprint/cxf"
 	   xmlns:cxfcore="http://cxf.apache.org/blueprint/core"
            xsi:schemaLocation="http://www.osgi.org/xmlns/blueprint/v1.0.0 https://www.osgi.org/xmlns/blueprint/v1.0.0/blueprint.xsd">

       <camel-cxf:cxfEndpoint id="routerEndpoint"
                      address="http://localhost:9001/router"
                      serviceClass="org.apache.servicemix.examples.cxf.HelloWorld">
         <camel-cxf:properties>
             <entry key="dataFormat" value="MESSAGE"/>
         </camel-cxf:properties>
      </camel-cxf:cxfEndpoint>

      <camel-cxf:cxfEndpoint id="serviceEndpoint"
			address="http://localhost:9000/SoapContext/SoapPort"
                     serviceClass="org.apache.servicemix.examples.cxf.HelloWorld">
    </camel-cxf:cxfEndpoint>

    <camelContext xmlns="http://camel.apache.org/schema/blueprint">
        <route>
            <from uri="routerEndpoint"/>
            <to uri="log:request"/>
        </route>
    </camelContext>

</blueprint>

目前，endpoint 元素是第一个支持的 CXF 命名空间handler。

您还可以使用 bean 参考，就像在 spring 中一样

<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:cm="http://aries.apache.org/blueprint/xmlns/blueprint-cm/v1.0.0"
           xmlns:jaxws="http://cxf.apache.org/blueprint/jaxws"
           xmlns:cxf="http://cxf.apache.org/blueprint/core"
           xmlns:camel="http://camel.apache.org/schema/blueprint"
           xmlns:camelcxf="http://camel.apache.org/schema/blueprint/cxf"
           xsi:schemaLocation="
             http://www.osgi.org/xmlns/blueprint/v1.0.0 https://www.osgi.org/xmlns/blueprint/v1.0.0/blueprint.xsd
             http://cxf.apache.org/blueprint/jaxws http://cxf.apache.org/schemas/blueprint/jaxws.xsd
             http://cxf.apache.org/blueprint/core http://cxf.apache.org/schemas/blueprint/core.xsd
             ">

    <camelcxf:cxfEndpoint id="reportIncident"
                     address="/camel-example-cxf-blueprint/webservices/incident"
                     wsdlURL="META-INF/wsdl/report_incident.wsdl"
                     serviceClass="org.apache.camel.example.reportincident.ReportIncidentEndpoint">
    </camelcxf:cxfEndpoint>

    <bean id="reportIncidentRoutes" class="org.apache.camel.example.reportincident.ReportIncidentRoutes" />

    <camelContext xmlns="http://camel.apache.org/schema/blueprint">
        <routeBuilder ref="reportIncidentRoutes"/>
    </camelContext>

</blueprint>

CXF 的 LoggingOutInterceptor 输出出站消息，该消息位于线上可记录系统(java.util.logging)。由于 LoggingOutInterceptor 处于 PRE_STREAM 阶段（但 PRE_STREAM 阶段在 MESSAGE 模式下），因此您必须在 WRITE 阶段配置 LoggingOutInterceptor 来运行。以下是一个示例。

   <bean id="loggingOutInterceptor" class="org.apache.cxf.interceptor.LoggingOutInterceptor">
        <!--  it really should have been user-prestream but CXF does have such phase! -->
        <constructor-arg value="target/write"/>
   </bean>

<cxf:cxfEndpoint id="serviceEndpoint" address="http://localhost:9002/helloworld"
	serviceClass="org.apache.camel.component.cxf.HelloService">
	<cxf:outInterceptors>
	    <ref bean="loggingOutInterceptor"/>
	</cxf:outInterceptors>
	<cxf:properties>
		<entry key="dataFormat" value="MESSAGE"/>
	</cxf:properties>
</cxf:cxfEndpoint>

从 JAXWS WSDL 优先开发人员的角度，存在带外 和带线标头。

in-band 标头是标头，被明确定义为 SOAP 标头等端点的 WSDL 绑定合同的一部分。

带外标头是通过 线序列化的标头，但没有明确属于 WSDL 绑定合同的一部分。

标头转发/过滤是双向的。

当路由具有 CXF 端点且开发人员需要有线头头（如 SOAP 标头）时，该路由会与另一个 JAXWS 端点所消耗的路由一起 转发，然后转发标头 应设置为 true （这是默认值）。

转发Headers=true 设置代表转发标头的意向。对给定标头进行转发的实际决定是否被委派给了实施 MessageHeadersRelay 接口的可插拔实例。将咨询一个对 MessageHeadersRelay 的整合实施，以确定是否需要转发标题。已有一个 SoapMessageHeadersRelay 的实现，它将自身绑定到知名的 SOAP 命名空间。目前，只过滤掉带外的标头，且在转发 Headers=true 时，始终会转发 带外的标头。如果线上有一个标头，则该命名空间对于运行时未知，则会使用一个回退 DefaultMessageHeadersRelay，只允许所有标头被转发。

转发Headers=false 设置表示将丢弃所有标题 in-band 和 out-of-band。

您可以插入您自己的 MessageHeadersRelay 实现覆盖，或向中继列表中添加额外的设置。要覆盖预加载的中继实例，只需确保您的 MessageHeadersRelay 实施服务与您要覆盖的命名空间相同。另请注意，覆盖中继必须与您要覆盖的所有命名空间作为您要覆盖的命名空间提供服务，否则，在路由启动时出现运行时异常会抛出，因为这会在命名空间引入了一个模糊性来转发实例映射。

<cxf:cxfEndpoint ...>
   <cxf:properties>
     <entry key="org.apache.camel.cxf.message.headers.relays">
       <list>
         <ref bean="customHeadersRelay"/>
       </list>
     </entry>
   </cxf:properties>
 </cxf:cxfEndpoint>
 <bean id="customHeadersRelay" class="org.apache.camel.component.cxf.soap.headers.CustomHeadersRelay"/>

查看演示如何在这里转发/drop 标头的测试：

link:https://svn.apache.org/repos/asf/camel/branches/camel-1.x/components/camel-cxf/src/test/java/org/apache/camel/component/cxf/soap/headers/CxfMessageHeadersRelayTest.java[https://svn.apache.org/repos/asf/camel/branches/camel-1.x/components/camel-cxf/src/test/java/org/apache/camel/component/cxf/soap/headers/CxfMessageHeadersRelayTest.java ]

您可以使用下方所示的 Spring 配置文件配置 CXF 端点，您还可以将端点嵌入到 camelContext 标签中。当您调用服务端点时，您可以将 operationName 和 operationNamespace 标头设置为显式调用的操作。

注意在 Camel 2.x 中，我们更改为使用 http://camel.apache.org/schema/cxf 作为 CXF 端点的目标命名空间。

<beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:cxf="http://camel.apache.org/schema/cxf"
        xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
        http://camel.apache.org/schema/cxf http://camel.apache.org/schema/cxf/camel-cxf.xsd
        http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring.xsd     ">
 ...

务必包含 root beans 元素中指定的 JAX-WS 模式Location 属性。这允许 CXF 验证文件并是必需的。另请注意，< cxf:cxfEndpoint/&gt; tag-​these 末尾的命名空间声明是必需的，因为此标签的属性值中不支持 {namespace}localName 语法。

cxf:cxfEndpoint 元素支持很多附加属性：

它还支持许多子元素：

您可以找到更多高级示例，其中显示了如何在此处提供拦截器、属性和处理程序 ：http://cwiki.apache.org/CXF20DOC/jax-ws-configuration.html

<cxf:cxfEndpoint id="testEndpoint" address="http://localhost:9000/router"
     serviceClass="org.apache.camel.component.cxf.HelloService"
     endpointName="s:PortName"
     serviceName="s:ServiceName"
     xmlns:s="http://www.example.com/test">
     <cxf:properties>
       <entry key="dataFormat" value="MESSAGE"/>
       <entry key="setDefaultBus" value="true"/>
     </cxf:properties>
   </cxf:cxfEndpoint>

CXF 的默认日志记录器是 java.util.logging。如果要将其更改为 log4j，请按如下操作：在 classpath 中创建一个文件，取名为 META-INF/cxf/org.apache.cxf.logger。此文件应当包含类的完全限定域名 org.apache.cxf.common.Log4jLogger 在单个行中。

如果您使用一些 SOAP 客户端，如 PHP，则会收到此类错误，因为 CXF 中没有添加 XML start 文档 < ?xml version="1.0" 编码="utf-8"?>。

Error:sendSms: SoapFault exception: [Client] looks like we got no XML document in [...]

要解决这个问题，您只需要告诉 StaxOutInterceptor 为您编写 XML 开始文档。

public class WriteXmlDeclarationInterceptor extends AbstractPhaseInterceptor<SoapMessage> {
    public WriteXmlDeclarationInterceptor() {
        super(Phase.PRE_STREAM);
        addBefore(StaxOutInterceptor.class.getName());
    }

    public void handleMessage(SoapMessage message) throws Fault {
        message.put("org.apache.cxf.stax.force-start-document", Boolean.TRUE);
    }

}

您可以添加一个客户拦截器，将其配置为 camel-cxf endpont

<cxf:cxfEndpoint id="routerEndpoint" address="http://localhost:${CXFTestSupport.port2}/CXFGreeterRouterTest/CamelContext/RouterPort"
 		serviceClass="org.apache.hello_world_soap_http.GreeterImpl"
 		skipFaultLogging="true">
     <cxf:outInterceptors>
         <!-- This interceptor will force the CXF server send the XML start document to client -->
         <bean class="org.apache.camel.component.cxf.WriteXmlDeclarationInterceptor"/>
     </cxf:outInterceptors>
     <cxf:properties>
         <!-- Set the publishedEndpointUrl which could override the service address from generated WSDL as you want -->
         <entry key="publishedEndpointUrl" value="http://www.simple.com/services/test" />
     </cxf:properties>
 </cxf:cxfEndpoint>

如果您使用的是 Camel 2.4，或者为它添加消息标头，如下所示。

 // set up the response context which force start document
 Map<String, Object> map = new HashMap<String, Object>();
 map.put("org.apache.cxf.stax.force-start-document", Boolean.TRUE);
 exchange.getOut().setHeader(Client.RESPONSE_CONTEXT, map);

camel-cxf 端点使用者 POJO 数据格式基于 cxf 调用器，因此消息标题具有名称 CxfConstants.OPERATION_NAME，消息正文是 SEI 方法参数的列表。

public class PersonProcessor implements Processor {

    private static final transient Logger LOG = LoggerFactory.getLogger(PersonProcessor.class);

    @SuppressWarnings("unchecked")
    public void process(Exchange exchange) throws Exception {
        LOG.info("processing exchange in camel");

        BindingOperationInfo boi = (BindingOperationInfo)exchange.getProperty(BindingOperationInfo.class.toString());
        if (boi != null) {
            LOG.info("boi.isUnwrapped" + boi.isUnwrapped());
        }
        // Get the parameters list which element is the holder.
        MessageContentsList msgList = (MessageContentsList)exchange.getIn().getBody();
        Holder<String> personId = (Holder<String>)msgList.get(0);
        Holder<String> ssn = (Holder<String>)msgList.get(1);
        Holder<String> name = (Holder<String>)msgList.get(2);

        if (personId.value == null || personId.value.length() == 0) {
            LOG.info("person id 123, so throwing exception");
            // Try to throw out the soap fault message
            org.apache.camel.wsdl_first.types.UnknownPersonFault personFault =
                new org.apache.camel.wsdl_first.types.UnknownPersonFault();
            personFault.setPersonId("");
            org.apache.camel.wsdl_first.UnknownPersonFault fault =
                new org.apache.camel.wsdl_first.UnknownPersonFault("Get the null value of person name", personFault);
            // Since camel has its own exception handler framework, we can't throw the exception to trigger it
            // We just set the fault message in the exchange for camel-cxf component handling and return
            exchange.getOut().setFault(true);
            exchange.getOut().setBody(fault);
            return;
        }

        name.value = "Bonjour";
        ssn.value = "123";
        LOG.info("setting Bonjour as the response");
        // Set the response message, first element is the return value of the operation,
        // the others are the holders of method parameters
        exchange.getOut().setBody(new Object[] {null, personId, ssn, name});
    }

}

camel-cxf 端点制作者基于 cxf 客户端 API。首先，您需要在消息标头中指定操作名称，然后将方法参数添加到列表中，并使用此参数列表初始化消息。响应消息的正文是 消息ContentsList，您可以从该列表中获取结果。

如果您没有在消息标头中指定操作名称，则 CxfProducer 将尝试使用 CxfEndpoint 中的 defaultOperationName。如果 CxfEndpoint 上没有设置 defaultOperationName，它将从操作列表获取第一个操作名称。

如果要从消息正文获取对象数组，您可以使用 message.getbody (Object[].class) 来获取正文，如下所示：

Exchange senderExchange = new DefaultExchange(context, ExchangePattern.InOut);
final List<String> params = new ArrayList<String>();
// Prepare the request message for the camel-cxf procedure
params.add(TEST_MESSAGE);
senderExchange.getIn().setBody(params);
senderExchange.getIn().setHeader(CxfConstants.OPERATION_NAME, ECHO_OPERATION);

Exchange exchange = template.send("direct:EndpointA", senderExchange);

org.apache.camel.Message out = exchange.getOut();
// The response message's body is an MessageContentsList which first element is the return value of the operation,
// If there are some holder parameters, the holder parameter will be filled in the reset of List.
// The result will be extract from the MessageContentsList with the String class type
MessageContentsList result = (MessageContentsList)out.getBody();
LOG.info("Received output text: " + result.get(0));
Map<String, Object> responseContext = CastUtils.cast((Map<?, ?>)out.getHeader(Client.RESPONSE_CONTEXT));
assertNotNull(responseContext);
assertEquals("We should get the response context here", "UTF-8", responseContext.get(org.apache.cxf.message.Message.ENCODING));
assertEquals("Reply body on Camel is wrong", "echo " + TEST_MESSAGE, result.get(0));

在 Apache Camel 2.0: CxfMessage.getBody （） 中，将返回 org.apache.camel.component.cxfPayload 对象，它具有 SOAP 消息标头和 Body 元素的 getters。这个更改启用了从 Apache Camel 消息分离原生 CXF 消息。

protected RouteBuilder createRouteBuilder() {
    return new RouteBuilder() {
        public void configure() {
            from(SIMPLE_ENDPOINT_URI + "&dataFormat=PAYLOAD").to("log:info").process(new Processor() {
                @SuppressWarnings("unchecked")
                public void process(final Exchange exchange) throws Exception {
                    CxfPayload<SoapHeader> requestPayload = exchange.getIn().getBody(CxfPayload.class);
                    List<Source> inElements = requestPayload.getBodySources();
                    List<Source> outElements = new ArrayList<Source>();
                    // You can use a customer toStringConverter to turn a CxfPayLoad message into String as you want
                    String request = exchange.getIn().getBody(String.class);
                    XmlConverter converter = new XmlConverter();
                    String documentString = ECHO_RESPONSE;

                    Element in = new XmlConverter().toDOMElement(inElements.get(0));
                    // Just check the element namespace
                    if (!in.getNamespaceURI().equals(ELEMENT_NAMESPACE)) {
                        throw new IllegalArgumentException("Wrong element namespace");
                    }
                    if (in.getLocalName().equals("echoBoolean")) {
                        documentString = ECHO_BOOLEAN_RESPONSE;
                        checkRequest("ECHO_BOOLEAN_REQUEST", request);
                    } else {
                        documentString = ECHO_RESPONSE;
                        checkRequest("ECHO_REQUEST", request);
                    }
                    Document outDocument = converter.toDOMDocument(documentString);
                    outElements.add(new DOMSource(outDocument.getDocumentElement()));
                    // set the payload header with null
                    CxfPayload<SoapHeader> responsePayload = new CxfPayload<SoapHeader>(null, outElements, null);
                    exchange.getOut().setBody(responsePayload);
                }
            });
        }
    };
}

POJO 表示，当 CXF 端点生成或消耗 Camel 交换时，数据格式是 Java 对象的列表。尽管 Apache Camel 在此模式下以 POJO 形式公开消息正文，但 CXF 组件仍然提供对读取和写入 SOAP 标头的访问。但是，由于拦截器在处理完成后从标头列表中删除带外 SOAP 标头，所以只有带外 SOAP 标头才可以在 POJO 模式中可用。

以下示例演示了如何获取/设置 SOAP 标头。假设我们有一个路由，它从一个 CXF 端点转发到另一个。也就是说，SOAP Client Apache Camel CXF 服务。在向 CXF 服务请求进入 CXF 服务前，我们可以附加两个处理器以获取/插入 SOAP 标头，然后响应回 SOAP 客户端。本例中的处理器(1)和(2)是 InsertRequestOutHeaderProcessor 和 InsertResponseOutHeaderProcessor。我们的路由如下：

<route>
    <from uri="cxf:bean:routerRelayEndpointWithInsertion"/>
    <process ref="InsertRequestOutHeaderProcessor" />
    <to uri="cxf:bean:serviceRelayEndpointWithInsertion"/>
    <process ref="InsertResponseOutHeaderProcessor" />
</route>

在 2.x SOAP 标头中，将传播到 并从 Apache Camel 消息标头传播。Apache Camel 消息标头名称为 org.apache.cxf.headers.Header.list，它是 CXF (org.apache.cxf.headers.Header.HEADER_LIST)中定义的常量。标头值为 CXF SoapHeader 对象的 List <> (org.apache.cxf.binding.soap.SoapHeader)。以下片段是 InsertResponseOutHeaderProcessor （在响应消息中插入一个新的 SOAP 标头）。在 InsertResponseOutHeaderProcessor 和 InsertRequestOutHeaderProcessor 中访问 SOAP 标头的方法实际上都相同。两个处理器之间的唯一区别是设置插入的 SOAP 标头的方向。

public static class InsertResponseOutHeaderProcessor implements Processor {

    @SuppressWarnings("unchecked")
    public void process(Exchange exchange) throws Exception {
        // You should be able to get the header if exchange is routed from camel-cxf endpoint
        List<SoapHeader> soapHeaders = CastUtils.cast((List<?>)exchange.getIn().getHeader(Header.HEADER_LIST));
        if (soapHeaders == null) {
            // we just create a new soap headers in case the header is null
            soapHeaders = new ArrayList<SoapHeader>();
        }

        // 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(),
                       DOMUtils.readXml(new StringReader(xml)).getDocumentElement());
        // make sure direction is OUT since it is a response message.
        newHeader.setDirection(Direction.DIRECTION_OUT);
        //newHeader.setMustUnderstand(false);
        soapHeaders.add(newHeader);

    }

}

我们已介绍如何在 PAYLOAD 模式中访问 SOAP 消息(CxfPayload 对象) （请参阅 “如何在 PAYLOAD 数据格式处理 camel-cxf 端点的信息”一节）。

获取 CxfPayload 对象后，您可以调用返回 DOM Elements (SOAP headers)的 CxfPayload.getHeaders （） 方法。

from(getRouterEndpointURI()).process(new Processor() {
    @SuppressWarnings("unchecked")
    public void process(Exchange exchange) throws Exception {
        CxfPayload<SoapHeader> payload = exchange.getIn().getBody(CxfPayload.class);
        List<Source> elements = payload.getBodySources();
        assertNotNull("We should get the elements here", elements);
        assertEquals("Get the wrong elements size", 1, elements.size());

        Element el = new XmlConverter().toDOMElement(elements.get(0));
        elements.set(0, new DOMSource(el));
        assertEquals("Get the wrong namespace URI", "http://camel.apache.org/pizza/types",
                el.getNamespaceURI());

        List<SoapHeader> headers = payload.getHeaders();
        assertNotNull("We should get the headers here", headers);
        assertEquals("Get the wrong headers size", headers.size(), 1);
        assertEquals("Get the wrong namespace URI",
                ((Element)(headers.get(0).getObject())).getNamespaceURI(),
                "http://camel.apache.org/pizza/types");
    }

})
.to(getServiceEndpointURI());

自 Camel 2.16.0 起，您可以使用与 “如何在 POJO 模式中获取和设置 SOAP 标头”一节 中描述的相同方法来设置或获取 SOAP 标头。现在，您可以使用 org.apache.cxf.headers.Header.list 标头获取和设置 SOAP 标头列表。这意味着，如果您有一个从一个 Camel CXF 端点转发到另一个 Camel CXF 端点的路由(SOAP Client Camel CXF 服务)，SOAP 客户端现在也会转发到 CXF 服务。如果您不希望标头转发，请将它们从 org.apache.cxf.headers.Header.list Camel 标头中删除。

当 SOAP 处理被跳过时，SOAP 标头在 MESSAGE 模式中不可用。

如果您使用 CXF 端点来消耗 SOAP 请求，您可能需要丢弃来自 camel 上下文的 SOAP 错误。基本上，您可以使用 throwFault DSL 来执行此操作；它适用于 POJO、PAYLOAD 和 MESSAGE 数据格式。您可以定义 soap 错误，如下所示：

SOAP_FAULT = new SoapFault(EXCEPTION_MESSAGE, SoapFault.FAULT_CODE_CLIENT);
Element detail = SOAP_FAULT.getOrCreateDetail();
Document doc = detail.getOwnerDocument();
Text tn = doc.createTextNode(DETAIL_TEXT);
detail.appendChild(tn);

然后像您一样进行丢弃：

from(routerEndpointURI).setFaultBody(constant(SOAP_FAULT));

如果您的 CXF 端点以 MESSAGE 数据格式工作，您可以在消息正文中设置 SOAP 失败消息，并在消息标头中设置响应代码。

from(routerEndpointURI).process(new Processor() {

    public void process(Exchange exchange) throws Exception {
        Message out = exchange.getOut();
        // Set the message body with the
        out.setBody(this.getClass().getResourceAsStream("SoapFaultMessage.xml"));
        // Set the response code here
        out.setHeader(org.apache.cxf.message.Message.RESPONSE_CODE, new Integer(500));
    }

});

POJO 数据格式也是如此。您可以在 Out body 上设置 SOAP 失败，并通过调用 Message.setFault (true) 来指出其出现了故障，如下所示：

from("direct:start").onException(SoapFault.class).maximumRedeliveries(0).handled(true)
    .process(new Processor() {
        public void process(Exchange exchange) throws Exception {
            SoapFault fault = exchange
                .getProperty(Exchange.EXCEPTION_CAUGHT, SoapFault.class);
            exchange.getOut().setFault(true);
            exchange.getOut().setBody(fault);
        }

    }).end().to(serviceURI);

CXF 客户端 API 提供了一种方法来调用带有请求和响应上下文的操作。如果您使用 CXF 端点制作者调用外部 Web 服务，您可以使用以下代码设置请求上下文并获取响应上下文：

        CxfExchange exchange = (CxfExchange)template.send(getJaxwsEndpointUri(), new Processor() {
             public void process(final Exchange exchange) {
                 final List<String> params = new ArrayList<String>();
                 params.add(TEST_MESSAGE);
                 // Set the request context to the inMessage
                 Map<String, Object> requestContext = new HashMap<String, Object>();
                 requestContext.put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, JAXWS_SERVER_ADDRESS);
                 exchange.getIn().setBody(params);
                 exchange.getIn().setHeader(Client.REQUEST_CONTEXT , requestContext);
                 exchange.getIn().setHeader(CxfConstants.OPERATION_NAME, GREET_ME_OPERATION);
             }
         });
         org.apache.camel.Message out = exchange.getOut();
         // The output is an object array, the first element of the array is the return value
         Object\[\] output = out.getBody(Object\[\].class);
         LOG.info("Received output text: " + output\[0\]);
         // Get the response context form outMessage
         Map<String, Object> responseContext = CastUtils.cast((Map)out.getHeader(Client.RESPONSE_CONTEXT));
         assertNotNull(responseContext);
         assertEquals("Get the wrong wsdl opertion name", "{http://apache.org/hello_world_soap_http}greetMe",
                      responseContext.get("javax.xml.ws.wsdl.operation").toString());

POJO 模式： 支持带 Attachment 和 MTOM 的双 SOAP （请参阅启用 MTOM 的 Payload Mode）。 但是，带有 Attachment 的 SOAP 没有被测试。 由于附件进行了汇总，并且未编入 POJO，因此用户通常无需处理他们自己附加的附件。 Attachments 被传播到从 2.1 开始的 Camel 消息的附件。 因此，可以通过 Camel 消息 API 重新发送附件

DataHandler Message.getAttachment(String id)

.

有效负载模式： 自 2.1 起支持 MTOM。上面提到的 Camel 消息 API 可以检索附件。不支持具有 Attachment 的 SOAP，因为此模式下没有 SOAP 处理。

要启用 MTOM，请将 CXF 端点属性 "mtom_enabled" 设置为 true。（我相信您只能在 Spring 中执行此操作。）

<cxf:cxfEndpoint id="routerEndpoint" address="http://localhost:${CXFTestSupport.port1}/CxfMtomRouterPayloadModeTest/jaxws-mtom/hello"
         wsdlURL="mtom.wsdl"
         serviceName="ns:HelloService"
         endpointName="ns:HelloPort"
         xmlns:ns="http://apache.org/camel/cxf/mtom_feature">

     <cxf:properties>
         <!--  enable mtom by setting this property to true -->
         <entry key="mtom-enabled" value="true"/>

         <!--  set the camel-cxf endpoint data fromat to PAYLOAD mode -->
         <entry key="dataFormat" value="PAYLOAD"/>
     </cxf:properties>

您可以使用附加生成 Camel 消息，以发送到 Payload 模式的 CXF 端点。

Exchange exchange = context.createProducerTemplate().send("direct:testEndpoint", new Processor() {

    public void process(Exchange exchange) throws Exception {
        exchange.setPattern(ExchangePattern.InOut);
        List<Source> elements = new ArrayList<Source>();
        elements.add(new DOMSource(DOMUtils.readXml(new StringReader(MtomTestHelper.REQ_MESSAGE)).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")));

    }

});

// process response

CxfPayload<SoapHeader> out = exchange.getOut().getBody(CxfPayload.class);
Assert.assertEquals(1, out.getBody().size());

Map<String, String> ns = new HashMap<String, String>();
ns.put("ns", MtomTestHelper.SERVICE_TYPES_NS);
ns.put("xop", MtomTestHelper.XOP_NS);

XPathUtils xu = new XPathUtils(ns);
Element oute = new XmlConverter().toDOMElement(out.getBody().get(0));
Element ele = (Element)xu.getValue("//ns:DetailResponse/ns:photo/xop:Include", oute,
                                   XPathConstants.NODE);
String photoId = ele.getAttribute("href").substring(4); // skip "cid:"

ele = (Element)xu.getValue("//ns:DetailResponse/ns:image/xop:Include", oute,
                                   XPathConstants.NODE);
String imageId = ele.getAttribute("href").substring(4); // skip "cid:"

DataHandler dr = exchange.getOut().getAttachment(photoId);
Assert.assertEquals("application/octet-stream", dr.getContentType());
MtomTestHelper.assertEquals(MtomTestHelper.RESP_PHOTO_DATA, IOUtils.readBytesFromStream(dr.getInputStream()));

dr = exchange.getOut().getAttachment(imageId);
Assert.assertEquals("image/jpeg", dr.getContentType());

BufferedImage image = ImageIO.read(dr.getInputStream());
Assert.assertEquals(560, image.getWidth());
Assert.assertEquals(300, image.getHeight());

您还可以在 Payload 模式中使用从 CXF 端点接收的 Camel 消息。

public static class MyProcessor implements Processor {

    @SuppressWarnings("unchecked")
    public void process(Exchange exchange) throws Exception {
        CxfPayload<SoapHeader> in = exchange.getIn().getBody(CxfPayload.class);

        // verify request
        assertEquals(1, in.getBody().size());

        Map<String, String> ns = new HashMap<String, String>();
        ns.put("ns", MtomTestHelper.SERVICE_TYPES_NS);
        ns.put("xop", MtomTestHelper.XOP_NS);

        XPathUtils xu = new XPathUtils(ns);
        Element body = new XmlConverter().toDOMElement(in.getBody().get(0));
        Element ele = (Element)xu.getValue("//ns:Detail/ns:photo/xop:Include", body,
                                           XPathConstants.NODE);
        String photoId = ele.getAttribute("href").substring(4); // skip "cid:"
        assertEquals(MtomTestHelper.REQ_PHOTO_CID, photoId);

        ele = (Element)xu.getValue("//ns:Detail/ns:image/xop:Include", body,
                                           XPathConstants.NODE);
        String imageId = ele.getAttribute("href").substring(4); // skip "cid:"
        assertEquals(MtomTestHelper.REQ_IMAGE_CID, imageId);

        DataHandler dr = exchange.getIn().getAttachment(photoId);
        assertEquals("application/octet-stream", dr.getContentType());
        MtomTestHelper.assertEquals(MtomTestHelper.REQ_PHOTO_DATA, IOUtils.readBytesFromStream(dr.getInputStream()));

        dr = exchange.getIn().getAttachment(imageId);
        assertEquals("image/jpeg", dr.getContentType());
        MtomTestHelper.assertEquals(MtomTestHelper.requestJpeg, IOUtils.readBytesFromStream(dr.getInputStream()));

        // create response
        List&lt;Source> elements = new ArrayList&lt;Source>();
        elements.add(new DOMSource(DOMUtils.readXml(new StringReader(MtomTestHelper.RESP_MESSAGE)).getDocumentElement()));
        CxfPayload&lt;SoapHeader> sbody = new CxfPayload&lt;SoapHeader>(new ArrayList&lt;SoapHeader>(),
            elements, null);
        exchange.getOut().setBody(sbody);
        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")));

    }
}

Message Mode： 不支持连接，因为它并不处理消息。

CXF_MESSAGE 模式： 支持 MTOM，并且可按照上述 Camel 消息 API 检索附件。请注意，当收到多部分（即 MTOM）消息时，默认的 SOAPMessage to String converter 将在正文中提供完整的多部分有效负载。如果您只要求 SOAP XML 作为字符串，您可以使用 message.getSOAPPart （） 设置消息正文，Camel 转换可以为您进行其余工作。

可以配置 CXF 端点，以便在服务器端引发 Java 异常时，异常堆栈的追踪会被整合到容错消息中，并返回给客户端。要启用此功能，请将 dataFormat 设置为 PAYLOAD，并在 cxfEndpoint 元素中将 faultStackTraceEnabled 属性设置为 true，如下所示：

<cxf:cxfEndpoint id="router" address="http://localhost:9002/TestMessage"
    wsdlURL="ship.wsdl"
    endpointName="s:TestSoapEndpoint"
    serviceName="s:TestService"
    xmlns:s="http://test">
  <cxf:properties>
    <!-- enable sending the stack trace back to client; the default value is false-->
    <entry key="faultStackTraceEnabled" value="true" /> <entry key="dataFormat" value="PAYLOAD" />
  </cxf:properties>
</cxf:cxfEndpoint>

出于安全考虑，堆栈跟踪不包括导致的异常（也就是说，堆栈跟踪的一部分 ）如果要在堆栈追踪中包含导致异常，请在 cxfEndpoint 元素中将 exceptionMessageCauseEnabled 属性设为 true，如下所示：

<cxf:cxfEndpoint id="router" address="http://localhost:9002/TestMessage"
    wsdlURL="ship.wsdl"
    endpointName="s:TestSoapEndpoint"
    serviceName="s:TestService"
    xmlns:s="http://test">
  <cxf:properties>
    <!-- enable to show the cause exception message and the default value is false -->
    <entry key="exceptionMessageCauseEnabled" value="true" />
    <!-- enable to send the stack trace back to client,  the default value is false-->
    <entry key="faultStackTraceEnabled" value="true" />
    <entry key="dataFormat" value="PAYLOAD" />
  </cxf:properties>
</cxf:cxfEndpoint>

在 2.8.2 中，Carl-cxf 组件现在支持在使用 PAYLOAD 模式时，支持在传入消息流处理。在以前的版本中，传入的信息已被完全解析。对于大型消息，这需要消耗大量内存。从 2.8.2 开始，传入消息可在路由期间保持为 javax.xml.transform.Source，如果不修改有效负载，则可以直接流传输到目标目的地。对于常见的"简单代理"用例（例如： from ("cxf:…​").to ("cxf:…​")），这可以提供非常显著的性能增加，以及显著降低的内存要求。

然而，在有些情况下，流性可能不适合或需要。由于流性，在稍后处理链中不会发现无效的传入 XML。另外，某些操作可能需要下载消息，如 WS-Security 或消息追踪（例如，流处理的优点）。此时，可以通过两种方式控制流：

从 2.8.0，camel-cxf 组件支持通用 CXF 分配模式，它可以传输任意结构的消息（例如，不绑定到特定 XML 模式）。要使用此模式，您只需省略 CXF 端点的 wsdlURL 和 serviceClass 属性。

<cxf:cxfEndpoint id="testEndpoint" address="http://localhost:9000/SoapContext/SoapAnyPort">
  <cxf:properties>
    <entry key="dataFormat" value="PAYLOAD"/>
  </cxf:properties>
</cxf:cxfEndpoint>

请注意，默认的 CXF 分配客户端不会发送特定的 SOAPAction 标头。因此，当目标服务需要特定的 SOAPAction 值时，会使用键 SOAPAction （不区分大小写）在 Camel 标头中提供。