【SpringBoot】通过Feign调用传递Header中参数

本文介绍如何在Spring Cloud Feign中实现Header参数的传递。通过自定义RequestInterceptor接口的实现,确保了调用远程服务时能正确携带Header信息,特别针对authorization参数进行了详细说明。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

1、问题描述

我们在SpringCloud中使用Feign请求另一个服务的Api接口时,有将Header中参数传递下去的需求,如果不做特殊处理,就会将Header中的参数丢失。

2、解决方案

通过实现 RequestInterceptor 接口

(1)、首先,自定义实现RequestInterceptor接口的apply方法,如下

package com.shareworx.auth.security.feign;

import feign.Logger;
import feign.RequestInterceptor;
import feign.RequestTemplate;
import feign.codec.Encoder;
import feign.form.spring.SpringFormEncoder;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.ObjectFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.http.HttpMessageConverters;
import org.springframework.cloud.openfeign.support.SpringEncoder;
import org.springframework.context.annotation.Bean;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

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

public class CommonFeignConfiguration implements RequestInterceptor {


    @Override
    public void apply(RequestTemplate template) {
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder
                .getRequestAttributes();
        if (attributes != null) {
            HttpServletRequest request = attributes.getRequest();
            Enumeration<String> headerNames = request.getHeaderNames();
            if (headerNames != null) {
                while (headerNames.hasMoreElements()) {
                    String name = headerNames.nextElement();
                    String values = request.getHeader(name);
                    if (StringUtils.isNotBlank(values) && "authorization".equals(name.toLowerCase())) {
                        template.header(name, values);
                    }
                }
            }
        }
    }

    /**
     * 配置Feign日志级别
     * @return
     */
    @Bean
    Logger.Level feignLoggerLevel(){
        return Logger.Level.FULL;
    }
    @Autowired
    private ObjectFactory<HttpMessageConverters> messageConverters;

    @Bean
    public Encoder feignFormEncoder() {
        return new SpringFormEncoder(new SpringEncoder(messageConverters));
    }
}

我这边在项目上遇到的只需要传递"authorization"参数,因此多加了一个条件判断

if(StringUtils.isNotBlank(values)&&"authorization".equals(name.toLowerCase())){
        template.header(name,values);
        }

(2)、然后将自定义的配置类配置到Feign中,就可以实现该Feign中接口Header参数的传递

package com.shareworx.auth.security.feign;

import com.shareworx.auth.security.fallback.SecurityBaseUserFeignServiceFallbackFactory;
import com.shareworx.auth.shiro.model.BaseProjectVO;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;


@FeignClient(contextId = "SecurityHoProjectInitFeignService", name = "xx-server",configuration = CommonFeignConfiguration.class)
public interface SecurityHoProjectInitFeignService {

}

<think>我们被要求解释Feign调用的详细代码实现和执行逻辑。根据引用[1][2][3],Feign通过动态代理和注解处理实现远程调用。我们将分步骤解释其实现原理和代码逻辑。 1. **定义Feign客户端接口**:使用`@FeignClient`注解声明一个接口,该接口的方法通过Spring MVC注解(如`@RequestMapping`)来描述远程调用的细节。 2. **动态代理生成**:在Spring应用启动时,Feign会为这些接口创建动态代理对象。当我们调用接口方法时,实际上是调用代理对象的方法。 3. **请求构造**:代理对象将方法名、参数、注解等信息转换成HTTP请求。 4. **HTTP请求发送**:通过底层的HTTP客户端(如OkHttp或HttpClient)发送HTTP请求。 5. **响应处理**:将HTTP响应反序列化为方法的返回值。 下面通过一个代码示例逐步解析: ### 1. 定义Feign客户端接口 ```java @FeignClient(name = "user-service", url = "http://localhost:8080") public interface UserService { @GetMapping("/users/{id}") User getUserById(@PathVariable("id") Long id); } ``` - `@FeignClient`指定了服务名称(用于服务发现)或直接指定URL(如引用[4]所示,可用于调用第三方接口)。 - 方法上的注解`@GetMapping`和`@PathVariable`定义了HTTP请求的细节。 ### 2. Feign动态代理生成原理 在Spring启动时,通过`@EnableFeignClients`开启Feign客户端扫描。Feign会为每个带有`@FeignClient`的接口生成代理对象,并注册为Spring Bean。生成代理的核心类是`FeignClientFactoryBean`。 ### 3. 请求构造与执行(核心逻辑) 当调用`getUserById`方法时,动态代理会执行以下步骤(以`ReflectiveFeign`为例,引用[3]): ```java // 伪代码展示代理调用过程 public Object invoke(Object proxy, Method method, Object[] args) { // 1. 根据方法生成RequestTemplate(包含请求URL、参数、方法类型等) RequestTemplate template = buildTemplateFromArgs(method, args); // 2. 应用拦截器(如引用[5]提到的请求头处理) for (RequestInterceptor interceptor : interceptors) { interceptor.apply(template); } // 3. 发送HTTP请求 Response response = client.execute(template, options); // 4. 处理响应,反序列化为返回值类型 return decode(response, method.getReturnType()); } ``` ### 4. 底层HTTP客户端 Feign默认使用`Client`接口发送请求,默认实现是`Client.Default`(基于`HttpURLConnection`)。但可以替换为OkHttp、Apache HttpClient等(通过配置)。 ### 5. 负载均衡 如果使用了服务发现(如Nacos),Feign会整合Ribbon实现客户端负载均衡(引用[4]中设置URL的方式是直接调用,不经过服务发现)。负载均衡在`Client`层实现,具体由`LoadBalancerFeignClient`处理。 ### 6. 异常处理与熔断 引用[5]提到,Feign可与Hystrix集成实现熔断。当方法调用失败(如超时或异常)时,会触发熔断机制,执行回退逻辑(通过`fallback`属性指定)。 ### 完整代码示例 ```java // 启动类 @SpringBootApplication @EnableFeignClients public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } } // Feign客户端 @FeignClient(name = "user-service", fallback = UserServiceFallback.class) public interface UserService { @GetMapping("/users/{id}") User getUserById(@PathVariable("id") Long id); } // 熔断回退实现 @Component public class UserServiceFallback implements UserService { @Override public User getUserById(Long id) { return new User(0L, "default"); // 默认用户 } } // 使用Feign客户端 @Service public class BusinessService { @Autowired private UserService userService; // 注入Feign代理 public void doBusiness(Long userId) { User user = userService.getUserById(userId); // 远程调用 // ... 业务逻辑 } } ``` ### 执行流程图 ```mermaid sequenceDiagram participant A as 业务代码 participant P as Feign代理 participant I as 拦截器 participant C as HTTP Client participant S as 远程服务 A->>P: 调用getUserById(1) P->>P: 构建RequestTemplate loop 拦截器链 P->>I: 应用拦截器(添加请求头等) end P->>C: 发送HTTP请求 C->>S: 请求GET /users/1 S-->>C: 返回响应 C-->>P: 封装Response P->>P: 解码响应(JSON->User) P-->>A: 返回User对象 ``` ### 关键点总结 1. **动态代理**:Feign的核心,将方法调用转化为HTTP请求。 2. **注解驱动**:通过注解配置请求参数,简化开发。 3. **模块化设计**:拦截器、编解码器、HTTP客户端均可定制。 4. **集成能力**:与Ribbon、Hystrix等组件无缝协作。 --- §§ 相关问题 1. Feign如何实现服务发现与负载均衡? 2. 如何自定义Feign的请求拦截器? 3. Feign与OpenFeign有什么区别? 4. 如何配置Feign的超时时间和重试机制? 5. Feign调用时如何传递请求头? [^1]: [微服务---feign调用服务](https://example.com/feign-intro) [^2]: [Feign 调用接口跟调用本地方法一样,这个是怎么实现的?](https://example.com/feign-principle) [^3]: [Feign远程调用的底层方法逻辑](https://example.com/feign-debug) [^4]: [Feign调用第三方接口并实现负载均衡](https://example.com/feign-third-party) [^5]: [Feign远程调用丢失请求头](https://example.com/feign-header-loss)</think>### Feign调用详细代码实现及执行逻辑解析 Feign通过动态代理和注解处理实现远程调用,核心流程如下: #### 1. **定义Feign客户端接口** ```java @FeignClient(name = "user-service", url = "http://api.example.com", fallback = UserServiceFallback.class) public interface UserService { @GetMapping("/users/{id}") User getUserById(@PathVariable("id") Long id); @PostMapping("/users") User createUser(@RequestBody User user); } ``` - `@FeignClient`:声明Feign客户端,`name`指定服务名,`url`定义目标地址(引用[4]) - 方法注解:使用Spring MVC注解定义HTTP请求细节(引用[2]) #### 2. **动态代理生成(核心机制)** 当Spring容器启动时: ```java // 伪代码展示代理创建过程 public class FeignClientFactoryBean { public Object getObject() { // 1. 创建方法处理器映射 Map<Method, MethodHandler> handlers = new HashMap<>(); for (Method method : targetType.getMethods()) { handlers.put(method, new Contract.BaseContract().parseAndValidateMetadata(method)); } // 2. 创建动态代理 return Proxy.newProxyInstance( targetType.getClassLoader(), new Class<?>[] {targetType}, new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) { // 将方法调用转换为HTTP请求(引用[2][3]) return dispatch.get(method).invoke(args); } } ); } } ``` 动态代理是Feign的核心机制(引用[2]),运行时生成接口代理对象,将方法调用转换为HTTP请求。 #### 3. **HTTP请求构造流程** ```mermaid sequenceDiagram participant A as 业务代码 participant P as Feign代理 participant H as 方法处理器 participant C as HTTP客户端 A->>P: 调用getUserById(123) P->>H: 查找方法处理器 H->>H: 解析注解信息 H->>H: 构建RequestTemplate H->>C: 生成HTTP请求 C->>C: 添加负载均衡(引用[4]) C->>C: 应用拦截器(引用[5]) C->>远程服务: 发送请求 远程服务-->>C: 返回响应 C-->>H: HTTP响应 H-->>P: 反序列化结果 P-->>A: 返回User对象 ``` #### 4. **关键组件解析** 1. **Contract**:解析接口方法上的注解(如`@GetMapping`),生成元数据 2. **Encoder/Decoder**:处理请求/响应的序列化 ```java // 自定义编码器示例 public class JacksonEncoder implements Encoder { @Override public void encode(Object object, Type bodyType, RequestTemplate template) { template.body(objectMapper.writeValueAsBytes(object)); } } ``` 3. **负载均衡**:整合Ribbon实现 ```java // 伪代码:负载均衡选择 Server server = loadBalancer.chooseServer("user-service"); String url = "http://" + server.getHost() + ":" + server.getPort(); ``` 4. **拦截器**:处理认证、日志等(引用[5]) ```java public class AuthInterceptor implements RequestInterceptor { @Override public void apply(RequestTemplate template) { template.header("Authorization", "Bearer xxx"); } } ``` #### 5. **异常处理机制** ```java // 熔断回退实现(引用[5]) @Component public class UserServiceFallback implements UserService { @Override public User getUserById(Long id) { return new User().setName("Fallback User"); } } ``` - 当远程调用失败或超时时,触发熔断回退 - 需配置`feign.hystrix.enabled=true` #### 6. **完整执行时序** 1. 代理对象接收方法调用 2. 解析方法注解生成RequestTemplate 3. 应用拦截器修改请求(添加header等) 4. 负载均衡选择目标实例 5. 编码器序列化请求体 6. HTTP客户端发送请求 7. 接收响应并反序列化 8. 处理错误或返回结果 > 通过DEBUG可观察到`ReflectiveFeign.FeignInvocationHandler`处理调用(引用[3]),实际HTTP请求由底层客户端如`OkHttpClient`或`HttpURLConnection`完成。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值