spring cloud ribbon load balancing strategy custom strategy dynamic configuration

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");
					// Determine if there is a service balancing strategy configured, if not, automatically select default
					if (ObjectUtils.isEmpty(rule) || rule.trim().length() < 1) {
						// If the default policy is not configured, it will be configured for WeightedResponseTimeRule by default
						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);
	}
}

The custom strategy class is used as the load balancing strategy entry for all services, and then dynamic switching between different balancing strategies between different services is performed through this class.