78장. CXF

cxf: 구성 요소는 CXF에서 호스팅되는 Cryostat-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) 컨테이너에 단순화된 배포 모델을 제공하는 EAP의 Camel(Wildfly Camel) 프레임워크에서 지원합니다.

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

cxf:bean:cxfEndpoint[?options]

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

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 namespacehandler입니다.

Spring과 마찬가지로 Quarkus 참조를 사용할 수도 있습니다.

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

WSDL 우선 개발자 관점에서 대역 내 및 대역 외 헤더가 있습니다.

대역 내 헤더는 Cryostat 헤더와 같은 엔드포인트에 대한 WSDL 바인딩 계약의 일부로 명시적으로 정의된 헤더입니다.

대역 외 헤더는 유선을 통해 직렬화되지만 WSDL 바인딩 계약의 명시적으로 일부가 아닌 헤더입니다.

헤더 중계/필터링은 양방향입니다.

경로에 CXF 엔드포인트가 있고 개발자가 on-the-wire 헤더(예: Cryostat 헤더)를 다른 CryostatWS 엔드포인트에서 말할 경로를 따라 중계해야 하는 경우 relayHeaders 를 기본값인 true 로 설정합니다.

relayHeaders=true 설정은 헤더를 릴레이하려는 의도를 나타냅니다. 지정된 헤더가 릴레이되는지에 대한 실제 결정은 MessageHeadersRelay 인터페이스를 구현하는 플러그형 인스턴스에 위임됩니다. MessageHeadersRelay 의 구체적인 구현은 헤더를 릴레이해야 하는지 여부를 결정합니다. 이미 잘 알려진 Cryostat 네임스페이스에 바인딩하는 SoapMessageHeadersRelay 의 구현이 있습니다. 현재 대역 외 헤더만 필터링되고, relayHeaders=true 인 경우 대역 내 헤더는 항상 릴레이됩니다. 런타임에 네임스페이스가 알 수 없는 유선 헤더가 있는 경우 모든 헤더를 릴레이할 수 있는 fall back DefaultMessageHeadersRelay 가 사용됩니다.

relayHeaders=false 설정은 모든 헤더 in-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"/>

여기에서 헤더를 relay/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 헤더를 설정하여 호출하는 작업을 명시적으로 표시할 수 있습니다.

참고: 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 빈 요소에 지정된 Cryostat-WS schemaLocation 속성을 포함해야 합니다. 이를 통해 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 라는 classpath에 파일을 만듭니다. 이 파일은 한 줄에 주석 없이 클래스 org.apache.cxf.common.logging.Log4jLogger 의 정규화된 이름을 포함해야 합니다.

PHP와 같은 일부 Cryostat 클라이언트를 사용하는 경우 CXF가 XML 시작 문서 < ?xml version="1.0" encoding="utf-8"?>을 추가하지 않기 때문에 이러한 종류의 오류가 발생할 수 있습니다.

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

이 문제를 해결하려면 stayxOutInterceptor에게 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 forces 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 끝점 소비자 데이터 형식은 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 에 기본OperationName 이 설정되지 않은 경우 작업 목록에서 첫 번째 작업 이름을 선택합니다.

메시지 본문에서 오브젝트 배열을 가져오려면 다음과 같이 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 is filled in the reset of List.
// The result is 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("The response context", "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.cxf.CxfPayload 오브젝트를 반환합니다. 이러한 변경으로 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);
                }
            });
        }
    };
}

Cryo stat는 CXF 엔드포인트에서 Camel 교환을 생성하거나 사용할 때 데이터 형식이 Java 개체 목록 임을 의미합니다. Apache Camel은 이 모드에서 메시지 본문을 이 모드에서 Cryostat로 노출하지만 CXF 구성 요소는 여전히 read 및 write Cryostat 헤더에 대한 액세스를 제공합니다. 그러나 CXF 인터셉터는 처리된 후 헤더 목록에서 대역 내 headers를 제거하므로, outside-of-band Cryostat 헤더만 Cryostat 모드에서 사용할 수 있습니다.

다음 예제에서는 Cryostat 헤더를 가져오고 설정하는 방법을 보여줍니다. 한 CXF 끝점에서 다른 엔드포인트로 전달되는 경로가 있다고 가정하겠습니다. 즉, Cryostat 클라이언트 Apache Camel CXF 서비스입니다. 요청이 CXF 서비스로 돌아가기 전에 (1)에서 두 개의 프로세서를 연결하여 CXF 서비스로 응답하기 전에 2)를 가져올 수 있습니다. 이 예에서 프로세서(1) 및 (2)는 InsertRequestOutHeaderProcessor 및 InsertResponseOutHeaderProcessor입니다. 이 경로는 다음과 같습니다.

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

2.x #159 헤더는 Apache Camel Message headers로 전파됩니다. Apache Camel 메시지 헤더 이름은 org.apache.cxf.headers.Header.list 입니다. 이는 CXF에 정의된 상수입니다(org.apache.cxf.headers.Header.HEADER_LIST). 헤더 값은 List <> of CXF SoapHeader 오브젝트(org.apache.cxf.binding.soapHeader)입니다. 다음 스니펫은 InsertResponseOutHeaderProcessor (응답 메시지에 새 Cryostat 헤더를 삽입하는)입니다. InsertResponseOutHeaderProcessor 및 InsertRequestOutHeaderProcessor 모두에서 Cryostat 헤더에 액세스하는 방법은 실제로 동일합니다. 두 프로세서의 유일한 차이점은 삽입된 Cryostat 헤더의 방향을 설정하는 것입니다.

public static class InsertResponseOutHeaderProcessor implements Processor {

    @SuppressWarnings("unchecked")
    public void process(Exchange exchange) throws Exception {
        // If exchange is routed from camel-cxf endpoint, this is the header
        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 모드에서 CxfPayload 객체(CxfPayload 오브젝트)에 액세스하는 방법을 이미 표시했습니다( PAYLOAD 데이터 형식에서 camel-cxf 엔드포인트에 대한 메시지를 처리하는방법을 참조하십시오).

CxfPayload 오브젝트를 가져온 후에는 CxfPayload.getHeaders() 메서드를 호출하여 List of Cryostat(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("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("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부터 “Cryostat 모드에서 Cryostat 헤더를 가져오고 설정하는 방법” 에 설명된 것과 동일한 접근 방식을 사용하여 Cryostat 헤더를 설정하거나 가져올 수 있습니다. 이제 org.apache.cxf.headers.Header.list 헤더를 사용하여 Cryostat 헤더 목록을 가져오고 설정할 수 있습니다. 즉, 하나의 Camel CXF 끝점에서 다른(SOAP 클라이언트 Camel CXF 서비스)로 전달하는 경로가 있는 경우 Cryostat 클라이언트가 전송한 Cryostat 헤더도 CXF 서비스로 전달됩니다. 헤더를 전달하지 않으려면 org.apache.cxf.headers.Header.list Camel 헤더에서 해당 헤더를 제거합니다.

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

CXF 엔드포인트를 사용하여 Cryostat 요청을 사용하는 경우 camel 컨텍스트에서 Cryostat Fault 를 throw해야 할 수 있습니다. 기본적으로 throwFault DSL을 사용하여 이를 수행할 수 있습니다. 이 DSL은 Cryostat ,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 데이터 형식으로 작동하는 경우 메시지 본문에서 Cryostat 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));
    }

});

Cryostat 데이터 형식에도 마찬가지입니다. 외부 본문에서 Cryostat 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());

Cryostat 모드: 첨부 파일 및 MTOM 모두 지원됩니다(예: MTOM 활성화를 위해 Payload Mode 참조). 그러나 첨부 파일은 테스트되지 않습니다. 일반적으로 사용자가 직접 첨부를 처리할 필요가 없습니다.Attachments는 2.1.So 이후 Camel 메시지의 첨부 파일로 전파됩니다.

DataHandler Message.getAttachment(String id)

.

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

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>

첨부 파일이 있는 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")));

    }
}

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

CXF_MESSAGE 모드: MTOM이 지원되며, 위에서 언급한 Camel Message API에서 첨부 파일을 검색할 수 있습니다.

Java 예외가 서버 측에서 throw될 때 예외에 대한 스택 추적이 오류 메시지로 마샬링되어 클라이언트에 반환되도록 CXF 엔드포인트를 구성할 수 있습니다. 이 페어링을 사용하려면 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에서 camel-cxf 구성 요소는 이제 PAYLOAD 모드를 사용할 때 들어오는 메시지의 스트리밍을 지원합니다. 이전에는 들어오는 메시지가 완전히 구문 분석되었습니다. 대규모 메시지의 경우 시간이 오래 걸리며 상당한 양의 메모리를 사용합니다. 2.8.2부터 수신되는 메시지는 라우팅되는 동안 javax.xml.transform.Source로 남아 있을 수 있으며, 페이로드를 수정하지 않으면 대상 대상으로 직접 스트리밍할 수 있습니다. 일반적인 "간단한 프록시" 사용 사례의 경우(예: from("cxf:…​").to("cxf:…​")의 경우 성능이 크게 향상되고 메모리 요구 사항이 크게 저하될 수 있습니다.

그러나 스트리밍이 적절하거나 바람직하지 않은 경우가 있습니다. 스트리밍 특성으로 인해 잘못된 들어오는 XML이 처리 체인의 나중까지 catch되지 않을 수 있습니다. 또한 특정 작업을 수행하려면 메시지를(예: 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 디스패치 클라이언트는 특정 CryostatAction 헤더를 보내지 않습니다. 따라서 대상 서비스에 특정 CryostatAction 값이 필요한 경우 키 CryostatAction(대소문자 구분)을 사용하여 Camel 헤더에 제공됩니다.