Camel in Action pdf

www.it-ebooks.info
Camel in Action

www.it-ebooks.info

www.it-ebooks.info
Camel in Action
CLAUS IBSEN
JONATHAN ANSTEY
MANNING
Greenwich
(74° w. long.)

www.it-ebooks.info
For online information and ordering of this and other Manning books, please visit
www.manning.com. The publisher offers discounts on this book when ordered in quantity.
For more information, please contact
Special Sales Department
Manning Publications Co.
180 Broad Street, Suite 1323
Stamford, CT 06901
Email:
©2011 by Manning Publications Co. All rights reserved.
No part of this publication may be reproduced, stored in a retrieval system, or transmitted, in
any form or by means electronic, mechanical, photocopying, or otherwise, without prior written
permission of the publisher.
Many of the designations used by manufacturers and sellers to distinguish their products are
claimed as trademarks. Where those designations appear in the book, and Manning
Publications was aware of a trademark claim, the designations have been printed in initial caps
or all caps.
Recognizing the importance of preserving what has been written, it is Manning’s policy to have

the books we publish printed on acid-free paper, and we exert our best efforts to that end.
Recognizing also our responsibility to conserve the resources of our planet, Manning books are
printed on paper that is at least 15 percent recycled and processed without the use of elemental
chlorine.
Manning Publications Co. Development editor: Cynthia Kane
180 Broad Street, Suite 1323 Copyeditor: Andy Carroll
Stamford, CT 06901 Cover designer: Marija Tudor
Typesetter: Gordan Salinovic
ISBN 978-1-935182-36-8
Printed in the United States of America
12345678910 –MAL –151413121110

www.it-ebooks.info
To the Apache Camel community
May this book be a helpful companion on your journeys with Camel

www.it-ebooks.info

www.it-ebooks.info
vii
brief contents
PART 1 FIRST STEPS . 1
1 ■ Meeting Camel 3
2 ■ Routing with Camel 22
PART 2 CORE CAMEL 59
3 ■ Transforming data with Camel 61
4 ■ Using beans with Camel 93
5 ■ Error handling 120
6 ■ Testing with Camel 154
7 ■ Understanding components 188

8 ■ Enterprise integration patterns 237
PART 3 OUT IN THE WILD 281
9 ■ Using transactions 283
10 ■ Concurrency and scalability 315
11 ■ Developing Camel projects 359
12 ■ Management and monitoring 385
13 ■ Running and deploying Camel 410
14 ■ Bean routing and remoting 443

www.it-ebooks.info

www.it-ebooks.info
ix
contents
foreword xvii
foreword xix
preface xxi
acknowledgments xxiii
about this book xxv
about the cover illustration xxix
about the authors xxxi
PART 1 FIRST STEPS. 1
1
Meeting Camel 3
1.1 Introducing Camel 4
What is Camel? 4
■
Why use Camel? 5
■
Getting

started 8
■
Getting Camel 8
■
Your first Camel ride 9
1.2 Camel’s message model 13
Message 13
■
Exchange 14
1.3 Camel’s architecture 15
Architecture from 10,000 feet 15
■
Camel concepts 16
1.4 Your first Camel ride, revisited 20
1.5 Summary 21

www.it-ebooks.info
CONTENTS
x
2
Routing with Camel 22
2.1 Introducing Rider Auto Parts 23
2.2 Understanding endpoints 24
Working with files over FTP 24
■
Sending to a JMS queue 26
2.3 Creating routes in Java 28
Using the RouteBuilder 29
■
The Java DSL 30

2.4 Creating routes with Spring 34
Bean injection and Spring 34
■
The Spring DSL 37
■
Using
Camel and Spring 40
2.5 Routing and EIPs 43
Using a content-based router 44
■
Using message filters 49
Using multicasting 50
■
Using recipient lists 52
■
Using the
wireTap method 55
2.6 Summary and best practices 57
PART 2 CORE CAMEL 59
3
Transforming data with Camel 61
3.1 Data transformation overview 62
Data transformation with Camel 62
3.2 Transforming data using EIPs and Java 63
Using the Message Translator EIP 63
■
Using the Content
Enricher EIP 70
3.3 Transforming XML 73
Transforming XML with XSLT 73

■
Transforming XML with
object marshaling 75
3.4 Transforming with data formats 77
Data formats provided with Camel 78
■
Using Camel’s CSV data
format 79
■
Using Camel’s Bindy data format 80
■
Using
Camel’s JSON data format 83
■
Configuring Camel data
formats 84
■
Writing your own data format 85
3.5 Transforming with templates 86
Using Apache Velocity 87
3.6 About Camel type converters 88
How the Camel type-converter mechanism works 88
■
Using Camel
type converters 90
■
Writing your own type converter 90
3.7 Summary and best practices 92

www.it-ebooks.info

CONTENTS
xi
4
Using beans with Camel 93
4.1 Using beans the hard way and the easy way 94
Invoking a bean from pure Java 94
■
Invoking a bean defined in
Spring 95
■
Using beans the easy way 96
4.2 The Service Activator pattern 97
4.3 Camel’s bean registries 98
SimpleRegistry 100
■
JndiRegistry 101
■
ApplicationContext-
Registry 101
■
OsgiServiceRegistry 102
4.4 Selecting bean methods 103
How Camel selects bean methods 104
■
Camel’s method-selection
algorithm 105
■
Some method-selection examples 107
Potential method-selection problems 109
4.5 Bean parameter binding 111

Binding with multiple parameters 112
■
Binding using built-in
types 113
■
Binding using Camel annotations 114
■
Binding
using Camel language annotations 115
4.6 Summary and best practices 119
5
Error handling 120
5.1 Understanding error handling 121
Recoverable and irrecoverable errors 121
■
Where Camel’s error
handling applies 123
5.2 Error handlers in Camel 124
The default error handler 125
■
The dead letter channel error
handler 126
■
The transaction error handler 128
■
The no error
handler 128
■
The logging error handler 128
■

Features of the
error handlers 128
5.3 Using error handlers with redelivery 129
An error-handling use case 129
■
Using redelivery 130
■
Error
handlers and scopes 135
■
Handling faults 137
5.4 Using exception policies 138
Understanding how onException catches exceptions 139
■
Understanding
how onException works with redelivery 142
■
Understanding how
onException can handle exceptions 143
■
Custom exception
handling 146
■
Ignoring exceptions 148
■
Implementing an error
handler solution 149
5.5 Other error-handling features 150
Using onWhen 150
■

Using onRedeliver 151
■
Using
retryWhile 152
5.6 Summary and best practices 153

www.it-ebooks.info
CONTENTS
xii
6
Testing with Camel 154
6.1 Introducing the Camel Test Kit 155
The Camel JUnit extensions 155
■
Using the Camel Test Kit 156
Unit testing with the CamelTestSupport class 156
■
Unit testing an
existing RouteBuilder class 159
■
Unit testing with the SpringCamel-
TestSupport class 159
■
Unit testing in multiple environments 161
6.2 Using the Mock component 166
Introducing the Mock component 167
■
Unit testing with the Mock
component 167
■

Verifying that the correct message arrived 169
Using expressions with mocks 170
■
Testing the ordering of
messages 174
■
Using mocks to simulate real components 175
6.3 Simulating errors 178
Simulating errors using a processor 178
■
Simulating errors using
mocks 180
■
Simulating errors using interceptors 180
6.4 Testing without mocks 183
Integration testing 183
■
Using NotifyBuilder 185
6.5 Summary and best practices 187
7
Understanding components 188
7.1 Overview of Camel components 189
Manually adding components 190
■
Autodiscovering components 190
7.2 Working with files (File and FTP components) 192
Reading and writing files with the File component 193
■
Accessing remote
files with the FTP component 196

7.3 Asynchronous messaging (JMS component) 197
Sending and receiving messages 200
■
Request-reply
messaging 201
■
Message mappings 202
7.4 Web services (CXF component) 205
Configuring CXF 206
■
Using a contract-first approach 209
Using a code-first approach 215
7.5 Networking (MINA component) 216
Using MINA for network programming 217
■
Using custom codecs 219
7.6 Working with databases (JDBC and JPA components) 221
Accessing data with the JDBC component 221
■
Persisting objects with the
JPA component 224
7.7 In-memory messaging (Direct, SEDA, and VM
components) 229
Synchronous messaging with the Direct component 229
Asynchronous messaging with SEDA and VM 230

www.it-ebooks.info
CONTENTS
xiii
7.8 Automating tasks (Timer and Quartz components) 232

Using the Timer component 232
■
Enterprise scheduling with
Quartz 233
7.9 Summary and best practices 235
8
Enterprise integration patterns 237
8.1 Introducing enterprise integration patterns 238
The Aggregator and Splitter EIPs 238
■
The Routing Slip and
Dynamic Router EIPs 239
■
The Load Balancer EIP 239
8.2 The Aggregator EIP 239
Introducing the Aggregator EIP 240
■
Completion conditions for
the Aggregator 243
■
Using persistence with the Aggregator 248
Using recovery with the Aggregator 251
8.3 The Splitter EIP 255
Using the Splitter 256
■
Using beans for splitting 258
■
Splitting
big messages 260
■

Aggregating split messages 262
■
When errors
occur during splitting 264
8.4 The Routing Slip EIP 266
Using the Routing Slip EIP 267
■
Using a bean to compute the
routing slip header 267
■
Using an Expression as the routing
slip 268
■
Using @RoutingSlip annotation 269
8.5 The Dynamic Router EIP 270
Using the Dynamic Router 270
■
Using the @DynamicRouter
annotation 271
8.6 The Load Balancer EIP 272
Introducing the Load Balancer EIP 272
■
Load-balancing
strategies 274
■
Using the failover load balancer 275
■
Using a
custom load balancer 278
8.7 Summary and best practices 280

PART 3 OUT IN THE WILD 281
9
Using transactions 283
9.1 Why use transactions? 284
The Rider Auto Parts partner integration application 284
■
Setting
up the JMS broker and the database 287
■
The story of the lost
message 288
9.2 Transaction basics 289
About Spring’s transaction support 290
■
Adding
transactions 291
■
Testing transactions 293

www.it-ebooks.info
CONTENTS
xiv
9.3 The Transactional Client EIP 296
Using local transactions 297
■
Using global transactions 298
9.4 Configuring and using transactions 301
Configuring transactions 301
■
Using transactions with multiple

routes 303
■
Returning a custom response when a transaction
fails 306
9.5 Compensating for unsupported transactions 309
Introducing UnitOfWork 309
■
Using Synchronization
callbacks 310
■
Using onCompletion 312
9.6 Summary and best practices 313
10
Concurrency and scalability 315
10.1 Introducing concurrency 316
Running the example without concurrency 318
■
Using
concurrency 318
10.2 Using thread pools 323
Understanding thread pools in Java 323
■
Camel thread pool
profiles 326
■
Creating custom thread pools 328
■
Using
ExecutorServiceStrategy 329
10.3 Using concurrency with EIPs 330

Using concurrency with the Threads EIP 331
■
Using concurrency
with the Multicast EIP 332
■
Using concurrency with the Wire
Tap EIP 334
10.4 Synchronicity and threading 335
Asynchronous caller using one thread 336
■
Synchronous caller
using one thread 337
■
Asynchronous caller using multiple
threads 339
■
Synchronous caller using multiple threads 340
Returning an early reply to a caller 342
10.5 The concurrency client API 344
The concurrency client API in Java 344
■
The concurrency client
API in Camel 347
10.6 The asynchronous routing engine 350
Hitting the scalability limit 350
■
Scalability in Camel 352
Components supporting asynchronous processing 353
Asynchronous API 354
■

Writing a custom asynchronous
component 356
10.7 Summary and best practices 358

www.it-ebooks.info
CONTENTS
xv
11
Developing Camel projects 359
11.1 Managing projects with Maven 360
Using Camel Maven archetypes 360
■
Camel Maven
dependencies 364
■
Using Camel in Eclipse 366
■
Using the
Maven Eclipse plugin 366
■
Using the m2eclipse plugin 368
11.2 Developing custom components 371
Setting up a new Camel component 371
■
Diving into the
implementation 373
11.3 Developing interceptors 377
Creating an InterceptStrategy 377
11.4 Using alternative languages 380
The Scala DSL 380

■
Adding Scala routes to the CamelContext 382
Mixing Java and Scala 382
11.5 Summary and best practices 384
12
Management and monitoring 385
12.1 Monitoring Camel 386
Checking health at the network level 386
■
Checking health at the
JVM level 388
■
Checking health at the application level 388
12.2 Using JMX with Camel 389
Using JConsole to manage Camel 390
■
Using JConsole to remotely
manage Camel 391
12.3 Tracking application activity 393
Using log files 393
■
Using core logs 394
■
Using custom
logging 394
■
Using Tracer 398
■
Using notifications 402
12.4 Managing Camel applications 405

Managing Camel application lifecycles 405
■
Managing custom
Camel components 406
12.5 Summary and best practices 409
13
Running and deploying Camel 410
13.1 Starting Camel 411
How Camel starts 411
■
Camel startup options 413
■
Ordering
routes 416
■
Disabling autostartup 418
13.2 Starting and stopping routes at runtime 419
Using CamelContext to start and stop routes at runtime 420
Using RoutePolicy to start and stop routes at runtime 422

www.it-ebooks.info
CONTENTS
xvi
13.3 Shutting down Camel 424
Graceful shutdown 425
13.4 Deploying Camel 428
Embedded in a Java application 428
■
Embedded in a web
application 430

■
Embedded in JBoss Application Server 436
13.5 Camel and OSGi 437
Setting up Maven to generate an OSGi bundle 438
■
Installing
and running Apache Karaf 439
■
Deploying the example 440
13.6 Summary and best practices 441
14
Bean routing and remoting 443
14.1 Using beans for routing 444
Inventory update at Rider Auto Parts 444
■
Receiving messages
with @Consume 445
■
Sending messages with @Produce 448
When to use beans for routing 450
14.2 Hiding middleware 451
Introducing the starter kit 453
■
Using Spring remoting and
Camel proxies 456
14.3 Summary and best practices 460
appendix A Simple, the expression language 461
appendix B Expressions and predicates 471
appendix C The producer and consumer templates 477
appendix D The Camel community 483

appendix E Akka and Camel 487
index 501

www.it-ebooks.info
xvii
foreword
Languages are a critical aspect of software development. They give us the vocabulary
to express what a program should do. They force us to encode our requirements in
precise and non-ambiguous terms. Lastly, they enable the sharing of knowledge
between developers. No, I’m not talking about Java, Haskell, or PL/1. I’m talking
about the languages we use to communicate from human to human, from developer
to developer, or from end user to product manager. For a long time, the world of
enterprise integration (or EAI, as it was commonly known in the “dark ages of integra-
tion”) lacked such a vocabulary. Each vendor offered a proprietary solution, which
not only failed to integrate at a technical level with other vendors’ offerings, but also
used a different language to describe the main components and their functions. This
not only caused confusion, but was also a key inhibitor to creating a community of
developers that could span the vast space of enterprise integration. Each “tribe” was
essentially held hostage by the language bestowed upon them. Ironically, integration
developers were faced with the same “tower of Babel” problem that their software was
designed to solve!
Establishing a common vocabulary that enables knowledge sharing and collabora-
tion was the key motivator for us to write Enterprise Integration Patterns (EIPs). Each
of the 65 patterns has a descriptive name, which represents the solution to a design
challenge in the integration space. Besides supporting effective communication, this
vocabulary also raises the level of abstraction at which we can describe integration
problems and solutions.
A shared vocabulary is a big step forward, but a giant step we could not imagine at
the time was that our language would spur the development of a whole family of open

www.it-ebooks.info
FOREWORD
xviii
source messaging and enterprise service bus (ESB) products. These tools embrace the
EIP vocabulary by implementing many patterns directly in the platform. With Apache
Camel, a Splitter pattern translates directly into a “split” element in the Camel DSL.
We couldn’t have wished for a more direct translation of the pattern language into an
implementation platform.
Claus and Jon bring the saga to a grand finale by showing us how to use the Camel
pattern language to compose real-life messaging solutions. In doing so, they not only
cover fundamental concepts like routing and transformation, but also dig into often-
neglected parts of the development process, including testing, monitoring, and deploy-
ing. They find the right balance of the pattern language, Camel core concepts, and run-
ning code to help you build easy-to-understand and robust messaging solutions.
G
REGOR HOHPE
COAUTHOR OF ENTERPRISE INTEGRATION PATTERNS
WWW.EAIPATTERNS.COM

www.it-ebooks.info
xix
foreword
I was one of the original founders of both Apache ActiveMQ (an open source high-
performance message broker) and ServiceMix (an open source ESB based on JBI and
OSGi). I found that Enterprise Integration Patterns were becoming increasingly cen-
tral to what we were doing on these projects and how we were using them; the only dif-
ference was the context and technologies with which we were using the patterns.
There have been many libraries and frameworks over the years to help with inte-
gration. But frequently the concepts behind the Enterprise Integration Patterns get
transformed into some complex class hierarchies or objects that need to be wired

together just so, and the original intentions and patterns are often lost. The developer
is forced from then on to focus on the low-level detail and some complex class library
API, losing the bigger picture and patterns.
Integration is hard and once you start down the path of integrating things together
the code can very easily mushroom; being able to easily comprehend, communicate,
adapt, and maintain integration solutions is vital to be able to solve integration prob-
lems efficiently in an agile way.
So we decided it was time for a new integration framework that put the EIPs at its
core and tried to raise the abstraction level so that developers could describe declara-
tively in very concise terms what Enterprise Integration Patterns they wanted to use in
a simple domain-specific language. Using a convention over configuration approach,
developers would declaratively describe what they wanted to do, using the Enterprise
Integration Pattern language; it would be both quick and easy to get things done and

www.it-ebooks.info
FOREWORD
xx
also very easy for any developer on a team (including the developer himself months
after writing the code!) to understand and adapt the code.
There are many different places we wanted to use the
EIPs; whether in a stand-
alone application, a web services stack, an enterprise message broker like Apache
Active
MQ, or inside a full-blown ESB like Apache ServiceMix, so we wanted a light-
weight framework that was middleware agnostic that users could embed anywhere
they wanted it. We also wanted developers to focus on the Enterprise Integration Pat-
terns first and foremost and not to get lost in the weeds of different middleware
APIs
and technologies.
We also wanted developers to be able to use whatever

DSL flavor they wished
(whether Java, XML, Groovy, Ruby, Scala, or whatever) and yet, at runtime, still be able
to introspect the framework and understand all of the EIPs that were being used. They
would be able to visualize the core patterns to the team at any point in the project life-
cycle, auto-document the patterns, or even support things like graphical editing of the
Enterprise Integration Patterns at design time or runtime.
So Apache Camel was born, and since then we’ve seen the codebase, community,
and number of components, technologies, and data formats grow massively as more
and more developers have found Apache Camel an ideal way to design, implement,
and maintain the Enterprise Integration Patterns.
In this book Claus and Jon describe the Enterprise Integration Patterns and the
concepts which underlie Apache Camel. Then they walk you through how to take the
concepts and apply them to many real-life scenarios to provide scalable and efficient
solutions that are easy to understand and quick to adapt to your integration needs. I
hope you’ll enjoy reading this book as much as I did!
J
AMES STRACHAN
CO-FOUNDER OF APACHE ACTIVEMQ
CAMEL, AND SERVICEMIX
TECHNICAL DIRECTOR FUSESOURCE.COM
HTTP://MACSTRAC.BLOGSPOT.COM

www.it-ebooks.info
xxi
preface
Developers who have done integration work know what a difficult task it can be. IT sys-
tems may not have been designed to be accessible from other systems, and if they were
designed for interoperability, they may not speak the protocol you need. As a devel-
oper, you end up spending a considerable amount of time working with the plumbing
of the integration protocols to open up the IT systems to the outside world.

In Enterprise Integration Patterns, Gregor Hohpe and Bobby Woolf gave us a standard
way to describe, document, and implement complex integration problems. Develop-
ers and architects alike can use this common language and catalog of solutions to
tackle their integration problems. But although Hohpe and Woolf gave us the theory,
the industry still needed an open source implementation of the book.
James Strachan, Rob Davies, Guillaume Nodet, and Hiram Chirino, within the
open source communities of Apache ActiveMQ and Apache ServiceMix, brought the
idea of Camel to life. Apache Camel is essentially an implementation of the EIP book,
and in the summer of 2007 version 1.0 was released.
Apache Camel is an integration framework whose main goal is to make integration
easier. It implements many of the EIP patterns and allows you to focus on solving busi-
ness problems, freeing you from the burden of plumbing. Using connectivity compo-
nents has never been easier, because you don’t have to implement JMS message
listeners or FTP clients, deal with converting data between protocols, or mess with the
raw details of HTTP requests. All of this is taken care of by Camel, which makes media-
tion and routing as easy as writing a few lines of Java code or XML in a Spring XML file.

www.it-ebooks.info
PREFACE
xxii
Apache Camel has since become very popular and today has an ever-growing com-
munity. As with many open source projects that become popular, a logical next step is
for someone to write a book about the project. Hadrian Zbarcea, the Project Manage-
ment Committee chair of the Apache Camel project, realized this, and in early 2009
he contacted Manning to discuss the need for such a book. Hadrian got in touch with
me (Claus Ibsen), inviting me in as a coauthor. It was perfect timing, as I was taking
over from James Strachan as the lead on Apache Camel. Later that year, Hadrian had
to step down as an author, but he invited Jonathan Anstey in as his replacement, to
ensure the project could continue.
Jonathan and I are both integration specialists working for FuseSource, which is

the professional company that offers enterprise services around various Apache proj-
ects. This book is written by the people who wrote the Camel code, which ensures you
have the most updated Camel book on the market.
Writing this book has been a very intense journey, proven by the fact that we were
able to complete the manuscript in a year. It took a long time to implement the exam-
ples and to ensure that the accompanying source code is of the highest standard. But
the result is a great source of examples that should inspire you to get the best out of
Camel, and it should be a good starting point for your Camel projects. While we were
writing this book, we were also implementing new features in Camel, which often
meant we had to go back and revise the material along the way. But we have kept up,
and this book uses the latest Camel release at the time of writing (Camel 2.5).
We hope this book brings great value to you and helps you prosper in the Camel
community.
CLAUS IBSEN

www.it-ebooks.info
xxiii
acknowledgments
We first want to thank Cynthia Kane, our development editor at Manning, who put up
with our many missed deadlines and gave great feedback during the writing process.
We’d also like to thank our awesome copy editor, Andy Carroll, for catching an amaz-
ing number of grammatical errors in the early revisions of the book. The greater Man-
ning team deserves kudos as well; they’ve made for a very pleasant writing experience
over the past year and a half.
Big thanks to our team of reviewers, who provided invaluable feedback during var-
ious stages of the book’s development: Bruce Snyder, Charles Moulliard, Christophe
Avare, Christopher Hunt, Domingo Suarez Torres, Doug Tillman, Fintan Bolton, Gor-
don Dickens, Gregor Hohpe, Jeroen Benckhuijsen, John S. Griffon, Kevin Jackson,
Marco Ughetti, Martin Gilday, Martin Krasser, Michael Nash, Mick Knutson, Roman
Kalukiewicz, Tijs Rademakers, and Willem Jiang.

Special thanks to Willem Jiang for being our technical proofreader, catching those
bugs we missed, and helping improve the source code for the book.
Thanks to Martin Krasser for contributing appendix E, which is all about using
Camel from the Akka project. We couldn’t think of a better person to write about
Camel and Akka.
We’d also like to thank Hadrian Zbarcea for getting this book project started—who
knows when this book would have been written or by whom if he hadn’t gotten us
together!
We’d like to thank Gregor Hohpe and James Strachan for writing the forewords to
our book. Gregor’s book, Enterprise Integration Patterns, has been one of our favorite

www.it-ebooks.info
ACKNOWLEDGMENTS
xxiv
tech books for years now, so it’s an honor to have Gregor on board to write the fore-
word. Without the EIP book, Apache Camel would look a lot different than it does
today, if it existed at all.
In our opinion, James is an inspiration to many developers out there—including
us. He has co-founded tons of successful open source projects; Camel is just one of
them. If James and the other Apache Camel co-founders had not decided to create
Camel, we wouldn’t be writing this book. So, again, thanks!
Finally, we’d like to give a big warm thank you to the community. Without the com-
munity, the Apache Camel project wouldn’t be as successful as it is today. In fact, with-
out the success, both of us would have different kinds of jobs today, which wouldn’t
involve hacking on Camel all day along.
CLAUS
I would like to thank my beautiful wife, Christina, for her understanding of the long
hours I needed to spend during evenings and weekends working on the book. Knowing
that you would never let my hand go, that the family life is safe and secure, is exactly the
support any writer needs in taking up such a big challenge as writing a book.

A warm thank you goes to our dog, Bambi , wh o pa tie ntl y sl eep s in my office, and occa-
sionally wakes up and politely “asks” me for a break and a walk. I must admit many of
the ideas and thoughts behind this book came to me during my walks with Bambi.
JON
I would like to thank my amazing wife, Lisa, for the patience, support, and encourage-
ment I needed throughout the writing of this book. It simply would not have hap-
pened if it wasn’t for you. To Georgia, my beautiful daughter: thank you for cheering
me up when the writing got the better of me. I love you both!

www.it-ebooks.info