I highly recommend this book. It kicks ass!
Second edition of this book is available in MEAP
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.
foreword by Gregor Hohpe
foreword by James Strachan
preface
acknowledgments
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
index
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.
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.
- combo $49.99 pBook + eBook
- eBook $39.99 pdf + ePub + kindle
FREE domestic shipping on three or more pBooks
Strikes the right balance between core concepts and running code.
Comprehensive guide to enterprise integration with Camel.
A deep book... with great examples.
Great content from the source developers.
A must-have.