美文网首页
[Soul 源码之旅] 1.8 Soul插件初体验 (Divid

[Soul 源码之旅] 1.8 Soul插件初体验 (Divid

作者: AndyWei123 | 来源:发表于2021-01-25 22:32 被阅读0次

    1.8.2.1 基础类

    Soul 中充满了各种各样的插件,插件极大地丰富了 Soul 的功能,而且插件支持热插拔,可扩展新极高,Soul 大方部分功能都是基于插件进行实现的。我们先来看一下 Soul 插件的抽象接口 SoulPlugin 的继承关系:


    image.png

    我们可以看到 SoulPlugin 下又非常多的实现类,我们再看一下 DividePlugin 的继承情况。


    image.png
    DividePlugin 继承了AbstractSoulPlugin ,AbstractSoulPlugin 再实现了 SoulPlugin 接口。我们先看一下 SoulPlugin 有哪些方法:
    image.png
    • execute 插件到执行方法,这里传入 Exchange 即各个插件之间进行通信到桥梁, Chain 插件链。
    • getOrder 返回各个插件到执行顺序。我们看 SoulConfiguration 这里是Soul 的核心代码,这里配置了对应的WebHandler ,它是所有插件的起点。我们接下来将 webFulx 会讲到。WebHandler 会根据Order 由小到大排列,定义各个插件的处理顺序。
    @Bean("webHandler")
       public SoulWebHandler soulWebHandler(final ObjectProvider<List<SoulPlugin>> plugins) {
           List<SoulPlugin> pluginList = plugins.getIfAvailable(Collections::emptyList);
           final List<SoulPlugin> soulPlugins = pluginList.stream()
                   .sorted(Comparator.comparingInt(SoulPlugin::getOrder)).collect(Collectors.toList());
           soulPlugins.forEach(soulPlugin -> log.info("load plugin:[{}] [{}]", soulPlugin.named(), soulPlugin.getClass().getName()));
           return new SoulWebHandler(soulPlugins);
       }
    
    • name 返回插件名。
    • skip 定义是否需要跳过该插件。
      我们接着看 AbstractSoulPlugin 的方法。


      image.png

      我们先来看一下最重要的 Excute规则,这是个 Default 方法,但做完 Selector 和 Rule 的匹配后,我们直接执行 doExecute 方法,这个方法需要各个子类实现。

        @Override
        public Mono<Void> execute(final ServerWebExchange exchange, final SoulPluginChain chain) {
            String pluginName = named();
            // 获取数据
            final PluginData pluginData = BaseDataCache.getInstance().obtainPluginData(pluginName);
            // 判断是否开启插件
            if (pluginData != null && pluginData.getEnabled()) {
                // 获取选择器
                final Collection<SelectorData> selectors = BaseDataCache.getInstance().obtainSelectorData(pluginName);
                if (CollectionUtils.isEmpty(selectors)) {
                    return handleSelectorIsNull(pluginName, exchange, chain);
                }
                //查看是否匹配
                final SelectorData selectorData = matchSelector(exchange, selectors);
                if (Objects.isNull(selectorData)) {
                    return handleSelectorIsNull(pluginName, exchange, chain);
                }
                selectorLog(selectorData, pluginName);
                // 获取规则
                final List<RuleData> rules = BaseDataCache.getInstance().obtainRuleData(selectorData.getId());
                if (CollectionUtils.isEmpty(rules)) {
                    return handleRuleIsNull(pluginName, exchange, chain);
                }
                RuleData rule;
                // 查找规则,假如是全局匹配则直接取最后一个规则
                if (selectorData.getType() == SelectorTypeEnum.FULL_FLOW.getCode()) {
                    //get last
                    rule = rules.get(rules.size() - 1);
                } else {
                    rule = matchRule(exchange, rules);
                }
                if (Objects.isNull(rule)) {
                    return handleRuleIsNull(pluginName, exchange, chain);
                }
                ruleLog(rule, pluginName);
                // 真正执行规则
                return doExecute(exchange, chain, selectorData, rule);
            }
            return chain.execute(exchange);
        }
    

    我们接着看 DividePlugin 做了啥,其主要是向数据交换区塞入了一部分数据。包括最终访问的地址,超时时间,重试次数。

        @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();
            // 根据负载均衡策略筛选下游服务器列表
            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);
        }
    

    最终调用了 chain.execute(exchange) 方法,我们再来看看调用链是怎么实现的。DefaultSoulPluginChain 它是 WebHandler 的子类,实现了 SoulPluginChain 接口,其主要实现了 execute 方法

    @Override
            public Mono<Void> execute(final ServerWebExchange exchange) {
                return Mono.defer(() -> {
                    if (this.index < plugins.size()) {
                        SoulPlugin plugin = plugins.get(this.index++);
                        Boolean skip = plugin.skip(exchange);
                        if (skip) {
                            return this.execute(exchange);
                        }
                        return plugin.execute(exchange, this);
                    }
                    return Mono.empty();
                });
            }
    

    这里使用了 Mono.defer 区别于 Mono.just 是立即执行 just 里的 function ,defer 是延迟加载的,当每次请求进来都会生成一个 DefaultSoulPluginChain ,这里记录了当情处理走到了那个 plugin 。
    最后我们看一下 SoulWebHandler ,他是所有WebFlux 请求的处理类。

        @Bean("webHandler")
        public SoulWebHandler soulWebHandler(final ObjectProvider<List<SoulPlugin>> plugins) {
            List<SoulPlugin> pluginList = plugins.getIfAvailable(Collections::emptyList);
            // 对插件进行排序
            final List<SoulPlugin> soulPlugins = pluginList.stream()
                    .sorted(Comparator.comparingInt(SoulPlugin::getOrder)).collect(Collectors.toList());
            // 调用插件链
            soulPlugins.forEach(soulPlugin -> log.info("load plugin:[{}] [{}]", soulPlugin.named(), soulPlugin.getClass().getName()));
            return new SoulWebHandler(soulPlugins);
        }
    

    首先它对所有对插件进行排序,然后插件链,进行链式调度。

    相关文章

      网友评论

          本文标题:[Soul 源码之旅] 1.8 Soul插件初体验 (Divid

          本文链接:https://www.haomeiwen.com/subject/fozvzktx.html