Spring Cloud （二）负载均衡-Ribbon

  1. Ribbon简介
    Ribbon是Netfix公司开源负载均衡组件，负载均衡是分布式系统高可用、缓解网络压力的重要手段；负载均衡分为硬件负载均衡和软件负载均衡：
  • 硬件负载均衡：在服务器间挂载负载均衡的设备，以提供负载均衡的功能
  • 软件负载均衡：通过逻辑代码将HTTP或者TCP请求进行转发，达到负载均衡的功能

Ribbon就是通过软件达到负载均衡的功能，Ribbon客户端加载负载均衡的组件以满足HTTP和TCP请求转发的功能。客户端需要达到负载均衡的功能就必须和注册中心合作（EUREKA）；

将RestTemplate和 Ribbon中的@LoadBalanced结合起来就可以实现客户端负载均衡的功能；

  1. RestTemplate简介
    RestTemplate是消费REST服务的网络请求框架，提供消费常见HTTP协议的方法，如GET、POST、DELETE、PUT...

  2. Ribbon 实现负载均衡
    3.1 RestTemplate加入@LoadBalanced

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

3.2 使用LoadBalancerClient获取服务列表

@RestController
@Slf4j
public class InfoController {

    @Autowired
    private RestTemplate restTemplate;
    @Autowired
    private LoadBalancerClient loadBalancerClient;

    @GetMapping("users/{id}")
    public User getUserOrder(@PathVariable("id") Long id){
        ServiceInstance serviceInstance = loadBalancerClient.choose("user-service");
        log.info("{}:{}:{}",serviceInstance.getServiceId(),serviceInstance.getHost(),serviceInstance.getPort());
        return restTemplate.getForEntity("http://user-service/users/"+id,User.class).getBody();
    }
}

3.3 网页访问http://localhost:8891/user1/2,会根据默认的负载均衡规则选择不同的服务，下街详细介绍Ribbon的负责均衡的规则。

image.png

  1. 阐述Ribbon工作流程
    4.1 我们从根源LoadBalancerClient入手，我们先看看它的类结构图；


    image.png

我们在demo中使用loadBalancerClient.choose("user-service"); 所以我们在RibbonLoadBalancerClient类中查看choose方法；

public ServiceInstance choose(String serviceId, Object hint) {
        Server server = getServer(getLoadBalancer(serviceId), hint);
        if (server == null) {
            return null;
        }
        return new RibbonServer(serviceId, server, isSecure(server, serviceId),
                serverIntrospector(serviceId).getMetadata(server));
    }

此方法返回一个ServiceInstance对象，得到根据负载均衡规则得到的服务,看到这里好像只得到负载均衡的服务并没什么关于RestTemplate负载均衡调用服务；
这时突然想到我们注入RestTemplate时加入了@LoadBalanced注解，我们先看看注解；

@Target({ ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Qualifier  //画重点很重要
public @interface LoadBalanced {

}

从注解的众多声明中，有一个@Qualifier在这里尤为重要；这时我们全文搜索@LoadBalanced，发现LoadBalancerAutoConfiguration类中用@LoadBalanced注解维护了一个RestTemplate的列表；

@LoadBalanced
    @Autowired(required = false)
    private List<RestTemplate> restTemplates = 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);
                }
            }
        });
    }

这段代码将标注了@LoadBalanced注解的RestTemplate注入（这就是说刚才那个@Qualifier很重要的原因了，因为@LoadBalanced加入@Qualifier才具备注入的功能）

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

这段代码将注入的RestTemplate增加了一个拦截器，此拦截器就是实现负载均衡的关键，打开loadBalancerInterceptor中的intercept方法；

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

这段代码清晰的表明，restTemplate发起的请求被拦截后交给了LoadBalancerClient处理，继而交给ILoadBalance去根据配置（这里先叫配置，等会详解）去选择对应的服务；

protected Server getServer(ILoadBalancer loadBalancer, Object hint) {
        if (loadBalancer == null) {
            return null;
        }
        // Use 'default' on a null hint, or just pass it on?
        return loadBalancer.chooseServer(hint != null ? hint : "default");
    }

所以这里我们又要去找ILoadBalance的源码了.，老规矩先看看类结构图；


image.png
public interface ILoadBalancer {
    public void addServers(List<Server> newServers);
    public Server chooseServer(Object key);
    public void markServerDown(Server server);
    public List<Server> getServerList(boolean availableOnly);
    public List<Server> getReachableServers();
    public List<Server> getAllServers();
}

该接口中定义了一个chooseServer方法，来返回服务,我们在BaseLoadBalancer中看它的实现；有代码不难看出根据负载均衡的规则选择服务。

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

这里就探究IRule的详细规则。

  • RoundRobinRule：轮询
  • RandomRule:随机
  • AvailabilityFilteringRule:过滤不可用服务，再做轮询
  • WeightedResponseTimeRule：根据权重来选择响应时间最小的服务
  • RetryRule：轮询加重试机制
  • BestAvailableRule：并发量最小的服务
  • ZoneAvoidanceRule：复合判断server所在区域的性能和server的可用性选择server
    下面贴上修改Ribbon默认IRule的代码。
    定义随机选择的Bean
@Configuration
class ExcludeConfigBean{
    @Bean
    public IRule getIRule(){
        return new RandomRule();
    }
}

避免你定义的规则被@ComponentScan扫描，会被RibbonClient共享从而冲突，所以需要排序此Bean被扫描。

@SpringBootApplication(exclude= {DataSourceAutoConfiguration.class})
@EnableDiscoveryClient
@ComponentScan(basePackages = {"com.ybb"}, excludeFilters = @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes = {ExcludeConfigBean.class}))
@RibbonClient(name= "user-service",    configuration = RandomRule.class)
public class ConsumerApplication {

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

}

代码运行结果请求两个服务是没有任何规律的，如图：


image.png
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容