Chapters

The whole tutorial, in order.

Every part, chapter, and appendix, linked. Read it top to bottom the first time through; each pattern chapter also stands on its own. New here? Start with the Outline.

Part 0 Getting Started

Prerequisites, local stack setup, and the shipping domain that drives every example.

  1. 0 Prerequisites & Setup Install Java 25, JBang, the Camel CLI, Maven, Docker Engine, and the tools you need to run every example locally.
  2. 1 The Running Example The shipping domain: orders, inventory, payments, shipments, and notifications that drive every pattern example.

Part 1 Integration Styles

The four fundamental ways applications can share data: file transfer, shared database, remote procedure invocation, and messaging.

  1. 2 Integration Styles The four fundamental ways applications share data: file transfer, shared database, remote procedure invocation, and messaging.

Part 2 Messaging Systems

The six building blocks of any messaging architecture: channels, messages, pipes and filters, routers, translators, and endpoints.

  1. 3 Messaging Systems Overview The six building blocks of any messaging architecture: channels, messages, pipes and filters, routers, translators, and endpoints.

Part 3 Messaging Channels

How messages travel between applications: point-to-point, publish-subscribe, dead letter channels, guaranteed delivery, and bridging.

  1. 4 Channel Types Point-to-point, publish-subscribe, and datatype channels: the three fundamental channel patterns that determine how messages are delivered.
  2. 5 Channel Reliability Handling failure gracefully: invalid message channels, dead letter channels, and guaranteed delivery.
  3. 6 Channel Infrastructure Connecting disparate systems: channel adapters, messaging bridges, and the message bus.

Part 4 Message Construction

What goes inside a message: command, document, and event messages, request-reply, correlation, sequencing, and expiration.

  1. 7 Message Types Command, document, and event messages: the three semantic types that determine what a message means and how the receiver should handle it.
  2. 8 Message Metadata Request-reply, correlation identifiers, return addresses, message sequences, expiration, and format indicators: the metadata that makes asynchronous conversations possible.

Part 5 Message Routing

Directing messages to the right destination: content-based routing, splitting, aggregating, scatter-gather, and process management.

  1. 9 Routing Fundamentals Content-Based Router, Message Filter, Recipient List, and Splitter: the four patterns that determine where a message goes based on its content.
  2. 10 Composed Routing Routing Slip, Process Manager, and Scatter-Gather: multi-step routing patterns that compose the fundamentals into dynamic, adaptive workflows.
  3. 11 Advanced Routing Dynamic Router, Wire Tap, Resequencer, Composed Message Processor, and Load Balancer: patterns for runtime-adaptive, observable, and resilient routing.

Part 6 Message Transformation

Reshaping message content: translation, enrichment, filtering, claim check, normalization, and canonical data models.

  1. 12 Transformation Fundamentals Message Translator, Envelope Wrapper, Content Enricher, and Content Filter: patterns that change what's inside a message.
  2. 13 Structural Transformation Aggregator, Normalizer, and Canonical Data Model: patterns that reshape, unify, and standardize messages across system boundaries.

Part 7 Messaging Endpoints

How applications connect to the messaging system: gateways, consumers, dispatchers, idempotent receivers, and service activators.

  1. 14 Consumer Patterns Polling Consumer, Event-Driven Consumer, Competing Consumers, and Message Dispatcher: patterns that determine how application code receives messages.
  2. 15 Producer and Transactional Patterns Durable Subscriber, Idempotent Receiver, Transactional Client, and Service Activator: patterns for reliable message production and exactly-once processing.
  3. 16 Endpoint Management Messaging Gateway, Selective Consumer, Channel Purger, and Messaging Mapper: patterns for managing the boundary between application code and the messaging system.

Part 8 System Management

Operating and monitoring a messaging system: control bus, wire tap, message history, message store, and testing patterns.

  1. 17 Observability Control Bus, Message Store, Message History, and Wire Tap (for monitoring): patterns that make a running integration system observable.
  2. 18 Testing and Management Test Message, Detour, Smart Proxy, and Channel Adapter management: patterns that keep a running integration system testable and manageable.

Part 9 Deep-Dive Appendices

Technology deep dives, case studies, and reference material: Kafka deep dive, Pulsar, Redis, Quarkus Flow, Drools, observability, Kubernetes deployment, OpenShift Local (CRC), Camel CLI, Camel TUI, Citrus testing, AI and MCP, consumer/producer tuning, share groups, diagnostics, Kafka Connect offsets, testing strategies, virtual threads, and the Loan Broker and Bond Trading case studies.

  1. 19 Appendix A: Camel on Spring Boot vs Quarkus Java DSL with Spring Boot (Camel Spring Boot) vs Quarkus (Camel Quarkus): DI models, configuration, testing, deployment, and the Spring XML DSL.
  2. 20 Appendix B: Kafka Deep Dive Topics, partitions, consumer groups, exactly-once semantics, and Kafka operational patterns for integration architects.
  3. 21 Appendix C: Pulsar Deep Dive Topics, subscriptions, schema registry, per-message TTL, and Pulsar's unique capabilities for integration patterns.
  4. 22 Appendix D: Redis for Integration Redis as a caching layer, idempotent store, pub/sub channel, and distributed lock for integration patterns.
  5. 23 Appendix E: Quarkus Dev Mode Dev services, continuous testing, live reload, and the JBang-to-Quarkus promotion workflow.
  6. 24 Appendix F: Drools and Business Rules Rule units, decision tables, and integrating Drools 10 with Camel routes for externalized business logic.
  7. 25 Appendix G: Quarkus Flow Serverless workflows and saga orchestration with Quarkus Flow, integrated with Camel routes.
  8. 26 Appendix H: Feature Flags Flagd + OpenFeature with Camel routes: gradual rollouts, A/B testing, and runtime route control.
  9. 27 Appendix I: Observability Stack OpenTelemetry instrumentation, Grafana dashboards, distributed tracing through Camel routes, and the LGTM stack.
  10. 28 Appendix J: The Loan Broker Case Study A complete EIP case study: the classic Loan Broker from Hohpe & Woolf, reimagined with Apache Camel, Kafka, and the shipping domain.
  11. 29 Appendix K: Bond Trading Case Study A second EIP case study: real-time bond pricing, market data distribution, and trade execution with Camel and Kafka.
  12. 30 Appendix L: Glossary Definitions of key terms, patterns, and technologies used throughout this tutorial.
  13. 31 Appendix M: Virtual Threads for Camel Workloads How Java virtual threads work under the hood, and how they transform throughput for I/O-bound Camel routes on Quarkus.
  14. 32 Appendix N: Kafka Consumer Tuning Fetch sizes, poll intervals, offset commits, session timeouts, and static group membership for Camel Kafka consumers.
  15. 33 Appendix O: Kafka Producer Tuning Batching, compression, acknowledgments, idempotence, and retry strategies for Camel Kafka producers.
  16. 34 Appendix P: Kafka Share Groups KIP-932 share groups bring queue semantics to Kafka: per-message acknowledgment, competing consumers without partition coupling, and the KafkaShareConsumer API.
  17. 35 Appendix Q: Kafka Diagnostics Collecting broker logs, consumer group state, topic metadata, JMX metrics, and thread dumps for Kafka troubleshooting.
  18. 36 Appendix R: Managing Kafka Connect Offsets Listing, altering, and resetting connector offsets via the Kafka Connect REST API for reprocessing, migration, and recovery.
  19. 37 Appendix S: Testing Strategies for Camel Quarkus Three-tier testing: unit tests with MockEndpoint and AdviceWith, integration tests with Dev Services and REST Assured, and black-box API tests with Newman.
  20. 38 Appendix T: Deploying Camel to Kubernetes Standard Maven builds, Containerfile images and Kubernetes deployments for Camel applications: Quarkus and Spring Boot on minikube (docker driver, containerd) with Strimzi Kafka and Redis.
  21. 39 Appendix U: Camel CLI Deep Dive A comprehensive guide to the Camel CLI: prototyping routes with camel run, tracing exchanges, debugging, managing infrastructure, and exporting to production runtimes.
  22. 40 Appendix V: Camel TUI The Camel TUI terminal dashboard: monitoring routes, tracing exchanges, inspecting message flow, and debugging integration issues without leaving the terminal.
  23. 41 Appendix W: Citrus Integration Testing End-to-end integration testing with Citrus: testing Camel routes against real Kafka, HTTP, and database infrastructure using the Camel test plugin.
  24. 42 Appendix X: AI and MCP with Camel Integrating AI into Camel routes: the LangChain4j Chat component for classification, ai-tool and LangChain4j Agent for tool calling, the embedded and catalog MCP servers, and Wanaku for exposing Camel routes as AI tools.
  25. 43 Appendix Y: Secure by Default What Camel 4.21 and 4.22 started doing for you (deserialization filters, header boundaries, dynamic URI allow-lists, path containment) and the three places you still have to decide.
  26. 44 Appendix Z: Running on OpenShift Local (CRC) The Appendix T pipeline on OpenShift Local: Kafka from the AMQ Streams operator with pinned, manually approved versions, images built inside the cluster with binary S2I, a Helm chart that runs under restricted-v2 behind edge-TLS Routes, and a teardown that leaves the cluster empty.