Camel in Action
Claus Ibsen and Jonathan Anstey
Forewords by Gregor Hohpe and James Strachan
  • December 2010
  • ISBN 9781935182368
  • 552 pages

I highly recommend this book. It kicks ass!

James Strachan, Cofounder of Apache Camel


Camel in Action, Second Edition is now available. An eBook of this older edition is included at no additional cost when you buy the revised edition!

A limited number of pBook copies of this edition are still available. Please contact Manning Support to inquire about purchasing previous edition copies.

Camel in Action is a Camel tutorial full of small examples showing how to work with the integration patterns. It starts with core concepts like sending, receiving, routing, and transforming data. It then shows you the entire lifecycle and goes in depth on how to test, deal with errors, scale, deploy, and even monitor your app—details you can find only in the Camel code itself. Written by the developers of Camel, this book distills their experience and practical insights so that you can tackle integration tasks like a pro.

About the Technology

Apache Camel is a Java framework that lets you implement the standard enterprise integration patterns in a few lines of code. With a concise but sophisticated DSL you snap integration logic into your app, Lego-style, using Java, XML, or Scala. Camel supports over 80 common transports such as HTTP, REST, JMS, and Web Services.

Table of Contents detailed table of contents

foreword by Gregor Hohpe

foreword by James Strachan



about this book

about the cover illustration

about the authors

Part 1 First steps

1. Meeting Camel

1.1. Introducing Camel

1.2. Camel’s message model

1.3. Camel’s architecture

1.4. Your first Camel ride, revisited

1.5. Summary

2. Routing with Camel

2.1. Introducing Rider Auto Parts

2.2. Understanding endpoints

2.3. Creating routes in Java

2.4. Creating routes with Spring

2.5. Routing and EIPs

2.6. Summary and best practices

Part 2 Core Camel

3. Transforming data with Camel

3.1. Data transformation overview

3.2. Transforming data using EIPs and Java

3.3. Transforming XML

3.4. Transforming with data formats

3.5. Transforming with templates

3.6. About Camel type converters

3.7. Summary and best practices

4. Using beans with Camel

4.1. Using beans the hard way and the easy way

4.2. The Service Activator pattern

4.3. Camel’s bean registries

4.4. Selecting bean methods

4.5. Bean parameter binding

4.6. Summary and best practices

5. Error handling

5.1. Understanding error handling

5.2. Error handlers in Camel

5.3. Using error handlers with redelivery

5.4. Using exception policies

5.5. Other error-handling features

5.6. Summary and best practices

6. Testing with Camel

6.1. Introducing the Camel Test Kit

6.2. Using the Mock component

6.3. Simulating errors

6.4. Testing without mocks

6.5. Summary and best practices

7. Understanding components

7.1. Overview of Camel components

7.2. Working with files (File and FTP components)

7.3. Asynchronous messaging (JMS component)

7.4. Web services (CXF component)

7.5. Networking (MINA component)

7.6. Working with databases (JDBC and JPA components)

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

7.8. Automating tasks (Timer and Quartz components)

7.9. Summary and best practices

8. Enterprise integration patterns

8.1. Introducing enterprise integration patterns

8.2. The Aggregator EIP

8.3. The Splitter EIP

8.4. The Routing Slip EIP

8.5. The Dynamic Router EIP

8.6. The Load Balancer EIP

8.7. Summary and best practices

Part 3 Out in the wild

9. Using transactions

9.1. Why use transactions?

9.2. Transaction basics

9.3. The Transactional Client EIP

9.4. Configuring and using transactions

9.5. Compensating for unsupported transactions

9.6. Summary and best practices

10. Concurrency and scalability

10.1. Introducing concurrency

10.2. Using thread pools

10.3. Using concurrency with EIPs

10.4. Synchronicity and threading

10.5. The concurrency client API

10.6. The asynchronous routing engine

10.7. Summary and best practices

11. Developing Camel projects

11.1. Managing projects with Maven

11.2. Developing custom components

11.3. Developing interceptors

11.4. Using alternative languages

11.5. Summary and best practices

12. Management and monitoring

12.1. Monitoring Camel

12.2. Using JMX with Camel

12.3. Tracking application activity

12.4. Managing Camel applications

12.5. Summary and best practices

13. Running and deploying Camel

13.1. Starting Camel

13.2. Starting and stopping routes at runtime

13.3. Shutting down Camel

13.4. Deploying Camel

13.5. Camel and OSGi

13.6. Summary and best practices

14. Bean routing and remoting

14.1. Using beans for routing

14.2. Hiding middleware

14.3. Summary and best practices

Appendix A: Simple, the expression language

Appendix B: Expressions and predicates

Appendix C: The producer and consumer templates

Appendix D: The Camel community

Appendix E: Akka and Camel


What's inside

  • Valuable examples in Java and XML
  • Explanations of complex patterns
  • Error handling, testing, deploying, managing, and running Camel
  • Accessible to beginners, useful to experts

About the authors

Claus Ibsen is a principal engineer working for FuseSource specializing in the enterprise integration space. He has worked on Apache Camel for the last three years where he is a a PMC member, a key contributor, and heads the development and roadmap. Claus lives in Sweden near Malmo with his wife and dog.

Jonathan Anstey is a software engineer with varied experience in manufacturing control systems, build infrastructure, and enterprise integration. Lately, Jon has been working on Apache Camel as a PMC member and an active committer while at FuseSource. When he is not hacking on Camel he likes to spend time with his wife and daughter in St. John's, Newfoundland.

placing your order...

Don't refresh or navigate away from the page.
customers also reading

This book

FREE domestic shipping on three or more pBooks