77장. CXF

cxf: 구성 요소는 CXF에서 호스팅되는 JAX-WS 서비스에 연결하기 위해 Apache CXF 와의 통합을 제공합니다.

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>

이 구성 요소는 Red Hat JBoss EAP(JBoss Enterprise Application Platform) 컨테이너에서 단순화된 배포 모델을 제공하는 Camel on EAP(Wildfly Camel) 프레임워크에서 지원합니다.

CXF 구성 요소는 Apache CXF도 사용하는 JBoss EAP 웹 서비스 susbsystem과 통합됩니다. 자세한 내용은 JAX-WS 를 참조하십시오.

cxf:bean:cxfEndpoint[?options]

여기서 cxfEndpoint 는 Spring 빈 레지스트리의 빈을 참조하는 빈 ID를 나타냅니다. 이 URI 형식을 사용하면 대부분의 끝점 세부 정보가 빈 정의에 지정됩니다.

cxf://someAddress[?options]

여기서 someAddress 는 CXF 끝점의 주소를 지정합니다. 이 URI 형식을 사용하면 대부분의 엔드포인트 세부 정보가 옵션을 사용하여 지정됩니다.

위의 두 스타일 모두 다음과 같이 URI에 옵션을 추가할 수 있습니다.

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

serviceName 및 portName 은 QNames 이므로, 제공한 경우 위의 예에 표시된 대로 {namespace} 로 접두사가 있어야 합니다.

교환 속성 CamelCXFDataFormat 을 검색하여 교환의 데이터 형식 모드를 결정할 수 있습니다. 교환 키 상수는 org.apache.camel.component.cxf.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입니다.

또한 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>

JAXWSWS -first 개발자의 관점에서 볼 때 대역 외 및 대역 외 온-선 헤더가 있습니다.

인 밴드 헤더는 SOAP 헤더와 같은 끝점에 대한 WSDL 바인딩 계약의 일부로 명시적으로 정의된 헤더입니다.

대역 외 헤더는 유선을 통해 직렬화되는 헤더이지만 WSDL 바인딩 계약의 일부는 명시적으로 포함되지 않습니다.

헤더 릴레이/필터링은 양방향입니다.

경로에 CXF 엔드포인트가 있고 개발자가 SOAP 헤더와 같은 on-the-wire 헤더가 있어야 하는 경우 다른 JAXWS 엔드포인트에서 사용할 경로를 따라 릴레이된 다음 relayHeaders 를 true 로 설정해야 합니다. 그러면 relayHeaders는 기본값입니다.

relayHeaders=true 설정은 헤더를 릴레이하려는 의도를 표시합니다. 지정된 헤더를 릴레이하는지 여부에 대한 실제 결정은 MessageHeadersRelay 인터페이스를 구현하는 플러그형 인스턴스에 위임됩니다. MessageHeadersRelay 의 구체적인 구현을 참조하여 헤더를 릴레이해야 하는지 여부를 결정합니다. 이미 잘 알려진 SOAP 네임 스페이스에 자체적으로 바인딩하는 SoapMessageHeadersRelay 구현이 이미 있습니다. 현재 대역 외 헤더만 필터링되고, relayHeaders=true 일 때 항상 대역 내 헤더가 중계됩니다. 이름 공간이 런타임에서 알 수 없는 전선에 헤더가 있는 경우 fall DefaultMessageHeadersRelay 가 사용됩니다. 그러면 단순히 모든 헤더를 릴레이할 수 있습니다.

relayHeaders=false 설정은 모든 헤더, 대역 내 및 대역 외가 삭제됨을 나타냅니다.

자체 MessageHeadersRelay 구현을 재정의하거나 릴레이 목록에 추가할 수 있습니다. 사전 로드된 릴레이 인스턴스를 재정의하려면 MessageHeadersRelay 구현 서비스가 재정의하려는 것과 동일한 네임 스페이스를 제공하는지 확인하십시오. 또한 덮어쓰기 릴레이는 모든 네임 스페이스를 재정의하려는 항목으로 제공해야 합니다. 그러지 않으면 인스턴스 매핑을 릴레이하는 네임 스페이스에 모호함을 도입하므로 라우팅 시작 시 런타임 예외가 throw됩니다.

<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 헤더를 릴레이할 수 있는 방법을 보여주는 테스트를 살펴보십시오.

링크: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 헤더를 호출할 작업을 명시적으로 state로 설정할 수 있습니다.

참고 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     ">
 ...

루트 빈 요소에 지정된 JAX-WS 스키마Location 속성을 포함해야 합니다. 이를 통해 CXF는 파일의 유효성을 검사하고 필요합니다. 또한 결합된 {namespace}localName 구문이 현재 이 태그의 특성 값에 대해 지원되지 않으므로 < cxf:cxfEndpoint /> 태그의 끝에 네임스페이스 선언이 필요합니다.

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 로 변경하려면 다음과 같이 진행하십시오. META-INF/cxf/org.apache.cxf.logger 라는 클래스 경로에 파일을 만듭니다. 이 파일에는 주석이 없는 org.apache.cxf.common.logging.Log4jLogger 클래스의 정규화된 이름이 포함되어야 합니다.

PHP와 같은 몇 가지 SOAP 클라이언트를 사용하는 경우 CXF가 XML 시작 문서 < ?xml 버전="1.0" encoding="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 를 기반으로 합니다. 먼저 메시지 헤더에 작업 이름을 지정한 다음 메서드 매개 변수를 목록에 추가하고 이 매개변수 목록을 사용하여 메시지를 초기화해야 합니다. 응답 메시지의 본문은 messageContentsList 이므로 해당 목록에서 결과를 가져올 수 있습니다.

메시지 헤더에 작업 이름을 지정하지 않으면 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() 는 SOAP 메시지 헤더 및 Body 요소에 대한 getter가 있는 org.apache.camel.component.cxf.CxfPayload 오브젝트를 반환합니다. 이러한 변경으로 기본 CXF 메시지를 Apache Camel 메시지에서 분리할 수 있습니다.

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 Exchange를 생성하거나 사용할 때 데이터 형식이 Java 개체의 목록 임을 의미합니다. Apache Camel은 이 모드에서 메시지 본문을 POJO로 공개하지만 CXF 구성 요소는 SOAP 헤더를 읽고 쓸 수 있는 액세스 권한을 계속 제공합니다. 그러나 CXF 인터셉터는 처리된 후 헤더 목록에서 인 대역 내 SOAP 헤더를 제거하므로 대역 외 SOAP 헤더만 POJO 모드에서 사용할 수 있습니다.

다음 예제에서는 SOAP 헤더를 가져오거나 설정하는 방법을 보여줍니다. 한 CXF 끝점에서 다른 CXF 엔드포인트로 전달하는 경로가 있다고 가정합니다. 즉, SOAP 클라이언트 → Apache Camel → CXF 서비스입니다. 요청이 CXF 서비스에 나가기 전에 (1)에 SOAP 헤더를 가져오고 삽입하기 위해 두 개의 프로세서를 연결하고, (2) 응답이 SOAP Client로 되돌아오기 전에 연결할 수 있습니다. 이 예에서 프로세서 (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 Message 헤더로 또는 Apache Camel Message 헤더로 전파됩니다. Apache Camel 메시지 헤더 이름은 org.apache.cxf.headers.Header.list 이며, CXF(org.apache.cxf.headers.Header.HEADER_LIST)에 정의된 상수입니다. 헤더 값은 CXF SoapHeader 오브젝트(org.apache.cxf.binding.soap.Soap.Soap.Soap)의 List <>입니다. 다음 스니펫은 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 오브젝트를 확보하면 CxfPayload.getHeaders() 메서드를 호출하여 DOM Elements(SOAP 헤더) 목록 을 반환합니다.

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부터 “How to get and set SOAP headers in POJO mode” 에 설명된 것과 동일한 방법을 사용하여 SOAP 헤더를 설정하거나 가져올 수 있습니다. 이제 org.apache.cxf.headers.Header.list 헤더를 사용하여 SOAP 헤더 목록을 가져오고 설정할 수 있습니다. 즉, 하나의 Camel CXF 끝점에서 다른 (SOAP Client → Camel → CXF 서비스)로 전달하는 경로가 있는 경우 SOAP 클라이언트에서 보낸 SOAP 헤더도 CXF 서비스로 전달됩니다. 헤더를 전달하지 않으려면 org.apache.cxf.headers.Header.list Camel 헤더에서 해당 헤더를 제거합니다.

SOAP 처리를 건너뛰기 때문에 MESSAGE 모드에서 SOAP 헤더를 사용할 수 없습니다.

SOAP 요청을 사용하기 위해 CXF 엔드포인트를 사용하는 경우 camel 컨텍스트에서 SOAP Fault 를 throw해야 할 수 있습니다. 기본적으로 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 Fault 메시지를 설정하고 메시지 헤더에 응답 코드를 설정할 수 있습니다.

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 Fault를 설정하고 다음과 같이 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 엔드포인트 생산자를 사용하여 외부 웹 서비스를 호출하는 경우 요청 컨텍스트를 설정하고 다음 코드로 응답 컨텍스트를 가져올 수 있습니다.

        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로 마샬링 및 손상되지 않으므로 일반적으로 사용자는 첨부 파일을 직접 처리할 필요가 없습니다. 첨부 파일은 2.1 이후 Camel 메시지의 첨부 파일에 전파됩니다. 따라서 Camel Message API로 다시 연결할 수 있습니다.

DataHandler Message.getAttachment(String id)

.

페이로드 모드: MTOM은 2.1 이후 지원됩니다. 위에서 언급한 Camel Message API를 통해 첨부 파일을 검색할 수 있습니다. 이 모드에서는 SOAP 처리가 없기 때문에 Attachment를 사용한 SOAP가 지원되지 않습니다.

MTOM을 활성화하려면 CXF 엔드포인트 속성 "mtom_enabled"를 true 로 설정합니다. (나는 봄에만 할 수 있다고 생각합니다.)

<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>

Payload 모드에서 CXF 엔드포인트에 보낼 첨부 파일로 Camel 메시지를 생성할 수 있습니다.

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")));

    }
}

메시지 모드: 첨부 파일은 메시지를 처리하지 않으므로 지원되지 않습니다.

CXF_MESSAGE 모드: MTOM이 지원되며 위에서 언급한 Camel Message API를 통해 첨부 파일을 검색할 수 있습니다. 멀티 파트 (즉, MTOM) 메시지를 수신할 때 기본 SOAPMessage to String 변환기가 본문에 대한 전체 멀티 파트 페이로드를 제공합니다. SOAP XML만 문자열이 필요한 경우 message.getSOAPPart() 를 사용하여 메시지 본문을 설정할 수 있으며 Camel 변환은 나머지 작업을 수행할 수 있습니다.

서버 측에서 Java 예외가 throw되면 예외에 대한 스택 추적이 오류 메시지로 마샬링되고 클라이언트에 반환되는 CXF 엔드포인트를 구성할 수 있습니다. 이 feaure를 활성화하려면 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>

보안상의 이유로 스택 추적에는 원인이 되는 예외(즉, 스택 추적의 일부)가 포함되어 있지 않습니다. 스택 추적에 causing 예외를 포함하려면 cxfEndpoint 요소에서 exceptionMessage causesEnabled 속성을 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에서 camel-cxf 구성 요소는 PAYLOAD 모드를 사용할 때 수신 메시지의 스트리밍을 지원합니다. 이전에는 들어오는 메시지가 완전히 DOM 구문 분석되었습니다. 대규모 메시지의 경우 시간이 오래 걸리고 상당한 양의 메모리를 사용합니다. 2.8.2부터, 수신 메시지는 라우팅되는 동안 javax.xml.transform.Source로 남아 있을 수 있으며, 아무 것도 페이로드를 수정하지 않으면 대상 목적지로 직접 스트리밍할 수 있습니다. 일반적인 "간단 프록시" 사용 사례(예:("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 헤더에 제공됩니다.