Ribbon负载均衡

工程版本

2.2.6.RELEASE
2.2.1.RELEASE
Hoxton.SR4

代码示例

@Autowired
private LoadBalancerClient loadBalancerClient;

@RequestMapping(value = "/test/{str}", method = RequestMethod.GET)
public String echo(@PathVariable String str) {
    // 利用 LoadBalancerClient 通过应用名称获取URL，然后再使用 RestTemplate，
    // 如果有多个应用，会采取负载均衡策略来选择不同的应用
    ServiceInstance serviceInstance = loadBalancerClient.choose("app-provider");
    if (serviceInstance != null) {
        String url = String.format(
            "http://%s:%s",
            serviceInstance.getHost(),
            serviceInstance.getPort()) + "/app/" + str;
        System.out.println("请求地址:" + url);
        RestTemplate restTemplate = new RestTemplate();
        String response = restTemplate.getForObject(url,String.class);
        return response;
    }
    return null;
}

LoadBalancerClient是SpringCloud提供的接口，它是一个负载均衡客户端。

流程分析

LoadBalancerClient

这是一个负载均衡客户端，可以通过服务名获取服务实例信息，如果存在多个服务实例，则可以采取负载均衡策略来获取一个。

// org.springframework.cloud.client.loadbalancer
public interface LoadBalancerClient extends ServiceInstanceChooser {
    // 省略......
}
public interface ServiceInstanceChooser {
    // 根据传入的serviceId，从负载均衡器中挑选一个实例
	ServiceInstance choose(String serviceId);
}

RibbonLoadBalancerClient

RibbonLoadBalancerClient实现了LoadBalancerClient接口

主要分析choose(String serviceId)方法

public class RibbonLoadBalancerClient implements LoadBalancerClient {
    // 从这里开始
    // 通过服务名获取一个服务信息
    @Override
	public ServiceInstance choose(String serviceId) {
		return choose(serviceId, null);
	}
    
    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));
	}
    // 通过ILoadBalancer.chooseServer(Object key)来获取服务实例
    protected Server getServer(ILoadBalancer loadBalancer, Object hint) {
		if (loadBalancer == null) {
			return null;
		}
		// 这里使用 ILoadBalancer 获取服务实例
        // ILoadBalancer 里面采用 IRule 获取单个服务实例
		return loadBalancer.chooseServer(hint != null ? hint : "default");
	}
    // 根据 serviceId 获取 ILoadBalancer
    protected ILoadBalancer getLoadBalancer(String serviceId) {
		return this.clientFactory.getLoadBalancer(serviceId);
	}
}

从上面getServer(ILoadBalancer loadBalancer, Object hint)方法可以发现，LoadBalancerClient是利用ILoadBalancer.chooseServer(Object key)来获取服务信息的，ILoadBalancer是一个负载均衡器，它的子类BaseLoadBalancer里面维护了服务实例列表，它的子类DynamicServerListLoadBalancer实现了服务列表的获取与定时刷新，每一个服务名都有一个对应的ILoadBalancer实例。后面再分析如何获取ILoadBalancer实例。ILoadBalancer接口是Ribbon的，所以SpringCloud的负载均衡是基于Ribbon来实现的。

由RibbonClientConfiguration配置类可以知道，ILoadBalancer默认使用的是ZoneAwareLoadBalancer，

@Bean
	@ConditionalOnMissingBean
	public ILoadBalancer ribbonLoadBalancer(IClientConfig config,
			ServerList<Server> serverList, ServerListFilter<Server> serverListFilter,
			IRule rule, IPing ping, ServerListUpdater serverListUpdater) {
		if (this.propertiesFactory.isSet(ILoadBalancer.class, name)) {
			return this.propertiesFactory.get(ILoadBalancer.class, config, name);
		}
		return new ZoneAwareLoadBalancer<>(config, rule, ping, serverList,
				serverListFilter, serverListUpdater);
	}	

ZoneAwareLoadBalancer重写了BaseLoadBalancer.chooseServer(Object key)方法，但由于默认情况下没有使用Zone的概念，因此它还是会调用BaseLoadBalancer.chooseServer(Object key)方法。

public class BaseLoadBalancer extends AbstractLoadBalancer implements
        PrimeConnections.PrimeConnectionListener, IClientConfigAware {
    public Server chooseServer(Object key) {
        if (counter == null) {
            counter = createCounter();
        }
        counter.increment();
        if (rule == null) {
            return null;
        } else {
            try {
                // 这里根据 IRule 来获取合适的服务
                return rule.choose(key);
            } catch (Exception e) {
                
                return null;
            }
        }
    }
}    

IRule

// com.netflix.loadbalancer.IRule
public interface IRule{
    // 从 ILoadBalancer 获取一个可用的服务实例
    // 这里的key一般是指服务名
    public Server choose(Object key);
    
    public void setLoadBalancer(ILoadBalancer lb);
    
    public ILoadBalancer getLoadBalancer();    
}

由RibbonClientConfiguration配置类可以知道，IRule默认使用的是ZoneAvoidanceRule

@Bean
@ConditionalOnMissingBean
public IRule ribbonRule(IClientConfig config) {
    if (this.propertiesFactory.isSet(IRule.class, name)) {
        return this.propertiesFactory.get(IRule.class, config, name);
    }
    ZoneAvoidanceRule rule = new ZoneAvoidanceRule();
    rule.initWithNiwsConfig(config);
    return rule;
}

ZoneAvoidanceRule采用轮训策略来实现负载均衡，这个规则也是会根据Zone进行过滤然后再采取轮训策略。

Ribbon中共提供了很多负载均衡的策略实现，如轮训策略com.netflix.loadbalancer.RoundRobinRule、随机策略com.netflix.loadbalancer.RandomRule。

以轮训策略为例，如下所示

RoundRobinRule

public class RoundRobinRule extends AbstractLoadBalancerRule {
    // 这是一个计数器，每调用一次就会加1
    private AtomicInteger nextServerCyclicCounter;

    public RoundRobinRule() {
        nextServerCyclicCounter = new AtomicInteger(0);
    }

    public RoundRobinRule(ILoadBalancer lb) {
        this();
        setLoadBalancer(lb);
    }
    
    // 这个是实现 IRule 接口的方法
    @Override
    public Server choose(Object key) {
        return choose(getLoadBalancer(), key);
    }
    
    // 这里是具体实现
    public Server choose(ILoadBalancer lb, Object key) {
        if (lb == null) {
            log.warn("no load balancer");
            return null;
        }

        Server server = null;
        int count = 0;
        while (server == null && count++ < 10) {
            // 获取可用服务列表
            List<Server> reachableServers = lb.getReachableServers();
            // 获取所有服务列表
            List<Server> allServers = lb.getAllServers();
            
            int upCount = reachableServers.size();
            int serverCount = allServers.size();

            if ((upCount == 0) || (serverCount == 0)) {
                log.warn("No up servers available from load balancer: " + lb);
                return null;
            }
            // 获取下一个服务列表的索引下标
            // 主要是原理是(extServerCyclicCounter+1)%serverCount
            int nextServerIndex = incrementAndGetModulo(serverCount);
            // 从服务列表中获取一个服务
            server = allServers.get(nextServerIndex);

            if (server == null) {
                /* Transient. */
                Thread.yield();
                continue;
            }
            // 如果服务是可用的，则直接返回
            if (server.isAlive() && (server.isReadyToServe())) {
                return (server);
            }
            // 如果服务不可用，则继续轮训。可以发现，这里最多轮训十次
            // Next.
            server = null;
        }

        if (count >= 10) {
            log.warn("No available alive servers after 10 tries from load balancer: "
                    + lb);
        }
        return server;
    }
    
    // 获取服务索引下标的方法
    private int incrementAndGetModulo(int modulo) {
        for (;;) {
            int current = nextServerCyclicCounter.get();
            int next = (current + 1) % modulo;
            if (nextServerCyclicCounter.compareAndSet(current, next))
                return next;
        }
    }

    @Override
    public void initWithNiwsConfig(IClientConfig clientConfig) {
        
    }
}

可以发现，如果我们想要自定义一个负载均衡策略类，只需要实现抽象类AbstractLoadBalancerRule就可以了，然后再更改负载均衡策略来使用自定义的负载均衡。

更该负载均衡策略

当我们需要修改负载均衡策略时，需要使用@RibbonClient注解来配置，如下所示。

@RibbonClient(name = "app-provider", configuration = {MyRibbonRule.class})

@Configuration
public class MyRibbonRule {
    @Bean
    IRule myRule() {
        return new RandomRule();
    }
}

需要注意的是，MyRibbonRule这个类不能放在启动类所有包及其子包下面，否则就会使得所有的客户端都采用这里面的负载均衡策略。

当我们在获取服务名为app-provider服务的时候，它就会使用随机策略，而其它服务还是会采用默认策略。