在Spring Cloud Eureka配置集群中，我们介绍了Eureka集群部署的方式。
在[pring Cloud Eureka消费者获取服务者信息
](在Spring Cloud Eureka配置集群中，我们介绍了Eureka集群部署的方式，)中，我们介绍了Eureka服务消费者获取服务提供者信息的方式。
这篇文章，我通过ribbon的方式，介绍服务消费者调用服务提供者的方式。
服务提供者代码无需改动，我们只基于microservice-consumer-movie增加调用服务提供者的相关代码。

基本调用方式

修改启动类

主要是提供RestTemplate相关Bean，增加@LoadBalanced注解使其具备负载均衡能力。

@SpringBootApplication
public class MicroserviceConsumerMovieApplication {

    public static void main(String[] args) {
        SpringApplication.run(MicroserviceConsumerMovieApplication.class, args);
    }

    @Bean
    @LoadBalanced //基于rest+ribbon的调用方式需要加此注解
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }

}

调用

@RestController
public class MovieController {

    @Resource
    private DiscoveryClient discoveryClient;

    @Resource
    private RestTemplate restTemplate;

    @GetMapping("/user-instance")
    public List<ServiceInstance> showInfo(){
        return discoveryClient.getInstances("microservice-provider-user");
    }

    @GetMapping("/user/{id}")
    public User findById(@PathVariable Long id){
        return restTemplate.getForObject("http://microservice-provider-user/"+id, User.class);
    }

}

其他配置

其他配置比如依赖、配置文件，请参考之前的文章。

测试

访问http://localhost:8081/user/1,正确返回用户信息

负载均衡算法

Ribbon是Netflix发布的负载均衡器，他有助于控制HTTP和TCP客户端的行为。Ribbon默认为我们提供了很多负载均衡算法，比如轮询、随机等，我们也可为Ribbon实现自定义的轮询算法。

使用默认轮询算法测试

启动两个客户端

还是使用前面的用户服务，我们启动两个服务提供者。

java -jar microservice-simple-provider-user-0.0.1-SNAPSHOT.jar --server.port=9001
java -jar microservice-simple-provider-user-0.0.1-SNAPSHOT.jar --server.port=9002

此时查看Eureka Server可以查看注册的服务，如下

编写测试代码，查看服务信息

/**
 * 博客：https://lisen.cc
 * Description:
 *
 * @Author: 香草物语
 * DateTime: 2021-07-17 22:11
 */
@RestController
public class MovieController {

    @Resource
    private DiscoveryClient discoveryClient;

    @Resource
    private RestTemplate restTemplate;

    @Resource
    private LoadBalancerClient loadBalancerClient;

    @GetMapping("/user-instance")
    public List<ServiceInstance> showInfo(){
        return discoveryClient.getInstances("microservice-provider-user");
    }

    @GetMapping("/user/{id}")
    public User findById(@PathVariable Long id){
        return restTemplate.getForObject("http://microservice-provider-user/"+id, User.class);
    }

    @GetMapping("log/microservice-provider-user")
    public ServiceInstance userLog(){
        return loadBalancerClient.choose("microservice-provider-user");
    }

}

多次访问http://localhost:8081/log/microservice-provider-user,查看输出信息
可以看到，服务会依次调用9001、9002端口，也就是通过轮询的方式，依次访问两个服务提供者。

Ribbon自定义配置

很多场景下，可以根据需要自定义Ribbon的配置，例如修改Ribbon负载均衡器规则等。Spring Cloud允许通过Java代码或属性自定义Ribbon的配置。

使用代码自定义Ribbon配置

使用Ribbon时一定要注意版本的问题，不然会各种报错。
springcloud 2020.0.1 版本之后删除了eureka中的ribbon，替代ribbon的是spring cloud自带的LoadBalancer，默认使用的是轮询的方式。
先说一下我这边使用的组件的版本信息：

Spring Boot 2.5.2
Spring Cloud 2020.0.3

添加依赖

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

[alt type="success"]无需添加ribbon依赖，eureka-client中已包含[/alt]

配置文件

配置文件与上面配置一致，不再单独说明。

server:
  port: 8081
eureka:
  instance:
    prefer-ip-address: false
  client:
    service-url:
      defaultZone: http://peer1:8761/eureka,http://peer2:8762/eureka
spring:
  application:
    name: microservice-consumer-movie

自定义轮询规则PeachLoadBalancer.java

/**
 * 博客：https://lisen.cc
 * Description:
 *
 * @Author: 香草物语
 * DateTime: 2021-07-18 11:54
 */
public class PeachLoadBalancer implements ReactorServiceInstanceLoadBalancer {
    private static final Log log = LogFactory.getLog(PeachLoadBalancer.class);

    final AtomicInteger position;//请求的次数

    final String serviceId; //服务名称 用于提示报错信息的

    private int flag = 0; //自己定义的计数器

    //两个参数的构造方法 需要服务名称和实例提供者 这个在方法中传递进来
    public PeachLoadBalancer(ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider,
                             String serviceId) {
        //如果不传人请求次数就自己初始化 反正每次都+1
        this(new Random().nextInt(1000), serviceId,serviceInstanceListSupplierProvider);
    }

    public PeachLoadBalancer(int seedPosition, String serviceId, ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider) {
        this.position = new AtomicInteger(seedPosition);
        this.serviceId = serviceId;
        this.serviceInstanceListSupplierProvider = serviceInstanceListSupplierProvider;
    }

    ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider;
    @Override
    public Mono<Response<ServiceInstance>> choose(Request request) {
        //从服务提供者中获取到当前request请求中的serviceInstances并且遍历
        ServiceInstanceListSupplier supplier = serviceInstanceListSupplierProvider
                .getIfAvailable(NoopServiceInstanceListSupplier::new);
        return supplier.get(request).next()
                .map(serviceInstances -> processInstanceResponse(supplier, serviceInstances));
    }

    private Response<ServiceInstance> processInstanceResponse(ServiceInstanceListSupplier supplier,
                                                              List<ServiceInstance> serviceInstances) {
        Response<ServiceInstance> serviceInstanceResponse = getInstanceResponse(serviceInstances);
        if (supplier instanceof SelectedInstanceCallback && serviceInstanceResponse.hasServer()) {
            ((SelectedInstanceCallback) supplier).selectedServiceInstance(serviceInstanceResponse.getServer());
        }
        return serviceInstanceResponse;
    }

    private Response<ServiceInstance> getInstanceResponse(List<ServiceInstance> instances) {
        if (instances.isEmpty()) {
            if (log.isWarnEnabled()) {
                log.warn("No servers available for service: " + serviceId);
            }
            return new EmptyResponse();
        }
        //pos是当前请求的次数 这样可以自定义负载均衡的切换  这个每次+1的操作是复制的 最好是不删
        int pos = Math.abs(this.position.incrementAndGet());

        if (pos%4==0){
            //是4的倍数就切换
            flag += 1;
        }
        if (flag >= instances.size()){
            flag = 0;
        }
        //主要的就是这句代码设置负载均衡切换
        ServiceInstance instance = instances.get(flag);
        return new DefaultResponse(instance);
    }
}

增加轮询配置

/**
 * 博客：https://lisen.cc
 * Description:
 *
 * @Author: 香草物语
 * DateTime: 2021-07-18 11:21
 */
public class CustomLoadBalancerConfiguration {

    @Bean
    ReactorLoadBalancer<ServiceInstance> randomLoadBalancer(Environment environment,
                                                            LoadBalancerClientFactory loadBalancerClientFactory) {
        String name = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);

        return new PeachLoadBalancer(loadBalancerClientFactory
                .getLazyProvider(name, ServiceInstanceListSupplier.class),
                name);
    }

}

配置轮询对应的服务

/**
 * 博客：https://lisen.cc
 * Description:使用RibbonClient为特定name的Ribbon Client自定义配置
 * 使用@RibbonClient的configuration，指定Ribbon的配置类
 *
 * @Author: 香草物语
 * DateTime: 2021-07-18 10:16
 */
@Configuration
@LoadBalancerClient(name = "microservice-provider-user",configuration = CustomLoadBalancerConfiguration.class)
public class MyRibbonConfig {

    @Bean
    @LoadBalanced //基于rest+ribbon的调用方式需要加此注解
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

}

测试

/**
 * 博客：https://lisen.cc
 * Description:
 *
 * @Author: 香草物语
 * DateTime: 2021-07-17 22:11
 */
@RestController
public class MovieController {

    @Resource
    private DiscoveryClient discoveryClient;

    @Resource
    private RestTemplate restTemplate;

    @Resource
    private LoadBalancerClient loadBalancerClient;

    @GetMapping("/user-instance")
    public List<ServiceInstance> showInfo(){
        return discoveryClient.getInstances("microservice-provider-user");
    }

    @GetMapping("/user/{id}")
    public User findById(@PathVariable Long id){
        return restTemplate.getForObject("http://microservice-provider-user/"+id, User.class);
    }

    @GetMapping("log/microservice-provider-user")
    public ServiceInstance userLog(){
        return loadBalancerClient.choose("microservice-provider-user");
    }

}

多次访问http://localhost:8081/log/microservice-provider-user，可以查看端口号，判断是否根据配置的轮询规则分别访问9001和9002端口。

Spring Cloud 服务消费者通过ribbon调用服务提供者