Soul网关（十四）---- Soul 中的容错保护（1）

最新推荐文章于 2026-04-16 19:18:43 发布

原创最新推荐文章于 2026-04-16 19:18:43 发布 · 646 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

Soul 网关源码

本文详细介绍了Soul框架中如何使用Hystrix进行容错保护，包括Hystrix的简介、Soul中的Hystrix插件实现、熔断规则设置以及工作原理。通过设置插件优先级、断路器逻辑等，实现了对微服务请求的熔断处理，确保系统稳定性。

Soul 中的容错保护

- Soul 中的容错保护

Soul 中的容错保护

Hystrix

Hystrix简介

Hystrix 由 Netflix 发布的针对微服务分布式系统的熔断保护中间件。

soul 中的 Hystrix 插件

在「反应式编程&插件调用链」一文中，已经分析过插件的调用链，请求进来会默认走以下 3 个前置插件，其中就包括 Hystrix 插件

HystrixPlugin
Resilience4JPlugin
SentinelPlugin

这里设置了插件优先级：

    /**
     * Hystrix plugin enum.
     */
    HYSTRIX(45, 0, "hystrix"),

    /**
     * Sentinel plugin enum.
     */
    SENTINEL(45, 0, "sentinel"),

    /**
     * Resilence4J plugin enum.
     */
    RESILIENCE4J(45, 0, "resilience4j"),

请求经过这3个插件时都会执行 AbstractSoulPlugin 类的 execute() 方法：

public Mono<Void> execute(final ServerWebExchange exchange, final SoulPluginChain chain) {
		// 获取插件名称
    String pluginName = named();
    // 根据插件名获取该插件的基本数据，如 PluginData(id=9, name=hystrix, config=null, role=0, enabled=true)
    final PluginData pluginData = BaseDataCache.getInstance().obtainPluginData(pluginName);
  	// 要在 soul-admin 中将插件打开，否则web请求不会被此插件处理 
    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);
}

doExecute()方法中的断路器是判断熔断的关键：

@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;
  	// 从当前web请求匹配上的规则取出熔断配置
    final HystrixHandle hystrixHandle = GsonUtils.getInstance().fromJson(rule.getHandle(), HystrixHandle.class);
    if (StringUtils.isBlank(hystrixHandle.getGroupKey())) {
        hystrixHandle.setGroupKey(Objects.requireNonNull(soulContext).getModule());
    }
    if (StringUtils.isBlank(hystrixHandle.getCommandKey())) {
      	// 没有配置 ‘命令Key’ 时，设置一个默认的
        hystrixHandle.setCommandKey(Objects.requireNonNull(soulContext).getMethod());
    }
    Command command = fetchCommand(hystrixHandle, exchange, chain);
    return Mono.create(s -> {
        Subscription sub = command.fetchObservable().subscribe(s::success,
                s::error, s::success);
        s.onCancel(sub::unsubscribe);
        // 断路器 判断是否熔断
        if (command.isCircuitBreakerOpen()) {
            log.error("hystrix execute have circuitBreaker is Open! groupKey:{},commandKey:{}", hystrixHandle.getGroupKey(), hystrixHandle.getCommandKey());
        }
    }).doOnError(throwable -> {
        log.error("hystrix execute exception:", throwable);
        exchange.getAttributes().put(Constants.CLIENT_RESPONSE_RESULT_TYPE, ResultEnum.ERROR.getName());
        chain.execute(exchange);
    }).then();
}