【源码品读】Ribbon可扩展性的研究-IRule机制

public interface IRule{
    /*
     * choose one alive server from lb.allServers or
     * lb.upServers according to key
     * 
     * @return choosen Server object. NULL is returned if none
     *  server is available 
     */

    public Server choose(Object key);
    
    public void setLoadBalancer(ILoadBalancer lb);
    
    public ILoadBalancer getLoadBalancer();    
}

public class RibbonClientConfiguration {

@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);
}

public String getClassName(Class clazz, String name) {
	if (this.classToProperty.containsKey(clazz)) {
		String classNameProperty = this.classToProperty.get(clazz);
		String className = environment
				.getProperty(name + "." + NAMESPACE + "." + classNameProperty);
		return className;
	}
	return null;
}

static final String NAMESPACE = "ribbon";

public <C> C get(Class<C> clazz, IClientConfig config, String name) {
	String className = getClassName(clazz, name);
	if (StringUtils.hasText(className)) {
		try {
			Class<?> toInstantiate = Class.forName(className);
			return (C) SpringClientFactory.instantiateWithConfig(toInstantiate,
					config);
		}
		catch (ClassNotFoundException e) {
			throw new IllegalArgumentException("Unknown class to load " + className
					+ " for class " + clazz + " named " + name);
		}
	}
	return null;
}

static <C> C instantiateWithConfig(Class<C> clazz, IClientConfig config) {
	return instantiateWithConfig(null, clazz, config);
}

static <C> C instantiateWithConfig(AnnotationConfigApplicationContext context,
		Class<C> clazz, IClientConfig config) {
	C result = null;

	try {
		Constructor<C> constructor = clazz.getConstructor(IClientConfig.class);
		result = constructor.newInstance(config);
	}
	catch (Throwable e) {
		// Ignored
	}

	if (result == null) {
		result = BeanUtils.instantiate(clazz);

		if (result instanceof IClientConfigAware) {
			((IClientConfigAware) result).initWithNiwsConfig(config);
		}

		if (context != null) {
			context.getAutowireCapableBeanFactory().autowireBean(result);
		}
	}

	return result;
}

public static <T> T instantiate(Class<T> clazz) throws BeanInstantiationException {
	Assert.notNull(clazz, "Class must not be null");
	if (clazz.isInterface()) {
		throw new BeanInstantiationException(clazz, "Specified class is an interface");
	}
	try {
		return clazz.newInstance();
	}
	catch (InstantiationException ex) {
		throw new BeanInstantiationException(clazz, "Is it an abstract class?", ex);
	}
	catch (IllegalAccessException ex) {
		throw new BeanInstantiationException(clazz, "Is the constructor accessible?", ex);
	}
}

public ZoneAwareLoadBalancer(IClientConfig clientConfig, IRule rule,
							 IPing ping, ServerList<T> serverList, ServerListFilter<T> filter,
							 ServerListUpdater serverListUpdater) {
	super(clientConfig, rule, ping, serverList, filter, serverListUpdater);
}

public DynamicServerListLoadBalancer(IClientConfig clientConfig, IRule rule, IPing ping,
									 ServerList<T> serverList, ServerListFilter<T> filter,
									 ServerListUpdater serverListUpdater) {
	super(clientConfig, rule, ping);
	this.serverListImpl = serverList;
	this.filter = filter;
	this.serverListUpdater = serverListUpdater;
	if (filter instanceof AbstractServerListFilter) {
		((AbstractServerListFilter) filter).setLoadBalancerStats(getLoadBalancerStats());
	}
	restOfInit(clientConfig);
}

public abstract class AbstractLoadBalancerRule implements IRule, IClientConfigAware {

    private ILoadBalancer lb;
        
    @Override
    public void setLoadBalancer(ILoadBalancer lb){
        this.lb = lb;
    }
    
    @Override
    public ILoadBalancer getLoadBalancer(){
        return lb;
    }      
}