Sometimes it is convenient to share routing logic between integrations hosted in the same container, for example, as web apps or OSGi bundles. Camel provides two components that allow you to do this, synchronously through a Direct VM Component, or asynchronously through a VM Component.
This recipe will show you how a Camel route can call another route running in a different Camel context.
In order for messages to be passed between routes using the vm: or direct-vm: transports, the exact same instance of the camel-core library must be available within the classloader hierarchy of both applications.
In an application server such as Apache Tomcat, this means placing the camel-core.jar file in the /ext directory of the server. Applications deployed onto the server should not contain camel-core within their WAR files.
When using an OSGi container such as Apache Karaf or Apache ServiceMix, it is simply a case of ensuring that the camel-core bundle is installed and running.
No additional work is necessary to use these transports if you intend to communicate between Camel contexts in the same application.
The Java code for this recipe is located in the org.camelcookbook.structuringroutes.vm package. The Spring XML files are located under src/main/resources/META-INF/spring and prefixed with vm.
Create a route to be shared consuming (from) with the vm: endpoint, and reference it from other routes using the same endpoint name.
Split out the integration logic that you want to share into a route and select a VM Component to consume from that best suits your threading requirements. If your route should handle requests using the same thread as the caller, choose
direct-vm:, otherwise if you want the exchange to be processed asynchronously by a different thread, choosevm:. Give the endpoint a name that will be unique across the JVM.In the XML DSL, this is written as follows:
<route> <from uri="vm:logMessageToBackendSystem"/> <to uri="..."/> </route>In the Java DSL, you express the same thing as:
from("vm:logMessageToBackendSystem").to(...);Invoke the shared route from within the top-level route that needs to make use of this logic by using the same URI prefix.
In the XML DSL, write the following:
<route> <from uri="..."/> <to uri="vm:logMessageToBackendSystem"/> </route>In the Java DSL, this is written as:
from(...).to("vm:logMessageToBackendSystem");
The VM Component is equivalent in functionality to SEDA, but works across applications within the same JVM. All of the same configuration options for a seda: endpoint also apply to the vm: endpoint. As in seda: endpoints, care should be taken that the endpoint name used in the top-level route matches that of the shared route. Otherwise, the exchange is placed onto a named in-memory queue that will never be consumed from.
Aside from working across applications, direct-vm: is functionally equivalent to direct:. The endpoint uses the same thread between the two applications, meaning that it can participate in the same transactions. This should be tested thoroughly to ensure that applications have been correctly configured. For this to work, both applications should make use of the same transactional resources (for example, JDBC DataSource or JMS ConnectionFactory) with the same transaction manager.
Note
When using direct-vm: you should pay particular attention to the order in which the applications or contexts are started up. You can use the block=true option on direct-vm: so that it will block until there is an active consumer associated with it. If the top-level route starts sending messages to the shared route before it is available, an exception similar to the following will be thrown by the Camel runtime:
org.apache.camel.CamelExchangeException : No consumers available on endpoint: Endpoint[direct-vm://someMissingEndpoint]
VM Component: http://camel.apache.org/vm.html
Direct-VM Component: http://camel.apache.org/direct-vm.html