Camel in Action

Name: Camel in Action
Brand: Manning
Price: 53.96 EUR
Availability: OnlineOnly

Claus Ibsen Jonathan Anstey(Autor*in)

Manning (Verlag)

1. Auflage

Erschienen am 2. Februar 2018

912 Seiten

E-Book

ePUB mit Adobe-DRM

Systemvoraussetzungen

978-1-63835-280-8 (ISBN)

53,96 €inkl. 7% MwSt.

Systemvoraussetzungen

für ePUB mit Adobe-DRM

E-Book Einzellizenz

Als Download verfügbar

Beschreibung

Summary 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. Forewords by James Strachan and Dr. Mark Little Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications. 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 Author 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. Table of Contents

Part 1 - First steps

Meeting Camel
Routing with Camel

Part 2 - Core Camel

Transforming data with Camel
Using beans with Camel
Enterprise integration patterns
Using components

Part 3 - Developing and testing

Microservices
Developing Camel projects
Testing
RESTful web services

Part 4 - Going further with Camel

Error handling
Transactions and idempotency
Parallel processing
Securing Camel

Part 5 - Running and managing Camel

Running and deploying Camel
Management and monitoring

Part 6 - Out in the wild

Clustering
Microservices with Docker and Kubernetes
Camel tooling

Bonus online chapters Available at https://www.manning.com/books/camel-in-action-second-edition and in electronic versions of this book:

Reactive Camel
Camel and the IoT by Henryk Konsek

Weitere Details

Weitere Ausgaben

Personen

Inhalt

Intro
Camel in Action
Praise for the First Edition
Copyright
Dedication
Foreword
Foreword
Foreword to the First Edition
Preface
Acknowledgments
About This Book
Roadmap
Who should read this book
Code conventions
Source code downloads
Software requirements
Author Online
About the Authors
About the Cover Illustration
Part 1: First steps
Chapter 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
Chapter 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 RouteBuilder
2.3.2 Using 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
Chapter 3: Transforming data with Camel
3.1 Data transformation overview
3.2 Transforming data by 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.5 Transforming with templates
3.5.1 Using Apache Velocity
3.6 Understanding 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
Chapter 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 Understanding the Service Activator pattern
4.3 Using 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 Performing 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
Chapter 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 Using 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 Using 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
Chapter 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 Direct and Direct-VM
6.6.2 Asynchronous messaging with SEDA and VM
6.7 Automating tasks: Scheduler and Quartz2 components
6.7.1 Using the Scheduler component
6.7.2 Enterprise scheduling with Quartz
6.8 Working with email
6.8.1 Sending mail with SMTP
6.8.2 Receiving mail with IMAP
6.9 Summary and best practices
Part 3: Developing and testing
Chapter 7: Microservices
7.1 Microservices overview
7.1.1 Small in size
7.1.2 Observable
7.1.3 Designed for failure
7.1.4 Highly configurable
7.1.5 Smart endpoints and dumb pipes
7.1.6 Testable
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.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 the Retry pattern to handle failures
7.4.2 Using the 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 microservices with fault-tolerance
7.4.9 Using Camel Hystrix with Spring Boot
7.4.10 The Hystrix dashboard
7.5 Summary and best practices
Chapter 8: Developing Camel projects
8.1 Managing projects with Maven
8.1.1 Using Camel Maven archetypes
8.1.2 Using Maven to add Camel dependencies
8.2 Using Camel in Eclipse
8.2.1 Creating a new Camel project
8.3 Debugging an issue with your new Camel project
8.4 Developing custom components
8.4.1 Setting up a new Camel component
8.4.2 Diving into the implementation
8.5 Generating components with the API component framework
8.5.1 Generating the skeleton API project
8.5.2 Configuring the camel-api-component-maven-plugin
8.5.3 Setting advanced configuration options
8.5.4 Implementing remaining functionality
8.6 Developing data formats
8.6.1 Generating the skeleton data format project
8.6.2 Writing the custom data format
8.7 Summary and best practices
Chapter 9: Testing
9.1 Introducing the Camel Test Kit
9.1.1 Using 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, OSGi, 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 Swarm
9.2.7 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 arrives
9.3.4 Using expressions with mocks
9.3.5 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 adviceWith to amend routes
9.5 Camel integration testing
9.5.1 Performing 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 other testing libraries
9.7 Summary and best practices
Chapter 10: RESTful web services
10.1 RESTful services
10.1.1 Understanding the principles of a 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-restlet with REST services
10.1.5 Using camel-cxf with REST services
10.2 The Camel Rest DSL
10.2.1 Exploring a quick example of the Rest DSL
10.2.2 Understanding how the Rest DSL works
10.2.3 Using 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.2.6 Calling RESTful services using 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 the Swagger web console
10.4 Summary and best practices
Part 4: Going further with Camel
Chapter 11: Error handling
11.1 Understanding error handling
11.1.1 Recoverable and irrecoverable errors
11.1.2 Where Camel's error handling applies
11.2 Using error handlers in Camel
11.2.1 Using 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 DefaultErrorHandler with redelivery
11.3.4 Error handlers and scopes
11.3.5 Reusing context-scoped error handlers
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 Working with other error-handling features
11.5.1 Using onWhen
11.5.2 Using onExceptionOccurred
11.5.3 Using onRedeliver
11.5.4 Using retryWhile
11.6 Summary and best practices
Chapter 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 Understanding 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 Using different transaction propagations
12.3.6 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
Chapter 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 Using Camel thread pool profiles
13.2.3 Creating custom thread pools
13.2.4 Using ExecutorServiceManager
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 Using 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.5 Summary and best practices
Chapter 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.4.1 Defining global SSL configuration
14.5 Route authentication and authorization
14.5.1 Configuring Spring Security
14.6 Summary and best practices
Part 5 : Running and managing Camel
Chapter 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 the Control Bus EIP to start and stop routes at runtime
15.2.3 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 an OSGi 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.7 Summary and best practices
Chapter 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 Control Bus 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
Chapter 17: Clustering
17.1 Clustered HTTP
17.2 Clustered Camel routes
17.2.1 Active/passive mode
17.2.2 Active/active mode
17.2.3 Clustered active/passive mode using Hazelcast
17.2.4 Clustered active/passive mode using Consul
17.2.5 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 Clustered cache using JCache and Infinispan
17.6 Using clustered scheduling
17.6.1 Clustered scheduling using Quartz
17.7 Calling clustered services using the Service Call EIP
17.7.1 How the Service Call EIP works
17.7.2 Service Call using static service registry
17.7.3 Service Call with failover
17.7.4 Configuring Service Call EIP
17.7.5 Service Call URI templating
17.7.6 Service Call using Spring Boot Cloud and Consul
17.8 Summary and best practices
Chapter 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 a Docker image using the Docker Maven plugin
18.1.4 Running 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 Running applications using kubectl
18.3.2 Calling a service running inside a Kubernetes cluster
18.3.3 Running 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 by calling services in Kubernetes
18.6 Testing Camel microservices on Kubernetes
18.6.1 Setting up Arquillian Cube
18.6.2 Writing a basic unit test using Arquillian Cube
18.6.3 Running Arquillian Cube tests on Kubernetes
18.6.4 Writing a unit test that calls a Kubernetes service
18.7 Introducing fabric8, Helm, and OpenShift
18.7.1 fabric8
18.7.2 Kubernetes Helm
18.7.3 OpenShift
18.8 Summary and best practices
Chapter 19: Camel tooling
19.1 Camel editors
19.1.1 JBoss Fuse Tooling
19.1.2 Apache Camel IDEA plugin
19.1.3 Camel validation using Maven
19.2 Camel Catalog: the information goldmine
19.3 hawtio: a web console for Camel and Java applications
19.3.1 Understanding hawtio functionality
19.3.2 Debugging Camel routes using hawtio
19.4 Summary and best practices
Chapter 20: Reactive Camel
20.1 Using Reactive Streams with Camel
20.1.1 Reactive Streams API
20.1.2 Reactive flow control with back pressure
20.1.3 First steps with Reactive Streams
20.1.4 Using Camel with Reactive Streams
20.1.5 Controlling back pressure from the producer side
20.1.6 Controlling back pressure from the consumer side
20.2 Using Vert.x with Camel
20.2.1 Building a football 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
Chapter 21: Camel and the 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 the right choice for the IoT
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-data-center connectivity
21.4.1 Understanding the architecture
21.4.2 Choosing a protocol
21.5 Camel and Eclipse Kura
21.5.1 Starting Kura in emulator mode
21.5.2 Defining Camel routes using the Kura web UI
21.5.3 Next steps with Camel and Kura
21.6 Next steps with Camel and the IoT
LWM2M and the Eclipse Leshan project
Eclipse Hono
21.7 Summary
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
Summary
Appendix B: The Camel community
Apache Camel website
JIRA, mailing lists, Gitter, and IRC
Camel at GitHub
Camel at Stack Overflow
Commercial Camel offerings
Camel tooling
Camel-extra project
Becoming a Camel committer
Videos
Other resources
Index

Systemvoraussetzungen

Als PDF speichern Als Link merken