FeignClientFactoryBean创建动态代理

FeignClientFactoryBean创建动态代理

探索FeignClient的注册流程

当直接进去注册的方法中，一步步放下走，都是直接放bean的定义信息中放入值，然后转成BeanDefinitionHolder,最后在注册到IOC容器中。 具体的信息可以看下面断点的图。

在仔细看一下就会发现很奇怪，为什么此处传入的是FeignClientFactoryBean，然后把feignclient的信息放它的里面，那我们就进去看看。

那我们就进行看一下FeignClientFactoryBean，里面的内容

首先发现它实现了FactoryBean接口，可以返回bean的实例的工厂bean，通过实现该接口可以对bean进行一些额外的操作。此处肯定重写了getObject方法，就是在此处，这个方法可以往容器中注入Bean的。

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

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

在getObject⽅法中，⾸先从applicationContext中、也就是从Spring容器中获取了⼀个FeignContext组件，应该是Feign存放⼯具类的⼀个上下⽂组件，然后从FeignContext中获取到了FeignLoggerFactory组件，⼀路追进去发现，原来在底层也是维护了⼀个Spring容器的缓存Map<String, AnnotationConfigApplicationContext>。Feign在执⾏时涉及到⼀系列的组件，所以Feign⼲脆为每个服务创建了⼀个Spring容器类ApplicationContext，⽤来存放每个服务各⾃所需要的组件，每个服务的这些⼯具类、组件都是互不影 响的，所以我们看到它在底层是通过⼀个Map来缓存的，key为服务名，value为服务所对应的的spring
容器ApplicationContext。

接下来我们陆续看到了其他的组件如：Decoder、Encoder、Contract等都被创建了出来，都设置到了Feign.Builder组件中，看来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、FeignLoggerFactory还是Encoder、Decoder、Contract，他们都是接⼝

发现在同包下面还有一个FeignClientsConfiguration配置类，那就点进去看看。

Decoder、Encoder、Contract、FeignLoggerFactory的实际类型都很顺利的找到了。
因为Feign最终还是要发送HTTP请求，这⾥就难免要涉及到序列化和反序列化、这个过程就会牵扯到编码和解码的过程，Encoder和Decoder就派上⽤场了。
因为Feign⾃带的注解@FeignClient、以及SpringMVC注解它们是被谁处理的呢？Contract的实现类SpringMVCContract就是来解析它们的，解析所有的注解信息、然后拼凑成⼀个完整的HTTP请求所需要的信息。

在最后一行，有一个这个方法configureFeign(context, builder);，看方法名字就是配置feign，猜一猜应该是把配置文件的一些配置绑定到feign的配置类上。

	protected void configureFeign(FeignContext context, Feign.Builder builder) {
		FeignClientProperties properties = this.applicationContext
				.getBean(FeignClientProperties.class);

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

		if (properties != null && inheritParentContext) {
			if (properties.isDefaultToProperties()) {
                               //这行默认取的是配置文件的信息。
				configureUsingConfiguration(context, builder);
                              //这行取的是yml中的默认配置
				configureUsingProperties(
						properties.getConfig().get(properties.getDefaultConfig()),
						builder);
                              //这行是yml中指定服务的配置
				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);
		}
	}

下图为配置类中的信息

下面为指定服务的yml中的信息

服务的配置信息优先级是要⽐默认配置要⾼的，所以也会覆盖默认的配置信息。分析到这⾥，Feign要创建⼀个对象的所需要的信息都设置的差不多了，简单来说就四⼤部分：
（1）默认的组件
（2）⾃定义组件
（3）默认的配置信息
（4）指定服务的配置信息

创建Feign的动态代理对象

然后我们就继续放行，最终得到了Feign.Builder对象，然后我们继续放行，来到了截图的哪行，这里会返回一个对象。

点进去，我们继续分析，第一行我们直接过，但是看idea的提示类型是LoadBalancerFeignClient，LoadBalancer是ribbon的三大核心组件之一，应该是和reibbon负载均衡有关系。

那我们就找一下它是在那个配置类被创建的。

接下来，我们看到它直接从容器中获取了⼀个Targeter对象，这个对象是HystrixTargeter对象，在FeignAutoConfiguration 中找到、然后直接调⽤target⽅法，如下图所示：

那我们就来到它的这个方法中，继续放下放行：

⼀路顺势跟到⾥⾯后发现，target⽅法中、调⽤了build⽅法，⾥⾯创建了SynchronousMethodHandler.Factory，翻译起来也就是同步⽅法处理器的⼯⼚类，具体⼲什么⽤的、⽬前也不是好确定，反正只知道⼯⼚就是⽤来创建对象⽤的，然后它把这个⼯⼚类放到了ParseHandlersByName中，并且new上了⼀个ReflectiveFeign对象并返回了。

紧接着调⽤了newInstance⽅法，看样⼦是要创建⼀个对象，继续跟进看下：

    public <T> T target(Target<T> target) {
      return build().newInstance(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;
  }

看见 InvocationHandler handler = factory.create(target, methodToHandler);这行，基本就可以确定，是创建了动态代理。因为前面解析@FeignClient注解，并且封装了一个Bean的定义信息注册中Ioc容器中，比较ServiceAClient毕竟是一个接口，所以给每个接口创建了一个动态代理，然后调用接口时，去让动态代理来执行

一进入到这个方法中，会看到有2个Map和一个List，那我们就先看一下第一个map，里面的数据如下图：

当我们点进apply方法的时候，进⼊到apply⽅法中、发现contract通过调⽤parseAndValidateMetadata⽅法得到了、List、也就是接⼝中的所有⽅法的元数据信息，然后遍历这些⽅法，通过factory创建MethodHandler，⽽这⾥的 factory就是我们前⾯在build⽅法中看到的SynchronousMethodHandler.Factory 。

后面的话，会遍历所有的nameToHandler，把它转成methodToHandler。

最终来到了这行InvocationHandler handler = factory.create(target, methodToHandler);把上面获取到的方法和要代理的对象都放到了FeignInvocationHandler中。

最终创建出了代理对象。