• 关于divide插件
• divide插件负载均衡实现
• divide插件ip端口探活
• 总结

关于divide插件

divide插件是进行http类型请求处理的插件。所有http类型的请求都是经过divide插件进行负载均衡运行的。

在前面文章中有介绍SoulWebHandler, 这里重申一下，当有相应的http请求时，在SoulWebHandler中会处理请求。同时也会根据不同的负载均衡算法，进行相应的转发请求。当然在soul-admin端，也会有相应的任务来检测缓存中是否有下线。

divide插件负载均衡

• RandomLoadBalance：性能高，均衡性差一些
• RoundRobinLoadBalance：性能相对于随机差一些，但均衡性好
• 一致性Hash（基于MD5）：由HashLoadBalance实现

配置路径：org.dromara.soul.plugin.divide.balance.spi.LoadBalance

配置内容：

hash=org.dromara.soul.plugin.divide.balance.spi.HashLoadBalance 
random=org.dromara.soul.plugin.divide.balance.spi.RandomLoadBalance 
roundRobin=org.dromara.soul.plugin.divide.balance.spi.RoundRobinLoadBalance 

负载均衡调用处理位置：

public class DividePlugin extends AbstractSoulPlugin {
    
    @Override 
    protected Mono<Void> doExecute(final ServerWebExchange exchange, final SoulPluginChain chain, final SelectorData selector, final RuleData rule) {
    
        final SoulContext soulContext = exchange.getAttribute(Constants.CONTEXT); 
        assert soulContext != null; 
        final DivideRuleHandle ruleHandle = GsonUtils.getInstance().fromJson(rule.getHandle(), DivideRuleHandle.class); 
        final List<DivideUpstream> upstreamList = UpstreamCacheManager.getInstance().findUpstreamListBySelectorId(selector.getId()); 
        if (CollectionUtils.isEmpty(upstreamList)) {
    
            log.error("divide upstream configuration error： {}", rule.toString()); 
            Object error = SoulResultWrap.error(SoulResultEnum.CANNOT_FIND_URL.getCode(), SoulResultEnum.CANNOT_FIND_URL.getMsg(), null); 
            return WebFluxResultUtils.result(exchange, error); 
        } 
        final String ip = Objects.requireNonNull(exchange.getRequest().getRemoteAddress()).getAddress().getHostAddress(); 
        // 根据传入的ruleHandler来选择相应的loadbalance，默认是hashLoadBalance 
        DivideUpstream divideUpstream = LoadBalanceUtils.selector(upstreamList, ruleHandle.getLoadBalance(), ip); 
        if (Objects.isNull(divideUpstream)) {
    
            log.error("divide has no upstream"); 
            Object error = SoulResultWrap.error(SoulResultEnum.CANNOT_FIND_URL.getCode(), SoulResultEnum.CANNOT_FIND_URL.getMsg(), null); 
            return WebFluxResultUtils.result(exchange, error); 
        } 
        // set the http url 
        String domain = buildDomain(divideUpstream); 
        String realURL = buildRealURL(domain, soulContext, exchange); 
        exchange.getAttributes().put(Constants.HTTP_URL, realURL); 
        // set the http timeout 
        exchange.getAttributes().put(Constants.HTTP_TIME_OUT, ruleHandle.getTimeout()); 
        exchange.getAttributes().put(Constants.HTTP_RETRY, ruleHandle.getRetry()); 
        return chain.execute(exchange); 
    } 
  } 

在DividePlugin 类中的doExecute方法中根据相应的规则来获取相应的规则处理器，然后再根据所获得的规则处理器来获取相应的负载均衡策略。
这里可以看下LoadBalanceUtils.selector(upstreamList, ruleHandle.getLoadBalance(), ip)的调用，如下：

public class LoadBalanceUtils {
    
    public static DivideUpstream selector(final List<DivideUpstream> upstreamList, final String algorithm, final String ip) {
    
        // 获取loadBalance 
        LoadBalance loadBalance = ExtensionLoader.getExtensionLoader(LoadBalance.class).getJoin(algorithm); 
        // 重点 
        return loadBalance.select(upstreamList, ip); 
    } 

}我们继续看看loadBalance.select(upstreamList, ip)调用：

public abstract class AbstractLoadBalance implements LoadBalance {
    
    /** 
     * Do select divide upstream. 
     * 
     * @param upstreamList the upstream list 
     * @param ip           the ip 
     * @return the divide upstream 
     */ 
    protected abstract DivideUpstream doSelect(List<DivideUpstream> upstreamList, String ip); 
    @Override 
    public DivideUpstream select(final List<DivideUpstream> upstreamList, final String ip) {
    
        if (CollectionUtils.isEmpty(upstreamList)) {
    
            return null; 
        } 
        if (upstreamList.size() == 1) {
    
            return upstreamList.get(0); 
        } 
        return doSelect(upstreamList, ip); 
    } 
    // ........ 
} 

接着看看doSelect方法他的具体实现，这里就是我们前面所提到的几种负载均衡方式，如图：

在AbstractLoadBalance类中有calculateWarmupWeight方法根据uptime、 warmup,、weight这三个参数来计算出路由权重。

private int getWeight(final long timestamp, final int warmup, final int weight) {
    
    if (weight > 0 && timestamp > 0) {
    
        int uptime = (int) (System.currentTimeMillis() - timestamp); 
        if (uptime > 0 && uptime < warmup) {
    
            return calculateWarmupWeight(uptime, warmup, weight); 
        } 
    } 
    return weight; 
} 
private int calculateWarmupWeight(final int uptime, final int warmup, final int weight) {
    
    int ww = (int) ((float) uptime / ((float) warmup / (float) weight)); 
    return ww < 1 ? 1 : (ww > weight ? weight : ww); 
} 

总结

本篇简单的分析了关于divide插件和负载均衡方面进行了分析，同时也介绍了有几种负载均衡的方式。