SpringCloud-Eureka集群和RibbonEureka集群简单来说，Eureka集群搭建多个注册中心，将注

Eureka集群

为什么会有Eureka集群？

简单来说，Eureka集群搭建多个注册中心，将注册在注册中心的服务共享，集群里面每个Eureka注册中心都有彼此的服务。比如说现在有三个Eureka注册中心（a,b,c），有两个服务（甲，乙），甲乙注册到任意注册中心，a,b,c中都有两个服务，以至于一个注册中心崩了，这些服务就丢失，就崩溃了。

环境搭建

首先，我们需要去改一下要访问的本机名称：在hosts文件最后加上，要访问的本机名称，默认是localhost

接着，我们创建另外两个eureka模块（之前我们已经创建了一个eureka模块了）

修改创建的这三个模块的application.yml文件

在服务提供者中配置服务注册到注册中心的地址

开启这三个eureka模块，测试一下集群。

把服务提供者也启动试试

在这三个eureka注册中心都能看到注册的服务，这就是eureka集群，可以解决一个注册中心崩了的情况下，服务还能通过其他注册中心进行使用

Ribbon

简介

Spring Cloud Ribbon是基于Netflix Ribbon 实现的一套客户端负载均衡的工具。
简单的说，Ribbon 是 Netflix 发布的开源项目，主要功能是提供客户端的软件负载均衡算法，将 Netflix 的中间层服务连接在一起。Ribbon 的客户端组件提供一系列完整的配置项，如：连接超时、重试等。简单的说，就是在配置文件中列出 LoadBalancer (简称LB：负载均衡) 后面所有的及其，Ribbon 会自动的帮助你基于某种规则 (如简单轮询，随机连接等等) 去连接这些机器。我们也容易使用 Ribbon 实现自定义的负载均衡算法！
负载均衡简单的说就是将用户的请求平摊的分配到多个服务上，从而达到系统的HA (高用)。
SpringCloud 的负载均衡算法可以自定义。
操作在服务消费者那端。

Ribbon的简单使用

在服务消费者导入Ribbon依赖

<!-- ribbon -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
    <version>2.2.5.RELEASE</version>
</dependency>

在服务消费者的application.yml配置Eureka

eureka:
  client:
    register-with-eureka: false # 不向 Eureka注册自己
    service-url: # 从三个注册中心中随机取一个去访问
      defaultZone: http://eureka7001:7001/eureka/,http://eureka7002:7002/eureka/,http://eureka7003:7003/eureka/

在服务消费者的主启动类加上@EnableEurekaClient注解，开启Eureka
定义Spring配置类：ConfigBean.java加上@LoadBalanced注解配置负载均衡实现RestTemplate
修改服务访问的地址

启动服务，测试

Ribbon实现负载均衡

原理

为了方便观察，我们再创建两个数据库db02,db03；并连接

创建另外两个服务提供者模块，参照之前第一个来修改

修改application.yml --> 连接的数据库和配置的描述信息
修改DeptMapper.xml，修改查询数据库的位置

修改完启动测试（根据自己电脑来启动服务，小心爆炸）

===> 轮询查询数据库中的数据

Ribbon自定义负载均衡算法

Ribbon 实现负载均衡，默认方式是轮询，当然，它还有其他方式，比如说随机，我们甚至可以自定义负载均衡的算法。具体操作如下：

在服务消费者下java包下创建myRule包，用来编写自定义负载均衡算法

myRule

package myRule;

import com.netflix.loadbalancer.IRule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MyRule {

    @Bean
    public IRule TestRule(){
        return new MyRandomRule();//默认是轮询RandomRule,现在自定义为自己的
    }
}

MyRandomRule.java


package myRule;

import com.netflix.client.config.IClientConfig;
import com.netflix.loadbalancer.AbstractLoadBalancerRule;
import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.Server;

import java.util.List;
import java.util.concurrent.ThreadLocalRandom;

public class MyRandomRule extends AbstractLoadBalancerRule {
    public MyRandomRule() {
    }

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

    //@edu.umd.cs.findbugs.annotations.SuppressWarnings(value = "RCN_REDUNDANT_NULLCHECK_OF_NULL_VALUE")
    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) {
                /*
                 * No servers. End regardless of pass, because subsequent passes
                 * only get more restrictive.
                 */
                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) {
                /*
                 * The only time this should happen is if the server list were
                 * somehow trimmed. This is a transient condition. Retry after
                 * yielding.
                 */
                Thread.yield();
                continue;
            }
            if (server.isAlive()) {
                return (server);
            }
            // Shouldn't actually happen.. but must be transient or a bug.
            server = null;
            Thread.yield();
        }
        return server;
    }
    
    protected int chooseRandomInt(int serverCount) {
        return ThreadLocalRandom.current().nextInt(serverCount);
    }

    public Server choose(Object key) {
        return this.choose(this.getLoadBalancer(), key);
    }

    public void initWithNiwsConfig(IClientConfig clientConfig) {
    }
}

在主启动类设置开启负载均衡的算法@RibbonClient(name = "SPRINGCLOUD-PROVIDER",configuration = MyRule.class)
启动测试