[[cxf-transport-other]]
= CXF Transport Component
:docTitle: CXF Transport
:shortname: cxf-transport
:artifactId: camel-cxf-transport
:description: Camel Transport for Apache CXF
:since: 2.8
:supportLevel: Stable
//Manually maintained attributes
:camel-spring-boot-name: cxf-transport

*Since Camel {since}*

[[CamelTransportforCXF-WhatstheCamelTransportforCXF]]
== What's the Camel Transport for CXF

In CXF you offer or consume a webservice by defining its address. The
first part of the address specifies the protocol to use. For example
address="http://localhost:9000" in an endpoint configuration means your
service will be offered using the http protocol on port 9000 of
localhost. When you integrate Camel Tranport into CXF you get a new
transport "camel". So you can specify
address="camel://direct:MyEndpointName" to bind the CXF service address
to a camel direct endpoint.

Technically speaking Camel transport for CXF is a component which
implements the
https://cxf.apache.org/docs/cxf-architecture.html#CXFArchitecture-Transports[CXF
transport API] with the Camel core library. This allows you to easily
use Camel's routing engine and integration patterns support together
with your CXF services.

[[CamelTransportforCXF-IntegrateCamelintoCXFtransportlayer]]
== Integrate Camel into CXF transport layer

To include the Camel Transport into your CXF bus you use the
CamelTransportFactory. You can do this in Java as well as in Spring.

[[CamelTransportforCXF-SettinguptheCamelTransportinSpring]]
=== Setting up the Camel Transport in Spring

You can use the following snippet in your applicationcontext if you want
to configure anything special. If you only want to activate the camel
transport you do not have to do anything in your application context. As
soon as you include the camel-cxf-transport.jar in your app, cxf will scan the
jar and load a CamelTransportFactory for you.

[source,xml]
--------------------------------------------------------------------------------------------------------
<!-- you don't need to specify the CamelTransportFactory configuration as it is auto load by CXF bus -->
<bean class="org.apache.camel.component.cxf.transport.CamelTransportFactory">
  <property name="bus" ref="cxf" />
  <property name="camelContext" ref="camelContext" />
  <!-- If checkException is true , CamelDestination will check the outMessage's
     exception and set it into camel exchange. You can also override this value 
     in CamelDestination's configuration. The default value is false.
     This option should be set true when you want to leverage the camel's error 
     handler to deal with fault message -->
  <property name="checkException" value="true" />
  <property name="transportIds">
    <list>
      <value>http://cxf.apache.org/transports/camel</value>
    </list>
  </property>
</bean>
--------------------------------------------------------------------------------------------------------

[[CamelTransportforCXF-IntegratingtheCamelTransportinaprogrammaticway]]
=== Integrating the Camel Transport in a programmatic way

Camel transport provides a setContext method that you could use to set
the Camel context into the transport factory. If you want this factory
take effect, you need to register the factory into the CXF bus. Here is
a full example for you.

[source,java]
------------------------------------------------------------------------------------------------------------------
import org.apache.cxf.Bus;
import org.apache.cxf.BusFactory;
import org.apache.cxf.transport.ConduitInitiatorManager;
import org.apache.cxf.transport.DestinationFactoryManager;
...

BusFactory bf = BusFactory.newInstance();
Bus bus = bf.createBus();
CamelTransportFactory camelTransportFactory = new CamelTransportFactory();
// set up the CamelContext which will be use by the CamelTransportFactory
camelTransportFactory.setCamelContext(context)
// if you are using CXF higher then 2.4.x the 
camelTransportFactory.setBus(bus);

// if you are lower CXF, you need to register the ConduitInitiatorManager and DestinationFactoryManager like below
// register the conduit initiator
ConduitInitiatorManager cim = bus.getExtension(ConduitInitiatorManager.class);
cim.registerConduitInitiator(CamelTransportFactory.TRANSPORT_ID, camelTransportFactory);
// register the destination factory
DestinationFactoryManager dfm = bus.getExtension(DestinationFactoryManager.class);
dfm.registerDestinationFactory(CamelTransportFactory.TRANSPORT_ID, camelTransportFactory);
// set or bus as the default bus for cxf
BusFactory.setDefaultBus(bus);
------------------------------------------------------------------------------------------------------------------

[[CamelTransportforCXF-ConfigurethedestinationandconduitwithSpring]]
== Configure the destination and conduit with Spring

[[CamelTransportforCXF-Namespace]]
=== Namespace

The elements used to configure a Camel transport endpoint are defined
in the namespace `\http://cxf.apache.org/transports/camel`. It is
commonly referred to using the prefix `camel`. In order to use the Camel
transport configuration elements, you will need to add the lines shown
below to the beans element of your endpoint's configuration file. In
addition, you will need to add the configuration elements' namespace to
the `xsi:schemaLocation` attribute.

*Adding the Configuration Namespace*

[source,java]
---------------------------------------------------------------------
<beans ...
       xmlns:camel="http://cxf.apache.org/transports/camel
       ...
       xsi:schemaLocation="...
                           http://cxf.apache.org/transports/camel
                           http://cxf.apache.org/transports/camel.xsd
                          ...>
---------------------------------------------------------------------

[[CamelTransportforCXF-Thedestinationelement]]
=== The `destination` element

You configure a Camel transport server endpoint using the
`camel:destination` element and its children. The `camel:destination`
element takes a single attribute, `name`, that specifies the WSDL port
element that corresponds to the endpoint. The value for the `name`
attribute takes the form _portQName_`.camel-destination`. The example
below shows the `camel:destination` element that would be used to add
configuration for an endpoint that was specified by the WSDL fragment
`<port binding="widgetSOAPBinding" name="widgetSOAPPort">` if the
endpoint's target namespace was `\http://widgets.widgetvendor.net`.

*camel:destination Element*

[source,java]
---------------------------------------------------------------------------------------------------------------------------
...
  <camel:destination name="{http://widgets/widgetvendor.net}widgetSOAPPort.http-destination>
    <camelContext id="context" xmlns="http://activemq.apache.org/camel/schema/spring">
         <route>
           <from uri="direct:EndpointC" />
           <to uri="direct:EndpointD" />
         </route>
     </camelContext>
  </camel:destination>

  <camel:destination name="{http://widgets/widgetvendor.net}widgetSOAPPort.camel-destination" camelContextId="context" />  

...
---------------------------------------------------------------------------------------------------------------------------

The `camel:destination` element for Spring has a number of child
elements that specify configuration information. They are described
below.

Element

Description

`camel-spring:camelContext`

You can specify the camel context in the camel destination

`camel:camelContextRef`

The camel context id which you want inject into the camel destination

[[CamelTransportforCXF-Theconduitelement]]
=== The `conduit` element

You configure a Camel transport client using the `camel:conduit` element
and its children. The `camel:conduit` element takes a single attribute,
`name`, that specifies the WSDL port element that corresponds to the
endpoint. The value for the `name` attribute takes the form
_portQName_`.camel-conduit`. For example, the code below shows the
`camel:conduit` element that would be used to add configuration for an
endpoint that was specified by the WSDL fragment
`<port binding="widgetSOAPBinding" name="widgetSOAPPort">` if the
endpoint's target namespace was `\http://widgets.widgetvendor.net`.

*http-conf:conduit Element*

[source,xml]
-------------------------------------------------------------------------------------------------------------------------
...
  <camelContext id="conduit_context" xmlns="http://activemq.apache.org/camel/schema/spring">
       <route>
           <from uri="direct:EndpointA" />
           <to uri="direct:EndpointB" />
       </route>
   </camelContext>

  <camel:conduit name="{http://widgets/widgetvendor.net}widgetSOAPPort.camel-conduit" camelContextId="conduit_context" />
     

  <camel:conduit name="*.camel-conduit">
  <!-- you can also using the wild card to specify the camel-conduit that you want to configure -->
    ...
  </camel:conduit>
...
-------------------------------------------------------------------------------------------------------------------------

The `camel:conduit` element has a number of child elements that specify
configuration information. They are described below.

Element

Description

`camel-spring:camelContext`

You can specify the camel context in the camel conduit

`camel:camelContextRef`

The camel context id which you want inject into the camel conduit

[[CamelTransportforCXF-ConfigurethedestinationandconduitwithBlueprint]]
== Configure the destination and conduit with Blueprint

Camel Transport for CXF supports configuration with Blueprint.

If you are using blueprint, you should use the namespace
`\http://cxf.apache.org/transports/camel/blueprint` and import the schema
like the blow.

*Adding the Configuration Namespace for blueprint*

[source,java]
-----------------------------------------------------------------------------
<beans ...
       xmlns:camel="http://cxf.apache.org/transports/camel/blueprint"
       ...
       xsi:schemaLocation="...
                           http://cxf.apache.org/transports/camel/blueprint 
                           http://cxf.apache.org/schmemas/blueprint/camel.xsd
                          ...>
-----------------------------------------------------------------------------

In blueprint `camel:conduit` `camel:destination` only has one
camelContextId attribute, they doesn't support to specify the camel
context in the camel destination.

[source,java]
------------------------------------------------------------------------
  <camel:conduit id="*.camel-conduit" camelContextId="camel1" />
  <camel:destination id="*.camel-destination" camelContextId="camel1" />
------------------------------------------------------------------------

[[CamelTransportforCXF-ExampleUsingCamelasaloadbalancerforCXF]]
== Example Using Camel as a load balancer for CXF

This example shows how to use the camel load balancing feature in CXF.
You need to load the configuration file in CXF and publish the endpoints
on the address "camel://direct:EndpointA" and "camel://direct:EndpointB"

include::spring-boot:partial$starter.adoc[]
