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

• Z时代
• 2024-01-10
• 分类：综合

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-7001cloud-eureka-7002cloud-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

二、Feign负载均衡Load Balance

1、Feign简介

 Feign是一个声明式WebService客户端。使用Feign能让编写Web Service客户端更加简单, 它的使用方法是定义一个接口，然后在上面添加注解，同时也支持JAX-RS标准的注解。Feign也支持可拔插式的编码器和解码器。Spring Cloud对Feign进行了封装，使其支持了Spring MVC标准注解和HttpMessageConverters。Feign可以与Eureka和Ribbon组合使用以支持负载均衡。
 Feign是一个声明式的Web服务客户端，使得编写Web服务客户端变得非常容易，
只需要创建一个接口，然后在上面添加注解即可。
参考官网：https://github.com/OpenFeign/feign 
 Feign能干什么
Feign旨在使编写Java Http客户端变得更容易。
前面在使用Ribbon+RestTemplate时，利用RestTemplate对http请求的封装处理，形成了一套模版化的调用方法。但是在实际开发中，由于对服务依赖的调用可能不止一处，往往一个接口会被多处调用，所以通常都会针对每个微服务自行封装一些客户端类来包装这些依赖服务的调用。所以，Feign在此基础上做了进一步封装，由他来帮助我们定义和实现依赖服务接口的定义。在Feign的实现下，我们只需创建一个接口并使用注解的方式来配置它(以前是Dao接口上面标注Mapper注解,现在是一个微服务接口上面标注一个Feign注解即可)，即可完成对服务提供方的接口绑定，简化了使用Spring cloud Ribbon时，自动封装服务调用客户端的开发量。
Feign集成了Ribbon
利用Ribbon维护了MicroServiceCloud-Dept的服务列表信息，并且通过轮询实现了客户端的负载均衡。而与Ribbon不同的是，通过feign只需要定义服务绑定接口且以声明式的方法，优雅而简单的实现了服务调用

上面我们用Ribbon进行负载均衡，功能很强大，甚至可以自定义算法。那么Feign是怎么出来的？
1、Ribbon直接调用我们的微服务来进行访问,如
private static final String REST_URL_PREFIX = "http://CLOUD-DEPT";
但是大家目前都西关面向接口编程，比如webservice捷库，比如我们的DAO接口，这个已经是大家的规范了。
所以SpringCloud提供了两种方式：
1、微服务名字获得调用地址---->Ribbon
2、通过接口+注解，获得我们的调用服务---->Feign

2、Feign工程构建

2.1）、参考cloud-consumer-dept-80创建cloud-consumer-dept-80-feign

注：不用拷贝controller

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

以上是 4、SpringCloud从看不懂到放弃，第三章 的全部内容， 来源链接： utcz.com/z/510316.html