Apache Camel Course

Lesson 1 • Core Camel Concepts and Terminology

Defines exchanges, messages, headers, and bodies as Camel's data model. Precise terminology prevents confusion in later routing and transformation chapters.

Lesson 2 • Apache Camel Architecture Overview

Explains Camel's core architectural components: CamelContext, routes, endpoints, and processors. Provides a mental model used throughout the entire course.

Lesson 3 • Setting Up the Development Environment

Guides installation of Java, Maven, and an IDE configured for Camel development. Ensures every student has a runnable environment before writing code.

Lesson 1 • Processors and Simple Transformations

Teaches inline message manipulation using Processor, setBody, and setHeader DSL methods. Connects data-model knowledge to practical route logic.

Lesson 2 • Working with Common Components

Demonstrates File, Timer, and Log components as practical starting points. Shows how component URIs configure behavior without custom code.

Lesson 3 • Error Handling in Routes

Covers onException, errorHandler, and dead-letter channels for fault tolerance. Reliable error handling is essential before moving to complex routing patterns.

Lesson 4 • Route Builder Basics

Introduces the RouteBuilder class and the from-to pattern for defining routes. Establishes the syntax foundation for all subsequent DSL-based examples.

Lesson 1 • Message Routing Patterns

Covers Content-Based Router, Message Filter, and Dynamic Router patterns. These patterns direct messages to the correct destination based on content or context.

Lesson 2 • Message Transformation Patterns

Teaches Message Translator, Envelope Wrapper, and Content Enricher patterns. Transforms messages to match the format expected by downstream systems.

Lesson 3 • Splitter and Aggregator Patterns

Demonstrates splitting a single message into parts and aggregating multiple messages into one. Handles batch and collection-based integration scenarios.

Lesson 4 • Idempotent Consumer and Message Deduplication

Prevents duplicate message processing using idempotent consumer repositories. Critical for at-least-once delivery environments.

Lesson 1 • XML Processing with JAXB and XStream

Binds Java objects to XML using JAXB annotations and XStream configuration. XML remains the dominant format in many enterprise integration scenarios.

Lesson 2 • XSLT and Message Mapping

Applies XSLT stylesheets within Camel routes for declarative XML-to-XML transformation. Separates transformation logic from routing logic for maintainability.

Lesson 3 • Marshaling and Unmarshaling Concepts

Explains the marshal/unmarshal DSL and how data formats plug into the pipeline. Establishes the pattern applied consistently across all format-specific sections.

Lesson 4 • JSON Processing with Jackson

Serializes and deserializes JSON using the Jackson data format in Camel routes. JSON is the primary format for REST and event-driven integrations.

Lesson 1 • JMS Integration with ActiveMQ

Configures the Camel JMS component to consume and produce messages on queues and topics. JMS is the baseline messaging API for most enterprise brokers.

Lesson 2 • Messaging Reliability and Transactions

Implements transactional routes to guarantee exactly-once or at-least-once delivery. Covers local and distributed transaction strategies.

Lesson 3 • Apache Kafka Integration

Uses the Camel Kafka component to publish and subscribe to Kafka topics. Covers offset management and consumer group configuration for reliable streaming.

Lesson 1 • REST Security and Authentication

Applies API key, Basic Auth, and OAuth2 token-based security to Camel REST endpoints. Ensures exposed APIs meet enterprise security requirements.

Lesson 2 • Consuming External REST APIs

Uses the HTTP and HTTP4 components to call external REST services from within routes. Handles authentication, headers, and response parsing.

Lesson 3 • Camel REST DSL Fundamentals

Defines REST endpoints declaratively using the REST DSL and binds them to routes. Separates API contract definition from processing logic.

Lesson 4 • OpenAPI Integration and Documentation

Generates and consumes OpenAPI specifications from Camel REST DSL definitions. Enables contract-first development and automated client generation.

Lesson 1 • Packaging and Deploying Camel Microservices

Builds executable JAR files and Docker images for Camel Spring Boot applications. Prepares routes for container-based deployment pipelines.

Lesson 2 • Dependency Injection in Camel Routes

Injects Spring beans into routes and processors using @Autowired and @BeanInject. Enables reuse of existing Spring services within Camel logic.

Lesson 3 • Configuration and Profiles

Manages environment-specific Camel settings using Spring profiles and externalized configuration. Supports dev, test, and production deployment scenarios.

Lesson 1 • Distributed Tracing with OpenTelemetry

Instruments Camel routes with OpenTelemetry spans for end-to-end trace correlation. Enables root-cause analysis across multi-service integration flows.

Lesson 2 • Camel JMX and Management API

Exposes route statistics and control operations via JMX and the Camel Management API. Enables runtime inspection without redeployment.

Lesson 3 • Metrics with Micrometer and Prometheus

Integrates Micrometer to export Camel route metrics to Prometheus for dashboarding. Provides quantitative visibility into throughput and error rates.

Lesson 4 • Performance Tuning and Thread Pools

Configures thread pools, parallelism, and backpressure to maximize route throughput. Addresses common bottlenecks in high-volume integration scenarios.