SpringCloud OpenFeign使用及原理

最新推荐文章于 2024-06-28 19:38:43 发布

猿小猴

最新推荐文章于 2024-06-28 19:38:43 发布

阅读量1.1k

点赞数

分类专栏： SpringCloud 文章标签： java spring 后端

本文链接：https://blog.csdn.net/m0_37044584/article/details/114372792

版权

SpringCloud 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

OpenFeign使用及原理

1.是什么

OpenFeign是一个伪客户端，为微服务架构下服务之间的调用提供了解决方案，之所以是伪客户端是因为它不做任何的请求处理。Feign通过处理注解生成request，从而实现简化HTTP API开发的目的，即开发人员可以使用注解的方式定制request api模板，在发送http request请求之前，feign通过处理注解的方式替换掉request模板中的参数，这种实现方式显得更为直接、可理解。

2.怎么用

OpenFeign使用起来很简单，需要引入依赖，增加两个注解@EnableFeignClients、@FeignClient。
写一个示例演示下：

2.1 增加依赖

在消费者工程中增加openfeign的依赖：

<dependency><!--可以支持OKHTTP-->
           <groupId>org.springframework.cloud</groupId>
           <artifactId>spring-cloud-starter-openfeign</artifactId>
           <version>2.2.3.RELEASE</version>
  </dependency>

2.2 定义服务接口

在接口上增加 @FeignClient注解

@FeignClient("spring-cloud-user-service")
public interface OrderServiceFeignClient {

   @GetMapping("/user")
   String getUser();

}

2.3 定义访问服务的控制层

@RestController
public class OrderControllerFeignClient {
   @Autowired
   OrderServiceFeignClient orderServiceFeignClient;
   @RequestMapping("/orderFeign/{id}")
   public String getOrdersById(){

       return orderServiceFeignClient.getUser();
   }
}

}

2.4 在程序启动类加@EnableFeignClients

在消费者工程启动程序类加上@EnableFeignClients注解，开启Feign功能，如果启动类和@FeignClient所在的包在同一级，可以不加basePackages 。

@EnableFeignClients(basePackages = "com.xiaohou.springcloud.demo.order")
@SpringBootApplication
public class SpringCloudOrderServiceApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringCloudOrderServiceApplication.class, args);
    }

}

2.5 创建服务提供者程序

如用户服务
（1）application.properties中设置端口和服务名称

server.port=9091
spring.application.name=spring-cloud-user-service

（2）创建服务接口

@RestController
public class UserService {
    @Value("${server.port}")
    private int port;

    @GetMapping("/user")
    public String getUser(){
        System.out.println("port:"+port);
        return "provider port = "+port;
    }

}

2.5 启动程序测试

服务提供者程序类至少启动两个，可以在Configurations 中设置，如图：
在这里插入图片描述

消费者程序启动，浏览器中输入url:http://localhost:9090/orderFeign/1
在这里插入图片描述

3 为什么(原理）

首先来看OpenFeign只增加了两个注解就完成了远程通信，所以分析原理要从这两个注解入手：

@EnableFeignClients
在这里插入图片描述
@import之前分析SpringBoot自动装配原理的时候说明过，再次说明下：

@Import:
（1）如果括号中的类实现了ImportSelector接口，spring容器就会实例化此类，并且调用其selectImports方法。
（2）如果实现了DeferredImportSelector接口，spring容器就会实例化此类，并且调用其selectImports方法，DeferredImportSelector是ImportSelector的子类，和ImportSelector的实例不同的是，DeferredImportSelector的实例的selectImports方法调用时机晚于ImportSelector的实例，要等到@Configuration注解中相关的业务全部都处理完了才会调用。
（3）如果实现了ImportBeanDefinitionRegistrar接口，spring容器就会实例化此类，并且调用其registerBeanDefinitions方法；
（4）如果没有实现 ImportSelector、DeferredImportSelector、ImportBeanDefinitionRegistrar等其中的任何一个，spring容器就会实例化此类

FeignClientsRegistrar实现了ImportBeanDefinitionRegistrar接口，会调用registerBeanDefinitions方法
registerBeanDefinitions() ：

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

registerDefaultConfiguration（）:
在启动配置上检查是否有@EnableFeignClients注解，如果有该注解，则开启包扫描，扫描被@FeignClient注解的接口

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

registerFeignClients() 方法
程序启动后通过包扫描，当类有@FeignClient注解，将注解的信息取出，连同类名一起取出，赋给BeanDefinitionBuilder，然后根据BeanDefinitionBuilder得到beanDefinition，最后beanDefinition注入到ioc容器中,比较特殊的是注入到容器的是一个工厂bean:FeignClientFactoryBean,源码在registerFeignClient方法中

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();
		//将工厂bean:FeignClientFactoryBean注入到IOC容器中
		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();
		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 });
		BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
	}

工厂bean:
在Spring容器中有一类特殊的bean叫工厂bean，普通的bean注入容器内的方式是通过调用其无参构造器创建一个对象导入在容器中，而工厂bean会通过FactoryBean的接口的getObject()方法将对象注册在容器中。

FactoryBean.java源码,getObject调用getTarget()方法

@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 = 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();
			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();
			}
			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<>(this.type, this.name, url));
	}

进入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()方法，最终进入ReflectiveFeign.newInstance方法

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

InvocationHandler：处理被拦截的方法，也就是本示例中的getOrdersById
在这里插入图片描述
进入invoke方法，SynchronousMethodHandler#invoke方法
当FeignClient的方法被拦截会根据参数生成RequestTemplate对象，该对象就是http请求的模板

  @Override
  public Object invoke(Object[] argv) throws Throwable {
    RequestTemplate template = buildTemplateFromArgs.create(argv);
    Options options = findOptions(argv);
    Retryer retryer = this.retryer.clone();
    while (true) {
      try {
        return executeAndDecode(template, options);
      } 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()方法，该方法是通RequestTemplate生成Request请求对象，然后根据用client获取response。
进入executeAndDecode方法：

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

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

    Response response;
    long start = System.nanoTime();
    try {
      response = client.execute(request, options);
      // ensure the request is set. TODO: remove in Feign 12
      response = response.toBuilder()
          .request(request)
          .requestTemplate(template)
          .build();
   //代码省略
  }

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

再往下就是结合ribbon的负载均衡算法来实现了，不深究了。

4 一张图总结

在这里插入图片描述
说明：这张图不是我画的，是上课老师画的，源码分析也是根据这张图一点点看代码明白的，图片更清晰直观。

参考文章：https://cloud.tencent.com/developer/article/1009212

猿小猴

关注

0
点赞
踩
5

收藏

觉得还不错? 一键收藏
3
评论
SpringCloud OpenFeign使用及原理

OpenFeign使用及原理1.是什么2.怎么用2.1 增加依赖2.2 定义服务接口2.3 定义访问服务的控制层2.4 在程序启动类加@EnableFeignClients1.是什么OpenFeign是一个伪客户端，为微服务架构下服务之间的调用提供了解决方案，之所以是伪客户端是因为它不做任何的请求处理。Feign通过处理注解生成request，从而实现简化HTTP API开发的目的，即开发人员可以使用注解的方式定制request api模板，在发送http request请求之前，feign通过处理注解
复制链接

扫一扫

专栏目录