@GetMapping(value = "/test_sentinel2")
public String testSentinel2(){
    log.info("測試Sentinel2");
    return "sentinel2";
}

/**
 * @author binghe
 * @version 1.0.0
 * @description 測試Sentinel
 */
public interface SentinelService {

    /**
     * 測試方法
     */
    void sendMessage();
}

/**
 * @author binghe
 * @version 1.0.0
 * @description 測試類
 */
@Service
public class SentinelServiceImpl implements SentinelService {
    @Override
    @SentinelResource("sendMessage")
    public void sendMessage() {
        System.out.println("測試Sentinel的鏈路流控模式");
    }
}

/**
 * @author binghe
 * @version 1.0.0
 * @description 測試Sentinel
 */
@Slf4j
@RestController
public class SentinelController {

    @Autowired
    private SentinelService sentinelService;

    @GetMapping(value = "/request_sentinel1")
    public String requestSentinel1(){
        log.info("測試Sentinel1");
        sentinelService.sendMessage();
        return "sentinel1";
    }
    @GetMapping(value = "/request_sentinel2")
    public String requestSentinel2(){
        log.info("測試Sentinel2");
        sentinelService.sendMessage();
        return "sentinel2";
    }
}

<properties>
    <java.version>1.8</java.version>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <spring-cloud.version>Hoxton.SR12</spring-cloud.version>
    <spring-cloud-alibaba.version>2.2.7.RELEASE</spring-cloud-alibaba.version>
    <spring.boot.version>2.3.12.RELEASE</spring.boot.version>
    <logback.version>1.1.7</logback.version>
    <slf4j.version>1.7.21</slf4j.version>
    <common.logging>1.2</common.logging>
    <fastjson.version>1.2.51</fastjson.version>
    <mybatis.version>3.4.6</mybatis.version>
    <mybatis.plus.version>3.4.1</mybatis.plus.version>
    <mysql.jdbc.version>8.0.19</mysql.jdbc.version>
    <druid.version>1.1.10</druid.version>
</properties>

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>${spring.boot.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-alibaba-dependencies</artifactId>
            <version>${spring-cloud-alibaba.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

startup.cmd -m standalone

spring:
  cloud:
    sentinel:
      web-context-unify: false

private int count = 0;
@GetMapping(value = "/request_sentinel4")
@SentinelResource("request_sentinel4")
public String requestSentinel4(){
    log.info("測試Sentinel4");
    count++;
    //模擬異常，比例為50%
    if (count % 2 == 0){
        throw new RuntimeException("演示基于異常比例熔斷");
    }
    return "sentinel4";
}

@GetMapping(value = "/request_sentinel3")
@SentinelResource("request_sentinel3")
public String requestSentinel3(String header, String body){
    log.info("測試Sentinel3");
    return "sentinel3";
}

/**
 * @author binghe
 * @version 1.0.0
 * @description Sentinel授權規則，用來處理請求的來源
 */
@Component
public class MyRequestOriginParser implements RequestOriginParser {
    @Override
    public String parseOrigin(HttpServletRequest httpServletRequest) {
        return httpServletRequest.getParameter("serverName");
    }
}

public String parseOrigin(HttpServletRequest httpServletRequest) {
    return httpServletRequest.getParameter("serverName");
}

/**
 * @author binghe
 * @version 1.0.0
 * @description 處理Sentinel系統規則，返回自定義異常
 */
@Component
public class MyUrlBlockHandler implements BlockExceptionHandler {
    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response, BlockException e) throws Exception {
        String msg = null;
        if (e instanceof FlowException) {
            msg = "限流了";
        } else if (e instanceof DegradeException) {
            msg = "降級了";
        } else if (e instanceof ParamFlowException) {
            msg = "熱點參數限流";
        } else if (e instanceof SystemBlockException) {
            msg = "系統規則（負載/...不滿足要求）";
        } else if (e instanceof AuthorityException) {
            msg = "授權規則不通過";
        }
        // http狀態碼
        response.setStatus(500);
        response.setCharacterEncoding("utf-8");
        response.setHeader("Content-Type", "application/json;charset=utf-8");
        response.setContentType("application/json;charset=utf-8");
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("code", 500);
        jsonObject.put("codeMsg", msg);
        response.getWriter().write(jsonObject.toJSONString());
    }
}

@GetMapping(value = "/request_sentinel5")
@SentinelResource("request_sentinel5")
public String requestSentinel5(){
    log.info("測試Sentinel5");
    return "sentinel5";
}

{"code":500,"codeMsg":"限流了"}

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
public @interface SentinelResource {

 //資源名稱
    String value() default "";
 //entry類型，標記流量的方向，取值IN/OUT，默認是OUT
    EntryType entryType() default EntryType.OUT;
    int resourceType() default 0;
 //處理BlockException的函數名稱,函數要求：
    //1. 必須是 public
    //2.返回類型 參數與原方法一致
    //3. 默認需和原方法在同一個類中。若希望使用其他類的函數，可配置
    //blockHandlerClass ，并指定blockHandlerClass里面的方法。
    String blockHandler() default "";
 
    //存放blockHandler的類,對應的處理函數必須static修飾。
    Class<?>[] blockHandlerClass() default {};
 
    //用于在拋出異常的時候提供fallback處理邏輯。fallback函數可以針對所
    //有類型的異常（除了 exceptionsToIgnore 里面排除掉的異常類型）進行處理。函數要求：
    //1. 返回類型與原方法一致
    //2. 參數類型需要和原方法相匹配
    //3. 默認需和原方法在同一個類中。若希望使用其他類的函數，可配置fallbackClass ，并指定fallbackClass里面的方法。
    String fallback() default "";
 
    //存放fallback的類。對應的處理函數必須static修飾。
    String defaultFallback() default "";

 //用于通用的 fallback 邏輯。默認fallback函數可以針對所有類型的異常進
    //行處理。若同時配置了 fallback 和 defaultFallback，以fallback為準。函數要求：
    //1. 返回類型與原方法一致
    //2. 方法參數列表為空，或者有一個 Throwable 類型的參數。
    //3. 默認需要和原方法在同一個類中。若希望使用其他類的函數，可配置fallbackClass ，并指定 fallbackClass 里面的方法。
    Class<?>[] fallbackClass() default {};

   //指定排除掉哪些異常。排除的異常不會計入異常統計，也不會進入fallback邏輯，而是原樣拋出。
    Class<? extends Throwable>[] exceptionsToTrace() default {Throwable.class};
    
 //需要trace的異常
    Class<? extends Throwable>[] exceptionsToIgnore() default {};
}

String sendMessage2();

private int count = 0;

@Override
@SentinelResource(
    value = "sendMessage2",
    blockHandler = "blockHandler",
    fallback = "fallback")
public String sendMessage2() {
    count ++;
    //25%的異常率
    if (count % 4 == 0){
        throw new RuntimeException("25%的異常率");
    }
    return "sendMessage2";
}

public String blockHandler(BlockException e){
    log.error("限流了:{}", e);
    return "限流了";
}

public String fallback(Throwable e){
    log.error("異常了:{}", e);
    return "異常了";
}

@GetMapping(value = "/request_sentinel6")
public String requestSentinel6(){
    log.info("測試Sentinel6");
    return sentinelService.sendMessage2();
}

/**
 * @author binghe
 * @version 1.0.0
 * @description 定義被Sentinel限流時調用的方法
 */
@Slf4j
public class MyBlockHandlerClass {

    public static String blockHandler(BlockException e){
        log.error("限流了:{}", e);
        return "限流了";
    }
}

/**
 * @author binghe
 * @version 1.0.0
 * @description 定義異常時調用的方法
 */
@Slf4j
public class MyFallbackClass {

    public static String fallback(Throwable e){
        log.error("異常了:{}", e);
        return "異常了";
    }
}

@Override
@SentinelResource(
    value = "sendMessage2",
    blockHandlerClass = MyBlockHandlerClass.class,
    blockHandler = "blockHandler",
    fallbackClass = MyFallbackClass.class,
    fallback = "fallback")
public String sendMessage2() {
    count ++;
    System.out.println(count);
    //25%的異常率
    if (count % 4 == 0){
        throw new RuntimeException("25%的異常率");
    }
    return "sendMessage2";
}

/**
 * @author binghe
 * @version 1.0.0
 * @description Sentinel規則持久化
 */
public class SentinelPersistenceRule implements InitFunc {
    //實際可以從外部配置讀取
    private String appcationName = "server-order";
    @Override
    public void init() throws Exception {
        String ruleDir = System.getProperty("user.home") + "/sentinel-rules/" + appcationName;
        String flowRulePath = ruleDir + "/flow-rule.json";
        String degradeRulePath = ruleDir + "/degrade-rule.json";
        String systemRulePath = ruleDir + "/system-rule.json";
        String authorityRulePath = ruleDir + "/authority-rule.json";
        String paramFlowRulePath = ruleDir + "/param-flow-rule.json";

        this.mkdirIfNotExits(ruleDir);
        this.createFileIfNotExits(flowRulePath);
        this.createFileIfNotExits(degradeRulePath);
        this.createFileIfNotExits(systemRulePath);
        this.createFileIfNotExits(authorityRulePath);
        this.createFileIfNotExits(paramFlowRulePath);

        // 流控規則
        ReadableDataSource<String, List<FlowRule>> flowRuleRDS = new FileRefreshableDataSource<>(
                flowRulePath,
                flowRuleListParser
        );
        FlowRuleManager.register2Property(flowRuleRDS.getProperty());
        WritableDataSource<List<FlowRule>> flowRuleWDS = new FileWritableDataSource<>(
                flowRulePath,
                this::encodeJson
        );
        WritableDataSourceRegistry.registerFlowDataSource(flowRuleWDS);

        // 降級規則
        ReadableDataSource<String, List<DegradeRule>> degradeRuleRDS = new FileRefreshableDataSource<>(
                degradeRulePath,
                degradeRuleListParser
        );
        DegradeRuleManager.register2Property(degradeRuleRDS.getProperty());
        WritableDataSource<List<DegradeRule>> degradeRuleWDS = new FileWritableDataSource<>(
                degradeRulePath,
                this::encodeJson
        );
        WritableDataSourceRegistry.registerDegradeDataSource(degradeRuleWDS);

        // 系統規則
        ReadableDataSource<String, List<SystemRule>> systemRuleRDS = new FileRefreshableDataSource<>(
                systemRulePath,
                systemRuleListParser
        );
        SystemRuleManager.register2Property(systemRuleRDS.getProperty());
        WritableDataSource<List<SystemRule>> systemRuleWDS = new FileWritableDataSource<>(
                systemRulePath,
                this::encodeJson
        );
        WritableDataSourceRegistry.registerSystemDataSource(systemRuleWDS);

        // 授權規則
        ReadableDataSource<String, List<AuthorityRule>> authorityRuleRDS = new FileRefreshableDataSource<>(
                authorityRulePath,
                authorityRuleListParser
        );
        AuthorityRuleManager.register2Property(authorityRuleRDS.getProperty());
        WritableDataSource<List<AuthorityRule>> authorityRuleWDS = new FileWritableDataSource<>(
                authorityRulePath,
                this::encodeJson
        );
        WritableDataSourceRegistry.registerAuthorityDataSource(authorityRuleWDS);

        // 熱點參數規則
        ReadableDataSource<String, List<ParamFlowRule>> paramFlowRuleRDS = new FileRefreshableDataSource<>(
                paramFlowRulePath,
                paramFlowRuleListParser
        );
        ParamFlowRuleManager.register2Property(paramFlowRuleRDS.getProperty());
        WritableDataSource<List<ParamFlowRule>> paramFlowRuleWDS = new FileWritableDataSource<>(
                paramFlowRulePath,
                this::encodeJson
        );
        ModifyParamFlowRulesCommandHandler.setWritableDataSource(paramFlowRuleWDS);
    }

    private Converter<String, List<FlowRule>> flowRuleListParser = source -> JSON.parseObject(
            source,
            new TypeReference<List<FlowRule>>() {
            }
    );
    private Converter<String, List<DegradeRule>> degradeRuleListParser = source -> JSON.parseObject(
            source,
            new TypeReference<List<DegradeRule>>() {
            }
    );
    private Converter<String, List<SystemRule>> systemRuleListParser = source -> JSON.parseObject(
            source,
            new TypeReference<List<SystemRule>>() {
            }
    );

    private Converter<String, List<AuthorityRule>> authorityRuleListParser = source -> JSON.parseObject(
            source,
            new TypeReference<List<AuthorityRule>>() {
            }
    );

    private Converter<String, List<ParamFlowRule>> paramFlowRuleListParser = source -> JSON.parseObject(
            source,
            new TypeReference<List<ParamFlowRule>>() {
            }
    );

    private void mkdirIfNotExits(String filePath) throws IOException {
        File file = new File(filePath);
        if (!file.exists()) {
            file.mkdirs();
        }
    }

    private void createFileIfNotExits(String filePath) throws IOException {
        File file = new File(filePath);
        if (!file.exists()) {
            file.createNewFile();
        }
    }

    private <T> String encodeJson(T t) {
        return JSON.toJSONString(t);
    }
}

io.binghe.shop.order.persistence.SentinelPersistenceRule

[
    {
        "clusterConfig": {
            "acquireRefuseStrategy": 0,
            "clientOfflineTime": 2000,
            "fallbackToLocalWhenFail": true,
            "resourceTimeout": 2000,
            "resourceTimeoutStrategy": 0,
            "sampleCount": 10,
            "strategy": 0,
            "thresholdType": 0,
            "windowIntervalMs": 1000
        },
        "clusterMode": false,
        "controlBehavior": 0,
        "count": 2,
        "grade": 1,
        "limitApp": "default",
        "maxQueueingTimeMs": 500,
        "resource": "/request_sentinel6",
        "strategy": 0,
        "warmUpPeriodSec": 10
    }
]