大致流程图

FeignClientFactoryBean的getObject

获取FeignContext对象，里面有服务名和AnnotationConfigApplicationContext的映射，可以获取实例，然后创建Feign.Builder。

feign

进行FeignLoggerFactory的创建，可以为某个接口配置，然后可以输出相关请求和相应信息的。然后根据上下文获取Feign.Builder类型的实例，并设置一些属性，最后做一些配置。

loadBalance获取代理对象

将前面获取到的对象注入，并创建HardCodedTarget对象，封装了接口类型，服务名字和拼接好的URL，这个对象可以理解为被代理对象。

内部会先创建SpringClientFactory，然后包装成CachingSpringLoadBalancerFactory，再从上下文中获取LoadBalancerFeignClient实例，放进Feign.Builder里，再获取Targeter类型的实例，是HystrixTargeter对象，好像是因为有相关类feign.hystrix.HystrixFeign。

HystrixTargeter的target

进行目标对象的代理，其实就是设置了一些属性，最后调用Feign.Builder进行代理处理的。如果是feign.hystrix.HystrixFeign.Builder类型的话，下面就会有一些熔断机制的设置，这个以后说吧。

Feign.Builder的target

创建一个ReflectiveFeign对象，这里有个方法处理器的工厂，后面的方法处理器都是他创建的，也就是SynchronousMethodHandler对象，里面封装了很多东西，等于是个包装类。

ReflectiveFeign的newInstance

这里就是动态代理的地方啦，获取目标接口类型的所有方法，封装成SynchronousMethodHandler，然后放入方法映射里，最后创建一个InvocationHandler的子类ReflectiveFeign.FeignInvocationHandler，封装目标对象HardCodedTarget和方法处理器映射methodToHandler ，然后Proxy.newProxyInstance进行动态代理。

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

至此，动态代理对象获取了，然后容器会继续执行，会将Ribbon相关的配置也注入进来，因为底层负载均衡有用Ribbon。下篇讲下这么处理请求的原理。

好了，今天就到这里了，希望对学习理解有帮助，大神看见勿喷，仅为自己的学习理解，能力有限，请多包涵。