Messages transport the data between the different parts of the mediation logic. Your mediation logic will define the flow of messages between different nodes.

A message flows in one direction, from a sender to a receiver. It's not possible to use the same message to answer the sender, we will have to use another message. A message is described in the org.apache.camel.Message interface.

The javadoc is available at http://camel.apache.org/maven/camel-2.13.0/camel-core/apidocs/org/apache/camel/Message.html.

A message contains the following:

Camel doesn't transport a message directly. The main reason is that a message flows only in one direction. When dealing with messaging, there are many Message Exchange Patterns (MEP) that we can use.

Depending on the use cases, we can send a message without expecting any return from the destination: this pattern is named event message and uses InOnlyMEP. For instance, when you read a file from the filesystem, you just process the file content, without returning anything to the endpoint that read the file. In that case, the component responsible for reading the filesystem will define an InOnlyMEP.

On the other hand, you may want to implement a request reply pattern: a response message should be returned to the sender of the request message, and so it uses an InOutMEP. For instance, you receive a SOAP Request from a WebService component, so you should return a SOAP Response (or SOAP Fault) to the message sender.

In Camel, MEP are described in the org.apache.camel.ExchangePattern enumeration...

The Camel context is the runtime system and the loading container of all resources required for the execution of the routing. It keeps everything together to allow the user to execute the routing logic. When the context starts, it also starts various components and endpoints, and activates the routing rules.

The Camel context is described by the org.apache.camel.CamelContext interface (http://camel.apache.org/maven/current/camel-core/apidocs/org/apache/camel/CamelContext.html).

A Camel context contains the following:

A processor is a node in the routing which is able to use, create, or modify an incoming exchange. During routing, the exchanges flow from one processor to another. This means all Enterprise Integration Patterns (EIP) are implemented using processors in Camel. The exchanges get in and out of a processor by using components and endpoints, as we will see later in this chapter.

A processor is described using the org.apache.camel.Processor interface. To create your own processor, you just have to implement the Processor interface and override the process() method:

public class MyProcessor implements Processor {

  public void process(Exchange exchange) {
System.out.println("Hello...

The Camel route is the routing definition. It's a graph of processors. The routes (routing definition) are loaded in the Camel context. The execution and flow of the exchange in a route is performed by the routing engine. The routes are used to decouple clients from servers, and producers from consumers: an exchange consumer doesn't know where the exchange comes from, and on the other hand an exchange producer doesn't know the destination of the exchange. Thanks to that, it provides a flexible way to add extra processing or change the routing with limited impact on the logic.

Each route has a unique identifier that you can specify (or Camel will create one for you). This identifier is used to easily find the route, especially when you want to log, debug, monitor, or manage a route (start or stop).

A route has exactly one input source (the input endpoint). A route has a life cycle similar to the Camel context with the same states: started, stopped, and suspended. To Camel, a context...

In every Camel route, there is a channel that sits between each processor in the route graph. It's responsible for the routing of an Exchange to the next Processor in the graph. The channel acts as a controller that monitors and controls the routing at runtime. It allows Camel to enrich the route with interceptors. For instance, the Camel tracer or the error handling are functionalities implemented using an interceptor on the channel.

The channel is described by the org.apache.camel.Channel interface. You can configure your own interceptor on the channels by describing it in Camel context.

Camel supports three kinds of interceptors on the channels: