spring cloud alibaba 学习（六）OpenFeign 初始化流程

已于 2022-02-05 19:42:16 修改
阅读量1.1k 收藏 1
点赞数 1
分类专栏： spring cloud alibaba 文章标签： spring cloud spring cloud alibaba
于 2022-02-05 19:34:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/RenshenLi/article/details/122785963
版权

目录

前言

在spring cloud alibaba 中使用OpenFeign，可以用来使用HTTP请求访问远程服务。

一、使用示例

1、引入依赖

<!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-openfeign -->
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-openfeign</artifactId>
			<version>3.0.0</version>
		</dependency>

2、启动类

加上注解@EnableFeignClients

@SpringBootApplication
@EnableFeignClients
public class CloudApplication {

	public static void main(String[] args) {
		SpringApplication.run(CloudApplication.class, args);
		System.out.println("started...");
	}

}

3、创建服务api接口

用@FeignClient 注解标识，value = “server” 表示要访问的服务提供者的名称是server

@FeignClient(value = "server")
@Component
public interface ServerApi {

    @GetMapping("/server/test/{id}")
    Map test(@PathVariable String id);
}

4、Controller接口

@RestController
@RequestMapping("/client")
public class ClientController {

    @Autowired
    private ServerApi serverApi;

    @GetMapping("/test/{id}")
    public Map test(@PathVariable String id){
        return serverApi.test(id);
    }
}

二、注册FeignClients

1、@EnableFeignClients

在启动类上加上了注解@EnableFeignClients，该注解导入了配置类@Import(FeignClientsRegistrar.class)

2、FeignClientsRegistrar

实现了 ImportBeanDefinitionRegistrar 接口，重写了 registerBeanDefinitions( ) 方法，
在配置类加载过程中，会回调该方法

loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());

3、回调方法

FeignClientsRegistrar.java

@Override
	public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
		//注册默认的配置类
		registerDefaultConfiguration(metadata, registry);
		//注册feign客户端 FeignClients
		registerFeignClients(metadata, registry);
	}

4、注册默认的配置类

private void registerDefaultConfiguration(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
		//获取 @EnableFeignClients 注解信息
		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"));
		}
	}

注册 FeignClientSpecification 类

private void registerClientConfiguration(BeanDefinitionRegistry registry, Object name, Object configuration) {
		BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(FeignClientSpecification.class);
		builder.addConstructorArgValue(name);
		builder.addConstructorArgValue(configuration);
		registry.registerBeanDefinition(name + "." + FeignClientSpecification.class.getSimpleName(),
				builder.getBeanDefinition());
	}

5、注册feign客户端

（1）registerFeignClients( )

public void registerFeignClients(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {

		LinkedHashSet<BeanDefinition> candidateComponents = new LinkedHashSet<>();
		//1、获取 @EnableFeignClients 注解信息
		Map<String, Object> attrs = metadata.getAnnotationAttributes(EnableFeignClients.class.getName());
		//@FeignClient 注解类型过滤器
		AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(FeignClient.class);
		final Class<?>[] clients = attrs == null ? null : (Class<?>[]) attrs.get("clients");
		//2、获取包含@FeignClient 注解的接口
		if (clients == null || clients.length == 0) {
			//注解中没有指定要加载的 FeignClient 接口类，则进行扫描指定的包或当前处理的配置类所在的包
			//获取扫描器
			ClassPathScanningCandidateComponentProvider scanner = getScanner();
			scanner.setResourceLoader(this.resourceLoader);
			//设置注解类型过滤器
			scanner.addIncludeFilter(new AnnotationTypeFilter(FeignClient.class));
			//获取@FeignClient注解上的value/basePackages/basePackageClasses 或当前处理的配置类所在的包
			Set<String> basePackages = getBasePackages(metadata);
			for (String basePackage : basePackages) {
				//找出包含@FeignClient 注解的接口
				candidateComponents.addAll(scanner.findCandidateComponents(basePackage));
			}
		}
		else {
			//注解中指定了要加载的 FeignClient 接口类
			for (Class<?> clazz : clients) {
				candidateComponents.add(new AnnotatedGenericBeanDefinition(clazz));
			}
		}

		//3、解析@FeignClient接口
		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());

				//@FeignClient制定的服务端的名称
				String name = getClientName(attributes);
				//根据服务端的名称注册FeignClientSpecification类
				registerClientConfiguration(registry, name, attributes.get("configuration"));

				//4、注册FeignClient
				registerFeignClient(registry, annotationMetadata, attributes);
			}
		}
	}

6、注册FeignClient

private void registerFeignClient(BeanDefinitionRegistry registry, AnnotationMetadata annotationMetadata,
			Map<String, Object> attributes) {
		String className = annotationMetadata.getClassName();
		//设置类型为 FeignClientFactoryBean，实现了FactoryBean<Object>, InitializingBean, ApplicationContextAware接口
		BeanDefinitionBuilder definition = BeanDefinitionBuilder.genericBeanDefinition(FeignClientFactoryBean.class);
		validate(attributes);
		//获取注解属性，设置到beanDefinition中
		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();
		beanDefinition.setAttribute(FactoryBean.OBJECT_TYPE_ATTRIBUTE, className);

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

		beanDefinition.setPrimary(primary);

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

		BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className, new String[] { alias });
		//注册到spring容器
		BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
	}

三、实例化FeignClients

上一步中注册的 FeignClient 类型为 FeignClientFactoryBean 类型，FeignClientFactoryBean 实现了FactoryBean, InitializingBean, ApplicationContextAware接口，则在实例化过程中会调用 getObject( ) 和 afterPropertiesSet( ) 方法。

1、afterPropertiesSet( )

只是做了一些校验

public void afterPropertiesSet() {
		Assert.hasText(contextId, "Context id must be set");
		Assert.hasText(name, "Name must be set");
	}

2、 getObject( )

public Object getObject() {
		return getTarget();
	}

<T> T getTarget() {
		//这里获取到feign的上下文信息，下面会对FeignContext做分析
		FeignContext context = applicationContext.getBean(FeignContext.class);
		//创建 Feign.Builder
		Feign.Builder builder = feign(context);

		if (!StringUtils.hasText(url)) {
			//没有指定服务端的url，使用服务端的名称
			if (!name.startsWith("http")) {
				url = "http://" + name;
			}
			else {
				url = name;
			}
			url += cleanPath();
			//获取带有负载均衡的客户端
			return (T) loadBalance(builder, context, new HardCodedTarget<>(type, name, url));
		}
		if (StringUtils.hasText(url) && !url.startsWith("http")) {
			url = "http://" + url;
		}
		String url = this.url + cleanPath();
		Client client = getOptional(context, Client.class);
		if (client != null) {
			if (client instanceof FeignBlockingLoadBalancerClient) {
				// not load balancing because we have a url,
				// but Spring Cloud LoadBalancer is on the classpath, so unwrap
				client = ((FeignBlockingLoadBalancerClient) client).getDelegate();
			}
			builder.client(client);
		}
		Targeter targeter = get(context, Targeter.class);
		return (T) targeter.target(this, builder, context, new HardCodedTarget<>(type, name, url));
	}

3、创建 Feign.Builder

（1）feign( )

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

		// @formatter:off
		//根据FeignContext中的configuration，也就是@FeignClient中指定的configuration属性创建，没有指定configuration属性时，根据默认的一些配置创建，默认的配置定义在FeignClientsConfiguration配置类中
		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
		
		//配置Feign.Builder
		configureFeign(context, builder);
		//自定义的一些配置
		applyBuildCustomizers(context, builder);

		return builder;
	}

（2）configureFeign( )

protected void configureFeign(FeignContext context, Feign.Builder builder) {
		//获取FeignClientProperties  @ConfigurationProperties("feign.client")
		FeignClientProperties properties = applicationContext.getBean(FeignClientProperties.class);

		FeignClientConfigurer feignClientConfigurer = getOptional(context, FeignClientConfigurer.class);
		setInheritParentContext(feignClientConfigurer.inheritParentConfiguration());

		if (properties != null && inheritParentContext) {
			if (properties.isDefaultToProperties()) {
				//配置@FeignClient中指定的configuration属性：Logger.Level、Retryer、ErrorDecoder、FeignErrorDecoderFactory、Request.Options、RequestInterceptor、QueryMapEncoder、ExceptionPropagationPolicy
				configureUsingConfiguration(context, builder);
				//配置FeignClientProperties 中的默认属性
				configureUsingProperties(properties.getConfig().get(properties.getDefaultConfig()), builder);
				//配置FeignClientProperties 中指定的属性
				configureUsingProperties(properties.getConfig().get(contextId), builder);
			}
			else {
				configureUsingProperties(properties.getConfig().get(properties.getDefaultConfig()), builder);
				configureUsingProperties(properties.getConfig().get(contextId), builder);
				configureUsingConfiguration(context, builder);
			}
		}
		else {
			configureUsingConfiguration(context, builder);
		}
	}

（3）applyBuildCustomizers( )

自定义配置回调 FeignBuilderCustomizer

private void applyBuildCustomizers(FeignContext context, Feign.Builder builder) {
		Map<String, FeignBuilderCustomizer> customizerMap = context.getInstances(contextId,
				FeignBuilderCustomizer.class);

		if (customizerMap != null) {
			customizerMap.values().stream().sorted(AnnotationAwareOrderComparator.INSTANCE)
					.forEach(feignBuilderCustomizer -> feignBuilderCustomizer.customize(builder));
		}
	}

4、loadBalance( )

protected <T> T loadBalance(Feign.Builder builder, FeignContext context, HardCodedTarget<T> target) {
		//在DefaultFeignLoadBalancerConfiguration中默认创建FeignBlockingLoadBalancerClient
		Client client = getOptional(context, Client.class);
		if (client != null) {
			//设置client
			builder.client(client);
			//默认是DefaultTargeter
			Targeter targeter = get(context, Targeter.class);
			//调用target()
			return targeter.target(this, builder, context, target);
		}

		throw new IllegalStateException(
				"No Feign Client for loadBalancing defined. Did you forget to include spring-cloud-starter-loadbalancer?");
	}

5、target( )

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

 public <T> T target(Target<T> target) {
 	  //创建feign 目标对象
      return build().newInstance(target);
    }

6、build( )

增强feign里的属性，创建ReflectiveFeign

public Feign build() {
	  //通过自定义的Capability来增强各属性
      Client client = Capability.enrich(this.client, capabilities);
      Retryer retryer = Capability.enrich(this.retryer, capabilities);
      List<RequestInterceptor> requestInterceptors = this.requestInterceptors.stream()
          .map(ri -> Capability.enrich(ri, capabilities))
          .collect(Collectors.toList());
      Logger logger = Capability.enrich(this.logger, capabilities);
      Contract contract = Capability.enrich(this.contract, capabilities);
      Options options = Capability.enrich(this.options, capabilities);
      Encoder encoder = Capability.enrich(this.encoder, capabilities);
      Decoder decoder = Capability.enrich(this.decoder, capabilities);
      InvocationHandlerFactory invocationHandlerFactory =
          Capability.enrich(this.invocationHandlerFactory, capabilities);
      QueryMapEncoder queryMapEncoder = Capability.enrich(this.queryMapEncoder, capabilities);

      SynchronousMethodHandler.Factory synchronousMethodHandlerFactory =
          new SynchronousMethodHandler.Factory(client, retryer, requestInterceptors, logger,
              logLevel, decode404, closeAfterDecode, propagationPolicy, forceDecoding);
      ParseHandlersByName handlersByName =
          new ParseHandlersByName(contract, options, encoder, decoder, queryMapEncoder,
              errorDecoder, synchronousMethodHandlerFactory);
      return new ReflectiveFeign(handlersByName, invocationHandlerFactory, queryMapEncoder);
    }
  }

7、newInstance( )

public <T> T newInstance(Target<T> target) {
	//方法名称与SynchronousMethodHandler的映射
    Map<String, MethodHandler> nameToHandler = targetToHandlersByName.apply(target);
    //方法与SynchronousMethodHandler的映射
    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)));
      }
    }
    //创建FeignInvocationHandler
    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;
  }

最终创建出了@FeignClient接口的代理对象

四、FeignContext

FeignContext 作为feign的上下文，包含了 FeignClient中指定的一些配置信息

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(Feign.class)
@EnableConfigurationProperties({ FeignClientProperties.class, FeignHttpClientProperties.class })
@Import(DefaultGzipDecoderConfiguration.class)
public class FeignAutoConfiguration {

	private static final Log LOG = LogFactory.getLog(FeignAutoConfiguration.class);

	@Autowired(required = false)
	private List<FeignClientSpecification> configurations = new ArrayList<>();

	@Bean
	public HasFeatures feignFeature() {
		return HasFeatures.namedFeature("Feign", Feign.class);
	}

	//创建bean FeignContext 
	@Bean
	public FeignContext feignContext() {
		FeignContext context = new FeignContext();
		//设置 FeignClientSpecification 类
		context.setConfigurations(this.configurations);
		return context;
	}
	...
}

FeignClientSpecification 类的注册在第二步中已经分析过。

总结

1、给@FeignClient接口创建代理对象

2、创建增强handler FeignInvocationHandler

3、创建SynchronousMethodHandler或DefaultMethodHandler 处理真正的方法

_lrs
关注
专栏目录
【微服务】SpringBoot启动流程初始化OpenFeign的入口
qq_57756904的博客
10-30 1516
学过SpringCloud的都知道使用OpenFeign都要在SpringBoot启动类上面加上@EnableFeignClients这个注解，而这个注解内部也使用了@Import注解导入FeignClientsRegistrar.class，是ImportBeanDefinitionRegistrar的实现类。 那么会不会也跟前面讲解的SpringBoot自动装配一样呢？感觉是一样，又好像不一样，@EnableFeignClients是spring-cloud-openfeign提供的注解。
SpringCloud Alibaba微服务第5章之项目初始化
qq_57756904的博客
07-04 394
本章节主要任务是初始化项目结构
springcloud openfeign原理-FeignClient初始化以及代理对象的创建
weixin_41300437的博客
10-29 2349
必备知识：ImportBeanDefinitionRegistrar方式实现Bean的动态装载 在ImportBeanDefinitionRegistrar方式实现Bean的动态装载 一文中，@EnableFeignClients 这个注解的作用是，开启openfeign客户端
SpringCloud alibaba openFeign调用教程
weixin_56448318的博客
10-01 229
1.想要远程调用别的服务 1)pom文件中引入open-feign依赖 <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-openfeign</artifactId> </dependency> 2)先在一个微服务.
openFeign正确使用流程
最新发布
Sashay_的博客
09-19 606
docker network create my - net # 创建了一个名为 "my-net" 的网络第一种方式：在这俩都容器启动后将这俩加入到my-net网络中docker run --name xuanyi-mes -p 8081:8081 -d xuanyi-mes:1.0 # 启动mes服务docker run --name xuanyi-kingdee -p 8082:8082 -d xuanyi-kingdee :1.0 # 启动king服务。
8小时学会使用Spring Cloud Alibaba(4)OpenFeign使用
飞熊的博客
10-07 222
一 OpenFeign的作用 声明式Http客户端，用于微服务之间的调用，集成Ribbon的负载均衡。 二 用户微服务 1.entity importcom.fasterxml.jackson.databind.annotation.JsonSerialize; importlombok.AllArgsConstructor; importlombok.Builder; importlombok.Data; importlombok.NoArgsConstructor; importj...
Spring-Cloud-Feign源码阅读(1)-FeignClient是如何初始化的
lipan121623的博客
06-06 836
一、FeignClient的注册器-FeignClientsRegistrar 在Spring Boot应用中要启用Feign，要在SpringBootApplication类上面加上@EnableFeignClients注解。查看@EnableFeignClients注解源码，相比其他的普通注解多了一行@Import({FeignClientsRegistrar.class})。FeignClientsRegistrar类的对象也会被Spring容器管理。 package org.s........
Spring Cloud Alibaba · 01 · 构建SpringCloud聚合项目 & 初始化环境配置
qq_41113339的博客
09-18 485
构建SpringCloud聚合项目 & 初始化环境配置工程结构创建空项目1. 打开Idea,创建一个空项目(Empty Project)项目初始化配置1. 设置项目maven repository2. 统一配置环境编码为UTF-83. 配置JDK编译环境4. 设置项目Java编译器版本创建聚合父模块1. 创建新模块2. 选择模块SDK3. 设置位置4. 配置项目JDK版本5. 删除src目录创建子模块1. 选中父模块，选择新建 - 新模块2. 配置父项、名称、位置添加依赖依赖版本管理全局依赖导入ma
Springcloud_alibaba学习笔记
三明治文鱼的博客
04-21 2920
文章目录0. 简介区别特点组件1. 环境搭建2. Nacosa.作为服务注册中心启动Nacos Client简单上手服务间通信（和之前一样）应用搭建Controller具体实现RestTemplate+Ribbon：OpenFeignb.作为统一配置中心Config Client简单上手ControllerNacos中创建配置Nacos config自动刷新细节1、配置集(Data ID)2、配置分组(Group)3、命名空间(Namespace)4、最佳实践c.配置持久化d. 高可用（集群）nacos高可
SpringCloud（2020新版）Hoxton版 + SpringCloud alibaba1
08-04
SpringBoot是用来简化Spring应用初始搭建以及开发过程的框架，而SpringCloud则是基于SpringBoot实现的云应用开发工具集，它为开发者提供了在分布式系统（如配置管理、服务发现、断路器、路由、微代理、控制总线、一...
feign客户端初始化
weixin_42145727的博客
02-03 759
feign客户端初始化
SpringCloud-Feign-初始化
UCZone
04-24 798
准备 在可以被主context scan的配置类中添加 @EnableFeignClients 最好是在应用入口 申明调用接口 // 基于URL调用 @FeignClient(name = "gitee-client", url = "https://gitee.com/") public interface GiteeService { @GetMapping String h...
feign中SynchonousMethodHandler
xiao_chainiao的博客
08-09 1157
我们知道feign是基于RequestRestTemplate模拟的http请求，如果有研究feign的源码，我们可以发现在SynchonousMethodHandler类下面，有一个targetRequest(RequestTemplate template)方法，这个方法里面会循环的调用interceptor.apply(); 而lcn正是重写了apply方法，将自己的group-id传递到了...
Spring Cloud Open Feign系列【17】MethodHandler方法处理器源码分析
记录知识、锤炼自我
01-05 1365
文章目录前言MethodHandler接口流程分析1. 初始化2. 方法执行 前言 在之前的案例中，我们分析了注解扫描，加载Feign 接口信息为FactoryBean，然后通过动态代理加载到IOC中， 在动态代理的newInstance过程中，会使用契约Contract创建方法元数据（MethodMetadata）,然后通过这些元数据为每个执行方法加载MethodHandler，接下来就具体分析下MethodHandler。 MethodHandler接口 MethodHandler接口非常简单，只有一
Spring Cloud教程 第八弹 Feign源码解读
学无止境！
11-21 983
更多Spring与微服务相关的教程请戳这里Spring与微服务教程合集 1、@EnableFeignClients注解的神秘之处 在使用Feign的时候，我们都知道，需要在springboot的启动类打上@EnableFeignClients注解，才能使Feign生效，那么@EnableFeignClients这个注解到底有哪些神秘之处呢，我们往下看。 首先看一下@EnableFeignClients注解的源码（去除了注释） package org.springframework.cloud.
SpringCloudRPC远程调用核心原理：Feign弹性RPC客户端的重要组件
公众号：该用户快成仙了
08-28 449
Feign弹性RPC客户端的重要组件 在微服务启动时，Feign会进行包扫描，对加@FeignClient注解的RPC接口创建远程接口的本地JDK动态代理实例。之后这些本地Proxy动态代理实例会注入Spring IOC容器中。当远程接口的方法被调用时，由Proxy动态代理实例负责完成真正的远程访问并返回结果。 演示用例说明 为了演示Feign的远程调用动态代理类，接下来的演示用例，将从uaa-provider服务实例向demo-provider服务实例发起RPC远程调用，调用流程如图3-10所示。
Spring Cloud Feign详解
brimsullowr的专栏
01-14 1688
feign是在SpringCloud微服务框架下，实现微服务间相互调用的开发利器，本文演示了简单的demo，并在源码角度详细分析了feign的调用流程，以及关键配置。
【微服务】16 图文源码剖析OpenFeign处理请求流程
健身变秃，coding变强
07-10 3745
1、源码剖析OpenFeign的动态代理如何接收和处理请求？ 2、OpenFeign的LoadBalancerFeignClient的工作流程？ 3、OpenFeign如何与Ribbon、Eureka整合到一起？ 4、OpenFeign如何负载均衡选择出一个Server？ 5、OpenFeign最终发送的请求地址如何拼接出来？ 6、OpenFeign如何将返回的JSON字符串解码为JavaBean？.........
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

_lrs

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值