spring cloud ribbon负载均衡策略自定义策略动态配置

package com.sunline.sunflow.consumer.rule;


import java.lang.reflect.Method;
import java.util.List;
import java.util.Map;


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.ObjectUtils;


import com.google.gson.Gson;
import com.netflix.client.config.IClientConfig;
import com.netflix.loadbalancer.AbstractLoadBalancerRule;
import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.Server;
import com.sunline.sunflow.consumer.common.CacheMgr;
import com.sunline.sunflow.consumer.common.DefaultRuleChooseServer;
import com.sunline.sunflow.consumer.enums.DefaultRibbonRule;


public class MyRule extends AbstractLoadBalancerRule {


	private final Logger logger = LoggerFactory.getLogger(getClass());


	
	public Server choose(ILoadBalancer lb, Object key) {
		Server chooseServer = null;
		try {
			System.out.println("-------------------------------------------------------------------------------");
			List<Server> allServers = lb.getAllServers();
			List<Server> upServers = lb.getReachableServers();
			if (null == allServers || allServers.isEmpty()) {
				return null;
			}
			if (allServers.size() < 2) {


				return upServers.get(0);
			}
			Server server = allServers.get(0);
			String clientName = server.getMetaInfo().getAppName();
			CacheMgr cacheMgr = CacheMgr.getInstance();
			Gson gson = new Gson();
			@SuppressWarnings("unchecked")
			Map<String, Map<String, String>> ribbonRule = gson.fromJson((String) cacheMgr.getValue("ribbonRule"),
					Map.class);
			for (String nameKey : ribbonRule.keySet()) {
				if (clientName.equals(nameKey)) {
					String rule = ribbonRule.get(nameKey).get("rule");
					String defaultRule = ribbonRule.get(nameKey).get("default");
					// 判断是否有配置服务均衡策略 如果没有则自动选择default
					if (ObjectUtils.isEmpty(rule) || rule.trim().length() < 1) {
						// 如果连默认策略也没配置 则默认给WeightedResponseTimeRule配置
						if (ObjectUtils.isEmpty(defaultRule) || defaultRule.trim().length() < 1) {
							System.out.println();
							chooseServer = getDefalutRuletChooseServer(lb, key, "WEIGHTED_RESPONSE_TIME_RULE");
							logger.info("默认WEIGHTED_RESPONSE_TIME_RULE--------------------->:{}",
									chooseServer.getPort());
							return chooseServer;
						} else {
							chooseServer = getDefalutRuletChooseServer(lb, key, defaultRule);
							logger.info("默认" + defaultRule + "-------------------->:{}", chooseServer.getPort());
							return chooseServer;
						}
					} else {
						try {
							Class<?> clazz = Class.forName(rule);
							Class[] types = { ILoadBalancer.class, Object.class };
							Method m = clazz.getDeclaredMethod("choose", types);
							chooseServer = (Server) m.invoke(clazz.newInstance(), lb, key);
							logger.info("自定义" + rule + "-------------------->:{}", chooseServer.getPort());
							return chooseServer;
						} catch (Exception e) {
							logger.error("MyRule:", e);
						}
					}
				}


			} 
		} catch (Exception e) {
			logger.error("MyRule:", e);
		}
		chooseServer= getDefalutRuletChooseServer(lb, key, "WEIGHTED_RESPONSE_TIME_RULE");
		return chooseServer;
	}


	@Override
	public Server choose(Object key) {
		// TODO Auto-generated method stub
		return choose(getLoadBalancer(), key);
	}


	@Override
	public void initWithNiwsConfig(IClientConfig clientConfig) {
	}


	public Server getDefalutRuletChooseServer(ILoadBalancer lb, Object key, String defaultRule) {
		return new DefaultRuleChooseServer().choose(lb, key, defaultRule);
	}
}

该自定义策略类作为所有服务的负载均衡策略入口，然后再经过该类进行不同服务之间不同均衡策略的动态切换