The Dynamic Router pattern, as shown in Figure 7.13, enables you to route a message consecutively through a series of processing steps, where the sequence of steps is not known at design time. The list of endpoints through which the message should pass is calculated dynamically at run time. Each time the message returns from an endpoint, the dynamic router calls back on a bean to discover the next endpoint in the route.
In Camel 2.5 we introduced a
dynamicRouter
in the DSL, which is like a dynamic Routing Slip that evaluates the slip
on-the-fly.
![]() | Beware |
---|---|
You must ensure the expression used for the |
From Camel 2.5, the Dynamic Router
updates the exchange property, Exchange.SLIP_ENDPOINT
, with the current
endpoint as it advances through the slip. This enables you to find out how far the
exchange has progressed through the slip. (It's a slip because the Dynamic Router implementation is based on
Routing Slip).
In Java DSL you can use the dynamicRouter
as follows:
from("direct:start") // use a bean as the dynamic router .dynamicRouter(bean(DynamicRouterTest.class, "slip"));
Which will leverage a Bean in EIP Component Reference to compute the slip on-the-fly, which could be implemented as follows:
// Java /** * Use this method to compute dynamic where we should route next. * * @param body the message body * @return endpoints to go, or <tt>null</tt> to indicate the end */ public String slip(String body) { bodies.add(body); invoked++; if (invoked == 1) { return "mock:a"; } else if (invoked == 2) { return "mock:b,mock:c"; } else if (invoked == 3) { return "direct:foo"; } else if (invoked == 4) { return "mock:result"; } // no more so return null return null; }
![]() | Note |
---|---|
The preceding example is not thread safe. You would have to
store the state on the |
The same example in Spring XML would be:
<bean id="mySlip" class="org.apache.camel.processor.DynamicRouterTest"/> <camelContext xmlns="http://camel.apache.org/schema/spring"> <route> <from uri="direct:start"/> <dynamicRouter> <!-- use a method call on a bean as dynamic router --> <method ref="mySlip" method="slip"/> </dynamicRouter> </route> <route> <from uri="direct:foo"/> <transform><constant>Bye World</constant></transform> <to uri="mock:foo"/> </route> </camelContext>
The dynamicRouter
DSL command supports the following options:
Name | Default Value | Description |
---|---|---|
uriDelimiter
|
,
|
Delimiter used if the Expression returned multiple endpoints. |
ignoreInvalidEndpoints
|
false
|
If an endpoint uri could not be resolved, should it be ignored. Otherwise Camel will thrown an exception stating the endpoint uri is not valid. |
You can also use the @DynamicRouter
annotation. For example:
// Java public class MyDynamicRouter { @Consume(uri = "activemq:foo") @DynamicRouter public String route(@XPath("/customer/id") String customerId, @Header("Location") String location, Document body) { // query a database to find the best match of the endpoint based on the input parameteres // return the next endpoint uri, where to go. Return null to indicate the end. } }
The route
method is invoked repeatedly as the message progresses
through the slip. The idea is to return the endpoint URI of the next destination. Return
null
to indicate the end. You can return multiple endpoints if
you like, just as the Routing Slip, where
each endpoint is separated by a delimiter.