Spring Cloud Feign相关原理分析

最新推荐文章于 2024-08-04 14:57:10 发布
最新推荐文章于 2024-08-04 14:57:10 发布
阅读量1.7k 收藏 5
点赞数
文章标签： Spring Cloud Feign Feign底层原理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39283212/article/details/89456862
版权

1.认识Spring Cloud Feign
在使用Spring Cloud构建的微服务架构中，Feign用来提供声明式的服务客户端定义方式。
Feign是一个伪客户端(不做任何的请求处理),它通过处理注解生成request，以此来简化HTTP API的开发。

2.定义的服务接口是如何注册到Spring容器的？
这里我们需要关注两个注解：
@FeignClient：使用在我们定义的服务接口上，表示该接口是一个Feign客户端；
@EnableFeignClients：使用在我们具体服务应用的启动类上。

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

@EnableFeignClients注解导入了FeignClientsRegistrar类，该类的核心方法如下：
public void registerBeanDefinitions(AnnotationMetadata metadata,
            BeanDefinitionRegistry registry) {
    registerDefaultConfiguration(metadata, registry);
    registerFeignClients(metadata, registry);
}

public void registerFeignClients(AnnotationMetadata metadata,
            BeanDefinitionRegistry registry) {
    ClassPathScanningCandidateComponentProvider scanner = getScanner();
    scanner.setResourceLoader(this.resourceLoader);

    Set<String> basePackages;

    Map<String, Object> attrs = metadata
            .getAnnotationAttributes(EnableFeignClients.class.getName());
    AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(
            FeignClient.class);
    final Class<?>[] clients = attrs == null ? null
            : (Class<?>[]) attrs.get("clients");
    if (clients == null || clients.length == 0) {
        scanner.addIncludeFilter(annotationTypeFilter);
        basePackages = getBasePackages(metadata);
    }
    else {
        final Set<String> clientClasses = new HashSet<>();
        basePackages = new HashSet<>();
        for (Class<?> clazz : clients) {
            basePackages.add(ClassUtils.getPackageName(clazz));
            clientClasses.add(clazz.getCanonicalName());
        }
        AbstractClassTestingTypeFilter filter = new AbstractClassTestingTypeFilter() {
            @Override
            protected boolean match(ClassMetadata metadata) {
                String cleaned = metadata.getClassName().replaceAll("\\$", ".");
                return clientClasses.contains(cleaned);
            }
        };
        scanner.addIncludeFilter(
                new AllTypeFilter(Arrays.asList(filter, annotationTypeFilter)));
    }

    for (String basePackage : basePackages) {
        Set<BeanDefinition> candidateComponents = scanner
                .findCandidateComponents(basePackage);
        for (BeanDefinition candidateComponent : candidateComponents) {
            if (candidateComponent instanceof AnnotatedBeanDefinition) {
                // verify annotated class is an interface
                AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition) candidateComponent;
                AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();
                Assert.isTrue(annotationMetadata.isInterface(),
                        "@FeignClient can only be specified on an interface");

                Map<String, Object> attributes = annotationMetadata
                        .getAnnotationAttributes(
                                FeignClient.class.getCanonicalName());

                String name = getClientName(attributes);
                registerClientConfiguration(registry, name,
                        attributes.get("configuration"));

                registerFeignClient(registry, annotationMetadata, attributes);
            }
        }
    }
}

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

通过分析源码，我们可以知道，@EnableFeignClients注解的作用就是通过FeignClientsRegistrar，最终将使用了@FeignClient注解的接口全部注入到Spring容器中。

3.Feign是如何进行服务调用的？

a.Feign.class的newInstance(Target<T> target)方法将会为被@FeignClient注解的接口生成一个代理的实例
/**
* Returns a new instance of an HTTP API, defined by annotations in the {@link Feign Contract},
* for the specified {@code target}. You should cache this result.
*/
public abstract <T> T newInstance(Target<T> target);

Feign.class的实现类ReflectiveFeign.class具体实现了这个方法，它的newInstance方法为指定的Feign接口生成代理对象
/**
* creates an api binding to the {@code target}. As this invokes reflection, care should be taken
* to cache the result.
*/
@SuppressWarnings("unchecked")
@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)));
      }
    }
    //将要被代理的方法全部在methodToHandler中；factory.create()默认返回的就是ReflectiveFeign.FeignInvocationHandler对象
    InvocationHandler handler = factory.create(target, methodToHandler);
    //使用jdk的动态代理为指定的Feign接口生成代理对象
    T proxy = (T) Proxy.newProxyInstance(target.type().getClassLoader(),
        new Class<?>[] {target.type()}, handler);

    for (DefaultMethodHandler defaultMethodHandler : defaultMethodHandlers) {
      defaultMethodHandler.bindTo(proxy);
    }
    return proxy;
}

b.代理对象把功能的实现委托给MethodHandler接口的invoke()方法
ReflectiveFeign.FeignInvocationHandler对象的invoke方法：
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  if ("equals".equals(method.getName())) {
    try {
      Object otherHandler =
          args.length > 0 && args[0] != null ? Proxy.getInvocationHandler(args[0]) : null;
      return equals(otherHandler);
    } catch (IllegalArgumentException e) {
      return false;
    }
  } else if ("hashCode".equals(method.getName())) {
    return hashCode();
  } else if ("toString".equals(method.getName())) {
    return toString();
  }

  //也就是MethodHandler.invoke方法   其实现类SynchronousMethodHandler.class提供了具体的invoke方法
  return dispatch.get(method).invoke(args);
}

c.SynchronousMethodHandler类进行拦截处理，根据传入参数构建http请求模板，把具体的请求委托给专门发送网络请求的类去具体执行
@Override
public Object invoke(Object[] argv) throws Throwable {
    //根据参数构建http请求模板
    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;
      }
    }
}

Object executeAndDecode(RequestTemplate template) throws Throwable {
    Request request = targetRequest(template);

    if (logLevel != Logger.Level.NONE) {
      logger.logRequest(metadata.configKey(), logLevel, request);
    }

    Response response;
    long start = System.nanoTime();
    try {
      //Client对象真正执行发送请求的任务
      response = client.execute(request, options);
    } catch (IOException e) {
      if (logLevel != Logger.Level.NONE) {
        logger.logIOException(metadata.configKey(), logLevel, e, elapsedTime(start));
      }
      throw errorExecuting(request, e);
    }
    long elapsedTime = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start);

    boolean shouldClose = true;
    try {
      if (logLevel != Logger.Level.NONE) {
        response =
            logger.logAndRebufferResponse(metadata.configKey(), logLevel, response, elapsedTime);
      }
      if (Response.class == metadata.returnType()) {
        if (response.body() == null) {
          return response;
        }
        if (response.body().length() == null ||
            response.body().length() > MAX_RESPONSE_BUFFER_SIZE) {
          shouldClose = false;
          return response;
        }
        // Ensure the response body is disconnected
        byte[] bodyData = Util.toByteArray(response.body().asInputStream());
        return response.toBuilder().body(bodyData).build();
      }
      if (response.status() >= 200 && response.status() < 300) {
        if (void.class == metadata.returnType()) {
          return null;
        } else {
          Object result = decode(response);
          shouldClose = closeAfterDecode;
          return result;
        }
      } else if (decode404 && response.status() == 404 && void.class != metadata.returnType()) {
        Object result = decode(response);
        shouldClose = closeAfterDecode;
        return result;
      } else {
        throw errorDecoder.decode(metadata.configKey(), response);
      }
    } catch (IOException e) {
      if (logLevel != Logger.Level.NONE) {
        logger.logIOException(metadata.configKey(), logLevel, e, elapsedTime);
      }
      throw errorReading(request, response, e);
    } finally {
      if (shouldClose) {
        ensureClosed(response.body());
      }
    }
  }
  
d.Client组件最终发送request请求以及接收response响应
Client的实现类默认是Client.Default，该类由HttpURLConnnection实现网络请求，另外还支持ApacheHttpClient、Okhttp.
@Configuration
class DefaultFeignLoadBalancedConfiguration {
    @Bean
    @ConditionalOnMissingBean
    public Client feignClient(CachingSpringLoadBalancerFactory cachingFactory,
                              SpringClientFactory clientFactory) {
        return new LoadBalancerFeignClient(new Client.Default(null, null),
                cachingFactory, clientFactory);
    }
}

4.Feign请求的负载均衡是如何实现的？

a.由FeignRibbonClientAutoConfiguration.class自动配置类可知，向容器注入的是LoadBalancerFeignClient（这个类与Ribbon研究中的LoadBalancerClient类在功能上有相似性），即负载均衡客户端。
@Configuration
class DefaultFeignLoadBalancedConfiguration {
    @Bean
    @ConditionalOnMissingBean
    public Client feignClient(CachingSpringLoadBalancerFactory cachingFactory,
                              SpringClientFactory clientFactory) {
        return new LoadBalancerFeignClient(new Client.Default(null, null),
                cachingFactory, clientFactory);
    }
}

b.当Client组件发送request请求之前，也就是执行Client.execute()方法时，具体的请求会被LoadBalancerFeignClient处理。LoadBalancerFeignClient接着又把处理逻辑交给AbstractLoadBalancerAwareClient的executeWithLoadBalancer()方法.
org.springframework.cloud.openfeign.ribbon.LoadBalancerFeignClient的execute()方法：
@Override
public Response execute(Request request, Request.Options options) throws IOException {
    try {
        URI asUri = URI.create(request.url());
        String clientName = asUri.getHost();
        URI uriWithoutHost = cleanUrl(request.url(), clientName);
        FeignLoadBalancer.RibbonRequest ribbonRequest = new FeignLoadBalancer.RibbonRequest(
                this.delegate, request, uriWithoutHost);

        IClientConfig requestConfig = getClientConfig(options, clientName);
        return lbClient(clientName).executeWithLoadBalancer(ribbonRequest,
                requestConfig).toResponse();
    }
    catch (ClientException e) {
        IOException io = findIOException(e);
        if (io != null) {
            throw io;
        }
        throw new RuntimeException(e);
    }
}

c.AbstractLoadBalancerAwareClient的executeWithLoadBalancer()方法把负载均衡的任务交给LoadBalancerCommand的submit方法处理
com.netflix.client.AbstractLoadBalancerAwareClient的executeWithLoadBalancer()方法：
public T executeWithLoadBalancer(final S request, final IClientConfig requestConfig) throws ClientException {
    LoadBalancerCommand<T> command = buildLoadBalancerCommand(request, requestConfig);

    try {
        return command.submit(
            new ServerOperation<T>() {
                @Override
                public Observable<T> call(Server server) {
                    URI finalUri = reconstructURIWithServer(server, request.getUri());
                    S requestForServer = (S) request.replaceUri(finalUri);
                    try {
                        return Observable.just(AbstractLoadBalancerAwareClient.this.execute(requestForServer, requestConfig));
                    } 
                    catch (Exception e) {
                        return Observable.error(e);
                    }
                }
            })
            .toBlocking()
            .single();
    } catch (Exception e) {
        Throwable t = e.getCause();
        if (t instanceof ClientException) {
            throw (ClientException) t;
        } else {
            throw new ClientException(e);
        }
    }
    
}

d.LoadBalancerCommand的submit方法委托LoadBalancerContext.getServerFromLoadBalancer从负载均衡器里面获取一个服务实例
com.netflix.loadbalancer.reactive.LoadBalancerCommand.class
private Observable<Server> selectServer() {
    return Observable.create(new OnSubscribe<Server>() {
        @Override
        public void call(Subscriber<? super Server> next) {
            try {
                //这很关键，委托负载均衡器取得一个Server实例
                Server server = loadBalancerContext.getServerFromLoadBalancer(loadBalancerURI, loadBalancerKey);   
                next.onNext(server);
                next.onCompleted();
            } catch (Exception e) {
                next.onError(e);
            }
        }
    });
}

public Server getServerFromLoadBalancer(@Nullable URI original, @Nullable Object loadBalancerKey) throws ClientException {
        //...
        ILoadBalancer lb = getLoadBalancer();
        if (host == null) {
            // Partial URI or no URI Case
            // well we have to just get the right instances from lb - or we fall back
            if (lb != null){
                Server svc = lb.chooseServer(loadBalancerKey);
            }
        //...
}

逆流而上的龟
关注
专栏目录
Spring-Cloud之Feign原理剖析
m0_67698950的博客
07-01 481
Feign 主要是帮助我们方便进行rest api服务间的调用，其大体实现思路就我们通过标记注解在一个接口类上(注解上将包含要调用的接口信息)，之后在调用时根据注解信息组装好请求信息，接下来基于ribbon这些负载均衡器来生成真实的服务地址，最后将请求发送出去；之后将接收到的结果反序列化为相关的Java对象供我们直接使用。 下面我们走进Spring Cloud对feign封装的源码中去了解其主要实现机制。通过在启动类上标记 @EnableFeignClients 注解来开启feign的功能，服务启动后会扫描
SpringCloudFeign原理剖析
m0_47495420的博客
03-05 1451
Feign是什么？简单来说，feign是用在微服务中，各个微服务间的调用。它是通过声明式的方式来定义接口，而不用实现接口。接口的实现由它通过spring bean的动态注册来实现的。fei...
SpringCloud 中Feign原理（图解）
kongkongyanan的博客
09-09 3160
SpringCloud 中Feign原理（图解）
Spring Cloud Feign详解：实现高效、可扩展的微服务通信
最新发布
m0_74022498的博客
08-04 1013
Feign 是一个声明式的 Web Service 客户端。它的出现使开发 Web Service 客户端变得很简单。使用 Feign 只需要创建一个接口加上对应的注解，比如：@FeignClient 注解。Feign 有可插拔的注解，包括 Feign 注解和 AX-RS 注解。Feign 也支持编码器和解码器，Spring Cloud Open Feign 对 Feign 进行增强支持 Spring Mvc 注解，可以像 Spring Web 一样使用 HttpMessageConverters 等。
深入源码分析SpringCloud组件Feign工作原理
lj872224的博客
06-17 681
Feign对于使用过SpringCloud微服务的程序员来说，想必都很熟悉，微服务之间的调用时基于Http方式的，ribbon提供了一个RestTemplate的类进行调用，不过并不是好用，服务与服务之间调用的化代码冗余量很大，所以Feign就产生了，使得微服务之间的调用可以声明式调用。大大简化了代码量 Feign在项目中的配置和使用 在SpringCloud项目中使用Feign，需要在配置类里面加入@EnableFeignClients注解，开启Feign服务 配置声明式客户端调用接..
Spring Cloud Feign原理详解
热门推荐
时光钟摆
05-05 1万+
目录 1.什么是Feign? 2.Open Feign vs Spring Cloud Feign 2.1.OpenFeign 2.2.Spring Cloud Open Feign 3.Spring Cloud Feign 的使用 4.Spring Cloud Feign 的源码解析 1.什么是Feign? Feign 的初衷是：feign makes writing java...
Spring Cloud 整合 Feign 的原理
JavaMonsterr的博客
07-27 270
通过源码可知FeignClientsRegistrar实现ImportBeanDefinitionRegistrar接口，该接口从名字也不难看出其主要功能就是将所需要初始化的BeanDefinition注入到容器中，接口定义两个方法功能都是用来注入给定的BeanDefinition的，一个可自定义beanName（通过实现BeanNameGenerator接口自定义生成beanName的逻辑），另一个使用默认的规则生成beanName（类名首字母小写格式）。...
SpringCloud之Feign架构及原理解析
qq_43614498的博客
03-18 783
feign架构原理解析 目录 feign与ribbon对接的关键点 feign与ribbon对接主要还是在Client对象上做文章，将Client替换为继承Ribbon模板的实现类，这样就可以对执行请求前后做一些负载逻辑 什么是feign？ 在使用feign之前，我们怎么发送请求？ 有了feign之后我们怎么发送请求 spring cloud openfeign的加载过程 feign的REST C...
SpringCloud之OpenFegin基本介绍及原理分析
HRebel的博客
12-15 1231
本文主要内容： 简单了解原生Feign、Spring Cloud Open Fegin是什么 一、Spring Cloud Open Fegin介绍 1.1、Feign基础介绍 Feign：是申明式Web服务客户端，基于JAX-RS（javaRest规范）实现的 申明式：通过接口声明、Annotation驱动 Web服务：HTTP通讯协议 客户端：用户服务调用存根 Feign可以将一个Service声明为可以被HTTP方式调用，底层基于面向接口的动态代理方式生成实现类，将请求调用委托到动态代理实现
SpringCloud-创建服务消费者-Feign方式示例代码.zip
10-15
在这个名为"SpringCloud-创建服务消费者-Feign方式示例代码.zip"的压缩包中，我们预计将看到一个简单的Spring Cloud应用，该应用展示了如何利用Feign作为服务消费者来调用其他服务。 首先，让我们了解Feign的基本...
springCloud Feign的实现原理
qq_20161461的博客
03-05 3798
一、Feign介绍 Feign是一个http请求调用的轻量级框架，可以以Java接口注解的方式调用Http请求。 Spring Cloud Feign是基于Netflix feign实现，整合了Spring Cloud Ribbon和Spring Cloud Hystrix 实现负载均衡和断路器，除了提供这两者的强大功能外，还提供了一种声明式的Web服务客户端定义的方式。 Spring Cloud Feign帮助我们定义和实现依赖服务接口的定义。在Spring Cloud feign的实现下，只需要创建一个
微服务精通之Feign原理解析
欢迎关注同名公众号，一起探索Java技术的奥秘，共同成长！
11-01 2461
前言        经过微服务精通之Ribbon原理解析的学习，我们了解到了服务消费者获取服务提供者实例的过程，都是通过RestTemplate来实现的，而且，都是模板化操作。那spring cloud是否有哪个组件可以通过注解或者配置的方式，来简化这个过程？答案是有的，就是Feign。 一、Feign是什么？        Feign是一个声明式的伪HTTP客户端，
Feign 原理 （图解）
架构师尼恩
12-01 3371
Feign原理 （核心图解） 疯狂创客圈 Java 高并发【 亿级流量聊天室实战】实战系列 【博客园总入口 】 疯狂创客圈 正在进行分布式和高并发基础原理的研习，进行已经发布一些基础性的文章： 一、版本1 ：springcloud + zookeeper 秒杀 以及有关Springcloud 几篇核心、重要的文章： 一、Springcloud 配置， 史上最全 一文全懂 二、Feign...
Feign的工作原理
吴声子夜歌的博客
05-20 5743
Feign的工作原理 Feign是一个伪Java Http 客户端，Feign 不做任何的请求处理。Feign 通过处理注解生成Request模板，从而简化了Http API 的开发。开发人员可以使用注解的方式定制Request API模板。 在发送Http Request请求之前，Feign通过处理注解的方式替换掉Request模板中的参数，生成真正的Request,并交给Java Http客户端去处理。利用这种方式，开发者只需要关注Feign注解模板的开发，而不用关注Http请求本身，简化了Http请求
Feign 原理解析
LarrYFinal的博客
10-26 1111
Feign 原理解析 基本原理 现在已经了解了 Ribbon 的负载均衡原理，我们可以来猜想下，Feign 的原理，仅仅通过一个注解 @FeignClient + 一个接口，就可以服务之间的调用。 通过 @FeignClient 在注解中的name，确定服务名，然后 RibbonClient 使用服务名去获取负载均衡器 loadBalancer，再通过负载均衡算法获取到 ip:port, 然后构建的请求为 http://nacos-component-provider/test/{id}，当 id = 1
feign原理分析
weixin_40980639的博客
07-23 514
一、feign测试代码 1.服务接口上标注@FeignClient @FeignClient("order") public interface OrderServiceFeign { @GetMapping("/getOrder") String getOrder(); } 2.调用方可以直接注入然后直接调用访问 @RestController @RequestMapping("/feign") public class FeignTestController { @Autow
Feign原理
weixin_39389888的博客
04-15 187
Feign是一种声明式、模板化的HTTP客户端。在Spring Cloud中使用Feign, 我们可以做到使用HTTP请求远程服务时能与调用本地方法一样的编码体验，开发者完全感知不到这是远程方法，更感知不到这是个HTTP请求，可以理解为一个基于http协议的RPC框架。 实现原理：Spring Cloud应用在启动时，Feign会扫描标有@FeignClient注解的接口...
【Spring Cloud】Feign底层原理分析-自动装载&动态代理
DreamSun的博客
04-15 2120
是一个HTTP请求调用轻量级框架，可以以Java接口注解的方式调用HTTP请求，而不用像Java中通过封装HTTP请求报文的方式直接调用，下面详细介绍。这里套用Feign官方Github上的介绍：“Feign是一个灵感来自于Retrofit、JAXRS-2.0、WebSocket的Java Http客户端，Feign的主要目标是降低大家使用Http API的复杂性”。其实，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值