This document provides an introduction to Apache Camel with Spring Boot. It discusses the architecture of Apache Camel including the routing engine, processor, components and Camel context. It explains that Apache Camel is an integration framework that allows defining routing rules and connecting different systems using a common API. The document outlines reasons to use Apache Camel such as routing, extensive components, easy configuration and integration patterns. It also provides an example of how to build routes with Apache Camel and integrate it with Spring Boot.

1. Presented By: Shiv Suraj Oberoi
Introduction to
Apache Camel with
Spring Boot

2. Lack of etiquette and manners is a huge turn off.
KnolX Etiquettes
Punctuality
Respect Knolx session
timings, you are requested
not to join sessions after a
5 minutes threshold post
the session start time.
Feedback
Make sure to submit a
constructive feedback for
all sessions as it is very
helpful for the presenter.
Silent Mode
Keep your mobile devices
in silent mode, feel free to
move out of session in
case you need to attend
an urgent call.
Avoid Disturbance
Avoid unwanted chit chat
during the session.

3. Agenda
01
02
03
04
05
Apache Camel Architecture
Overview of Apache Camel and the problem it
solves?
Building Routes With Apache Camel & Demo
What is Apache Camel & Reasons to Use
Apache Camel
Apache Camel Integration with Spring Boot

4. What is Apache Camel ?
● Apache Camel is an “Integration Framework”.
● Apache Camel allows us to define custom routing rules, and it also
allows us to decide from which source we want to accept messages.
● It also helps us to determine how to process those messages and
then send those messages to various destinations
● Camel provides high-level abstractions that allow us to connect with
a variety of systems using the same API, independent of protocol or
data format. This eliminates the need for unnecessary conversions
from one protocol to another.

5. Reasons to use Apache Camel
● Routing and mediation engine
● Extensive component library
● Easy Configuration
● Enterprise integration patterns
● Domain-specific language
● Payload-agnostic router

6. When to use Apache Camel
● Apache Camel with a rich set of components will be useful in applications
requiring integration with systems over different protocols (like files, APIs, or
JMS Queues).
● Apache Camel’s implementation of Enterprise Integration Patterns is useful to
fulfill complex integration requirements with tried and tested solutions for
recurring integration scenarios.
● Apache Camel is a Java framework, so it is especially good at working with
Java objects.

7. When not to use Apache Camel
● If we have simple integration involving calling few APIs
● Camel is not known to perform well for heavy data processing

8. Apache Camel Architecture
● Routing Engine
● Processor
● Components
● Camel Context

9. Apache Camel Architecture

10. Apache Camel Architecture -
Camel Context

11. CamelContext - Code Snippet

12. Overview of the problem that
Apache Camel solves

13. ● Lets analyse Microservice 4. This particular service is interacting with almost 6
microservices and it might be using different transports for each service it is
interacting with.
● We can assume that Microservice 4 might be calling microservice 5 as a rest api,
how ever to communicate with Microservice 6 it might be using a queue.
● Now interacting with services as rest API’s or by using any other methods involves
wide variety of protocols.
● Now the question arise, how can we simplify these enterprise integrations or
how can we simplify the code that will be written which enables
microservice4 to talk to other microservices.
● All this can be taken care by implementing Enterprise Integration Patterns.
● Although understanding and implementing Enterprise Integration Patterns can
turnout to be a big challenge.
● And, This is where Apache Camel steps in. Apache Camel is one of the best
frameworks in this specific space.
● Apache Camel is an open source Enterprise Integration Framework, which allows
us to easily integrate systems who are either consuming or producing data.
● Apache Camel is extremely lightweight and extensible
○ It provides 100+ components for databases, message queues, API’s etc
○ Supports 200+ protocols, data formats
○ Provides a Domain Specific Language (DSL) customized to suit needs of
application integration

14. Integration of Apache Camel with
Spring Boot
● Spring boot supports auto-configuration with Apache Camel using a starter dependency
<dependency>
<groupId>org.apache.camel.springboot</groupId>
<artifactId>camel-spring-boot-starter</artifactId>
<version>3.17.0</version>
</dependency>

15. Building Routes with Apache Camel
I

16. Building Routes with Apache Camel
In Apache Camel, routing done in EMS(enterprise messaging systems) is the process of
taking a message from the input queue to different output queues based on the defined
conditions. The conditions set between the input and output queues are unknown to them.
The message consumer and producer are kept separate from the conditional logic.
Creating Camel Routes in spring boot
● We need to annotate our class which has the camel route definition with the
“@component” annotation.
● To create camel route. You have to extend RouteBuilder and add your route into
method configure().

17. Building Routes with Apache Camel
●

18. DEMO

19. Conclusion
Apache Camel is a lightweight integration tool that doesn’t require a separate
machine to use your integration system, and the language is relatively simple
to learn.
It enables developers to integrate several technologies and communicate
data with various endpoints such as files, queues, and external services
while being simple to use.

20. References
https://camel.apache.org/docs/
https://www.tutorialspoint.com/apache_camel/index.htm
https://www.javacodegeeks.com/2013/08/introduction-to-apache-camel.html