Spring Cloud Feign【源码篇】Feign 如何进行服务间请求调用

最新推荐文章于 2024-02-05 09:00:00 发布

多隆

最新推荐文章于 2024-02-05 09:00:00 发布

阅读量691

点赞数

分类专栏： # SpringCloud 文章标签： spring cloud

本文链接：https://blog.csdn.net/huayushuangfei/article/details/121288869

版权

SpringCloud 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

参考资料：
Spring Cloud 官网
相关版本：Spring Boot 2.1.5 、 spring cloud Greenwich.SR1
spring-cloud-openfeign 2.1.1

Spring Cloud Feign 默认使用 HTTP 的形式进行远程服务调用。

先来看一个简单的案例，假设此时有一个服务provider 和一个服务consumer。


服务provider	9527	提供接口/hello/{name}
服务consumer	9528	调用服务provider的 hello/{name} 接口

服务consumer 通过 RestTemplate 发起 HTTP 请求调用服务 provider 接口代码如下：

@RequestMapping("/feign/hello/{param}")
public Object hello(@PathVariable String param,) throws InterruptedException {
	return  restTemplate.getForObject("http://localhost:9527/hello/" + param,String.class);
}

在上面代码中，我们通过传入一个字符参数，发起 http 请求，接收一个字符串的返回结果。

假设，此时我们需要传入的是一个对象，对象中存在多个参数，返回结果同样也是一个对象。
这时候，为了能够提高开发效率，我们就需要对 RestTemplate 进行封装，例如，通过反射获取参数对象值，并进行拼接，返回结果同样需要通过反射进行赋值等。

而 Feign 帮我们对 RestTemplate 进行了封装，除此之外，Feign 集成了 Hystrix ，Ribbon 等功能。在之后会针对 Feign 对 Hystrix 和 Ribbon 等集成进行分析。

Feign 简单例子

step1、 引入依赖
step2、 开启 Feign 功能
@EnableFeignClients
step3、 编写相关代码，如下图
在这里插入图片描述
总结：使用 Feign 进行远程调用，只需定义一个 Feign 客户端，通过调用方法的形式，便可完成远程接口调用。

Feign Client 如何被加载到 Spring 中

在上面 Feign 调用的案例中 HelloClient 只需 @FeignClient 注解，然后 @Autowired 进行注入便可完成 Feign Client 注入。

下面通过源码分析，看看 Feign Client 是如何被加载到 Spring 中的。

Feign Client BeanDefinition 信息注册

以 @EnableFeignClients 为入口，进行源码分析

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

通过 EnableFeignClients 源码查看，聚焦 @Import(FeignClientsRegistrar.class) 中的 FeignClientsRegistrar.class。

FeignClientsRegistrar

FeignClientsRegistrar 类实现了 ImportBeanDefinitionRegistrar 。聚焦 FeignClientsRegistrar#registerBeanDefinitions 方法。

知识点：实现了 ImportBeanDefinitionRegistrar 的类，会根据该类的配置属性进行相关 Bean 的动态注入。

FeignClientsRegistrar#registerBeanDefinitions

class FeignClientsRegistrar
		implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {
	@Override
	public void registerBeanDefinitions(AnnotationMetadata metadata,
			BeanDefinitionRegistry registry) {
		// 注册 EnableFeignClients 中配置的相关到 BeanDefinitionRegistry 中
		registerDefaultConfiguration(metadata, registry);
		// 注册 Feign 客户端到 BeanDefinitionRegistry 中
		registerFeignClients(metadata, registry);
	}
｝

方法中调用了两个方法

registerDefaultConfiguration(metadata, registry);
该方法主要是获取注解 @EnableFeignClients 中是否有相关的配置信息，如果有进行配置信息的注册
registerFeignClients(metadata, registry);
该方法是用来将我们定义的带有 @FeignClient 注解的类注册到 BeanDefinitionRegistry 中

追踪主线方法 registerFeignClients(metadata, registry);

FeignClientsRegistra#registerFeignClients

class FeignClientsRegistrar
		implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {
	public void registerFeignClients(AnnotationMetadata metadata,
			BeanDefinitionRegistry registry) {

		// 定义过滤条件，需要包含 FeignClient 
		AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(
				FeignClient.class);

		scanner.addIncludeFilter(annotationTypeFilter);

		// 获取扫描的包
		basePackages = getBasePackages(metadata);

		for (String basePackage : basePackages) {
			// 根据包路径，过滤条件，获取相关类的 BeanDefinition 
			Set<BeanDefinition> candidateComponents = scanner
					.findCandidateComponents(basePackage);
			for (BeanDefinition candidateComponent : candidateComponents) {
				if (candidateComponent instanceof AnnotatedBeanDefinition) {
					// 如果每个 FeignClient 有相关的配置，则进行配置注入
					registerClientConfiguration(registry, name,attributes.get("configuration"));

					// 进行 Feign Client 注入
					registerFeignClient(registry, annotationMetadata, attributes);
				}
			}
		}
	}
}

处理逻辑

1、获取所有需要扫描的包路径。
该路径可以从 EnableFeignClients 中的配置中获取，如：value，basePackages，basePackageClasses。
如果 EnableFeignClients 中没有进行配置，默认扫描包路径为：应用 @EnableFeignClients 的类，也就是 Application 启动类所在包路径为主。
例如：com.qguofeng.Application.class 启动类中 @EnableFeignClients 中没有相关扫描包配置时，则默认扫描 FeignClient 的路径为：com.qguofeng

2、增加扫描条件
在步骤 1 中确定了需要扫描的包路径，为了获取精确数据，增加筛选条件：含有 FeignClient.class 注解的类

3、根据步骤1 确定的扫描路径，步骤二确定的过滤条件，获取含有注解 FeignClient 的所有的相关类的 Set 集合

4、遍历步骤三获取到的 set 集合，如果 FeignClient 相关类注解 @FeignClient 中含有相关的配置类，则进行配置的注入。然后进行类的注入。

我们来看看执行 Feign Client 注册的时候，注册了哪些信息。

FeignClientsRegistra#registerFeignClient

class FeignClientsRegistrar
		implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {

	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 的 Feign Client 的 BeanDefinition 注册到 Spring 中。

通过上面的分析，我们知道了 Feign Client 类相关信息 BeanDefinition 被注册到了 Spring 中，此时 Feign Client 并没有被实例化，Feign Client 真正进行实例化是在 @Autowired 时，才进行的实例化。

Feign Client 实例化

在之前文章中我们提到得依赖注入：IOC/DI
，Spring 在进行依赖注入时会有进行 bean 的实例化操作。

知识点回顾： AbstractAutowireCapableBeanFactory

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
		implements AutowireCapableBeanFactory {
    protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
			throws BeanCreationException {
		......
	    // 实例化对象
		instanceWrapper = createBeanInstance(beanName, mbd, args);
		// 依赖注入 
		populateBean(beanName, mbd, instanceWrapper);
		......
	}
}

而从该方法开始，进行实例化对象获取的路径如下：
其中实例化方法 AbstractAutowireCapableBeanFactory#createBeanInstance 调用 AbstractAutowireCapableBeanFactory#obtainFromSupplier 调用 AbstractAutowireCapableBeanFactory#getObjectForBeanInstance 调用
AbstractBeanFactory#getObjectForBeanInstance 调用 FactoryBeanRegistrySupport#getObjectFromFactoryBean 调用 FactoryBeanRegistrySupport#getObject() 。

上面路径中，最终会调用 org.springframework.beans.factory.FactoryBean#getObject() 获取到实例对象。

Spring 中 Bean 的获取通常都是需要从相对应的工厂类中进行获取，Feign 也不例外。Feign 实例对象获取的工厂类为 FeignClientFactoryBean 。

聚焦 FeignClientFactoryBean#getObject()

class FeignClientFactoryBean
		implements FactoryBean<Object>, InitializingBean, ApplicationContextAware {

	@Override
	public Object getObject() throws Exception {
		return getTarget();
	}

	<T> T getTarget() {
		// Feign 客户端上下文
		FeignContext context = this.applicationContext.getBean(FeignContext.class);
		// Feign 客户端构建起
		Feign.Builder builder = feign(context);

        // 进行 Feign 请求前缀的拼接
        // 如果有配置 url 使用 url，如果没有配置使用 name （相当于服务名称）
		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);
		}

		// 获取Feign 客户端 实例对象
		Targeter targeter = get(context, Targeter.class);
		return (T) targeter.target(this, builder, context,new HardCodedTarget<>(this.type, this.name, url));
	}

}

FeignClientFactoryBean#getTarget() 实例化对象操作中，会有两种形式的方法调用：

return (T) loadBalance(builder, context,new HardCodedTarget<>(this.type, this.name, this.url));
return (T) targeter.target(this, builder, context,new HardCodedTarget<>(this.type, this.name, url));
这两种返回调用最终都是调用的 Targeter#targeter.target(…) 方法。

通过上面的代码

FeignContext context = this.applicationContext.getBean(FeignContext.class);
Targeter targeter = get(context, Targeter.class);

会发现 Targeter 对象直接是从 Spring 上下文中获取到的。

那么究竟 Targeter 是在什么时候加载到 Spring 上下文中的?

通过查看 Targeter 的两个实现类：DefaultTargeter 和 HystrixTargeter。

我们可以聚焦到 Feign 自动配置类 FeignAutoConfiguration

友情链接：Spring Boot自动配置

其中 Targeter 的两个实现类： DefaultTargeter 和 HystrixTargeter。

DefaultTargeter 如果依赖中没有 Hystrix ，以 DefaultTargeter 为实现
HystrixTargeter 如果依赖中有 Hystrix ，以 HystrixTargeter 为实现

上面我们说到Feign Client 最终调用的是 Targeter#targeter.target(…) 方法。这里以 DefaultTargeter 进行展开。

class DefaultTargeter implements Targeter {

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

}

DefaultTargeter#target() 方法调用的 Feign.Builder 的 target() 方法。

聚焦 Feign.Builder 的 target()

public abstract class Feign {
	public static class Builder {
		public <T> T target(Target<T> target) {
	      return build().newInstance(target);
	    }

	}
}

Feign.Builder 的 target() 方法转而调用 ReflectiveFeign#newInstance()

聚焦ReflectiveFeign#newInstance()

public class ReflectiveFeign extends Feign {
  @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;
  }
}

这里主线代码很直观，对 HardCodedTarget<>(this.type, this.name, url) 进行代理，生成一个新的代理对象。

总结

以 @Autowired 为入口，加上 Feign 的自动配置 FeignAutoConfiguration 。我们得到：Feign Client 在依赖注入时，对 Feign Client 进行实例化操作。实例化对象从 FeignClientFactoryBean 工厂中获取，获取到 HardCodedTarget<>(this.type, this.name, url) 该实例对象被 ReflectiveFeign.FeignInvocationHandler 代理。

Feign Client 调用流程

在上面的流程中，Feign Client 生成了一个被 ReflectiveFeign.FeignInvocationHandler 代理的 HardCodedTarget 对象，对象信息如下
在这里插入图片描述
所以在使用 Feign Client 进行调用的时候，方法会进入到 ReflectiveFeign.FeignInvocationHandler 中。

ReflectiveFeign.FeignInvocationHandler 是一个 JDK 动态代理类。

聚焦 ReflectiveFeign.FeignInvocationHandler#invoke() 方法

public class ReflectiveFeign extends Feign {

	private final Map<Method, MethodHandler> dispatch;
	static class FeignInvocationHandler implements InvocationHandler {
		@Override
	    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
	      ......
	      return dispatch.get(method).invoke(args);
	    }
	}
}

dispatch.get(method) 拿到的是一个 SynchronousMethodHandler 。其中包含了 Feign Client 被代理的对象 HardCodedTarget
在这里插入图片描述
聚焦 SynchronousMethodHandler#invoke()

final class SynchronousMethodHandler implements MethodHandler {
	@Override
  	public Object invoke(Object[] argv) throws Throwable {
  		......
  		// 拼接简单的请求
  		RequestTemplate template = buildTemplateFromArgs.create(argv);
  		// 执行请求
  		return executeAndDecode(template);
  		......
  	}
}

将请求参数和请求路径封装成 RequestTemplate ，然后调用 SynchronousMethodHandler#executeAndDecode()方法执行

封装之后 RequestTemplate 信息如下：
在这里插入图片描述
聚焦SynchronousMethodHandler#executeAndDecode

final class SynchronousMethodHandler implements MethodHandler {
	Object executeAndDecode(RequestTemplate template) throws Throwable {
		// 拼装完整的 request 请求
		Request request = targetRequest(template);

		// 发起请求，并获取返回结果 Response
		response = client.execute(request, options);

		// 解析 response 请求，获取最后的结果
		Object result = decode(response);

		// 响应返回结果
		return result;
	}
}

1、拼接完整的 request请求方法 targetRequest(template); 最终会调用 HardCodedTarget#apply() 。HardCodedTarget#apply() 组合封装了完整的 request请求。request请求信息如下：
在这里插入图片描述
上面就是 Feign Client 调用远程服务，并获取到响应数据的主线流程。复杂逻辑处理这里不进行展开。

总结
Feign Client 进行服务间调用分为几个步骤：

1、Spring 根据扫描包中使用了注解 @FeignClient 的 Feign Client 。将 Feign Client 信息抽象成为 BeanDefinition 并注册到 Spring 中。
2、在使用 @Autowired 注入 Feign Client 时，触发依赖注入，根据 Feign Client 的 BeanDefinition 信息，实例化 Feign Client ，并生成代理对象，并放入 IOC 容器中。
3、执行调用是，调用 Feign Client 的代理对象 ReflectiveFeign.FeignInvocationHandler 的 invoke() 方法。该方法经过一系列调用拼装 RequestTemplate 请求对象，并发送请求调用，获取响应。

————————————————
原文链接：https://blog.csdn.net/qq_23202687/article/details/92957118

多隆

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Spring Cloud Feign【源码篇】Feign 如何进行服务间请求调用

参考资料：Spring Cloud 官网相关版本：Spring Boot 2.1.5 、 spring cloud Greenwich.SR1spring-cloud-openfeign 2.1.1Spring Cloud Feign 默认使用 HTTP 的形式进行远程服务调用。先来看一个简单的案例，假设此时有一个服务provider 和一个服务consumer。服务provider9527提供接口/hello/{name}服务consumer9528调用.
复制链接

扫一扫