提出疑问
① 如何在配置Eureka Client注册中心时不去硬编码Eureka Server的地址？
② 在微服务不同模块间进行通信时，如何不去硬编码服务提供者的地址？
③ 当部署多个相同微服务时，如何实现请求时的负载均衡？
解决方案-Ribbon
一 Ribbon简介
Spring Cloud Ribbon是基于NetFilix Ribbon实现的一套客户端的负载均衡工具。Ribbon客户端组件提供一系列的完整的配置，如超时，重试等。通过Load Balancer（LB）获取到服务提供的所有机器实例，Ribbon会自动提供基于某种规则（轮询、权重、ip_hash等）去调用这些服务。Ribbon也可以实现我们自己的负载均衡算法。
1.1 客户端的负载均衡
我们来谈谈什么是客户端的负载均衡？（进程内的LB，他是一个类库集成到消费端，通过消费端进行获取提供者的地址）
生活中：类似与你去火车站排队进站（有三条通道），只要是正常人，都会排队到人少的队伍中去；
程序中：我们消费端，能获取到服务提供者地址列表，然后根据某种策略去获取一个地址进行调用；
1.2 服务端的负载均衡
生活中：类似与你去火车站排队进站的时候，有一个火车站的引导员告诉你说三号通道人少，你去三号通道排队；
程序中：就是你消费者调用的是ng的地址，由ng来选择请求的转发（轮询、权重、ip_hash等）；
二 Ribbon应用
2.1 依赖引入
在之前的文章SpringCloud之Eureka简单入门(单机版)中的父工程添加子工程，引入依赖：
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<artifactId>spring-cloud-parent</artifactId>
<groupId>org.example</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<artifactId>ms-consumer-ribbon-8002</artifactId>
<packaging>war</packaging>
<name>ms-consumer-ribbon-8002 Maven Webapp</name>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<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.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
<!--加入ribbon的依赖-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
2.2 引入服务提供者
按照之前的文章SpringCloud之Eureka简单入门(单机版)中的服务提供者重新创建2个服务提供者，端口分别为7001和7002；
其中Controller中类代码编写分别如下：
@RestController
@RequestMapping("/ms")
public class ServiceController {
@RequestMapping(value = "/hello")
public String testEureka() {
return "hello,this is micro-service-provider,using 7001 port!";
}
}
@RestController
@RequestMapping("/ms")
public class ServiceController {
@RequestMapping(value = "/hello")
public String testEureka() {
return "hello,this is micro-service-provider,using 7002 port!";
}
}
2.3 编写application.properties配置文件
server.port=8002
# 注册到Eureka服务端的微服务名称
spring.application.name=ms-consumer-user
# 注册到Eureka服务端的地址
# http://${
eureka.instance.hostname}:${
server.port}/eureka/ ----修改了hosts文件
# eureka.client.service-url.defaultZone=http://www.eureka9000.com:9000/eureka/
eureka.client.service-url.defaultZone=http://localhost:9000/eureka/
# 点击具体的微服务，右下角是否显示ip
eureka.instance.prefer-ip-address=true
# 显示微服务的名称
eureka.instance.instance-id=ms-consumer-ribbon-8003
2.4 编写启动类
@SpringBootApplication
@EnableDiscoveryClient
public class MsConsumerRibbonStarter {
public static void main(String[] args) {
SpringApplication.run(MsConsumerRibbonStarter.class,args);
}
}
2.5 编写controller
@RestController
public class RibbonController {
@Autowired
RestTemplate restTemplate;
@RequestMapping(value = "/hello", method = RequestMethod.GET)
public String test(){
return restTemplate.getForEntity("http://micro-service-provider/ms/hello", String.class).getBody();
}
}
2.6 加入负载均衡配置
@Configuration
public class RibbonConfig {
@Bean
@LoadBalanced
public RestTemplate restTemplate() {
return new RestTemplate();
}
}
主要就是加入了注解@LoadBalanced，这里是采用了Ribbon的默认策略-轮询；使用添加@LoadBalanced注解后的RestTemplate调用服务提供者的接口时，可以使用虚拟IP替代真实IP地址。所谓的虚拟IP就是服务提供者在application.properties或yml文件中配置的spring.application.name属性的值
三、应用测试
1、先启动之前的文章SpringCloud之Eureka简单入门(单机版)中的Eureka服务端，然后再启动两个服务提供者，截图如下：
2、再启动基于spring cloud ribbon搭建的服务消费者
3、端口访问
浏览器输入：http://localhost:8002/hello
点击刷新以后：
四、Ribbon负载均衡策略
4.1 轮询策略（默认）
策略对应类名：RoundRobinRule
实现原理：轮询策略表示每次都顺序取下一个 provider，比如一共有 5 个 provider，第 1 次取第 1 个，第 2 次取第 2 个，第 3 次取第 3 个，以此类推。
4.2 权重轮询策略
策略对应类名：WeightedResponseTimeRule
扫描二维码关注公众号，回复：
13112344 查看本文章
实现原理：
- 根据每个 provider 的响应时间分配一个权重，响应时间越长，权重越小，被选中的可能性越低。
- 原理：一开始为轮询策略，并开启一个计时器，每 30 秒收集一次每个 provider 的平均响应时间，当信息足够时，给每个 provider 附上一个权重，并按权重随机选择 provider，高权越重的 provider 会被高概率选中。
4.3 随机策略
策略对应类名：RandomRule
实现原理：从 provider 列表中随机选择一个。
4.4 最少并发数策略
策略对应类名：BestAvailableRule
实现原理：选择正在请求中的并发数最小的 provider，除非这个 provider 在熔断中。
4.5 重试策略
策略对应类名：RetryRule
实现原理：其实就是轮询策略的增强版，轮询策略服务不可用时不做处理，重试策略服务不可用时会重新尝试集群中的其他节点。
4.6 可用性敏感策略
策略对应类名：AvailabilityFilteringRule
实现原理：过滤性能差的 provider
- 第一种：过滤掉在 Eureka 中处于一直连接失败的 provider。
- 第二种：过滤掉高并发（繁忙）的 provider。
4.7 区域敏感性策略
策略对应类名：ZoneAvoidanceRule
实现原理：
- 以一个区域为单位考察可用性，对于不可用的区域整个丢弃，从剩下区域中选可用的 provider。
- 如果这个 ip 区域内有一个或多个实例不可达或响应变慢，都会降低该 ip 区域内其他 ip 被选中的权重。
在启动类或配置类中注入负载均衡策略对象。所有服务请求均使用该策略。
@Bean
public IRule iRule(){
return new RoundRobinRule();
}
五、Ribbon配置文件设置
Eureka是用于服务发现和服务注册、以及使用服务名来解决服务消费者和服务提供者通信时地址的硬编码问题的。如果Ribbon脱离了Eureka，那么在服务消费者端就无法根据服务名通过心跳机制从EurekaServer端获取对应服务提供者的IP以及端口号。这时就需要在服务消费者端配置对应服务提供者的地址列表，然后Ribbon才能通过配置文件或者自定义的RibbonClient或者默认的配置获取负载均衡的轮询策略进行请求分发。
配置方式：
第一步：检查是否引入了Eureka。如果服务在依赖中添加了spring-cloud-starter-eureka，这种情况下如果想使Ribbon脱离Eureka使用的话就需要将Eureka禁用掉。仅仅需要添加以下配置，如果没有引入Eureka就不需要禁用。
ribbon:
eureka:
enabled: false
第二步：配置某服务提供者的地址列表以及均衡策略(默认是轮询)
<服务提供者名称>:
ribbon:
listOfServers: localhost:7001,localhost:7002
NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule
ribbon的常见配置
1.禁用eureka
当我们在resttemplate上面添加loadbalence注解后，就可以使用服务名去调用，如果我们想关闭这个功能，可以使用
ribbon.eureka.enable=false
2.配置接口地址列表
如果我们关闭了eureka之后，还想用服务名去调用，就需要手动配置服务配置列表
服务名.ribbon.listOfServers=IP:PORT1,IP:PORT2
3.配置负载均衡策略
服务名.ribbon.NFLoadBalencerRuleClassName=策略class全类名
4.超时时间
ribbon中有两种和超时时间相关的配置
ribbon.ConnectTimeout=2000 请求连接的超时时间
ribbon.ReadTimeout=5000 请求处理的超时时间
可以在前面加上具体的服务名，为指定的服务配置
5.并发参数
ribbon.MaxTotalConnections=500 最大连接数
ribbon,MaxConnectionsPerHost=500 每个host最大连接数
六、自定义ribbon负载均衡策略
只要实现了IRule就可以完成自定义负载均衡，至于具体怎么来，我们先看看他默认的实现。
/*
*
* Copyright 2013 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package com.netflix.loadbalancer;
import com.netflix.client.config.IClientConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
/**
* The most well known and basic load balancing strategy, i.e. Round Robin Rule.
*
* @author stonse
* @author Nikos Michalakis <[email protected]>
*
*/
public class RoundRobinRule extends AbstractLoadBalancerRule {
private AtomicInteger nextServerCyclicCounter;
private static final boolean AVAILABLE_ONLY_SERVERS = true;
private static final boolean ALL_SERVERS = false;
private static Logger log = LoggerFactory.getLogger(RoundRobinRule.class);
public RoundRobinRule() {
nextServerCyclicCounter = new AtomicInteger(0);
}
public RoundRobinRule(ILoadBalancer lb) {
this();
setLoadBalancer(lb);
}
public Server choose(ILoadBalancer lb, Object key) {
if (lb == null) {
log.warn("no load balancer");
return null;
}
Server server = null;
int count = 0;
while (server == null && count++ < 10) {
List<Server> reachableServers = lb.getReachableServers();
List<Server> allServers = lb.getAllServers();
int upCount = reachableServers.size();
int serverCount = allServers.size();
if ((upCount == 0) || (serverCount == 0)) {
log.warn("No up servers available from load balancer: " + lb);
return null;
}
int nextServerIndex = incrementAndGetModulo(serverCount);
server = allServers.get(nextServerIndex);
if (server == null) {
/* Transient. */
Thread.yield();
continue;
}
if (server.isAlive() && (server.isReadyToServe())) {
return (server);
}
// Next.
server = null;
}
if (count >= 10) {
log.warn("No available alive servers after 10 tries from load balancer: "
+ lb);
}
return server;
}
/**
* Inspired by the implementation of {@link AtomicInteger#incrementAndGet()}.
*
* @param modulo The modulo to bound the value of the counter.
* @return The next value.
*/
private int incrementAndGetModulo(int modulo) {
for (;;) {
int current = nextServerCyclicCounter.get();
int next = (current + 1) % modulo;
if (nextServerCyclicCounter.compareAndSet(current, next))
return next;
}
}
@Override
public Server choose(Object key) {
return choose(getLoadBalancer(), key);
}
@Override
public void initWithNiwsConfig(IClientConfig clientConfig) {
}
}
看来只要继承类AbstractLoadBalancerRule就可以实现，看一下这个类：
/**
* Class that provides a default implementation for setting and getting load balancer
* @author stonse
*
*/
public abstract class AbstractLoadBalancerRule implements IRule, IClientConfigAware {
private ILoadBalancer lb;
@Override
public void setLoadBalancer(ILoadBalancer lb){
this.lb = lb;
}
@Override
public ILoadBalancer getLoadBalancer(){
return lb;
}
}
这里我们能发现，还是我们上面所说过的 实现了IRule就能够自定义负载均衡即使是他默认的策略也实现了IRule，我们可以直接把代码copy过来改动一点：
import com.netflix.client.config.IClientConfig;
import com.netflix.loadbalancer.AbstractLoadBalancerRule;
import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.Server;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
public class MyRandomRule extends AbstractLoadBalancerRule {
Random rand;
public MyRandomRule() {
rand = new Random();
}
private int currentIndex = 0;
private List<Server> currentChooseList = new ArrayList<>();
/**
* Randomly choose from all living servers
*/
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);
// 当前的轮询次数小于等于5的时候
if (currentIndex < 5) {
if (currentChooseList.isEmpty()) {
currentChooseList.add(upList.get(index));
}
// 当前的次数加1
currentIndex++;
return currentChooseList.get(0);
} else {
currentChooseList.clear();
currentChooseList.add(0, upList.get(index));
currentIndex = 0;
// return currentChooseList.get(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
}
}
上面设置的策略还是轮询，只不过设置成5次轮询一次，可以测试一下，然后在配置ribbon负载均衡的类中设置：
@Configuration
public class RibbonConfig {
@Bean
@LoadBalanced
public RestTemplate restTemplate() {
return new RestTemplate();
}
@Bean
public IRule myRandomRule() {
return new MyRandomRule();
}
}
到这里，就是SpringCloud之Ribbon的简单入门了，有问题的童鞋可以留下问题一起交流交流。