OpenFeign 源码分析

一、基本流程

BeanDefinition builderdefinition = BeanDefinitionBuilder.genericBeanDefinition(FeignClientFactoryBean.class);

核心就是 FeignClientFactoryBean 类，根据类的名字我们可以知道这是一个工厂类，用来创建 FeignClient Bean 的。

最开始用的 @FeignClient，里面有个参数 "passjava-study"，这个是注解的属性，当 OpenFeign 框架去创建 FeignClient Bean 的时候，就会使用这些参数去生成 Bean。流程图如下：

• 解析 @FeignClient 定义的属性。
• 将注解@FeignClient 的属性 + 接口 StudyTimeFeignService的信息构造成一个 StudyTimeFeignService 的 beanDefinition。
• 然后将 beanDefinition 转换成一个 holder，这个 holder 就是包含了 beanDefinition, alias, beanName 信息。
• 最后将这个 holder 注册到 Spring 容器中

AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();
		Class<?> type = ClassUtils.resolveClassName(className, null);
		beanDefinition.setAttribute(FactoryBean.OBJECT_TYPE_ATTRIBUTE, type);
		// has a default, won't be null
		boolean primary = (Boolean) attributes.get("primary");
		beanDefinition.setPrimary(primary);
		BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className, qualifiers);
		BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
		registerRefreshableBeanDefinition(registry, contextId, Request.Options.class, OptionsFactoryBean.class);
		registerRefreshableBeanDefinition(registry, contextId, RefreshableUrl.class, RefreshableUrlFactoryBean.class);

使用OpenFeign的调用流程如下

二、OpenFeign动态代理

动态代理的代码入口

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

1.先获取feignClientFactory

2.然后根据feignClientFactory初始化feign的builder，设置各种属性和interceptor

<T> T getTarget() {
		FeignClientFactory feignClientFactory = beanFactory != null ? beanFactory.getBean(FeignClientFactory.class)
				: applicationContext.getBean(FeignClientFactory.class);
		Feign.Builder builder = feign(feignClientFactory);
		if (!StringUtils.hasText(url) && !isUrlAvailableInConfig(contextId)) {

			if (LOG.isInfoEnabled()) {
				LOG.info("For '" + name + "' URL not provided. Will try picking an instance via load-balancing.");
			}
			if (!name.startsWith("http://") && !name.startsWith("https://")) {
				url = "http://" + name;
			}
			else {
				url = name;
			}
			url += cleanPath();
			return (T) loadBalance(builder, feignClientFactory, new HardCodedTarget<>(type, name, url));
		}
		if (StringUtils.hasText(url) && !url.startsWith("http://") && !url.startsWith("https://")) {
			url = "http://" + url;
		}
		Client client = getOptional(feignClientFactory, 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();
			}
			if (client instanceof RetryableFeignBlockingLoadBalancerClient) {
				// not load balancing because we have a url,
				// but Spring Cloud LoadBalancer is on the classpath, so unwrap
				client = ((RetryableFeignBlockingLoadBalancerClient) client).getDelegate();
			}
			builder.client(client);
		}

		applyBuildCustomizers(feignClientFactory, builder);

		Targeter targeter = get(feignClientFactory, Targeter.class);
		return targeter.target(this, builder, feignClientFactory, resolveTarget(feignClientFactory, contextId, url));
	}

3.通过负载均衡，获取适合的client

  获取client，然后调用targeter.target

protected <T> T loadBalance(Feign.Builder builder, FeignClientFactory context, HardCodedTarget<T> target) {
		Client client = getOptional(context, Client.class);
		if (client != null) {
			builder.client(client);
			applyBuildCustomizers(context, builder);
			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-loadbalancer?");
	}

public <T> T target(Target<T> target) {
	//创建一个动态代理类,最终会调用 ReflectiveFeign.newInstance
      return build().newInstance(target);
  }

public Feign build() {
  //这个方法是用来创建一个动态代理的方法，在生成动态代理之前，
  //会根据Contract协议（协议解析规则，解析接口类的注解信息，
  //解析成内部的MethodHandler的处理方式。会解析我们在每个接口中定义的参数，
  //方法类型等。
      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);
      //ReflectiveFeign创建一个动态代理类
      return new ReflectiveFeign(handlersByName, invocationHandlerFactory, queryMapEncoder);
    }

//target就是我们的原始接口
public <T> T newInstance(Target<T> target) {
//根据接口类和Contract协议解析方式，解析接口类上的方法和注解，转换成内部的MethodHandler处理方式
//nameToHandle集合包含的属性可以看下面的图进行理解
    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()) {
    //如果是Object中提供的方法，跳过
      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)));
      }
    }
    // 基于Proxy.newProxyInstance 为接口类创建动态实现，将所有的请求转换给InvocationHandler 处理。
    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;
  }

ReflectiveFeign 做的工作就是为带有 @FeignClient 注解的接口，创建出接口方法的动态代理对象。

• 解析 FeignClient 接口上各个方法级别的注解，比如远程接口的 URL、接口类型（Get、Post 等）、各个请求参数等。这里用到了 MVC Contract 协议解析，后面会讲到。
• 然后将解析到的数据封装成元数据，并为每一个方法生成一个对应的 MethodHandler 类作为方法级别的代理。相当于把服务的请求地址、接口类型等都帮我们封装好了。这些 MethodHandler 方法会放到一个 HashMap 中。
• 然后会生成一个 InvocationHandler 用来管理这个 hashMap，其中 Dispatch 指向这个 HashMap。
• 然后使用 Java 的 JDK 原生的动态代理，实现了 FeignClient 接口的动态代理 Proxy 对象。这个 Proxy 会添加到 Spring 容器中。
• 当要调用接口方法时，其实会调用动态代理 Proxy 对象的 methodHandler 来发送请求。

OpenFeign调用过程

@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();
      }
// 利用分发器筛选方法，找到对应的handler 进行处理,也就是根据请求目标对应的url找到需要执行的方法进行调用
      return dispatch.get(method).invoke(args);
    }

SynchronousMethodHandler.invoke 而接着，在invoke方法中，会调用 this.dispatch.get(method)).invoke(args) 。this.dispatch.get(method) 会返回一个SynchronousMethodHandler，进行拦截处理。这个方法会根据参数生成完成的RequestTemplate对象，这个对象是Http请求的模版。

@Override
  public Object invoke(Object[] argv) throws Throwable {
  	//得到RequestTemplate 对象
    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;
      }
    }
  }

  Object executeAndDecode(RequestTemplate template, Options options) throws Throwable {
  //获取Request对象
    //此处也是自定义拦截器的实现
    Request request = targetRequest(template);

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

    Response response;
    long start = System.nanoTime();
    try {
    //发起远程通信
    //这里的 client.execute 的 client 的类型是LoadBalancerFeignClient
    //走到这里就是我们前门分析的ribbon那一套了，这里不做说明
      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());
      }
    }
  }

         

             

三、OpenFeign发送请求的原理

四、Feign Client的注册

看下注册入口，方法registerBeanDefinitions

包括注册默认配置和注册Feign客户端列表

class FeignClientsRegistrar
        implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {
        
    @Override
    public void registerBeanDefinitions(AnnotationMetadata metadata,
            BeanDefinitionRegistry registry) {
        //注册@EnableFeignClients中定义defaultConfiguration属性下的类，包装成FeignClientSpecification，注册到Spring容器。
　　  //在@FeignClient中有一个属性：configuration，这个属性是表示各个FeignClient自定义的配置类，
        //后面也会通过调用registerClientConfiguration方法来注册成FeignClientSpecification到容器。
　　  //所以，这里可以完全理解在@EnableFeignClients中配置的是做为兜底的配置，在各个@FeignClient配置的就是自定义的情况。   
        registerDefaultConfiguration(metadata, registry);
        
        
        //该方法负责读取@EnableFeignClients的属性，获取需要扫描的包名，
        //然后扫描指定的所有包名下的被@FeignClient注解注释的接口，
        //将扫描出来的接口调用registerFeignClient方法注册到spring容器。
        registerFeignClients(metadata, registry);
    }
}

先看下注册默认配置registerDefaultConfiguration

class FeignClientsRegistrar
        implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {

    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"));
        }
    }
    
    private void registerClientConfiguration(BeanDefinitionRegistry registry, Object name,
            Object configuration) {
        //加载FeignClientSpecification bean   
        BeanDefinitionBuilder builder = BeanDefinitionBuilder
                .genericBeanDefinition(FeignClientSpecification.class);
        builder.addConstructorArgValue(name);
        builder.addConstructorArgValue(configuration);
        //注册FeignClientSpecification类型的Bean
        registry.registerBeanDefinition(
                name + "." + FeignClientSpecification.class.getSimpleName(),
                builder.getBeanDefinition());
    }
}

继续看注册FeignClients列表

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

		Set<String> basePackages;
		//收集该注解的元数据信息：value ，basePackages ，basePackageClasses 等
		Map<String, Object> attrs = metadata
				.getAnnotationAttributes(EnableFeignClients.class.getName());
	  // 构造过滤器 用于过滤添加了FeignClient的类
    AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(
				FeignClient.class);
		//获取@EnableFeignClients注解中的client属性
		final Class<?>[] clients = attrs == null ? null
				: (Class<?>[]) attrs.get("clients");
		// 如果没有指定clients，则从EnableFeignClients取出包路径
		if (clients == null || clients.length == 0) {
			//添加需要扫描的注解@FeignClient
			scanner.addIncludeFilter(annotationTypeFilter);
			//该方法就是根据@EnableFeignClients注解的属性信息去获取需要扫描的路径
			basePackages = getBasePackages(metadata);
		}
		
        //如果指定了clients，则为其添加一个特定的过滤器，
        //只保留clients内的FeignClient客户端
		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)));
		}
		//遍历所有的路径获取标有@FeignClient注解的接口
		for (String basePackage : basePackages) {
			//找到候选的对象（标有@FeignClient注解的接口）封装成BeanDefinition对象
			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");
					//获取每个接口中定义的元数据信息，即@FeignClient注解中配置的属性值例如，value,name,path,url等
					Map<String, Object> attributes = annotationMetadata
							.getAnnotationAttributes(
									FeignClient.class.getCanonicalName());
					//获取name的属性值
					String name = getClientName(attributes);
					//注册被调用客户端配置
                    //注册(微服务名).FeignClientSpecification类型的bean
                    //对beanname的名称进行拼接: name.FeignClientSpecification ，例如我们上面获取的naem值等于：${feign.baseInfoManagement.name:baseInfoManagement/baseInfoManagement}
                    //拼接后：${feign.baseInfoManagement.name:baseInfoManagement/baseInfoManagement}.FeignClientSpecification               
					registerClientConfiguration(registry, name,
							attributes.get("configuration"));
                    注册 FeignClient 重点分析*****
					registerFeignClient(registry, annotationMetadata, attributes);
				}
			}
		}
	}

	protected Set<String> getBasePackages(AnnotationMetadata importingClassMetadata) {
		//@EnableFeignClients 元数据信息就是我们在该注解中配置的key:value值
		Map<String, Object> attributes = importingClassMetadata
				.getAnnotationAttributes(EnableFeignClients.class.getCanonicalName());
		//遍历属性信息，拿到需要扫描的路径
		Set<String> basePackages = new HashSet<>();
		for (String pkg : (String[]) attributes.get("value")) {
			if (StringUtils.hasText(pkg)) {
				basePackages.add(pkg);
			}
		}
		for (String pkg : (String[]) attributes.get("basePackages")) {
			if (StringUtils.hasText(pkg)) {
				basePackages.add(pkg);
			}
		}
		for (Class<?> clazz : (Class[]) attributes.get("basePackageClasses")) {
			basePackages.add(ClassUtils.getPackageName(clazz));
		}

		if (basePackages.isEmpty()) {
			basePackages.add(
					ClassUtils.getPackageName(importingClassMetadata.getClassName()));
		}
		return basePackages;
	}

   把接口对应的代理类注入到ioc容器中：注册 FeignClient，组装BeanDefinition，实质是一个FeignClientFactoryBean，然后注册到Spring IOC容器。

Spring容器启动，调用AbstractApplicationContext#refresh方法，在refresh方法内部调用finishBeanFactoryInitialization方法对单例bean进行初始化，

finishBeanFactoryInitialization方法调用getBean获取name对应的bean实例，如果不存在，则创建一个，即调用doGetBean方法。

doGetBean调用createBean方法，createBean方法调用doCreateBean方法。

doCreateBean()方法主要是根据 beanName、mbd、args，使用对应的策略创建 bean 实例，并返回包装类 BeanWrapper。

doCreateBean方法中调用populateBean对 bean 进行属性填充；其中，可能存在依赖于其他 bean 的属性，则会递归初始化依赖的 bean 实例，初始化阶段又涉及到三级缓存以及AOP的实现。

继续深入看注册Feign Client方法

private void registerFeignClient(BeanDefinitionRegistry registry, AnnotationMetadata annotationMetadata,
			Map<String, Object> attributes) {
		String className = annotationMetadata.getClassName();
		if (String.valueOf(false).equals(
				environment.getProperty("spring.cloud.openfeign.lazy-attributes-resolution", String.valueOf(false)))) {
			eagerlyRegisterFeignClientBeanDefinition(className, attributes, registry);
		}
		else {
			lazilyRegisterFeignClientBeanDefinition(className, attributes, registry);
		}
	}

根据元数据的className，分成急注册和延迟注册

先看下急注册eagerlyRegisterFeignClientBeanDefinition

再看下延迟注册lazilyRegisterFeignClientBeanDefinition

五、Feign的自动配置