首页 > > 程序设计 > Java技术 >

Spring Cloud认知学习(二)：Ribbon使用

2020-05-15 16:05:54来源：博客园 阅读 ()

新老客户大回馈,云服务器低至5折

Spring Cloud认知学习(二)：Ribbon使用

??上一篇介绍了Spring Cloud，以及服务注册与发现的组件Eureka的简单使用。 ??这一篇我们来介绍微服务构建起来后，使用Ribbon来解决多个服务的负载均衡问题。

目录

  • Ribbon负载均衡
    • 简单使用步骤：
      • 1.新建模块，用于负载均衡
      • 2.修改模块代码：
      • 3.启动模块
      • 4.修改消费者模块
    • 负载均衡算法：
    • 自定义负载规则：

??接上回Spring Cloud认知学习(一)：Spring Cloud介绍与Eureka使用
??上一篇介绍了Spring Cloud，以及服务注册与发现的组件Eureka的简单使用。
??这一篇我们来介绍微服务构建起来后，使用Ribbon来解决多个服务的负载均衡问题。

Ribbon负载均衡

客户端负载均衡的意思是，让客户端来进行负载均衡，而不是服务端来进行负载均衡，是什么意思呢？比如说你要去排队买东西，有三条队，你自然而然地会选择队伍短的队去排咯??，这是由你去进行的负载均衡，而不是服务员帮你去安排你该排哪条队。
??为什么要采用客户端负载均衡呢？

  • 主要是，客户端的负载均衡是会减少服务端的资源消耗的，就好像如果有很多消费者的话，你要么就雇佣很多服务员，要么就让消费者等服务员有空。
  • 其次呢，这也是从架构上考虑的，因为客户端会从eureka中拉取服务可用列表，那么如果此时顺便拉取了此时各种服务的负载状态的话，那么也就顺手地可以使用这些信息来进行客户端负载均衡了。


简单使用步骤：

下面的代码可以参考：Ribbon负载均衡简单实验

1.新建模块，用于负载均衡

新建模块spring-cloud-user-service-8002，spring-cloud-user-service-8003


2.修改模块代码：

  • 给模块spring-cloud-user-service-8002，spring-cloud-user-service-8003导入pom.xml、修改application.yml和修改主启动类。
  • 代码基本与模块spring-cloud-user-service-8001一样的。
  • pom.xml与spring-cloud-user-service-8001一样的。
  • 控制器，mapper，都跟spring-cloud-user-service-8001一样的。只是主程序类的名字问题
  • 主要是修改服务端口和数据库。
    20200511220322

由于新建了服务提供者，所以为了让不同的服务使用不同的数据库，所以要执行下面的SQL来创建额外的数据库：

sql:

-- db2
DROP DATABASE IF EXISTS cloud02;
CREATE DATABASE cloud02 CHARACTER SET UTF8;
USE cloud03;
CREATE TABLE user
(
  id int PRIMARY KEY AUTO_INCREMENT,
  username VARCHAR(255),
  fullName  VARCHAR(255)
);


INSERT INTO user(username,fullName) VALUES('zhangsan','张三2');
INSERT INTO user(username,fullName) VALUES('lisi','李四2');
INSERT INTO user(username,fullName) VALUES('wangwu','王五2');
INSERT INTO user(username,fullName) VALUES('zhaoliu','赵六2');
INSERT INTO user(username,fullName) VALUES('lidazhuang','李大壮2');

 
SELECT * FROM user;

--- db3
DROP DATABASE IF EXISTS cloud03;
CREATE DATABASE cloud03 CHARACTER SET UTF8;
USE cloud03;
CREATE TABLE user
(
  id int PRIMARY KEY AUTO_INCREMENT,
  username VARCHAR(255),
  fullName  VARCHAR(255)
);


INSERT INTO user(username,fullName) VALUES('zhangsan','张三3');
INSERT INTO user(username,fullName) VALUES('lisi','李四3');
INSERT INTO user(username,fullName) VALUES('wangwu','王五3');
INSERT INTO user(username,fullName) VALUES('zhaoliu','赵六3');
INSERT INTO user(username,fullName) VALUES('lidazhuang','李大壮3');

 
SELECT * FROM user;


3.启动模块

3.1启动服务生产者：
spring-cloud-eureka-server-7001，spring-cloud-user-service-8001，spring-cloud-user-service-8002，spring-cloud-user-service-8003
查看eureka内部注册的服务实例有多少个，你可以看到我们启动的三个服务实例都显示出来了。
20200410223800

3.2启动服务消费者：
现在对于USERSERIVE服务有三个服务实例了，然后我们启动服务消费者模块，看多次调用下他是怎么调用的吧。
由于上面对不同服务的数据库有了小修改（为了有区分，所以我修改了一下数据，但实际业务中他们应该是相同的），所以可以根据数据来判断当前调用了哪个数据库。
多次调用http://localhost/user/list，你应该能看到数据在变化，说明默认是有负载均衡的。


?你可能有点疑惑，默认的负载均衡是什么时候配置的呢？还记得我们之前在配置消费者从eureka中获取服务列表时配置了什么吗？我们给我们的restTemplate加了一个注解@LoadBalanced，而LoadBalanced就是负载均衡的意思。

当你调用服务之后，你会看到消费者拉取服务列表的时候会拉取到一些服务的健康信息。
20200419011434

默认情况下，从eureka中拉取的服务会使用轮询调用（加入有ABC三个服务实例，会顺序的逐一的调用，比如说可能会是不断按BCA的顺序来调用；），但ribbon能帮我们做更多。

下面使用Ribbon来进行客户端的负载均衡。



4.修改消费者模块

由于Ribbon是客户端的负载均衡，所以要修改消费者模块spring-cloud-user-consumer-80：
4.1修改pom.xml，添加ribbon依赖:

        <!--增加ribbon依赖 start-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
            <!--旧版的需要去掉-netflix-->
        </dependency>
        <!--增加ribbon依赖 end-->

4.2.修改负载均衡策略：
?当导入ribbon的时候，如果你不做其他操作，默认的负载均衡还是轮询。下面我们修改一下负载均衡策略：
20200419012057

@Configuration
public class AppConfig {
    @Bean
    @LoadBalanced // eureka与这个配合，要使用LoadBalanced才会调用eureka中注册的服务
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

    @Bean
    public IRule myRule() {
//        return new RoundRobinRule();
		return  new RandomRule();
//        return new RetryRule();
    }
}

然后你重新调用几次http://localhost/user/list，你应该能看到负载均衡策略变了。

上面的例子中已经演示了修改负载均衡策略。下面来讲负责均衡相关的东西。



负载均衡算法：

Ribbon中负责负载均衡策略的就是IRule，所以我们上面的代码就新创建了一个IRule的bean。
下面讲一下这个IRule的几个常见的实现类。

  • RandomRule：随机调用服务
  • RoundRobinRule：轮询调用服务
  • WeightedResponseTimeRule：是加权策略，某个服务权重高的话调用的次数就会多。内部会维护一个权重表，每隔一段时间就依据服务的响应时间来更新权重，响应时间短的权重高。（刚启动的时候由于没有服务调用的相关信息，会先使用轮询策略。）
  • RetryRule：默认内部是轮询调用（注意这个策略可以更改），不过是带重试机制的轮询，ABC三个服务实例，如果B服务实例突然挂了，那么默认的轮询策略轮询到B的时候应该会调用失败，而如果采用了RetryRule，那么B调用不了的时候，就会尝试调用C，以保证此次调用是成功的。
@Configuration
public class AppConfig {
    @Bean
    @LoadBalanced // eureka与这个配合，要使用LoadBalanced才会调用eureka中注册的服务
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

    @Bean
    public IRule myRule(){
//        return new RandomRule(); // 随机调用服务
//        return  new RoundRobinRule();// 轮询策略
        return new RetryRule();// 带重试的轮询
    }
}

自定义负载规则：

除了以上的规则，你还可以自定义负载均衡的规则。
你可能会想，那么我应该可以参考一下RandomRule或RoundRobinRule的实现重写一下，然后像上面指定IRule这个Bean的实现对象就行了。
?? 但要注意一点，如果你是在主程序类的同级目录或下级目录下（也就是能被主程序类的ComponentScan扫描到的目录），那么这个规则会对这个消费者的所有调用的服务生效。
1.写一个负载均衡规则：只调用8003的服务。

package com.progor.study.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;

public class MyLoadBalancedRule extends AbstractLoadBalancerRule {

    // 这个choose方法就是选择哪个服务来进行调用
    public Server choose(ILoadBalancer lb, Object key) {
        // ILoadBalancer是服务注册列表
        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) {
                // 服务数为0
                return null;
            }

            // 看一下下面的代码（此段代码来自RandomRule），应该能判断出来，就是这里指定了返回的server，
            // 所以我们也在这里修改策略，假如说我们指定只调用8003的
//            int index = rand.nextInt(serverCount);
//            server = upList.get(index);
            // 修改 start
            if (upList.size()==0){
                return null;
            }
            for (int i = 0; i < upList.size() ; i++) {
                Server item = upList.get(i);
                int httpPort = item.getPort();
                // 你可以通过Server和ILoadBalancer的各种参数来自定义你的规则()
                if (httpPort == 8003){
                    server = item; // 这里由于只是示例，所以就随便写了，所以安全逻辑并没有做完全。
                }
            }
            // 修改 end

            if (server == null) {
                Thread.yield();
                continue;
            }

            if (server.isAlive()) {
                return (server);
            }

            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

    }
}

2.在主程序类的外部目录创建一个Configuration:
20200419024200

package com.progor.config;

import com.netflix.loadbalancer.IRule;
import com.progor.study.myrule.MyLoadBalancedRule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MyConfig {

    @Bean
    public IRule myRule(){
        return new MyLoadBalancedRule();// 使用我们自定义的规则
    }
}

3.修改主程序类，增加@RibbonClient
如果你的Configuration放在了主程序类外部的时候就要加上这个才能扫描到外部的Configuration：
??这个注解用来指定某个服务的负载均衡规则，如果不使用这个注解来给对应服务配置负载均衡策略，并且你在内层目录的配置类中指定了IRule的实例为我们创建的实现类实例，那么所有的服务都会采用这个策略。

package com.progor.study;

import com.progor.config.MyConfig;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.ribbon.RibbonClient;

@SpringBootApplication
@EnableEurekaClient
@RibbonClient(name="USERSERIVE",configuration= MyConfig.class)
public class UserConsumer80Application {
    public static void main(String[] args) {
        SpringApplication.run(UserConsumer80Application.class, args);
    }
}

4.调用http://localhost/user/list，你会发现现在只会有8003的数据返回了，这说明我们的负载均衡生效了。


??对于不同服务的负载均衡规则的问题，也可以参考代码中的MessageService。这里面我写了一个Message服务的两个服务实例8004和8005，并且让消费者来调用了这个服务，效果如下：

  • 当不使用@RibbonClient时：由于那个Configuration并没有被扫描到，所以不会生效，此时应该所有的服务都使用内部配置的负载均衡规则
    如果在内部配置中采用内部的定义规则：
    @Bean
    public IRule myRule(){s
//        return new RandomRule(); // 随机调用服务
//        return  new RoundRobinRule();// 轮询策略
        return new RetryRule();// 带重试的轮询
    }

当在内部配置规则的额时候，如果使用我们定义的规则：由于我们之前为USERSERVICE定义了只使用8003服务的规则，此时MESSAGESERVICE也会使用这个规则，那么这时候MESSAGESERVICE会一直请求不到。

    @Bean
    public IRule myRule() {
//		return  new RoundRobinRule();
//		return  new RandomRule();
//        return new RetryRule();
        return new MyLoadBalancedRule();
    }

  • 当使用@RibbonClient时：对于指定的服务，会使用指定的负载均衡规则。【从其他资料(不确定??)中了解到以前的@RibbonClient的name应该是可以为空的，从这个注解的name有default默认值，我觉得这个说法应该是对的。但现在不允许了，应该是为了避免专属的负载均衡规则覆盖全局规则的问题】
//  自定义负载均衡的代码
package com.progor.config;

import com.netflix.loadbalancer.IRule;
import com.progor.study.myrule.MyLoadBalancedRule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MyConfig {

    @Bean
    public IRule myRule() {
        return new MyLoadBalancedRule();// 使用我们自定义的规则
    }
}

//  主程序类代码
@SpringBootApplication
@EnableEurekaClient
@RibbonClient(name = "USERSERIVE", configuration = MyConfig.class) 
public class UserConsumer80Application {
    public static void main(String[] args) {
        SpringApplication.run(UserConsumer80Application.class, args);
    }
}


原文链接:https://www.cnblogs.com/progor/p/12893434.html
如有疑问请与原作者联系

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有

上一篇：spring-boot-run 指令是怎么运行 Spring Boot 项目的？

下一篇：创建ssm项目步骤

相关文章

IDC资讯： 主机资讯 注册资讯 托管资讯 vps资讯 网站建设

网站运营： 建站经验 策划盈利 搜索优化 网站推广 免费资源

网站联盟： 联盟新闻 联盟介绍 联盟点评 网赚技巧

行业资讯： 搜索引擎 网络游戏 电子商务 广告传媒

网络编程： Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它

服务器技术： Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护

软件技巧： 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷

网页制作： FrontPages Dreamweaver Javascript css photoshop fireworks Flash

程序设计： Java技术 C/C++ VB delphi

网络知识： 网络协议 网络安全 网络管理 组网方案 Cisco技术

操作系统： Win2000 WinXP Win2003 Mac OS Linux FreeBSD

热门词条
最新资讯
热门关注
热门标签