Fegin 第8 章：Client

分享未结  0  1071

李延 LV6 2021-06-23

悬赏：20积分

# 作用

# 初始化

我们在DefaultFeignLoadBalancerConfiguration中看到它的创建
```java

@Bean
	@ConditionalOnMissingBean
	@Conditional(OnRetryNotEnabledCondition.class)
	public Client feignClient(LoadBalancerClient loadBalancerClient, LoadBalancerProperties properties,
			LoadBalancerClientFactory loadBalancerClientFactory) {
		return new FeignBlockingLoadBalancerClient(new Client.Default(null, null), loadBalancerClient, properties,
				loadBalancerClientFactory);
	}
```

这里我们看到有两个Client子类
- Client.Default 真正发送请求的对象
- FeignBlockingLoadBalancerClient 负责负载均衡最后请求委托给Client.Default实现

我们逐一说明

# FeignBlockingLoadBalancerClient

```java

@Override
	public Response execute(Request request, Request.Options options) throws IOException {
	    //获取url
		final URI originalUri = URI.create(request.url());
		// 获取host，也就是服务名
		String serviceId = originalUri.getHost();
		Assert.state(serviceId != null, "Request URI does not contain a valid hostname: " + originalUri);
		String hint = getHint(serviceId);
		// 创建请求上下文，也就是将Request的内容进行分装
		DefaultRequest<RequestDataContext> lbRequest = new DefaultRequest<>(
				new RequestDataContext(buildRequestData(request), hint));
		通过loadBalancerClientFactory，获取负载均衡生命周期类
		Set<LoadBalancerLifecycle> supportedLifecycleProcessors = LoadBalancerLifecycleValidator
				.getSupportedLifecycleProcessors(
						loadBalancerClientFactory.getInstances(serviceId, LoadBalancerLifecycle.class),
						RequestDataContext.class, ResponseData.class, ServiceInstance.class);
		//发送开始时间
		supportedLifecycleProcessors.forEach(lifecycle -> lifecycle.onStart(lbRequest));
		// 通过loadBalancerClient获取ServiceInstance对象
		ServiceInstance instance = loadBalancerClient.choose(serviceId, lbRequest);
		org.springframework.cloud.client.loadbalancer.Response<ServiceInstance> lbResponse = new DefaultResponse(
				instance);
		if (instance == null) {
			String message = "Load balancer does not contain an instance for the service " + serviceId;
			if (LOG.isWarnEnabled()) {
				LOG.warn(message);
			}
			supportedLifecycleProcessors.forEach(lifecycle -> lifecycle
					.onComplete(new CompletionContext<ResponseData, ServiceInstance, RequestDataContext>(
							CompletionContext.Status.DISCARD, lbRequest, lbResponse)));
			return Response.builder().request(request).status(HttpStatus.SERVICE_UNAVAILABLE.value())
					.body(message, StandardCharsets.UTF_8).build();
		}
		//获取证实的请求连接
		String reconstructedUrl = loadBalancerClient.reconstructURI(instance, originalUri).toString();
		// 根据新url封装request
		Request newRequest = buildRequest(request, reconstructedUrl);
		//发送请求
		return executeWithLoadBalancerLifecycleProcessing(delegate, options, newRequest, lbRequest, lbResponse,
				supportedLifecycleProcessors);
	}

```

在这里主要有几个步骤

1. 通过loadBalancerClient获取ServiceInstance对象
2. 通过ServiceInstance获取真实的请求路径
3. 发送请求

并且在其中我们通过loadBalancerClientFactory获取其负载均衡的生命周期类，在各自的阶段发送事件。

# 总结
这里我们主要有几个类
- LoadBalancerClient 负载均衡器，负责获取请求的真实路径
- LoadBalancerClientFactory 负载均衡相关类的类工厂，用于获取我们需要的对象。

在获取到真实的请求ip后我们通过Client.Default发送请求

回帖

消灭零回复