loadBalancer 第3 章：ReactorServiceInstanceLoadBalancer

分享未结  0  2642

李延 LV6 2021-06-23

悬赏：20积分

# 作用
实现负载均衡。

# 调用
在LoadBalancerClient类中我们看到就是通过loadBalancerClientFactory来获取到的当前对象

loadBalancerClientFactory具体代码如下：
```java

@Override
	public ReactiveLoadBalancer<ServiceInstance> getInstance(String serviceId) {
		return getInstance(serviceId, ReactorServiceInstanceLoadBalancer.class);
	}
```
就是获取ReactorServiceInstanceLoadBalancer对象的过程。

最后通过choose方法实现负载均衡。

# 加载
在LoadBalancerClientConfiguration类中我们看到

```java

@Bean
	@ConditionalOnMissingBean
	public ReactorLoadBalancer<ServiceInstance> reactorServiceInstanceLoadBalancer(Environment environment,
			LoadBalancerClientFactory loadBalancerClientFactory) {
		String name = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);
		return new RoundRobinLoadBalancer(
				loadBalancerClientFactory.getLazyProvider(name, ServiceInstanceListSupplier.class), name);
	}
```

但LoadBalancerClientConfiguration类不是在我们主上下文中加载的，而是通过LoadBalancerClientFactory加载，所以对于不同的serviceId都有一个它自己的对象。

# 构造函数

```java

public RoundRobinLoadBalancer(ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider,
			String serviceId) {
		this(serviceInstanceListSupplierProvider, serviceId, new Random().nextInt(1000));
	}
	public RoundRobinLoadBalancer(ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider,
			String serviceId, int seedPosition) {
		this.serviceId = serviceId;
		this.serviceInstanceListSupplierProvider = serviceInstanceListSupplierProvider;
		this.position = new AtomicInteger(seedPosition);
	}
	
```
这里我们看到需要ServiceInstanceListSupplier对象，它也是通过loadBalancerClientFactory加载，的这块初始化我们在其对于的类中说明

# 主要方法 choose

```java

public Mono<Response<ServiceInstance>> choose(Request request) {
		ServiceInstanceListSupplier supplier = serviceInstanceListSupplierProvider
				.getIfAvailable(NoopServiceInstanceListSupplier::new);
		return supplier.get(request).next()
				.map(serviceInstances -> processInstanceResponse(supplier, serviceInstances));
	}
```

这里使用了reator代码。不是特别熟悉，但根据debug猜测：

通过ServiceInstanceListSupplier可以获取到所有符合要求的实例，比如：一个有两个实例那么通过ServiceInstanceListSupplier就可以获取到2个serviceInstance对象。之后通过processInstanceResponse方法获取到我们需要的那个实例，这样就实现了负载均衡

所有我们主要看processInstanceResponse代码

```java

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();
		}
		// TODO: enforce order?
		int pos = Math.abs(this.position.incrementAndGet());

ServiceInstance instance = instances.get(pos % instances.size());

return new DefaultResponse(instance);
	}
```

这里比较简单，可以看到就是在多个实例之间进行一个轮询的过程。

回帖

消灭零回复