全解析Spring Cloud之负载均衡之LoadBalance_Java

负载均衡

问题

上面是我们之前的代码，是根据应用名称获取了服务实例列表，并从列表中选择了一个服务实例。

那如果一个服务对应多个实例呢？流量是否可以合理的分配到多个实例呢？

我们再启动两个product-service示例。

步骤

打开view->tool windows->services

选中productserviceapplication，然后右键，选择copy configuration

然后改名，并点击modify options

然后点击add vm options

然后添加-dserver.port=9091，然后apply，ok

然后再重复上述步骤，再添加一个服务实例。

现象

启动上述所有实例后，可以在eureka网站页面看到：

此时多次访问"http://127.0.0.1:8080/order/1"，然后查看idea上的日志，可以看到，我们刚刚的多次访问，都访问到了同一台机器上，即第一个注册到eureka的服务实例端口号为9092的机器。

这肯定不是我们想要的结果，我们启动多个服务实例，是希望可以分担其它机器的负荷，那么如何实现呢?

我们可以修改一下之前的order-service中的orderservice代码，把只请求服务列表第一台机器修改为轮询请求服务列表中的机器。

修改后的order-service中的orderservice代码如下：

package order.service;
import jakarta.annotation.postconstruct;
import lombok.extern.slf4j.slf4j;
import order.mapper.ordermapper;
import order.model.orderinfo;
import order.model.productinfo;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.cloud.client.serviceinstance;
import org.springframework.cloud.client.discovery.discoveryclient;
import org.springframework.stereotype.service;
import org.springframework.web.client.resttemplate;
import java.util.list;
import java.util.concurrent.atomic.atomicinteger;
@slf4j
@service
public class orderservice {
    @autowired
    private ordermapper ordermapper;
    @autowired
    private resttemplate resttemplate;
    @autowired
    private discoveryclient discoveryclient;
    //计数器
    private atomicinteger count = new atomicinteger(1);
    private list<serviceinstance> instances;
    @postconstruct
    public void init(){
        //从eureka中获取服务列表
        instances = discoveryclient.getinstances("product-service");
    }
    public orderinfo selectorderbyid(integer orderid){
        orderinfo orderinfo = ordermapper.selectorderbyid(orderid);
        //计算轮流的实例idnex
        int index= count.getandincrement() % instances.size();
        //获取实例
        string uri = instances.get(index).geturi().tostring();
        //拼接url
        string url = uri+"/product/"+orderinfo.getproductid();
        log.info("远程调用url:{}", url);
        productinfo productinfo = resttemplate.getforobject(url, productinfo.class);
        orderinfo.setproductinfo(productinfo);
        return orderinfo;
    }
}

重启order-service，再次多次访问"127.0.0.1:8080/order/1"，可以看到每个服务实例都有被请求到：

通过⽇志可以看到, 请求被均衡的分配在了不同的实例上, 这就是负载均衡.

什么是负载均衡？

负载均衡(load balance，简称 lb) , 是⾼并发, ⾼可⽤系统必不可少的关键组件.
当服务流量增⼤时, 通常会采⽤增加机器的⽅式进⾏扩容, 负载均衡就是⽤来在多个机器或者其他资源中, 按照⼀定的规则合理分配负载.

负载均衡的一些实现

上⾯的例⼦中, 我们只是简单的对实例进⾏了轮询, 但真实的业务场景会更加复杂. ⽐如根据机器的配置进⾏负载分配, 配置⾼的分配的流量⾼, 配置低的分配流量低等.

服务多机部署时, 开发⼈员都需要考虑负载均衡的实现, 所以也出现了⼀些负载均衡器, 来帮助我们实现负载均衡.

负载均衡分为服务端负载均衡和客⼾端负载均衡.

服务端负载均衡

在服务端进⾏负载均衡的算法分配.
⽐较有名的服务端负载均衡器是nginx. 请求先到达nginx负载均衡器, 然后通过负载均衡算法, 在多个服务器之间选择⼀个进⾏访问.

客户端负载均衡

在客⼾端进⾏负载均衡的算法分配.

把负载均衡的功能以库的⽅式集成到客⼾端, ⽽不再是由⼀台指定的负载均衡设备集中提供.
⽐如spring cloud的ribbon, 请求发送到客⼾端, 客⼾端从注册中⼼(⽐如eureka)获取服务列表, 在发送请求前通过负载均衡算法选择⼀个服务器,然后进⾏访问.
ribbon是spring cloud早期的默认实现, 由于不维护了, 所以最新版本的spring cloud负载均衡集成的是spring cloud loadbalancer(spring cloud官⽅维护)。

客⼾端负载均衡和服务端负载均衡最⼤的区别在于服务清单所存储的位置。

spring cloud loadbalance

springcloud 从 2020.0.1 版本开始, 移除了ribbon 组件，使⽤spring cloud loadbalancer 组件来代替 ribbon 实现客⼾端负载均衡。

使用spring cloud loadbalance实现负载均衡

1. 给 resttemplate 这个bean添加 @loadbalanced 注解就可以

package order.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
public class beanconfig {
    @bean
    @loadbalanced
    public resttemplate resttemplate(){
        return new resttemplate();
    }
}

2.修改后的order-service中的orderservice代码如下：

修改ip为服务端名称。

package order.service;
import jakarta.annotation.postconstruct;
import lombok.extern.slf4j.slf4j;
import order.mapper.ordermapper;
import order.model.orderinfo;
import order.model.productinfo;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.stereotype.service;
import org.springframework.web.client.resttemplate;
@slf4j
@service
public class orderservice {
    @autowired
    private ordermapper ordermapper;
    @autowired
    private resttemplate resttemplate;
    public orderinfo selectorderbyid(integer orderid){
        orderinfo orderinfo = ordermapper.selectorderbyid(orderid);
        string url = "http://product-service/product/"+orderinfo.getproductid();
        log.info("远程调用url:{}", url);
        productinfo productinfo = resttemplate.getforobject(url, productinfo.class);
        orderinfo.setproductinfo(productinfo);
        return orderinfo;
    }
}

此时再次多次访问"127.0.0.1:8080/order/1"，可以看到每个服务实例都有被请求到，且比例差不多:

负载均衡策略

负载均衡策略是⼀种思想, ⽆论是哪种负载均衡器, 它们的负载均衡策略都是相似的. spring cloud
loadbalancer 仅⽀持两种负载均衡策略: 轮询策略和随机策略。

1. 轮询(round robin): 轮询策略是指服务器轮流处理⽤⼾的请求. 这是⼀种实现最简单, 也最常⽤的策略. ⽣活中也有类似的场景, ⽐如学校轮流值⽇, 或者轮流打扫卫⽣.
2. 随机选择（random): 随机选择策略是指随机选择⼀个后端服务器来处理新的请求.

官方介绍

翻译：

spring cloud提供了自己的客户端负载均衡器抽象和实现。对于负载平衡机制，添加了reactiveloadbalancer接口，并为其提供了基于轮转和随机的实现。为了让实例从反应式serviceinstancelistsupplier中进行选择，使用了该接口。目前，我们支持serviceinstancelistsupplier的基于服务发现的实现，该实现使用类路径中可用的发现客户端从服务发现中检索可用实例。通过将spring.cloud.loadbalancer.enabled的值设置为false，可以禁用spring cloud loadbalancer。

1. 定义随机算法对象, 通过 @bean 将其加载到 spring 容器中
此处使⽤spring cloud loadbalancer提供的 randomloadbalancer

package order.config;
import org.springframework.cloud.client.serviceinstance;
import org.springframework.cloud.loadbalancer.core.randomloadbalancer;
import org.springframework.cloud.loadbalancer.core.reactorloadbalancer;
import org.springframework.cloud.loadbalancer.core.serviceinstancelistsupplier;
import org.springframework.cloud.loadbalancer.support.loadbalancerclientfactory;
import org.springframework.context.annotation.bean;
import org.springframework.core.env.environment;
public class customloadbalancerconfiguration {
    @bean
    reactorloadbalancer<serviceinstance> randomloadbalancer(environment environment,
                                                            loadbalancerclientfactory loadbalancerclientfactory) {
        string name = environment.getproperty(loadbalancerclientfactory.property_name);
        return new randomloadbalancer(loadbalancerclientfactory
                .getlazyprovider(name, serviceinstancelistsupplier.class),
                name);
    }
}

注意: 该类需要满⾜:
1. 不⽤ @configuration 注释
2. 在组件扫描范围内

2. 使⽤ @loadbalancerclient 或者 @loadbalancerclients 注解

在 resttemplate 配置类上⽅, 使⽤ @loadbalancerclient 或 @loadbalancerclients 注解, 可以对不同的服务提供⽅配置不同的客⼾端负载均衡算法策略.
由于我们只有⼀个客户端服务提供者, 所以使⽤@loadbalancerclient。

package order.config;
import org.springframework.cloud.client.loadbalancer.loadbalanced;
import org.springframework.cloud.loadbalancer.annotation.loadbalancerclient;
import org.springframework.context.annotation.bean;
import org.springframework.context.annotation.configuration;
import org.springframework.web.client.resttemplate;
@loadbalancerclient(name = "product-service", configuration = customloadbalancerconfiguration.class)
@configuration
public class beanconfig {
    @bean
    @loadbalanced
    public resttemplate resttemplate(){
        return new resttemplate();
    }
}

@loadbalancerclient 注解说明
1. name: 该负载均衡策略对哪个服务⽣效(服务提供⽅)
2. configuration : 该负载均衡策略⽤哪个负载均衡策略实现.

此时再次多次访问"127.0.0.1:8080/order/1"，可以看到每个服务实例都有被请求到，且比例随机：

loadbalancer原理

loadbalancer 的实现, 主要是 loadbalancerinterceptor , 这个类会对 resttemplate 的请
求进⾏拦截, 然后从eureka根据服务id获取服务列表，随后利⽤负载均衡算法得到真实的服务地址信息，替换服务id。

我们来看看源码实现:

可以看到这⾥的intercept⽅法, 拦截了⽤⼾的httprequest请求，然后做了⼏件事：

1. request.geturi() 从请求中获取uri, 也就是 http://product-service
2. service/product/1001 originaluri.gethost() 从uri中获取路径的主机名, 也就是服务id, product-service
3. loadbalancer.execute 根据服务id, 进⾏负载均衡, 并处理请求

根据serviceid,和负载均衡策略, 选择处理的服务:

服务部署

准备环境和数据

安装好jdk17和mysql，并在mysql中建表且存放好数据信息。

修改配置文件中的数据库密码。

服务构建打包

采⽤maven打包, 需要对3个服务分别打包:
eureka-server, order-service, product-service

启动服务

上传jar包到云服务器

第一次上传需要安装 lrzsz

centos:

yum install lrzsz

ubantu:

apt install lrzsz

直接拖动文件到xshell窗口，上传成功。

启动服务

#后台启动eureka-server, 并设置输出⽇志到logs/eureka.log
nohup java -jar eureka-server.jar >logs/eureka.log &

#后台启动order-service, 并设置输出⽇志到logs/order.log
nohup java -jar order-service.jar >logs/order.log &

#后台启动product-service, 并设置输出⽇志到logs/order.log
nohup java -jar product-service.jar >logs/product-9090.log &

再多启动两台product-service实例

#启动实例, 指定端⼝号为9091
nohup java -jar product-service.jar --server.port=9091 >logs/product-9091.log &

#启动实例, 指定端⼝号为9092
nohup java -jar product-service.jar --server.port=9092 >logs/product-9092.log &