openfeign原理

已于 2022-12-20 16:07:40 修改
阅读量689 收藏
点赞数
分类专栏： # spring 文章标签： java 开发语言 feign
于 2022-11-26 18:33:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dolly_baby/article/details/128055274
版权

openfeign原理

@EnableFeignClients注解启用Feign客户端，通过@Import注解导入了FeignClientsRegistrar类加载额外的Bean。FeignClientsRegistrar实现了ImportBeanDefinitionRegistrar接口，在Spring启动过程中会调用registerBeanDefinitions方法注册BeanDefinition。

//FeignClientsRegistrar#registerBeanDefinitions
public void registerBeanDefinitions(AnnotationMetadata metadata,
                                    BeanDefinitionRegistry registry) {
    //处理@EnableFeignClients注解上的配置
    registerDefaultConfiguration(metadata, registry);
    //处理@FeignClient对应的接口
    registerFeignClients(metadata, registry);
}

FeignClientsRegistrar#registerFeignClients:

private void registerDefaultConfiguration(AnnotationMetadata metadata,
                                          BeanDefinitionRegistry registry) {
    Map<String, Object> defaultAttrs = metadata
        .getAnnotationAttributes(EnableFeignClients.class.getName(), true);

    if (defaultAttrs != null && defaultAttrs.containsKey("defaultConfiguration")) {
        String name;
        if (metadata.hasEnclosingClass()) {
            name = "default." + metadata.getEnclosingClassName();
        }
        else {
            name = "default." + metadata.getClassName();
        }
        registerClientConfiguration(registry, name,
                                    defaultAttrs.get("defaultConfiguration"));
    }
}

FeignClientsRegistrar#registerFeignClients:

public void registerFeignClients(AnnotationMetadata metadata,
                                 BeanDefinitionRegistry registry) {
    //找到@FeignClient标识的接口类
    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);
            }
        }
    }
}

FeignClientsRegistrar#registerFeignClient:

private void registerFeignClient(BeanDefinitionRegistry registry,
                                 AnnotationMetadata annotationMetadata, 
                                 Map<String, Object> attributes) {
    String className = annotationMetadata.getClassName();
    //创建了FeignClientFactoryBean实例
    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#getObject:

//实现FactoryBean接口getObject方法，返回工厂管理的Bean实例
@Override
public Object getObject() throws Exception {
    return getTarget();
}

//根据指定的数据和上下文信息创建Feign客户端
<T> T getTarget() {
    //获得FeignContext对象
    FeignContext context = this.applicationContext.getBean(FeignContext.class);
    Feign.Builder builder = feign(context);

    if (!StringUtils.hasText(this.url)) {
        if (!this.name.startsWith("http")) {
            this.url = "http://" + this.name;
        }
        else {
            this.url = this.name;
        }
        this.url += cleanPath();
        //获得Feign客户端
        return (T) loadBalance(builder, context,
                               new HardCodedTarget<>(this.type, this.name, this.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));
}

//获得Feign.Builder实例
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;
}

//使用FeignContext和Feign.Builder对象配置Feign
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);
    }
}

//以负载均衡的方式获取Feign客户端
protected <T> T loadBalance(Feign.Builder builder, FeignContext context,
                            HardCodedTarget<T> target) {
    //获取Client对象
    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?");
}

//默认的Target实现类
class DefaultTargeter implements Targeter {

	@Override
	public <T> T target(FeignClientFactoryBean factory, Feign.Builder feign,
			FeignContext context, Target.HardCodedTarget<T> target) {
		return feign.target(target);
	}

}

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

//通过反射方式创建Feign对象
public Feign build() {
    SynchronousMethodHandler.Factory synchronousMethodHandlerFactory =
        new SynchronousMethodHandler
        .Factory(client, retryer, requestInterceptors, logger,                                             logLevel, decode404, closeAfterDecode, propagationPolicy);
    ParseHandlersByName handlersByName = new ParseHandlersByName
        (contract, options, encoder, decoder, queryMapEncoder,
                                errorDecoder, synchronousMethodHandlerFactory);
    return new ReflectiveFeign(
        handlersByName, invocationHandlerFactory, queryMapEncoder);
}

//使用JDK动态代理的方式创建Target的代理对象
@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;
}
OpenFeign核心流程

OpenFeign核心流程图

  1. 在Spring项目启动阶段，服务OpenFeign框架会发起一个主动的扫描包的流程；
  2. 从指定目录下扫描并加载所有被@FeignClient注解修饰的接口，然后将这些接口转换成Bean，统一交给Spring来管理；
  3. 然后这些接口会经过MVC Contract协议解析，将方法上的注解解析出来，放到MethodMetadata中；
  4. 根据加载的每个FeignClient接口生成一个动态代理对象，指向一个包含对应方法的MethodHandler的HashMap。生成的动态代理对象会被添加到Spring容器中，并注入到对应的服务中；
  5. 服务A调用接口，准备发起远程调用；
  6. 从动态代理对象Proxy中找到一个MethodHandler实例，生成Request，包含欧服务的请求URL；
  7. 经过负载均衡算法找到一个服务的IP地址，拼接处请求的URL；
  8. 服务B处理服务A发起的远程调用请求，执行业务逻辑后，返回响应给服务A。
核心思想
  1. OpenFeign扫描带有@FeignClient注解的接口，然后为其生成一个动态代理；
  2. 动态代理中包含有接口方法的MethodHandler，MethodHandler中又包含经过MVC Contract解析注解后的元数据；
  3. 发起请求时，MethodHandler会生成一个Request；
  4. 负载均衡器Ribbon会从服务列表中选取一个Server，拿到对应的IP地址后，拼接成最后的URL，就可以发起远程服务调用了。
总结
  1. OpenFeign是声明式的HTTP客户端，可以像访问本地方法一样进行远程调用；
  2. 提供了HTTP请求的模板，编写简单的接口和插入注解，就可以定义好HTTP请求的参数、格式、地址等信息；
  3. 整合了负载均衡组件Ribbon和服务熔断组件Hystrix。
快乐江小鱼
关注
专栏目录
OpenFeign原理整理【Java面试】_openfeign的工作原理(1)
2401_84009300的博客
04-12 364
*
OpenFeign原理整理【Java面试】_openfeign的工作原理
2301_79600088的博客
04-12 391
*
OpenFeign 实现原理
u012925692的博客
01-08 2215
OpenFeign 简介 OpenFeign 是一个声明式 RESTful 网络请求客户端。OpenFeign 会根据带有注解的函数信息构建出网络请求的模板，在发送网络请求之前，OpenFeign 会将函数的参数值设置到这些请求模板中。虽然 OpenFeign 只能支持基于文本的网络请求，但是它可以极大简化网络请求的实现，方便编程人员快速构建自己的网络请求应用。 核心组件与概念 在阅读源码时，可以沿着两条线路进行，一是被@FeignClient注解修饰的接口类如何创建，也就是其 Bean 实例是如何被
OpenFeign使用详解
最新发布
m0_74293254的博客
09-25 1140
如果需要在所有请求中添加相同的请求头，可以通过定义一个 Feign 请求拦截器来实现。
openfeign实现原理
weixin_41821642的博客
03-31 2726
OpenFeign 提供了一种声明式的远程调用接口，它可以大幅简化远程调用的编程体验。调用其他服务接口像调用本地服务service方法一样丝滑顺畅。引入依赖</</</</order服务调product服务接口扫描feignClient。
Openfeign的实现原理
zzzjm_的博客
01-11 8126
Openfeign是Spring Cloud 对Feign 也进行了增强，直接支持Hystrix 和 Ribbon，也支持SpringMVC 的注解。这样使得Feign 的使用非常方便。 1、在使用Openfeign时首先会在springboot的启动类上添加@EnableFeignClients注解，该注解会导入FeignClientsRegistrar类，会去扫描所有的带有@FeignClient 2、解析到 @FeignClient 修饰类后， Feign 框架通过扩展 Spring Bean..
SpringCloud.Honxton 版本 OpenFeign原理上篇
12-21
SpringCloud.Honxton 版本 OpenFeign原理前置说明如何使用openfeign原理总结 前置说明 好久没写博客了， 突然想起自己的springcloud系列文章就讲了配置中心，注册中心，负载均衡和熔断。那么今天就来分析一下...
OpenFeign原理
04-17
OpenFeign 是一个基于接口的声明式 HTTP 客户端，它...OpenFeign 构建于 Ribbon 和 Spring Cloud LoadBalancer 之上，可以自定义和拦截请求和响应。它还支持多种编码器和解码器，并且可以与 Spring Cloud Config 集成。
OpenFeign工作原理
qq_45110449的博客
01-12 4298
（1）首先通过@EnableFeignCleints注解开启FeignCleint （2）根据OpenFeign的规则编写接口，并加@FeignCleint注解 （3）程序启动后，会进行包扫描，扫描所有的@ FeignCleint的注解的接口，通过jdk的动态代理生成接口的实现类 （4）当实现类被生成的时候会根据反射的原理拿到@FeignClein的服务名执行服务发现的过程。 （5）得到某个服务名所有服务实例后执行负载均衡拿到一个实例 （6）通过反射读取到SpringMVC的注解，获取请求路径、参数等配置信
OpenFeign 原理
live的专栏
09-02 468
OpenFeign 依靠Ribbon，Ribbon类似于拦截器 进行计算挑选路由后调用远端服务 @OpenFeignClient原理 拼接url：name + mapping 实际就像原始的 Ribbon +ResetTemplate调用方式
OpenFeign原理及其使用方法
热门推荐
weixin_44302046的博客
05-14 1万+
目录 1、OpenFeign基础 1.1、概念 1.2、作用 1.3、Feign和OpenFeign区别 2、OpenFeign使用步骤 2.1、创建Feign消费端微服务 2.2、修改POM文件配置 2.3、编写yaml配置文件 2.4、编写主启动类 2.5、编写业务类 2.5.1、编写 service 层接口，用于服务提供者接口的远程调用 2.5.2、编写 controller 层，用于url映射和service调用 2.6、测试 3、OpenFeign超时控制 3.1、超
OpenFeign原理整理
代码蒋的博客
07-02 695
4.基于上面加载的每一个 FeignClient 接口，会生成一个动态代理对象，指向了一个包含对应方法的 MethodHandler 的 HashMap。生成的动态代理对象会被添加到 Spring 容器中，并注入到对应的服务里。2.然后将解析到的数据封装成元数据，并为每一个方法生成一个对应的 MethodHandler 类作为方法级别的代理。6.从动态代理对象 Proxy 中找到一个 MethodHandler 实例，生成 Request，包含有服务的请求 URL（不包含服务的 IP）。
OpenFeign原理整理【Java面试】
qq_58353992的博客
03-28 1915
1.在 Spring 项目启动阶段，服务 A 的OpenFeign 框架会发起一个主动的扫包流程。2.从指定的目录下扫描并加载所有被 @FeignClient 注解修饰的接口，然后将这些接口转换成 Bean，统一交给 Spring 来管理。3.根据这些接口会经过 MVC Contract 协议解析，将方法上的注解都解析出来，放到 MethodMetadata 元数据中。
OpenFeign的服务调用原理
qq_42098875的博客
07-22 4850
用户
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

快乐江小鱼

知识创造财富，余额还是小数

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值