springboot3.0自定义负载均衡策略(ReactorLoadBalancer)

已于 2024-05-01 10:11:30 修改
阅读量1.7k 收藏 17
点赞数 23
文章标签： java 后端 spring cloud
于 2023-12-24 15:11:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_18478183/article/details/135180656
版权

springboot3.0自定义ReactorLoadBalancer

背景

目前我们很多都使用spring cloud系框架做为项目开发的基础微服务架构框架。在使用spring cloud系列的框架时，我们经常会用到feign作为服务间调用的框架，为了应对一些定制化需求，我们有时会对这个框架做一些定制化。

Feign.Client

类路径feign.Client。这是一个接口，只包含了一个方法，方法名为execute，请求参数两个，返回参数一个。具体如下：

  /**
 * Executes a request against its {@link Request#url() url} and returns a response.
 *  * @param request safe to replay.
 * @param options options to apply to this request.
 * @return connected response, {@link Response.Body} is absent or unread.
 * @throws IOException on a network error connecting to {@link Request#url()}.
   */
  Response execute(Request request, Options options) throws IOException;

如果我们需要定义一个自己的client，例如不是用http，使用其他协议；或者需要实现重试等情况。但是一般情况我们不自定义这个类，而是使用线程的spring的实现类，或者使用其他框架的类。

常用的Feign.Client

  • org.springframework.cloud.openfeign.loadbalancer.FeignBlockingLoadBalancerClient:比较常用的类，loadbalancer在不配置重试时，使用的是该类。
  • org.springframework.cloud.openfeign.loadbalancer.RetryableFeignBlockingLoadBalancerClient:配置了重试使用的类，使用该类的前置条件是配置重试规则和引入了RetryTemplate类

	@Bean
	@ConditionalOnMissingBean
	@ConditionalOnClass(name = "org.springframework.retry.support.RetryTemplate")
	@ConditionalOnBean(LoadBalancedRetryFactory.class)
	@ConditionalOnProperty(value = "spring.cloud.loadbalancer.retry.enabled", havingValue = "true",
			matchIfMissing = true)
	public Client feignRetryClient(LoadBalancerClient loadBalancerClient,
			LoadBalancedRetryFactory loadBalancedRetryFactory, LoadBalancerClientFactory loadBalancerClientFactory,
			List<LoadBalancerFeignRequestTransformer> transformers) {
		return new RetryableFeignBlockingLoadBalancerClient(new Client.Default(null, null), loadBalancerClient,
				loadBalancedRetryFactory, loadBalancerClientFactory, transformers);
	}

引入了RetryTemplate类

 		<!-- https://mvnrepository.com/artifact/org.springframework.retry/spring-retry -->
		<dependency>
		    <groupId>org.springframework.retry</groupId>
		    <artifactId>spring-retry</artifactId>
		</dependency>

自定义请求时选择哪个serviceInstance

serviceInstance选择实现类BlockingLoadBalancerClient

以上的FeignBlockingLoadBalancerClient或者RetryableFeignBlockingLoadBalancerClient的execute方法都会调用一个retrievedServiceInstance = loadBalancerClient.choose(serviceId, lbRequest);方法。目前来说loadBalancerClient在只使用spring-cloud-starter-loadbalancer时只有一个实现类，就是BlockingLoadBalancerClient。
BlockingLoadBalancerClient代码：

/**
 * The default {@link LoadBalancerClient} implementation.
 *
 * @author Olga Maciaszek-Sharma
 * @since 2.2.0
 */
@SuppressWarnings({ "unchecked", "rawtypes" })
public class BlockingLoadBalancerClient implements LoadBalancerClient {

	private final ReactiveLoadBalancer.Factory<ServiceInstance> loadBalancerClientFactory;

	public BlockingLoadBalancerClient(ReactiveLoadBalancer.Factory<ServiceInstance> loadBalancerClientFactory) {
		this.loadBalancerClientFactory = loadBalancerClientFactory;
	}

	/*省略其他代码*/
	@Override
	public ServiceInstance choose(String serviceId) {
		return choose(serviceId, REQUEST);
	}

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

	/*省略其他代码*/

}

BlockingLoadBalancerClient构造函数

我们看到构造方法是需要传一个ReactiveLoadBalancer.Factory，这个很重要，可以具体看一下这个接口的实现类LoadBalancerClientFactory，这是一个继承了NamedContextFactory的类。NamedContextFactory出现在很多框架中，一般是用来做子容器使用。
看看NamedContextFactory的代码：

/*
 * Copyright 2012-2020 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.cloud.context.named;

/*省略其他代码*/
/**
 * Creates a set of child contexts that allows a set of Specifications to define the beans
 * in each child context.
 *
 * Ported from spring-cloud-netflix FeignClientFactory and SpringClientFactory
 *
 * @param <C> specification
 * @author Spencer Gibb
 * @author Dave Syer
 * @author Tommy Karlsson
 * @author Olga Maciaszek-Sharma
 */
public abstract class NamedContextFactory<C extends NamedContextFactory.Specification>
		implements DisposableBean, ApplicationContextAware {

	private final Map<String, ApplicationContextInitializer<GenericApplicationContext>> applicationContextInitializers;

	private final String propertySourceName;

	private final String propertyName;

	private final Map<String, GenericApplicationContext> contexts = new ConcurrentHashMap<>();

	private Map<String, C> configurations = new ConcurrentHashMap<>();

	private ApplicationContext parent;

	private Class<?> defaultConfigType;

	public NamedContextFactory(Class<?> defaultConfigType, String propertySourceName, String propertyName) {
		this(defaultConfigType, propertySourceName, propertyName, new HashMap<>());
	}

	public NamedContextFactory(Class<?> defaultConfigType, String propertySourceName, String propertyName,
			Map<String, ApplicationContextInitializer<GenericApplicationContext>> applicationContextInitializers) {
		this.defaultConfigType = defaultConfigType;
		this.propertySourceName = propertySourceName;
		this.propertyName = propertyName;
		this.applicationContextInitializers = applicationContextInitializers;
	}
/*省略其他代码*/
	protected GenericApplicationContext 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);
	}

	public GenericApplicationContext createContext(String name) {
		GenericApplicationContext context = buildContext(name);
		// there's an AOT initializer for this context
		if (applicationContextInitializers.get(name) != null) {
			applicationContextInitializers.get(name).initialize(context);
			context.refresh();
			return context;
		}
		registerBeans(name, context);
		context.refresh();
		return context;
	}

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

	public <T> ObjectProvider<T> getLazyProvider(String name, Class<T> type) {
		return new ClientFactoryObjectProvider<>(this, name, type);
	}

	public <T> ObjectProvider<T> getProvider(String name, Class<T> type) {
		GenericApplicationContext context = getContext(name);
		return context.getBeanProvider(type);
	}

	public <T> T getInstance(String name, Class<?> clazz, Class<?>... generics) {
		ResolvableType type = ResolvableType.forClassWithGenerics(clazz, generics);
		return getInstance(name, type);
	}

	@SuppressWarnings("unchecked")
	public <T> T getInstance(String name, ResolvableType type) {
		GenericApplicationContext context = getContext(name);
		String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(context, type);
		if (beanNames.length > 0) {
			for (String beanName : beanNames) {
				if (context.isTypeMatch(beanName, type)) {
					return (T) context.getBean(beanName);
				}
			}
		}
		return null;
	}

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

		return BeanFactoryUtils.beansOfTypeIncludingAncestors(context, type);
	}

/*省略其他代码*/

}

我们看到在类属性里面是包含了一个contexts 的map，这个map的key是String类型的，value是GenericApplicationContext，这个GenericApplicationContext就是我们常说的spring的容器。

private final Map<String, GenericApplicationContext> contexts = new ConcurrentHashMap<>();

也就是说NamedContextFactory是针对不同的场景创建不同的子容器。那么对于feign来说，不同的feign接口（带@FeignClien的接口）就是不同的场景。

BlockingLoadBalancerClient的choose方法

先看代码

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

在执行choose方法内部，先找到ReactiveLoadBalancer，然后再调用ReactiveLoadBalancer的choose方法。到这里我们可以看到常用的ReactiveLoadBalancer有RandomLoadBalancer和RoundRobinLoadBalancer，如果使用了nacos，还有NacosLoadBalancer。RandomLoadBalancer是随机取一个serviceInstance，RoundRobinLoadBalancer是轮询。这两个中在spring-loadbalancer只使用了RoundRobinLoadBalancer。

RoundRobinLoadBalancer实现

看看RoundRobinLoadBalancer的代码：

public class RoundRobinLoadBalancer implements ReactorServiceInstanceLoadBalancer {

	private static final Log log = LogFactory.getLog(RoundRobinLoadBalancer.class);

	final AtomicInteger position;

	final String serviceId;

	ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider;

	/**
	 * @param serviceInstanceListSupplierProvider a provider of
	 * {@link ServiceInstanceListSupplier} that will be used to get available instances
	 * @param serviceId id of the service for which to choose an instance
	 */
	public RoundRobinLoadBalancer(ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider,
			String serviceId) {
		this(serviceInstanceListSupplierProvider, serviceId, new Random().nextInt(1000));
	}

	/**
	 * @param serviceInstanceListSupplierProvider a provider of
	 * {@link ServiceInstanceListSupplier} that will be used to get available instances
	 * @param serviceId id of the service for which to choose an instance
	 * @param seedPosition Round Robin element position marker
	 */
	public RoundRobinLoadBalancer(ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider,
			String serviceId, int seedPosition) {
		this.serviceId = serviceId;
		this.serviceInstanceListSupplierProvider = serviceInstanceListSupplierProvider;
		this.position = new AtomicInteger(seedPosition);
	}

	@SuppressWarnings("rawtypes")
	@Override
	// see original
	// https://github.com/Netflix/ocelli/blob/master/ocelli-core/
	// src/main/java/netflix/ocelli/loadbalancer/RoundRobinLoadBalancer.java
	public Mono<Response<ServiceInstance>> choose(Request request) {
		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();
		}

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

}

我们看到choose代码其实没两行，先是从众多ServiceInstanceListSupplier中获取一个ServiceInstanceListSupplier，然后从ServiceInstanceListSupplier获取符合这个serviceId的serviceInstance列表。最后从这个列表中按照轮询的规则获取其中一个serviceInstance。
先看下ServiceInstanceListSupplier有哪些。
ServiceInstanceListSupplier
其中我们最后获取出来的是RetryAwareServiceInstanceListSupplier，但是RetryAwareServiceInstanceListSupplier其实走的是一个委托模式，RetryAwareServiceInstanceListSupplier的底层是CachingServiceInstanceListSupplier，CachingServiceInstanceListSupplier也是委托模式，CachingServiceInstanceListSupplier的底层是DiscoveryClientServiceInstanceListSupplier。DiscoveryClientServiceInstanceListSupplier也是委托，最后获取serviceInstance的还是DiscoveryClient。
CachingServiceInstanceListSupplier主要是做一个缓存，避免每次都去重新获取。
最后ServiceInstanceListSupplier会获取出来一个serviceInstance的列表。

自定义LoadBalancer

先自定义类

我们可以参考RoundRobinLoadBalancer，一样先获取出来serviceInstance的list，然后再从serviceInstance的list中选一个。
举例：

package xxx.loadbalancer;

public class XxxxLoadBalancer  implements ReactorServiceInstanceLoadBalancer {

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

	final String serviceId;
	
	final Map<String, Integer> TTLMap = MapUtil.newConcurrentHashMap();
	
	ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider;
	
	private NetworkSituationHandler networkSituationHandler;

	/**
	 * @param serviceInstanceListSupplierProvider a provider of
	 * {@link ServiceInstanceListSupplier} that will be used to get available instances
	 * @param serviceId id of the service for which to choose an instance
	 */
	public XxxxLoadBalancer  (ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider,
			String serviceId) {
		this.serviceId = serviceId;
		this.serviceInstanceListSupplierProvider = serviceInstanceListSupplierProvider;
		networkSituationHandler = new NetworkSituationHandler();
		networkSituationHandler.start();
		LOG.info("service " + serviceId + " use NearestLoadBalancer");
	}

	@SuppressWarnings("rawtypes")
	@Override
	// see original
	// https://github.com/Netflix/ocelli/blob/master/ocelli-core/
	// src/main/java/netflix/ocelli/loadbalancer/RoundRobinLoadBalancer.java
	//ClientFactoryObjectProvider
	public Mono<Response<ServiceInstance>> choose(Request request) {
		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();
		}

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

		return new DefaultResponse(instance);
	}
	
	public ServiceInstance determineInstance(List<ServiceInstance> instances) {
		/*
			从instances筛选想要的ServiceInstance，这里就是业务代码
		*/
	}
	
}
注入到对应的applicationContext

自定义完成后，我们需要将我们的LoadBalancer注入到applicationContext中。参考RoundRobinLoadBalancer的注入方式，RoundRobinLoadBalancer需要一个ServiceInstanceListSupplierProvider作为构造函数，ServiceInstanceListSupplierProvider来自于loadBalancerClientFactory，loadBalancerClientFactory就是我们上面说到的针对不同的@FeignClient创建的不同的子容器。

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

也就是说我们现在自定义的LoadBalancer需要加入到LoadBalancerClientFactory的子容器中，不能直接写一个配置类然后加个@bean，需要在特定的Configuration中。这里就借鉴RoundRobinLoadBalancer所在的Configuration（org.springframework.cloud.loadbalancer.annotation.LoadBalancerClientConfiguration）。因为在LoadBalancerClientFactory这个类中写死了配置类是LoadBalancerClientConfiguration，所以需要重写LoadBalancerClientConfiguration，新增我们新加的LoadBalancer类的创建。
LoadBalancerClientFactory构造函数：

	public LoadBalancerClientFactory(LoadBalancerClientsProperties properties) {
		super(LoadBalancerClientConfiguration.class, NAMESPACE, PROPERTY_NAME, new HashMap<>());
		this.properties = properties;
	}

举例：
重写LoadBalancerClientConfiguration.java，注意里面省略代码只是为了方便观看，在实际操作时，省略的代码需要原封原样的复制过来。

/*
 * Copyright 2012-2023 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/*重写这里不能变*/
package org.springframework.cloud.loadbalancer.annotation;
/*省略导包*/


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

	private static final int REACTIVE_SERVICE_INSTANCE_SUPPLIER_ORDER = 193827465;
	
	
	@Bean
	@ConditionalOnMissingBean
	@ConditionalOnProperty(prefix = "spring.cloud.loadbalancer", name = "instance-load-balancer", havingValue = "XxxxLoadBalancer  ")
	public ReactorLoadBalancer<ServiceInstance> reactorServiceInstanceNearestLoadBalancer(Environment environment,
			LoadBalancerClientFactory loadBalancerClientFactory) {
		String name = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);
		return new XxxxLoadBalancer (
				loadBalancerClientFactory.getLazyProvider(name, ServiceInstanceListSupplier.class), name);
	}
	
	@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);
	}
	/*省略部分代码，这里是省略，不是去除，在重写这个类时，省略的方法需要原封原样的复制过来*/
}
派大星的沙滩裤
关注
  • 23
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SpringCloud之四 负载均衡Feign
01-07
SpringCloud之四 负载均衡Feign，使用Feign进行微服务的负载均衡处理
带你了解Springboot3.0新特性
06-16
Spring Boot 3.0 依赖的java 17 并且迁移到了Jakarta命名空间，这是计划将生态依赖JAVA 8 升级到JAVA 17 重大修订，基于Spring框架6.0 他将是第一个使用Jakarta EE 9 APIs（jakarta.* )的Spring Boot 版本，而不再...
Spring Cloud Gateway3.x自定义Spring Cloud Loadbalancer负载均衡策略以及实现动态负载均衡策略的方案
最新发布
Ice166的博客
06-25 1747
工作和兴趣的使然，由于需要对各种开源的项目做一些自定义的插件以及扩展，所以会经常研究一些开源组件的源码。
SpringCloud之LoadBalancer自定义负载均衡算法，基于nacos权重
aoxiaojun的博客
04-15 806
自定义loadbalancer 负载算法，权重，nacos
feign自定义负载均衡实现
fusugongzi的博客
04-24 716
通过实现IRule接口，自定义负载均衡规则@Override@Override@Override自己实现choose方法逻辑即可，serviceName是请求的服务名称。
springcloud自定义负载均衡LoadBalancer
agulahaha的博客
05-20 1944
***/// 服务列表@Override// 自定义// 默认RoundRobinLoadBalancer// 随机/*** 使用随机算法 参考{link* @param instances 实例*//*** 使用RoundRobin机制获取节点* @param instances 实例*/// 每一次计数器都自动+1，实现轮询的效果/*** 自定义的负载策略* @return*/
Feign负载均衡
旭出东方
07-05 350
概述 Feign是一个声明式WebService客户端。使用Feign能让编写Web Service客户端更加简单, 它的使用方法是定义一个接口，然后在上面添加注解，同时也支持JAX-RS标准的注解。Feign也支持可拔插式的编码器和解码器。Spring Cloud对Feign进行了封装，使其支持了Spring MVC标准注解和HttpMessageConverters。Feign可以与Eureka和Ribbon组合使用以支持负载均衡 Feign能干什么 Feign旨在使编写Java Http客户端变得更
SpringCloud之Feign实现负载均衡(三)
偏偏行
01-04 398
简介： Feign是一个声明式的伪Http客户端，它使得写Http客户端变得更简单。使用Feign，只需要创建一个接口并注解。它具有可插拔的注解特性，可使用Feign 注解和JAX-RS注解。Feign支持可插拔的编码器和解码器。Feign默认集成了Ribbon，并和Eureka结合，默认实现了负载均衡的效果。它还整合了Hysitrix，具备熔断器的能力。 本章实例为使用Feign消费服务提供...
springboot工程自定义response注解、自定义规范化返回数据结构
09-02
本主题将深入探讨如何在Spring Boot工程中通过自定义response注解、利用Java反射机制、设置自定义拦截器以及实现WebMvcConfigurer接口来实现这一目标。 首先，我们来看自定义response注解。在Spring Boot中，可以...
SpringBoot Jpa 自定义查询实现代码详解
08-25
SpringBoot Jpa 自定义查询实现代码详解 SpringBoot Jpa 自定义查询实现代码详解是 SpringBoot 框架中使用 JPA（Java Persistence API）进行持久层开发时的一种实现方式。JPA 是 Java 规范，提供了对象关系映射...
Spring Boot 集成 Nacos + feign + LoadBalancer，实现简单的调用
08-25
Spring Boot 集成 Nacos + feign + LoadBalancer，实现简单的调用，作为简单的脚手架可以的，同时将Nacos 源码集成进来可以便于调试阅读源码
SpringBoot3.0 + RocketMq 构建企业级数据中台完结11章
11-22
视频课程下载——SpringBoot3.0 + RocketMq 构建企业级数据中台【完结11章】
Springboot之自定义全局异常处理的实现
08-25
Springboot之自定义全局异常处理的实现 Springboot之自定义全局异常处理的实现是指在Springboot框架中，通过自定义异常处理器来捕获和处理全局异常的方法。这种方法可以帮助开发者更好地处理程序中的异常，提高...
SpringCloud--4.feign负载均衡
qq_46492246的博客
10-25 1065
1.Feign介绍 feign是声明式的web service客户端,它让微服务之间的调用变得更简单了，类似controller调用service。 SpringCloud集成了Ribbon和Eureka,同时可在使用Feign时提供负载均衡的http客户端。只需要创建一个接口， 然后添加注解即可! feign，主要是社区，大家都习惯面向接口编程。这个是很多开发人员的规范。调用微服务访问两种方法 1.使用微服务名字 [ribbon+restTemplate] 2.使用接口和注解 [feign] Feign
SpringCloud-Feign：负载均衡(基于服务端)
小孔靠得住的博客
02-13 3275
Feign是一个开源的声明式HTTP客户端，它可以简化HTTP API的调用过程。Feign的设计目标是使得使用者可以像调用本地方法一样调用远程服务，使得编写和维护HTTP客户端变得更加简单。类似controller调用service。SpringCloud集成了Ribbon和Eureka，可以使用Feigin提供负载均衡的http客户端只需要创建一个接口，然后添加注解即可~使用Feign时，需要先定义一个接口，该接口中定义了需要远程调用的方法、URL、请求方法、请求头等信息。
【SpringCloud Alibaba】（四）使用 Feign 实现服务调用的负载均衡
sco5282的博客
07-27 2765
这里，我们通过修改订单微服务的代码来实现自定义负载均衡。由于在整个项目中，订单微服务作为客户端存在，由订单微服务调用用户微服务和商品微服务，所以，这里采用的是客户端负载均衡的模式。
七、Feign 负载均衡(基于服务端)
Karen博客
09-22 418
七、Feign 负载均衡(基于服务端)
SpringCloud 自定义负载均衡算法
GaoChenXi
10-01 846
本章基于SpringCloud Ribbon负载均衡配置说明 官方说明：自定义配置类不能放在@ComponentScan所扫描的当前包以及子包下面，否则我们自定义的配置类就会被所有的Ribbon客户端共享，也就是说我们达不到特殊化定制的目的了。 @SpringBootApplication注解中有@CompontentScan注解，这个加上SpringBootApplication所在的类所在...
springboot3.0自定义starter
10-31
在Spring Boot 3.0中自定义starter的步骤如下： 1. 创建一个Maven项目，命名为xxx-spring-boot-starter，其中xxx为你的starter名称。 2. 在该项目中添加依赖，包括spring-boot-autoconfigure和spring-boot-starter。 3. 创建一个自动配置类，命名为XxxAutoConfiguration，其中Xxx为你的starter名称。在该类中使用@Configuration注解标注该类为配置类，并使用@ConditionalOnClass注解来判断是否存在某个类，如果存在则自动配置生效。 4. 在自动配置类中使用@Bean注解来定义需要自动配置的Bean。 5. 创建一个spring.factories文件，将自动配置类的全限定名添加到该文件中。 6. 打包该项目并安装到本地仓库。 7. 在其他项目中添加依赖，引入你自定义的starter即可。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值