Spring Cloud Neflix Ribbon入门到实战

已于 2024-02-05 14:29:12 修改
阅读量934 收藏 22
点赞数 20
分类专栏： 微服务 Spring Cloud系列文章 文章标签： spring cloud ribbon spring spring boot java 微服务 负载均衡
于 2024-02-05 14:13:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42008170/article/details/136040923
版权

Ribbon入门

由于客户端负载均衡需要从注册中心获取服务列表，所以需要集成注册中心。

创建父级工程cloud-ribbon-practice

	<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.3.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <spring.cloud-version>Hoxton.SR3</spring.cloud-version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring.cloud-version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

创建注册中心cloud-eureka-server

<dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
    </dependencies>

配置文件application.xml

server:
  port: 8761
eureka:
  instance:
    hostname: localhost
  client:
    registerWithEureka: false
    fetchRegistry: false
    serviceUrl:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

启动类

@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {

    public static void main(String[] args) {
        SpringApplication.run(EurekaServerApplication.class, args);
    }
}

创建源服务工程cloud-ribbon-hello-b1、cloud-ribbon-hello-b2、cloud-ribbon-hello-b3

	<dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
    </dependencies>

配置文件application.yml

b1

spring:
  application:
    name: ribbon-service-b
server:
  port: 7777
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/
  instance:
    prefer-ip-address: true

b2

spring:
  application:
    name: ribbon-service-b
server:
  port: 7778
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/
  instance:
    prefer-ip-address: true

b3

spring:
  application:
    name: ribbon-service-b
server:
  port: 7779
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/
  instance:
    prefer-ip-address: true

b1、b2、b3的controller

@RestController
public class OrderController {

    @Value("${server.port}")
    private Integer port;

    @Value("${spring.application.name}")
    private String name;

    @GetMapping("/test")
    public String add() {
        return "this service name is " + name + " and port is " + port;
    }

}

b1、b2、b3的启动类

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

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

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

创建服务调用者cloud-ribbon-hello-a

spring-cloud-starter-netflix-eureka-client已经集成了ribbon。不需要额外引入，直接使用即可。

	<dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
    </dependencies>

配置文件application.yml

spring:
  application:
    name: ribbon-hello-a
server:
  port: 7776
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/
  instance:
    prefer-ip-address: true

启动类，RestTemplate使用了@LoadBalanced，这样RestTemplate就开启了ribbon的负载均衡了。

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

    @LoadBalanced
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

controller

@RestController
@RequestMapping("ribbon")
public class TestController {

    @Autowired
    private RestTemplate restTemplate;

    @GetMapping("/test")
    public String test(){
        String body = restTemplate.getForEntity("http://RIBBON-SERVICE-B/test", String.class).getBody();
        return body;
    }

}

测试，使用postman访问几次：http://localhost:7776/ribbon/test。下图可以看出，默认是的负载均衡算法是轮询。

Ribbon实战

从上一节可以看到，开启负载均衡只需通过@LoadBalanced注解即可。负载均衡中又很多的负载均衡策略，如轮询（Round Robin）、权重（Weight）、ip_hash等。这些丰富的策略让我们在构建应用的时候，有很多选择的余地，可以根据实际的业务场景选择最合适的策略。

在Ribbon中一共提供了7中负载均衡策略：

策略类命名描述
RandomRule随机策略随机选择Server
RoundRobinRule轮询策略按顺序选择Server
RetryRule重试策略在一个配置时间段内当选择Server不成功，则一直尝试选择一个可用的Server
BestAvailableRule最低并发策略卓哥考察Server，如果Server断路器打开，则忽略，再选择其中并发连接最低的Server
AvailabilityFilteringRule可用过滤策略过滤一直连接失败并标记为circuit tripped的Server，过滤掉那些高并发连接的Server(active connections超过配置的阈值)
ResponseTimeWeightedRule响应时间加权策略已经被弃用，作用同WeightedResponseTimeRule
WeightedResponseTimeRule响应时间加权策略根据Server的响应时间分配权重，响应时间越长，权重越低，被选中的概率就越低。响应时间越短，权重越高，被选择到的概率越高
ZoneAvoidanceRule区域权衡策略综合判断Server所在区域的性能和Server的可用性轮询选择Server，并且判断一个AWS Zone的运行性能是否可用，剔除不可用的Zone中的所有Server

在上面的入门案例中Ribbon的默认负载均衡策略是轮询策略，

Ribbon自定义配置负载均衡策略

全局配置

使用Ribbon时配置全局的负载均衡策略，需要加一个配置类。改配置类需要被@ComponentScan扫描到才能全局生效。

@Configuration
public class GlobalRuleConfig {
    @Bean
    public IRule ribbonRule() {
        return new RandomRule();
    }
}

上面配置了随机的策略，多次访问http://localhost:7776/ribbon/test。就可看到Server的选择就变成了随机了。同样了可以选择其他的Ribbon已经实现的策略，也可以自定义负载均衡策略。

基于@RibbonClient或@RibbonClients注解的配置

配置类，注意：编写自定义配置类，需要特别注意的是官方文档明确给出了警告：这个自定义配置类不能放在@ComponentScan所扫描的包以及其子包下(即不能放在主启动类所在的包及其子包下，因此我们需要新建一个包来放该配置类)，否则我们自定义的这个配置类就会被所有的Ribbon客户端所共享，也就达不到特殊化定制的目的了

@Configuration
public class AnnoRuleConfig {
    @Bean
    public IRule ribbonRule() {
        return new RandomRule();
    }
}

启动类的配置

@SpringBootApplication
@EnableDiscoveryClient
@RibbonClient(name = "ribbon-service-b", configuration = AnnoRuleConfig.class)
public class ServiceAApplication {
    public static void main(String[] args) {
        SpringApplication.run(ServiceAApplication.class, args);
    }

    @LoadBalanced
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

通过@RibbonClient指定某个服务的负载均衡策略，其他没有被指定的，就是用默认的负载均衡策略。该注解可以把其他的配置类作为另外一个IOC容器导入到应用中，相当于加载了两个完全不相干的Spring的beans配置文件，此时应用中会有两个IOC容器。

@RibbonClient(name = "RIBBON-SERVICE-B", configuration = AnnoRuleConfig.class)

也可以使用一下的方式，指定多个服务的负载均衡策略

@RibbonClients(value = {
		@RibbonClient(name = "RIBBON-SERVICE-B", configuration = AnnoRuleConfig.class),
		@RibbonClient(name = "RIBBON-SERVICE-C", configuration = AnnoRuleConfig.class)
})

基于配置文件

下面对服务ribbon-service-b的负载均衡策略使用

RIBBON-SERVICE-B:
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule

Ribbon超时与重试

使用HTTP发起请求难免会发生问题，在F版开始Ribbon的重试机制默认是开启的，需要添加对超时时间与重试策略的配置。列入下面ribbon-service-b服务的配置

RIBBON-SERVICE-B:
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule
    ConnectTimeout: 3000
    ReadTimeout: 60000
    MaxAutoRetries: 3 #对第一次请求的服务的重试次数
    MaxAutoRetriesNextServer: 1 #要重试的下一个服务的最大数量（不包括第一个服务）
    OkToRetryOnAllOperations: true

也可以全局配置

ribbon:
  ConnectTimeout: 3000
  ReadTimeout: 60000
  MaxAutoRetries: 3 #对第一次请求的服务的重试次数
  MaxAutoRetriesNextServer: 1 #要重试的下一个服务的最大数量（不包括第一个服务）
  OkToRetryOnAllOperations: true

一般Ribbon都是搭配OpenFeign这类Http客户端或者其他RPC使用。因为这样去调用远程服务会更加优雅和方便。而OpenFeign默认是继承了Ribbon，对于Ribbon的超时时间配置也是很简单。

对于网络抖动这些可以使用spring-retry，spring-retry是spring提供的一个基于spring的重试框架，非常好用。

Ribbon饥饿加载

Ribbon在进行客户端负载均衡的时候，并不是启动时就加载上下文，而是在实际请求的时候采取创建。因为要加载上下文的原因，在第一次调用时可能会很慢，甚至导致超时。所以我们可以指定Ribbon客户端开启立即加载(饥饿加载)，在应用启动的时候就立即加载所有配置项的应用程序上下文。

ribbon:
  eager-load:
    clients: ribbon-service-b, ribbon-service-order
    enabled: true

自定义Ribbon客户端

在Ribbon的1.2.0版本之后，就可以使用配置文件来定制Ribbon客户端，其实实质就是使用配置文件来指定一些默认加载类，从而更改Ribbon客户端的行为，并且使用这种方式优先级最高，优先级高于使用注解@RibbonClient指定的配置和源码中加载的相关的Bean。看下表：

配置项说明
.ribbon.NFLoadBalancerClassName指定ILoadBalancer的实现类
.ribbon.NFLoadBalancerRuleClassName指定IRule的实现类
.ribbon.NFLoadBalancerPingClassName指定IPing的实现类
.ribbon.NiWSServerListClassName指定ServerList的实现类
.ribbon.NIWSServerListFilterClassName指定ServerListFilter的实现类

例如：这里使用的实现的RIbbon提供的实现

RIBBON-SERVICE-B:
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule
    NiWSServerListClassName: com.netflix.loadbalancer.ConfigurationBasedServerList

Ribbon脱离Eureka使用

在默认的情况下，Ribbon客户端需要从Eureka注册中心读取服务注册信息列表，来达到一种动态负载均衡的功能。当使用的注册中心是公共的注册中心，例如：社区公益Eureka(http://eureka.springcloud.cn)，所以就不要从Eureka中读取服务列表了。而是从Ribbon客户端自行指定原服务地址，让Rabbon脱离使用。配置如下：

ribbon: 
  eureka:
    enabled: false
#RIBBON-SERVICE-B服务的获取地址
RIBBON-SERVICE-B:
  ribbon:
    listOfServers: http://localhost:8088/

Ribbon进阶

核心工作原理

Ribbon的核心接口：

接口描述默认实现
IClientConfig定义Ribbon中管理配置的接口DefaultClientConfigImpl
IRule定义Ribbon中负载均衡策略的接口ZoneAdvoidanceRule
IPing定义定期Ping服务检查可用性的接口DummyPing
ServerList<Server>定义获取服务列表方法的接口ConfigurationBasedServerList
ServerListFilter<Server>定义特定期望获取服务列表方法的接口ZonePreferenceServerListFilter
ILoadBalancer定义负载均衡选择服务的核心方法的接口ZoneAwareLoadBalancer
ServerListUpdater为DynamicServerListLoadBalancer定义动态更新服务列表的接口PollingServerListUpdater

Ribbon完全是基于这些接口上建立起来的，是Ribbon的核心。了解这些核心的类的功能对于理解Ribbon的原理和扩展很有利。

在之前的例子中，使用Ribbon负载均衡都是通过在RestTemplate的Bean上添加注解@LoadBalanced，使得RestTemplate拥有了负载均衡的能力。

LoadBalanced源码：


/**
 * Annotation to mark a RestTemplate or WebClient bean to be configured to use a
 * LoadBalancerClient.
 * @author Spencer Gibb
 */
@Target({ ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Qualifier
public @interface LoadBalanced {
}

在注释中可以看到：该注解标记在RestTemplate或者其他的WebClient的Bean上，来使用LoadBalancerClient。

**LoadBalancerClient：**该接口扩展自ServiceInstanceChooser

public interface LoadBalancerClient extends ServiceInstanceChooser {

	/**
	 * Executes request using a ServiceInstance from the LoadBalancer for the specified
	 * service.
	 * @param serviceId The service ID to look up the LoadBalancer.
	 * @param request Allows implementations to execute pre and post actions, such as
	 * incrementing metrics.
	 * @param <T> type of the response
	 * @throws IOException in case of IO issues.
	 * @return The result of the LoadBalancerRequest callback on the selected
	 * ServiceInstance.
	 */
	<T> T execute(String serviceId, LoadBalancerRequest<T> request) throws IOException;

	/**
	 * Executes request using a ServiceInstance from the LoadBalancer for the specified
	 * service.
	 * @param serviceId The service ID to look up the LoadBalancer.
	 * @param serviceInstance The service to execute the request to.
	 * @param request Allows implementations to execute pre and post actions, such as
	 * incrementing metrics.
	 * @param <T> type of the response
	 * @throws IOException in case of IO issues.
	 * @return The result of the LoadBalancerRequest callback on the selected
	 * ServiceInstance.
	 */
	<T> T execute(String serviceId, ServiceInstance serviceInstance,
			LoadBalancerRequest<T> request) throws IOException;

	/**
	 * Creates a proper URI with a real host and port for systems to utilize. Some systems
	 * use a URI with the logical service name as the host, such as
	 * http://myservice/path/to/service. This will replace the service name with the
	 * host:port from the ServiceInstance.
	 * @param instance service instance to reconstruct the URI
	 * @param original A URI with the host as a logical service name.
	 * @return A reconstructed URI.
	 */
	URI reconstructURI(ServiceInstance instance, URI original);
}

ServiceInstanceChooser：

public interface ServiceInstanceChooser {

	/**
	 * Chooses a ServiceInstance from the LoadBalancer for the specified service.
	 * @param serviceId The service ID to look up the LoadBalancer.
	 * @return A ServiceInstance that matches the serviceId.
	 */
	ServiceInstance choose(String serviceId);
}
  • ServiceInstance choose(String serviceId)：根据ServiceId，结合负载均衡器选择一个服务实例
  • T execute(String serviceId, LoadBalancerRequest request)：使用来自LoadBalancer的ServiceInstance为指定的服务执行请求
  • T execute(String serviceId, ServiceInstance serviceInstance,
    LoadBalancerRequest request)：使用来自LoadBalancer的ServiceInstance为指定的服务执行请求，是上一个方法的重载，在实现类中可以看到它们的关系，就是前一个方法的细节实现、
  • URI reconstructURI(ServiceInstance instance, URI original)：使用注解ip和port构建特定的URL以供Ribbon内部使用。Ribbon使用具有逻辑服务名称的URL作为host，例如：http://service-b/order/add。

从这些方法的功能可以知道这两个接口的重要性了。这两个接口的同一包下有一个类LoadBalancerAutoConfiguration。LoadBalancerAutoConfiguration在org.springframework.cloud.client.loadbalancer包下，在spring-cloud-commons里面。该自动配置类正式Ribbon的核心配置类。

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(RestTemplate.class)
@ConditionalOnBean(LoadBalancerClient.class)
@EnableConfigurationProperties(LoadBalancerRetryProperties.class)
public class LoadBalancerAutoConfiguration {

	@LoadBalanced
	@Autowired(required = false)
	private List<RestTemplate> restTemplates = Collections.emptyList();

	@Autowired(required = false)
	private List<LoadBalancerRequestTransformer> transformers = Collections.emptyList();

	@Bean
	public SmartInitializingSingleton loadBalancedRestTemplateInitializerDeprecated(
			final ObjectProvider<List<RestTemplateCustomizer>> restTemplateCustomizers) {
		return () -> restTemplateCustomizers.ifAvailable(customizers -> {
			for (RestTemplate restTemplate : LoadBalancerAutoConfiguration.this.restTemplates) {
				for (RestTemplateCustomizer customizer : customizers) {
					customizer.customize(restTemplate);
				}
			}
		});
	}

	@Bean
	@ConditionalOnMissingBean
	public LoadBalancerRequestFactory loadBalancerRequestFactory(
			LoadBalancerClient loadBalancerClient) {
		return new LoadBalancerRequestFactory(loadBalancerClient, this.transformers);
	}

	@Configuration(proxyBeanMethods = false)
	@ConditionalOnMissingClass("org.springframework.retry.support.RetryTemplate")
	static class LoadBalancerInterceptorConfig {

		@Bean
		public LoadBalancerInterceptor ribbonInterceptor(
				LoadBalancerClient loadBalancerClient,
				LoadBalancerRequestFactory requestFactory) {
			return new LoadBalancerInterceptor(loadBalancerClient, requestFactory);
		}

		@Bean
		@ConditionalOnMissingBean
		public RestTemplateCustomizer restTemplateCustomizer(
				final LoadBalancerInterceptor loadBalancerInterceptor) {
			return restTemplate -> {
				List<ClientHttpRequestInterceptor> list = new ArrayList<>(
						restTemplate.getInterceptors());
				list.add(loadBalancerInterceptor);
				restTemplate.setInterceptors(list);
			};
		}

	}

	/**
	 * Auto configuration for retry mechanism.
	 */
	@Configuration(proxyBeanMethods = false)
	@ConditionalOnClass(RetryTemplate.class)
	public static class RetryAutoConfiguration {

		@Bean
		@ConditionalOnMissingBean
		public LoadBalancedRetryFactory loadBalancedRetryFactory() {
			return new LoadBalancedRetryFactory() {
			};
		}

	}

	/**
	 * Auto configuration for retry intercepting mechanism.
	 */
	@Configuration(proxyBeanMethods = false)
	@ConditionalOnClass(RetryTemplate.class)
	public static class RetryInterceptorAutoConfiguration {

		@Bean
		@ConditionalOnMissingBean
		public RetryLoadBalancerInterceptor ribbonInterceptor(
				LoadBalancerClient loadBalancerClient,
				LoadBalancerRetryProperties properties,
				LoadBalancerRequestFactory requestFactory,
				LoadBalancedRetryFactory loadBalancedRetryFactory) {
			return new RetryLoadBalancerInterceptor(loadBalancerClient, properties,
					requestFactory, loadBalancedRetryFactory);
		}

		@Bean
		@ConditionalOnMissingBean
		public RestTemplateCustomizer restTemplateCustomizer(
				final RetryLoadBalancerInterceptor loadBalancerInterceptor) {
			return restTemplate -> {
				List<ClientHttpRequestInterceptor> list = new ArrayList<>(
						restTemplate.getInterceptors());
				list.add(loadBalancerInterceptor);
				restTemplate.setInterceptors(list);
			};
		}

	}

}

这就清晰起来了，他的配置加载时机是当前工程环境必须有RestTemplate的实例和必须初始化了LoadBalancerClient的实现类。

@ConditionalOnClass(RestTemplate.class)
@ConditionalOnBean(LoadBalancerClient.class)

LoadBalancerRequestFactory：用于创建LoadBalancerRequest给LoadBalancerInterceptor使用。

LoadBalancerInterceptorConfig：维护了LoadBalancerInterceptor与RestTemplateCustomizer的实例。

  • LoadBalancerInterceptor：拦截每一次的HTTP请求，将请求绑定金Ribbon的负载均衡的生命周期。
  • RestTemplateCustomizer：为每一个Restemplate绑定LoadBalancerInterceptor拦截器。

LoadBalancerInterceptor的作用已经和贴近答案了。

public class LoadBalancerInterceptor implements ClientHttpRequestInterceptor {

	private LoadBalancerClient loadBalancer;

	private LoadBalancerRequestFactory requestFactory;

	public LoadBalancerInterceptor(LoadBalancerClient loadBalancer,
			LoadBalancerRequestFactory requestFactory) {
		this.loadBalancer = loadBalancer;
		this.requestFactory = requestFactory;
	}

	public LoadBalancerInterceptor(LoadBalancerClient loadBalancer) {
		// for backwards compatibility
		this(loadBalancer, new LoadBalancerRequestFactory(loadBalancer));
	}

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

在源码可以看到它是通过ClientHttpRequestInterceptor实现每次对HTTP请求的拦截，ClientHttpRequestInterceptor类是Spring中维护的请求拦截器，实现它的intercept方法就可以使得请求进入方法内，从而Ribbon就可以做一些自己的处理了。

在使用RestTemplate请求服务时使用的URI：http://serviceName/path/to/service，通过getHost拿到服务名称serviceName。LoadBalancer有两个：RibbonLoadBalancerClient和BlockingLoadBalancerClient。这里只说RibbonLoadBalancerClient。

LoadBalancerInterceptor中的intercept方法，最终调用的是RibbonLoadBalancerClient的execute方法：

	public <T> T execute(String serviceId, LoadBalancerRequest<T> request, Object hint) throws IOException {
        // 拿到负载均衡器的实现
        ILoadBalancer loadBalancer = this.getLoadBalancer(serviceId);
        // 拿到具体的Server
        Server server = this.getServer(loadBalancer, hint);
        if (server == null) {
            throw new IllegalStateException("No instances available for " + serviceId);
        } else {
            RibbonLoadBalancerClient.RibbonServer ribbonServer = new RibbonLoadBalancerClient.RibbonServer(serviceId, server, this.isSecure(server, serviceId), this.serverIntrospector(serviceId).getMetadata(server));
            return this.execute(serviceId, (ServiceInstance)ribbonServer, (LoadBalancerRequest)request);
        }
    }
	protected Server getServer(ILoadBalancer loadBalancer, Object hint) {
        return loadBalancer == null ? null : loadBalancer.chooseServer(hint != null ? hint : "default");
    }

对于chooseServer是接口ILoadBalancer的方法，这里就先看一下其中的一个实现BaseLoadBalancer

	public Server chooseServer(Object key) {
        if (this.counter == null) {
            this.counter = this.createCounter();
        }

        this.counter.increment();
        if (this.rule == null) {
            return null;
        } else {
            try {
                return this.rule.choose(key);
            } catch (Exception var3) {
                logger.warn("LoadBalancer [{}]:  Error choosing server for key {}", new Object[]{this.name, key, var3});
                return null;
            }
        }
    }

最后是通过：rule.choose(key)拿到Server，而rule就是IRule。

在RibbonClientConfiguration中初始化了上面表格提到几个核心类

  1. 初始化ribbonRule: ZoneAvoidanceRule
  2. 初始化ribbonPing：DummyPing
  3. 初始化ribbonServerList：ConfigurationBasedServerList
  4. 初始化ServerListUpdater：new PollingServerListUpdater(config)
  5. 初始化ILoadBalancer：ZoneAwareLoadBalancer
  6. 初始化ribbonServerListFilter：ZonePreferenceServerListFilter
  7. 初始化ribbonLoadBalancerContext：RibbonLoadBalancerContext
  8. 初始化serverIntrospector：DefaultServerIntrospector

关于BlockingLoadBalancerClient：

Spring Cloud Hoxton.RELEASE 版本发布之后，新增了一个新的负载均衡器实现BlockingLoadBalancerClient。它是第一个包含阻塞式和非阻塞式负载均衡器客户端实现的版本，作为已进入维护模式的Netflix Ribbon的替代方案。

如果想在 RestTemplate使用新的 BlockingLoadBalancerClient, 需要增加 spring-cloud-loadbalancer 的依赖，否则默认使用RibbonLoadBalancerClient。

最后

可关注我的微信公众号
在这里插入图片描述

NullzzZ
关注
  • 20
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
html-neflix-who-watch
04-08
html-neflix-who-watch
Neflix Auto Skip Intro Button-crx插件
04-04
语言:English 在任何剧集中自动按Netflix上的“跳过”按钮
【SpringCloud】-Ribbon负载均衡实战及源码解析，如何结合Nacos
一起加油吧~
09-23 396
方式一：代码方式，定义随机策略import com} /*** @Description: 将RestTemplate注册到容器中} /*** @Description: 修改负载均衡策略方式} }} /*** @Description: 将RestTemplate注册到容器中} /*** @Description: 修改负载均衡策略方式} }IRule;
负载均衡Ribbon
qq_56187566的博客
11-07 331
ribbon负载均衡
【三】Spring Cloud Ribbon 实战
最新发布
作者：大头兵（kit）
04-22 882
首先Ribbon是基于如下核心接口实现的：图4、Ribbon核心接口这里只是展示一下核心接口，具体实现原理讲解起来篇幅将会太长不利于初学者学习，下一篇将会详细分析源码级实现原理。本文首先围绕ribbon的实际应用和实现原理两方面展开讲解，意在让大家能够快速了解这一负载均衡组件的使用和实现，如果想更深入了解ribbon的原理可以去把源码down下来认真学习。参考文章Spring Cloud Ribbon 中的 7 种负载均衡策略的实现方法_java_脚本之家。
微服务负载均衡器Ribbon实战
qq_36109477的博客
08-06 454
目前主流的负载均衡方式有两种：集中式负载均衡，在客户端和服务端中间建立一个独立的代理来做负载均衡，硬件比如F5;软件比如Nginx。 根据客户自己的情况做负载均衡，Ribbon 就属于这一种。Spring Cloud Ribbon是基于Netflix Ribbon 实现的一套客户端的负载均衡工具，Ribbon客户端组件提供一系列的完善的配置，如超时，重试等。通过Load Balancer获取到服务提供的所有机器实例，Ribbon会自动基于某种规则(轮询，随机)去调用这些服务。Ribbon也可以实现我们自己的
SpringCloud实战七：Spring Cloud Ribbon 实战
web13116256725的博客
08-25 200
前面的两篇博客已经讲解了Feign作为服务间的调用，但是Feign是集成、封装了Ribbonn这个组件而来的，让服务间的调用更方便，因此大多使用Feign，本篇让大家了解Ribbon的概念与调用Ribbon是Netflix开发的一个负载均衡组件，它在服务体系中起着重要作用，Pivotal将其整合成为Spring Cloud Ribbon，与其他SpringCloud组件结合可以发挥出强大作用，它的负载策略有多种，默认轮询，可配置超时重试。
Neflix文化自由与责任中文版.pptx
04-08
Neflix文化自由与责任中文版.pptx
Neflix自动跳过介绍按钮「Neflix Auto Skip Intro Button」-crx插件
03-15
在任何情况下，自动按下Netflix上的跳过按钮 支持语言:English
clone-netflix-dio:Netflix com教授Felipe Aguiar da Dio的界面研究-数字创新之一，HTML，CSS和JavaScript的专业知识
03-16
Neflix Recrie是HTML5，CSS3和JavaScript com教授Felipe Aguiar da Dio教授-Digital Innovation One的主要接口。 Nesse projeto estou colando empráticacoisas：como estruturar um布局，CSS3 com容器evariáveis...
SpringCloud【进阶】04：Ribbon实战教程
weixin_40964170的博客
03-12 464
1、Ribbon入门介绍 Spring Cloud Ribbon是基于Netflix Ribbon实现的一套客户端负载均衡的工具。 Ribbon = 负载均衡（@LoadBalanced） + RestTemplate调用 主要功能是提供客户端的软件负载均衡算法和服务调用。Ribbon客户端组件提供一系列完善的配置项如连接超时，重试等。 简单的说，就是在配置文件中列出Load Balancer(简称LB)后面所有的机器，Ribbon会自动的帮助你基于某种规则(如简单轮询，随机连接等）去连接这些机器。我们很容
Ribbon负载均衡（一）Ribbon实战
流浪的喵的博客
05-14 513
SpringCloud Ribbon 实战及Ribbon 负载均衡策略详解
五：微服务负载均衡器Ribbon
Xx__WangQi的博客
04-06 491
目录 1.什么是Ribbon 1.1 客户端的负载均衡 1.2 服务端的负载均衡 1.3 常见负载均衡算法 1.4 Ribbon模块 1.5 Ribbon使用 2. Spring Cloud快速整合Ribbon 2.1引入依赖 2.2添加@LoadBalanced注解 2.3修改controller 3. Ribbon内核原理 3.1 Ribbon原理 3.1.1 模拟ribbon实现 3.1.2 @LoadBalanced 注解原理 3.1.3 Ribbon相关接口...
Ribbon入门实战
三少说
10-15 824
8 Ribbon学习 8.1 什么是负载均衡（LB）？ 做web开发都会接触到负载均衡。 百度百科： 负载均衡，英文名称为Load Balance， 其含义就是指将负载（工作任务）进行平衡、分摊到多个操作单元上进行运行， 例如FTP服务器、Web服务器、企业核心应用服务器和其它主要任务服务器等， 从而协同完成工作任务。 负载均衡主要分为：软件负载（比如Nginx）和硬件负载（比如F5） 在微服务盛行的现在，软件负载在微服务里成为主流，Netflix的Ribbon就是其中之一 我们这里只关注软件负载，硬件负
Ribbon实战
猴子哥哥的博客
06-10 450
1、Ribbon简介 Ribbon是Netflix发布的负载均衡器，配合Eureka使用时，可自动从Eureka Server获取服务提供者地址列表，并基于负载均衡算法，请求其中一个服务提供者实例 2、使用Demo 1）引入Ribbon依赖 <dependency> <groupId>org.springframework.cloud</groupId> ...
springcloud微服务实战:Eureka+Zuul+Feign/Ribbon+Hystrix Turbine+SpringConfig+sleuth+zipkin
热门推荐
码农笔录-微信公众号博客
09-18 7万+
springcloud微服务实战:Eureka+Zuul+Feign/Ribbon+Hystrix Turbine+SpringConfig+sleuth+zipkin 相信现在已经有很多小伙伴已经或者准备使用springcloud微服务了，接下来为大家搭建一个微服务框架，后期可以自己进行扩展。会提供一个小案例： 服务提供者和服务消费者 ，消费者会调用提供者的服务，新建的项目都是用springb...
SpringCloud之Ribbon实战使用及源码实现
瘦子没有夏天
10-09 699
SpringCloud之Ribbon实战使用及源码实现 一、Ribbon概述 Ribbon与负载均衡 负载均衡（Load Balance），即利用特定方式将流量分摊到多个操作单元上的一种手段，它对系统吞吐量与系统处理能力有着质的提升，毫不夸张地说，当今极少有企业没有用到负载均衡器或是负载均衡策略的。我们提到负载均衡，往往第一个想到的就是Nginx，或许还会想到LVS，这些大家都不陌生，且不管它们的...
SpringCloud微服务实战之服务消费者Ribbon+RestTemplate
上善若水
12-20 7314
Eureka服务治理体系中有3个核心角色：服务注册中心、服务提供者、服务消费者。spring cloud的服务调用又分为两种方式：ribbon+RestTemplate和feign,本篇主要说的是ribbon+restTemplate方式。 Spring Cloud Ribbon是基于Http和Tcp协议的客户端负载均衡工具，基于Netflix Ribbon实现，它只是一个工具类，不需要独

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值