Apache Camel Architecture and Concepts

Apache Camel is an open-source integration framework that facilitates connecting systems and exchanging data between them using a route-based model.

In this section, we will introduce some fundamental concepts to understand the logic of integrations.

For a thorough and comprehensive understanding, consult the official Apache Camel documentation. It provides a detailed view of the features, patterns, and best practices.

Architecture

The diagram below provides an overview of the main concepts that make up the Camel architecture.

camel architecture

  • The Camel context acts as the central hub managing the integration of systems.

  • Within the Camel context, the routing engine uses a DSL (Domain-Specific Language) to define and create routes.

  • The routes connect endpoints, which are entry and exit points for external systems, using various components.

  • The components provide connectivity and abstraction for various protocols and technologies, such as files, HTTP, JMS, among others.

  • The messages travel through these routes and are processed by processors, which transform and manipulate the data as needed. They perform functions such as message filtering, EIPs, routing, transformation, mediation, enrichment, validation, and interception.

Concepts

Camel Context

The Camel context is the central core of the Camel application. It is responsible for managing the lifecycle of routes, components, and other resources.

camel context

Domain-Specific Language (DSL)

A DSL is a language designed for a specific domain that enables users to define and configure routes and integrations.

Camel supports DSLs in various languages, such as Java, Groovy, YAML, XML, among others. In Sensedia Integrations, we use the YAML DSL for building routes.

Route

A route defines the path that a message follows within the integration system, showing the processing steps applied to the message as it travels from a source to a destination.

Typically, a route consists of a series of steps connected in a linear sequence, detailing how the message will be handled, routed, or mediated.

Routes are described using a simple and declarative syntax that facilitates readability and understanding.

Below is an example of a Camel route in code format and diagram:

- from:
    id: from-4032
    uri: rest:post:/logs
    steps:
      - log:
          message: {{beforePost}}
      - toD:
          uri: http://{{supermock}}
          parameters:
            bridgeEndpoint: true
            httpMethod: POST
      - log:
          message: "afterPost"

route diagram example

  • The route begins with a REST trigger that receives POST requests at the /logs endpoint.

  • Then, the route logs a message with the value {{beforePost}}.

  • Next, it sends a POST request to the endpoint http://{{supermock}}, with the parameters:

    • bridgeEndpoint: true and

    • httpMethod: POST.

  • Finally, it logs the message "afterPost".

See route examples on the Tutorials and Examples page.

Message

A message is the smallest unit of data that is propagated and modified along a route. It consists of two main components:

  • Header: metadata associated with the message. Headers can include information such as identifiers, data types, or any other relevant information for message processing.

  • Body: can be any Java object. Typically, it is a string, but it can be transformed into more complex objects depending on the integration or the components involved.

message

Exchange

Exchange is an object that encapsulates the message and some metadata during the exchange of information between systems. It also provides utility methods for use in integrations, such as the ability to save and retrieve properties.

Endpoints

Endpoints are components that represent a connection point where data can be sent or received within an integration flow. They define how data is accessed and manipulated in a system.

Endpoints are referenced in the DSL via URIs.

Components

Components are artifacts used when building a route that enable integration and communication between different systems and protocols. They act as connection points between Camel and various technologies or external services you want to integrate into your routes, such as:

  • HTTP: makes a call to an HTTP endpoint;

  • FTP: retrieves or sends files to an FTP server;

  • Quartz: generates events according to a schedule.

For more information about components, refer to:

Enterprise Integration Patterns (EIPs)

EIPs are integration patterns that describe common solutions to frequent problems found in integration and communication systems between applications.

They help structure and optimize communication between applications by providing methods for message routing, data transformation, message aggregation and splitting, message filtering, and error handling. Examples include:

  • Split: divides a message into multiple parts for individual processing.

  • Choice: selects a specific route based on conditions or criteria.

  • On Exception: defines how to handle exceptions and errors during message processing.

As logic components, EIPs can be compared to general tools used in Diagram-type integrations.

For more information about EIPs, refer to:

Expression Languages

An expression language is a way to write instructions in EIPs that help process and manipulate data as it passes through an integration route.

Imagine you are moving data from one place to another and need to do something with that data, such as extracting information, modifying the content, or deciding where to send it. The expression language allows you to write these instructions in a way that Camel can understand and apply during the data flow.

For example, the condition for a Choice can be written using languages such as Groovy, JSONPath, JQ etc.

For more information about expression languages, refer to:

Data Formats

Data formats are artifacts referenced by data transformation EIPs to determine the input or output format of the data. They facilitate the conversion of data between formats such as XML, JSON, CSV, and others.

For more information about data formats, refer to:

  • Before coding, draw your integration flow.

  • Define the necessary steps for execution according to business rules.

  • Map these steps to the required components and/or EIPs.

  • Only then, start coding!
Thanks for your feedback!
EDIT

Share your suggestions with us!
Click here and then [+ Submit idea]