Comprehensive Guide to Using OpenFeign in Spring Cloud: Setup, Configuration, and Advanced Features

1. Introduction

Hello, I am Wukong. This article introduces the service‑calling component OpenFeign, a more powerful successor to Ribbon and Feign.

2. What is Feign?

Feign simplifies Java HTTP client development by allowing developers to define an interface with annotations instead of manually using RestTemplate. It integrates Ribbon for load‑balancing but is no longer actively maintained.

3. What is OpenFeign?

OpenFeign builds on Feign and adds support for Spring MVC annotations such as @RequestMapping. The @FeignClient annotation can parse these mappings and generate a dynamic proxy that performs load‑balanced service calls.

Official documentation: https://docs.spring.io/spring-cloud-openfeign/docs/2.2.10.BUILD-SNAPSHOT/reference/html

4. Differences Between Feign and OpenFeign

Feign

OpenFeign

Lightweight RESTful HTTP client with built‑in Ribbon for load balancing.

Extends Feign to support Spring MVC annotations and generates implementations via dynamic proxies.

5. Environment Preparation

The Spring Cloud version, JDK, and project setup are the same as the previous Nacos tutorial. Nacos is used as the service registry and configuration center instead of Eureka.

Project structure:

Register services in Nacos: Produce (provider) and Consumer (consumer).

6. Create Service Provider

Create module openFeign-provider9005 and register it in Nacos with the following configuration:

server:
  port: 9005
spring:
  application:
    name: openFeign-provider
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
management:
  endpoints:
    web:
      exposure:
        include: '*'

Note: The spring.application.name is used by OpenFeign to locate the provider.

7. Create Service Consumer

Create module openFeign-consumer9006 and add dependencies:

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

Enable OpenFeign in the main class with @EnableFeignClients:

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

Define the OpenFeign interface:

@FeignClient(value = "openFeign-provider")
public interface OpenFeignService {
}

Note: The value attribute specifies the service name registered in Nacos.

Create a controller to test the interface:

@RestController
@RequestMapping("/openfeign")
public class OpenFeignController {
    // implementation omitted for brevity
}

8. Parameter Passing in OpenFeign

OpenFeign supports several parameter passing styles:

JSON body using @RequestBody.

POJO form parameters with @SpringQueryMap.

Path variables using @PathVariable.

Traditional form parameters with @RequestParam.

Examples for each style are provided in the source code sections.

9. Timeout Handling

OpenFeign’s default timeouts are 10 seconds (connect) and 60 seconds (read), but Ribbon’s defaults (1 second) override them if not explicitly set. You can configure timeouts either globally or per service in application.yml:

# Ribbon timeout (not recommended)
ribbon:
  ReadTimeout: 5000
  ConnectTimeout: 5000

# OpenFeign timeout (recommended)
feign:
  client:
    config:
      default:
        connectTimeout: 5000
        readTimeout: 5000
      serviceC:
        connectTimeout: 30000
        readTimeout: 30000

Note: Service‑specific configuration overrides the global settings.

10. Enabling Log Enhancement

OpenFeign’s logging levels are NONE, BASIC, HEADERS, and FULL. Configure a logger bean and set the desired level in application.yml:

logging:
  level:
    cn.myjszl.service: debug

When set to FULL, request and response bodies are logged.

11. Replacing the Default HTTP Client

By default OpenFeign uses JDK URLConnection. To replace it with Apache HttpClient, add the following dependencies:

<!-- Use Apache HttpClient -->
<dependency>
  <groupId>org.apache.httpcomponents</groupId>
  <artifactId>httpclient</artifactId>
</dependency>
<dependency>
  <groupId>io.github.openfeign</groupId>
  <artifactId>feign-httpclient</artifactId>
</dependency>

Enable it in configuration:

feign:
  client:
    httpclient:
      enabled: true

Verification can be done by inspecting FeignSyncMethodHandler#executeAndDecode() which will show the Apache client being used.

12. Communication Optimization with GZIP

OpenFeign can compress request and response bodies using GZIP. Enable it in application.yml:

feign:
  compression:
    request:
      enabled: true
      min-request-size: 10
      mime-types: text/xml,application/xml,application/json
    response:
      enabled: true

After enabling, the request header will contain Accept-Encoding: gzip and responses will be decompressed automatically.

13. Circuit Breaking and Fallback

OpenFeign integrates with Sentinel for circuit breaking. Add the Sentinel starter dependency and enable it:

<!-- Sentinel dependency -->
<dependency>
  <groupId>com.alibaba.cloud</groupId>
  <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>

feign:
  sentinel:
    enabled: true

Create a fallback class that implements the same interface and reference it via the fallback attribute of @FeignClient:

@FeignClient(value = "openFeign-provider", fallback = OpenFeignFallbackService.class)
public interface OpenFeignService {
    // methods
}

When the provider throws an exception, the fallback implementation is invoked, demonstrating successful degradation.