SpringCloud学习笔记(黑马)(二)——ribbon组件

负载均衡原理

负载均衡流程

源码

1.LoadBalancerInterceptor

public ClientHttpResponse intercept(final HttpRequest request, final byte[] body, final ClientHttpRequestExecution execution) throws IOException {
		//1.获取请求地址
        URI originalUri = request.getURI();
        //2.获取服务提供者的主机名
        String serviceName = originalUri.getHost();
        Assert.state(serviceName != null, "Request URI does not contain a valid hostname: " + originalUri);
        //3.执行获取返回的数据
        return (ClientHttpResponse)this.loadBalancer.execute(serviceName, this.requestFactory.createRequest(request, body, execution));
}

2.RibbonLoadBalancerClient

 public <T> T execute(String serviceId, LoadBalancerRequest<T> request, Object hint) throws IOException {
 		//1.根据服务名称从注册中心中获取该服务的服务列表
        ILoadBalancer loadBalancer = this.getLoadBalancer(serviceId);
        //2.从服务列表中根据负载均衡策略选择一个服务提供者
        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));
            //3.返回执行结果
            return this.execute(serviceId, (ServiceInstance)ribbonServer, (LoadBalancerRequest)request);
        }
 }

3.RibbonLoadBalancerClient

protected Server getServer(ILoadBalancer loadBalancer, Object hint) {
        return loadBalancer == null ? null : loadBalancer.chooseServer(hint != null ? hint : "default");
}

4.ZoneAwareLoadBalancer

public Server chooseServer(Object key) {
        if (ENABLED.get() && this.getLoadBalancerStats().getAvailableZones().size() > 1) {
            Server server = null;

            try {
                LoadBalancerStats lbStats = this.getLoadBalancerStats();
                Map<String, ZoneSnapshot> zoneSnapshot = ZoneAvoidanceRule.createSnapshot(lbStats);
                logger.debug("Zone snapshots: {}", zoneSnapshot);
                if (this.triggeringLoad == null) {
                    this.triggeringLoad = DynamicPropertyFactory.getInstance().getDoubleProperty("ZoneAwareNIWSDiscoveryLoadBalancer." + this.getName() + ".triggeringLoadPerServerThreshold", 0.2D);
                }

                if (this.triggeringBlackoutPercentage == null) {
                    this.triggeringBlackoutPercentage = DynamicPropertyFactory.getInstance().getDoubleProperty("ZoneAwareNIWSDiscoveryLoadBalancer." + this.getName() + ".avoidZoneWithBlackoutPercetage", 0.99999D);
                }

                Set<String> availableZones = ZoneAvoidanceRule.getAvailableZones(zoneSnapshot, this.triggeringLoad.get(), this.triggeringBlackoutPercentage.get());
                logger.debug("Available zones: {}", availableZones);
                if (availableZones != null && availableZones.size() < zoneSnapshot.keySet().size()) {
                    String zone = ZoneAvoidanceRule.randomChooseZone(zoneSnapshot, availableZones);
                    logger.debug("Zone chosen: {}", zone);
                    if (zone != null) {
                        BaseLoadBalancer zoneLoadBalancer = this.getLoadBalancer(zone);
                        server = zoneLoadBalancer.chooseServer(key);
                    }
                }
            } catch (Exception var8) {
                logger.error("Error choosing server using zone aware logic for load balancer={}", this.name, var8);
            }

            if (server != null) {
                return server;
            } else {
                logger.debug("Zone avoidance logic is not invoked.");
                return super.chooseServer(key);
            }
        } else {
            logger.debug("Zone aware logic disabled or there is only one zone");
            return super.chooseServer(key);
        }
    }

5.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 {
            	//根据负载均衡的策略选择一个服务，rule是一个负载均衡则略
                return this.rule.choose(key);
            } catch (Exception var3) {
                logger.warn("LoadBalancer [{}]:  Error choosing server for key {}", new Object[]{this.name, key, var3});
                return null;
            }
        }
    }

负载均衡策略

修改负载均衡规则

方法一

在应用中注册一个规则

//轮询规则
@Bean
public IRule rule(){
    return new RoundRobinRule();
}

方法二

在配置文件中配置,只针对一个微服务而言格式为：服务名.ribbon.NFLoad…

service-user.ribbon.NFLoadBalancerRuleClassName=com.netflix.loadbalancer.RandomRule

饥饿加载

ribbon组件默认是第一次发起http请求的时候才会初始化，这样第一次请求的时候就会增加请求时间，我们可以在应用初始化的时候就加载ribbon

# 启用饥饿加载
ribbon.eager-load.enabled=true
# 对service-user服务饥饿加载
ribbon.eager-load.clients=service-user