Skip to site navigation (Press enter)

[CONF] Apache Camel > CXF Proxy Example

confluence Fri, 18 Nov 2011 13:26:24 -0800

     CXF Proxy Example
    Page edited by             Glen Mazza
    
        
        Comment:
        text updates

    
        

                         Changes (24)
                                 
    

                    
    
            h2. CXF Proxy Example 

            *Available as of Camel 2.5* 

             
This example is located in the {{examples/camel-example-cxf-proxy}} directory of the Camel distribution. 
There is a {{README.txt}} file with instructions how to run it. 
 

            If you use mMaven then you can easily run it from the command line using: 

            {code} 

            mvn jetty:run camel:run 

            {code} 
 
h3. About 
 

            This example demonstrates how you can use [CXF] to proxy a real web service. For example in this case we want Camel to validate and enrich the input message before its send to the real web service. We do this to ensure the data is correct and that missing information is added automatic by Camel. In real life you may want to do this in case a client send bad/faulty data to a web service, and its costly/not possible to update and fix that client. Instead lets fix it by a proxy with Camel. 

            This example demonstrates how [CXF] can be used to proxy a real web service. For this example we want Camel to validate and enrich the input message before it's sent to the actual web service. We do this to ensure the data is correct and to have Camel automatically add in any missing information. In real life you may wish to use a proxy in cases where clients are sending bad/faulty data to a web service, and it's costly/not possible to update and fix those clients. 

             
{tip:title=Pure HTTP proxy} 

            If you want a pure http based proxy then you can use [Jetty] or [Servlet] as front end in Camel. Then delegate those incoming HTTP requests to the real web service. You may want to do this if you want a simple straight thru proxy where the message should not be altered by Camel. 
By using the [CXF] component you get access to all the web service features Apache CXF provides, where as with [Jetty] its just pure HTTP proxy. 

            If you want a pure HTTP-based proxy then you can use [Jetty] or [Servlet] as the front end in Camel. Then delegate those incoming HTTP requests to the real web service.  This is for cases where you need a simple straight through proxy where the message should not be altered by Camel.  By using the [CXF] component you get access to all the web service features Apache CXF provides, whereas [Jetty] will provide just a pure HTTP proxy. 

            {tip} 
 
h3. Implementation 
 

            Since this is a example it provides both the Camel application and the real web service in the same JVM. In your use-case the real webs ervice will be hosted on another server etc. 

            For this simple example both the Camel application and the real web service are in the same JVM. In production work the real web service may often be hosted on another server, etc. 

             
h4. Spring XML 
 

            In the Spring XML file we have defined the [CXF] proxy endpoint using the {{<cxf:cxfEndpoint>}} tag.  The real web service is the Spring bean with the id {{realWebService}}. 

            And the real web service is the Spring bean with the id {{realWebService}}. 

             

            As you can see in the Camel route we use a [CXF] consumer to proxy the web service. Then we route the message to the enrich bean EnrichBean which validates and adds the missing information. Then we just use the [HTTP] component to send the web service request to the real web service. 

            The reply from the real web service is then logged and used as a reply for the proxied web service as well. 

             
{snippet:id=e1|lang=xml|url="" 

            ...

            h3. Running the example 
 

            You start the example from the command line using the maven goal {{mvn jetty:run}}. There is also a {{build.xml}} file for ANT users. 

            You start the example from the command line using the Maven goal {{mvn camel:run}}. 

            You can also start the Camel application from your IDE, by running the {{org.apache.camel.example.cxf.proxy.MyMain}} main class. 

             

            You can then use SoapUI or another web service client and send a request to the {{http://localhost:9080/camel-example-cxf-proxy/webservices/incident}} url. The wsdl is located at: {{http://localhost:9080/camel-example-cxf-proxy/webservices/incident?wsdl}}. 
 

            The console should then output progress. 

            After making a SOAP request, check the console to see the SOAP request and response: 

             
h3. Sample output 
 

            Here is some a sample output from the console: 

            {code} 
2010-09-26 12:20:46,974 [main           ] INFO  DefaultCamelContext            - Apache Camel 2.5-SNAPSHOT (CamelContext: camel-1) started in 0.858 seconds 

            ...

               <soapenv:Body> 
      <rep:inputReportIncident> 

            <incidentId>63</incidentId> 

                     <incidentDate>2010-09-26</incidentDate> 

            <givenName>Ibsen</givenName> <givenName>Claus</givenName> 

            <familyName>Claus</familyName> <familyName>Ibsen</familyName> 

                     <summary>Bla bla</summary> 
         <details>More bla</details> 

            ...

               </soapenv:Body> 
</soapenv:Envelope>] 

            Incident was , 63, changed to 456 

             
 

            Invoked real web service: id=456 by Claus Ibsen 

             

            Invoked real web service: id=456 by Ibsen Claus 

             

            2010-09-26 12:20:55,997 [tp-1790017034-1] INFO  output                         - Exchange[ExchangePattern:InOut, 
    BodyType:org.apache.camel.converter.stream.CachedOutputStream.WrappedInputStream, Body: 

            ...

    
            
    
                            Full Content
                    
        CXF Proxy Example

This example is located in the examples/camel-example-cxf-proxy directory of the Camel distribution.

There is a README.txt file with instructions how to run it.

If you use Maven then you can easily run it from the command line using:

mvn camel:run



About

This example demonstrates how CXF can be used to proxy a real web service. For this example we want Camel to validate and enrich the input message before it's sent to the actual web service. We do this to ensure the data is correct and to have Camel automatically add in any missing information. In real life you may wish to use a proxy in cases where clients are sending bad/faulty data to a web service, and it's costly/not possible to update and fix those clients.

Pure HTTP proxy
If you want a pure HTTP-based proxy then you can use Jetty or SERVLET as the front end in Camel. Then delegate those incoming HTTP requests to the real web service.  This is for cases where you need a simple straight through proxy where the message should not be altered by Camel.  By using the CXF component you get access to all the web service features Apache CXF provides, whereas Jetty will provide just a pure HTTP proxy.

Implementation

For this simple example both the Camel application and the real web service are in the same JVM. In production work the real web service may often be hosted on another server, etc.

Spring XML

In the Spring XML file we have defined the CXF proxy endpoint using the <cxf:cxfEndpoint> tag.  The real web service is the Spring bean with the id realWebService.

As you can see in the Camel route we use a CXF consumer to proxy the web service. Then we route the message to the EnrichBean which validates and adds the missing information. Then we just use the HTTP component to send the web service request to the real web service.

The reply from the real web service is then logged and used as a reply for the proxied web service as well.


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

  <import resource="classpath:META-INF/cxf/cxf.xml"/>
  
  <!-- use a bean to start and stop the real web service (is not Camel specific) -->
  <!-- in a real use-case the real web service would be located on another server
       but we simulate this in the same JVM -->
  <bean id="realWebService" class="org.apache.camel.example.cxf.proxy.RealWebServiceBean"
        init-method="start" destroy-method="stop">
    <!-- this is the url of the real web service we have proxied -->
    <property name="url" value="http://localhost:9081/real-webservice"/>
  </bean>

  <!-- a bean to enrich the input -->
  <bean id="enrichBean" class="org.apache.camel.example.cxf.proxy.EnrichBean"/>

  <!-- this is the CXF webservice we use as front end -->
  <cxf:cxfEndpoint id="reportIncident"
                   address="http://localhost:9080/camel-example-cxf-proxy/webservices/incident"
                   endpointName="s:ReportIncidentEndpoint"
                   serviceName="s:ReportIncidentEndpointService"
                   wsdlURL="etc/report_incident.wsdl"
                   xmlns:s="http://reportincident.example.camel.apache.org"/>

  <!-- this is the camel route which proxy the web service and forward it to the real web service -->
  <camelContext xmlns="http://camel.apache.org/schema/spring">

    <route>
      <!-- cxf consumer using MESSAGE format -->
      <from uri="cxf:bean:reportIncident?dataFormat=MESSAGE"/>
      <!-- log input received -->
      <to uri="log:input"/>
      <!-- enrich the input by ensure the incidentId parameter is set -->
      <to uri="bean:enrichBean"/>
      <!-- send proxied request to real web service -->
      <to uri="http://localhost:9081/real-webservice?throwExceptionOnFailure=false"/>
      <!-- log answer from real web service -->
      <to uri="log:output"/>
    </route>

  </camelContext>

</beans>



Enrich bean

The enrich bean is Java code which in our simple example will just set the incidentId parameter to the fixed value of 456. In your implementation you can of course do a lot more.


public class EnrichBean {

    public Document enrich(Document doc) {
        Node node = doc.getElementsByTagName("incidentId").item(0);
        String incident = node.getTextContent();

        // here we enrich the document by changing the incident id to another value
        // you can of course do a lot more in your use-case
        node.setTextContent("456");
        System.out.println("Incident was " + incident + ", changed to 456");

        return doc;
    }
}



Running the example

You start the example from the command line using the Maven goal mvn camel:run.

You can also start the Camel application from your IDE, by running the org.apache.camel.example.cxf.proxy.MyMain main class.

You can then use SoapUI or another web service client and send a request to the http://localhost:9080/camel-example-cxf-proxy/webservices/incident url. The wsdl is located at: http://localhost:9080/camel-example-cxf-proxy/webservices/incident?wsdl.

After making a SOAP request, check the console to see the SOAP request and response:

Sample output

Here is a sample output from the console:

2010-09-26 12:20:46,974 [main           ] INFO  DefaultCamelContext            - Apache Camel 2.5-SNAPSHOT (CamelContext: camel-1) started in 0.858 seconds
2010-09-26 12:20:55,685 [tp-1790017034-1] INFO  input                          - Exchange[ExchangePattern:InOut, BodyType:null, Body:
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:rep="http://reportincident.example.camel.apache.org">
   <soapenv:Header/>
   <soapenv:Body>
      <rep:inputReportIncident>
         <incidentId>63</incidentId>
         <incidentDate>2010-09-26</incidentDate>
         <givenName>Claus</givenName>
         <familyName>Ibsen</familyName>
         <summary>Bla bla</summary>
         <details>More bla</details>
         <email>[email protected]</email>
         <phone>12345678</phone>
      </rep:inputReportIncident>
   </soapenv:Body>
</soapenv:Envelope>]
Incident was 63, changed to 456


Invoked real web service: id=456 by Claus Ibsen


2010-09-26 12:20:55,997 [tp-1790017034-1] INFO  output                         - Exchange[ExchangePattern:InOut,
    BodyType:org.apache.camel.converter.stream.CachedOutputStream.WrappedInputStream, Body:
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
    <soap:Body>
        <ns2:outputReportIncident xmlns:ns2="http://reportincident.example.camel.apache.org">
            <code>OK;456</code>
        </ns2:outputReportIncident>
    </soap:Body>
</soap:Envelope>]



See Also

	Examples
	CXF
	HTTP
	Jetty
	SERVLET
	SOAP


    
        
        
            Change Notification Preferences
        
        View Online
        |
        View Changes
                |
        Add Comment
 h2. CXF Proxy Example
-*Available as of Camel 2.5*
 This example is located in the {{examples/camel-example-cxf-proxy}} directory of the Camel distribution. 
There is a {{README.txt}} file with instructions how to run it.
 If you use mMaven then you can easily run it from the command line using:
 {code}
 mvn jetty:run camel:run
 {code} 
 
h3. About
-This example demonstrates how you can use [CXF] to proxy a real web service. For example in this case we want Camel to validate and enrich the input message before its send to the real web service. We do this to ensure the data is correct and that missing information is added automatic by Camel. In real life you may want to do this in case a client send bad/faulty data to a web service, and its costly/not possible to update and fix that client. Instead lets fix it by a proxy with Camel.
+This example demonstrates how [CXF] can be used to proxy a real web service. For this example we want Camel to validate and enrich the input message before it's sent to the actual web service. We do this to ensure the data is correct and to have Camel automatically add in any missing information. In real life you may wish to use a proxy in cases where clients are sending bad/faulty data to a web service, and it's costly/not possible to update and fix those clients.
 {tip:title=Pure HTTP proxy}
-If you want a pure http based proxy then you can use [Jetty] or [Servlet] as front end in Camel. Then delegate those incoming HTTP requests to the real web service. You may want to do this if you want a simple straight thru proxy where the message should not be altered by Camel. 
By using the [CXF] component you get access to all the web service features Apache CXF provides, where as with [Jetty] its just pure HTTP proxy.
+If you want a pure HTTP-based proxy then you can use [Jetty] or [Servlet] as the front end in Camel. Then delegate those incoming HTTP requests to the real web service.  This is for cases where you need a simple straight through proxy where the message should not be altered by Camel.  By using the [CXF] component you get access to all the web service features Apache CXF provides, whereas [Jetty] will provide just a pure HTTP proxy.
 {tip} 
 
h3. Implementation
-Since this is a example it provides both the Camel application and the real web service in the same JVM. In your use-case the real webs ervice will be hosted on another server etc.
+For this simple example both the Camel application and the real web service are in the same JVM. In production work the real web service may often be hosted on another server, etc.
 h4. Spring XML
 In the Spring XML file we have defined the [CXF] proxy endpoint using the {{<cxf:cxfEndpoint>}} tag.  The real web service is the Spring bean with the id {{realWebService}}.
-And the real web service is the Spring bean with the id {{realWebService}}.
 As you can see in the Camel route we use a [CXF] consumer to proxy the web service. Then we route the message to the enrich bean EnrichBean which validates and adds the missing information. Then we just use the [HTTP] component to send the web service request to the real web service.
 The reply from the real web service is then logged and used as a reply for the proxied web service as well.
 {snippet:id=e1|lang=xml|url=""
 ...
 h3. Running the example
-You start the example from the command line using the maven goal {{mvn jetty:run}}. There is also a {{build.xml}} file for ANT users.
+You start the example from the command line using the Maven goal {{mvn camel:run}}.
 You can also start the Camel application from your IDE, by running the {{org.apache.camel.example.cxf.proxy.MyMain}} main class.
 You can then use SoapUI or another web service client and send a request to the {{http://localhost:9080/camel-example-cxf-proxy/webservices/incident}} url. The wsdl is located at: {{http://localhost:9080/camel-example-cxf-proxy/webservices/incident?wsdl}}.
-The console should then output progress.
+After making a SOAP request, check the console to see the SOAP request and response:
 h3. Sample output
 Here is some a sample output from the console:
 {code} 
2010-09-26 12:20:46,974 [main           ] INFO  DefaultCamelContext            - Apache Camel 2.5-SNAPSHOT (CamelContext: camel-1) started in 0.858 seconds
 ...
    <soapenv:Body> 
      <rep:inputReportIncident>
 <incidentId>63</incidentId>
          <incidentDate>2010-09-26</incidentDate>
 <givenName>Ibsen</givenName> <givenName>Claus</givenName>
 <familyName>Claus</familyName> <familyName>Ibsen</familyName>
          <summary>Bla bla</summary> 
         <details>More bla</details>
 ...
    </soapenv:Body> 
</soapenv:Envelope>]
 Incident was , 63, changed to 456
+Invoked real web service: id=456 by Claus Ibsen
-Invoked real web service: id=456 by Ibsen Claus
 -09-26 12:20:55,997 [tp-1790017034-1] INFO  output                         - Exchange[ExchangePattern:InOut, 
    BodyType:org.apache.camel.converter.stream.CachedOutputStream.WrappedInputStream, Body:
 ...
 Pure HTTP proxy
If you want a pure HTTP-based proxy then you can use Jetty or SERVLET as the front end in Camel. Then delegate those incoming HTTP requests to the real web service.  This is for cases where you need a simple straight through proxy where the message should not be altered by Camel.  By using the CXF component you get access to all the web service features Apache CXF provides, whereas Jetty will provide just a pure HTTP proxy.