Camel in Action, Second Edition
Claus Ibsen and Jonathan Anstey
Forewords by James Strachan and Dr. Mark Little
  • February 2018
  • ISBN 9781617292934
  • 912 pages
  • printed in black & white

I highly recommend this book to anyone with even a passing interest in Apache Camel. Do take Camel for a ride...and don't get the hump!

From the Foreword by James Strachan, Creator of Apache Camel

GET MORE WITH MANNING

An eBook copy of the previous edition, Camel in Action (First Edition), is included at no additional cost. It will be automatically added to your Manning Bookshelf within 24 hours of purchase.


Camel in Action, Second Edition is the most complete Camel book on the market. Written by core developers of Camel and the authors of the highly acclaimed first edition, this book distills their experience and practical insights so that you can tackle integration tasks like a pro.

Table of Contents detailed table of contents

Part 1: First Steps

1. Meeting Camel

1.1. Introducing Camel

1.1.1. What is Camel?

1.1.2. Why use Camel?

1.2. Getting started

1.2.1. Getting Camel

1.2.2. Your first Camel ride

1.3. Camel's message model

1.3.1. Message

1.3.2. Exchange

1.4. Camel's architecture

1.4.1. Architecture from 10,000 feet

1.4.2. Camel concepts

1.5. Your first Camel ride, revisited

1.6. Summary

2. Routing with Camel

2.1. Introducing Rider Auto Parts

2.2. Understanding endpoints

2.2.1. Consuming from an FTP endpoint

2.2.2. Sending to a JMS endpoint

2.3. Creating routes in Java

2.3.1. Using the RouteBuilder

2.3.2. The Java DSL

2.4. Defining routes in XML

2.4.1. Bean injection and Spring

2.4.2. The XML DSL

2.4.3. Using Camel and Spring

2.5. Endpoints revisited

2.5.1. Sending to dynamic endpoints

2.5.2. Using property placeholders in endpoint URIs

2.5.3. Using raw values in endpoint URIs

2.5.4. Referencing registry beans in endpoint URIs

2.6. Routing and EIPs

2.6.1. Using a content-based router

2.6.2. Using message filters

2.6.3. Using multicasting

2.6.4. Using recipient lists

2.6.5. Using the wireTap method

2.7. Summary and best practices

Part 2: Core Camel

3. Transforming

3.1. Data transformation overview

3.1.1. Data transformation with Camel

3.2. Transforming data using EIPs and Java

3.2.1. Using the Message Translator EIP

3.2.2. Using the Content Enricher EIP

3.3. Transforming XML

3.3.1. Transforming XML with XSLT

3.3.2. Transforming XML with object marshaling

3.4. Transforming with data formats

3.4.1. Data formats provided with Camel

3.4.2. Using Camel's CSV data format

3.4.3. Using Camel's Bindy data format

3.4.4. Using Camel's JSON data format

3.4.5. Configuring Camel data formats

3.4.6. Writing your own data format

3.5. Transforming with templates

3.5.1. Using Apache Velocity

3.6. About Camel type converters

3.6.1. How the Camel type—converter mechanism works

3.6.2. Using Camel type converters

3.6.3. Writing your own type converter

3.7. Summary and best practices

4. Using beans with Camel

4.1. Using beans the hard way and the easy way

4.1.1. Invoking a bean from pure Java

4.1.2. Invoking a bean defined in XML DSL

4.1.3. Using beans the easy way

4.2. The Service Activator pattern

4.3. Camel's bean registries

4.3.1. JndiRegistry

4.3.2. SimpleRegistry

4.3.3. ApplicationContextRegistry

4.3.4. OsgiServiceRegistry and BlueprintContainerRegistry

4.3.5. CdiBeanRegistry

4.4. Selecting bean methods

4.4.1. How Camel selects bean methods

4.4.2. Camel's method-selection algorithm

4.4.3. Some method-selection examples

4.4.4. Potential method-selection problems

4.4.5. Method selection using type matching

4.5. Bean parameter binding

4.5.1. Binding with multiple parameters

4.5.2. Binding using built-in types

4.5.3. Binding using Camel annotations

4.5.4. Binding using Camel language annotations

4.5.5. Parameter binding using method name with signature

4.6. Using beans as predicates and expressions

4.6.1. Using beans as predicates in routes

4.6.2. Using beans as expressions in routes

4.7. Summary and best practices

5. Enterprise integration patterns

5.1. Introducing enterprise integration patterns

5.1.1. The Aggregator and Splitter EIPs

5.1.2. The Routing Slip and Dynamic Router EIPs

5.1.3. The Load Balancer EIP

5.2. The Aggregator EIP

5.2.1. Introducing the Aggregator EIP

5.2.2. Completion conditions for the Aggregator

5.2.3. Using persistence with the Aggregator

5.2.4. Using recovery with the Aggregator

5.3. The Splitter EIP

5.3.1. Using the Splitter

5.3.2. Using beans for splitting

5.3.3. Splitting big messages

5.3.4. Aggregating split messages

5.3.5. When errors occur during splitting

5.4. The Routing Slip EIP

5.4.1. Using the Routing Slip EIP

5.4.2. Using a bean to compute the routing slip header

5.4.3. Using an Expression as the routing slip

5.4.4. Using @RoutingSlip annotation

5.5. The Dynamic Router EIP

5.5.1. Using the Dynamic Router

5.5.2. Using the @DynamicRouter annotation

5.6. The Load Balancer EIP

5.6.1. Introducing the Load Balancer EIP

5.6.2. Load-balancing strategies

5.6.3. Using the failover load balancer

5.6.4. Using a custom load balancer

5.7. Summary and best practices

6. Using components

6.1. Overview of Camel components

6.1.1. Manually adding components

6.1.2. Autodiscovering components

6.2. Working with files (File and FTP components)

6.2.1. Reading and writing files with the File component

6.2.2. Accessing remote files with the FTP component

6.3. Asynchronous messaging (JMS component)

6.3.1. Sending and receiving messages

6.3.2. Request-reply messaging

6.3.3. Message mappings

6.4. Networking (Netty4 component)

6.4.1. Using Netty for network programming

6.4.2. Using custom codecs

6.5. Working with databases (JDBC and JPA components)

6.5.1. Accessing data with the JDBC component

6.5.2. Persisting objects with the JPA component

6.6. In-memory messaging (Direct, Direct-VM, SEDA, and VM components)

6.6.1. Synchronous messaging with the Direct and Direct-VM components

6.6.2. Asynchronous messaging with SEDA and VM

6.7. Automating tasks (Scheduler and Quartz2 components)

6.7.1. Using the Scheduler component

Part 3: Developing and testing

7. Microservices

7.1. Microservices Overview

7.1.1. Microservices Characteristics

7.2. Running Camel microservices

7.2.1. Standalone Camel as microservice

7.2.2. CDI Camel as microservice

7.2.3. WildFly Swarm with Camel as microservice

7.2.4. Spring Boot with Camel as microservice

7.2.5. Using Vert.x to build microservices

7.2.6. Using Camel together with Vert.X

7.3. Calling other microservices

7.3.1. Recommendation prototype

7.3.2. Shopping cart prototype

7.3.3. Rules and Inventory prototypes

7.3.4. Rating prototype

7.3.5. Putting all the microservices together

7.4. Designing for failures

7.4.1. Using Retry Pattern to handle failures

7.4.2. Using Retry Pattern without Camel

7.4.3. Using Circuit Breaker to handle failures

7.4.4. Netflix Hystrix

7.4.5. Using Hystrix with Camel

7.4.6. Configuring Hystrix

7.4.7. Bulkhead pattern

7.4.8. Calling other microservice with fault tolerance

7.4.9. Using Camel Hystrix with Spring Boot

7.4.10. The Hystrix Dashboard

7.5. Summary and best practices

8. Developing Camel projects

8.1. Managing projects with Maven

8.1.1. Using Camel Maven archetypes

8.1.2. Camel Maven dependencies

8.2. Using Camel in Eclipse

8.2.1. Starting a new Camel project

8.2.2. Debugging an issue with your new Camel project

8.3. Developing custom components

8.3.1. Setting up a new Camel component

8.3.2. Diving into the implementation

8.4. Generating components with the API component framework

8.4.1. Generating the skeleton API project

8.4.2. Configuring the camel-api-component-maven-plugin

8.4.3. Advanced configuration options

8.4.4. Implementing remaining functionality

8.5. Developing data formats

8.5.1. Generating the skeleton data format project

8.5.2. Writing the custom data format

8.6. Developing interceptors

8.6.1. Creating an InterceptStrategy

8.7. Summary and best practices

9. Testing

9.1. Introducing the Camel Test Kit

9.1.1. The Camel JUnit extensions

9.1.2. Using camel-test to test Java Camel routes

9.1.3. Unit testing an existing RouteBuilder class

9.2. Testing Camel with Spring, Blueprint, and CDI

9.2.1. Camel testing with Spring XML

9.2.2. Camel testing with Spring Java Config

9.2.3. Camel testing with Spring Boot

9.2.4. Camel testing with OSGi Blueprint XML

9.2.5. Camel testing with CDI

9.2.6. Camel testing with WildFly

9.3. Using the Mock component

9.3.1. Introducing the Mock component

9.3.2. Unit testing with the Mock component

9.3.3. Verifying that the correct message arrived

9.3.4. Using expressions with mocks

9.3.5. Testing the ordering of messages

9.3.6. Using mocks to simulate real components

9.4. Simulating errors

9.4.1. Simulating errors using a processor

9.4.2. Simulating errors using mocks

9.4.3. Simulating errors using interceptors

9.4.4. Using adviceWith to add interceptors to an existing route

9.4.5. Using adviceWith to manipulate routes for testing

9.4.6. Using weave with advice with to amend routes

9.5. Camel integration testing

9.5.1. Integration testing

9.5.2. Using NotifyBuilder

9.6. Using third party testing libraries

9.6.1. Using Arquillian to test Camel applications

9.6.2. Using Pax-Exam to test Camel applications

9.6.3. Using Citrus Framework to test Camel applications

9.6.4. Other Testing Libraries

9.7. Summary and best practices

10. RESTful and SOAP web services

10.1. Restful services

10.1.1. The principle of an RESTful API

10.1.2. Using JAX-RS with REST services

10.1.3. Using Camel in an existing JAX-RS application

10.1.4. Using camel-reslet with REST services

10.1.5. Using camel-cxfrs with REST services

10.2. The Camel Rest DSL

10.2.1. A quick example of the Rest DSL

10.2.2. How the Rest DSL works

10.2.3. Supported components for the Rest DSL

10.2.4. Configuring Rest DSL

10.2.5. Using XML and JSon data formats with Rest DSL

10.3. API Documentation using Swagger

10.3.1. Using Swagger with JAX-RS Rest services

10.3.2. Using Swagger with Rest DSL

10.3.3. Documenting Rest DSL services

10.3.4. Documenting input, output and error codes

10.3.5. Configuring API documentation

10.3.6. Using CORS and Swagger web console

10.4. Web services

10.4.1. Configuring CXF

10.4.2. Using a contract-first approach

10.4.3. Using a code-first approach

10.5. Summary and best practices

Part 4: Going further with Camel

11. Error Handling

11.1. Understanding error handling

11.1.1. Where Camel’s error handling applies

11.2. Error handlers in Camel

11.2.1. The default error handler

11.2.2. The dead letter channel error handler

11.2.3. The transaction error handler

11.2.4. The no error handler

11.2.5. The logging error handler

11.2.6. Features of the error handlers

11.3. Using error handlers with redelivery

11.3.1. An error-handling use case

11.3.2. Using redelivery

11.3.3. Using the DefaultErrorHandler with redelivery

11.3.4. Error handlers and scopes

11.3.5. Reusing context scoped error handlers

11.3.6. Handling faults

11.4. Using exception policies

11.4.1. Understanding how onException catches exceptions

11.4.2. Understanding how onException works with redelivery

11.4.3. Understanding how onException can handle exceptions

11.4.4. Custom exception handling

11.4.5. New exception while handling exception

11.4.6. Ignoring exceptions

11.4.7. Implementing an error handler solution

11.4.8. Bridging the consumer with Camel’s error handler

11.5. Other error-handling features

11.5.1. Using onWhen

11.5.2. Using onRedeliver

11.5.3. Using retryWhile

11.6. Summary and best practices

12. Transactions and Idempotency

12.1. Why use transactions?

12.1.1. The Rider Auto Parts partner integration application

12.1.2. Setting up the JMS broker and the database

12.1.3. The story of the lost message

12.2. Transaction basics

12.2.1. About Spring’s transaction support

12.2.2. Adding transactions

12.2.3. Testing transactions

12.3. The Transactional Client EIP

12.3.1. Using local transactions

12.3.2. Using global transactions

12.3.3. Transaction starting from a database resource

12.3.4. Transaction redeliveries

12.3.5. Transaction propagations

12.3.6. Using transactions with multiple routes

12.3.7. Using different transaction propagations

12.3.8. Returning a custom response when a transaction fails

12.4. Compensating for unsupported transactions

12.4.1. Introducing UnitOfWork

12.4.2. Using Synchronization callbacks

12.4.3. Using onCompletion

12.5. Idempotency

12.5.1. Idempotent Consumer EIP

12.5.2. Idempotent Repositories

12.5.3. Clustered idempotent repository

12.6. Summary and best practices

13. Parallel processing

13.1. Introducing concurrency

13.1.1. Running the example without concurrency

13.1.2. Using concurrency

13.2. Using thread pools

13.2.1. Understanding thread pools in Java

13.2.2. Camel thread pool profiles

13.2.3. Creating custom thread pools

13.2.4. Using ExecutorServiceStrategy

13.3. Parallel processing with EIPs

13.3.1. Using concurrency with the Threads EIP

13.3.2. Using concurrency with the Multicast EIP

13.3.3. Using concurrency with the Wire Tap EIP

13.4. The asynchronous routing engine

13.4.1. Hitting the scalability limit

13.4.2. Scalability in Camel

13.4.3. Components supporting asynchronous processing

13.4.4. Asynchronous API

13.4.5. Writing a custom asynchronous component

13.4.6. Potential issues when using an asynchronous component

13.4.7. Dangers with blocked threads

13.5. Summary and best practices

14. Securing Camel

14.1. Securing your configuration

14.1.1. Encrypting configuration

14.1.2. Decrypting configuration

14.2. Web service security

14.2.1. Authentication in web services

14.2.2. Authenticating web services using JAAS

14.3. Payload security

14.3.1. Digital signatures

14.3.2. Payload encryption

14.4. Transport security

14.5. Route authentication and authorization

14.6. Summary and best practices

Part 5: Running and managing Camel

15. Running and deploying Camel

15.1. Starting Camel

15.1.1. How Camel starts

15.1.2. Camel startup options

15.1.3. Ordering routes

15.1.4. Disabling autostartup

15.2. Starting and stopping routes at runtime

15.2.1. Using CamelContext to start and stop routes at runtime

15.2.2. Using RoutePolicy to start and stop routes at runtime

15.3. Shutting down Camel

15.3.1. Graceful shutdown

15.4. Deploying Camel

15.4.1. Embedded in a Java application

15.4.2. Embedded in a web application

15.4.3. Embedded in WildFly

15.5. Camel and OSGi

15.5.1. Setting up Maven to generate an OSGi bundle

15.5.2. Installing and running Apache Karaf

15.5.3. Using a Blueprint-based Camel route

15.5.4. Deploying the example

15.5.5. Using a managed service factory to spin up route instances

15.6. Camel and CDI

15.6.1. WildFly deployment

15.6.2. Karaf deployment

15.7. Summary and best practices

16. Management and Monitoring

16.1. Monitoring Camel

16.1.1. Checking health at the network level

16.1.2. Checking health level at the JVM level

16.1.3. Checking health at the application level

16.2. Using JMX with Camel

16.2.1. Using JConsole to manage Camel

16.2.2. Using JConsole to remotely manage Camel

16.2.3. Using Jolokia to manage Camel

16.3. Tracking application activity

16.3.1. Using log files

16.3.2. Using core logs

16.3.3. Using custom logging

16.3.4. Using Tracer

16.3.5. Using notifications

16.4. Managing Camel applications

16.4.1. Managing Camel application lifecycles

16.4.2. Using Jolokia and hawtio to manage Camel lifecycles

16.4.3. Using Camel commands to manage Camel

16.4.4. Using controlbus to manage Camel

16.5. The Camel management API

16.5.1. Accessing the Camel management API using Java

16.5.2. Using Camel management API from within Camel

16.5.3. Performance Statistics

16.5.4. Management enable custom Camel components

16.5.5. Management enable custom Java beans

16.6. Summary and best practices

Part 6: Out in the wild

17. Clustering

17.1. Clustered HTTP

17.2. Clustered Camel routes

17.2.1. Clustered active/passive mode using Hazelcast

17.2.2. Clustered active/passive mode using Consul

17.2.3. Clustered active/passive mode using ZooKeeper

17.3. Clustered JMS

17.3.1. Client side clustering with JMS and ActiveMQ

17.4. Clustered Kafka

17.4.1. Kafka consumer offset

17.4.2. Crashing a JVM with a running Kafka consumer

17.5. Clustering caches

17.5.1. Clustered cache using Hazelcast

17.5.2. Clustering cache using JCache and Infinispan

17.6. Using clustered scheduling

17.6.1. Clustered scheduling using Quartz

17.7. Summary and best practices

18. Microservices with Docker and Kubernetes

18.1. Getting started with Camel on Docker

18.1.1. Building and running Camel microservices locally

18.1.2. Building and running Camel microservices using Docker

18.1.3. Building Docker Image using Docker Maven Plugin

18.1.4. Run Java Microservices on Docker

18.2. Getting Started with Kubernetes

18.2.1. Installing Minikube

18.2.2. Starting Minikube

18.3. Running Camel and other applications in Kubernetes

18.3.1. Run applications using kubctl

18.3.2. Calling a service running inside Kubernetes cluster

18.3.3. Run Java applications in Kubernetes using Maven tooling

18.3.4. Java microservices calling each other in the cluster

18.3.5. Debugging Java applications in Kubernetes

18.4. Understanding Kubernetes

18.4.1. Introducing Kubernetes

18.4.2. Kubernetes Architecture

18.4.3. Essential Kubernetes Concepts

18.5. Building resilient Camel microservices on Kubernetes

18.5.1. Scaling up microservices

18.5.2. Using readiness and liveness probes

18.5.3. Dealing with failures calling services in Kubernetes

18.6. fabric8, helm and OpenShift

18.6.1. About fabric8

18.6.2. Installing fabric8 console

18.6.3. Kubernetes Helm

18.6.4. OpenShift

18.7. Summary and best practices

19. Camel tooling

19.1. Camel Editors

19.1.1. JBoss Tools for Apache Camel

19.1.2. fabric8 Camel editor

19.1.3. Camel Validation using Maven

19.2. Camel Catalog - The information goldmine

19.2.1. Developing custom tooling using the camel-catalog

19.2.2. Camel tooling with Karaf

19.3. hawtio - A web console for Camel and Java applications

19.3.1. Overview of hawtio functionality

19.3.2. Debugging Camel routes using hawtio

19.3.3. Building hawtio plugins

19.4. Summary and best practices

20. Reactive Camel

20.1. Using Reactive Streams with Camel

20.1.1. Reactive flow control with back pressure

20.1.2. First steps with Reactive Streams

20.1.3. Using Camel with Reactive Streams

20.1.4. Controlling back pressure from producer side

20.1.5. Controlling back pressure from consumer side

20.2. Using Vert.x with Camel

20.2.1. Building a dong simulator using Vert.x

20.2.2. Using Camel together with Vert.x

20.2.3. Summary of using Camel with Vert.x for microservices

20.3. Summary and best practices

21. Camel and IoT

21.1. The Internet Of Things shopping list

21.1.1. Raspberry Pi

21.1.2. SD Card for Raspberry Pi

21.1.3. Power bank for Raspberry Pi

21.1.4. Camera for Raspberry Pi

21.1.5. TI SensorTag

21.2. The Internet Of Things architecture

21.3. Why Camel is a right choice for The Internet Of Things?

21.3.1. Components

21.3.2. Data formats

21.3.3. Redelivery

21.3.4. Throttling

21.3.5. Content based routing

21.3.6. Client side load balancing

21.3.7. Control bus

21.4. Gateway to a data center connectivity

21.4.1. AMQP

21.4.2. MQTT

21.4.3. REST/HTTP

21.5. Camel and Eclipse Kura

21.5.1. Starting Kura in emulator mode

21.5.2. Defining Camel routes using Kura web UI

21.5.3. Next steps with Camel and Kura

21.6. Next steps with Camel and Internet Of Things

21.6.1. Eclipse Kapua

21.6.2. LWM2M and Eclipse Leshan project

21.6.3. Eclipse Hono

Appendixes

Appendix A: Simple, the expression language

A.1. Introducing Simple

A.2. Syntax

A.3. Built-in variables

A.4. Built-in functions

A.5. Built-in file variables

A.6. Built-in operators

A.6.1. Combining expressions

A.7. The OGNL feature

A.8. Using Simple from custom Java code

A.9. Summary

Appendix B: The Camel community

B.1. Apache Camel website

B.2. JIRA, mailing lists, and IRC

B.3. Camel at GitHub

B.4. Camel at Stack Overflow

B.5. Commercial Camel Offerings

B.6. Camel Tooling

B.7. Camel-extra project

B.8. Camel quick reference card

B.9. Becoming a Camel committer

B.10. Other resources

About the Technology

Apache Camel is a Java framework that implements enterprise integration patterns (EIPs) and comes with over 200 adapters to third-party systems. A concise DSL lets you build integration logic into your app with just a few lines of Java or XML. By using Camel, you benefit from the testing and experience of a large and vibrant open source community.

About the book

Camel in Action, Second Edition is the definitive guide to the Camel framework. It starts with core concepts like sending, receiving, routing, and transforming data. It then goes in depth on many topics such as how to develop, debug, test, deal with errors, secure, scale, cluster, deploy, and monitor your Camel applications. The book also discusses how to run Camel with microservices, reactive systems, containers, and in the cloud.

What's inside

  • Coverage of all relevant EIPs
  • Camel microservices with Spring Boot
  • Camel on Docker and Kubernetes
  • Error handling, testing, security, clustering, monitoring, and deployment
  • Hundreds of examples in Java and XML

About the reader

Readers should be familiar with Java. This book is accessible to beginners and invaluable to experts.

About the authors

Claus Ibsen is a senior principal engineer working for Red Hat specializing in cloud and integration. He has worked on Apache Camel for the last nine years where he heads the project. Claus lives in Denmark.

Jonathan Anstey is an engineering manager at Red Hat and a core Camel contributor. He lives in Newfoundland, Canada.


buy
Camel in Action, Second Edition (combo) added to cart
continue shopping
go to cart

combo $69,99 pBook + eBook + liveBook
Camel in Action, Second Edition (eBook) added to cart
continue shopping
go to cart

eBook $55,99 pdf + ePub + kindle + liveBook

FREE domestic shipping on three or more pBooks

Claus and Jon are great writers, relying on figures and diagrams where needed and presenting lots of code snippets and worked examples.

From the Foreword by Dr. Mark Little, Technical Director of JBoss

The second edition of this all-time classic is an indispensable companion for your Apache Camel rides.

Gregor Zurowski, Apache Camel Committer

The absolute best way to learn and use Camel - top to bottom, front to back, and all the way through. Camel is a fantastic tool - every Java coder should have a copy of this book.

Rick Wagner, Red Hat

An excellent book and the definite reference for experienced engineers.

Yan Guo, EventBrite