Feign使用分析

淡淡的烟草味﹌ 2022-10-04 14:55 147阅读 0赞

## feign使用 ##

在实现的效果上来说Feign = RestTemplate+Ribbon+Hystrix

### Feign实现RestTemplate+Ribbon效果 ###

Feign实现RestTemplate+Ribbon效果，只需要以下几步 在springcloud项目调用方的pom文件中加入openFeign的配置

<dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-openfeign</artifactId>
            </dependency>

在启动类中加入@EnableFeignClients 同时使用接口声明的方式来实现接口调用

@FeignClient(name = "zhao-service-resume")
    public interface ResumeFeignClient {
        @GetMapping("/resume/openstate/{userId}")
        public Integer findDefaultResumeState(@PathVariable Long userId) ;
    }

这个接口的声明与被调用方的实现完全一样，我们需要在声明时@FeignClient(name = "zhao-service-resume")声明被调用的服务，即可按照默认的方式进行调用 使用单元测试测试即可测试到负载均衡的效果,访问两次，分别访问到8081和8082端口的服务

@RunWith(SpringRunner.class)
    @SpringBootTest(classes = DeliverApplication8091.class)
    public class FeignTest {
        @Autowired
        ResumeFeignClient feignClient;
        @Test
        public void feignTest(){
            Integer port = feignClient.findDefaultResumeState(2195321L);
            System.out.println("测试的结果"+port);
         }
    
    }

那么如何在配置类中配置负载均衡呢？格式如下,同时我们还配置了请求的超时时间，在没有配置hystrix的情况下，会出现超时的情况，

zhao-service-resume:
      ribbon: #请求连接超时时间
        ConnectTimeout: 2000
      #请求处理超时时间
        ReadTimeout: 5000
      #对所有操作都进⾏重试
        OkToRetryOnAllOperations: true
    ####根据如上配置，当访问到故障请求的时候，它会再尝试访问⼀次当前实例（次数由MaxAutoRetries配置），
      ####如果不⾏，就换⼀个实例进⾏访问，如果还不⾏，再换⼀次实例访问（更换次数由MaxAutoRetriesNextServer配置），
    ####如果依然不⾏，返回失败信息。
        MaxAutoRetries: 0 #对当前选中实例重试次数，不包括第⼀次调⽤
        MaxAutoRetriesNextServer: 0 #切换实例的重试次数
        NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RoundRobinRule #负载策略调整

超时的报错feign.RetryableException: Read timed out executing GET [http://zhao-service-resume/resume/openstate/2195321][http_zhao-service-resume_resume_openstate_2195321] 即是没有配置重试的这几个参数也是同样的效果

### Feign实现Hystrix效果 ###

首先是先开启熔断器

feign:
      hystrix:
        enabled: true

接着增加超时处理逻辑的相关配置

hystrix:
      command:
        default:
          execution:
            isolation:
              thread:
                timeoutInMilliseconds: 15000

但是即使我在被调用方只线程休眠了十秒，程序依然被熔断了。查阅资料表明，Hystrix将采用feign和hystrix超时时间中较小的那个进行超时判定 ![file][] 增加降级兜底方法

@Component
    public class FeignClientFallBack implements ResumeFeignClient {
        @Override
        public Integer findDefaultResumeState(Long userId) {
            return -1;
        }
    }

在调用方增加降级配置

@FeignClient(name = "zhao-service-resume",fallback = FeignClientFallBack.class)
    public interface ResumeFeignClient {
        @GetMapping("/resume/openstate/{userId}")
        public Integer findDefaultResumeState(@PathVariable Long userId) ;
    }

同时可以在@FeignClient中增加path属性，将方法上的公共路径提取到类中

## Feign使用上的其他特性 ##

### Feign请求压缩和响应压缩配置 ###

配置属性如下

feign:
      compression:
        request:
          enabled: true
          min-request-size: 2048
          mime-types: text/html,application/xml,application/json # 设置压缩的数据类型
        response:
          enabled: true

以上配置包含的两个属性，min-request-size: 2048表示开启压缩的最小值为2048字节，mime-types为支持压缩的数据类型，当前的这几种类型未默认值

### Feign请求日志配置 ###

首先在yml中设置具体的类的日志响应级别

logging:
     level:
    # Feign⽇志只会对⽇志级别为debug的做出响应
     com.lagou.edu.controller.service.ResumeServiceFeignClient:
    debug

然后就是针对feign的log的配置

import feign.Logger;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    
    @Configuration
    public class FeignConfig {
        @Bean
        Logger.Level feignLevel(){
            return Logger.Level.FULL;
        }
    }

需要注意的是，此处引入的是feign.Logger,此处表示的含义是feign将会打印请求的所有信息如下 ![file][file 1]

## Feign源码简要分析 ##

还是依据前文，依照启动类注解和spring.factories中配置的自动配置类来进行分析，首先我们看@EnableFeignClients注解中的FeignClientsRegistrar的具体内容,实现的依然是Spring中的注入beanDefinition的内容

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

registerDefaultConfiguration注入默认配置我们基本可以确定就是加入一些默认配置，而registerFeignClients就是最终实现逻辑的地方。而最终实现逻辑的地方是在该方法下的

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);
        }

而这个类都依赖于 BeanDefinitionBuilder definition = BeanDefinitionBuilder.genericBeanDefinition(FeignClientFactoryBean.class);几乎可以确定注入的时候就是FeignClientFactoryBean这个工厂Bean在起作用，那么我们在进入里面看一看,工厂Bean最重要的就是getObject返回的类型情况

@Override
        public Object getObject() throws Exception {
            return getTarget();
        }
    
        /**
         * @param <T> the target type of the Feign client
         * @return a {@link Feign} client created with the specified data and the context information
         */
        <T> T getTarget() {
            FeignContext context = applicationContext.getBean(FeignContext.class);
            Feign.Builder builder = feign(context);
    
            if (!StringUtils.hasText(this.url)) {
                if (!this.name.startsWith("http")) {
                    url = "http://" + this.name;
                }
                else {
                    url = this.name;
                }
                url += cleanPath();
                return (T) loadBalance(builder, context, new HardCodedTarget<>(this.type,
                        this.name, url));
            }
            if (StringUtils.hasText(this.url) && !this.url.startsWith("http")) {
                this.url = "http://" + this.url;
            }
            String url = this.url + cleanPath();
            Client client = getOptional(context, Client.class);
            if (client != null) {
                if (client instanceof LoadBalancerFeignClient) {
                    // not load balancing because we have a url,
                    // but ribbon is on the classpath, so unwrap
                    client = ((LoadBalancerFeignClient)client).getDelegate();
                }
                builder.client(client);
            }
            Targeter targeter = get(context, Targeter.class);
            return (T) targeter.target(this, builder, context, new HardCodedTarget<>(
                    this.type, this.name, url));
        }

在上述代码中，基本上就是构造客户端并调用的过程，那么最关键的就是实现了Ribbon功能的负载均衡的loadBalance操作中内容

protected <T> T loadBalance(Feign.Builder builder, FeignContext context,
                HardCodedTarget<T> target) {
            Client client = getOptional(context, Client.class);
            if (client != null) {
                builder.client(client);
                Targeter targeter = get(context, Targeter.class);
                return targeter.target(this, builder, context, target);
            }
    
            throw new IllegalStateException(
                    "No Feign Client for loadBalancing defined. Did you forget to include spring-cloud-starter-netflix-ribbon?");
        }

而 targeter.target这段最后都会执行到feign类中的这个方法中

public <T> T target(Target<T> target) {
          return build().newInstance(target);
        }

关注到newInstance方法发现最终实现时在ReflectiveFeign类中

@Override
      public <T> T newInstance(Target<T> target) {
        Map<String, MethodHandler> nameToHandler = targetToHandlersByName.apply(target);
        Map<Method, MethodHandler> methodToHandler = new LinkedHashMap<Method, MethodHandler>();
        List<DefaultMethodHandler> defaultMethodHandlers = new LinkedList<DefaultMethodHandler>();
    
        for (Method method : target.type().getMethods()) {
          if (method.getDeclaringClass() == Object.class) {
            continue;
          } else if (Util.isDefault(method)) {
            DefaultMethodHandler handler = new DefaultMethodHandler(method);
            defaultMethodHandlers.add(handler);
            methodToHandler.put(method, handler);
          } else {
            methodToHandler.put(method, nameToHandler.get(Feign.configKey(target.type(), method)));
          }
        }
        InvocationHandler handler = factory.create(target, methodToHandler);
        T proxy = (T) Proxy.newProxyInstance(target.type().getClassLoader(),
            new Class<?>[] {target.type()}, handler);
    
        for (DefaultMethodHandler defaultMethodHandler : defaultMethodHandlers) {
          defaultMethodHandler.bindTo(proxy);
        }
        return proxy;
      }

上述可见，最终生成的类实际上一个代理类完成了最终的调用，而在代理对象就完成了最后的负载均衡等处理,生成代理对象使用的死FeignInvocationHandler的invoke方法

static final class Default implements InvocationHandlerFactory {
    
        @Override
        public InvocationHandler create(Target target, Map<Method, MethodHandler> dispatch) {
          return new ReflectiveFeign.FeignInvocationHandler(target, dispatch);
        }
      }

最后执行了相关的编解码操作

@Override
      public Object invoke(Object[] argv) throws Throwable {
        RequestTemplate template = buildTemplateFromArgs.create(argv);
        Retryer retryer = this.retryer.clone();
        while (true) {
          try {
            return executeAndDecode(template);
          } catch (RetryableException e) {
            try {
              retryer.continueOrPropagate(e);
            } catch (RetryableException th) {
              Throwable cause = th.getCause();
              if (propagationPolicy == UNWRAP && cause != null) {
                throw cause;
              } else {
                throw th;
              }
            }
            if (logLevel != Logger.Level.NONE) {
              logger.logRetry(metadata.configKey(), logLevel);
            }
            continue;
          }
        }
      }

而执行并解码的操作executeAndDecode中最重要的就是client.execute方法，点进去之后发现，居然最终调用的就是LoadBalancerFeignClient.execute方法 ![file][file 2] 最终在该方法中实现了远程调用和负载均衡

> 欢迎搜索关注本人的公众号【微瞰技术】,以及总结的分类面试题[https://github.com/zhendiao/JavaInterview][https_github.com_zhendiao_JavaInterview]

![file][file 3]

[http_zhao-service-resume_resume_openstate_2195321]: http://zhao-service-resume/resume/openstate/2195321
[file]: /images/20221004/32bc437bf6ec4503adabbf1e77d0c87e.png
[file 1]: /images/20221004/4c5ca91c06aa468aa7efcee75a58427f.png
[file 2]: /images/20221004/3f7b6dd3ee7a4de8a2a6e24786443524.png
[https_github.com_zhendiao_JavaInterview]: https://github.com/zhendiao/JavaInterview
[file 3]: /images/20221004/52be19a5aac8445b8acc477616dfa1c1.png