Over a million developers have joined DZone.

Create Resilient Camel Applications With Hystrix

DZone 's Guide to

Create Resilient Camel Applications With Hystrix

Find out how to use Hystrix with Apache Camel to easily implement the Circuit Breaker pattern in your integrated Java applications.

· Integration Zone ·
Free Resource

(This post was originally published on Red Hat Developers, the community to learn, code, and share faster. To read the original post, click here.) 

Apache Camel is a mature integration library (over 9 years old now) that implements all the patterns from the Enterprise Integration Patterns book. But Camel is not only an EIP implementation library, it is a modern framework that constantly evolves, adds new patterns, and adapts to the changes in the industry. Apart from tens of connectors added in each release, Camel also goes hand-in-hand with the new features provided by the new versions of Java language itself and other Java frameworks. With time some architectural styles such as SOA and ESB lose attraction and new architectural styles such as REST and Microservices get popular. To enable developers do integrations using these new trends, Camel responds by adding new DSLs such the REST DSL and new patterns such as the Circuit Breaker, and components such as Spring Boot. And that's not all and we are nowhere near done. With technologies such as Docker containers and Kubernetes, the IT industry is moving forward even faster now, and Camel is evolving too in order to ease the developers as it always has been. To get an idea of kinda tools you would need to develop and run applications on Docker and Kubernetes, check out the Fabric8 project and specifically tools such as the Docker Maven plugin, Kubernetes CDI extension, Kubernetes Java client, Arquilian tests for Kubernetes, etc. Exciting times ahead with lot's of cool technologies, so let's have a look at one of those: Camel and the Hystrix based circuit breaker.

Two Circuit Breakers in Camel, Which One to Choose?

Two years ago, when I first read Release It from Michael Nygard, I couldn't stop myself implementing the Circuit Breaker pattern in Camel. Usually I drive my contributions by real customer needs, but Circuit Breaker pattern is so elegant, I had to do it. To implement it in a non-intrusive manner, I have added it as a Camel Load Balancer strategy. Here's how simple it is:

<camelContext id="camel" xmlns="http://camel.apache.org/schema/spring">
    <from uri="direct:start"/>
        <circuitBreaker threshold="2" halfOpenAfter="1000">
        <to uri="mock:result"/>

The DSL above is self-describing: if the number of MyCustomExceptions thrown by the mock:result endpoint reaches the threshold number, the CircuitBreaker goes to the open state and starts rejecting all requests. After 1000ms it moves to the halfOpenAfter state and the result of the first request in this state will define its next state as closed or open. It is the simplest possible implementation of the CircuitBreaker you can imagine, but still useful.

Since then, the Microservices architecture has become more popular, and so has the Circuit Breaker Pattern and its Java implementation Hystrix. At some point Raúl Kripalani started the Hystrix implementation in Camel and put all the ground work in place, but with time it lost momentum. Then seeing the same request again and again from different customers, I took the relay and continued the work and pushed to Camel a Hystrix component. Seeing the feedback from the community, it still didn't feel as elegant as it could be. Then Claus stepped in and made Hystrix part of the Camel DSL by turning it into an EIP (rather than component). So how does it look to create a Hystrix based Circuit Breaker in Camel now?

public class ClientRoute extends RouteBuilder {

    public void configure() {
            .log(" Client request: ${body}")
            // use onFallback() to provide a repsonse message immediately
            // use onFallbackViaNetwork() when there is a 2nd service call
            .log("Client response: ${body}");

In the example above, you can see only very few of the available options for a Circuit Breaker, to see all of them checkout the offical documents and try out the example application Claus put in place. Based on this example you may think that Hystrix is part of Camel core, but it is not. Camel core is still this light and without dependencies to third party libraries. If you want to use the Hystrix-based Circuit Breaker, you need to add camel-hystrix dependency to your dependencies as it is with any other non-core component and make it available at runtime.

Fail Fast, Fallback, Bulkhead, Timeout and More

The Hystrix library implements more than the Circuit Breaker pattern. It also does bulkheading, request caching, timeouts, request collapsing, etc. The implementation in Camel does not support request collapsing and caching as these are done using other patterns and components available in Camel already. Request collapsing in Camel can be done using Aggregator EIP and caching can be done using cache components such as Redis, Inifinspan, Hazelcast, etc. The Hystrix DSL in Camel offers around 30 configuration options supported by Hystrix, also exposes metrics over JMX and/or REST for the Hystrix Dashboard.

As a final note, don't foget that to create a truly resilient application, you need more than Hystrix. Hystrix will do bulkheading at thread pool level, but that is not enough if you don't apply the same principle at process, host and phisical machine level. To create a create a resilient distributed system, you will need to use also Retry, Throttling, Timeout... and other good practices, some of which I have described in the Camel Design Patterns book.

To get some hands on feeling of the new pattern, check the example and then start defending your Camel based Microservices with Hystrix.

camel ,circuit breaker ,hystrix

Published at DZone with permission of

Opinions expressed by DZone contributors are their own.

{{ parent.title || parent.header.title}}

{{ parent.tldr }}

{{ parent.urlSource.name }}