spring:
   cloud:
     sentinel:
       filter:
         # 關閉鏈路收斂使鏈路收斂能夠生效
         enabled: false

import com.alibaba.csp.sentinel.adapter.servlet.callback.RequestOriginParser;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;

/**
* <p> sentinel自定義授權來源獲取規(guī)則 </p>
*/
@Component
public class RequestOriginParserDefinition implements RequestOriginParser {

  /**
   * 定義區(qū)分來源的規(guī)則：本質上是通過獲取request域中獲取來源標識，然后交給流控應用來進行匹配處理
   *
   * @param request request域
   * @return 返回區(qū)分來源的值
   */
  @Override
  public String parseOrigin(HttpServletRequest request) {
      String client = request.getHeader("client");
      if(StringUtils.isNotBlank(client)){
          return "NONE";
      }
      return client;
  }
}

java -Dserver.port=9080 -Dcsp.sentinel.dashboard.server=localhost:9080 -Dproject.name=sentinel-dashboard -jar sentinel-dashboard.jar

<!--由于我們使用的spring-cloud,因此這里因此 sentinel的集成包來簡化我們的配置 -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>
<!--sentinel 對dubbo的支持-->
<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-apache-dubbo-adapter</artifactId>
</dependency>

@Service
public class SentinelDemoServiceImpl implements SentinelDemoService {

    /**
     * sentinel 熔斷限流示例1
     */
    @SentinelResource(value = "SentinelDemoService#sentinelDemo1", defaultFallback = "sentinelDemo1Fallback")
    @Override
    public String sentinelDemo1() {
        return "sentinel 示例1";
    }

    /**
     * 失敗的時候會調(diào)用此方法
     */
    public String sentinelDemo1Fallback(Throwable t) {
        if (BlockException.isBlockException(t)) {
            return "Blocked by Sentinel: " + t.getClass().getSimpleName();
        }
        return "Oops, failed: " + t.getClass().getCanonicalName();
    }

}

@Component
public class SentinelExceptionHandler implements BlockExceptionHandler {

    /**
     * 異常處理
     *
     * @param request  請求
     * @param response 響應
     * @param e        BlockException異常接口，包含Sentinel的五個異常
     *                 FlowException  限流異常
     *                 DegradeException  降級異常
     *                 ParamFlowException  參數(shù)限流異常
     *                 AuthorityException  授權異常
     *                 SystemBlockException  系統(tǒng)負載異常
     * @throws IOException IO異常
     */
    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response, BlockException e) throws Exception {
        JSONObject responseData = new JSONObject();
        if (e instanceof FlowException) {
            responseData.put("message", "限流異常");
            responseData.put("code", "C5001");
        } else if (e instanceof DegradeException) {
            responseData.put("message", "降級異常");
            responseData.put("code", "C5002");
        } else if (e instanceof ParamFlowException) {
            responseData.put("message", "參數(shù)限流異常");
            responseData.put("code", "C5003");
        } else if (e instanceof AuthorityException) {
            responseData.put("message", "授權異常");
            responseData.put("code", "C5004");
        } else if (e instanceof SystemBlockException) {
            responseData.put("message", "系統(tǒng)負載異常");
            responseData.put("code", "C5005");
        }
        response.setContentType("application/json;charset=utf-8");
        response.getWriter().write(responseData.toJSONString());
    }
}

public class FilePersistence implements InitFunc {

  @Value("spring.application.name")
  private String applicationName;

  @Override
  public void init() throws Exception {
      String ruleDir = System.getProperty("user.home") + "/sentinel-rules/" + applicationName;
      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);

      // 流控規(guī)則
      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);

      // 降級規(guī)則
      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);

      // 系統(tǒng)規(guī)則
      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);

      // 授權規(guī)則
      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);

      // 熱點參數(shù)規(guī)則
      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);
  }
}

<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-datasource-nacos</artifactId>
</dependency>

spring:
  cloud:
    sentinel:
      datasource:
        flow:
          # 配置nacos的
          nacos:
            rule-type: FLOW
            server-addr: 127.0.0.1:8848
            namespace: public
            groupId: "DEFAULT_GROUP"
            dataId: dubbo-customer-demo-sentinel.rule
            username: nacos
            password: 123456

[
    {
        "resource": "SentinelDemoService#sentinelDemo2",
        "count": 0,
        "grade": 1,
        "limitApp":"default",
        "strategy":0,
        "controlBehavior":0,
        "clusterMode":false
    }
]