版权声明：署名，允许他人基于本文进行创作，且必须基于与原先许可协议相同的许可协议分发本文 （Creative Commons）
前言
Spring Cloud Ribbon 是基于Netflix Ribbon实现的一套客户端负载均衡的工具，将Netflix的中间层服务连接在一起。Ribbon组件提供了一系列完善的配置项如连接超时、重试等。
在配置文件中列出Load Balancer(简称LB)后面所有的机器，Ribbon会自动帮助你基于某种规则（简单轮询、随机连接等）去连接这些机器，同时我们也能够实现自定义的负载均衡算法。
配置Ribbon组件
一、创建Eureka Consumer module--- microservicecloud-consumer-dept-80
这个是在【Spring Cloud】 Eureka 服务注册与发现 文章的基础上，继续创建模块。
二、修改本pom文件
将Eureka 客户端的组件、ribbon和config的组件依赖引入进来
<!-- Ribbon相关 -->
<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>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-config</artifactId>
</dependency>三、消费端的 application.yml 文件
添加Eureka配置，注册到Eureka Server端。这是Eureka集群模式 ，同时Eureka Provider也是集群模式，（配置过程省略）
server:
port: 80
eureka:
client:
register-with-eureka: false
service-url:
defaultZone: http://eureka7001.com:7001/eureka/ ,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/四、主启动类添加注解
其中 @EnableEurekaClient，同Eureka Provider的主启动类的注解作用一样，代表是Eureka Client，帮助注册进Eureka Server；@RibbonClient 注解是Ribbon组件所使用的，作用是加载我们自己自定义的负载均衡算法类MySelfRule.class。
@SpringBootApplication
@EnableEurekaClient
//在启动该微服务的时候就能去加载我们的自定义Ribbon配置类，从而使配置生效
@RibbonClient(name="MICROSERVICECLOUD-DEPT",configuration=MySelfRule.class)
public class DeptConsumer80_App
{
public static void main(String[] args)
{
SpringApplication.run(DeptConsumer80_App.class, args);
}
}
五、新增配置类ConfigBean
在RestTemplate类配置注解@LoadBalanced实现默认的轮询算法。
如果要更改默认的轮询算法，就添加配置IRule，里面有三种常用的负载均衡算法RoundRobinRule、RandomRule和RetryRule。
@Configuration
public class ConfigBean //boot -->spring applicationContext.xml --- @Configuration配置 ConfigBean = applicationContext.xml
{
@Bean
@LoadBalanced//Spring Cloud Ribbon是基于Netflix Ribbon实现的一套客户端 负载均衡的工具。
public RestTemplate getRestTemplate()
{
return new RestTemplate();
}
@Bean
public IRule myRule()
{
return new RoundRobinRule(); // 轮询算法 默认
// return new RandomRule();//随机算法替代默认的轮询。
// return new RetryRule(); // 重试算法
}
}六、controller层调用Eureka Provider提供的服务
之前我们在写Eureka Provider服务时，在主启动类上添加了注解@EnableDiscoveryClient，这个注解的作用是将提供者所提供的服务暴露给消费者，下面消费者的Controller层使用RestTemplate访问提供者提供的服务。
Ribbon的负载均衡算法与Eureka结合后，我们在配置 REST_URL_PREFIX 时，不需要指定端口，Consumer可以直接调用服务而不用关心地址和端口号。
@RestController
public class DeptController_Consumer
{
// private static final String REST_URL_PREFIX = "http://localhost:8001";
private static final String REST_URL_PREFIX = "http://MICROSERVICECLOUD-DEPT";
/**
* 使用 使用restTemplate访问restful接口非常的简单粗暴无脑。 (url, requestMap,
* ResponseBean.class)这三个参数分别代表 REST请求地址、请求参数、HTTP响应转换被转换成的对象类型。
*/
@Autowired
private RestTemplate restTemplate;
@RequestMapping(value = "/consumer/dept/add")
public boolean add(Dept dept)
{
return restTemplate.postForObject(REST_URL_PREFIX + "/dept/add", dept, Boolean.class);
}
@RequestMapping(value = "/consumer/dept/get/{id}")
public Dept get(@PathVariable("id") Long id)
{
return restTemplate.getForObject(REST_URL_PREFIX + "/dept/get/" + id, Dept.class);
}
@SuppressWarnings("unchecked")
@RequestMapping(value = "/consumer/dept/list")
public List<Dept> list()
{
return restTemplate.getForObject(REST_URL_PREFIX + "/dept/list", List.class);
}
// 测试@EnableDiscoveryClient,消费端可以调用服务发现
@RequestMapping(value = "/consumer/dept/discovery")
public Object discovery()
{
return restTemplate.getForObject(REST_URL_PREFIX + "/dept/discovery", Object.class);
}
}
扫描二维码关注公众号，回复：
6773463 查看本文章
效果展现
默认轮询算法，端口号8003/8002/8001 不断循环变换。
这个discovery方法调用的是服务提供者提供的方法，具体的方法体如下：
@Autowired
private DiscoveryClient client;
List<String> list = client.getServices();
System.out.println("**********" + list);
List<ServiceInstance> srvList = client.getInstances("MICROSERVICECLOUD-DEPT");
for (ServiceInstance element : srvList) {
System.out.println(element.getServiceId() + "\t" + element.getHost() + "\t" + element.getPort() + "\t"
+ element.getUri());
}
return this.client;小结
自定义算法类代码：
package com.atguigu.myrule;
import java.util.List;
import com.netflix.client.config.IClientConfig;
import com.netflix.loadbalancer.AbstractLoadBalancerRule;
import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.Server;
public class RandomRule_ZY extends AbstractLoadBalancerRule
{
// total = 0 // 当total==5以后，我们指针才能往下走，
// index = 0 // 当前对外提供服务的服务器地址，
// total需要重新置为零，但是已经达到过一个5次，我们的index = 1
// 分析：我们5次，但是微服务只有8001 8002 8003 三台，OK？
//
private int total = 0; // 总共被调用的次数，目前要求每台被调用5次
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) {
/*
* No servers. End regardless of pass, because subsequent passes only get more
* restrictive.
*/
return null;
}
// int index = rand.nextInt(serverCount);// java.util.Random().nextInt(3);
// server = upList.get(index);
// private int total = 0; // 总共被调用的次数，目前要求每台被调用5次
// private int currentIndex = 0; // 当前提供服务的机器号
if(total < 5)
{
server = upList.get(currentIndex);
total++;
}else {
total = 0;
currentIndex++;
if(currentIndex >= upList.size())
{
currentIndex = 0;
}
}
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;
}
@Override
public Server choose(Object key)
{
return choose(getLoadBalancer(), key);
}
@Override
public void initWithNiwsConfig(IClientConfig clientConfig)
{
// TODO Auto-generated method stub
}
}感谢您的访问！