SpringCloud—Ribbon负载均衡及服务调用

一.概念

1.什么是Ribbon？

Spring Cloud Ribbon是基于Netflix Ribbon实现的一套客户端负载均衡的工具。

简单的说，Ribbon是Netflix发布的开源项目，主要功能是提供客户端的软件负载均衡算法，它有助于控制HTTP和TCP的客户端的行为。为Ribbon配置服务提供者地址后，Ribbon就可基于某种负载均衡算法，自动地帮助服务消费者去请求。Ribbon默认为我们提供了很多负载均衡算法，例如轮询、随机等。当然，我们也可为Ribbon实现自定义的负载均衡算法。

在Spring Cloud中，当Ribbon与Eureka配合使用时，Ribbon可自动从Eureka Server获取服务提供者地址列表，并基于负载均衡算法，请求其中一个服务提供者实例。展示了Ribbon与Eureka配合使用时的架构。

2.LB负载均衡（Load Balance）?

简单的说就是将用户的请求平摊的分配到多个服务上，从而达到系统的HA（高可用）。常见的负载均衡有软件 Nginx，LVS，硬件F5 等。

• 集中式B
  即在服务的消费方和提供方之间使用独立的LB设施（可以是硬件，如F5，也可以是软件，如nginx）,由该设施负责把访问请求通过某种策略转发至服务的提供方
• 进程内LB
  将 LB 逻辑集成到消费方，消费方从服务注册中心获知有哪些地址可用，然后自己再从这些地址中选择出一个合适的服务器。Ribbon就属于进程内 LB ，它只是一个类库，集成与消费方进程，消费方通过它来获取到服务提供方的地址。

Ribbon 就是 负载均衡 + RestTemplate调用，最终实现RPC的远程调用。

二.通过Ribbon实现负载均衡

客户端(消费者)

1.客户端(消费者)添加依赖

        <!-- Ribbon -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-ribbon</artifactId>
            <version>1.4.7.RELEASE</version>
        </dependency>
        <!--eureka-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
            <version>1.4.7.RELEASE</version>
        </dependency>

2.修改客户端(消费者)配置文件

#eureka配置
eureka:
  client:
    register-with-eureka: false #不向eureka注册自己
    service-url: 
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/

3.修改客户端(消费者)启动类

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

4.修改客户端(消费者)配置类

@Configuration
public class ConfigBean {
    //配置负载均衡实现restTemplate
    @Bean
    @LoadBalanced //ribbon
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }
}

5.修改客户端(消费者)访问的地址

// 请求地址 http://localhost:8001/dept/get/1
/*
    Ribbon。我们这里的地址应该是一个变量，通过服务名来访问
    private static final String REST_URL_PREFIX="http://localhost:8001";
*/
private static final String REST_URL_PREFIX="http://SPRINGCLOUD-PROVIDER-DEPT";

5.客户端(消费者)效果

服务提供者

1.创建三个服务提供者

2.修改每个服务提供者的配置文件

3.服务提供者实现负载均衡的效果

三.自定义负载均衡算法

1.配置类

//不可以和启动类在同一个包下,即启动类无法扫描到
@Configuration
public class MyRule {
    //IRule
    //RoundRobinRule：轮询
    //RandomRule：随机
    //AvailabilityFilteringRule：会先过滤跳闸，访问故障的服务，对剩下的进行轮询
    //RetryRule:会先按照轮询获取服务，如果服务获取失败，则会在指定的时间内进行重试
    @Bean
    public IRule lzhMyRule() {
        return new MyRandomRule();//默认是轮循，现在我们自定义
    }
}

2.自定义算法

//不可以和启动类在同一个包下
public class MyRandomRule extends AbstractLoadBalancerRule {

    /**
     * 每个服务访问5次，则换下一个服务(总共3个服务)
     * total=0,默认=0,如果=5,指向下一个服务节点
     * index=0,默认=0,如果total=5,index+1
     */
    private int total = 0;          //被调用的次数
    private int currentIndex = 0;   //当前是谁在提供服务

    public Server choose(ILoadBalancer lb, Object key) {
        if (lb == null) {
            return null;
        }
        Server server = null;

        while (server == null) {
            if (Thread.interrupted()) {
                return null;
            }
            List<Server> upList = lb.getReachableServers(); //获得当前活着的服务
            List<Server> allList = lb.getAllServers(); //获取所有的服务

            int serverCount = allList.size();
            if (serverCount == 0) {
                return null;
            }

            //int index = chooseRandomInt(serverCount);//生成区间随机数
            //server = upList.get(index);//从或活着的服务中,随机获取一个

            //=====================自定义代码=========================

            if (total < 5) {
                server = upList.get(currentIndex);
                total++;
            } else {
                total = 0;
                currentIndex++;
                if (currentIndex >= upList.size()) {
                    currentIndex = 0;
                }
                //server = upList.get(currentIndex);//从活着的服务中,获取指定的服务来进行操作
            }

            //======================================================

            if (server == null) {
                Thread.yield();
                continue;
            }

            if (server.isAlive()) {
                return (server);
            }
            server = null;
            Thread.yield();
        }

        return server;

    }

    protected int chooseRandomInt(int serverCount) {
        return ThreadLocalRandom.current().nextInt(serverCount);
    }

	@Override
	public Server choose(Object key) {
		return choose(getLoadBalancer(), key);
	}

	@Override
	public void initWithNiwsConfig(IClientConfig clientConfig) {
		// TODO Auto-generated method stub
		
	}
}

3.修改启动类

@SpringBootApplication
@EnableEurekaClient
@RibbonClient(name = "SPRINGCLOUD-PROVIDER-DEPT",configuration = MyRule.class)
public class DeptConsumer_80 {
    public static void main(String[] args) {
        SpringApplication.run(DeptConsumer_80.class,args);
    }
}

4.效果

每个服务访问5次，再换下一个服务