Spring-Cloud-Loadblancer详细分析_3

news2024/11/26 20:29:22

前两篇文章介绍了加载过程，本文从Feign的入口开始分析执行过程，还是从FeignBlockingLoadBalancerClient.execute来入手

public class FeignBlockingLoadBalancerClient implements Client {

	private static final Log LOG = LogFactory.getLog(FeignBlockingLoadBalancerClient.class);

	private final Client delegate;

	private final LoadBalancerClient loadBalancerClient;

	private final LoadBalancerClientFactory loadBalancerClientFactory;


	@Override
	public Response execute(Request request, Request.Options options) throws IOException {
		//请求路径
		final URI originalUri = URI.create(request.url());
		//获取到要调用的服务id
		String serviceId = originalUri.getHost();
		DefaultRequest<RequestDataContext> lbRequest = new DefaultRequest<>(
				new RequestDataContext(buildRequestData(request), hint));
		//在这步创建了每个服务的子容器		
		Set<LoadBalancerLifecycle> supportedLifecycleProcessors = LoadBalancerLifecycleValidator
				.getSupportedLifecycleProcessors(
						//在这步创建了每个服务的子容器
						loadBalancerClientFactory.getInstances(serviceId, LoadBalancerLifecycle.class),
						RequestDataContext.class, ResponseData.class, ServiceInstance.class);
		supportedLifecycleProcessors.forEach(lifecycle -> lifecycle.onStart(lbRequest));		
		//执行loadBalancer的负载均衡策略，返回将过滤后的服务，非常重要
		ServiceInstance instance = loadBalancerClient.choose(serviceId, lbRequest);
		org.springframework.cloud.client.loadbalancer.Response<ServiceInstance> lbResponse = new DefaultResponse(
				instance);
		//省略...

		//将ServiceInstance进行解析后，转换为真正的http方式进行远程调用服务
		String reconstructedUrl = loadBalancerClient.reconstructURI(instance, originalUri).toString();
		Request newRequest = buildRequest(request, reconstructedUrl);
		LoadBalancerProperties loadBalancerProperties = loadBalancerClientFactory.getProperties(serviceId);
		return executeWithLoadBalancerLifecycleProcessing(delegate, options, newRequest, lbRequest, lbResponse,
				supportedLifecycleProcessors, loadBalancerProperties.isUseRawStatusCodeInResponseData());
	}

	protected Request buildRequest(Request request, String reconstructedUrl) {
		return Request.create(request.httpMethod(), reconstructedUrl, request.headers(), request.body(),
				request.charset(), request.requestTemplate());
	}

	private String getHint(String serviceId) {
		LoadBalancerProperties properties = loadBalancerClientFactory.getProperties(serviceId);
		String defaultHint = properties.getHint().getOrDefault("default", "default");
		String hintPropertyValue = properties.getHint().get(serviceId);
		return hintPropertyValue != null ? hintPropertyValue : defaultHint;
	}

}

loadBalancerClientFactory.getInstances(serviceId, LoadBalancerLifecycle.class)

在这步是创建了每个服务的负载均衡子容器，loadBalancerClientFactory的生成过程在上篇文章已经分析了，这里getInstances实际调用的是父类NamedContextFactory

NamedContextFactory.getInstances

public <T> Map<String, T> getInstances(String name, Class<T> type) {
	AnnotationConfigApplicationContext context = getContext(name);

	return BeanFactoryUtils.beansOfTypeIncludingAncestors(context, type);
}

NamedContextFactory.getContext

protected AnnotationConfigApplicationContext getContext(String name) {
	if (!this.contexts.containsKey(name)) {
		synchronized (this.contexts) {
			if (!this.contexts.containsKey(name)) {
				//创建子容器，name为服务名 value为容器
				this.contexts.put(name, createContext(name));
			}
		}
	}
	return this.contexts.get(name);
}

NamedContextFactory.createContext

protected AnnotationConfigApplicationContext createContext(String name) {
	AnnotationConfigApplicationContext context;
	//创建容器
	if (this.parent != null) {
		DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
		if (parent instanceof ConfigurableApplicationContext) {
			beanFactory.setBeanClassLoader(
					((ConfigurableApplicationContext) parent).getBeanFactory().getBeanClassLoader());
		}
		else {
			beanFactory.setBeanClassLoader(parent.getClassLoader());
		}
		context = new AnnotationConfigApplicationContext(beanFactory);
		context.setClassLoader(this.parent.getClassLoader());
	}
	else {
		context = new AnnotationConfigApplicationContext();
	}
	//configurations就是LoadBalancerClientSpecification类型的LoadBalancerAutoConfiguration和BlockingLoadBalancerClientAutoConfiguration
	//这里是将@LoadBalancerClient对应的负载均衡配置注册到对应的容器中
	//由以上可知通过此步我们可以使用@LoadBalancerClient自定义负载均衡策略
	//如果不自定义的话，这里为false
	if (this.configurations.containsKey(name)) {
		for (Class<?> configuration : this.configurations.get(name).getConfiguration()) {
			context.register(configuration);
		}
	}
	//也就是将configurations中LoadBalancerClientSpecification类型的LoadBalancerAutoConfiguration和BlockingLoadBalancerClientAutoConfiguration注册到容器中
	//这样每个容器就拥有了
	for (Map.Entry<String, C> entry : this.configurations.entrySet()) {
		if (entry.getKey().startsWith("default.")) {
			for (Class<?> configuration : entry.getValue().getConfiguration()) {
				context.register(configuration);
			}
		}
	}
	//defaultConfigType就是LoadBalancerClientConfiguration，在子类LoadBalancerClientFactory的构造方法传入
	//在刚才分析LoadBalancerClientFactory的时候介绍过
	context.register(PropertyPlaceholderAutoConfiguration.class, this.defaultConfigType);
	context.getEnvironment().getPropertySources().addFirst(new MapPropertySource(this.propertySourceName,
			Collections.<String, Object>singletonMap(this.propertyName, name)));
	//将父容器添加进去
	if (this.parent != null) {
		// Uses Environment from parent as well as beans
		context.setParent(this.parent);
	}
	context.setDisplayName(generateDisplayName(name));
	context.refresh();
	return context;
}

可以看到当每个服务创建子容器后，LoadBalancerAutoConfiguration、BlockingLoadBalancerClientAutoConfiguration、LoadBalancerClientConfiguration到注册到了每个子容器中

服务的子容器创建完成后，下面就开始执行负载均衡的流程了

BlockingLoadBalancerClient.choose

public <T> ServiceInstance choose(String serviceId, Request<T> request) {
	//获取负载均衡器
	ReactiveLoadBalancer<ServiceInstance> loadBalancer = loadBalancerClientFactory.getInstance(serviceId);
	if (loadBalancer == null) {
		return null;
	}
	Response<ServiceInstance> loadBalancerResponse = Mono.from(loadBalancer.choose(request)).block();
	if (loadBalancerResponse == null) {
		return null;
	}
	return loadBalancerResponse.getServer();
}

loadBalancerClientFactory.getInstance(serviceId)

public ReactiveLoadBalancer<ServiceInstance> getInstance(String serviceId) {
	return getInstance(serviceId, ReactorServiceInstanceLoadBalancer.class);
}

这时的getInstance调用的是父类NamedContextFactory.getInstance

NamedContextFactory.getInstance

public <T> T getInstance(String name, Class<T> type) {
	AnnotationConfigApplicationContext context = getContext(name);
	try {
		return context.getBean(type);
	}
	catch (NoSuchBeanDefinitionException e) {
		// ignore
	}
	return null;
}

protected AnnotationConfigApplicationContext getContext(String name) {
	if (!this.contexts.containsKey(name)) {
		synchronized (this.contexts) {
			if (!this.contexts.containsKey(name)) {
				this.contexts.put(name, createContext(name));
			}
		}
	}
	return this.contexts.get(name);
}

刚才介绍了，在BlockingLoadBalancerClient.choose执行之前，子容器已经创建完毕，这里就执行返回

容器返回后，获取ReactorServiceInstanceLoadBalancer类型的对象，此类型的对象就是在LoadBalancerClientConfiguration创建的，我们再看一眼

@Configuration(proxyBeanMethods = false)
@ConditionalOnDiscoveryEnabled
public class LoadBalancerClientConfiguration {

	private static final int REACTIVE_SERVICE_INSTANCE_SUPPLIER_ORDER = 193827465;

	@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);
	}

	//省略
}

RoundRobinLoadBalancer结构图
在这里插入图片描述
所以loadBalancerClientFactory.getInstance(serviceId)返回的就是RoundRobinLoadBalancer，然后就会调用此策略进行执行

RoundRobinLoadBalancer.choose

public Mono<Response<ServiceInstance>> choose(Request request) {
	ServiceInstanceListSupplier supplier = serviceInstanceListSupplierProvider
			.getIfAvailable(NoopServiceInstanceListSupplier::new);
	return supplier.get(request).next()
			.map(serviceInstances -> processInstanceResponse(supplier, serviceInstances));
}
  • serviceInstanceListSupplierProvider.getIfAvailable(NoopServiceInstanceListSupplier::new)就是获取注册中心的服务列表了
  • processInstanceResponse执行具体的负载均衡策略

serviceInstanceListSupplierProvider

public T getIfAvailable(Supplier<T> defaultSupplier) throws BeansException {
	return delegate().getIfAvailable(defaultSupplier);
}

default T getIfAvailable(Supplier<T> defaultSupplier) throws BeansException {
	T dependency = getIfAvailable();
	//dependency 的类型是CachingServiceInstanceListSupplier
	return (dependency != null ? dependency : defaultSupplier.get());
}

RoundRobinLoadBalancer.processInstanceResponse

private Response<ServiceInstance> processInstanceResponse(ServiceInstanceListSupplier supplier,
		List<ServiceInstance> serviceInstances) {
	//serviceInstances就是获取的服务列表了	
	//getInstanceResponse(serviceInstances)就是真正的负债均衡策略了
	Response<ServiceInstance> serviceInstanceResponse = getInstanceResponse(serviceInstances);
	if (supplier instanceof SelectedInstanceCallback && serviceInstanceResponse.hasServer()) {
		//
		((SelectedInstanceCallback) supplier).selectedServiceInstance(serviceInstanceResponse.getServer());
	}
	return serviceInstanceResponse;
}

RoundRobinLoadBalancer.getInstanceResponse

private Response<ServiceInstance> getInstanceResponse(List<ServiceInstance> instances) {
	if (instances.isEmpty()) {
		if (log.isWarnEnabled()) {
			log.warn("No servers available for service: " + serviceId);
		}
		return new EmptyResponse();
	}

	// Do not move position when there is only 1 instance, especially some suppliers
	// have already filtered instances
	if (instances.size() == 1) {
		return new DefaultResponse(instances.get(0));
	}

	// Ignore the sign bit, this allows pos to loop sequentially from 0 to
	// Integer.MAX_VALUE
	int pos = this.position.incrementAndGet() & Integer.MAX_VALUE;

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

	return new DefaultResponse(instance);
}

可以看到是轮训的策略

那么服务列表是怎么获取的呢，在下篇文章中我们回详细的分析

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/867478.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【TypeScript】进阶之路语法细节，类型和函数

【TypeScript】进阶之路语法细节，类型和函数

进阶之路 类型别名(type)的使用接口(interface)的声明的使用二者区别&#xff1a; 联合类型和交叉类型联合类型交叉类型 类型断言获取DOM元素 非空类型断言字面量类型的使用类型缩小&#xff08;类型收窄&#xff09;TypeScript 函数类型函数类型表达式内部规则检测函数的调用签…
阅读更多...
什么是响应式设计？列举几种实现响应式设计的方法。

什么是响应式设计？列举几种实现响应式设计的方法。

聚沙成塔每天进步一点点 ⭐ 专栏简介⭐ 什么是响应式设计&#xff1f;⭐ 实现响应式设计的方法⭐ 写在最后 ⭐ 专栏简介 前端入门之旅&#xff1a;探索Web开发的奇妙世界 记得点击上方或者右侧链接订阅本专栏哦 几何带你启航前端之旅 欢迎来到前端入门之旅&#xff01;这个专栏…
阅读更多...
Linux：Shell编程之免交互

Linux：Shell编程之免交互

目录 绪论 1、here Document免交互 1.1 格式 1.2 cat结合免交互实现重定向输出到指定文件 1.3 变量替换 2、Expect免交互 2.1 三种写法 3、免交互实现普通用户切换root 3.1 send_user 4、接收参数 5、嵌入执行模式 6、ssh远程登录 绪论 免交互&#xff1a;不需要人…
阅读更多...
【Linux进行时】进程概念

【Linux进行时】进程概念

进程的概念 什么是进程呢&#xff1f; ❓首先我们需要认识一下什么叫进程呢&#xff1f; 课本概念&#xff1a;程序的一个执行实例&#xff0c;正在执行的程序等 &#x1f525;内核观点&#xff1a;担当分配系统资源&#xff08;CPU时间&#xff0c;内存&#xff09;的实体。…
阅读更多...
海外ASO优化之关于应用的营销2

海外ASO优化之关于应用的营销2

在目标受众中建立信任度&#xff0c;并获得博客/新闻网站的热榜&#xff0c;这样自然会提高应用的知名度和目标受众的认知度。就博客读者而言&#xff0c;需要找出推荐的最佳时间和真正推动我们应用是什么。 1、提供了App Store或Google Play的直接链接。 我们首先需要创建一个…
阅读更多...
2023年中国锂电池X-Ray及CT检测设备市场竞争格局及行业市场规模前景分析[图]

2023年中国锂电池X-Ray及CT检测设备市场竞争格局及行业市场规模前景分析[图]

锂电池X-Ray成像检测设备主要是利用X射线穿透电芯时的吸收、反射、散射效应实现成像并对图像进行处理及算法分析&#xff0c;实现非接触式的无损、自动测量锂电池电芯内部特征尺寸以进行瑕疵检测&#xff0c;确认电芯结构是否合格、避免造成电芯内部短路等安全隐患。 锂电池X-…
阅读更多...
fork创建多个子进程

fork创建多个子进程

fork创建多个子进程 示例代码 fork1.c #include <stdio.h> #include <stdlib.h> #include <sys/types.h> #include <unistd.h>int main(int argc,char **argv) {int i, j;pid_t pid;for (i 0; i < 3; i){pid fork();if (pid < 0){perror(&q…
阅读更多...
Zip压缩包有密码，如何删除？

Zip压缩包有密码，如何删除？

Zip压缩包设置设置了密码&#xff0c;想要删除密码&#xff0c;除了将压缩包解压出来之后再将文件压缩为不带密码的压缩文件以外&#xff0c;还有一种删除密码的方法。设置方法如下&#xff1a; 右键点击zip文件&#xff0c;找到打开方式&#xff0c;以Windows资源管理器方式打…
阅读更多...
sql server profiler使用

sql server profiler使用

一、打开sql server profiler 二、配置 比如我们只过滤包含这个关键字的&#xff0c;输入&#xff1a;%Employees%
阅读更多...
【C++11】lambda表达式 | 包装器

【C++11】lambda表达式 | 包装器

文章目录 一.lambda表达式1.lambda表达式概念2.lambda表达式语法3.lambda表达式交换两个数4.lambda表达式底层原理 二.包装器1.function包装器①function包装器介绍②function包装器统一类型③function包装器的意义 2.bind包装器①bind包装器介绍②bind包装器绑定固定参数③bin…
阅读更多...
计算机基础之RAID技术

计算机基础之RAID技术

概述 RAID&#xff0c;Redundant Array of Independent Disks&#xff0c;独立磁盘冗余阵列&#xff0c;一种把多块独立的硬盘&#xff08;物理硬盘&#xff09;按不同的方式组合起来形成一个硬盘组&#xff08;逻辑硬盘&#xff09;&#xff0c;从而提供比单个硬盘更高的存储…
阅读更多...
Springboot3整合使用aj-captcha行为验证码解决方案

Springboot3整合使用aj-captcha行为验证码解决方案

截止到目前(2023-04-20)&#xff0c;Springboot最新稳定版本已经迭代到3.0.5&#xff0c;而我们项目中使用的行为验证码框架aj-captcha还没有适配Springboot3&#xff0c;码云上类似的请求也没有得到过回应&#xff0c;于是决定自己动手适配一下&#xff0c;研究下来发现适配3.…
阅读更多...
oi知识表+NOIP提高组算法及算法思想总结

oi知识表+NOIP提高组算法及算法思想总结

&#xfeff;算法及算法思想总结 │ By lib │ ├暴力 ├模拟 ├递归及递推:数位统计类 ├构造 ▼├排序算法 │ ├冒泡排序 │ ├选择排序 │ ├计数排序 │ ├基数排序 │ ├插入排序 │ ├归并排序 │ ├快速排序 │…
阅读更多...
腾讯云轻量应用服务器地域怎么选？上海广州北京？

腾讯云轻量应用服务器地域怎么选？上海广州北京？

腾讯云轻量应用服务器地域是指轻量服务器数据中心所在的地理位置&#xff0c;如上海、广州和北京等地域&#xff0c;如何选择地域&#xff1f;地域的选择建议就近原则&#xff0c;用户距离轻量服务器地域越近&#xff0c;网络延迟越低&#xff0c;速度就越快&#xff0c;根据用…
阅读更多...
day38 滑动窗口

day38 滑动窗口

1. 滑动窗口 应用场景&#xff1a; 满足xxx条件&#xff08;计算结果、出现次数、同时包含&#xff09; 关键词&#xff1a;最长最短子串无重复等等 1&#xff09;最长 左右指针在起始点&#xff0c;R 向右依次滑动循环&#xff1b; 如果&#xff1a; 窗内元素满足条件&#x…
阅读更多...
聚观早报 | 三星和LG发展电车零件业务；宝马召回国产和进口电车

聚观早报 | 三星和LG发展电车零件业务；宝马召回国产和进口电车

【聚观365】8月12日消息 三星和LG加速发展电车零件业务宝马召回部分国产和进口电动汽车华为有意推动车BU独立运营长城汽车CTO就“中国汽车在一起”发声比科奇芯片被Contela选为单元的核心组件 三星和LG加速发展电车零件业务 随着电动汽车需求的增加&#xff0c;对电池、芯片等…
阅读更多...
Redis - 数据类型映射底层结构

Redis - 数据类型映射底层结构

简介 从数据类型上体现就是&#xff0c;同一个数据类型&#xff0c;在不同的情况下会使用不同的编码类型&#xff0c;底层所使用的的数据结构也不相同。 字符串对象 字符串对象的编码可以是 int、raw 和 embstr 三者之一。 embstr 编码是专门用于保存简短字符串的一种优化编…
阅读更多...
.DS_Store是什么文件

.DS_Store是什么文件

dsstore是自定义属性的隐藏文件。dsstore全称“Desktop Services Store”&#xff0c;是一种由苹果公司的Mac OS X操作系统所创造的隐藏文件&#xff0c;目的在于存贮目录的自定义属性&#xff0c;例如文件们的图标位置或者是背景色的选择。 dsstore是什么文件&#xff1f; ds…
阅读更多...
高端百度地图开发2：自定义水滴头像（鼠标事件、API封装对接）

高端百度地图开发2：自定义水滴头像（鼠标事件、API封装对接）

高端百度地图开发系列 高端百度地图开发1&#xff1a;自定义水滴头像&#xff08;自定义标注覆盖物、Overlay覆盖类&#xff09; 自定义水滴头像之鼠标事件、API封装对接 高端百度地图开发系列一、添加自定义覆盖物的方法二、对接API数据1.获取API数据(模拟)2.遍历数据3.添加自…
阅读更多...
LeetCode--HOT100题（28）

LeetCode--HOT100题（28）

目录 题目描述&#xff1a;2. 两数相加&#xff08;中等&#xff09;题目接口解题思路代码 PS: 题目描述&#xff1a;2. 两数相加&#xff08;中等&#xff09; 给你两个 非空 的链表&#xff0c;表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的&#xff0c;并且…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023