关于FeignClient的使用大全——进阶篇

转自：https://www.jianshu.com/p/50fd582b739f

关于FeignClient的基本使用，我在上一篇文章关于FeignClient的使用大全——使用篇已经介绍过了，大家可以先浏览一遍。
这一篇文章仍然是关于FeignClient，不过是进阶篇，我来讲讲如何定制自己期望的FeignClient。

1，FeignClient的实现原理

我们知道，想要开启FeignClient，首先要素就是添加@EnableFeignClients注解。其主要功能是初始化FeignClient的配置和动态执行client的请求。
我们看看EnableFeignClients的源代码，其核心是

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(FeignClientsRegistrar.class)
public @interface EnableFeignClients {

    /**
     * Alias for the {@link #basePackages()} attribute. Allows for more concise annotation
     * declarations e.g.: {@code @ComponentScan("org.my.pkg")} instead of
     * {@code @ComponentScan(basePackages="org.my.pkg")}.
     * @return the array of 'basePackages'.
     */
    String[] value() default {};

    /**
     * Base packages to scan for annotated components.
     * <p>
     * {@link #value()} is an alias for (and mutually exclusive with) this attribute.
     * <p>
     * Use {@link #basePackageClasses()} for a type-safe alternative to String-based
     * package names.
     * @return the array of 'basePackages'.
     */
    String[] basePackages() default {};

    /**
     * Type-safe alternative to {@link #basePackages()} for specifying the packages to
     * scan for annotated components. The package of each class specified will be scanned.
     * <p>
     * Consider creating a special no-op marker class or interface in each package that
     * serves no purpose other than being referenced by this attribute.
     * @return the array of 'basePackageClasses'.
     */
    Class<?>[] basePackageClasses() default {};

    /**
     * A custom <code>@Configuration</code> for all feign clients. Can contain override
     * <code>@Bean</code> definition for the pieces that make up the client, for instance
     * {@link feign.codec.Decoder}, {@link feign.codec.Encoder}, {@link feign.Contract}.
     *
     * @see FeignClientsConfiguration for the defaults
     * @return list of default configurations
     */
    Class<?>[] defaultConfiguration() default {};

    /**
     * List of classes annotated with @FeignClient. If not empty, disables classpath
     * scanning.
     * @return list of FeignClient classes
     */
    Class<?>[] clients() default {};

}

其中@Import(FeignClientsRegistrar.class)是用来初始化FeignClient配置的。我们接着看其代码，找到核心实现代码

    @Override
    public void registerBeanDefinitions(AnnotationMetadata metadata,
            BeanDefinitionRegistry registry) {
        registerDefaultConfiguration(metadata, registry);
        registerFeignClients(metadata, registry);
    }

其中，registerDefaultConfiguration(metadata, registry)是用来加载@EnableFeignClients中的defaultConfiguration和@FeignClient中的configuration配置文件。代码实现代码比较简单，不再细说。
registerFeignClients(metadata, registry)是用来加载@EnableFeignClients中的其他配和@FeignClient中的其他配置。这是该文章要说的重点。
我们找到下面的代码

    private void registerFeignClient(BeanDefinitionRegistry registry,
            AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
        String className = annotationMetadata.getClassName();
        BeanDefinitionBuilder definition = BeanDefinitionBuilder
                .genericBeanDefinition(FeignClientFactoryBean.class);
        validate(attributes);
        definition.addPropertyValue("url", getUrl(attributes));
        definition.addPropertyValue("path", getPath(attributes));
        String name = getName(attributes);
        definition.addPropertyValue("name", name);
        String contextId = getContextId(attributes);
        definition.addPropertyValue("contextId", contextId);
        definition.addPropertyValue("type", className);
        definition.addPropertyValue("decode404", attributes.get("decode404"));
        definition.addPropertyValue("fallback", attributes.get("fallback"));
        definition.addPropertyValue("fallbackFactory", attributes.get("fallbackFactory"));
        definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);

        String alias = contextId + "FeignClient";
        AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();

        boolean primary = (Boolean) attributes.get("primary"); // has a default, won't be
                                                                // null

        beanDefinition.setPrimary(primary);

        String qualifier = getQualifier(attributes);
        if (StringUtils.hasText(qualifier)) {
            alias = qualifier;
        }

        BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className,
                new String[] { alias });
        BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
    }

从其中可以看到，该初始化是对FeignClientFactoryBean的初始化，接着我们进入FeignClientFactoryBean的代码中

    protected Feign.Builder feign(FeignContext context) {
        FeignLoggerFactory loggerFactory = get(context, FeignLoggerFactory.class);
        Logger logger = loggerFactory.create(this.type);

        // @formatter:off
        Feign.Builder builder = get(context, Feign.Builder.class)
                // required values
                .logger(logger)
                .encoder(get(context, Encoder.class))
                .decoder(get(context, Decoder.class))
                .contract(get(context, Contract.class));
        // @formatter:on

        configureFeign(context, builder);

        return builder;
    }

该段代码就是动态实现FeignClient的基本逻辑，从这里可以看到，它实现了下面几个组件：Feign.Builder、logger、encoder、decoder和contract。
我们先继续看configureFeign(context, builder)的代码

    protected void configureFeign(FeignContext context, Feign.Builder builder) {
        FeignClientProperties properties = this.applicationContext
                .getBean(FeignClientProperties.class);
        if (properties != null) {
            if (properties.isDefaultToProperties()) {
                configureUsingConfiguration(context, builder);
                configureUsingProperties(
                        properties.getConfig().get(properties.getDefaultConfig()),
                        builder);
                configureUsingProperties(properties.getConfig().get(this.contextId),
                        builder);
            }
            else {
                configureUsingProperties(
                        properties.getConfig().get(properties.getDefaultConfig()),
                        builder);
                configureUsingProperties(properties.getConfig().get(this.contextId),
                        builder);
                configureUsingConfiguration(context, builder);
            }
        }
        else {
            configureUsingConfiguration(context, builder);
        }
    }

其中configureUsingConfiguration(...)是使用我们定义的属性去更新Feign.Builder；configureUsingProperties是用我们定义的default属性去更新Feign.Builder。
继续看configureUsingConfiguration(...)

    protected void configureUsingConfiguration(FeignContext context,
            Feign.Builder builder) {
        Logger.Level level = getOptional(context, Logger.Level.class);
        if (level != null) {
            builder.logLevel(level);
        }
        Retryer retryer = getOptional(context, Retryer.class);
        if (retryer != null) {
            builder.retryer(retryer);
        }
        ErrorDecoder errorDecoder = getOptional(context, ErrorDecoder.class);
        if (errorDecoder != null) {
            builder.errorDecoder(errorDecoder);
        }
        Request.Options options = getOptional(context, Request.Options.class);
        if (options != null) {
            builder.options(options);
        }
        Map<String, RequestInterceptor> requestInterceptors = context
                .getInstances(this.contextId, RequestInterceptor.class);
        if (requestInterceptors != null) {
            builder.requestInterceptors(requestInterceptors.values());
        }
        QueryMapEncoder queryMapEncoder = getOptional(context, QueryMapEncoder.class);
        if (queryMapEncoder != null) {
            builder.queryMapEncoder(queryMapEncoder);
        }
        if (this.decode404) {
            builder.decode404();
        }
    }

虽然使用了3次属性初始化，其实3次大体逻辑是一样的，只是所使用的context不一样而已。相关context的优先级顺序遵循如下规则：
当没定义FeignClientProperties对应的bean时，从全局context查找对属性；
当定义了FeignClientProperties对应的bean时：
如果defaultToProperties=true
先从全局context查找对应属性并且初始化；再从default的context中查找对应属性并且初始化；最后从当前配置的context中查找属性并且初始化。
也就是配置文件优先级顺序是：appConfig < defaultConfig < clientConfig。
如果defaultToProperties=false
先从default的context中查找对应属性并且初始化；在从当前配置的context中查找属性并且初始化；最后从全局context查找对应属性并且初始化。
也就是配置文件优先级顺序是：defaultConfig < clientConfig < appConfig 。
这段代码的逻辑是从对应的context中分别查找logLevel、retryer、errorDecoder、options、requestInterceptors、queryMapEncoder、decode404等组件，然后重新初始化Feign.Builder，从而达到定制FeignClient的目的。

2，FeignClient的功能定制

通过前面的分析，那我们想要定制自己需要的FeignClient就轻而易举了。我们以一下情况来举例说明：

2.1，使用Apache的Httpclient替换Ribbon/loadbalance配置：

有时候，我们的Feignclient没有启用注册中心，那我们就要启用FeignClient的url属性来标明被调用方。此时，启用Httpclient的连接池方式可能会比Ribbon的客户端loadbalance方式更好，那么，我们可以按照如下方式定制我们的FeignClient：

2.1.1，引入jar包

        <!-- apache httpclient -->
        <dependency>
            <groupId>io.github.openfeign</groupId>
            <artifactId>feign-httpclient</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpcore</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpmime</artifactId>
        </dependency>

相关版本号可自行根据自己的配置来定。

2.1.2，定义Apache的httpclient的bean

方案一，可以直接引入HttpClientFeignConfiguration；

 

引入HttpClientFeignConfiguration

方案二，可以参照HttpClientFeignConfiguration在自己的config里定义自己的httpClient；

2.1.3，根据httpclient定义Feign的ApacheHttpClient：

    @Bean
    @Primary
    public Client feignClient(HttpClient httpClient) {
        return new ApacheHttpClient(httpClient);
    }

2.1.4，定义Feign.Builder

 

Feign.Builder定义

其实，这个定义不是必须的，但是，我们为了避免其他的client对其影响，这样做可以确保正确。

2.2，支持文件上传配置：

httpclient默认启用的encoder是SpringEncoder，是不支持文件上传的，为了支持文件上传，我们需要如下定制：

2.2.1，引入jar包

        <!-- 解决Feign的 application/x-www-form-urlencoded和multipart/form-data类型 -->
        <dependency>
            <groupId>io.github.openfeign.form</groupId>
            <artifactId>feign-form</artifactId>
        </dependency>
        <dependency>
            <groupId>io.github.openfeign.form</groupId>
            <artifactId>feign-form-spring</artifactId>
        </dependency>
        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
        </dependency>

相关版本号根据自己的环境自行定义。

2.2.2，定义SpringFormEncoder和Feign.Builder

    @Bean
    @Primary
    public Encoder multipartFormEncoder(ObjectFactory<HttpMessageConverters> messageConverters) {
        return new SpringFormEncoder(new SpringEncoder(messageConverters));
    }

    @Bean
    @Scope("prototype")
    public Feign.Builder feignBuilder(Encoder encoder) {
        return Feign.builder().encoder(encoder);
    }

注意这里，SpringEncoder其实也支持文件上传，但是仅仅支持单个MultipartFile的文件上传，不支持MultipartFile[]或者其他类型的多文件上传，因此需要再用SpringFormEncoder封装一层。

2.3，支持Hystrix配置：

2.3.1，引入FeignClientsConfiguration

 

FeignClientsConfiguration

因为在FeignClientsConfiguration类中定义了Feign.Builder

    @Configuration(proxyBeanMethods = false)
    @ConditionalOnClass({ HystrixCommand.class, HystrixFeign.class })
    protected static class HystrixFeignConfiguration {

        @Bean
        @Scope("prototype")
        @ConditionalOnMissingBean
        @ConditionalOnProperty(name = "feign.hystrix.enabled")
        public Feign.Builder feignHystrixBuilder() {
            return HystrixFeign.builder();
        }

    }

2.3.2，HystrixFeign.builder加载

配置feign.hystrix.enabled=true

2.4，用业务定义的log日志系统替换FeignClient默认日志系统：

2.4.1，实现业务日志系统代理Feignclient日志系统类

    final class FeignLog extends Logger {
        private Log log;
        
        public FeignLog(Class<?> clazz) {
            log = LogFactory.getLog(clazz);
        }
        
        @Override
        protected void log(String configKey, String format, Object... args) {
            if (log.isDebugEnabled()) {
                log.debug(String.format(methodTag(configKey) + format, args));
            }
        }
    }

2.4.2，定义日志系统bean

    @Bean
    @Primary
    public Logger logger() {
        return new FeignLog(this.getClass());
    }
    @Bean
    @Scope("prototype")
    public Feign.Builder feignBuilder(Logger logger) {
        return Feign.builder().logger(logger);
    }

2.5，定义FeignClient的request的重试机制：

2.5.1，定义重试bean

    @Bean
    @Primary
    public Retryer feignRetryer() {
        return Retryer.NEVER_RETRY;
    }

2.5.1，初始化Feign.builder

    @Bean
    @Scope("prototype")
    public Feign.Builder feignBuilder(Retryer retryer) {
        return Feign.builder().retryer(retryer);
    }

2.6，启用response的压缩功能：

2.6.1，开启response的压缩属性

feign:
  compression: 
    response: 
      enabled: true
      useGzipDecoder: true

2.6.2，定义DefaultGzipDecoder的bean

    @Bean
    @Primary
    @ConditionalOnProperty("feign.compression.response.useGzipDecoder")
    public Decoder responseGzipDecoder(ObjectFactory<HttpMessageConverters> messageConverters) {
        return new OptionalDecoder(new ResponseEntityDecoder(
                new DefaultGzipDecoder(new SpringDecoder(messageConverters))));
    }

由于该bean是有条件的，所以，无需强制加载到Feign.builder，让其自动加载即可。

2.7，自定义UserAgent：

使用Apache Httpclient的FeignClient的请求，默认会添加UserAgent：Apache-HttpClientxxxxxxx，如果我们需要自定义UserAgent，可有下面多种方法：
方法1，使用系统属性http.agent：

System.setProperty("http.agent", "MyUserAgent");

方法2，通用设置方式：

    @Bean
    public RequestInterceptor uaRequestInterceptor() {
        return new RequestInterceptor() {
            @Override
            public void apply(RequestTemplate template) {
                template.header("User-Agent", "MyUserAgent");
            }
        };
    }

2,8，动态请求地址的host

有时候，我们可能会需要动态更改请求地址的host，也就是@FeignClient中的url的值在我调用的是才确定。此时我们就可以利用他的一个高级用法实现这个功能：
在定义的接口的方法中，添加一个URI类型的参数即可，该值就是新的host。此时@FeignClient中的url值在该方法中将不再生效。如下：

@FeignClient(name = "categoryFeignClient",
             url = "http://127.0.0.1:10002", 
             fallback = CategoryFeignClientFallback.class,
             configuration = {FeignConfig.class})
public interface CategoryFeignClient {
    /**
     * 第三方业务接口
     * @param categoryIds 参数
     * @return 结果
     */
    @RequestMapping(method = RequestMethod.GET, value = "/v1/categorys/multi")
    String getCategorys(@RequestParam("categoryIds") String categoryIds, URI newHost);
}

2.9，其他功能的定制：

关于其他功能的定制，这里就不再赘述，大家可以参照上述实现原理。如果还是不明白可以留言。

作者：一曲畔上
链接：https://www.jianshu.com/p/50fd582b739f
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。