1. Background and concept
In microservice architecture, communication between services is one of the key issues. There are usually two common communication methods:
- HTTP-based REST communication: The HTTP protocol is used between services, and HTTP requests are usually made using RestTemplate or OkHttp.
- RPC-based remote calls: Through remote procedure calls (RPC), such as gRPC.
In order to simplify REST calls between microservices, Spring Cloud providesFeignAs a declarative HTTP client, it replaces handwritten HTTP request logic. Feign is a tool that simplifies service calls. It makes remote calls more intuitive and simple through declarative interface definitions and annotations.
2. Features of Feign
- Declarative call: Define service calls through interfaces and annotations, avoiding handwriting a large amount of HTTP client code.
- Combined with Ribbon:Feign can be combined with Ribbon to achieve client load balancing.
- Combined with Hystrix:Feign can be integrated with Hystrix to achieve fault-tolerant processing such as circuit breaker and downgrade.
- Combined with Eureka:Feign can be combined with Eureka service discovery mechanism to dynamically select service instances through service names.
3. Introduction and configuration of Feign
In order to use Feign, you first need to introduce corresponding dependencies in the Spring Boot project and make some configuration.
3.1. Introducing dependencies
existIntroduce Spring Cloud Feign-related dependencies into the file.
<dependency>
<groupId></groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
Note: If the project is based on Spring Cloud, Feign is usually built into Spring Cloud, just introducespring-cloud-dependenciesJust do it.
3.2. Enable Feign
To enable Feign client support, you need to use it in the startup class of Spring Boot@EnableFeignClientsAnnotation.
@SpringBootApplication
@EnableFeignClients // Enable Feign clientpublic class FeignApplication {
public static void main(String[] args) {
(, args);
}
}
3.3. Configuration file (optional)
Can be inorSome Feign configurations are performed in the file, such as timeout time, log level, etc.
feign:
client:
config:
default:
connectTimeout: 5000 # Connection timeout readTimeout: 5000 # Read timeout httpclient:
enabled: true # Enable HttpClient as the underlying implementation of Feignlogging:
level:
: DEBUG # Set the log level to DEBUG4. Define Feign client interface
The core of using Feign is to declare calls to remote services through interfaces. Feign will generate a specific HTTP request based on this interface.
4.1. Define the service interface
For example, suppose we have a user serviceuser-service, the service provides an API for querying user information:
@FeignClient(name = "user-service", url = "http://localhost:8081") // Define Feign Clientpublic interface UserClient {
@GetMapping("/users/{id}")
User getUserById(@PathVariable("id") Long id);
}
-
@FeignClient: Define Feign client,
nameSpecify the name of the client,urlis the basic URL of the service. If integrated with service discovery systems such as Eureka,urlCan be omitted. - @GetMapping: Specify the HTTP method to GET and define the request path.
-
@PathVariable: Change variables in the path
{id}Map as method parameters.
4.2. Define the data model
In order to receive data returned by the server, we need to define a user model.User：
public class User {
private Long id;
private String name;
private String email;
// getters and setters
}
4.3. Using Feign Client
Where user services need to be called, you can injectUserClientInterface, and then use it directly to initiate the request:
@RestController
@RequestMapping("/orders")
public class OrderController {
@Autowired
private UserClient userClient;
@GetMapping("/{id}/user")
public User getUserByOrderId(@PathVariable("id") Long orderId) {
// Call user service through Feign User user = (orderId);
return user;
}
}
here()The call will automatically generate HTTP requests through Feign and initiate calls without the need to hand-written complex HTTP client code.
5. Feign integrated load balancing and service discovery
5.1. Integrate Eureka Service Discovery
If the project integrates Eureka as the service discovery component, Feign can automatically discover services through the service name without specifyingurl. At this time, you only need to@FeignClientjust specify the service name.
@FeignClient(name = "user-service") // Get the service address through Eureka service discoverypublic interface UserClient {
@GetMapping("/users/{id}")
User getUserById(@PathVariable("id") Long id);
}
Eureka will automaticallyuser-serviceSelect the appropriate instance and Feign is responsible for communicating with the instance.
5.2. Load balancing
Feign integrates Ribbon as the client's load balancer by default. When called through the service name, Ribbon selects available service instances based on the configuration. Can be inThe load balancing strategy configured in Ribbon:
ribbon:
eureka:
enabled: true # Enable integration with Eureka NFLoadBalancerRuleClassName: # Load balancing policy, polling5.3. Customize Feign configuration
You can customize Feign's behavior by configuring the class. For example, custom timeout, retry mechanism, or log configuration:
@Configuration
public class FeignConfig {
@Bean
public options() {
return new (5000, 10000); // Set connection timeout and read timeout }
@Bean
public feignLoggerLevel() {
return ; // Set the log level to FULL }
}
Then in@FeignClientSpecify the configuration class in :
@FeignClient(name = "user-service", configuration = )
public interface UserClient {
@GetMapping("/users/{id}")
User getUserById(@PathVariable("id") Long id);
}
6. Feign downgrade processing (Hystrix integration)
In a microservice environment, remote calls may fail or timeout. To address these issues, Feign can be integrated with Hystrix to provide fuse and downgrade capabilities.
6.1. Enable Hystrix
existEnable Hystrix:
feign:
hystrix:
enabled: true # Enable Feign's Hystrix downgrade6.2. Define the downgrade logic
You can@FeignClientPassedfallbackThe parameter specifies the downgrade class. When the service call fails, Hystrix will execute the downgrade logic:
@FeignClient(name = "user-service", fallback = )
public interface UserClient {
@GetMapping("/users/{id}")
User getUserById(@PathVariable("id") Long id);
}
// Define the downgrade class@Component
public class UserClientFallback implements UserClient {
@Override
public User getUserById(Long id) {
// Return the default user information User user = new User();
(id);
("Default User");
("default@");
return user;
}
}
7. Feign log configuration
Feign supports logging detailed logs of each request for debugging and monitoring. You canConfigure log level:
logging:
level:
: DEBUG # Enable DEBUG level log feign:
Logger: FULL # Record Feign's detailed log8. Complete example
Here is a complete Spring Boot application that integrates Feign and downgrades using Hystrix:
@SpringBootApplication
@EnableFeignClients
public class FeignApplication {
public static void main(String[] args) {
(, args);
}
}
@FeignClient(name = "user-service", fallback = )
public interface UserClient {
@GetMapping("/users/{id}")
User getUserById(@PathVariable("id") Long id);
}
@Component
public class UserClientFallback implements UserClient {
@Override
public User getUserById(Long id) {
User user = new User();
(id);
("Default User");
("default@");
return user;
}
}
@RestController
@RequestMapping("/orders")
public class OrderController {
@Autowired
private UserClient userClient;
@GetMapping("/{id}/user")
public User getUserByOrderId(@PathVariable("id") Long orderId) {
return (orderId);
}
}
9. Summary
Spring Boot Integration Feign provides a simple and efficient way to call REST services. Through Feign, developers only need to define interfaces and annotations to complete calls to remote services. Feign supports integration with a variety of components of the Spring Cloud ecosystem, such as Eureka, Ribbon, Hystrix, etc., making it very practical in microservice architectures.
This is the end of this article about the implementation example of springboot integration Feign. For more related springboot integration Feign content, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!