SpringCloud微服务之三:Ribbon负载均衡

最新推荐文章于 2023-12-14 15:10:21 发布

逻辑怪人

最新推荐文章于 2023-12-14 15:10:21 发布

阅读量296

点赞数

分类专栏：微服务文章标签： ribbon

本文链接：https://blog.csdn.net/a1554289942/article/details/108074103

版权

微服务专栏收录该内容

3 篇文章 0 订阅

订阅专栏

Ribbon是什么

Spring Cloud Ribbon 是基于Netflix Ribbon实现的一套客户端负载均衡的工具
简单来说，Ribbon是Netflix发布的开源项目，主要的功能是提供客户端的软件负载均衡的算法，将Netflix的中间层服务连接在一起，Ribbon的客户端组件提供的一系列完整的配置项，如：连接超时、重试等等，简单来说，就是在配置文件中LoadBalancer(简称LB：负载均衡)后面所有的机器，Ribbon会自动的帮助你基于某种规则（如简单轮询、随机连接等等）去连接这些机器，我们也很容易使用Ribbon实现自定的负载均衡算法

Ribbon能干嘛？

LB，即负载均衡（Load Balance），在微服务或分布式集群中经常使用的一种应用
负载就很简单来说就是将用户的请求平摊的分配到多个服务，从而达到系统的HA（高可用）
常见的负载均衡软件有Nginx、LVS等等
Dubbo、SpringCloud中均给我们提供负载均衡，SpringCloud的负载算法可以自定义
负载均衡的简单分类
- 集中式LB
  - 即在服务的消费方和提供方之间使用独立的LB设施，如Nginx：反向代理服务器，由该设施复杂把访问请求通过某种策略转发至服务端的提供方
- 进程式LB
  - 将LB逻辑继承到消费方，消费方从服务注册中心（Eureka）获知有哪些地址可用，如何自己再从这些地址选出一个合适的服务器
  - Ribbon就属于进程内LB，它只是一个类库，集成与消费方进程，消费方通过它来获取服务提供方的地址

Ribbon负载均衡只能在服务消费端（springcloud-consumer-dept-80项目）：

1、导入依赖

<!--Ribbon负载均衡-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-ribbon</artifactId>
    <version>1.4.7.RELEASE</version>
</dependency>
<!--Eureka客户端-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-eureka</artifactId>
    <version>1.4.7.RELEASE</version>
</dependency>

2、配置文件application.yml

server:
  port: 80


eureka:
  client:
    register-with-eureka: false #不向Eureka注册自己
    service-url:
    # eureka7001.com、eureka7002.com、eureka7003.com是本地主机的名称，7001,7002,7003是Eureka集群的端口（服务注册中心）
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/

3、启动Eureka Client

//Ribbon和Eureka 整合之后，客户端就可以直接调用，不用关心IP地址和端口
@SpringBootApplication
@EnableEurekaClient
public class DeptConsumer_80 {
    public static void main(String[] args) {
        SpringApplication.run(DeptConsumer_80.class,args);
    }
}

4、配置类

package com.springcloud.config;

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//相当于spring中的SpringContext.xml
public class ConfigBean {

    //配置负载均衡实现RestTemplate
    @Bean
    @LoadBalanced //实现负载均衡Ribbon
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }
}

Controller层：

package com.springcloud.controller;

import com.kuangshen.springcloud.pojo.Dept;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.List;

@RestController
public class DeptConsumerController {

    /***
     * 理解消费者不应该有消费层
     * RestTemplate我们直接调用即可，注册到Spring中
     */
    @Autowired
    private RestTemplate restTemplate;//提供多种便捷的访问远程服务的方法，简单的Restful服务，模板

    //Ribbon，我们这里的地址应该是一个变量，应该通过服务名来访问
    //private final static String REST_URL_PREFIX="http://localhost:8001/dept/";
    private final static String REST_URL_PREFIX="http://SPRINGCLOUD-PROVIDER-DEPT/dept/";

    @PostMapping("/consumer/dept/add")
    public boolean addDept(Dept dept){
        return restTemplate.postForObject(REST_URL_PREFIX+"add",dept,boolean.class);
    }

    @GetMapping("/consumer/dept/{id}")
    public Dept queryById(@PathVariable("id") Long id){
        return restTemplate.getForObject(REST_URL_PREFIX+"get/"+id,Dept.class);
    }

    @GetMapping("/consumer/dept/list")
    public List<Dept> queryAll(){
        return restTemplate.getForObject(REST_URL_PREFIX+"list",List.class);
    }
}

在这里插入图片描述

Ribbon测试

先创建3个数据库db01、db02、db03，搭建3个服务提供者，

springcloud-provider-dept-8001项目

导入依赖

 <dependencies>
        <!--导入Eureka-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
            <version>1.4.7.RELEASE</version>
        </dependency>
        <!--完善actuator监控信息-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

        <!--我们需要拿到实体类，所以配置API Module-->
        <dependency>
            <groupId>com.kuangshen</groupId>
            <artifactId>springcloud-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <!--test-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-test</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--jetty:应用服务器-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jetty</artifactId>
        </dependency>
        <!--热部署：就是修改完代码，不用重启项目，只需要刷新页面即可-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
    </dependencies>

在这里插入图片描述

配置资源文件

application.yml

server:
  port: 8001

#mybatis配置
mybatis:
  type-aliases-package: com.kuangshen.springcloud.pojo
  config-location: classpath:mybatis/mybatis-config.xml
  mapper-locations: classpath:mybatis/mapper/*.xml

#Spring的配置
spring:
  application:
    name: springcloud-provider-dept
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/db01?useUnicode=true&characterEncoding=utf-8
    username: root
    password: 1554289942

#Eureka配置，服务注册到哪里
eureka:
  client:
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
  instance:
    instance-id: springcloud-provide-dept8001 #修改Eureka上的默认描述

#info配置信息:访问地址：http://localhost:8001/actuator/info
info:
  app.name: kuangshen-springcloud
  company.name: blog.kuangshenstudy.com

mybatis-config.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC
        "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <settings>
        <!--开启二级缓存，默认是开启的-->
        <setting name="cacheEnabled" value="true"/>
    </settings>
</configuration>

DeptMappper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.kuangshen.springcloud.dao.DeptDao">
    <insert id="addDept" parameterType="Dept">
        insert into dept(dname,db_source) values (#{dname},DATABASE());
    </insert>

    <select id="queryById" resultType="Dept" parameterType="Long">
        select * from dept where deptno=#{deptno};
    </select>

    <select id="queryAll" resultType="Dept">
        select * from dept;
    </select>
</mapper>

配置类

Dao层：

@Mapper //使用@mapper后，不需要在spring配置中设置扫描地址，通过mapper.xml里面的namespace属性对应相关的mapper类，spring将动态的生成Bean后注入到ServiceImpl中。
@Repository //@repository则需要在Spring中配置扫描包地址，然后生成dao层的bean，之后被注入到ServiceImpl中
public interface DeptDao {
    //增加数据
    boolean addDept(Dept dept);

    //通过id查询
    Dept queryById(Long id);

    //查询所有
    List<Dept> queryAll();
}

Service层：

public interface DeptService {
    //增加数据
    boolean addDept(Dept dept);

    //通过id查询
    Dept queryById(Long id);

    //查询所有
    List<Dept> queryAll();
}

@Service
public class DeptServiceImpl implements DeptService {

    @Autowired
    private DeptDao deptDao;

    @Override
    public boolean addDept(Dept dept) {
        return deptDao.addDept(dept);
    }

    @Override
    public Dept queryById(Long id) {
        return deptDao.queryById(id);
    }

    @Override
    public List<Dept> queryAll() {
        return deptDao.queryAll();
    }
}

Controller层：

//提供Restful服务
@RestController
public class DeptController {

    @Autowired
    private DeptService deptService;

    //获取一些配置信息，得到具体的微服务
    @Autowired
    private DiscoveryClient discoveryClient;

    @PostMapping("/dept/add")
    public boolean addDept(Dept dept){
        return deptService.addDept(dept);
    }

    @GetMapping("/dept/get/{id}")
    public Dept queryById(@PathVariable("id") Long id){
        return deptService.queryById(id);
    }

    @GetMapping("/dept/list")
    public List<Dept> queryAll(){
        return deptService.queryAll();
    }

    //注册进来的微服务，获取一些信息
    @GetMapping("/")
    public Object discovery(){
        //获取微服务列表的清单
        List<String> services = discoveryClient.getServices();
        System.out.println("service="+services);

        //得多一个具体的微服务信息，通过具体的微服务id
        List<ServiceInstance> instances = discoveryClient.getInstances("SPRINGCLOUD-PROVIDER-DEPT");
        for (ServiceInstance instance : instances) {
            System.out.println(
                    instance.getHost()+"\t"+
                    instance.getPort()+"\t"+
                    instance.getUri()+"\t"+
                    instance.getInstanceId()
            );
        }
        return this.discoveryClient;
    }
}

启动类：

@SpringBootApplication
@EnableEurekaClient //在服务启动后自动注册到Eureka中
@EnableDiscoveryClient //开启发现服务
public class DeptProvider_8001 {
    public static void main(String[] args) {
        SpringApplication.run(DeptProvider_8001.class,args);
    }
}

springcloud-provider-dept-8002项目

该项目和springcloud-provider-dept-8001项目其它的都一样，需要修改的地方：application.yml中服务端口和数据库，还有主入口的类名。

server:
  port: 8002

#mybatis配置
mybatis:
  type-aliases-package: com.kuangshen.springcloud.pojo
  config-location: classpath:mybatis/mybatis-config.xml
  mapper-locations: classpath:mybatis/mapper/*.xml

#Spring的配置
spring:
  application:
    name: springcloud-provider-dept #3个服务一样的名称
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/db02?useUnicode=true&characterEncoding=utf-8
    username: root
    password: 1554289942

#Eureka配置，服务注册到哪里
eureka:
  client:
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
  instance:
    instance-id: springcloud-provide-dept8002 #修改Eureka上的默认描述

#info配置信息:访问地址：http://localhost:8001/actuator/info
info:
  app.name: kuangshen-springcloud
  company.name: blog.kuangshenstudy.com

springcloud-provider-dept-8003项目

该项目和springcloud-provider-dept-8001项目其它的都一样，需要修改的地方：application.yml中服务端口和数据库，还有主入口的类名。

server:
  port: 8003

#mybatis配置
mybatis:
  type-aliases-package: com.kuangshen.springcloud.pojo
  config-location: classpath:mybatis/mybatis-config.xml
  mapper-locations: classpath:mybatis/mapper/*.xml

#Spring的配置
spring:
  application:
    name: springcloud-provider-dept
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/db03?useUnicode=true&characterEncoding=utf-8
    username: root
    password: 1554289942

#Eureka配置，服务注册到哪里
eureka:
  client:
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
  instance:
    instance-id: springcloud-provide-dept8003 #修改Eureka上的默认描述

#info配置信息:访问地址：http://localhost:8001/actuator/info
info:
  app.name: kuangshen-springcloud
  company.name: blog.kuangshenstudy.com

这样实现每个服务提供者绑定不同的数据库，启动3个服务提供者，3个注册中心（也可能电脑只能启动一个注册中心），启动服务消费者

在网页地址栏上输入http://localhost/consumer/dept/list

发现网页上的json格式的数据，其中数据库名db01、db02、db03是轮询的，说明使用Ribbon负载均衡算法。

Ribbon：自定义负载均衡算法

在这里插入图片描述

自定义负载算法配置类不在启动类（主入口）的当前包及以下的包。

配置类：

package com.springcloud.config;

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//相当于spring中的SpringContext.xml
public class ConfigBean {

    //配置负载均衡实现RestTemplate
    //IRule实现类

    /**
     * RoundRobinRule轮询
     * RandomRule 随机查询
     * AbstractLoadBalancerRule：会先过滤掉，跳闸，访问故障的服务，对身下的进行轮询
     * RetryRule: 会现在轮询获取服务，如果服务失败，则会在指定的时间你进行，重试
     * @return
     */
    @Bean
    @LoadBalanced //实现负载均衡Ribbon,默认是轮询
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }

    @Bean
    public IRule myRule(){
        return new RandomRule();//随机的Ribbon的负载均衡算法
    }
}

自定义负载均衡算法：

@Configuration
public class KuangRule {
    @Bean
    public IRule myRule(){
        return new MyRandomRule();
    }
}

package com.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 {

    /**
     *每个服务访问5次，换下一个服务（3个服务）
     *
     * total=0，默认是0，如果是5，我们指向下一个服务节点
     * index=0，默认是0，如果total=5，index+1
     */
    private int total=0;//当前访问次数
    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 = chooseRandomInt(serverCount);//生成区间的随机数
//            server = upList.get(index);//从活着的服务中，随机获取一个
            //===============================================
            if(total<5){
                server= upList.get(currentIndex);//从活着的服务中，指定获取一个
                total++;
            }
            else {
                total=0;
                currentIndex++;
                if (currentIndex>=upList.size()){
                    System.out.println("upList.size()="+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);
    }

    @Override
    public Server choose(Object key) {
        return choose(getLoadBalancer(), key);
    }

    @Override
    public void initWithNiwsConfig(IClientConfig clientConfig) {
        // TODO Auto-generated method stub

    }
}

启动主入口：

//Ribbon和Eureka 整合之后，客户端就可以直接调用，不用关心IP地址和端口
@SpringBootApplication
@EnableEurekaClient
//在微服务启动的时候加载我们自定义的Ribbon类
@RibbonClient(name = "SPRINGCLOUD-PROVIDER-DEPT",configuration = KuangRule.class)
public class DeptConsumer_80 {
    public static void main(String[] args) {
        SpringApplication.run(DeptConsumer_80.class,args);
    }
}

测试：启动三个服务提供者，一个注册中心，一个服务消费者。

地址栏：http://localhost/consumer/dept/list访问,可以实现每个服务访问5次，之后就访问下一个服务。

逻辑怪人

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SpringCloud微服务之三:Ribbon负载均衡

Ribbon是什么Spring Cloud Ribbon 是基于Netflix Ribbon实现的一套客户端负载均衡的工具简单来说，Ribbon是Netflix发布的开源项目，主要的功能是提供客户端的软件负载均衡的算法，将Netflix的中间层服务连接在一起，Ribbon的客户端组件提供的一系列完整的配置项，如：连接超时、重试等等，简单来说，就是在配置文件中LoadBalancer(简称LB：负载均衡)后面所有的机器，Ribbon会自动的帮助你基于某种规则（如简单轮询、随机连接等等）去连接这些机
复制链接

扫一扫