SpringCloud从看不懂到放弃，第三章

SpringCloud从看不懂到放弃，第三章

一、Ribbon负载均衡Load Balance

思考

Ribbon、Nginx、Feign 三者有什么区别

1、Ribbon简介

1）、Ribbon是一套 【客户端】 的 【负载均衡】 工具 2）、负载均衡（Load Balance）分为 集中式LB 和 进程内LB 集中式LB ： 即在服务的消费方和提供方之间使用独立的LB设施(可以是硬件，如F5, 也可以是软件，如nginx), 由该设施负责把访问请求通过某种策略转发至服务的提供方; 进程内LB : 将LB逻辑集成到消费方，消费方从服务注册中心获知有哪些地址可用，然后自己再从这些地址中选择出一个合适的服务器。Ribbon就属于进程内LB，它只是一个类库，集成于消费方进程，消费方通过它来获取到服务提供方的地址。 3）、Spring Cloud Ribbon是基于Netflix Ribbon实现的一套客户端负载均衡的工具。 简单的说，Ribbon是Netflix发布的开源项目，主要功能是提供客户端的软件负载均衡算法，将Netflix的中间层服务连接在一起。Ribbon客户端组件提供一系列完善的配置项如连接超时，重试等。简单的说，就是在配置文件中列出Load Balancer（简称LB）后面所有的机器，Ribbon会自动的帮助你基于某种规则（如简单轮询，随机连接等）去连接这些机器。我们也很容易使用Ribbon实现自定义的负载均衡算法。

2、Ribbon的初步配置

①、maven坐标 ②、启动类@EnnableXXX

应为是客户端负载均衡工具，所以一系列操作都是在cloud-consumer-dept-80上进行的。

2.1）、POM修改

eureka客户端、Ribbon客户端、config客户端（服务端都带-server）

<!-- Ribbon相关 --> <!--Ribbon client--> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-eureka</artifactId> </dependency> <!--Eureka client--> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-ribbon</artifactId> </dependency> <!--config client--> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-config</artifactId> </dependency>

2.2）、YML修改

新增eureka服务路径

eureka: client: register-with-eureka: false service-url: defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/

2.3）、ConfigBean修改

应为consumer是通过restTemplate访问服务提供方的，所以要在restTemplate中增加负载均衡

package com.lee.cloud.cfgbean; import org.springframework.cloud.client.loadbalancer.LoadBalanced; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.web.client.RestTemplate; //配置类 @Configuration public class ConfigBean { //RestTemplate提供了多种便捷访问远程HTTP服务的方法 //是一种简单便捷的访问restful服务模板类，是spring提供的用于访问Rest服务的客户端模板工具集 //类似JDBCTemplate RedisTemplate等 @Bean @LoadBalanced//负载均衡 public RestTemplate restTemplate(){ return new RestTemplate(); } }

2.4）、主启动类修改

@EnableEurekaClient //注意是Eureka客户端不是Ribbon

2.5）、修改客户端访问类

因为原来访问的都是localhost:8001路径接口，现在访问 多个路径

将路径改成 微服务 在Eureka中注册的实例名称

// private static final String REST_URL_PREFIX = "http://localhost:8001"; private static final String REST_URL_PREFIX = "http://CLOUD-DEPT";

测试：

1、启动 cloud-eureka-7001\cloud-eureka-7002\cloud-eureka-7003 2、启动 cloud-provider-dept-8001 3、启动 cloud-consumer-dept-80 4、访问 http://localhost:80/consumer/dept/list 结论，Ribbon和Eureka整合后Consumer可以直接通过服务实例名称调用服务而不用再关心服务端的地址和接口（这里还没有用到Load Balance，下一步会增加cloud-provider-dept来验证）

3、Ribbon负载均衡

3.1）、Ribbon架构图

Ribbon在工作时分成两步 第一步先选择 EurekaServer ,它优先选择在同一个区域内负载较少的server. 第二步再根据用户指定的策略，在从server取到的服务注册列表中选择一个地址。 其中Ribbon提供了多种策略：比如轮询、随机和根据响应时间加权。

3.2）、新增 两个服务提供者

cloud-provider-dept-8002、cloud-provider-dept-8003

修改他们对应的POM 、YML、 启动类

三个服务对外暴露的 服务实例名称 必须一致

3.3）、新增对应的数据库

不是必须的，只是为了测试 负载均衡时，可以看清楚到底访问的哪个服务而已

DROP DATABASE IF EXISTS cloudDB02; CREATE DATABASE cloudDB02 CHARACTER SET UTF8; USE cloudDB02; CREATE TABLE dept ( deptno BIGINT NOT NULL PRIMARY KEY AUTO_INCREMENT, dname VARCHAR(60), db_source VARCHAR(60) ); INSERT INTO dept(dname,db_source) VALUES('开发部',DATABASE()); INSERT INTO dept(dname,db_source) VALUES('人事部',DATABASE()); INSERT INTO dept(dname,db_source) VALUES('财务部',DATABASE()); INSERT INTO dept(dname,db_source) VALUES('市场部',DATABASE()); INSERT INTO dept(dname,db_source) VALUES('运维部',DATABASE()); SELECT * FROM dept; ------------------------------------------------------------- DROP DATABASE IF EXISTS cloudDB03; CREATE DATABASE cloudDB03 CHARACTER SET UTF8; USE cloudDB03; CREATE TABLE dept ( deptno BIGINT NOT NULL PRIMARY KEY AUTO_INCREMENT, dname VARCHAR(60), db_source VARCHAR(60) ); INSERT INTO dept(dname,db_source) VALUES('开发部',DATABASE()); INSERT INTO dept(dname,db_source) VALUES('人事部',DATABASE()); INSERT INTO dept(dname,db_source) VALUES('财务部',DATABASE()); INSERT INTO dept(dname,db_source) VALUES('市场部',DATABASE()); INSERT INTO dept(dname,db_source) VALUES('运维部',DATABASE()); SELECT * FROM dept;

测试：

1、启动3个Eureka服务 2、启动3个服务提供方 3、启动服务消费方 4、访问http://localhost:80/consumer/dept/list 结论： Ribbon其实就是一个软负载均衡的客户端组件， 他可以和其他所需请求的客户端结合使用，和eureka结合只是其中的一个实例。

4、Ribbon核心组件IRule

IRule：根据特定算法中从服务列表中选取一个要访问的服务 默认自带的七种算法： 1、RoundRobinRule：轮询 2、RandomRule：随机 3、AvailabilityFilteringRULE:会先过滤掉由于多次访问故障而处于断路器跳闸状态的服务， 还有并发的连接数量超过阈值的服务，然后对剩余的服务列表按照轮询策略进行访问 4、WeightedResponseTimeRule:根据平均响应时间计算所有服务的权重，响应时间越快服务权重越大被选中的概率越高。 刚启动时如果统计信息不足，则使用RoundRobinRule策略,等统计信息足够,会切换到 WeightedResponseTimeRule 5、RetryRule:先按照RoundRobinRule的策略获取服务，如果获取服务失败则在指定时间内会进行重试，获取可用的服务 6、BestAvailableRule:会先过滤掉由于多次访问故障而处于断路器跳闸状态的服务，然后选择一个并发量最小的服务 7、ZoneAvoidanceRule:默认规则,复合判断server所在区域的性能和server的可用性选择服务器

更换负载均衡方式：

修改cloud-consumer-dept-80中的configBean

package com.lee.cloud.cfgbean; import com.netflix.loadbalancer.IRule; import com.netflix.loadbalancer.RandomRule; import org.springframework.cloud.client.loadbalancer.LoadBalanced; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.web.client.RestTemplate; //配置类 @Configuration public class ConfigBean { //RestTemplate提供了多种便捷访问远程HTTP服务的方法 //是一种简单便捷的访问restful服务模板类，是spring提供的用于访问Rest服务的客户端模板工具集 //类似JDBCTemplate RedisTemplate等 @Bean @LoadBalanced//负载均衡--默认RoundRobinRule轮询算法 public RestTemplate restTemplate(){ return new RestTemplate(); } //修改成随机算法 @Bean public IRule myRule(){ return new RandomRule(); } }

5、自定义负载均衡算法

在自定义算法前我们先看一下自带默认的算法的结构 //轮询 public class RoundRobinRule extends AbstractLoadBalancerRule //随机 public class RandomRule extends AbstractLoadBalancerRule 他们都是继承了AbstractLoadBalancerRule类 而AbstractLoadBalancerRule：实现了IRule接口。 public abstract class AbstractLoadBalancerRule implements IRule, IClientConfigAware { private ILoadBalancer lb; public AbstractLoadBalancerRule() { } public void setLoadBalancer(ILoadBalancer lb) { this.lb = lb; } public ILoadBalancer getLoadBalancer() { return this.lb; } } public interface IRule { //选择 Server choose(Object var1); //设置轮询算法 void setLoadBalancer(ILoadBalancer var1); //获取算法 ILoadBalancer getLoadBalancer(); } 所以我们自定义算法的时候直接继承AbstractLoadBalancerRule 实现 setLoadBalancer 和 getLoadBalancer方法即可 且在启动该微服务的时候就能去加载我们的自定义Ribbon配置类，从而使配置生效，形如： @RibbonClient(name="CLOUD-DEPT",configuration=MySelfRule.class)配置

注意：

官方文档明确给出了警告： 这个自定义配置类不能放在@ComponentScan所扫描的当前包下以及子包下， 否则我们自定义的这个配置类就会被所有的Ribbon客户端所共享，也就是说 我们达不到特殊化定制的目的了。

步骤：

自定义算法：

package com.lee.myrule; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import com.netflix.loadbalancer.IRule; import com.netflix.loadbalancer.RandomRule; @Configuration public class MySelfRule { @Bean public IRule myRule() { return new RandomRule_ZY(); } } package com.lee.myrule import java.util.List; import java.util.Random; 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 { 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); // server = upList.get(index); 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) { } }

主启动类增加：

@RibbonClient(name="CLOUD-DEPT",configuration=MySelfRule.class)

测试：

http://localhost:80/consumer/dept/list

POM新增

<!--Feign相关，应为Feign是基于Ribbon的，所以还需要Ribbon的东西--> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-feign</artifactId> </dependency>

service新增

package com.lee.cloud.feign.service; import com.lee.cloud.entity.Dept; import org.springframework.cloud.netflix.feign.FeignClient; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import java.util.List; /** * 远程调用服务端接口--底层其实也是通过restTemplate调用的 * CLOUD-DEPT 调用服务的实例名称 */ @FeignClient(value = "CLOUD-DEPT") public interface DeptFeignService { @RequestMapping(value = "/dept/get/{id}",method = RequestMethod.GET) public Dept get(@PathVariable("id") long id); @RequestMapping(value = "/dept/list",method = RequestMethod.GET) public List<Dept> list(); @RequestMapping(value = "/dept/add",method = RequestMethod.POST) public boolean add(Dept dept); }

controller修改

package com.lee.cloud.controller; import com.lee.cloud.entity.Dept; import com.lee.cloud.feign.service.DeptFeignService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; import java.util.List; @RestController public class DeptController_Consumer { @Autowired private DeptFeignService deptFeignService; @RequestMapping(value = "/consumer/dept/get/{id}") public Dept get(@PathVariable("id") Long id) { return deptFeignService.get(id); } @RequestMapping(value = "/consumer/dept/list") public List<Dept> list() { return deptFeignService.list(); } @RequestMapping(value = "/consumer/dept/add") public Object add(Dept dept) { return deptFeignService.add(dept); } }

启动类：

package com.lee.cloud; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.cloud.netflix.eureka.EnableEurekaClient; import org.springframework.cloud.netflix.feign.EnableFeignClients; @EnableEurekaClient @SpringBootApplication @EnableFeignClients public class DeptConsumer80Feign_App { public static void main(String[] args) { SpringApplication.run(DeptConsumer80Feign_App.class,args); } }

注意：Feign的负载均衡自定义方式 还是和Ribbon的一样

测试：

1、启动3个Eureka cloud-eureka-7001|7002|7003 2、启动3个微服务 cloud-provider-dept-8001|8002|8003 3、启动服务消费者 cloud-consumer-dept-80-feign 4、访问：http://localhost:80/consumer/dept/list