பார்வை உங்கள் microservice அழைப்புகளை Circuit Breaker மாதிரி பயன்படுத்தி பாதுகாப்பான செய்ய எப்படி அறிய மற்றும் முழுமையான டெமோ, step-by-step commands, class-by-class explanations, sample outputs, real-world use cases, and production tips. Resilience4j Spring Boot Why This Matters ஏன் இது பொருந்தும் இதன் காரணமாக, கீழே விழுந்த விற்பனையாளர்கள் தங்களது விற்பனையை முழுமையாக மாற்ற முடியும். மாஸ்டர் : Circuit Breaker 
 
 
 
 
 அநியாயமான அறுவை சிகிச்சை, அவ்வாறு பணிபுரிவதற்கான முயற்சிகள் நடந்து வருகின்றன. ஒரு அழகான பதிலை திரும்பப் பெறுகிறது, சராசரியாக அறுவை சிகிச்சை மற்றும் சரியான நேரத்தில் சராசரி செயல்பாடு திரும்பும். இவ்வாறு வடிவமைப்பு நேரத்தை குறைக்கிறது, thread pools பாதுகாக்கிறது, user experience reasonable, and prevents retry storms. Demo Summary (What You Have) Demo Summary (நீங்கள் என்ன வேண்டும்) இரண்டு வகையான Maven Demo: 
 
 
 
  (port  ) — simple REST provider that intentionally fails intermittently. hello-service 8081 முடிவு Point GET /api/hello
 
 
 
 
  (port  ) — calls hello-service using RestTemplate and is protected by   with a fallback. client-service 8080 Resilience4j @CircuitBreaker முடிவு Point GET /api/get-message
 இவை இரண்டும் ( ) hello-service and client-service பிறகு Test GET http://localhost:8080/api/get-message
 Architecture அட்டவணை இது ஒரு சிறிய, கவனம் செலுத்தும் விளைவு, ஒரு டிரைவியை ஓவியம் செய்ய சரியானது. Files & Code: Class-By-Class Explanation Files & Code: Class-by-Class விளக்கம் hello-service ஹோட்டல் சேவை.java 
 
 
 
 Standard   bootstrap class. @SpringBootApplication HelloController.java

@RestController
public class HelloController {

    private static int counter = 0;

    @GetMapping("/api/hello")
    public String sayHello() {
        counter++;
        // simulate intermittent failure: fail on every 3rd request
        if (counter % 3 == 0) {
            throw new RuntimeException("Simulated failure from Hello-Service!");
        }
        return "Hello from Hello-Service! (count=" + counter + ")";
    }
}
 இந்த கட்டுப்பாட்டு நிர்ணயமாக ஒரு RuntimeException உள்நுழைவு அழைப்புகள் நீங்கள் உண்மையான அமைப்புகள் (DB விழிப்புணர்வு, மோசமான தரவுகள், timeouts) நீங்கள் காணும் விரைவான விழிப்புணர்வுகளை மாற்றுகிறது. Explanation: client-service அலுவலகப் பணியாளர்கள்.java 
 
 Standard Spring Boot main class. No special config required. AppConfig.java
@Configuration
public class AppConfig {
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}
 RestTemplate என்பது ஒரு Spring bean ஆகும், அதனால் AOP/resilience proxies சரியாக வேலை செய்ய முடியும். Explanation: HelloClientService.java
@Service
public class HelloClientService {

    private final RestTemplate restTemplate;

    @Value("${hello.service.url}")
    private String helloServiceUrl;

    public HelloClientService(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    @CircuitBreaker(name = "helloService", fallbackMethod = "fallbackHello")
    public String getHelloMessage() {
        System.out.println("Calling hello service: " + helloServiceUrl);
        return restTemplate.getForObject(helloServiceUrl, String.class);
    }

    public String fallbackHello(Throwable t) {
        System.out.println("Fallback triggered: " + t);
        return "Hello Service is currently unavailable. Please try again later.";
    }
}
 Explanation (crucial bits) 
 
 
 
 
 
 @CircuitBreaker(name = "helloService", fallbackMethod = "fallbackHello") wraps the getHelloMessage() call in a circuit breaker. The name links to configuration properties. 
 
 
 
 fallbackHello(Throwable t) is called when the call fails according to the breaker rules. The fallback must:     o    Be in the same class

    o    Have the same return type

    o   Accept the original method parameters (none here) and a final Throwable parameter (or Exception/Throwable compatible with thrown exceptions)
 
 
 Important: The method must be public, and the class must be a Spring bean (@Service), so proxy-based AOP works. ClientController.java
@RestController
public class ClientController {

    private final HelloClientService helloClientService;

    public ClientController(HelloClientService helloClientService) {
        this.helloClientService = helloClientService;
    }

    @GetMapping("/api/get-message")
    public String getMessage() {
        return helloClientService.getHelloMessage();
    }
}
 ஒலிப்பதிவுகள் கிடைக்க பெறும்Delegate to இதன் மூலம் தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி Explanation: HelloClientService Configuration Used (client-service application.properties) பயன்படுத்தப்பட்ட அமைப்பு (client-service application.properties) Demo இல் பயன்படுத்தப்பட்ட Key Configuration server.port=8080
spring.application.name=client-service

hello.service.url=http://localhost:8081/api/hello

resilience4j.circuitbreaker.instances.helloService.registerHealthIndicator=true
resilience4j.circuitbreaker.instances.helloService.slidingWindowSize=5
resilience4j.circuitbreaker.instances.helloService.minimumNumberOfCalls=2
resilience4j.circuitbreaker.instances.helloService.failureRateThreshold=50
resilience4j.circuitbreaker.instances.helloService.waitDurationInOpenState=10s

logging.level.io.github.resilience4j.circuitbreaker=DEBUG
 Meaning of important properties 
 
 
 
 
 
 SlidingWindowSize: தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி தொலைபேசி MinimumNumberOfCalls: Minimum calls before failure rate is evaluated. failureRateThreshold: சராசரி திறக்கத் தவறுகள் சதவீதம் (e.g., 50) எவ்வளவு காலம் திறந்தாலும், எவ்வளவு காலம் திறந்தாலும், எவ்வளவு காலம் திறந்தாலும். அணுகுமுறையை அணுகுதல்: அணுகுமுறையை அணுகுமுறையை அணுகுமுறையை Step-By-Step Run & Expected Outputs விண்ணப்பங்கள் முதல் சேவை 
 
 முதலீடு Hello-Service Visit: http://localhost:8081/api/hello
 → “Hello from Hello-Service!” (or throws simulated failure) Returns 
 
 Customer Service முதலீடு Visit: http://localhost:8080/api/get-message
 Test Scenarios & Outputs Test Scenarios & Outputs படங்கள் Scenario A — Hello-Service Healthy ஒரு அழைப்பு GET http://localhost:8080/api/get-message
 வாடிக்கையாளர்கள் logs Calling hello service: http://localhost:8081/api/hello
2025-11-13T11:58:23.366+05:30 DEBUG 32692 --- [client-service] [nio-8080-exec-8] i.g.r.c.i.CircuitBreakerStateMachine : CircuitBreaker 'helloService' succeeded:
2025-11-13T11:58:23.366+05:30 DEBUG 32692 --- [client-service] [nio-8080-exec-8] i.g.r.c.i.CircuitBreakerStateMachine : Event SUCCESS published: 2025-11-13T11:58:23.366634+05:30[Asia/Calcutta]: CircuitBreaker 'helloService' recorded a successful call. Elapsed time: 15 ms
 Response Hello from Hello-Service! (count=4)
 Scenario B — Hello-Service Intermittent Failures நீங்கள் பல முறை அழைத்தால் மற்றும் ஹலோ சேவை விழுந்தால் சில அழைப்புகள் : RuntimeException ● வெற்றிகரமான அழைப்புகள்: வாடிக்கையாளர் ஹலோ அனுப்பும். ஒரு downstream அழைப்பு HTTP 500/exception திரும்பும் போது:             o    Resilience4j records the failure.

            o    If failure rate exceeds threshold (e.g., 50% over sliding window), the Circuit becomes **OPEN**.

            o    While OPEN, calls are short-circuited; **fallbackHello**() is immediately executed — no network call. \n                       **Client response while fallback active**
 Client Response while active Response Hello Service is currently unavailable. Please try again later.
 Sample client log sequence Calling hello service: http://localhost:8081/api/hello
2025-11-13T12:00:55.842+05:30 DEBUG 32692 --- [client-service] [nio-8080-exec-1] i.g.r.c.i.CircuitBreakerStateMachine : CircuitBreaker 'helloService' recorded an exception as failure:
 Scenario C — Recovery பிறகு   எதிர்நோக்கல் 10 சதவீதம் : எதிர்நோக்கல் 
 
 
 
 சுற்றுப்புறம் HALF_OPEN செல்லும்: சில சோதனை அழைப்புகள் அனுமதிக்கப்படுகின்றன. சோதனை அழைப்புகள் வெற்றிகரமாக இருந்தால், அணுகுமுறை மூடப்படும் மற்றும் சாதாரண பயணத்தை மீண்டும் தொடங்குகிறது. சோதனைகள் தவறவிட்டால், சுட்டி திறந்து திரும்பும். Real-World Use Cases உண்மையான உலகளாவிய பயன்பாடு 
 
 
 
 
 Payment Integration - A checkout service calling an external bank API: if the bank's API becomes slow/fails, the circuit breaker returns a user-friendly message and prevents retry storms. 3rd-party rate-limited APIs - APIs with limited calls per second - when limits are reached, the circuit opens to avoid hitting quotas further; fallback returns cached data. Microservice chains within an enterprise - Service A calls B, which calls C. If C is unstable, open breakers protect B and A, preventing system-wide slowdown. ஆங்கிலத்தில் இதை Single Orgasm, Multiple Orgasm என்றும் கூறுகிறார்கள். Advantages & Business Value நன்மைகள் & Business Value 
 
 
 
 
 
 
 Fault isolation - one bad dependence from cascading - ஒரு தீவிர அறுவை சிகிச்சை தடுமாறி விடுகிறது. எதிர்காலத்தில் எதிர்காலம் எதிர்காலம் எதிர்காலம் எதிர்காலம் எதிர்காலம் எதிர்காலம் எதிர்காலம் எதிர்காலம் எதிர்காலம் ரஹ்மானுக்கு எதிரான தீவிரவாத நடவடிக்கைகள், தீவிரவாத நடவடிக்கைகளை எதிர்கொள்ளும். Resource Protection - CPU, Threads, மற்றும் Network இன் செலவுகளை தவிர்க்கவும். Auto recovery - சரியான மருந்தாக இருந்தால் சரியான மருந்தாகிவிடும். Observability - breaker states and metrics can be exposed via the Actuator மற்றும் கண்காணிக்கப்படும். Sample logs you’ll see (realistic) Calling hello service: http://localhost:8081/api/hello
2025-11-13T12:00:55.842+05:30 DEBUG 32692 --- [client-service] [nio-8080-exec-1] i.g.r.c.i.CircuitBreakerStateMachine : CircuitBreaker 'helloService' recorded an exception as failure
2025-11-13T12:00:55.847+05:30 DEBUG 32692 --- [client-service] [nio-8080-exec-1] i.g.r.c.i.CircuitBreakerStateMachine : Event ERROR published: 2025-11-13T12:00:55.847908200+05:30[Asia/Calcutta]: CircuitBreaker 'helloService' recorded an error: 'org.springframework.web.client.HttpServerErrorException$InternalServerError: 500 : "{"timestamp":"2025-11-13T06:30:55.842+00:00","status":500,"error":"Internal Server Error","path":"/api/hello"}"'. Elapsed time: 8 ms
Fallback triggered: org.springframework.web.client.HttpServerErrorException$InternalServerError: 500 : "{"timestamp":"2025-11-13T06:30:55.842+00:00","status":500,"error":"Internal Server Error","path":"/api/hello"}"


Read My Stories

இந்த ஆடியோ கதையின் அசல் மொழியில் தயாரிக்கப்பட்டது!

How to Build Resilient APIs with Resilience4j Circuit Breaker in Spring Boot இன் விளைவுகளை உருவாக்குவது எப்படி

About Author

கருத்துகள்

ஹேங் டேக்குகள்

இந்த கட்டுரையில் வழங்கப்பட்டது

Related Stories

Meet Hubstaff: HackerNoon Company of the Week

Meet Tailscale: HackerNoon Company of the Week

Meet Brave: HackerNoon Company of the Week

Meet Hubstaff: HackerNoon Company of the Week

Meet Tailscale: HackerNoon Company of the Week

Meet Brave: HackerNoon Company of the Week

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps