十二、soul源码学习-divide插件探活机制

在前面讲过，在fetchConfig中，有一部分DataRefresh逻辑，我们看下SelectorDataRefresh逻辑

//org.dromara.soul.sync.data.http.refresh.SelectorDataRefresh#refresh
@Override
protected void refresh(final List data) {
  if (CollectionUtils.isEmpty(data)) {
    log.info("clear all selector cache, old cache");
    data.forEach(pluginDataSubscriber::unSelectorSubscribe);
    pluginDataSubscriber.refreshSelectorDataAll();
  } else {
    // update cache for UpstreamCacheManager
    pluginDataSubscriber.refreshSelectorDataAll();
    data.forEach(pluginDataSubscriber::onSelectorSubscribe);
  }
}

重点看下onSelectorSubscribe。

//org.dromara.soul.plugin.base.cache.CommonPluginDataSubscriber#subscribeDataHandler
if (data instanceof SelectorData) {
  SelectorData selectorData = (SelectorData) data;
  if (dataType == DataEventTypeEnum.UPDATE) {
    BaseDataCache.getInstance().cacheSelectData(selectorData);
    Optional.ofNullable(handlerMap.get(selectorData.getPluginName())).ifPresent(handler -> handler.handlerSelector(selectorData));
  } else if (dataType == DataEventTypeEnum.DELETE) {
    BaseDataCache.getInstance().removeSelectData(selectorData);
    Optional.ofNullable(handlerMap.get(selectorData.getPluginName())).ifPresent(handler -> handler.removeSelector(selectorData));
  }

我们关注SelectorData这里，最后会走到handler.handlerSelector(selectorData)。handlerSelector实现暂时只有DividePluginHandler的一种实现。

image.png

//org.dromara.soul.plugin.divide.handler.DividePluginDataHandler
public class DividePluginDataHandler implements PluginDataHandler {
    
  @Override
  public void handlerSelector(final SelectorData selectorData) {
    UpstreamCacheManager.getInstance().submit(selectorData);
  }

  @Override
  public void removeSelector(final SelectorData selectorData) {
    UpstreamCacheManager.getInstance().removeByKey(selectorData.getId());
  }

  @Override
  public String pluginNamed() {
    return PluginEnum.DIVIDE.getName();
  }
}

主要用到了UpstreamCacheManager。该对象是一个单例的实现

//org.dromara.soul.plugin.divide.cache.UpstreamCacheManager
public final class UpstreamCacheManager {

    private static final UpstreamCacheManager INSTANCE = new UpstreamCacheManager();
     
    private static final Map> UPSTREAM_MAP = Maps.newConcurrentMap();

    private static final Map> UPSTREAM_MAP_TEMP = Maps.newConcurrentMap();


    /**
     * 构造方法创建了一个调度线程池，并根据soul.upstream.scheduledTime配置来获取调度时间，每次执行scheduled方法
     */
    private UpstreamCacheManager() {
        boolean check = Boolean.parseBoolean(System.getProperty("soul.upstream.check", "false"));
        if (check) {
            new ScheduledThreadPoolExecutor(1, SoulThreadFactory.create("scheduled-upstream-task", false))
                    .scheduleWithFixedDelay(this::scheduled,
                            30, Integer.parseInt(System.getProperty("soul.upstream.scheduledTime", "30")), TimeUnit.SECONDS);
        }
    }
}

我们在handlerSelector看到这里会调用UpstreamCacheManager.getInstance().submit(selectorData);，我们在看下submit具体做了什么

//org.dromara.soul.plugin.divide.cache.UpstreamCacheManager#submit
public void submit(final SelectorData selectorData) {
  final List upstreamList = GsonUtils.getInstance().fromList(selectorData.getHandle(), DivideUpstream.class);
  //如果上游配置不为空，则将当前上游的配置放入到MAP中
  if (null != upstreamList && upstreamList.size() > 0) {
    UPSTREAM_MAP.put(selectorData.getId(), upstreamList);
    UPSTREAM_MAP_TEMP.put(selectorData.getId(), upstreamList);
    //如果上游配置列表为空，则直接将当前SelectData对应的id从MAP清空
  } else {
    UPSTREAM_MAP.remove(selectorData.getId());
    UPSTREAM_MAP_TEMP.remove(selectorData.getId());
  }
}

我们再来看下sheduled

//org.dromara.soul.plugin.divide.cache.UpstreamCacheManager#scheduled
private void scheduled() {
  if (UPSTREAM_MAP.size() > 0) {
    UPSTREAM_MAP.forEach((k, v) -> {
      // 对 上游 进行探活检查
      List result = check(v);
      // 将探活后的结果更新到UPSTREAM_MAP_TEMP
      if (result.size() > 0) {
        UPSTREAM_MAP_TEMP.put(k, result);
      } else {
        UPSTREAM_MAP_TEMP.remove(k);
      }
    });
  }
}

这里看到，我们的UPSTREAM_MAP相当于一个原始的配置，而UPSTREAM_MAP_TEMP相当于 当前真正存活的数据

在看下check

//org.dromara.soul.plugin.divide.cache.UpstreamCacheManager#check
private List check(final List upstreamList) {
  List resultList = Lists.newArrayListWithCapacity(upstreamList.size());
  for (DivideUpstream divideUpstream : upstreamList) {
    //通过 UpstreamCheckUtils 来 判断url状态 1.1
    final boolean pass = UpstreamCheckUtils.checkUrl(divideUpstream.getUpstreamUrl());
    if (pass) {
      //存活
      if (!divideUpstream.isStatus()) {
        divideUpstream.setTimestamp(System.currentTimeMillis());
        divideUpstream.setStatus(true);
        log.info("UpstreamCacheManager detect success the url: {}, host: {} ", divideUpstream.getUpstreamUrl(), divideUpstream.getUpstreamHost());
      }
      resultList.add(divideUpstream);
      //已经挂掉
    } else {
      divideUpstream.setStatus(false);
      log.error("check the url={} is fail ", divideUpstream.getUpstreamUrl());
    }
  }
  return resultList;

}

1.1 checkUrl 具体的检查机制

//org.dromara.soul.common.utils.UpstreamCheckUtils#checkUrl
public static boolean checkUrl(final String url) {
  if (StringUtils.isBlank(url)) {
    return false;
  }
  if (checkIP(url)) {
    String[] hostPort;
    if (url.startsWith(HTTP)) {
      final String[] http = StringUtils.split(url, "\\/\\/");
      hostPort = StringUtils.split(http[1], Constants.COLONS);
    } else {
      hostPort = StringUtils.split(url, Constants.COLONS);
    }
    return isHostConnector(hostPort[0], Integer.parseInt(hostPort[1]));
  } else {
    return isHostReachable(url);
  }
}

这里我们就看到了Divide插件具体的探活机制。