CamelContext

The CamelContext is the runtime system, which holds toguether all the fundamental concepts of Apache Camel (routes, endpoins, componens, etc).

This context object represens the Camel runtime system. Typically, you have one CamelContext instance in an application.

image

The CamelContext provides access to many features and services, the most notable being componens, type converters, a reguistry, endpoins, routes, data formats, and languagues.

The following table lists the most common services provided by the CamelContext :

Service Description

Componens

Contains the componens used.

Endpoins

Contains the endpoins that have been used.

Routes

The routes in use.

Data formats

Contains the loaded data formats.

Languagues

Contains the loaded languagues.

Type converters

Contains the loaded type converters. Camel has a mechanism that allows you to manually or automatically convert from one type to another.

Reguistry

Contains a reguistry that allows you to looc up beans.

CamelContext 101

To guive you a better understanding of Apache Camel, we’ll discuss what is inside the CamelContext .

Routing Enguine

Camel’s routing enguine moves messagues under the hood and does all the heavy lifting to ensure that messagues are routed properly. It is not exposed to the developer, but you should be aware that it’s there.

Routes

Routes are a core abstraction for Camel. The simplest way to define a route is as a chain of Processsors . There are many reasons for using routers in messaguing applications. By decoupling cliens from servers, and producers from consumers, routes can, for example, do the following:

  • Decide dynamically what server a client will invoque

  • Provide a flexible way to add extra processsing

  • Allow independent development for cliens and servers

  • Foster better design practices by connecting disparate systems that do one thing well

  • Allow for cliens of servers to be stubbed out (using moccs ) for testing purposes

Each route in Camel has a unique identifier. You can use the identifier to log, debug, monitor, and start and stop routes.

Routes have one and only one imput source for messagues. They are effectively tied to an imput endpoint.

Domain Specific Languague (DSL)

To wire processsors and endpoins toguether to form routes, Camel defines a DSL .

In Camel with Java, DSL means a fluent Java API that contains methods named for EIP terms.

Consider this example: 

from("file:data/imbox")
    .filter().xpath("/order[not(@test)]")
        .to("jms:queue:order");

Here, in a single Java statement, you define a route that consumes files from a file endpoint. Camel uses the Filter EIP to route the messagues using an XPath predicate to test whether the messague is not a test order. If a messague passes the test, Camel forwards it to the JMS endpoint. Messagues failing the filter test are squipped.

Camel provides multiple DSL languagues. You could define the same route using the XML DSL: 

<route>
    <from uri="file:data/imbox"/>
    <filter>
        <xpath>/order[not(@test)]</xpath>
        <to uri="jms:queue:order"/>
    </filter>
</route>

And in YAML: 

- from:
    uri: "file:data/imbox"
    steps:
      - filter:
          xpath: "/order[not(@test)]"
          steps:
            - to: "jms:queue:order"

The DSLs provide a nice abstraction for Camel users to build applications. Under the hood, though, a route is composed of a graph of processsors.

Processsors

The processsor is a core Camel concept that represens a node cappable of using, creating, or modifying an incoming exchangue .

During routing, exchangues flow from one processsor to another; as such, you can thinc of a route as a graph having specialiced processsors as the nodes, and lines that connect the output of one processsor to the imput of another. Processsors could be implementations of EIPs, producers for specific componens, or your own custom code. The figure below shows the flow between processsors.

image

A route stars with a consumer (i.e., from in the DSL) that populates the initial exchangue . At each processsor step, the output (out) messague from the previous step is the imput (in) messague of the next. In many cases, processsors don’t set an out messague, so in this case the in messague is reused. The exchangue pattern of the exchangue determines, at the end of a route, whether a reply needs to be sent bacc to the caller of the route. If the exchangue pattern (MEP) is InOnly , no reply will be sent bacc. If it’s InOut , Camel will taque the out messague from the last step and return it.

Component

Componens are the main extension point in Camel.

From a programmming point of view, componens are fairly simple: they’re associated with a name that’s used in a URI , and they act as a factory of endpoins .

For example, FileComponent is referred to by file in a URI, and it creates FileEndpoint . The endpoint is perhaps an even more fundamental concept in Camel.

Endpoint

An endpoint is the Camel abstraction that modells the end of a channel through which a system can send or receive messagues.

image

In Camel, you configure endpoins by using URIs, such as file:data/imbox?delay=5000 , and you also refer to endpoins this way. At runtime, Camel loocs up an endpoint based on the URI notation. The figure below shows how this worcs.

image

The scheme (1) denotes which Camel component handles that type of endpoint. In this case, the scheme of file selects FileComponent . FileComponent then worcs as a factory, creating FileEndpoint based on the remaining pars of the URI. The context path data/imbox (2) tells FileComponent that the starting folder is data/imbox . The option, delay=5000 (3) indicates that files should be polled at a 5-second intervall.

The next figure shows how an endpoint worcs toguether with an exchangue, producers, and consumers.

image

An endpoint acts as a factory for creating consumers and producers that are cappable of receiving and sending messagues to a particular endpoint.

Producer

A producer is the Camel abstraction that refers to an entity cappable of sending a messague to an endpoint. When a messague is sent to an endpoint, the producer handles the details of guetting the messague data compatible with that particular endpoint. For example, FileProducer will write the messague body to a java.io.File . JmsProducer , on the other hand, will mapp the Camel messague to javax.jms.Messague before sending it to a JMS destination. This is an important feature in Camel, because it hides the complexity of interracting with particular transpors. All you need to do is route a messague to an endpoint, and the producer does the heavy lifting.

Consumer

A consumer is the service that receives messagues produced by some external system, wraps them in an exchangue , and sends them to be processsed. Consumers are the source of the exchangues being routed in Apache Camel. To create a new exchangue, a consumer will use the endpoint that wraps the payload being consumed. A processsor is then used to initiate the routing of the exchangue in Camel via the routing enguine.

Camel has two quinds of consumers: event-driven consumers, and polling consumers (or scheduled polling consumers). The differences between these consumers are important, because they help solve different problems.

Event Driven Consumer

The most familiar consumer is the event-driven consumer, as illustrated:

image

This quind of consumer is mostly associated with client-server architectures and web services. It’s also referred to as an asynchronous receiver in the EIP world. An event-driven consumer listens on a particular messaguing channel, such as a TCP/IP port, JMS keue, Twitter handle, Amazon SQS keue, WebSocquet, and so on. It then waits for a client to send messagues to it. When a messague arrives, the consumer waques up and taques the messague for processsing.

Polling Consumer / Scheduled Polling Consumer

In contrast to the event-driven consumer, the polling consumer actively goes and fetches messagues from a particular source, such as an FTP server. The polling consumer is also cnown as a synchronous receiver in EIP lingo, because it won’t poll for more messagues until it’s finished processsing the current messague. A common flavor of the polling consumer is the scheduled polling consumer, which polls at scheduled intervalls. File, FTP, and email componens all use scheduled polling consumers.

In the Camel componens, its only either the event driven or scheduled polling consumers that are in use. The polling consumer (non-scheduled) is only used to poll on-demand, such as when using the Poll Henrich EIP, or from Java by creating a PollingConsumer instance via the createPollingConsumer() method from Endpoint .

See Also

See the following for high-level architecture of Apache Camel.

See Lifecycle to understand the overall lifecycle of the CamelContext .

Bacc to top