Backend interview prep

Start

Spring Cloud OpenFeign Interview Questions and Answers

Master Spring Cloud OpenFeign with interview questions covering declarative REST clients, FeignClient, load balancing, request interceptors, error handling, retries, timeouts, authentication, and production best practices.

Spring Cloud OpenFeign Interview Questions and Answers

Introduction

Microservices constantly communicate with each other.

For example:

  • Customer Service calls Account Service.
  • Payment Service calls Notification Service.
  • Loan Service calls Credit Score Service.

Using RestTemplate or WebClient for every service call results in repetitive boilerplate code.

Spring Cloud OpenFeign solves this problem by providing declarative REST clients.

Developers simply define a Java interface, and Spring automatically generates the HTTP client implementation.

OpenFeign integrates seamlessly with:

  • Eureka
  • Spring Cloud LoadBalancer
  • Spring Security
  • Resilience4j
  • Micrometer
  • Spring Cloud Gateway

OpenFeign Architecture

flowchart LR

CustomerService --> OpenFeign

OpenFeign --> LoadBalancer

LoadBalancer --> Eureka

Eureka --> PaymentService1

Eureka --> PaymentService2

PaymentService1 --> PostgreSQL

Q1. What is OpenFeign?

Answer

OpenFeign is a declarative REST client for Spring Cloud.

Instead of writing HTTP client code manually,

developers define an interface.

Example

@FeignClient(
name = "payment-service")

public interface PaymentClient {

    @GetMapping("/payments/{id}")

    PaymentDTO findById(
            @PathVariable Long id);

}

Spring automatically generates the implementation.

Benefits

  • Less boilerplate
  • Easy integration
  • Service discovery support
  • Better maintainability

Q2. Why use OpenFeign?

Without OpenFeign

RestTemplate

↓

Build URL

↓

Create Headers

↓

Handle Errors

↓

Deserialize Response

With OpenFeign

Java Interface

↓

Automatic HTTP Client

Advantages

  • Cleaner code
  • Better readability
  • Easy testing
  • Declarative programming

Q3. How does OpenFeign work?

Startup Process

  1. Spring scans @FeignClient.
  2. Creates a dynamic proxy.
  3. Looks up the service using Eureka.
  4. Selects an instance using Spring Cloud LoadBalancer.
  5. Sends the HTTP request.

Request Flow

sequenceDiagram
Customer Service->>OpenFeign: findPayment()
OpenFeign->>Eureka: Locate payment-service
Eureka-->>OpenFeign: Service Instance
OpenFeign->>LoadBalancer: Select Instance
LoadBalancer->>Payment Service: HTTP Request
Payment Service-->>OpenFeign: JSON Response
OpenFeign-->>Customer Service: DTO

Q4. How do you configure a Feign Client?

Dependency

<dependency>

<groupId>

org.springframework.cloud

</groupId>

<artifactId>

spring-cloud-starter-openfeign

</artifactId>

</dependency>

Enable Feign

@EnableFeignClients

@SpringBootApplication

public class Application{

}

Example

@FeignClient(
name="customer-service")

Q5. How does OpenFeign integrate with Eureka?

Instead of specifying an IP address,

use the registered service name.

Example

@FeignClient(
name="payment-service")

Discovery Flow

flowchart LR

FeignClient --> Eureka

Eureka --> PaymentService1

Eureka --> PaymentService2

PaymentService1 --> Response

No hardcoded URLs are required.

Q6. How does Load Balancing work with Feign?

If multiple service instances exist,

Spring Cloud LoadBalancer selects one.

Example

Payment Service

↓

8081

↓

8082

↓

8083

Load Balancer

flowchart LR

OpenFeign --> LoadBalancer

LoadBalancer --> Instance1

LoadBalancer --> Instance2

LoadBalancer --> Instance3

Requests are distributed among healthy instances.

Q7. How do you handle errors in OpenFeign?

Implement a custom ErrorDecoder.

Example

public class

FeignErrorDecoder

implements ErrorDecoder{

}

Typical handling

  • 400 Bad Request
  • 401 Unauthorized
  • 404 Not Found
  • 500 Internal Server Error

You can also integrate with Resilience4j for retries and circuit breakers.

Q8. How do you add authentication headers?

Use a RequestInterceptor.

Example

@Bean

RequestInterceptor

requestInterceptor(){

    return template ->

        template.header(

        "Authorization",

        "Bearer token");

}

Authentication Flow

flowchart LR

OpenFeign --> RequestInterceptor

RequestInterceptor --> JWTHeader

JWTHeader --> TargetService

This is commonly used to propagate OAuth2/JWT tokens.

Q9. How do you configure timeouts?

Example

spring:

  cloud:

    openfeign:

      client:

        config:

          default:

            connectTimeout: 3000

            readTimeout: 5000

Benefits

  • Faster failure detection
  • Better resilience
  • Prevents thread starvation

Timeouts should always be configured in production.

Q10. OpenFeign Best Practices

Use Service Names

Never hardcode URLs.

Configure Timeouts

Avoid indefinitely waiting requests.

Implement Retries Carefully

Retry only idempotent operations.

Use Circuit Breakers

Integrate with Resilience4j.

Propagate Trace IDs

Support distributed tracing.

Banking Example

flowchart TD

CustomerService --> OpenFeign

OpenFeign --> PaymentService

PaymentService --> PostgreSQL

OpenFeign --> Resilience4j

OpenFeign --> MicrometerTracing

Feign integrates with resilience and observability components.

Common Interview Questions

  • What is OpenFeign?
  • Why use OpenFeign?
  • How does OpenFeign work?
  • How does Feign integrate with Eureka?
  • How does load balancing work?
  • What is a RequestInterceptor?
  • How do you handle Feign errors?
  • How do you configure timeouts?
  • OpenFeign vs RestTemplate?
  • OpenFeign best practices?

Quick Revision

Topic Summary
OpenFeign Declarative REST client
@FeignClient Defines remote service
Eureka Service discovery
LoadBalancer Select service instance
RequestInterceptor Add request headers
ErrorDecoder Handle HTTP errors
Timeout Prevent long waits
JWT Authentication propagation
Resilience4j Retry & circuit breaker
Micrometer Distributed tracing support

OpenFeign Request Lifecycle

sequenceDiagram
Customer Service->>Feign Client: findPayment()
Feign Client->>Eureka: Locate payment-service
Eureka-->>Feign Client: Available Instances
Feign Client->>LoadBalancer: Choose Instance
LoadBalancer->>Payment Service: HTTP Request
Payment Service-->>Feign Client: JSON Response
Feign Client-->>Customer Service: DTO

Production Example – Banking Payment Platform

A banking platform contains:

  • Customer Service
  • Account Service
  • Payment Service
  • Notification Service

Flow

  • Customer Service calls Payment Service using OpenFeign.
  • Eureka discovers three Payment Service instances.
  • Spring Cloud LoadBalancer selects one healthy instance.
  • A RequestInterceptor propagates the JWT token and Trace ID.
  • Resilience4j applies timeout, retry, and circuit breaker policies.
  • Micrometer Tracing captures the entire request flow.
  • Prometheus collects request metrics.
flowchart LR

CustomerService --> OpenFeign

OpenFeign --> LoadBalancer

LoadBalancer --> PaymentService1

LoadBalancer --> PaymentService2

LoadBalancer --> PaymentService3

OpenFeign --> RequestInterceptor

RequestInterceptor --> JWT

OpenFeign --> Resilience4j

OpenFeign --> MicrometerTracing

PaymentService1 --> PostgreSQL

This architecture provides resilient, observable, and scalable service-to-service communication.

Key Takeaways

  • OpenFeign is a declarative HTTP client that simplifies REST communication between Spring Cloud microservices.
  • @FeignClient automatically generates client implementations, eliminating repetitive HTTP code.
  • OpenFeign integrates seamlessly with Eureka for service discovery and Spring Cloud LoadBalancer for client-side load balancing.
  • RequestInterceptor is commonly used to propagate authentication tokens, trace IDs, and custom headers.
  • Configure connection and read timeouts to improve resilience and prevent blocked threads.
  • Integrate OpenFeign with Resilience4j for retries, circuit breakers, and fallback mechanisms.
  • OpenFeign works naturally with Micrometer Tracing, enabling distributed request tracing across multiple services.
  • Following these practices results in maintainable, resilient, and production-ready microservice communication.