HyStrix替代方案限流降级框架 Sentinel 的原理和实践

public ResultWrapper<OrderDTO> getOrder(String id) {
        /**
         * pre inception
         */
        Entry entry = null;
        try {
            entry = SphU.entry("getOrder");
            ResultWrapper<OrderDTO> orderResultWrapper = testRestManagerImpl.getOrderInfo(id);

            if (orderResultWrapper.getData() == null) {
                orderResultWrapper.setData(new OrderDTO("No Order", "No Shop", " Random Data"));
            }

            return orderResultWrapper;
        } catch (BlockException e) {
            Tracer.trace(e);
            log.info(id + " 服务熔断");
            /**
             * 可以mock一个假数据返回
             */
            return new ResultWrapper<>();
        } catch (Exception e) {
            log.info(id + " 业务异常");
            /**
             * 业务异常，mock假数据返回
             */
            return new ResultWrapper<>();
        } finally {
            if (entry != null) {
                entry.exit();
            }
        }
        /**
         * 之前也可以不返回结果，这里调用其他的业务逻辑
         * post inception
         */
    }

首先,注入SentinelResource注解
@Configuration
public class SentinelAspectConfiguration {

    @Bean
    public SentinelResourceAspect sentinelResourceAspect() {
        return new SentinelResourceAspect();
    }
}

然后直接使用注解:
@SentinelResource(value = "getOrder",entryType = EntryType.IN, fallback = "getOrderFallBack", fallbackClass = {ITestRestAPIUtil.class}, blockHandler = "getOrderHandler", blockHandlerClass = {ITestRestAPIUtil.class})
public ResultWrapper<OrderDTO> getOrder(String id) {
    ResultWrapper<OrderDTO> orderResultWrapper = testRestManagerImpl.getOrderInfo(id);

    if (orderResultWrapper.getData() == null) {
        orderResultWrapper.setData(new OrderDTO("No Order", "No Shop", " Random Data"));
    }

    return orderResultWrapper;
}

然后实现我们设定的BlockHander和fallback方法
@Slf4j
public class ITestRestAPIUtil {
    public static ResultWrapper<OrderDTO> getOrderHandler(String id, BlockException ex) {
//        log.info(JSON.toJSONString(ex));
        //这里可以进行埋点
        //mock假数据返回
        return new ResultWrapper().setSuccess(true).setData(new OrderDTO()).setCode("服务已被降级").addMessage("服务已被降级");
    }

    public static ResultWrapper<OrderDTO> getOrderFallBack(String id, Throwable throwable) {
        log.info("捕捉到业务异常:{}", throwable.toString());
//        log.error("getOrderError", id);
        //mock假数据返回
        return new ResultWrapper<OrderDTO>().setSuccess(false).addMessage("捕捉到业务异常");
       }
}

@Configuration
public class SentinelConfig {

    @Resource
    private ApolloConfigureCenter apolloConfigureCenter;

    @PostConstruct
    private void initFlowRule() {
        List<FlowRule> rules = JSON.parseArray(apolloConfigureCenter.getFlowControlRule(), FlowRule.class);
        FlowRuleManager.loadRules(rules);
    }

    @PostConstruct
    private void initDegradeRule() {
        List<DegradeRule> rules = JSON.parseArray(apolloConfigureCenter.getDegradeRule(), DegradeRule.class);
        DegradeRuleManager.loadRules(rules);
    }

    //自定义规则,另一种写在代码中方法,也可以配置到apollo中
    @PostConstruct
    private void initCustomRule() {
        List<CustomRule> rules = new ArrayList<>();
        CustomRule customRule = new CustomRule();
        customRule.setPercentage();
        customRule.setTimeWindow();
        customRule.setResource("testCustom");
        rules.add(customRule);
        CustomRuleManager.loadRules(rules);
    }
}

public class CustomRule extends AbstractRule {
    private static final int RT_MAX_EXCEED_N = ;
    private double percentage;
    private int timeWindow;
    private final AtomicBoolean cut = new AtomicBoolean(false);
    private AtomicLong passCount = new AtomicLong(0L);

    public CustomRule() {
    }

    public CustomRule(String resourceName) {
        this.setResource(resourceName);
    }

    public double getPercentage() {
        return this.percentage;
    }

    public CustomRule setPercentage(double percentage) {
        this.percentage = percentage;
        return this;
    }

    public int getTimeWindow() {
        return timeWindow;
    }

    public CustomRule setTimeWindow(int timeWindow) {
        this.timeWindow = timeWindow;
        return this;
    }

    private boolean isCut() {
        return this.cut.get();
    }

    private void setCut(boolean cut) {
        this.cut.set(cut);
    }

    public AtomicLong getPassCount() {
        return this.passCount;
    }

    public boolean equals(Object o) {
        if (this == o) {
            return true;
        } else if (!(o instanceof CustomRule)) {
            return false;
        } else if (!super.equals(o)) {
            return false;
        } else {
            CustomRule that = (CustomRule)o;
            if (this.percentage != that.percentage) {
                return false;
            } else {
                return false;
            }
        }
    }

    public int hashCode() {
        int result = super.hashCode();
        result =  * result + (new Double(this.percentage)).hashCode();
        result =  * result + this.timeWindow;
        return result;
    }

    public boolean passCheck(Context context, DefaultNode node, int acquireCount, Object... args) {
        //实际情况下肯定不会只传一个参数,需要看情况自己解析
        Object[] objects = args;
        String uid = (String)objects[];
        if (StringUtils.isBlank(uid)) {
            return true;
        } else {
            取后两位与灰度值进行比较
            double greyUID = Double.parseDouble(uid.substring(uid.length()-));
            if (greyUID < this.percentage) {
                return true;
            }
        }

        return false;
    }

    public String toString() {
        return "CustomRule{resource=" + this.getResource() + ", percentage=" + this.percentage + ", limitApp=" + this.getLimitApp() + ", timeWindow=" + this.timeWindow + "}";
    }

    private static final class ResetTask implements Runnable {
        private CustomRule rule;

        ResetTask(CustomRule rule) {
            this.rule = rule;
        }

        public void run() {
            this.rule.getPassCount().set(0L);
            this.rule.cut.set(false);
        }
    }
}

public class CustomException extends BlockException {
    public CustomException(String ruleLimitApp) {
        super(ruleLimitApp);
    }

    public CustomException(String ruleLimitApp, CustomRule rule) {
        super(ruleLimitApp, rule);
    }

    public CustomException(String message, Throwable cause) {
        super(message, cause);
    }

    public CustomException(String ruleLimitApp, String message) {
        super(ruleLimitApp, message);
    }

    @Override
    public Throwable fillInStackTrace() {
        return this;
    }

    /**
     * Get triggered rule.
     * Note: the rule result is a reference to rule map and SHOULD NOT be modified.
     *
     * @return triggered rule
     * @since 1.4.2
     */
    @Override
    public CustomRule getRule() {
        return rule.as(CustomRule.class);
    }
}

public class CustomRuleManager {

    private static final Map<String, Set<CustomRule>> greyRules = new ConcurrentHashMap<>();

    private static final RulePropertyListener LISTENER = new RulePropertyListener();
    private static SentinelProperty<List<CustomRule>> currentProperty
            = new DynamicSentinelProperty<>();

    static {
        currentProperty.addListener(LISTENER);
    }

    public static void register2Property(SentinelProperty<List<CustomRule>> property) {
        AssertUtil.notNull(property, "property cannot be null");
        synchronized (LISTENER) {
            RecordLog.info("[CustomRuleManager] Registering new property to degrade rule manager");
            currentProperty.removeListener(LISTENER);
            property.addListener(LISTENER);
            currentProperty = property;
        }
    }

    public static void checkDegrade(ResourceWrapper resource, Context context, DefaultNode node, int count, Object ...args)
            throws BlockException {

        Set<CustomRule> rules = greyRules.get(resource.getName());
        if (rules == null) {
            return;
        }

        for (CustomRule rule : rules) {
            if (!rule.passCheck(context, node, count, args)) {
                throw new CustomException(rule.getLimitApp(), rule);
            }
        }
    }

    public static boolean hasConfig(String resource) {
        if (resource == null) {
            return false;
        }
        return greyRules.containsKey(resource);
    }

    /**
     * Get a copy of the rules.
     *
     * @return a new copy of the rules.
     */
    public static List<CustomRule> getRules() {
        List<CustomRule> rules = new ArrayList<>();
        for (Map.Entry<String, Set<CustomRule>> entry : greyRules.entrySet()) {
            rules.addAll(entry.getValue());
        }
        return rules;
    }

    /**
     * Load {@link CustomRule}s, former rules will be replaced.
     *
     * @param rules new rules to load.
     */
    public static void loadRules(List<CustomRule> rules) {
        try {
            currentProperty.updateValue(rules);
        } catch (Throwable e) {
            RecordLog.warn("[CustomRuleManager] Unexpected error when loading degrade rules", e);
        }
    }

    /**
     * Set degrade rules for provided resource. Former rules of the resource will be replaced.
     *
     * @param resourceName valid resource name
     * @param rules        new rule set to load
     * @return whether the rules has actually been updated
     * @since 1.5.0
     */
    public static boolean setRulesForResource(String resourceName, Set<CustomRule> rules) {
        AssertUtil.notEmpty(resourceName, "resourceName cannot be empty");
        try {
            Map<String, Set<CustomRule>> newRuleMap = new HashMap<>(greyRules);
            if (rules == null) {
                newRuleMap.remove(resourceName);
            } else {
                Set<CustomRule> newSet = new HashSet<>();
                for (CustomRule rule : rules) {
                    if (isValidRule(rule) && resourceName.equals(rule.getResource())) {
                        newSet.add(rule);
                    }
                }
                newRuleMap.put(resourceName, newSet);
            }
            List<CustomRule> allRules = new ArrayList<>();
            for (Set<CustomRule> set : newRuleMap.values()) {
                allRules.addAll(set);
            }
            return currentProperty.updateValue(allRules);
        } catch (Throwable e) {
            RecordLog.warn(
                    "[CustomRuleManager] Unexpected error when setting degrade rules for resource: " + resourceName, e);
            return false;
        }
    }

    private static class RulePropertyListener implements PropertyListener<List<CustomRule>> {

        @Override
        public void configUpdate(List<CustomRule> conf) {
            Map<String, Set<CustomRule>> rules = loadDegradeConf(conf);
            if (rules != null) {
                greyRules.clear();
                greyRules.putAll(rules);
            }
            RecordLog.info("[CustomRuleManager] Degrade rules received: " + greyRules);
        }

        @Override
        public void configLoad(List<CustomRule> conf) {
            Map<String, Set<CustomRule>> rules = loadDegradeConf(conf);
            if (rules != null) {
                greyRules.clear();
                greyRules.putAll(rules);
            }
            RecordLog.info("[CustomRuleManager] Degrade rules loaded: " + greyRules);
        }

        private Map<String, Set<CustomRule>> loadDegradeConf(List<CustomRule> list) {
            Map<String, Set<CustomRule>> newRuleMap = new ConcurrentHashMap<>();

            if (list == null || list.isEmpty()) {
                return newRuleMap;
            }

            for (CustomRule rule : list) {
                if (!isValidRule(rule)) {
                    RecordLog.warn(
                            "[CustomRuleManager] Ignoring invalid degrade rule when loading new rules: " + rule);
                    continue;
                }

                if (StringUtil.isBlank(rule.getLimitApp())) {
                    rule.setLimitApp(RuleConstant.LIMIT_APP_DEFAULT);
                }

                String identity = rule.getResource();
                Set<CustomRule> ruleSet = newRuleMap.get(identity);
                if (ruleSet == null) {
                    ruleSet = new HashSet<>();
                    newRuleMap.put(identity, ruleSet);
                }
                ruleSet.add(rule);
            }

            return newRuleMap;
        }
    }

    public static boolean isValidRule(CustomRule rule) {
        boolean baseValid = rule != null && !StringUtil.isBlank(rule.getResource())
                && rule.getPercentage() >=  && rule.getTimeWindow() > ;
        if (!baseValid) {
            return false;
        }
        // Warn for RT mode that exceeds the {@code TIME_DROP_VALVE}.
        int maxAllowedRt = Constants.TIME_DROP_VALVE;
        return true;
    }
}

public class CustomSlot extends AbstractLinkedProcessorSlot<DefaultNode> {
    public CustomSlot() {

    }

    @Override
    public void entry(Context context, ResourceWrapper resourceWrapper, DefaultNode node, int count, boolean prioritized, Object... args) throws Throwable {
        CustomRuleManager.checkDegrade(resourceWrapper, context, node, count, args);
        fireEntry(context, resourceWrapper, node, count, prioritized, args);
    }

    @Override
    public void exit(Context context, ResourceWrapper resourceWrapper, int count, Object... args) {
        fireExit(context, resourceWrapper, count, args);
    }
}

public class CustomSlotChainBuilder implements SlotChainBuilder {

    @Override
    public ProcessorSlotChain build() {

        ProcessorSlotChain chain = new DefaultProcessorSlotChain();
        chain.addLast(new NodeSelectorSlot());
        chain.addLast(new ClusterBuilderSlot());
        chain.addLast(new LogSlot());
        chain.addLast(new StatisticSlot());
        chain.addLast(new SystemSlot());
        chain.addLast(new AuthoritySlot());
        chain.addLast(new CustomSlot());
        chain.addLast(new FlowSlot());
        chain.addLast(new DegradeSlot());

        return chain;
    }
}