SpringCloud 第二期 SpringCloud负载均衡-Ribbon

最新推荐文章于 2022-11-12 22:36:05 发布

白话 java

最新推荐文章于 2022-11-12 22:36:05 发布

阅读量145

点赞数

文章标签： spring cloud 负载均衡 ribbon

本文链接：https://blog.csdn.net/SDBHC12345/article/details/121524255

版权

负载均衡是将用户的请求按照一定规则分配到服务器上，从而实现服务的高可用。

常见的负载均衡软件有Nginx ，lvs ，F5等

Ribbon是本地负载均衡（调用方） vs Nginx是服务器端（提供方）负载均衡

Ribbon负载均衡会从注册中心获取服务注册信息，将服务注册列表缓存到jvm，从而在本地实现远程调用

负载均衡的主动发起者是本地服务，属于进程内LB，属于消费方进程，消耗资源是消费方资源，而Nginx负载均衡负载均衡的主动发起者是服务器，消耗资源是服务端资源。

Ribbon本质上是RestTemlate +负载均衡。

首先介绍RestTemlate

RestTemlate就是一个可以实现远程RPC调用的组件。

在消费端81中配置RestTemlate

package liuxu.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;

/**
 * @author liuxu
 * @date 2021/10/28 21:45
 */
@Configuration
public class RestTemlateConfig {
    @Bean
    @LoadBalanced//可以通过服务名进行负载均衡调用  //注释掉本注解 可以通过url调用唯一指定服务
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }
}

在服务提供方配置路径相同的两个端口

8001

package liuxu.controller;

import com.liuxu.result.CommResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

/**
 * @author liuxu
 * @date 2021/10/27 22:00
 */
@RestController
@RequestMapping("/provider")
public class MyController {
    private static final String SERVER_NAME = "http://cloud-provider";
    private static final String SERVER_URL = "http://localhsot:8001";
    @Autowired
    RestTemplate restTemplate;

    @RequestMapping("/ok")
    public CommResult ok(){
        CommResult commResult = new CommResult();
        commResult.setCode("200");
        commResult.setMsg("80正常返回");
        return commResult;
    }
    @RequestMapping("/temlate")
    public CommResult temlate(){
        CommResult commResult = restTemplate.getForObject(SERVER_NAME + "/provider/port", CommResult.class);
        return commResult;
    }
}

8002

package com.liuxu.controller;

import com.liuxu.result.CommResult;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author liuxu
 * @date 2021/10/27 22:00
 */
@RestController
@RequestMapping("/provider")
public class MyController {
    @Value("${server.port}")
    private String port;
    @RequestMapping("/ok")
    public CommResult ok(){
        CommResult commResult = new CommResult();
        commResult.setCode("200");
        commResult.setMsg("8001正常返回");
        return commResult;
    }
    @RequestMapping("/port")
    public CommResult getPort(){
        CommResult commResult = new CommResult();
        commResult.setCode("200");
        commResult.setMsg("8002正常返回port是："+port);
        return commResult;
    }
}

81消费接口

package liuxu.controller;

import com.liuxu.result.CommResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

/**
 * @author liuxu
 * @date 2021/10/27 22:00
 */
@RestController
@RequestMapping("/consumer")
public class MyController {
    private static final String SERVER_NAME = "http://cloud-provider";
    private static final String SERVER_URL = "http://localhost:8001";
    @Autowired
    RestTemplate restTemplate;

    @RequestMapping("/ok")
    public CommResult ok(){
        CommResult commResult = new CommResult();
        commResult.setCode("200");
        commResult.setMsg("81正常返回");
        return commResult;
    }
    @RequestMapping("/temlate")
    public CommResult temlate(){
        CommResult commResult = restTemplate.getForObject(SERVER_NAME + "/provider/port", CommResult.class);
        return commResult;
    }

    /**
     * 可以通过  etStatusCode().is2xxSuccessful(); 判断是否远程调用成功
     * @return
     */
    @RequestMapping("/temlate/ifok")
    public CommResult temlateIfOk(){
        ResponseEntity<CommResult> forEntity = restTemplate.getForEntity(SERVER_NAME + "/provider/port", CommResult.class);
        boolean xxSuccessful = forEntity.getStatusCode().is2xxSuccessful();
        if(xxSuccessful){
            return forEntity.getBody();
        }
        CommResult commResult = new CommResult();
        commResult.setMsg("远程调用失败");
        commResult.setCode("500");
        return commResult;
    }
    @RequestMapping("/temlate/url")
    public CommResult temlateUrl(){
        CommResult commResult = restTemplate.getForObject(SERVER_URL + "/provider/port", CommResult.class);
        return commResult;
    }
}

访问http://localhost:81/consumer/ok 消费方自测通过

访问http://localhost:81/consumer/temlate 验证RestTemplate实现了对8001 8002轮询调用

注释掉81配置文件中负载均衡注解 @LoadBalanced重启消费端81

访问http://localhost:81/consumer/temlate/url 只能访问指定8001服务

访问http://localhost:81/consumer/temlate/ifok可以只访问远程调用成功的结果

此时如果只有8002 启动，则只会返回8002成功调用的结果

可以看到服务高可用的雏形一支服务挂掉后，只会返回可用服务的结果

如果 8001 8002 全部不可用，则返回调用失败

上面过程用到@LoadBalanced但是没有引入相关依赖的过程，其实EurekaClient已经默认引入相关依赖

手动改造负载均衡算法 7中

负载均衡算法有

随机 RandomRule

轮询 RoundRobinRule

重试 RetryRule

优先访问响应最快的实例 WeightedResponseTimeRule

过滤故障的实例 BestAvailableRule

过滤故障，然后选择并发小的服实例 AvailabilityFilteringRule

默认规则复合判断服务中实例的性能和可用性 ZoneAvoidanceRule

可以根据需要替换

只需要在消费端81配置文件中添加如下代码

  @Bean
    public IRule getRule(){
        return new RandomRule();
    }

下面手写负载均衡逻辑

负载均衡接口

package liuxu.lb;

import org.springframework.cloud.client.ServiceInstance;
import org.springframework.stereotype.Component;

import java.util.List;

/**
 * @author liuxu
 * @date 2021/10/28 23:45
 */
@Component
public interface LoadBalancer {
    ServiceInstance instance(List<ServiceInstance> serviceInstances);
}

实现类

package liuxu.lb;

import org.springframework.cloud.client.ServiceInstance;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author liuxu
 * @date 2021/10/28 23:50
 */
@Component
public class MyLb implements LoadBalancer {
    private AtomicInteger atomicInteger = new AtomicInteger(0); //保证原子性操作
    public final int getAndinCrement(){
        int current;
        int next;

        do{
            current =this.atomicInteger.get();
            next=current>=2147483647?0:current+1;
        }while (!this.atomicInteger.compareAndSet(current,next));

        System.out.println("第"+current+"次访问，下一次是"+next);
        return next;
    }

    @Override
    public ServiceInstance instance(List<ServiceInstance> serviceInstances) {
        int index = getAndinCrement()%serviceInstances.size();
        return serviceInstances.get(index);
    }
}

消费端81接口Controller新增myLb接口

package liuxu.controller;

import com.liuxu.result.CommResult;
import liuxu.lb.LoadBalancer;
import liuxu.lb.MyLb;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.net.URI;
import java.util.List;

/**
 * @author liuxu
 * @date 2021/10/27 22:00
 */
@RestController
@RequestMapping("/consumer")
public class MyController {
    private static final String SERVER_NAME = "http://cloud-provider";
    private static final String SERVER_URL = "http://localhost:8001";
    @Autowired
    LoadBalancer loadBalancer;
    @Autowired
    DiscoveryClient discoveryClient;
    @Autowired
    RestTemplate restTemplate;

    @RequestMapping("/ok")
    public CommResult ok(){
        CommResult commResult = new CommResult();
        commResult.setCode("200");
        commResult.setMsg("81正常返回");
        return commResult;
    }
    @RequestMapping("/temlate")
    public CommResult temlate(){
        CommResult commResult = restTemplate.getForObject(SERVER_NAME + "/provider/port", CommResult.class);
        return commResult;
    }

    /**
     * 可以通过  etStatusCode().is2xxSuccessful(); 判断是否远程调用成功
     * @return
     */
    @RequestMapping("/temlate/ifok")
    public CommResult temlateIfOk(){
        ResponseEntity<CommResult> forEntity = restTemplate.getForEntity(SERVER_NAME + "/provider/port", CommResult.class);
        boolean xxSuccessful = forEntity.getStatusCode().is2xxSuccessful();
        System.out.println("xxSuccessful:"+xxSuccessful);
        if(xxSuccessful){
            return forEntity.getBody();
        }else {
            System.out.println("远程调用失败xxSuccessful:"+xxSuccessful);
            CommResult commResult = new CommResult();
            commResult.setMsg("远程调用失败");
            commResult.setCode("500");
            return commResult;
        }
    }
    @RequestMapping("/temlate/url")
    public CommResult temlateUrl(){
        ResponseEntity<CommResult> forEntity = restTemplate.getForEntity(SERVER_URL + "/provider/port", CommResult.class);
        boolean xxSuccessful = forEntity.getStatusCode().is2xxSuccessful();
        System.out.println("xxSuccessful:"+xxSuccessful);
        if(xxSuccessful){
            return forEntity.getBody();
        }else {
            System.out.println("远程调用失败xxSuccessful:"+xxSuccessful);
            CommResult commResult = new CommResult();
            commResult.setMsg("远程调用失败");
            commResult.setCode("500");
            return commResult;
        }

    }

    @RequestMapping("/myLb")
    public CommResult myLb() {
        /**
         * 关键代码 通过 服务名获取服务中的实例
         */
        List<ServiceInstance> instances = discoveryClient.getInstances("cloud-provider");
        System.out.println("得到实例是："+instances);
        instances.forEach((instance)->{
            System.out.println("host:"+instance.getHost());
            System.out.println("InstanceId:"+instance.getInstanceId());
            System.out.println("port"+instance.getPort());
            System.out.println("uri"+instance.getUri());
            System.out.println("serviceId"+instance.getServiceId());
        });
        ServiceInstance instance = loadBalancer.instance(instances);
        URI uri = instance.getUri();
        return restTemplate.getForObject(uri+"/provider/port",CommResult.class);
    }
}

注释掉@LoadBalanced通过访问

http://localhost:81/consumer/myLb可以看到自己手写轮序法则已经生效

日志如下，可以获取到相应服务名下已注册服务的相关信息

得到实例个数是：[org.springframework.cloud.netflix.eureka.EurekaDiscoveryClient$EurekaServiceInstance@5982becd, org.springframework.cloud.netflix.eureka.EurekaDiscoveryClient$EurekaServiceInstance@57454b8d]
host:DESKTOP-1624PKF
InstanceId:DESKTOP-1624PKF:cloud-provider:8002
port8002
urihttp://DESKTOP-1624PKF:8002
serviceIdCLOUD-PROVIDER
host:DESKTOP-1624PKF
InstanceId:DESKTOP-1624PKF:cloud-provider:8001
port8001
urihttp://DESKTOP-1624PKF:8001
serviceIdCLOUD-PROVIDER

至此Ribbon介绍完毕

下期介绍更加成熟的客户端负载均衡方式 OpenFeign。

白话 java

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SpringCloud 第二期 SpringCloud负载均衡-Ribbon

负载均衡是将用户的请求按照一定规则分配到服务器上，从而实现服务的高可用。常见的负载均衡软件有Nginx ，lvs ，F5等Ribbon是本地负载均衡（调用方） vs Nginx是服务器端（提供方）负载均衡Ribbon负载均衡会从注册中心获取服务注册信息，将服务注册列表缓存到jvm，从而在本地实现远程调用负载均衡的主动发起者是本地服务，属于进程内LB，属于消费方进程，消耗资源是消费方资源，而Nginx负载均衡负载均衡的主动发起者是服务器，消耗资源是服务端资源。Ribbon本质上是Re
复制链接

扫一扫