Feign高级特性详解

前置知识

在学习本教程之前，建议您已经：

• 了解 Feign 的基本使用方法
• 熟悉 Spring Cloud 的基本组件
• 掌握 Java 注解和接口设计

自定义配置

Feign 提供了丰富的自定义配置选项，可以根据业务需求进行灵活定制。

1. 全局配置与客户端特定配置

在 Spring Cloud 中，可以通过以下两种方式配置 Feign 客户端：

# application.yml - 全局配置
feign:
  client:
    config:
      default:  # 全局配置
        connectTimeout: 5000
        readTimeout: 5000
        loggerLevel: full
        errorDecoder: com.example.CustomErrorDecoder
        retryer: com.example.CustomRetryer
        requestInterceptors:
          - com.example.FeignTokenInterceptor
        decoder: com.example.ResponseDecoder
        encoder: com.example.RequestEncoder
        contract: com.example.CustomContract
      user-service:  # 特定客户端配置，优先级高于默认配置
        connectTimeout: 2000
        readTimeout: 2000
        loggerLevel: basic

2. Java 配置类方式

package com.example.feign.config;

import feign.Logger;
import feign.Request;
import feign.Retryer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

// 全局配置
@Configuration
public class GlobalFeignConfig {
    
    @Bean
    public Logger.Level feignLoggerLevel() {
        return Logger.Level.FULL;
    }
    
    @Bean
    public Request.Options options() {
        return new Request.Options(5000, 5000);
    }
    
    @Bean
    public Retryer retryer() {
        // 最大请求次数为3（初始请求 + 2次重试），初始等待时间为100ms，最大等待时间为1s
        return new Retryer.Default(100, 1000, 3);
    }
}

// 特定客户端配置
@Configuration
public class UserServiceFeignConfig {
    
    @Bean
    public Logger.Level feignLoggerLevel() {
        return Logger.Level.BASIC;
    }
    
    @Bean
    public Request.Options options() {
        return new Request.Options(2000, 2000);
    }
}

在 Feign 客户端上指定配置类：

@FeignClient(name = "user-service", configuration = UserServiceFeignConfig.class)
public interface UserClient {
    // 方法定义...
}

请求/响应压缩

Feign 支持对请求和响应进行 GZIP 压缩，可以有效减少网络传输数据量，提高性能。

1. 启用压缩

# application.yml
feign:
  compression:
    request:
      enabled: true
      mime-types: text/xml,application/xml,application/json
      min-request-size: 2048  # 最小压缩大小，默认2048字节
    response:
      enabled: true  # 启用响应压缩

2. 压缩效果测试

package com.example.feign.controller;

import com.example.feign.client.UserClient;
import com.example.feign.model.User;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.List;

@RestController
@RequestMapping("/api/compression")
@Slf4j
public class CompressionTestController {
    
    @Autowired
    private UserClient userClient;
    
    @PostMapping("/test")
    public String testCompression() {
        // 创建大量数据测试压缩效果
        List<User> users = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            users.add(new User((long) i, "user" + i, "user" + i + "@example.com"));
        }
        
        long startTime = System.currentTimeMillis();
        List<User> result = userClient.createBatchUsers(users);
        long endTime = System.currentTimeMillis();
        
        log.info("批量创建用户耗时: {}ms", endTime - startTime);
        return "成功创建 " + result.size() + " 个用户";
    }
}

超时控制

在微服务架构中，合理的超时控制对于系统稳定性至关重要。

1. 超时配置详解

// 方法一：配置文件方式
feign:
  client:
    config:
      default:
        connectTimeout: 5000  # 连接超时时间（毫秒）
        readTimeout: 5000     # 读取超时时间（毫秒）

// 方法二：Java配置类方式
@Bean
public Request.Options options() {
    // 第一个参数是连接超时时间，第二个参数是读取超时时间
    return new Request.Options(5000, 5000);
}

// 方法三：新版本的Java配置类方式（Spring Cloud 2020.0.0+）
@Bean
public Request.Options options() {
    return new Request.Options(
        5, TimeUnit.SECONDS,  // 连接超时
        5, TimeUnit.SECONDS,  // 读取超时
        true                  // 是否跟随重定向
    );
}

2. 超时异常处理

package com.example.feign.service;

import com.example.feign.client.UserClient;
import com.example.feign.model.User;
import feign.FeignException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
@Slf4j
public class UserService {
    
    @Autowired
    private UserClient userClient;
    
    public User getUserById(Long id) {
        try {
            return userClient.getUserById(id);
        } catch (FeignException.ConnectException e) {
            log.error("连接超时: {}", e.getMessage());
            // 返回默认用户或抛出自定义异常
            return new User(0L, "default-user", "default@example.com");
        } catch (FeignException.ReadTimeoutException e) {
            log.error("读取超时: {}", e.getMessage());
            // 返回默认用户或抛出自定义异常
            return new User(0L, "default-user", "default@example.com");
        } catch (FeignException e) {
            log.error("Feign调用异常: {}", e.getMessage());
            throw e;
        }
    }
}

重试机制

Feign 内置了重试机制，可以在请求失败时自动重试，提高系统的可用性。

1. 默认重试策略

默认情况下，Feign 使用 Retryer.Default 作为重试策略，它的规则是：

• 初始等待时间：100ms
• 最大等待时间：1s
• 最大重试次数：5次（包括初始请求）

2. 自定义重试策略

package com.example.feign.config;

import feign.Retryer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FeignRetryConfig {
    
    @Bean
    public Retryer retryer() {
        // 最大请求次数为3（初始请求 + 2次重试），初始等待时间为100ms，最大等待时间为1s
        return new Retryer.Default(100, 1000, 3);
    }
}

3. 禁用重试

// 方法一：配置文件方式
feign:
  client:
    config:
      default:
        retryer: feign.Retryer.NEVER_RETRY

// 方法二：Java配置类方式
@Bean
public Retryer retryer() {
    return Retryer.NEVER_RETRY;
}

日志配置

Feign 提供了详细的日志记录功能，可以帮助开发者调试和排查问题。

1. 日志级别详解

Feign 定义了四种日志级别：

• NONE：不记录任何日志（默认）
• BASIC：仅记录请求方法、URL、响应状态码及执行时间
• HEADERS：记录 BASIC 级别的基础上，记录请求和响应的 headers
• FULL：记录请求和响应的 headers、body 和元数据

2. 配置日志级别

// 方法一：配置文件方式
feign:
  client:
    config:
      default:
        loggerLevel: full
      user-service:
        loggerLevel: basic

// 方法二：Java配置类方式
@Bean
public Logger.Level feignLoggerLevel() {
    return Logger.Level.FULL;
}

3. 启用日志输出

在 application.properties 或 application.yml 中配置日志输出级别：

# 为特定的Feign客户端启用DEBUG级别日志
logging.level.com.example.feign.client.UserClient=DEBUG

# 为所有Feign客户端启用DEBUG级别日志
logging.level.feign=DEBUG

4. 自定义日志格式

package com.example.feign.config;

import feign.Logger;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class CustomFeignLogConfig {
    
    @Bean
    public Logger customFeignLogger() {
        return new CustomFeignLogger();
    }
    
    public class CustomFeignLogger extends Logger {
        @Override
        protected void log(String configKey, String format, Object... args) {
            // 自定义日志格式
            System.out.println(String.format("[FEIGN] %s - %s", configKey, String.format(format, args)));
        }
    }
}

拦截器实现

Feign 拦截器可以在请求发送前或响应接收后进行处理，常用于添加认证信息、请求头、日志记录等。

1. 请求拦截器

package com.example.feign.interceptor;

import feign.RequestInterceptor;
import feign.RequestTemplate;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

@Component
@Slf4j
public class FeignAuthInterceptor implements RequestInterceptor {
    
    @Override
    public void apply(RequestTemplate template) {
        // 添加认证头
        template.header("Authorization", "Bearer " + getToken());
        
        // 添加自定义头
        template.header("X-Custom-Header", "CustomValue");
        
        // 记录请求信息
        log.debug("Feign请求: {} {}", template.method(), template.url());
    }
    
    private String getToken() {
        // 获取token的逻辑，可以从上下文、缓存或安全上下文中获取
        return "your-token-here";
    }
}

2. 全局拦截器配置

// 方法一：配置文件方式
feign:
  client:
    config:
      default:
        requestInterceptors:
          - com.example.feign.interceptor.FeignAuthInterceptor
          - com.example.feign.interceptor.FeignLogInterceptor

// 方法二：Java配置类方式
@Configuration
public class FeignInterceptorConfig {
    
    @Bean
    public RequestInterceptor authInterceptor() {
        return new FeignAuthInterceptor();
    }
    
    @Bean
    public RequestInterceptor logInterceptor() {
        return new FeignLogInterceptor();
    }
}

3. 特定客户端拦截器

@FeignClient(name = "user-service", configuration = UserServiceFeignConfig.class)
public interface UserClient {
    // 方法定义...
}

@Configuration
public class UserServiceFeignConfig {
    
    @Bean
    public RequestInterceptor userServiceInterceptor() {
        return template -> {
            template.header("X-Service-Name", "user-service");
        };
    }
}

4. 动态拦截器示例

动态请求头拦截器

package com.example.feign.interceptor;

import feign.RequestInterceptor;
import feign.RequestTemplate;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.util.Enumeration;
import java.util.LinkedHashMap;
import java.util.Map;

@Component
public class FeignHeaderInterceptor implements RequestInterceptor {
    
    @Override
    public void apply(RequestTemplate template) {
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        if (attributes != null) {
            HttpServletRequest request = attributes.getRequest();
            Map<String, String> headers = getHeadersFromRequest(request);
            
            // 传递特定的请求头
            for (Map.Entry<String, String> entry : headers.entrySet()) {
                String headerName = entry.getKey();
                String headerValue = entry.getValue();
                
                // 只传递特定的请求头，如认证信息
                if (headerName.equalsIgnoreCase("Authorization") ||
                    headerName.equalsIgnoreCase("Content-Type") ||
                    headerName.startsWith("X-")) {
                    template.header(headerName, headerValue);
                }
            }
        }
    }
    
    private Map<String, String> getHeadersFromRequest(HttpServletRequest request) {
        Map<String, String> headers = new LinkedHashMap<>();
        Enumeration<String> headerNames = request.getHeaderNames();
        while (headerNames.hasMoreElements()) {
            String headerName = headerNames.nextElement();
            headers.put(headerName, request.getHeader(headerName));
        }
        return headers;
    }
}

错误处理

Feign 提供了灵活的错误处理机制，可以自定义错误解码器和异常处理逻辑。

1. 自定义错误解码器

package com.example.feign.config;

import com.example.feign.exception.BadRequestException;
import com.example.feign.exception.NotFoundException;
import com.example.feign.exception.ServerException;
import com.fasterxml.jackson.databind.ObjectMapper;
import feign.Response;
import feign.codec.ErrorDecoder;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.io.IOException;
import java.io.InputStream;

@Configuration
@Slf4j
public class FeignErrorDecoderConfig {
    
    @Bean
    public ErrorDecoder errorDecoder() {
        return new CustomErrorDecoder();
    }
    
    public class CustomErrorDecoder implements ErrorDecoder {
        private final ObjectMapper objectMapper = new ObjectMapper();
        
        @Override
        public Exception decode(String methodKey, Response response) {
            try {
                // 解析错误响应体
                String errorMessage = getErrorMessage(response);
                
                // 根据状态码返回不同的异常
                switch (response.status()) {
                    case 400:
                        return new BadRequestException(errorMessage);
                    case 404:
                        return new NotFoundException(errorMessage);
                    case 500:
                    case 503:
                        return new ServerException(errorMessage);
                    default:
                        return new Default().decode(methodKey, response);
                }
            } catch (IOException e) {
                log.error("解析错误响应失败", e);
                return new Default().decode(methodKey, response);
            }
        }
        
        private String getErrorMessage(Response response) throws IOException {
            try (InputStream bodyIs = response.body().asInputStream()) {
                // 尝试解析JSON响应
                try {
                    Map<String, Object> errorMap = objectMapper.readValue(bodyIs, Map.class);
                    if (errorMap.containsKey("message")) {
                        return (String) errorMap.get("message");
                    } else if (errorMap.containsKey("error")) {
                        return (String) errorMap.get("error");
                    }
                } catch (Exception e) {
                    // 如果不是JSON格式，直接返回响应体
                    return response.body().toString();
                }
                return "未知错误";
            }
        }
    }
}

2. 异常处理类

package com.example.feign.exception;

import lombok.Getter;

@Getter
public class FeignClientException extends RuntimeException {
    private final int status;
    
    public FeignClientException(String message, int status) {
        super(message);
        this.status = status;
    }
}

// 400 错误
@Getter
public class BadRequestException extends FeignClientException {
    public BadRequestException(String message) {
        super(message, 400);
    }
}

// 404 错误
@Getter
public class NotFoundException extends FeignClientException {
    public NotFoundException(String message) {
        super(message, 404);
    }
}

// 500 错误
@Getter
public class ServerException extends FeignClientException {
    public ServerException(String message) {
        super(message, 500);
    }
}

3. 全局异常处理

package com.example.feign.handler;

import com.example.feign.exception.BadRequestException;
import com.example.feign.exception.FeignClientException;
import com.example.feign.exception.NotFoundException;
import com.example.feign.exception.ServerException;
import feign.FeignException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

import java.util.HashMap;
import java.util.Map;

@RestControllerAdvice
@Slf4j
public class GlobalExceptionHandler {
    
    @ExceptionHandler(FeignClientException.class)
    public ResponseEntity<Map<String, Object>> handleFeignClientException(FeignClientException e) {
        log.error("Feign客户端异常: {}", e.getMessage());
        
        Map<String, Object> error = new HashMap<>();
        error.put("message", e.getMessage());
        error.put("status", e.getStatus());
        
        return ResponseEntity.status(e.getStatus()).body(error);
    }
    
    @ExceptionHandler(BadRequestException.class)
    public ResponseEntity<Map<String, Object>> handleBadRequestException(BadRequestException e) {
        return handleFeignClientException(e);
    }
    
    @ExceptionHandler(NotFoundException.class)
    public ResponseEntity<Map<String, Object>> handleNotFoundException(NotFoundException e) {
        return handleFeignClientException(e);
    }
    
    @ExceptionHandler(ServerException.class)
    public ResponseEntity<Map<String, Object>> handleServerException(ServerException e) {
        return handleFeignClientException(e);
    }
    
    @ExceptionHandler(FeignException.class)
    public ResponseEntity<Map<String, Object>> handleFeignException(FeignException e) {
        log.error("Feign异常: {}", e.getMessage());
        
        Map<String, Object> error = new HashMap<>();
        error.put("message", e.getMessage());
        error.put("status", e.status());
        
        return ResponseEntity.status(e.status()).body(error);
    }
}

总结

本文详细介绍了 Spring Cloud Feign 的高级特性，包括：

1. ✅ 自定义配置：全局配置与客户端特定配置
2. ✅ 请求/响应压缩：减少网络传输数据量
3. ✅ 超时控制：提高系统稳定性
4. ✅ 重试机制：自动重试失败请求
5. ✅ 日志配置：详细记录请求和响应信息
6. ✅ 拦截器实现：添加认证信息和自定义处理
7. ✅ 错误处理：自定义错误解码和异常处理

下一步学习

• 学习 Feign 与 Hystrix 的集成
• 了解 Feign 的性能优化技巧
• 探索 Feign 在微服务架构中的最佳实践