引言

插件是 Soul 的灵魂。

Soul 使用了插件化设计思想，实现了插件的热插拔，且极易扩展。内置丰富的插件支持，鉴权，限流，熔断，防火墙等等。

【Soul网关探秘】插件链实现 - 图1

Soul 是如何实现插件化设计的呢？

一切还得从插件链说起，本篇我们来探密 Soul 中插件链的实现。

从插件说起

Soul 中所有插件最终均继承自 SoulPlugin，其完整继承关系如下所示：

【Soul网关探秘】插件链实现 - 图2

可以看到，Soul 的插件生态极其丰富，正是如此丰富的插件支撑起了 Soul 网关强大的扩展能力。

我们以常用的 DividePlugin 为例，分析插件内部所做工作。

DividePlugin 继承结构：

【Soul网关探秘】插件链实现 - 图3

1、SoulPlugin 插件接口：

【Soul网关探秘】插件链实现 - 图4

  • execute 方法：处理方法，需要传入 exchange交换区 和 SoulPluginChain插件链
  • getOrder 方法：取得序号，用作插件排序
  • named 方法：获得插件名
  • skip 方法：判断是否跳过本次处理

每次处理时，将先进行 skip 判断，不跳过则执行 excute 处理方法。

2、AbstractSoulPlugin 抽象插件：

【Soul网关探秘】插件链实现 - 图5

重点关注 execute 方法，其核心代码如下：

  1. if (pluginData.getEnable()){
  2.     // 获取插件数据
  3.     final PluginData pluginData = BaseDataCache.getInstance().obtainPluginData(pluginName);
  4.     // 获取选择器数据
  5.     final Collection<SelectorData> selectors = BaseDataCache.getInstance().obtainSelectorData(pluginName);
  6.     final SelectorData selectorData = matchSelector(exchange, selectors);
  7.     // 获取规则
  8.     final List<RuleData> rules = BaseDataCache.getInstance().obtainRuleData(selectorData.getId());
  9.     RuleData rule;
  10.   if (selectorData.getType() == SelectorTypeEnum.FULL_FLOW.getCode()) {
  11.       //get last
  12.     rule = rules.get(rules.size() - 1);
  13.   } else {
  14.     rule = matchRule(exchange, rules);
  15.   }
  16.   // 执行具体处理
  17.   return doExecute(exchange, chain, selectorData, rule);
  18. }
  19. // 继续执行后续插件处理
  20. return chain.execute(exchange);

获取选择器数据和规则，然后传入 doExecute 方法进行具体处理，doExecute 方法为抽象方法，交由子类具体实现。

3、DividePlugin 插件：

【Soul网关探秘】插件链实现 - 图6

重点关注 doExecute 方法，以下是核心代码：

  1. // 获取网关上下文和规则处理器
  2. final SoulContext soulContext = exchange.getAttribute(Constants.CONTEXT);
  3. final DivideRuleHandle ruleHandle = GsonUtils.getInstance().fromJson(rule.getHandle(), DivideRuleHandle.class);
  4. // 获取上游列表
  5. final List<DivideUpstream> upstreamList = UpstreamCacheManager.getInstance().findUpstreamListBySelectorId(selector.getId());
  6. // 选择待分发的目标上游
  7. final String ip = Objects.requireNonNull(exchange.getRequest().getRemoteAddress()).getAddress().getHostAddress();
  8. DivideUpstream divideUpstream = LoadBalanceUtils.selector(upstreamList, ruleHandle.getLoadBalance(), ip);
  9. // 设置 http url 
  10. String domain = buildDomain(divideUpstream);
  11. String realURL = buildRealURL(domain, soulContext, exchange);
  12. exchange.getAttributes().put(Constants.HTTP_URL, realURL);
  13. // 设置 http timeout
  14. exchange.getAttributes().put(Constants.HTTP_TIME_OUT, ruleHandle.getTimeout());
  15. exchange.getAttributes().put(Constants.HTTP_RETRY, ruleHandle.getRetry());
  16. return chain.execute(exchange);

很明显，divide 插件只是完成目标上游服务的待分发，即根据选择器和规则找到对应服务，再通过负载均衡策略分配上游服务实例。

而调用上游服务的工作是由其他相应的 client 类插件完成。

插件链实现

借由插件链，Soul 将众多插件整合到一起进行统一调度处理。

插件链继承结构：

【Soul网关探秘】插件链实现 - 图7

可以看到，Soul 中插件链 SoulPluginChain 仅有一个默认实现类 DefaultSoulPluginChain。

1、DefaultSoulPluginChain：

【Soul网关探秘】插件链实现 - 图8

其持有通过构造方法传入的插件链，看看 execute 方法：

  1. public Mono<Void> execute(final ServerWebExchange exchange) {
  2.     // 反应式编程语法：Mono.defer
  3.       return Mono.defer(() -> {
  4.         if (this.index < plugins.size()) {
  5.             SoulPlugin plugin = plugins.get(this.index++);
  6.             // 判断是否需要调过
  7.               Boolean skip = plugin.skip(exchange);
  8.             if (skip) {
  9.                 return this.execute(exchange);
  10.             }
  11.               // 依次执行插件处理逻辑
  12.             return plugin.execute(exchange, this);
  13.         }
  14.         return Mono.empty();
  15.     });
  16. }

DefaultSoulPluginChain 是 SoulWebHandler 的内部类，看下 SoulWebHandler 的实现。

2、SoulWebHandler：

【Soul网关探秘】插件链实现 - 图9

SoulWebHandler 是 web 请求处理的起点，在此创建并开始插件链的处理。

同 DefaultSoulPluginChain一样，SoulWebHandler 也是持有通过构造方法传入的插件链。

看看 handle 方法：

  1. public Mono<Void> handle(@NonNull final ServerWebExchange exchange) {
  2.     MetricsTrackerFacade.getInstance().counterInc(MetricsLabelEnum.REQUEST_TOTAL.getName());
  3.     Optional<HistogramMetricsTrackerDelegate> startTimer = MetricsTrackerFacade.getInstance().histogramStartTimer(MetricsLabelEnum.REQUEST_LATENCY.getName());
  4.     return new DefaultSoulPluginChain(plugins).execute(exchange).subscribeOn(scheduler)
  5.             .doOnSuccess(t -> startTimer.ifPresent(time -> MetricsTrackerFacade.getInstance().histogramObserveDuration(time)));
  6. }

handle 方法负责插件链执行指标度量的采集，通过在 DefaultSoulPluginChain 执行时加订阅实现，DefaultSoulPluginChain 在此处完成初始化。

全局查找 SoulWebHandler 构造方法可以定位到 SoulConfiguration 的 soulWebHandler 方法，看下 SoulConfiguration 的实现。

3、SoulConfiguration：

【Soul网关探秘】插件链实现 - 图10

SoulConfiguration 是 Soul 的核心配置类，负责自动装配网关所需的核心 bean 对象。

如装配 SoulWebHandler：

  1. @Bean("webHandler")
  2. public SoulWebHandler soulWebHandler(final ObjectProvider<List<SoulPlugin>> plugins) {
  3.     // 获取可用的插件
  4.       List<SoulPlugin> pluginList = plugins.getIfAvailable(Collections::emptyList);
  5.     // 插件重排
  6.       final List<SoulPlugin> soulPlugins = pluginList.stream()
  7.             .sorted(Comparator.comparingInt(SoulPlugin::getOrder)).collect(Collectors.toList());
  8.     soulPlugins.forEach(soulPlugin -> log.info("load plugin:[{}] [{}]", soulPlugin.named(), soulPlugin.getClass().getName()));
  9.     return new SoulWebHandler(soulPlugins);
  10. }

注意此处的插件列表经过了一次重排，重排顺序参见 PluginEnum。

4、初始化 SoulWebHandler

soul-bootstrap启动的过程中，所有插件是怎么形成final ObjectProvider plugins，然后初始化SoulWebHandler的呢？

SoulWebHandler 所在的配置类通过配置 @ComponentScan(“org.dromara.soul”)，通知 spring 扫描 org.dromara.soul 包。

同属 org.dromara.soul 包下所有插件的 starter项目中，在各自的spring.factories 文件里都指定了自动配置类。

【Soul网关探秘】插件链实现 - 图11

因此，List会去收集在soul-bootstrap的 pom 文件里引入了相关依赖的插件，并以此形成插件链。

总结

本篇从单独的插件开始，到探究插件链的实现，基本理清了 Soul 中插件式设计的实现。

  1. 由 SoulConfiguration 自动装配 SoulWebHandler，但此时 SoulWebHandler 持有插件列表但未初始化插件链。
  2. 待调用 handle 方法处理请求时，才初始化插件链进入插件处理。

个人知识库

高性能微服务API网关-Soul