@Override
@SentinelResource(value = "test", blockHandler = "handleException", blockHandlerClass = {ExceptionUtil.class})
public void test() throws InterruptedException {
    Thread.sleep(random.nextInt(20));
    System.out.println("Test");
}

@Override
@SentinelResource(value = "hello", fallback = "helloFallback")
public String hello(long s) {
    if (s < 0) {
        throw new IllegalArgumentException("invalid arg");
    }
    return String.format("Hello at %d", s);
}
 
public String helloFallback(long s, Throwable ex) {
    // Do some log here.
    ex.printStackTrace();
    return "Oops, error occurred at " + s;
}

public final class ExceptionUtil {
    //必须为static修饰
    public static void handleException(BlockException ex) {
        // Handler method that handles BlockException when blocked.
        // The method parameter list should match original method, with the last additional
        // parameter with type BlockException. The return type should be same as the original method.
        // The block handler method should be located in the same class with original method by default.
        // If you want to use method in other classes, you can set the blockHandlerClass
        // with corresponding Class (Note the method in other classes must be static).
        System.out.println("Oops: " + ex.getClass().getCanonicalName());
    }
}

/**
 * 流量控制
 */
@PostConstruct
private  void intFlowQpsRule(){
    List<FlowRule> rules = new ArrayList<>();
    // 设置资源
    FlowRule rule = new FlowRule("hello");
    //设置阈值
    rule.setCount(5);
	//设置规则
    rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
	//来源 默认default
    rule.setLimitApp("default");
    rules.add(rule);
    FlowRuleManager.loadRules(rules);
}

/**
 * 熔断降级
 */
@PostConstruct
private void initDegradeRule(){
    List<DegradeRule> rules = new ArrayList<>();
    // 设置资源
    DegradeRule degradeRule = new DegradeRule("test");
    degradeRule.setGrade(RuleConstant.DEGRADE_GRADE_RT);
    //响应时间阈值10ms
    degradeRule.setCount(10);
    //熔断时间单位秒
    degradeRule.setTimeWindow(10);
    //阈值比例
    degradeRule.setSlowRatioThreshold(0.1);
    //最小请求数
    degradeRule.setMinRequestAmount(10);
    rules.add(degradeRule);
    DegradeRuleManager.loadRules(rules);
}

private void initParamFlowRule(){
    //资源名
    ParamFlowRule paramFlowRule = new ParamFlowRule("hello")
            //热点参数的索引，必填，对应字段参数的索引位置
            .setParamIdx(0)
            //限流阈值
            .setCount(5)
            //统计窗口时间长度（单位为秒）
            .setDurationInSec(10);
    //参数例外项，可以针对指定的参数值单独设置限流阈值，不受前面 count 阈值的限制。仅支持基本类型和字符串类型
    ParamFlowItem item = new ParamFlowItem()
            // 针对 int 类型的参数 1234，单独设置限流 QPS 阈值为 10，而不是全局的阈值 5.
            .setObject(String.valueOf(1234))
            .setClassType(int.class.getTypeName())
            .setCount(10);
    paramFlowRule.setParamFlowItemList(Collections.singletonList(item));
    List<ParamFlowRule> paramFlowRules = Collections.singletonList(paramFlowRule);
    System.out.println(JSON.toJSONString(paramFlowRules));
    ParamFlowRuleManager.loadRules(paramFlowRules);

private static void initSystemRule() {
    SystemRule rule = new SystemRule();
    // max load is 3
    rule.setHighestSystemLoad(3.0);
    // max cpu usage is 60%
    rule.setHighestCpuUsage(0.6);
    // max avg rt of all request is 10 ms
    rule.setAvgRt(10);
    // max total qps is 20
    rule.setQps(20);
    // max parallel working thread is 10
    rule.setMaxThread(10);
    SystemRuleManager.loadRules(Collections.singletonList(rule));
}

/**
 * 白名单限制
 */
private static void initWhiteRules() {
    AuthorityRule rule = new AuthorityRule();
    //资源
    rule.setResource(RESOURCE_NAME);
    //限制策略，默认白名单
    rule.setStrategy(RuleConstant.AUTHORITY_WHITE);
    //允许访问的app列表
    rule.setLimitApp("appA,appE");
    AuthorityRuleManager.loadRules(Collections.singletonList(rule));
}

/**
 * 黑名单限制
 */
private static void initBlackRules() {
    AuthorityRule rule = new AuthorityRule();
    //资源
    rule.setResource(RESOURCE_NAME);
    //限制策略为黑名单
    rule.setStrategy(RuleConstant.AUTHORITY_BLACK);
    //限制访问app列表
    rule.setLimitApp("appA,appB");
    AuthorityRuleManager.loadRules(Collections.singletonList(rule));
}

@FeignClient(name = "service-provider", fallback = EchoServiceFallback.class, configuration = FeignConfiguration.class)
public interface EchoService {
    @RequestMapping(value = "/echo/{str}", method = RequestMethod.GET)
    String echo(@PathVariable("str") String str);
}

class FeignConfiguration {
    @Bean
    public EchoServiceFallback echoServiceFallback() {
        return new EchoServiceFallback();
    }
}

class EchoServiceFallback implements EchoService {
    @Override
    public String echo(@PathVariable("str") String str) {
        return "echo fallback";
    }
}

@Bean
@SentinelRestTemplate(blockHandler = "handleException", blockHandlerClass = ExceptionUtil.class)
public RestTemplate restTemplate() {
    return new RestTemplate();
}

public class ExceptionUtil {
    public static ClientHttpResponse handleException(HttpRequest request, byte[] body, ClientHttpRequestExecution execution, BlockException exception) {
        ...
    }
}