Course Overview
Master Enterprise Integration with Apache Camel and Spring Boot. Learn to build, test, and deploy robust integration solutions using Camel’s EIPs, Spring Boot, and advanced features like Kamelets, dynamic routing, REST services, and messaging middleware. Perfect for developers aiming to simplify microservices and enterprise integrations.
Who should attend
Java developers building integrations between systems, and teams replacing an ageing ESB or hand-rolled integration code with something maintainable. Also for Spring Boot teams who keep writing the same plumbing (retries, routing, transformation, dead-letter handling) by hand and want a proper framework for it.
What you'll learn
- Understand Enterprise Integration Patterns and the problems they solve
- Understand Camel's core model of Contexts, Routes, Components, Endpoints and Exchanges
- Build routes with the Java DSL, and read the XML and YAML variants
- Run and prototype integrations quickly with Camel JBang
- Develop and deploy Camel applications as Spring Boot microservices
- Apply content-based routing, filtering, splitting, aggregation and routing slips
- Transform data between formats and integrate with JMS and Kafka messaging middleware
- Expose integrations as REST services with the Camel REST DSL
- Handle errors with retries, dead-letter channels and Spring transactions
- Test routes with mocks, templates and integration tests
Course Prerequisites
Students should be familiar with Java and Spring Boot
Outline
Learning Objectives
Introduction
- Discuss EAI (Enterprise Application Integration)
- Role of EIP (Enterprise Integration Patterns)
- List and discuss key patterns (real-world examples of each pattern)
Introduction to Camel
- Camel as a EAI and EIP platform
- Camel history from ESB to MSA
- Introduce of Camel terms (Components, DSL, Routes, Endpoints, Data Formats, …)
- Understand the Camel Context
- Discuss the various Embedded DSL options (Java, XML, …)
- Explore Camel Architecture and Core Concepts
- Develop a good understanding of Exchange & Message
- Using Camel JBang
- Overview of platforms: Camel Quarkus, kubernetes CamelK and OSGI Karaf
Camel Spring Boot
- Understand the integration with *Spring Boot
- Explore the Spring Boot starter for Camel
- Configure routes using properties/application.yml
- Leveraging Spring's Dependency Injection (DI) in Routes
- Develop and deploy Camel applications as Spring Boot microservices
- Utilize Spring Boot Actuator for monitoring routes
- Integrate with Spring Transactions
Testing with Camel and Spring Boot
- Discuss building tests with Camel
- Use Templates to produce/consume messages
- Mocking components
- Using Interceptors
- Building Integration Tests
- Best practices for Test Automation in Camel
Develop Camel Routes
- Understand the relation between Components and Endpoints
- Defining the context programmatically or Using Spring
- Explanation of the eDSL syntax (XML and Java)
- Use of the YAML DSL
- Discuss the various Message Exchange Patterns (MEP)
- The use of Endpoint URIs
- Transforming Data
- Implementing and using dynamic routing, content-based routing and filtering
- Deep dive into additional patterns (Aggregator, Splitter, and Routing Slip, …)
- Implementing REST services
- Integrating with Messaging Middleware (JMS, Kafka, etc.)
- Throughout and Parallel Processing
- Error Handling and Fault Tolerance
- Implementing retry mechanisms and dead-letter channels
Kamelets Overview
- Introduction to Kamelets
- Understand the role of Kamelets in Camel integrations
- Explore the Kamelet Catalog
- Understand the concepts of Source, Sink, and Action
- parameterized Kamelets for dynamic routing
Frequently asked questions
What are the prerequisites?
Working Java and Spring Boot. Familiarity with Maven or Gradle helps, as does basic Linux, but neither is required. No Camel knowledge is assumed. If Spring Boot itself is new, take SPRING-CORE first.
Do I need to know Enterprise Integration Patterns already?
No. The course opens with EAI and the integration patterns themselves, using real-world examples, before introducing Camel as an implementation of them. Understanding the patterns is what makes Camel's design read as obvious rather than arbitrary.
Which Camel runtime does the course use?
Spring Boot, through the Camel Spring Boot starter, which is where most teams run Camel. The course also puts the alternatives in context, including Camel Quarkus and Camel K on Kubernetes, so you can tell whether Spring Boot remains the right host for your workload.
How hands-on is the course?
Very. Eight lab sessions carry the two days, from your first route through bean support, testing, Spring Boot integration, pipelines, transactions and finally exposing a REST service.
Do I need to install anything on my laptop?
No. Every student gets their own pre-configured cloud machine with the JDK, build tooling and a cluster already in place, so all you need locally is an SSH client (already present on Linux, macOS and Windows). Work in the editors installed on the machine (vim, LazyVim, Emacs) or connect your own with IntelliJ's SSH remote development or VS Code Remote Development. Login details are emailed a week before the course.
How long is the Building Integrations using Apache Camel and Spring Boot course?
2 days, on-site or online. Sessions can run on consecutive days or be spread out to fit your team's schedule.
How large are the groups?
Deliberately small so the trainer can adapt to every participant: at most 10 on-site and 7 online.
In which languages can the course be delivered?
English, French or Dutch.
