SpringCloud OpenFeign整合Ribbon实现负载均衡及源码分析

负载均衡器在分布式网络中扮演着非常重要的角色。通过负载均衡，可以实现更好的性能和可靠性，同时提高系统的可扩展性和弹性。目前，SpringCloud体系中，主要使用的有两种�.NETflix的Ribbon以及官方推出的LoadBalancer。本文OpenFeign与Ribbon协同工作的核心流程及源码分析。

使用篇

更换内置策略

策略UML图

Ribbon 通过实现IRule接口，内置了多种负载均衡的策略，默认采用的是 RoundRobinRule，即轮询策略。项目中，服务节点的部署可能存在基础配置、网络环境等的差异，抑或是功能上线需要灰度测试，因此，轮询策略往往不能满足实际需求。

ribbon内置策略

通过修改消费者工程的配置文件，或修改消费者的启动类或 JAVAConfig 类可以实现更换负载均衡策略的目的。

方式一，修改配置文件

修改配置文件，在其中添加如下内容，指定要使用的负载均衡策略 <clientName>. <clientConfigNameSpace>.NFLoadBalancerRuleClassName。【注：clientName是指服务提供者的服务名称】

该方式的好处是，可以为不同的微服务指定相应的负载均衡策略。

复制

xxx-service:
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule

• 1.
• 2.
• 3.

方式二，修改JavaConfig类

在 JavaConfig 类中添加负载 Bean 方法。全局所有feign对应服务都可以生效。

复制

@Configuration
public class FeignConfiguration {
    /**
     * 配置随机的负载均衡策略
     * 特点：对所有的服务都生效
     */
    @Bean
    public IRule loadBalancedRule() {
        return new RandomRule();
    }
}

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.

自定义负载均衡策略

如果上述的策略不满足自身要求，我们还可以自定义负载均衡策略。需要操作 2 个步骤：

第一步，集成 AbstractLoadBalancerRule类，AbstractLoadBalancerRule实现了IRule 中的 setLoadBalancer 和 getLoadBalancer，通过继承 AbstractLoadBalancerRule ，我们就不需要在自己实现这两个方法，而是把关注点放在choose方法上，即只关注如何进行服务的负载上。

复制

/**
 * 自定义负载均衡算法
 */
public class CustomRule extends AbstractLoadBalancerRule {

    @Override
    public void initWithNiwsConfig(IClientConfig clientConfig) {
        // 基本上不需要实现
    }

    @Override
    public Server choose(Object key) {
        // 实现自己的负载均衡算法
    }
}

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.

第二步，修改JavaConfig类，使用自定义的负载均衡策略：

复制

@Configuration
public class FeignConfiguration {
    @Bean
    public IRule loadBalancedRule() {
        return new CustomRule();
    }
}

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.

或者修改配置文件（Application.properties 或 application.yml）：

复制

xxx:
  ribbon:
    NFLoadBalancerRuleClassName: com.xiaopeng.ribbon.CustomRule

• 1.
• 2.
• 3.

Ribbon 核心组件

Ribbon 主要有五大功能组件：ServerList、Rule、Ping、ServerListFilter、ServerListUpdater。

Ribbon 核心组件

（1）负载均衡器 LoadBalancer

用于管理负载均衡的组件。初始化的时候通过加载 YMAL 配置文件创建出来的。

（2）服务列表 ServerList

ServerList 主要用来获取所有服务的地址信息，并存到本地。根据获取服务信息的方式不同，又分为静态存储和动态存储。

• 静态存储：从配置文件中获取服务节点列表并存储到本地。
• 动态存储：从注册中心获取服务节点列表并存储到本地

（3）服务列表过滤 ServerListFilter

将获取到的服务列表按照过滤规则过滤。

• 通过 Eureka 的分区规则对服务实例进行过滤。
• 比较服务实例的通信失败数和并发连接数来剔除不够健康的实例。
• 根据所属区域过滤出同区域的服务实例。

（4）服务列表更新 ServerListUpdater

服务列表更新就是 Ribbon 会从注册中心获取最新的注册表信息。是由这个接口 ServerListUpdater 定义的更新操作。而它有两个实现类，也就是有两种更新方式：

• 通过定时任务进行更新。由这个实现类 PollingServerListUpdater 做到的。
• 利用 Eureka 的事件监听器来更新。由这个实现类 EurekaNotificationServerListUpdater 做到的。

（5）心跳检测 Ping

IPing 接口类用来检测哪些服务可用。如果不可用了，就剔除这些服务。实现类主要有这几个：PingUrl、PingConstant、NoOpPing、DummyPing、NIWSDiscoveryPing。

心跳检测策略对象 IPingStrategy，默认实现是轮询检测。

（6）负载均衡策略 Rule

源码分析

我们知道，如果要使用OpenFeign，需要在项目的启动类增加@EnableFeignClinets注解，接口定义增加@FeignClient注解，这样一来，@EnableFeignClinets会扫描出每个加了@FeignClient注解的接口，然后生成对应的BeanDefinition，最后重新生成一个bean class为FeignClientFactoryBean的BeanDefinition，注册到spring容器。接下来就会根据BeanDefinition来生成feign客户端的代理对象。

Feign代理对象生成过程

生成代理对象后，所有的方法调用的时候最终都会走InvocationHandler接口的实现，默认就是ReflectiveFeign.FeignInvocationHandler。而我们今天要重点分析的就是，FeignInvocationHandler是如何实现远程及负载均衡的。

Feign动态代理调用实现rpc流程分析

FeignInvocationHandler对于invoke方法的实现。

前几个if判断很简单，就是判断是不是调用的方法是不是equals，hashCode，toString，因为这些方法的调是不需要走rpc调用的。

接下就是从dispatch获取要调用的方法对应的MethodHandler，然后调用MethodHandler的invoke方法。那MethodHandler是什么时候生成的呢？MethodHandler是在构建动态代理的时候生成的。那MethodHandler作用是什么呢？你可以理解为最终rpc的调用都是基于这个MethodHandler来实现的，每个方法都有对应MethodHandler来实现rpc调用，接下来我们就来看一下MethodHandler的invoke方法的实现。

MethodHandler是个接口，有两个实现类，一个是DefaultMethodHandler，这个是处理接口中的默认方法的，另一个是SynchronousMethodHandler，这个是实现rpc调用的方法。接下来我们就看看SynchronousMethodHandler关于invoke方法的实现。

第一行通过方法的参数构建了一个RequestTemplate，RequestTemplate可以看成是组装http请求所需各种参数的封装，比如什么情头，body之类的都放在这里面。

第二行 Options options = findOptions(argv); 这个很有意思，Options主要是封装了发送请求是连接超时时间和读超时时间的配置，findOptions(argv)也就是先从参数里面找有没有Options，没有就返回构造SynchronousMethodHandler的入参时的Options，也就是说，连接超时时间和读超时时间可以从方法入参来传入，不过一般没有人这么玩。

第三行就是搞一个重试的组件，是可以实现重试的，一般不设置。

然后执行到executeAndDecode(template, options)，进入这个方法。

首先调用了targetRequest方法：

这个方法会遍历所有的拦截器RequestInterceptor，这是feign的一个扩展点，也就说在发送请求前，仍然还有机会对请求的内容进行调整，比如说加个请求头，这也是很常见的一种方式，在微服务之间鉴权的时候使用。RequestInterceptor是在构建Feign.Builder的时候传进来的，Feign.Builder的组件都是通过ioc容器获取的，组件又是通过配置类来的，所以你需要的话就可以在配置类中声明RequestInterceptor对象。配置类有不同的优先级，按照自己的需求，可以在其中一个优先级使用，不过一般这种通用的东西，不是某个微服务特有的功能，一般选择在springboot启动中的容器中配置。

执行完targetRequest，回到executeAndDecode之后，会构建出一个Request，Request很好理解，就是一个请求，里面封装了http请求的东西。接下来就会调用Client的execute方法来执行请求，拿到响应，接下来就是基于处理这个响应，将响应数据封装成需要返回的参数，之后返回给调用方。

到这里，我们已经分析出接口的动态代理是如何运行的。其实就是通过每个方法对应的MethodHandler来实现的，MethodHandler主要就是拼接各种参数，组装成一个请求，随后交由Client接口的实现去发送请求。

LoadBalancerFeignClient

通过上面分析整个动态代理调用过程可以看出，Client是发送http请求的关键类。那么Client是什么玩意？当Feign客户端在构建动态代理的时候，填充很多组件到Feign.Builder中，其中有个组件就是Client的实现，我们并没有在FeignClientsConfiguration配置类中找到关于Client的对象的声明。这个组件的实现是要依赖负载均衡的，也就是这个组件是Feign用来整合Ribbon的入口。

接下来，我们就着重看一下Client的实现，看看Feign是如何通过ribbon实现负载均衡的。

我们先来看一下Feign跟ribbon整合的配置类。

我们来分析一下，首先通过@Impot注解导入了三个配置类。

• HttpClientFeignLoadBalancedConfiguration：基于HttpClient实现http调用的。
• OkHttpFeignLoadBalancedConfiguration：基于OkHttp实现http调用的。
• DefaultFeignLoadBalancedConfiguration：默认的，也就是Feign原生的发送http的实现。

这里我们看一下DefaultFeignLoadBalancedConfiguration配置类，因为默认就是它，HttpClientFeignLoadBalancedConfiguration和OkHttpFeignLoadBalancedConfiguration都需要有引入HttpClient和OkHttp依赖才会有用。

这个配置类很简单，声明了LoadBalancerFeignClient到spring容器，传入了三个参数，一个Client的实现，一个
CachingSpringLoadBalancerFactory和一个SpringClientFactory。LoadBalancerFeignClient这个类实现了Client接口，也就数说我们在构建Feign.Builder填充的就是这个对象，也就是上面说feign的执行流程最后用来执行请求的Client的实现。

接下来我说一下入参的三个参数是什么意思。

• Client.Default：就是Feign自己实现的Client，里面封装了真正发送http发送请求的功能，LoadBalancerFeignClient虽然也实现了Client接口，但是这个实现其实是为了整合Ribbon用的，并没有发送http的功能，所以需要有个可以发送http功能的实现。
• CachingSpringLoadBalancerFactory：后面会说这个类的作用
• SpringClientFactory：这个跟Feign里面的FeignContext的作用差不多，用来实现配置隔离的，当然，这个也在关于Ribbon的那篇文章有剖析过。
• 其实大家可以自行去看OkHttpFeignLoadBalancedConfiguration和HttpClientFeignLoadBalancedConfiguration，其实他们配置跟DefaultFeignLoadBalancedConfiguration是一样的，声明的对象都是LoadBalancerFeignClient，只不过将Client.Default换成了基于HttpClient和OkHttp的实现，也就是发送http请求使用的工具不一样。

FeignRibbonClientAutoConfiguration除了导入配置类还声明了CachingSpringLoadBalancerFactory，只不过一种是带基于spring实现的重试功能的，一种是不带的，主要看有没有引入spring重试功能的包，所以上面构建LoadBalancerFeignClient注入的CachingSpringLoadBalancerFactory就是在这声明的。

这里就说完了Feign整合ribbon的配置类
FeignRibbonClientAutoConfiguration，我们也找到了构造Feign.Builder的实现LoadBalancerFeignClient，接下来就来剖析LoadBalancerFeignClient的实现。

在动态代理调用的那里我们得出一个结论，那就是最后会调用Client接口的execute方法的实现，所以我们就看一下execute方法的实现，这里就是一堆操作，从请求的URL中拿到了clientName，也就是服务名。

为什么可以拿到服务名？

其实很简单，OpenFeign构建动态代理的时候，传入了一个HardCodedTarget，当时说在构建HardCodedTarget的时候传入了一个url，那个url当时说了其实就是http://服务名，所以到这里，虽然有具体的请求接口的路径，但是还是类似 http://服务名/api/sayHello这种，所以可以通过路径拿到你锁请求的服务名。

拿到服务名之后，再拿到了一个配置类IClientConfig，最后调用lbClient，我们看一下lbClient的方法实现。

就是调用CachingSpringLoadBalancerFactory的create方法。

这个方法先根据服务名从缓存中获取一个FeignLoadBalancer，获取不到就创建一个。

创建的过程就是从每个服务对应的容器中获取到IClientConfig和ILoadBalancer。Ribbon那篇文章都讲过这些核心类，这里不再赘述。

默认就是创建不带spring重试功能的FeignLoadBalancer，放入缓存，最后返回这个FeignLoadBalancer。所以第一次来肯定没有，需要构建，也就是最终一定会返回FeignLoadBalancer，所以我们通过lbClient方法拿到的是FeignLoadBalancer。从这里可以看出
CachingSpringLoadBalancerFactory是构建FeignLoadBalancer的工厂类，只不过先从缓存中查找，找不到再创建FeignLoadBalancer。

拿到FeignLoadBalancer之后就会调用executeWithLoadBalancer，接收到Response之后直接返回。

FeignLoadBalancer

那么这个FeignLoadBalancer又是啥呢？这里放上FeignLoadBalancer核心源码。

FeignLoadBalancer继承自AbstractLoadBalancerAwareClient，AbstractLoadBalancerAwareClient又是啥玩意？看过我写的关于Ribbon核心组件已经运行原理的那篇文章小伙伴肯定知道，AbstractLoadBalancerAwareClient类主要作用是通过ILoadBalancer组件获取一个Server，然后基于这个Server重构了URI，也就是将你的请求路径http://服务名/api/sayHello转换成类似http://192.168.1.101:8088/api/sayHello这种路径，也就是将原服务名替换成服务所在的某一台机器ip和端口，替换之后就交由子类实现的exceut方法来发送http请求。

所以我们知道调用executeWithLoadBalancer之后，就会重构请求路径，将服务名替换成某个具体的服务器所在的ip和端口，之后交给子类execute来处理，对于这里来说，也就是FeignLoadBalancer的execute方法，因为FeignLoadBalancer继承
AbstractLoadBalancerAwareClient。

直接定位到execute方法最核心的一行代码。

request.client()就会拿到构建LoadBalancerFeignClient传入的那个Client的实现，我提到过，这个Client的实现是具体发送请求的实现，默认的就是Client.Default类（不是默认就有可能是基于HttpClient或者是OkHttp的实现）。所以这行代码就是基于这个Client就成功的发送了Http请求，拿到响应，然后将这个Response 封装成一个RibbonResponse返回，最后就返回给MethodHandler，然后解析响应，封装成方法的返回值返回给调用者。

好了，其实到这里就完全知道Feign是如何整合Ribbon的，LoadBalancerFeignClient其实是OpenFeign适配Ribbon的入口，FeignLoadBalancer才是真正实现选择负载均衡，发送http请求的组件，因为他继承了
AbstractLoadBalancerAwareClient。

整个动态代理的调用过程：

 

通过这张图，我们可以清楚地看出OpenFeign、Ribbon以及注册中心之间的协同关系。

总结

OpenFeign在进行rpc调用的时候，由于不知道服务具体在哪台机器上，所以需要Ribbon这个负载均衡组件从服务所在的机器列表中选择一个，Ribbon中服务所在的机器列表是从注册中心拉取的，Ribbon提供了一个ServerList接口，注册中心实现之后，Ribbon就可以获取到服务所在的机器列表，这就是这三个组件最基本的原理。

参考&鸣谢

https://www.cnblogs.com/zzyang/p/16404783.html