[享学Netflix] 五十七、Ribbon负载均衡器ILoadBalancer（二）：ZoneAwareLoadBalancer具备区域意识、动态服务列表的负载均衡器

public class DynamicServerListLoadBalancer<T extends Server> extends BaseLoadBalancer {

	// 这两个属性木有任何用处，也不知道是不是开发人员忘记删了  哈哈
	boolean isSecure = false;
	boolean useTunnel = false;
	
    protected AtomicBoolean serverListUpdateInProgress = new AtomicBoolean(false);
    volatile ServerList<T> serverListImpl;
    volatile ServerListFilter<T> filter;
    protected final ServerListUpdater.UpdateAction updateAction = () -> updateListOfServers();
    protected volatile ServerListUpdater serverListUpdater;
}

DynamicServerListLoadBalancer：

    void restOfInit(IClientConfig clientConfig) {
    	...
        updateListOfServers();
        // ~~~~~update之后马上进行首次连接~~~~~
        if (primeConnection && this.getPrimeConnections() != null) {
            this.getPrimeConnections().primeConnections(getReachableServers());
        }
        ...
    }

DynamicServerListLoadBalancer：

    public void updateListOfServers() {
        List<T> servers = new ArrayList<T>();
        if (serverListImpl != null) {
            servers = serverListImpl.getUpdatedListOfServers();
            if (filter != null) {
                servers = filter.getFilteredListOfServers(servers);
            }
        }
        updateAllServerList(servers);
    }
	
	// 该方法作用：能保证同一时间只有一个线程可以进来做修改动作~~~
	// 把准备好的Servers更新到列表里。该方法是protected，子类并无复写
	// 但是，但是，但是setServersList()方法子类是有复写的哦
    protected void updateAllServerList(List<T> ls) {
        if (serverListUpdateInProgress.compareAndSet(false, true)) {
            try {
            	// 显示标注Server均是活的（至于真活假活交给forceQuickPing()去判断）
                for (T s : ls) {
                    s.setAlive(true); 
                }
                setServersList(ls);
                super.forceQuickPing();
            } finally {
                serverListUpdateInProgress.set(false);
            }
        }
    }

DynamicServerListLoadBalancer：

    @Override
    public void setServersList(List lsrv) {
        super.setServersList(lsrv);
        List<T> serverList = (List<T>) lsrv;
        Map<String, List<Server>> serversInZones = new HashMap<String, List<Server>>();
        for (Server server : serverList) {
        	// 调用这句的作用：确保初始化的时候就把ServerStats创建好
            getLoadBalancerStats().getSingleServerStat(server);

			// 把Server们按照zone进行分类，最终放到LoadBalancerStats.upServerListZoneMap属性里面去
            String zone = server.getZone();
            if (zone != null) {
                zone = zone.toLowerCase();
                List<Server> servers = serversInZones.get(zone);
                if (servers == null) {
                    servers = new ArrayList<Server>();
                    serversInZones.put(zone, servers);
                }
                servers.add(server);
            }
        }
        // 该方法父类实现很简单：getLoadBalancerStats().updateZoneServerMapping(zoneServersMap)
        //子类有复写哦
        setServerListForZones(serversInZones);
    }

ublic class ZoneAwareLoadBalancer<T extends Server> extends DynamicServerListLoadBalancer<T> {

	private static final DynamicBooleanProperty ENABLED = DynamicPropertyFactory.getInstance().getBooleanProperty("ZoneAwareNIWSDiscoveryLoadBalancer.enabled", true);
	private ConcurrentHashMap<String, BaseLoadBalancer> balancers = new ConcurrentHashMap<String, BaseLoadBalancer>();
    private volatile DynamicDoubleProperty triggeringLoad;
    private volatile DynamicDoubleProperty triggeringBlackoutPercentage; 
}

DynamicServerListLoadBalancer：

    protected void setServerListForZones(Map<String, List<Server>> zoneServersMap) {
        getLoadBalancerStats().updateZoneServerMapping(zoneServersMap);
    }

ZoneAwareLoadBalancer：

    @Override
    protected void setServerListForZones(Map<String, List<Server>> zoneServersMap) {
    	// 完成父类的赋值~~~~~
        super.setServerListForZones(zoneServersMap);
        if (balancers == null) {
            balancers = new ConcurrentHashMap<String, BaseLoadBalancer>();
        }
        
        // getLoadBalancer(zone)的意思是获得指定zone所属的负载均衡器
        // 这个意思是给每个LB设置它所管理的服务列表
        for (Map.Entry<String, List<Server>> entry: zoneServersMap.entrySet()) {
        	String zone = entry.getKey().toLowerCase();
            getLoadBalancer(zone).setServersList(entry.getValue());
        }
        
		// 这一步属一个小优化：若指定zone不存在了（木有机器了），就把balancers对应zone的机器置空
        for (Map.Entry<String, BaseLoadBalancer> existingLBEntry: balancers.entrySet()) {
            if (!zoneServersMap.keySet().contains(existingLBEntry.getKey())) {
                existingLBEntry.getValue().setServersList(Collections.emptyList());
            }
        }
    }

ZoneAwareLoadBalancer：

    BaseLoadBalancer getLoadBalancer(String zone) {
        zone = zone.toLowerCase();
        BaseLoadBalancer loadBalancer = balancers.get(zone);
        if (loadBalancer == null) {
        	// ~~~~~~~~为每个zone都指定一个独立的IRule实例~~~~~~~~
        	IRule rule = cloneRule(this.getRule());
            loadBalancer = new BaseLoadBalancer(this.getName() + "_" + zone, rule, this.getLoadBalancerStats());
            BaseLoadBalancer prev = balancers.putIfAbsent(zone, loadBalancer);
            if (prev != null) {
            	loadBalancer = prev;
            }
        } 
        return loadBalancer; 
    }

ZoneAwareLoadBalancer：

    @Override
    public Server chooseServer(Object key) {
    	// 如果禁用了区域意识。或者只有一个zone，那就遵照父类逻辑
        if (!ENABLED.get() || getLoadBalancerStats().getAvailableZones().size() <= 1) {
            return super.chooseServer(key);
        }

        Server server = null;
        try {
            LoadBalancerStats lbStats = getLoadBalancerStats();
			...     		
			// 核心方法：根据triggeringLoad等阈值计算出可用区~~~~
            Set<String> availableZones = ZoneAvoidanceRule.getAvailableZones(zoneSnapshot, triggeringLoad.get(), triggeringBlackoutPercentage.get());
            if (availableZones != null &&  availableZones.size() < zoneSnapshot.keySet().size()) {
			
				// 从可用区里随机选择一个区域（zone里面机器越多，被选中概率越大）
                String zone = ZoneAvoidanceRule.randomChooseZone(zoneSnapshot, availableZones);
                if (zone != null) {
                    BaseLoadBalancer zoneLoadBalancer = getLoadBalancer(zone);
                    // 按照IRule从该zone内选择一台Server出来
                    server = zoneLoadBalancer.chooseServer(key);
                }
            }
        } catch (Exception e) {
            logger.error("Error choosing server using zone aware logic for load balancer={}", name, e);
        }
        if (server != null) {
            return server;
        } else {
        	// 回退到父类逻辑~~~兜底
            return super.chooseServer(key);
        }
    }