Ribbon与Spring cloud整合源码分析

简价

Ribbon是一种客户端的负载均衡器。提供了多种负载均衡的算法,支持多种协议(HTTP,TCP,UDP),并提供了故障容错的能力。官方网址为:https://github.com/Netflix/ribbon

Ribbon版Hello World

我们再使用的时候需要指定Server对象也就是可以做为负载的服务器,以及负载的Rule规则,默认采用的是轮询的规则。 代码如下,里面有详细的注释:

package com.ivan.ribbon;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.List;

import com.google.common.collect.Lists;
import com.netflix.loadbalancer.BaseLoadBalancer;
import com.netflix.loadbalancer.LoadBalancerBuilder;
import com.netflix.loadbalancer.Server;
import com.netflix.loadbalancer.reactive.LoadBalancerCommand;
import com.netflix.loadbalancer.reactive.ServerOperation;

import rx.Observable;

public class RibbonClient {
   public static void main(String[] args) throws Exception {
       // 提供服务的服务器列表, 这里可以根据具体的测试url提供多个url。
       List<Server> servers = Lists.newArrayList(new Server("localhost", 8000), new Server("localhost", 8001));
       // 负载均衡器, 这里可以设置rule
       BaseLoadBalancer loadBalancer = LoadBalancerBuilder.newBuilder().buildFixedServerListLoadBalancer(servers);
       //这个可以提交具体的执行命令逻辑。需要传入具体的负载均衡器
       LoadBalancerCommand<String> command = LoadBalancerCommand.<String> builder().withLoadBalancer(loadBalancer).build();
       //连续执行10次,这样使可以看到具体的效果了。
       for (int i = 0; i < 10; i++) {
           command.submit(new ServerOperation<String>() {
               public Observable<String> call(Server server) {
                   URL url;
                   //这里的path是能够访问的url
                   String path = "/provider";
                   InputStream inputStream = null;
                   InputStreamReader inputStreamReader = null;
                   BufferedReader reader = null;
                   try {
                       url = new URL("http://" + server.getHost() + ":" + server.getPort() + path);
                       HttpURLConnection conn = (HttpURLConnection) url.openConnection();
                       inputStream = conn.getInputStream();
                       inputStreamReader = new InputStreamReader(inputStream);
                       reader = new BufferedReader(inputStreamReader);
                       String tempLine = null;
                       StringBuffer resultBuffer = new StringBuffer();
                       while ((tempLine = reader.readLine()) != null) {
                           resultBuffer.append(tempLine);
                       }
                       String data = resultBuffer.toString();
                       System.out.println("data : " + data);
                       return Observable.just(data);
                   } catch (Exception e) {
                       return Observable.error(e);
                   } finally {
                       if (reader != null) {
                           try {
                               reader.close();
                           } catch (IOException e) {
                           }
                       }

                       if (inputStreamReader != null) {
                           try {
                               inputStreamReader.close();
                           } catch (IOException e) {
                           }
                       }

                       if (inputStream != null) {
                           try {
                               inputStream.close();
                           } catch (IOException e) {
                           }
                       }

                   }
               }
           }).toBlocking().first();

       }

   }
}

负载均衡规则

Ribbon 提供了若干个内置的负载规则如下图所示:

image.png

  • RoundRobinRule: 系统默认的规则, 通过简单的轮询服务列表来选择服务器
  • AvailabilityFilteringRule: 该规则会忽略以下服务器: 1)无法连接的服务器: 在默认情况下, 如果 3 次连接失败, 该服务器将会被置为 “ 短路” 的状态, 该状态将持续 30 秒, 如果再次连接失败, “ 短路” 状态的持 续 时 间 将 会 以 几 何 级 增 加 。 可 以 通 过 修 改 niws.loadbalancer.<clientName>.connectionFailureCountThreshold 属性, 来 配置连接失败的次数。 2) 并发数过高的服务器: 如果连接到该服务器的并发数过高, 也会被这个规则忽 略, 可以通过修改<clientName>.ribbon.ActiveConnectionsLimit 属性来设定最 高并发数。
  • WeightedResponseTimeRule: 为每个服务器赋予一个权重值, 服务器的响应时间 越长, 该权重值就是越少, 这个规则会随机选择服务器, 这个权重值有可能会决定 服务器的选择。
  • ZoneAvoidanceRule: 该规则以区域、 可用服务器为基础, 进行服务器选择。 使用 Zone 对服务器进行分类, 可以理解为机架或者机房。
  • BestAvailableRule: 忽略“ 短路” 的服务器, 并选择并发数较低的服务器。
  • RandomRule: 顾名思义, 随机选择可用的服务器。
  • RetryRule: 含有重试的选择逻辑, 如果使用 RoundRobinRule 选择服务器无法连 接, 那么将会重新选择服务器。

与Spring Cloud整合

1:先在pom.xml文件里加入需要的依赖, 关键信息如下:

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Edgware.SR4</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

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

2:写启动类,需要加入EnableDiscoveryClient人注解。代码如下:

package com.ivan.consumer;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

/**
 * 
 * 功能描述: 
 * 
 * @version 2.0.0
 * @author zhiminchen
 */

@SpringBootApplication
@EnableDiscoveryClient
public class App 
{
    public static void main( String[] args )
    {
        SpringApplication.run(App.class, args);
    }
}

3:写个自定义负载的规则,也可以没有这个类,这样默认就是轮询的规则。代码如下:

package com.ivan.consumer.rule;

import java.util.List;

import org.apache.commons.lang.math.RandomUtils;
import org.springframework.stereotype.Component;

import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.Server;

/**
 * 
 * 功能描述: 自定义Rule,80%的概率选第一台服务器,20%的概率选第二台服务器
 * 
 * @version 2.0.0
 * @author zhiminchen
 */
@Component
public class MyRule implements IRule {

    private ILoadBalancer lb;

    @Override
    public Server choose(Object key) {
        List<Server> allServer = lb.getAllServers();
        int value = RandomUtils.nextInt(10);
        Server server = null;
        if (value > 8) {
            server = allServer.get(0);
        } else {
            server = allServer.get(1);
        }
        System.out.println("port is : " + server.getPort());
        return server;
    }

    @Override
    public void setLoadBalancer(ILoadBalancer lb) {
        this.lb = lb;
    }

    @Override
    public ILoadBalancer getLoadBalancer() {
        return this.lb;
    }

}

4:编写服务调用者,代码如下:

package com.ivan.consumer.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.cloud.netflix.ribbon.SpringClientFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@RestController
@Configuration
public class ConsumerController {
    
    //这个值会自动注入的噢
    @Autowired
    private LoadBalancerClient client;
    
    //这个值也会自动注入的噢
    @Autowired
    private SpringClientFactory factory;

    @Bean
    @LoadBalanced
    public RestTemplate getRestTemplate() {
        return new RestTemplate();
    }

    @RequestMapping(value = "/consumer", method = RequestMethod.GET)
    public String consumer() {
        RestTemplate template = getRestTemplate();
        // 根据应用名称调用服务
        String json = template.getForObject("http://provider/provider", String.class);
        return json;
    }
}

代码效果应该是大部分请求会调用到Server为零的服务器上,也就是说我们自定义的Rule起作用了,同时可以看到控制台有相应的输出记录。

源码分析

上面的代码我们会有两个疑问:

  • 为什么我们自定义的Rule,只加上了@Component注解,这个规则便能起作用。
  • SpringClientFactory 与 LoadBalancerClient 这两个类是如何注入到我们自定义的Controller里的。 因为Spring Cloud是基与Spring Boot进行构建的, 之所以上面的类能够起作用,核心还是因为Spring Boot 的SpringFactoriesLoader 机制在起作用。我们可以找到spring-cloud-netflix-cord的jar包,里面有个spring.factories文件,在这个文件里,我们可以看到会自动加载RibbonAutoConfiguration类。代码如下图所示:

image.png 在RibbonAutoConfiguration类里,我们可以看到定义了SpringClientFactory 与 LoadBalancerClient 这两个Bean, 这就解释了为什么我们的应用代码可以注入这两个类了。代码截图如下图所示:

image.png 至于我们自定义的Rule能够起作用,是因为我们的Spring容器会扫描当前录与子录的代码,将Component注释的类自动注入到Spring IOC容器类, 如果我们没有配置相应的Rule, Spring Cloud会为我们默认加载一个Rule类,这个类在RibbonClientConfiguration里定义,代码如下图:

image.png

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏一个会写诗的程序员的博客

8.2 Spring Boot集成Groovy、Grails开发小结参考资料

本章介绍Spring Boot集成Groovy,Grails开发。我们将开发一个极简版的pms(项目管理系统)。

1213
来自专栏Netkiller

使用 Jersey 调用 Restful 服务

第 20 章 Jersey - RESTful Web Services in Java. 目录 20.1. Client 20.1.1. Maven 版本 ...

3564
来自专栏技术翻译

使用Spring Cloud Netflix的Kotlin微服务:第2部分

在本系列的第1部分中,我们使用Kotlin介绍了Spring Cloud。我们讨论了Config Server,Discovery Server(Eureka)...

1872
来自专栏Kubernetes

Kubernetes Nginx Ingress Controller源码分析

main controllers/nginx/pkg/cmd/controller/main.go:29 func main() { // start a ...

49610
来自专栏JadePeng的技术博客

jenkins X实践系列(2) —— 基于jx的DevOps实践

jx是云原生CICD,devops的一个最佳实践之一,目前在快速的发展成熟中。最近调研了JX,这里为第2篇,使用已经安装好的jx来实践CICD,旨在让大家了解基...

4392
来自专栏北京马哥教育

Python大法之告别脚本小子---信息资产收集类脚本编写

在采集到URL之后,要做的就是对目标进行信息资产收集了,收集的越好,你挖到洞也就越多了............当然这一切的前提,就是要有耐心了!!!由于要写工具...

1340
来自专栏SpringBoot

SpringCloud Ribbon

Ribbon是一个客户端负载平衡器,它可以很好地控制HTTP和TCP客户端的行为。Feign已经使用Ribbon,所以如果你使用@FeignClient,那么这...

1372
来自专栏Ryan Miao

gradle中使用嵌入式(embedded) tomcat, debug 启动

在gradle项目中使用embedded tomcat。 最开始部署项目需要手动将web项目打成war包,然后手动上传到tomcat的webapp下,然后启动t...

4459
来自专栏kl的专栏

Feign-声明式java Http客户端

Feign 是Netfilx开源的一个声明web服务客户端,这便得编写web服务客户端更容易,使用Feign 创建一个接口并对它进行注解,它具有可插拔的注解支持...

6875
来自专栏一个会写诗的程序员的博客

《Spring Boot极简教程》第8章 Spring Boot集成Groovy,Grails开发第8章 Spring Boot集成Groovy,Grails开发小结参考资料

本章介绍Spring Boot集成Groovy,Grails开发。我们将开发一个极简版的pms(项目管理系统)。

1382

扫码关注云+社区