«

SpringCloud项目中Feign组件添加请求头所遇到的坑如何解决

时间:2024-5-20 08:53     作者:韩俊     分类: Java


本文小编为大家详细介绍“SpringCloud项目中Feign组件添加请求头所遇到的坑如何解决”,内容详细,步骤清晰,细节处理妥当,希望这篇“SpringCloud项目中Feign组件添加请求头所遇到的坑如何解决”文章能帮助大家解决疑惑,下面跟着小编的思路慢慢深入,一起来学习新知识吧。

    前言

    在spring cloud的项目中用到了feign组件,简单配置过后即可完成请求的调用。

    又因为有向请求添加Header头的需求,查阅了官方示例后,就觉得很简单,然后一顿操作之后调试报错...

    按官方修改的示例:

    #MidServerClient.java
    import feign.Param;
    import org.springframework.cloud.openfeign.FeignClient;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestMethod;
    
    @FeignClient(value = "edu-mid-server")
    public interface MidServerClient {
    
        @RequestMapping(value = "/test/header", method = RequestMethod.GET)
        @Headers({"userInfo:{userInfo}"})
        Object headerTest(@Param("userInfo") String userInfo);
    }

    提示错误:

    java.lang.IllegalArgumentException: method GET must not have a request body.

    分析

    通过断点debug发现feign发请求时把userInfo参数当成了requestBody来处理,而okhttp3会检测get请求不允许有body(其他类型的请求哪怕不报错,但因为不是设置到请求头,依然不满足需求)。

    查阅官方文档里是通过Contract(Feign.Contract.Default)来解析注解的:

    Feign annotations define the Contract between the interface and how the underlying client should work. Feign's default contract defines the following annotations:

    AnnotationInterface TargetUsage
    @RequestLineMethodDefines the HttpMethod and UriTemplate for request. Expressions, values wrapped in curly-braces {expression} are resolved using their corresponding @Param annotated parameters.
    @ParamParameterDefines a template variable, whose value will be used to resolve the corresponding template Expression, by name.
    @HeadersMethod, TypeDefines a HeaderTemplate; a variation on a UriTemplate. that uses @Param annotated values to resolve the corresponding Expressions. When used on a Type, the template will be applied to every request. When used on a Method, the template will apply only to the annotated method.
    @QueryMapParameterDefines a Map of name-value pairs, or POJO, to expand into a query string.
    @HeaderMapParameterDefines a Map of name-value pairs, to expand into Http Headers
    @BodyMethodDefines a Template, similar to a UriTemplate and HeaderTemplate, that uses @Param annotated values to resolve the corresponding Expressions.

    从自动配置类找到使用的是spring cloud的SpringMvcContract(用来解析@RequestMapping相关的注解),而这个注解并不会处理解析上面列的注解

    @Configuration
    public class FeignClientsConfiguration {
        ···
        @Bean
        @ConditionalOnMissingBean
        public Contract feignContract(ConversionService feignConversionService) {
            return new SpringMvcContract(this.parameterProcessors, feignConversionService);
        }
        ···

    解决

    原因找到了

    spring cloud使用了自己的SpringMvcContract来解析注解,导致默认的注解解析方式失效。

    解决方案自然就是重新解析处理feign的注解,这里通过自定义Contract继承SpringMvcContract再把Feign.Contract.Default解析逻辑般过来即可(重载的方法是在SpringMvcContract基础上做进一步解析,否则Feign对RequestMapping相关对注解解析会失效)

    代码如下(此处只对@Headers、@Param重新做了解析):

    #FeignCustomContract.java
    
    import feign.Headers;
    import feign.MethodMetadata;
    import feign.Param;
    import org.springframework.cloud.openfeign.AnnotatedParameterProcessor;
    import org.springframework.cloud.openfeign.support.SpringMvcContract;
    import org.springframework.core.convert.ConversionService;
    
    import java.lang.annotation.Annotation;
    import java.lang.reflect.Method;
    import java.util.*;
    
    import static feign.Util.checkState;
    import static feign.Util.emptyToNull;
    
    public class FeignCustomContract extends SpringMvcContract {
    
        public FeignCustomContract(List<AnnotatedParameterProcessor> annotatedParameterProcessors, ConversionService conversionService) {
            super(annotatedParameterProcessors, conversionService);
        }
    
        @Override
        protected void processAnnotationOnMethod(MethodMetadata data, Annotation methodAnnotation, Method method) {
            //解析mvc的注解
            super.processAnnotationOnMethod(data, methodAnnotation, method);
            //解析feign的headers注解
            Class<? extends Annotation> annotationType = methodAnnotation.annotationType();
            if (annotationType == Headers.class) {
                String[] headersOnMethod = Headers.class.cast(methodAnnotation).value();
                checkState(headersOnMethod.length > 0, "Headers annotation was empty on method %s.", method.getName());
                data.template().headers(toMap(headersOnMethod));
            }
        }
    
        @Override
        protected boolean processAnnotationsOnParameter(MethodMetadata data, Annotation[] annotations, int paramIndex) {
            boolean isMvcHttpAnnotation = super.processAnnotationsOnParameter(data, annotations, paramIndex);
    
            boolean isFeignHttpAnnotation = false;
            for (Annotation annotation : annotations) {
                Class<? extends Annotation> annotationType = annotation.annotationType();
                if (annotationType == Param.class) {
                    Param paramAnnotation = (Param) annotation;
                    String name = paramAnnotation.value();
                    checkState(emptyToNull(name) != null, "Param annotation was empty on param %s.", paramIndex);
                    nameParam(data, name, paramIndex);
                    isFeignHttpAnnotation = true;
                    if (!data.template().hasRequestVariable(name)) {
                        data.formParams().add(name);
                    }
                }
            }
            return isMvcHttpAnnotation || isFeignHttpAnnotation;
    
        }
    
        private static Map<String, Collection<String>> toMap(String[] input) {
            Map<String, Collection<String>> result =
                    new LinkedHashMap<String, Collection<String>>(input.length);
            for (String header : input) {
                int colon = header.indexOf(':');
                String name = header.substring(0, colon);
                if (!result.containsKey(name)) {
                    result.put(name, new ArrayList<String>(1));
                }
                result.get(name).add(header.substring(colon + 1).trim());
            }
            return result;
        }
    }
    #FeignCustomConfiguration.java
    
    import feign.Contract;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
    import org.springframework.cloud.openfeign.AnnotatedParameterProcessor;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.core.convert.ConversionService;
    
    import java.util.ArrayList;
    import java.util.List;
    
    @Configuration
    public class FeignCustomConfiguration {
    
        ···
        @Autowired(required = false)
        private List<AnnotatedParameterProcessor> parameterProcessors = new ArrayList<>();
    
        @Bean
        @ConditionalOnProperty(name = "feign.feign-custom-contract", havingValue = "true", matchIfMissing = true)
        public Contract feignContract(ConversionService feignConversionService) {
            return new FeignCustomContract(this.parameterProcessors, feignConversionService);
        }
        ···

    改完马上进行新一顿的操作, 看请求日志已经设置成功,响应OK!:

    请求:{"type":"OKHTTP_REQ","uri":"/test/header","httpMethod":"GET","header":"{"accept":["/"],"userinfo":["{"userId":"sssss","phone":"13544445678],"x-b3-parentspanid":["e49c55484f6c19af"],"x-b3-sampled":["0"],"x-b3-spanid":["1d131b4ccd08d964"],"x-b3-traceid":["9405ce71a13d8289"]}","param":""}

    响应{"type":"OKHTTP_RESP","uri":"/test/header","respStatus":0,"status":200,"time":5,"header":"{"cache-control":["no-cache,no-store,max-age=0,must-revalidate"],"connection":["keep-alive"],"content-length":["191"],"content-type":["application/json;charset=UTF-8"],"date":["Fri,11Oct201913:02:41GMT"],"expires":["0"],"pragma":["no-cache"],"x-content-type-options":["nosniff"],"x-frame-options":["DENY"],"x-xss-protection":["1;mode=block"]}"}

    标签: java spring

    热门推荐