LoadBalancer 负载均衡

前面我们讲解了如何对服务进行拆分、如何通过 Eureka 服务器进行服务注册与发现，那么现在我们来看看，它的负载均衡到底是如何实现的，实际上之前演示的负载均衡是依靠 LoadBalancer 实现的。

在2020年前的 SpringCloud 版本是采用 Ribbon 作为负载均衡实现，但是2020年的版本之后SpringCloud 把 Ribbon 移除了，进而用自己编写的 LoadBalancer 替代。

那么，负载均衡是如何进行的呢？

一、@LoadBalanced 负载均衡

我们之前注册 RestTemplate 时，就用 @LoadBalanced 注解进行了修饰：

@Configuration
public class BeanConfiguration {
    @Bean
    @LoadBalanced // 负载均衡
    public RestTemplate getRestTemplate() {
        return new RestTemplate();
    }
}
// User user = this.template.getForObject("http://userservice/user/"+uid, User.class);

剖析源码：
实际上，在添加 @LoadBalanced 注解之后，会启用LoadBalancerInterceptor拦截器对我们发起的服务调用请求进行拦截（只针对我们发起的请求）。

它实现ClientHttpRequestInterceptor接口：

@FunctionalInterface
public interface ClientHttpRequestInterceptor {
    ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException;
}

LoadBalancerInterceptor类对 intercept()方法 的实现：

public ClientHttpResponse intercept(final HttpRequest request, final byte[] body, final ClientHttpRequestExecution execution) throws IOException {
    URI originalUri = request.getURI();
    String serviceName = originalUri.getHost();
    Assert.state(serviceName != null, "Request URI does not contain a valid hostname: " + originalUri);
    return (ClientHttpResponse)this.loadBalancer.execute(serviceName, this.requestFactory.createRequest(request, body, execution));
}

我们可以打个断点看看实际是怎么在执行的，可以看到：
在这里插入图片描述
服务端会在发起请求时执行这些拦截器。它们会去找 Eureka 获取真正需要访问的主机名称。

我们来看看BlockingLoadBalancerClient类对 loadBalancer.execute()方法 的具体实现：

//从上面给进来了服务的名称和具体的请求实体
public <T> T execute(String serviceId, LoadBalancerRequest<T> request) throws IOException {
    String hint = this.getHint(serviceId);
    LoadBalancerRequestAdapter<T, DefaultRequestContext> lbRequest = new LoadBalancerRequestAdapter(request, new DefaultRequestContext(request, hint));
    Set<LoadBalancerLifecycle> supportedLifecycleProcessors = this.getSupportedLifecycleProcessors(serviceId);
    supportedLifecycleProcessors.forEach((lifecycle) -> {
        lifecycle.onStart(lbRequest);
    });
  	//可以看到在这里会调用choose方法自动获取对应的服务实例信息
    ServiceInstance serviceInstance = this.choose(serviceId, lbRequest);
    if (serviceInstance == null) {
        supportedLifecycleProcessors.forEach((lifecycle) -> {
            lifecycle.onComplete(new CompletionContext(Status.DISCARD, lbRequest, new EmptyResponse()));
        });
      	//没有发现任何此服务的实例就抛异常（之前的测试中可能已经遇到了）
        throw new IllegalStateException("No instances available for " + serviceId);
    } else {
      	//成功获取到对应服务的实例，这时就可以发起HTTP请求获取信息了
        return this.execute(serviceId, serviceInstance, lbRequest);
    }
}

所以，实际上在进行负载均衡的时候，会向 Eureka 发起请求，选择一个可用的对应服务，然后会返回此服务的主机地址等信息：
在这里插入图片描述

回到目录…

二、自定义负载均衡

LoadBalancer 默认提供了两种负载均衡策略：

RandomLoadBalancer - 随机分配策略
RoundRobinLoadBalancer - (默认)轮询分配策略

现在我们希望修改默认的负载均衡策略，可以进行指定，比如我们现在希望用户服务采用随机分配策略。

①我们需要先创建随机分配策略的配置类（不用加@Configuration）：

public class LoadBalancerConfig {
  	//将官方提供的 RandomLoadBalancer 注册为Bean
    @Bean
    public ReactorLoadBalancer<ServiceInstance> randomLoadBalancer(Environment environment, LoadBalancerClientFactory loadBalancerClientFactory){
        String name = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);
        return new RandomLoadBalancer(loadBalancerClientFactory.getLazyProvider(name, ServiceInstanceListSupplier.class), name);
    }
}

②接着我们需要为对应的服务指定负载均衡策略，直接使用注解即可：

@Configuration
// 指定只要是 userservice 服务，都会使用我们指定的策略 LoadBalancerConfig
@LoadBalancerClient(value = "userservice", configuration = LoadBalancerConfig.class)
public class BeanConfiguration {
    @Bean
    @LoadBalanced // 负载均衡
    public RestTemplate getRestTemplate() {
        return new RestTemplate();
    }
}

接着我们在BlockingLoadBalancerClient中添加断点，观察是否采用我们指定的策略进行请求：
在这里插入图片描述

发现访问 userservice 服务的策略已经更改为我们指定的策略了。

回到目录…

三、OpenFeign 实现负载均衡

官方文档：https://docs.spring.io/spring-cloud-openfeign/docs/current/reference/html/

Feign 和 RestTemplate 一样，也是 HTTP 客户端请求工具，但是它的使用方式更加便捷。
OpenFeign 默认的负载均衡策略是轮询调用。

①添加依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

②启动类添加 @EnableFeignClients

@SpringBootApplication
@EnableFeignClients
public class BorrowApplication {
    public static void main(String[] args) {
        SpringApplication.run(BorrowApplication.class, args);
    }
}

那么现在我们需要调用其他微服务提供的接口，该怎么做呢？

③创建客户端接口 UserClient

我们的客户端接口需要用 @FeignClient 注解来指定向哪个微服务发送 HTTP 请求。

@FeignClient("userservice")   //声明为 userservice 服务的 HTTP 请求客户端
public interface UserClient {
}

我们之前的远程调用：

RestTemplate template = new RestTemplate();
User user = template.getForObject("http://userservice/user/"+uid, User.class);

现在直接在客户端接口中写入控制层的方法：

@FeignClient("userservice")
public interface UserClient {
  	//路径保证和其他微服务提供的一致即可
    @RequestMapping("/user/{uid}")
    User getUserById(@PathVariable("uid") int uid);  //参数和返回值也保持一致
}

④service业务中调用客户端接口

我们直接注入使用（有 Mybatis 那味了）：

@Service
public class BorrowServiceImpl implements BorrowService {
    @Resource
    private BorrowMapper borrowMapper;
    @Resource
    private UserClient userClient;
    @Resource
    private BookClient bookClient;

    @Override
    public UserBorrowView getBorrowViewByUid(int uid) {
        // 现在拿到借阅关联信息了，怎么调用其他服务获取信息呢？
        List<Borrow> borrowList = borrowMapper.getBorrowsByUid(uid);
        // 直接调用客户端接口的方法
        User user = userClient.findUserById(uid);
        List<Book> bookList = borrowList
                .stream()
                .map(b -> bookClient.findBookById(b.getBid()))
                .collect(Collectors.toList());
        return new UserBorrowView(user, bookList);
    }
}