第三章 Ribbon负载均衡及源码解析笔记

谁践踏了优雅 2023-07-18 03:13 12阅读 0赞

现在服务提供方已经可以通过Eureka进行注册了，但对于服务的消费者，目前并没有处理，对于服务的消费方，也应该连接上eureka，进行服务的获取，这个时候就应该使用Ribbon这个组件了。

代码Git地址：https://gitee.com/hankin\_chj/springcloud-micro-service.git

## **一、Ribbon基本使用** ##

### **1、Ribbon配置介绍** ###

**1.1、对应的pom文件如下**

<**dependency**>  
    <**groupId**>org.springframework.cloud</**groupId**>  
    <**artifactId**>spring-cloud-starter-netflix-ribbon</**artifactId**>  
</**dependency**>

注意：如果是Edgware或之前的版本，ribbon文件如下：

<**dependency**>  
    <**groupId**>org.springframework.cloud</**groupId**>  
    <**artifactId**>spring-cloud-starter-ribbon</**artifactId**>  
</**dependency**

在用到负载均衡之前，先要到eureka中获取相关的服务，所以我们这一块依然需要用到eureka，但eureka中已经内置集成了ribbon，所以在pom文件中，并不需要显示引入ribbon的依赖。

**1.2、bootstrap.properties配置文件可以指定某个微服务配置**

springcloud-service2020\\springcloud-web\\src\\main\\resources\\bootstrap.properties

**spring.application.name**=**micro-web**  
**server.port**=**8083**  
*\#eureka.client.serviceUrl.defaultZone=http\\://localhost\\:8763/eureka/*  
**eureka.client.serviceUrl.defaultZone**=**http://admin:admin@localhost:8763/eureka/**  
*\#服务续约，心跳的时间间隔*  
**eureka.instance.lease-renewal-interval-in-seconds**=**30**   
*\#如果从前一次发送心跳时间起，90 秒没接受到新的心跳，剔除服务*  
**eureka.instance.lease-expiration-duration-in-seconds**=**90**   
*\#表示 eureka client 间隔多久去拉取服务注册信息，默认为 30 秒*  
**eureka.client.registry-fetch-interval-seconds**=**30**  
*\# 关闭ribbon访问注册中心Eureka Server发现服务，但是服务依旧会注册。*  
*\#true使用eureka false不使用*  
**ribbon.eureka.enabled**=**true**  
*\#指定调用的节点    localhost:8001  localhost:8002  localhost:8003*  
**micro-order.ribbon.listOfServers=localhost:8001,localhost:8002,localhost:8003**  
*\#单位ms ,请求连接超时时间*  
**micro-order.ribbon.ConnectTimeout**=**1000**  
*\#单位ms ,请求处理的超时时间*  
**micro-order.ribbon.ReadTimeout**=**2000**  
**micro-order.ribbon.OkToRetryOnAllOperations**=**true**  
*\# 切换实例的重试次数*  
**micro-order.ribbon.MaxAutoRetriesNextServer**=**2**  
*\#对当前实例的重试次数 当Eureka中可以找到服务，但是服务连不上时将会重试*  
**micro-order.ribbon.MaxAutoRetries**=**2**  
*\#*  
**micro-order.ribbon.NFLoadBalancerRuleClassName**=**com.netflix.loadbalancer.RandomRule**  
**micro-order.ribbon.NFLoadBalancerPingClassName**=**com.netflix.loadbalancer.PingUrl**

### **2、为consumer集成Ribbon** ###

**2.1、consumer服务修改pom文件，增加eureka的支持：**

**  
<**dependency**>  
    <**groupId**>org.springframework.cloud</**groupId**>  
    <**artifactId**>spring-cloud-starter-netflix-eureka-client</**artifactId**>  
</**dependency**>

**2.2、consumer服务修改RestConfig配置类**

在获取RestTemplate对象的时候加入Ribbon的配置信息@LoadBalanced

@Configuration  
**public class** RestConfig \{   
    @Bean  
    @LoadBalanced  
    **public** RestTemplate restTemplate() \{   
        **return  new** RestTemplate();  
    \}  
    */\*\**  
*     \* 服务提供方目前已经使用了密码验证，这个时候服务的消费方如果想直接访问就不可能了，*  
*     \* 这个时候一个以头的信息进行处理，然后使用Base64进行加密处理后才能得到正确的访问路径*  
*     \*/*  
*    *@Bean  
    **public** HttpHeaders getHeaders() \{ *// 要进行一个Http头信息配置*  
*        *HttpHeaders headers = **new** HttpHeaders(); *// 定义一个HTTP的头信息*  
*        *String auth = **"admin:admin"**; *// 认证的原始信息*  
*        ***byte**\[\] encodedAuth = Base64.*getEncoder*()  
                .encode(auth.getBytes(Charset.*forName*(**"US-ASCII"**))); *// 进行一个加密的处理*  
*        *String authHeader = **"Basic "** \+ **new** String(encodedAuth);  
        headers.set(**"Authorization"**, authHeader);  
        **return** headers;  
    \}  
\}

**2.3、consumer服务增加Eureka服务注册信息**

consumer服务修改application.yml文件，增加Eureka服务注册相关信息

**server**:  
  **port**: 80  
**eureka**:  
  **client**:  
    **register-with-eureka**: **false**  
**    service-url**:  
      **defaultZone**: http://admin:admin@eureka1:7001/eureka,http://admin:admin@eureka2:7002/eureka,http://admin:admin@eureka3:7003/eureka

**2.4、启动类增加Eureka客户端的配置注解**

Consumer服务员修改项目启动类ConsumerApp，增加Eureka客户端的配置注解@EnableEurekaClient。

**2.5、修改ConsumerProductController控制器**

现在在eureka中注册的服务名称都是大写字母：**SPRINGCLOUD-MICRO-PRODUCT**

![20200323221710877.png][]

@RestController  
@RequestMapping(**"/consumer"**)  
**public class** ConsumerProductSecurityController \{   
    *// 普通方式访问product服务接口*  
*//    public static final String PRODUCT\_GET\_URL = "http://localhost:8080/prodcut/get/";*  
*//    public static final String PRODUCT\_LIST\_URL="http://localhost:8080/prodcut/list/";*  
*//    public static final String PRODUCT\_ADD\_URL = "http://localhost:8080/prodcut/add/";*  
*    //* ***TODO 通过使用ribbon访问product服务***  
***    *****public static final** String ***PRODUCT\_GET\_URL*** = **"http://SPRINGCLOUD-MICRO-PRODUCT/prodcut/get/"**;  
    **public static final** String ***PRODUCT\_LIST\_URL***=**"http://SPRINGCLOUD-MICRO-PRODUCT/prodcut/list/"**;  
    **public static final** String ***PRODUCT\_ADD\_URL*** = **"http://SPRINGCLOUD-MICRO-PRODUCT/prodcut/add/"**;  
    @Resource  
    **private** RestTemplate **restTemplate**;  
    @Resource  
    **private** HttpHeaders **httpHeaders**;  
    */\*\**  
*     \* 添加了spring security以后，访问接口需要密码验证，需要在请求头HttpHeaders中添加验证信息*  
*     \*/*  
*    *@RequestMapping(**"/product/get2"**)  
    **public** Object getProduct2(**long** id) \{   
        Product product = **restTemplate**.exchange(***PRODUCT\_GET\_URL*** \+ id,HttpMethod.***GET***,  
                **new** HttpEntity<Object>(**httpHeaders**), Product.**class**).getBody();  
        **return  **product;  
    \}  
    @RequestMapping(**"/product/list2"**)  
    **public  **Object listProduct2() \{   
        List<Product> list = **restTemplate**.exchange(***PRODUCT\_LIST\_URL***,HttpMethod.***GET***,  
                **new** HttpEntity<Object>(**httpHeaders**), List.**class**).getBody();  
        **return  **list;  
    \}  
    @RequestMapping(**"/product/add2"**)  
    **public** Object addPorduct2(Product product) \{   
        Boolean result = **restTemplate**.exchange(***PRODUCT\_ADD\_URL***, HttpMethod.***POST***,  
                **new** HttpEntity<Object>(product,**httpHeaders**), Boolean.**class**).getBody();  
        **return  **result;  
    \}  
\}

启动服务，访问地址：[http://localhost/consumer/product/list][http_localhost_consumer_product_list]2

可以返回结果，这个时候Ribbon与Eureka已经整合成功。

\[\{"productId":null,"productName":"java编程","productDesc":"springcloud"\},

\{"productId":null,"productName":"Springboot","productDesc":"springcloud"\},

\{"productId":null,"productName":"西游记","productDesc":"springcloud"\},

\{"productId":null,"productName":"水浒传","productDesc":"springcloud"\},

\{"productId":null,"productName":"西厢记","productDesc":"springcloud"\}\]

### **3、ribbon服务调用restTemplate使用说明** ###

**3.1、restTemplate调用代码：**

@Slf4j  
@Service  
@Scope(proxyMode = ScopedProxyMode.***INTERFACES***)  
**public class** UserServiceImpl **implements** UserService \{   
    **private** AtomicInteger **s** = **new** AtomicInteger();  
    **private** AtomicInteger **f** = **new** AtomicInteger();  
    **public static** String *SERVIER\_NAME* = **"micro-order"**;  
    @Autowired  
    **private** RestTemplate **restTemplate**;  
    @Override  
    **public** String queryContents() \{   
        **s**.incrementAndGet();  
        *//****TODO 注意：getForObject是 getForEntity() 的封装，包含了请求头等信息***  
***       ****** ***String results = **restTemplate**.getForObject(**"http://"**  
**                **\+ *SERVIER\_NAME* \+ **"/queryUser"**, String.**class**);  
        **return** results;  
    \}  
\}

通过getForObject方法可以掉到用micro-order服务的，queryUser接口。然后在调用期间会存在负载均衡，micro-order服务对应有几个服务实例就会根据负载均衡算法选择某一个去调用。

**3.2、Get请求说明：**

getForEntity：此方法有三种重载形式，分别为：

getForEntity(String url, Class<T> responseType)

getForEntity(String url, Class<T> responseType, Object... uriVariables)

getForEntity(String url, Class<T> responseType, Map<String, ?> uriVariables)

getForEntity(URI url, Class<T> responseType)

注意：此方法返回的是一个包装对象ResponseEntity<T>其中T为responseType传入类型，想拿到返回类型需要使用这个包装类对象的getBody()方法。

getForObject：此方法也有三种重载形式，这点与 getForEntity 方法相同：

getForObject(String url, Class<T> responseType)

getForObject(String url, Class<T> responseType, Object... uriVariables)

getForObject(String url, Class<T> responseType, Map<String, ?> uriVariables)

getForObject(URI url, Class<T> responseType)

注意：此方法返回的对象类型为 responseType 传入类型

**3.2、Post请求**

post请求 get请求都有\*ForEntity 和\*ForObject 方法，其中参数列表有些不同，除了这两个方法外，还有一个postForLocation方法，其中postForLocation以post请求提交资源，并返回新资源的URI

**postForEntity****：此方法有三种重载形式，分别为：**

postForEntity(String url, Object request, Class<T> responseType, Object... uriVariables)

postForEntity(String url, Object request, Class<T> responseType, Map<String, ?> uriVariables)

postForEntity(URI url, Object request, Class<T> responseType)

注意：此方法返回的是一个包装对象ResponseEntity<T>其中T为responseType传入类型，想拿到返回类型需要使用这个包装类对象的getBody()方法。

**postForObject****：此方法也有三种重载形式，这点与** **postForEntity** **方法相同：**

postForObject(String url, Object request, Class<T> responseType, Object... uriVariables)

postForObject(String url, Object request, Class<T> responseType, Map<String, ?> uriVariables)

postForObject(URI url, Object request, Class<T> responseType)

注意：此方法返回的对象类型为responseType传入类型

**postForLocation****：此方法中同样有三种重载形式，分别为：**

postForLocation(String url, Object request, Object... uriVariables)

postForLocation(String url, Object request, Map<String, ?> uriVariables)

postForLocation(URI url, Object request)

注意：此方法返回的是新资源的URI，相比getForEntity、getForObject、postForEntity、postForObject方法不同的是这个方法中无需指定返回类型，因为返回类型就是URI，通过Object... uriVariables、Map<String, ?> uriVariables进行传参依旧需要占位符，参看postForEntity部分代码。

## **二、Ribbon负载均衡的实现** ##

通过上面的代码发现我们用到了一个注解@LoadBalanced，根据这名字大概就能知道Ribbon是可以实现负载均衡的。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70][]

### **1、复制多个product服务实例** ###

**第一步：**将springcloud-micro-product服务复制两份：

分别为springcloud-micro-product2与springcloud-micro-product3。

**第二步：**将springcloud数据库复制两份，分别为springcloud2与springcloud3数据库，里面分别执行spingcloud数据库的脚本。

**1.1、product2服务修改application.yml文件如下：**

注意：切记application:name: springcloud-micro-product这个不能修改，这样做的目的是同一个服务下面有多个服务实例。

**server**:  
  **port**: 8081  
**mybatis**:  
  **mapper-locations**: *\# 所有的mapper映射文件*  
*    *\- classpath:mapping/\*.xml  
**spring**:  
  **application**:  
    **name**: springcloud-micro-product  
  **datasource**:  
    **type**: com.alibaba.druid.pool.DruidDataSource *\# 配置当前要使用的数据源的操作类型*  
*    ***driver-class-name**: com.mysql.cj.jdbc.Driver *\# 配置MySQL的驱动程序类*  
*    ***url**: jdbc:mysql://localhost:3306/springcloud2?serverTimezone=GMT%2B8 *\# 数据库连接地址*  
*    ***username**: root *\# 数据库用户名*  
*    ***password**: root *\# 数据库连接密码*  
**eureka**: *\# eureka客户端配置*  
*  ***client**:  
    **register-with-eureka**: **true**  
**    service-url**:  
      *\#defaultZone: http://admin:admin@localhost:7001/eureka*  
*      ***defaultZone**: http://admin:admin@eureka1:7001/eureka,http://admin:admin@eureka2:7002/eureka,http://admin:admin@eureka3:7003/eureka  
  **instance**:  
    **instance-id**: springcloud-micro-product2  
    **prefer-ip-address**: **true**  
**    lease-renewal-interval-in-seconds**: 2  *\# 设置心跳的时间间隔（默认是30秒）*  
*    ***lease-expiration-duration-in-seconds**: 5  *\# 如果现在超过了5秒的间隔（默认是90秒）*  
**info**: *\# 增加服务信息*  
* ** ***app.name**: microcloud-provider-product2  
  **company.name**: hankin  
  **build.artifactId**: $project.artifactId$  
  **build.modelVersion**: $project.modelVersion$  
*\#  security:  \# 使用自定义的security模块*  
*\#    user:*  
*\#      name: admin  \# 认证用户名*  
*\#      password: admin  \# 认证密码*  
*\#      roles:*  
*\#        - USER \# 授权角色*

**1.2、product3服务修改application.yml文件如下**

**server**:  
  **port**: 8082  
**mybatis**:  
  **mapper-locations**: *\# 所有的mapper映射文件*  
*    *\- classpath:mapping/\*.xml  
**spring**:  
  **application**:  
    **name**: springcloud-micro-product  
  **datasource**:  
    **type**: com.alibaba.druid.pool.DruidDataSource *\# 配置当前要使用的数据源的操作类型*  
*    ***driver-class-name**: com.mysql.cj.jdbc.Driver *\# 配置MySQL的驱动程序类*  
*    ***url**: jdbc:mysql://localhost:3306/springcloud3?serverTimezone=GMT%2B8 *\# 数据库连接地址*  
*    ***username**: root *\# 数据库用户名*  
*    ***password**: root *\# 数据库连接密码*  
**eureka**: *\# eureka客户端配置*  
*  ***client**:  
    **register-with-eureka**: **true**  
**    service-url**:  
      *\#defaultZone: http://admin:admin@localhost:7001/eureka*  
*      ***defaultZone**: http://admin:admin@eureka1:7001/eureka,http://admin:admin@eureka2:7002/eureka,http://admin:admin@eureka3:7003/eureka  
  **instance**:  
    **instance-id**: springcloud-micro-product3  
    **prefer-ip-address**: **true**  
**    lease-renewal-interval-in-seconds**: 2  *\# 设置心跳的时间间隔（默认是30秒）*  
*    ***lease-expiration-duration-in-seconds**: 5  *\# 如果现在超过了5秒的间隔（默认是90秒）*  
**info**: *\# 增加服务信息*  
* ** ***app.name**: microcloud-provider-product3  
  **company.name**: hankin  
  **build.artifactId**: $project.artifactId$  
  **build.modelVersion**: $project.modelVersion$  
*\#  security:  \# 使用自定义的security模块*  
*\#    user:*  
*\#      name: admin  \# 认证用户名*  
*\#      password: admin  \# 认证密码*  
*\#      roles:*  
*\#        - USER \# 授权角色*  
*\#logging:*  
*\#  level:*  
*\#    com.chj.mapper: debug*

**1.3、分别启动3个服务提供方**

启动完成，分别访问：

![20200323221541649.png][]

[http://localhost:8080/prodcut/get/1][http_localhost_8080_prodcut_get_1]

[http://localhost:8081/prodcut/get/1][http_localhost_8080_prodcut_get_1]

[http://localhost:8082/prodcut/get/1][http_localhost_8080_prodcut_get_1]

确认3个服务是能正确提供访问的，查询结果如下：

\{"productId":null,"productName":"java编程","productDesc":"springcloud"\}

\{"productId":null,"productName":"java编程2","productDesc":"springcloud2"\}

"productId":null,"productName":"java编程3","productDesc":"springcloud3"\}

**1.4、启动consumer**

访问：[http://localhost/consumer/product/list][http_localhost_consumer_product_list]

现在发现每一次获取数据都是通过不同的微服务获得的，所以现在同一个消费端就可以通过Ribbon实现了负载均衡配置处理。

### **2、代码方式配置负载算法** ###

**2.1、使用@RibbonClients 加载配置**

*/\**  
*\** *这个是针对 micro-order服务的 ribbon配置*  
*\* \*/*  
@Configuration  
@RibbonClients(value = \{   
        @RibbonClient(name = **"micro-order"**,configuration = RibbonLoadBalanceMicroOrderConfig.**class**)  
\})  
**public class** LoadBalanceConfig \{   
\}

**2.2、负载算法使用**

*/\**  
*\* 这个类最好不要出现在启动类的@ComponentScan扫描范围*  
*\* 如果出现在@ComponentScan扫描访问，那么这个配置类就是每个服务共用的配置了*  
*\* \*/*  
@Configuration  
**public class** RibbonLoadBalanceMicroOrderConfig \{   
*//    @RibbonClientName*  
*    ***private** String **name** = **"micro-order"**;  
    @Bean  
    @ConditionalOnClass  
    **public** IClientConfig defaultClientConfigImpl() \{   
        DefaultClientConfigImpl config = **new** DefaultClientConfigImpl();  
        config.loadProperties(**name**);  
        config.set(CommonClientConfigKey.***MaxAutoRetries***,2);  
        config.set(CommonClientConfigKey.***MaxAutoRetriesNextServer***,2);  
        config.set(CommonClientConfigKey.***ConnectTimeout***,2000);  
        config.set(CommonClientConfigKey.***ReadTimeout***,4000);  
        config.set(CommonClientConfigKey.***OkToRetryOnAllOperations***,**true**);  
        **return** config;  
    \}  
    */\**  
*    \* 判断服务是否存活**，**不建议使用*  
*    \* \*/*  
*//    @Bean*  
*    ***public** IPing iPing() \{   
        *//这个实现类会去调用服务来判断服务是否存活*  
*        ***return new** PingUrl();  
    \}  
    @Bean  
    **public** IRule ribbonRule() \{   
        *//线性轮训*  
*        ***new** RoundRobinRule();  
        *//可以重试的轮训*  
*        ***new** RetryRule();  
        *//根据运行情况来计算权重*  
*        ***new** WeightedResponseTimeRule();  
        *//过滤掉故障实例，选择请求数最小的实例*  
*        ***new** BestAvailableRule();  
        **return new** RandomRule();  
    \}  
\}

### **3、自定义Ribbon路由** ###

前面已经使用Ribbon实现了路由，通过测试，也不难发现默认Ribbon使用的路由策略是轮询，可以看下源代码BaseLoadBalancer（ribbon-loadbalancer-2.2.5.jar）。

**public class** BaseLoadBalancer **extends** AbstractLoadBalancer **implements**  
**        **PrimeConnections.PrimeConnectionListener, IClientConfigAware \{   
    **private static** Logger *logger* = LoggerFactory.*getLogger*(BaseLoadBalancer.**class**);  
    **private final static** IRule ***DEFAULT\_RULE*** = **new** RoundRobinRule();  
    **private final static** SerialPingStrategy ***DEFAULT\_PING\_STRATEGY*** = **new** SerialPingStrategy();  
    **private static final** String ***DEFAULT\_NAME*** = **"default"**;  
    **private static final** String ***PREFIX*** = **"LoadBalancer\_"**;

**3.1、全局路由配置**

这种负载均衡的策略其实也是可以由用户来修改的，如果想要去修改，可以使用自定义的LoadBalance

**consumer****服务修改RestConfig：**

@Configuration  
**public class** RestConfig \{   
    @Bean  
    @LoadBalanced  *// 负载均衡*  
*    ***public** RestTemplate restTemplate() \{   
        **return  new** RestTemplate();  
    \}  
    */\*\**  
*     \* 服务提供方目前已经使用了密码验证，这个时候服务的消费方如果想直接访问就不可能了，*  
*     \* 这个时候一个以头的信息进行处理，然后使用Base64进行加密处理后才能得到正确的访问路径*  
*     \*/*  
*    *@Bean  
    **public** HttpHeaders getHeaders() \{ *// 要进行一个Http头信息配置*  
*        *HttpHeaders headers = **new** HttpHeaders(); *// 定义一个HTTP的头信息*  
*        *String auth = **"admin:admin"**; *// 认证的原始信息*  
*        ***byte**\[\] encodedAuth = Base64.*getEncoder*()  
                .encode(auth.getBytes(Charset.*forName*(**"US-ASCII"**))); *// 进行一个加密的处理*  
*        *String authHeader = **"Basic "** \+ **new** String(encodedAuth);  
        headers.set(**"Authorization"**, authHeader);  
        **return** headers;  
    \}  
    *// 自定义的LoadBalance*  
*    *@Bean  
    **public** IRule ribbonRule() \{ *// 其中IRule就是所有规则的标准*  
*        ***return new** com.netflix.loadbalancer.RandomRule(); *// 随机的访问策略*  
*    *\}  
\}

这个时候重启测试发现，默认的路由规则已经变成了随机。

**3.2、单独设置某个Ribbon的路由**

有时候，某个消费者可能需要访问多个多个服务提供方，而希望每个服务提供方提供的路由规则并不相同，这个时候就不能让Spring扫描到IRULE，需要通过@RibbonClient 来指定服务与配置的关系。

**1）****consumer****服务修改RestConfig，删除IRULE**

*//    @Bean*  
*//    public IRule ribbonRule() \{ // 其中IRule就是所有规则的标准*  
*//        return new com.netflix.loadbalancer.RandomRule(); // 随机的访问策略*  
*//    \}*

**2）****consumer****服务新增一个路由规则的配置类**

注意这个类不应该放到SpringCloud扫描不到的位置，否则又回变成全局的IRULE，所以这个时候应该单独使用一个新的包，这个包和启动并不在同一个包目录结构下：

**package** com.ribbon.config;  
*/\*\**  
* \* 自定义的LoadBalance（非全局）*  
* \* 有时候，某个消费者可能需要访问多个多个服务提供方，而希望每个服务提供方提供的路由规则并不相同，*  
* \* 这个时候就不能让Spring扫描到IRULE，需要通过@RibbonClient 来指定服务与配置的关系*  
* \*/*  
**public class** RibbonConfig \{   
    @Bean  
    **public** IRule ribbonRule() \{ *// 其中IRule就是所有规则的标准*  
*       **** *****return new com.netflix.loadbalancer.RandomRule();** ***// 随机的访问策略***  
*    *\}  
\}

**3）****consumer****修改启动类，使用@RibbonClient指定配置类**

@SpringBootApplication  
@EnableEurekaClient  
@RibbonClient(name =**"SPRINGCLOUD-MICRO-PRODUCT"** ,configuration = RibbonConfig.**class**)  
**public class** ConsumerApp \{   
    **public static void** main(String\[\] args) \{   
        SpringApplication.*run*(ConsumerApp.**class**,args);  
    \}  
\}

这里的name只服务的名称，如果需要有多个服务提供方，可以使用@RibbonClients进行配置。

重启动访问依然是随机返回不同的数据库数据结果。

**3.3、服务提供方的信息获取**

在服务的消费方，也是可以获取到服务提供方的具体信息

Consumer服务修改ConsumerProductController引入LoadBalancerClient，可以通过loadBalancerClient的choose("MICROCLOUD-PROVIDER-PRODUCT") ;方法取得服务提供方的实例信息：

@RestController  
@RequestMapping(**"/consumer"**)  
**public class** ConsumerProductSecurityController \{   
*    //* ***TODO 通过使用ribbon访问product服务***  
***    *****public static final** String ***PRODUCT\_GET\_URL*** = **"http://SPRINGCLOUD-MICRO-PRODUCT/prodcut/get/"**;  
    **public static final** String ***PRODUCT\_LIST\_URL***= **"http://SPRINGCLOUD-MICRO-PRODUCT/prodcut/list/"**;  
    **public static final** String ***PRODUCT\_ADD\_URL*** = **"http://SPRINGCLOUD-MICRO-PRODUCT/prodcut/add/"**;  
    @Resource  
    **private** RestTemplate **restTemplate**;  
    @Resource  
    **private** HttpHeaders **httpHeaders**;  
    *// 服务提供方的信息获取*  
*    *@Resource  
    **private** LoadBalancerClient **loadBalancerClient**;  
    */\*\**  
*     \* 添加了spring security以后，访问接口需要密码验证，需要在请求头HttpHeaders中添加验证信息*  
*     \*/*  
*    *@RequestMapping(**"/product/get2"**)  
    **public** Object getProduct2(**long** id) \{   
        ServiceInstance serviceInstance = **this**.**loadBalancerClient**.choose(**"SPRINGCLOUD-MICRO-PRODUCT"**) ;  
        System.***out***.println(**"【\*\*\* ServiceInstance \*\*\*】host = "** \+ serviceInstance.getHost()  
               + **"：port = "** \+ serviceInstance.getPort()+ **"：serviceId = "** \+ serviceInstance.getServiceId());  
        Product product = **restTemplate**.exchange(***PRODUCT\_GET\_URL*** \+ id,HttpMethod.***GET***,  
                **new** HttpEntity<Object>(**httpHeaders**), Product.**class**).getBody();  
        **return  **product;  
    \}  
    @RequestMapping(**"/product/list2"**)  
    **public  **Object listProduct2() \{   
        List<Product> list = **restTemplate**.exchange(***PRODUCT\_LIST\_URL***,HttpMethod.***GET***,  
                **new** HttpEntity<Object>(**httpHeaders**), List.**class**).getBody();  
        **return  **list;  
    \}  
    @RequestMapping(**"/product/add2"**)  
    **public** Object addPorduct2(Product product) \{   
        Boolean result = **restTemplate**.exchange(***PRODUCT\_ADD\_URL***, HttpMethod.***POST***,  
                **new** HttpEntity<Object>(product,**httpHeaders**), Boolean.**class**).getBody();  
        **return  **result;  
    \}  
\}

### **4、脱离Eureka使用Ribbon** ###

Ribbon是一个独立组件，可以脱离springcloud 使用的，之前所用Ribbon都是从Eureka中获取服务并通过@LoadBalanced来实现负载均衡的，其实Ribbon也可以脱离Eureka来使用。

复制springcloud-micro-consumer成一个新的模块springcloud-micro-consumer-ribbon

**4.1、Ribbon服务修改pom文件**

删除eureka的依赖添加ribbon的依赖：

**  
*        *<**dependency**>  
            <**groupId**>com.chj</**groupId**>  
            <**artifactId**>springcloud-micro-api</**artifactId**>  
        </**dependency**>  
        <**dependency**>  
            <**groupId**>org.springframework.boot</**groupId**>  
            <**artifactId**>spring-boot-starter-web</**artifactId**>  
        </**dependency**>  
        <**dependency**>  
            <**groupId**>org.springframework.boot</**groupId**>  
            <**artifactId**>spring-boot-starter-test</**artifactId**>  
            <**scope**>test</**scope**>  
        </**dependency**>  
        <**dependency**>  
            <**groupId**>org.springframework.boot</**groupId**>  
            <**artifactId**>spring-boot-devtools</**artifactId**>  
        </**dependency**>  
        **  
**  
**  
**  
**  
*        *<**dependency**>  
            <**groupId**>org.springframework.cloud</**groupId**>  
            <**artifactId**>spring-cloud-starter-netflix-ribbon</**artifactId**>  
        </**dependency**>

**4.2、Ribbon服务修改application.yml配置文件**

**server**:  
  **port**: 80  
**ribbon**:  
  **eureka**:  
    **enabled**: false  
**MICROCLOUD-PROVIDER-PRODUCT**:  
  **ribbon**:  
    **listOfServers**: http://localhost:8080,http://localhost:8081,http://localhost:8082

**4.3、Ribbon修改RestConfig，删除@LoadBalanced注解**

@Configuration  
**public class** RestConfig \{   
    @Bean  
*//    @LoadBalanced  // 负载均衡*  
*    ***public** RestTemplate restTemplate() \{   
        **return  new** RestTemplate();  
    \}  
*    *@Bean  
    **public** HttpHeaders getHeaders() \{ *// 要进行一个Http头信息配置*  
*        *HttpHeaders headers = **new** HttpHeaders(); *// 定义一个HTTP的头信息*  
*        *String auth = **"admin:admin"**; *// 认证的原始信息*  
*        ***byte**\[\] encodedAuth = Base64.*getEncoder*()  
                .encode(auth.getBytes(Charset.*forName*(**"US-ASCII"**))); *// 进行一个加密的处理*  
*        *String authHeader = **"Basic "** \+ **new** String(encodedAuth);  
        headers.set(**"Authorization"**, authHeader);  
        **return** headers;  
    \}  
*//    @Bean*  
*//    public IRule ribbonRule() \{ // 其中IRule就是所有规则的标准*  
*//        return new com.netflix.loadbalancer.RandomRule(); // 随机的访问策略*  
*//    \}*  
\}

**4.4、Ribbon修改ConsumerProductController，修改服务的调用URI**

@RestController  
@RequestMapping(**"/consumer"**)  
**public class** ConsumerProductSecurityController \{   
    **public static final** String ***PRODUCT\_TOPIC*** = **"SPRINGCLOUD-MICRO-PRODUCT"**;  
    @Resource  
    **private** RestTemplate **restTemplate**;  
    @Resource  
    **private** HttpHeaders **httpHeaders**;  
    *// 服务提供方的信息获取*  
*    *@Resource  
    **private** LoadBalancerClient **loadBalancerClient**;  
*    *@RequestMapping(**"/product/list3"**)  
    **public  **Object listProduct3() \{   
        ServiceInstance serviceInstance = **this**.**loadBalancerClient**.choose(***PRODUCT\_TOPIC***) ;  
        System.***out***.println(**"【\*\*\* ServiceInstance \*\*\*】host = "** \+ serviceInstance.getHost()  
                + **"：port = "** \+ serviceInstance.getPort() +**"：serviceId = "** \+serviceInstance.getServiceId());  
        URI url = URI.*create*(String.*format*(**"http://%s:%s/prodcut/list/"**,

serviceInstance.getHost(), serviceInstance.getPort()));  
        List<Product> list = **restTemplate**.exchange(url,HttpMethod.***GET***,

**new** HttpEntity<Object>(**httpHeaders**), List.**class**).getBody();  
        **return  **list;  
    \}  
\}

启动springcloud-micro-consumer-ribbon服务，访问：[http://localhost/consumer/product/list][http_localhost_consumer_product_list]3

结果和上面一样可以实现随机访问服务提供端，返回不同的数据结果。

## **三、Ribbon源码解析** ##

### **1、注解@RibbonClient** ###

@RibbonClient注解可以实现Ribbon客户端，ribbon需要设置客户端的名称，以及相关的路由配置类

@Configuration  
@Import(RibbonClientConfigurationRegistrar.**class**)  
@Target(ElementType.***TYPE***)  
@Retention(RetentionPolicy.***RUNTIME***)  
@Documented  
**public** @**interface** RibbonClient \{   
*   *String value() **default ""**;  
*   *String name() **default ""**;  
*   *Class<?>\[\] configuration() **default** \{\};  
\}

value和name是等价了，用于设置客户端的实例名称，而configuration用于指定配置类，接下来还导入了个RibbonClientConfigurationRegistrar，他实现了ImportBeanDefinitionRegistrar接口，也不用多说，它是spring-context-5.1.5.RELEASE.jar包的工具接口，用于spring动态注册BeanDefinition的接口，在这是用于注册Ribbon所需的BeanDefinition（比如Ribbon客户端实例）。

**1.1、RibbonClientConfigurationRegistrar源码分析**

org.springframework.cloud.netflix.ribbon.RibbonClientConfigurationRegistrar\#registerBeanDefinitions()：

@Override  
**public void** registerBeanDefinitions(AnnotationMetadata metadata,BeanDefinitionRegistry registry) \{   
    *//****TODO 获取@RibbonClient的参数，获取clientName后进行configuraction注册***  
***    ***Map<String, Object> attrs = metadata.getAnnotationAttributes(RibbonClients.**class**.getName(), **true**);  
    **if** (attrs != **null** && attrs.containsKey(**"value"**)) \{   
        AnnotationAttributes\[\] clients = (AnnotationAttributes\[\]) attrs.get(**"value"**);  
        **for** (AnnotationAttributes client : clients) \{   
            registerClientConfiguration(registry, getClientName(client), client.get(**"configuration"**));  
        \}  
    \}  
    **if** (attrs != **null** && attrs.containsKey(**"defaultConfiguration"**)) \{   
        String name; *//****TODO 获取ribbonclient的value或者name属性***  
***        *****if** (metadata.hasEnclosingClass()) \{   
            name = **"default."** \+ metadata.getEnclosingClassName();  
        \} **else** \{   
            name = **"default."** \+ metadata.getClassName();  
        \}

*//****TODO 注册***  
        registerClientConfiguration(registry, name,attrs.get(**"defaultConfiguration"**));  
    \}  
    Map<String, Object> client = metadata.getAnnotationAttributes(RibbonClient.**class**.getName(), **true**);  
    String name = getClientName(client);  
    **if** (name != **null**) \{   
        *//****TODO 注册***  
***        ***registerClientConfiguration(registry, name, client.get(**"configuration"**));  
    \}  
\}

两个情况注册到会调用同一个方法，这里用到了建造者模式：

**private void** registerClientConfiguration(BeanDefinitionRegistry registry,Object name, Object configuration) \{   
   BeanDefinitionBuilder builder = BeanDefinitionBuilder.*genericBeanDefinition*(RibbonClientSpecification.**class**);  
   builder.addConstructorArgValue(name);  
   builder.addConstructorArgValue(configuration);  
   registry.registerBeanDefinition(name + **".RibbonClientSpecification"**,builder.getBeanDefinition());  
\}

Registry.registerClientConfiguration方法会注册一个RibbonClientSpecification的bean，名称是ribbon的名称加上RibbonClientSpecification；RibbonClientSpecification实现了NamedContextFactory.Specification，是提供给SpringClientFactory使用的，他用于初始化ribbon的相关实例使用。

**public abstract class** NamedContextFactory<C **extends** NamedContextFactory.Specification>  
      **implements** DisposableBean, ApplicationContextAware \{   
   **public interface** Specification \{   
      String getName();  
      Class<?>\[\] getConfiguration();  
   \}

**public class** RibbonClientSpecification **implements** NamedContextFactory.Specification \{   
   **private** String **name**;  
   **private** Class<?>\[\] **configuration**;  
   **public** RibbonClientSpecification() \{\}

**1.2、SpringClientFactory在哪？**

RibbonAutoConfiguration配置见：spring-cloud-netflix-ribbon-2.0.0.RELEASE.jar!/META-INF/spring.factories

**org.springframework.boot.autoconfigure.EnableAutoConfiguration**=**\\**  
**org.springframework.cloud.netflix.ribbon.RibbonAutoConfiguration**

RibbonAutoConfiguration源码如下所示：

@Configuration  
@ConditionalOnClass(\{ IClient.**class**, RestTemplate.**class**, AsyncRestTemplate.**class**, Ribbon.**class**\})  
@RibbonClients  
@AutoConfigureAfter(name = **"org.springframework.cloud.netflix.eureka.EurekaClientAutoConfiguration"**)  
@AutoConfigureBefore(\{LoadBalancerAutoConfiguration.**class**, AsyncLoadBalancerAutoConfiguration.**class**\})  
@EnableConfigurationProperties(\{RibbonEagerLoadProperties.**class**, ServerIntrospectorProperties.**class**\})  
**public class** RibbonAutoConfiguration \{   
   @Autowired(required = **false**)  
   **private** List<RibbonClientSpecification> **configurations** = **new** ArrayList<>();  
   @Autowired  
   **private** RibbonEagerLoadProperties **ribbonEagerLoadProperties**;  
   @Bean  
   **public** HasFeatures ribbonFeature() \{   
      **return** HasFeatures.*namedFeature*(**"Ribbon"**, Ribbon.**class**);  
   \}  
   @Bean  
  ** public SpringClientFactory springClientFactory() \{**   
      SpringClientFactory factory = **new** SpringClientFactory();  
      factory.setConfigurations(**this**.**configurations**);  
      **return** factory;  
   \}  
 **  @Bean**  
**   @ConditionalOnMissingBean(LoadBalancerClient.class)**  
**   public LoadBalancerClient loadBalancerClient() \{**   
**      return new RibbonLoadBalancerClient(springClientFactory());**  
**   \}**

那么最重要的就回到了LoadBalancerClient，他是Ribbon项目最核心的接口，他有一个实现类RibbonLoadBalancerClient，LoadBalancerClient接口源码如下：

**public interface** LoadBalancerClient **extends** ServiceInstanceChooser \{   
    *//****TODO 从servericeId 所代表的服务列表中选择一个服务器来发送网络请求***  
***    ***<T> T execute(String serviceId, LoadBalancerRequest<T> request) **throws** IOException;  
    <T> T execute(String serviceId, ServiceInstance serviceInstance, LoadBalancerRequest<T> request) **throws** IOException;  
    *//****TODO 构建网络请求URI***  
***    ***URI reconstructURI(ServiceInstance instance, URI original);  
\}

### **2、LoadBalancerClient源码分析** ###

LoadBalancerClient 还继承了一个接口ServiceInstanceChooser

org.springframework.cloud.client.loadbalancer.ServiceInstanceChooser

**public interface** ServiceInstanceChooser \{   
    //根据serviceId从服务器列表中选择一个ServiceInstance  
*    *ServiceInstance choose(String serviceId);  
\}

org.springframework.cloud.netflix.ribbon.RibbonLoadBalancerClient 是LoadBalancerClient 的实现类，核心方法execute源码如下：

@Override  
**public** <T> T execute(String serviceId, LoadBalancerRequest<T> request) **throws** IOException \{   
    *//****TODO 每次发送请求都回获取一个ILoadBalancer ，会涉及负载均衡（IRULS），***

***服务器列表集群（ServerList） 和检验服务是否存活（IPing）等细节实现***  
***    ***ILoadBalancer loadBalancer = getLoadBalancer(serviceId);  
    Server server = getServer(loadBalancer);  
    **if** (server == **null**) \{   
        **throw new** IllegalStateException(**"No instances available for "** \+ serviceId);  
    \}  
    RibbonServer ribbonServer = **new** RibbonServer(serviceId, server, isSecure(server,  
            serviceId), serverIntrospector(serviceId).getMetadata(server));  
    **return** execute(serviceId, ribbonServer, request);  
\}

另外RibbonLoadBalancerClient\#getServer(com.netflix.loadbalancer.ILoadBalancer)方法：

**protected** Server getServer(ILoadBalancer loadBalancer) \{   
   **if** (loadBalancer == **null**) \{   
      **return null**;  
   \}  
   **return** loadBalancer.chooseServer(**"default"**); *// TODO: better handling of key*  
\}

这方法直接调用了ILoadBalancer 的chooseServer方法来使用负载君和策略，从已知的服务列表中选出一个服务器实例；接下来重点就到了ILoadBalancer 这接口了，他定义负载均衡操作的接口，由前面说过的SpringClientFactory获得而来。而SpringClientFactory又是再RibbonAutoConfiguration定义：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 1][]

### **3、ILoadBalancer接口分析** ###

接口的实现类有如下所示：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 2][]

**com.netflix.loadbalancer.****ZoneAwareLoadBalancer****是****ILoadBalancer****的具体实现，看下他构造方法：**

@Deprecated  
**public** ZoneAwareLoadBalancer(IClientConfig clientConfig, IRule rule, IPing ping,

ServerList<T> serverList, ServerListFilter<T> filter) \{   
    **super**(clientConfig, rule, ping, serverList, filter);  
\}  
**public** ZoneAwareLoadBalancer(IClientConfig clientConfig, IRule rule, IPing ping, ServerList<T> serverList,

ServerListFilter<T> filter,ServerListUpdater serverListUpdater) \{   
    **super**(clientConfig, rule, ping, serverList, filter, serverListUpdater);  
\}

**IClientConfig****：**client的配置类，具体指的DefaultClientConfigImpl，

**IRule****：负载均衡的策略类,默认轮询RoundRobinRule。**

**IPing****：**服务可用性检查，默认DummyPing。

**ServerList****：**服务列表获取，ConfigurationBasedServerList。

**ServerListFilter****：**服务列表过滤 ZonePreferenceServerListFilter。

ZoneAwareLoadBalancer其中一个重要的方法就是chooseServer()方法。

扩展阅读：[https://www.cnblogs.com/junjiang3/p/9061867.html][https_www.cnblogs.com_junjiang3_p_9061867.html]

### **4、chooseServer()方法源码分析：** ###

com.netflix.loadbalancer.ZoneAwareLoadBalancer.chooseServer(Object key)方法源码分析：

@Override  
**public** Server chooseServer(Object key) \{   
    *//****TODO 如果就一个zone，直接返回***  
***    *****if** (!ENABLED.get() || getLoadBalancerStats().getAvailableZones().size() <= 1) \{   
        logger.debug(**"Zone aware logic disabled or there is only one zone"**);  
        **return super**.chooseServer(key);  
    \}  
    Server server = **null**;  
    **try** \{   
        *//****TODO 获取当前有关负载均衡的服务器状态集合***  
***        ***LoadBalancerStats lbStats = getLoadBalancerStats();  
        Map<String, ZoneSnapshot> zoneSnapshot = ZoneAvoidanceRule.createSnapshot(lbStats);  
        logger.debug(**"Zone snapshots: \{\}"**, zoneSnapshot);  
        *//****TODO 获取平均负载阈值***  
***        *****if** (triggeringLoad == **null**) \{   
            triggeringLoad = DynamicPropertyFactory.getInstance().getDoubleProperty(  
          **"ZoneAwareNIWSDiscoveryLoadBalancer."** \+ **this**.getName() + **".triggeringLoadPerServerThreshold"**, 0.2d);  
        \}  
        *//****TODO 获取平均实例故障率阈值***  
***        *****if** (triggeringBlackoutPercentage == **null**) \{   
            triggeringBlackoutPercentage = DynamicPropertyFactory.getInstance().getDoubleProperty(  
         **"ZoneAwareNIWSDiscoveryLoadBalancer."** \+ **this**.getName() + **".avoidZoneWithBlackoutPercetage"**, 0.99999d);  
        \}  
        *//****TODO 根据两个阈值来获取所有可用的服务列表***  
***       ****** ***Set<String> availableZones = ZoneAvoidanceRule.getAvailableZones(zoneSnapshot, triggeringLoad.get(), triggeringBlackoutPercentage.get());  
        logger.debug(**"Available zones: \{\}"**, availableZones);  
        **if** (availableZones != **null** &&  availableZones.size() < zoneSnapshot.keySet().size()) \{   
            *//****TODO 随机从可用服务区列表中选择一个服务器***  
***            ***String zone = ZoneAvoidanceRule.randomChooseZone(zoneSnapshot, availableZones);  
            logger.debug(**"Zone chosen: \{\}"**, zone);  
            **if** (zone != **null**) \{   
                *//****TODO 得到zoone对应的BaseLoadBalancer***   
***              ******  ***BaseLoadBalancer zoneLoadBalancer = getLoadBalancer(zone);  
                server = zoneLoadBalancer.chooseServer(key);  
            \}  
        \}  
    \} **catch** (Exception e) \{   
        logger.error(**"Error choosing server using zone aware logic for load balancer=\{\}"**, name, e);  
    \}  
    **if** (server != **null**) \{   
        **return** server;  
    \} **else** \{   
        logger.debug(**"Zone avoidance logic is not invoked."**);  
        **return super**.chooseServer(key);  
    \}  
\}

**父类****com.netflix.loadbalancer.BaseLoadBalancer\#chooseServer****方法实现：**

**public** Server chooseServer(Object key) \{   
    **if** (**counter** == **null**) \{   
        **counter** = createCounter();  
    \}  
    **counter**.increment();  
    **if** (**rule** == **null**) \{   
        **return null**;  
    \} **else** \{   
        **try** \{

**    ****//根据具体的路由算法获取服务**  
**            return rule.choose(key);**  
        \} **catch** (Exception e) \{   
            *logger*.warn(**"LoadBalancer \[\{\}\]:  Error choosing server for key \{\}"**, **name**, key, e);  
            **return null**;  
        \}  
    \}  
\}

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 3][]

### **5、IRULE负载均衡的实现** ###

具体服务的的负载还是由IRULE实现，前面在入门部分也讲过怎么更换具体的路由实现方法，IRULE具体在RibbonClientConfiguration进行配置，IRule的接口choose方法负责选区一个具体的服务。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 4][]

**BestAvailableRule****：**选择最小请求数的服务器

RoundRobinRule：轮询方式

ClientConfigEnabledRoundRobinRule：使用RoundRobinRule选择服务器

RetryRule：根据选的轮询的方式重试

WeightedResponseTimeRule：根据响应时间去计算一个权重，weight越低，被选择的可能性就越低。

ZoneAvoidanceRule：根据server的zone区域和可用性来轮询选择。

**RibbonClientConfiguration.ribbonRule(IClientConfig config)方法代码如下所示：**

@Configuration  
@EnableConfigurationProperties  
@Import(\{HttpClientConfiguration.**class**, OkHttpRibbonConfiguration.**class**, RestClientRibbonConfiguration.**class**, HttpClientRibbonConfiguration.**class**\})  
**public class** RibbonClientConfiguration \{   
   **public static final int** ***DEFAULT\_CONNECT\_TIMEOUT*** = 1000;  
   **public static final int** ***DEFAULT\_READ\_TIMEOUT*** = 1000;  
   @RibbonClientName  
   **private** String **name** = **"client"**;  
*   *@Autowired  
   **private** PropertiesFactory **propertiesFactory**;  
   @Bean  
   @ConditionalOnMissingBean  
   **public** IClientConfig ribbonClientConfig() \{   
      DefaultClientConfigImpl config = **new** DefaultClientConfigImpl();  
      config.loadProperties(**this**.**name**);  
      config.set(CommonClientConfigKey.***ConnectTimeout***, ***DEFAULT\_CONNECT\_TIMEOUT***);  
      config.set(CommonClientConfigKey.***ReadTimeout***, ***DEFAULT\_READ\_TIMEOUT***);  
      **return** config;  
   \}  
   @Bean  
   @ConditionalOnMissingBean  
  ** public IRule ribbonRule(IClientConfig config) \{**   
      **if** (**this**.**propertiesFactory**.isSet(IRule.**class**, **name**)) \{   
         **return this**.**propertiesFactory**.get(IRule.**class**, config, **name**);  
      \}  
      **ZoneAvoidanceRule rule = new ZoneAvoidanceRule();**  
      rule.initWithNiwsConfig(config);  
      **return** rule;  
   \}

### **6、ZoneAvoidanceRule的具体实现** ###

ZoneAvoidanceRule是默认的IRule实例，它的父类是PredicateBasedRule，他使用PredicateBasedRule来根据服务区的运行状况和服务器的可用性来选择服务器。

**6.1、PredicateBasedRule类分析，具体依次做了以下事情：**

1）先使用ILoadBalancer获取服务器列表

2）使用AbstractServerPredicate进行服务器过滤

3）最后轮询从剩余的服务器列表中选择最终的服务器

**public abstract class** PredicateBasedRule **extends** ClientConfigEnabledRoundRobinRule \{   
*    ***public abstract** AbstractServerPredicate getPredicate();  
*    *@Override  
    **public** Server choose(Object key) \{   
        ILoadBalancer lb = getLoadBalancer();  
        Optional<Server> server = **getPredicate()**.chooseRoundRobinAfterFiltering(lb.getAllServers(), key);  
        **if** (server.isPresent()) \{   
            **return** server.get();  
        \} **else** \{   
            **return null**;  
        \}         
    \}  
\}

PredicateBasedRule.getPredicate()方法又是一个抽象的实现，具体实现见：ZoneAvoidanceRule的getPredicate()方法，又通过createCompositePredicate(zonePredicate, availabilityPredicate)进行赋值：

**public class** ZoneAvoidanceRule **extends** PredicateBasedRule \{   
    **private static final** Random ***random*** = **new** Random();  
    **private** CompositePredicate **compositePredicate**;  
    **public** ZoneAvoidanceRule() \{   
        **super**();  
        ZoneAvoidancePredicate zonePredicate = **new** ZoneAvoidancePredicate(**this**);  
        AvailabilityPredicate availabilityPredicate = **new** AvailabilityPredicate(**this**);  
        **compositePredicate** = createCompositePredicate(zonePredicate, availabilityPredicate);  
    \}

//将两个Predicate组合成一个CompositePredicate  
    **private** CompositePredicate **createCompositePredicate**(ZoneAvoidancePredicate p1, AvailabilityPredicate p2) \{   
        **return** CompositePredicate.*withPredicates*(p1, p2).addFallbackPredicate(p2)  
                             .addFallbackPredicate(AbstractServerPredicate.*alwaysTrue*()) .build();  
    \}  
    @Override  
    **public** AbstractServerPredicate getPredicate() \{   
        **return compositePredicate**;  
    \}

**createCompositePredicate****方法两个参数分析：**

ZoneAvoidancePredicate：判断一个服务器的运行状况是否可用，去除不可用服务器的所有服务器。

AvailabilityPredicate：用于过滤连接数过多的服务器。

**6.2、在来看下chooseRoundRobinAfterFiltering方法**

前面已经说过了它是过滤的方法，然后AvailabilityPredicate里面并没有这方法，他直接继承了他的父类AbstractServerPredicate.chooseRoundRobinAfterFiltering(java.util.List<com.netflix.loadbalancer.Server>)：

**1）首先看下ZoneAvoidanceRule的父类PredicateBasedRule的代码实现：**

**public abstract class** PredicateBasedRule **extends** ClientConfigEnabledRoundRobinRule \{   
*    ***public abstract** AbstractServerPredicate getPredicate();  
*    *@Override  
    **public** Server choose(Object key) \{   
        ILoadBalancer lb = getLoadBalancer();  
        Optional<Server> server = getPredicate().chooseRoundRobinAfterFiltering(lb.getAllServers(), key);  
        **if** (server.isPresent()) \{   
            **return** server.get();  
        \} **else** \{   
            **return null**;  
        \}         
    \}  
\}

**2）****chooseRoundRobinAfterFiltering****方法的实现是在AbstractServerPredicate类中完成：**

**public** Optional<Server> chooseRoundRobinAfterFiltering(List<Server> servers, Object loadBalancerKey) \{

**//过滤服务器列表**  
    List<Server> eligible = getEligibleServers(servers, loadBalancerKey);  
    **if** (eligible.size() == 0) \{   
        **return** Optional.*absent*();  
    \}

**//（i+1）%n 轮询选择一个服务实例**  
    **return** Optional.*of*(eligible.get(incrementAndGetModulo(eligible.size())));  
\}

**6.3、使用serverOnlyPredicate来依次实现服务过滤**

由于前面loadBalancerKey直接传入的null，方法getEligibleServers会使用serverOnlyPredicate来依次实现服务过滤，代码如下：com.netflix.loadbalancer.AbstractServerPredicate.getEligibleServers()

**public** List<Server> getEligibleServers(List<Server> servers, Object loadBalancerKey) \{   
    **if** (loadBalancerKey == **null**) \{   
        **return** ImmutableList.*copyOf*(Iterables.*filter*(servers, **this.getServerOnlyPredicate()**));              
    \} **else** \{   
        List<Server> results = Lists.*newArrayList*();  
        **for** (Server server: servers) \{   
            **if** (**this**.apply(**new** PredicateKey(loadBalancerKey, server))) \{   
                results.add(server);  
            \}  
        \}  
        **return** results;              
    \}  
\}

serverOnlyPredicate则会调用apply方法，并将Server 对象分装PredicateKey当作参数传入，

代码见：com.netflix.loadbalancer.AbstractServerPredicate.getServerOnlyPredicate()方法

**public** Predicate<Server> getServerOnlyPredicate() \{   
    **return serverOnlyPredicate**;  
\}

**private final** Predicate<Server> **serverOnlyPredicate** =  **new** Predicate<Server>() \{   
    @Override  
    **public boolean** apply(@Nullable Server input) \{                      
        **return** AbstractServerPredicate.**this**.apply(**new** PredicateKey(input));  
    \}  
\};

AbstractServerPredicate并没有实现apply方法，具体的实现又回到了子类CompositePredicate的apply方法，它会依次调用ZoneAvoidancePredicate与AvailabilityPredicate的apply方法：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 5][]

**6.4、ZoneAvoidancePredicate\#apply方法实现：**

源码见：com.netflix.loadbalancer.ZoneAvoidancePredicate.apply();

**public class** ZoneAvoidancePredicate **extends  **AbstractServerPredicate \{

@Override  
**public boolean** apply(@Nullable PredicateKey input) \{   
    **if** (!ENABLED.get()) \{   
        **return true**;  
    \}  
    String serverZone = input.getServer().getZone();  
    **if** (serverZone == **null**) \{   
        *//****TODO 如果服务器没有zone的相关信息，直接返回***  
***        *****return true**;  
    \}  
    LoadBalancerStats lbStats = getLBStats();  
    *//****TODO LoadBalancerStats 存储每个服务器节点的执行特征和运行记录，这些信息可供动态负责均衡使用***  
***    *****if** (lbStats == **null**) \{   
        *//****TODO 如果没有服务器的记录，直接返回***  
***        *****return true**;  
    \}  
    **if** (lbStats.getAvailableZones().size() <= 1) \{   
        *//****TODO 如果根本就一个服务器，直接返回***  
***        *****return true**;  
    \}  
    *//****TODO PredicateKey 封装了Server的信息，判断下服务器区的记录是否用当前区的信息***  
***    ***Map<String, ZoneSnapshot> zoneSnapshot = ZoneAvoidanceRule.createSnapshot(lbStats);  
    *//****TODO 如果没有直接返回***  
***    *****if** (!zoneSnapshot.keySet().contains(serverZone)) \{   
        *//* ***TODO The server zone is unknown to the load balancer, do not filter it out***  
***        *****return true**;  
    \}  
    logger.debug(**"Zone snapshots: \{\}"**, zoneSnapshot);  
    *//****TODO 获取可用的服务器列表***  
***  ******  ***Set<String> availableZones = ZoneAvoidanceRule.getAvailableZones(zoneSnapshot, triggeringLoad.get(), triggeringBlackoutPercentage.get());  
    logger.debug(**"Available zones: \{\}"**, availableZones);  
    *//****TODO 判断当前服务器是否在可用的服务器列表中***  
***    *****if** (availableZones != **null**) \{   
        **return** availableZones.contains(input.getServer().getZone());  
    \} **else** \{   
        **return false**;  
    \}  
\}

**6.5、获取可用的服务器列表getAvailableZones方法实现**

源码见：com.netflix.loadbalancer.ZoneAvoidanceRule\#getAvailableZones()方法

最后落到这方法上，这方法是用来筛选服务区列表的：

**public static** Set<String> getAvailableZones( Map<String, ZoneSnapshot> snapshot,  
                               **double** triggeringLoad,**double** triggeringBlackoutPercentage) \{   
    **if** (snapshot.isEmpty()) \{   
        **return null**;  
    \}  
    Set<String> availableZones = **new** HashSet<String>(snapshot.keySet());  
    **if** (availableZones.size() == 1) \{   
        **return** availableZones;  
    \}  
    Set<String> worstZones = **new** HashSet<String>();  
    **double** maxLoadPerServer = 0;  
    **boolean** limitedZoneAvailability = **false**;  
    *//****TODO 遍历所有的服务区***  
***    *****for** (Map.Entry<String, ZoneSnapshot> zoneEntry : snapshot.entrySet()) \{   
        String zone = zoneEntry.getKey();  
        ZoneSnapshot zoneSnapshot = zoneEntry.getValue();  
        *//****TODO 获取服务器中的服务实例数***  
***        *****int** instanceCount = zoneSnapshot.getInstanceCount();  
        **if** (instanceCount == 0) \{   
            *//****TODO 如果服务器中没有服务实例，那么移除该服务区***  
***            ***availableZones.remove(zone);  
            limitedZoneAvailability = **true**;  
        \} **else** \{   
            **double** loadPerServer = zoneSnapshot.getLoadPerServer();  
            *//****TODO 服务区的实例平均负载小于0，或者实例故障率（断路器端口次数/实例数）大于等于阈值（默认0.99999），则去掉该服务区***  
***            *****if** (((**double**) zoneSnapshot.getCircuitTrippedCount())  
                    / instanceCount >= triggeringBlackoutPercentage  
                    || loadPerServer < 0) \{   
                availableZones.remove(zone);  
                limitedZoneAvailability = **true**;  
            \} **else** \{   
                *//****TODO 如果该服务区的平均负载和最大负载的差小于一定的数量，则将该服务器加入到最坏服务区集合***  
***                *****if** (Math.*abs*(loadPerServer - maxLoadPerServer) < 0.000001d) \{   
                    *// they are the same considering double calculation*  
*                    // round error*  
*                    *worstZones.add(zone);  
                \} **else if** (loadPerServer > maxLoadPerServer) \{   
                    *//****TODO 否则，如果该zone的平均负载还大于最大负载***  
***                    ***maxLoadPerServer = loadPerServer;  
                    worstZones.clear();  
                    worstZones.add(zone);  
                \}  
            \}  
        \}  
    \}  
    *//****TODO 如果最大的平均负载小于设定的阈值则直接返回***  
***    *****if** (maxLoadPerServer < triggeringLoad && !limitedZoneAvailability) \{   
        *// zone override is not needed here*  
*        ***return** availableZones;  
    \}  
    *//****TODO 否则，从最好的服务器集合里面随机挑选一个***  
***    ***String zoneToAvoid = randomChooseZone(snapshot, worstZones);  
    **if** (zoneToAvoid != **null**) \{   
        availableZones.remove(zoneToAvoid);  
    \}  
    **return** availableZones;  
\}

ZoneSnapshot参数说明：

**public class** ZoneSnapshot \{   
    *//实例数*  
*    ***final int** **instanceCount**;  
    *//平均负载*  
*    ***final double** **loadPerServer**;  
    *//断路器端口数量*  
*    ***final int** **circuitTrippedCount**;  
    *//活动请求数量*  
*    ***final int** **activeRequestsCount**;  
\}

**6.6、CompositePredicate的apply方法**

会依次调用ZoneAvoidancePredicate与AvailabilityPredicate的apply方法，那接下来就是AvailabilityPredicate的apply方法了：

**1）CompositePredicate.apply方法实现如下：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 6][]

**2）AvailabilityPredicate.apply方法源码分析：**

@Override  
**public boolean** apply(@Nullable PredicateKey input) \{   
    LoadBalancerStats stats = getLBStats();  
    **if** (stats == **null**) \{   
        **return true**;  
    \}  
    *//****TODO 获得关于该服务器的记录***  
***    *****return** !shouldSkipServer(stats.getSingleServerStat(input.getServer()));  
\}  
**private boolean** shouldSkipServer(ServerStats stats) \{   
    *//****TODO 如果该服务器的断路器已经打开，或者他的连接数大于设定的阈值，那么就需要将服务器过滤掉      ***  
***    *****if** ((CIRCUIT\_BREAKER\_FILTERING.get() && stats.isCircuitBreakerTripped())  
            || stats.getActiveRequestsCount() >= activeConnectionsLimit.get()) \{   
        **return true**;  
    \}  
    **return false**;  
\}

[20200323221710877.png]: /images/20230528/510220ba17494aa29b3dc8d56e1487fd.png
[http_localhost_consumer_product_list]: http://localhost/consumer/product/list
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70]: /images/20230528/77cd8c8b961342cab85e8ba6e7805a6d.png
[20200323221541649.png]: /images/20230528/0f30d84b6be64391afefc8b1101290ce.png
[http_localhost_8080_prodcut_get_1]: http://localhost:8082/prodcut/get/1
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 1]: /images/20230528/4a0b15bb9b454bfda635fa3eb07d12ec.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 2]: /images/20230528/ba0acbe061054a998787f83f70e537a5.png
[https_www.cnblogs.com_junjiang3_p_9061867.html]: https://www.cnblogs.com/junjiang3/p/9061867.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 3]: /images/20230528/53f8c3f04d1d46578028dd9eee3acc92.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 4]: /images/20230528/cf8c0bdf7da7482cbc8676878b3d088a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 5]: /images/20230528/3e45517b843145d9a0eb4bbe19eb4078.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 6]: /images/20230528/f99d10c393004d7c98b3c54556e176e5.png