In distributed architectures, service dependencies create complex interaction networks where component failures can cascade through the system. When a service becomes unresponsive, client services may experience thread blocking during remote calls. This single point of failure can exhaust thread pools, propagating through dependency chains and ultimately causing system-wide unavailability—a phenomenon known as the avalanche effect. Circuit breakers provide a defensive mechanism against such cascading failures.

Netflix's Hystrix implements a circuit breaker pattern that isolates service access points and provides fallback mechanisms to enhance distributed system resilience. The circuit breaker transitions through three states: closed (normal operation), open (fast failure), and half-open (recovery testing).

When failure rates remain below a configured threshold, the circuit stays closed. Exceeding this threshold triggers the open state, where requests immediately execute fallback logic instead of the primary operation. After a cooldown period, the circuit enters half-open state, allowing limited requests to test service recovery. Successful responses close the circuit; failures reopen it, enabling self-healing capabilities.

Hystrix Integration with RestTemplate and Ribbon

Starting with an existing Ribbon configuration, add Hystrix support to your service client.

Update pom.xml with Hystrix dependency:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>

Enable circuit breaking in the main application class:

@SpringBootApplication
@EnableHystrix
public class ConsumerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ConsumerApplication.class, args);
    }
}

Implement the service layer with fallback logic:

@Service
public class RemoteService {
    private final RestTemplate restTemplate;
    
    @Autowired
    public RemoteService(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }
    
    @HystrixCommand(fallbackMethod = "retrieveFallback")
    public String retrieveData(String input) {
        return restTemplate.getForObject(
            "http://data-service/process?param=" + input, 
            String.class
        );
    }
    
    public String retrieveFallback(String input) {
        return "Service unavailable: " + input;
    }
}

Configure load-balanced RestTemplate:

@Configuration
public class ClientConfig {
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

Controller implementation:

@RestController
public class DataController {
    private final RemoteService remoteService;
    
    @Autowired
    public DataController(RemoteService remoteService) {
        this.remoteService = remoteService;
    }
    
    @GetMapping("/data")
    public String getData(@RequestParam(defaultValue = "default") String value) {
        return remoteService.retrieveData(value);
    }
}

Hystrix with Feign Clients

Feign includes Hystrix by default—simply enable it in configuration:

feign:
  hystrix:
    enabled: true

Define the Feign interface with fallback implementation:

@FeignClient(value = "processor-service", fallback = ProcessorFallback.class)
public interface ProcessorClient {
    @GetMapping("/compute")
    String compute(@RequestParam("input") String input);
}

@Component
public class ProcessorFallback implements ProcessorClient {
    @Override
    public String compute(String input) {
        return "Computation failed for: " + input;
    }
}

Service layer integration:

@Service
public class BusinessService {
    private final ProcessorClient client;
    
    @Autowired
    public BusinessService(ProcessorClient client) {
        this.client = client;
    }
    
    public String processValue(String value) {
        return client.compute(value);
    }
}

Hystrix Dashboard Monitoring

Add monitoring dependencies to your service:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
</dependency>

Enable monitoring in application class:

@SpringBootApplication
@EnableHystrix
@EnableHystrixDashboard
public class MonitoredApplication {
    public static void main(String[] args) {
        SpringApplication.run(MonitoredApplication.class, args);
    }
}

Configure actuator endpoints in application.yml:

management:
  endpoints:
    web:
      exposure:
        include: hystrix.stream,health,info

Aggregated Monitoring with Turbine

Create a monitoring service to aggregate Hystrix metrics:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-turbine</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
</dependency>

Configuration for turbine aggregation:

spring:
  application:
    name: turbine-monitor
    
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/
      
turbine:
  app-config: service-one,service-two
  cluster-name-expression: "default"
  aggregator:
    cluster-config: default

Main class with Turbine and Dashboard enabled:

@SpringBootApplication
@EnableTurbine
@EnableHystrixDashboard
public class TurbineApplication {
    public static void main(String[] args) {
        SpringApplication.run(TurbineApplication.class, args);
    }
}

Access the aggregated dashboard at http://localhost:8769/turbine.stream after starting Eureka servers, client services, and the monitoring service.