Camel-设计可扩展的动态数据流

Question

Use case: I receive a message from a source endpoint. Depending on the type of message, it gets handled by completely different business logic (eg http request, tcp message, db call). Afterwards, the outcome and passed downstream (assume uniform standard for output message)

The route would look something like this:

from(_source_)
...
// handle data (this is dynamic)
...
process(_logger_)
to(_receiver_)

A straight forward solution would be use choice():

... // Upstream
.choice()
.when(someCondition).process(sendHTTP)
.when(anotherCondition).process(getToken).process(sendTCP)
.otherwise().process(sendToDB)
... // Downstream

But that's not very scalable.

Another solution would be to just put everything in a single processor which in turn calls a client that has polymorphic behaviour:

... // Upstream
.process(messageSwitch)
... // Downstream

public class MessageSwitch implements Processor {

    public void process(Exchange ex) {
         RequestClient client = this.resolveClient(ex);
         client.sendRequest(ex.getIn());
     }
}

However, this also makes us lose sight of the route. In that case, my question is whether or not it is common practice to execute a new route that takes place inside a processor. For example, I may want to execute a http call through the http4 library ( http://camel.apache.org/http4.html ).

Or maybe I am approaching this problem incorrectly.

Answer 1

One way you could approach this is to have a processor set a header on the received message with a destination route for each type then use the camel recipient list to send the message to those destination routes.

from(_source_)
.process(_processorcodebelow_)
.recipientList(simple("direct:${header.MessageRouterByType}"));

Processor would look something like:

public void doProcees(Message message){
Message message = exchange.getIn();
... //logic to check type 
message.setHeader("MessageRouterByType", "messagetype1");
...//etc for different types

Then you can have different routes to perform your business logic for each of the different message types.

from("direct:messagetype1").routeId("messagetype1")
.process(_messagetype1processor_)
.to(_receiver_)

You can use the route id or logging to keep track of which route the message took.