<!-- 注册中心-->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<!-- 配置中心 -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>
<!-- 限流依赖-->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
	<version>2021.0.4.0</version>
</dependency>

package com.xlt.config;

import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
import com.alibaba.fastjson.JSON;
import com.geely.idc.imd.anonymize.worker.config.propety.AnonSentinelProperties;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.context.environment.EnvironmentChangeEvent;
import org.springframework.context.ApplicationEvent;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.event.EventListener;

import javax.annotation.PostConstruct;
import java.util.Set;

@Configuration
public class SentinelConfig {

    private final Logger log = LoggerFactory.getLogger(SentinelConfig.class);

    @Autowired
    private SentinelProperties sentinelProperties;

    @PostConstruct
    public void init() {
        loadFlowRules();
    }

    /**
     * 添加配置变更监听，热更新限流规则
     *
     * @param event
     */
    @EventListener
    public void handleEvent(ApplicationEvent event) {
        if (event instanceof EnvironmentChangeEvent) {
            EnvironmentChangeEvent environmentChangeEvent = (EnvironmentChangeEvent) event;
            Set<String> keys = environmentChangeEvent.getKeys();
            boolean match = keys.stream().anyMatch(e -> e.startsWith(sentinelProperties.getConfigKey()));
            if (match) {
                loadFlowRules();
            }
        }
    }

    private void loadFlowRules() {
        if (sentinelProperties.isEnable()) {
            log.info("Sentinel flow rule changed: {}", JSON.toJSON(sentinelProperties.getRules()));
            FlowRuleManager.loadRules(sentinelProperties.getRules());
        }
    }

}
  

@Data
@Component
@RefreshScope
@ConfigurationProperties(prefix = "sentinel")
public class SentinelProperties {

    private boolean enable = false;

    private List<FlowRule> rules;

    private String configKey = "sentinel.rules";

}

@PostMapping("/images/anonymize")
@SentinelResource(value = "imageAnonymize")
public ApiResponse<AnonImageVO> anonymize(@RequestBody byte[] file) {
    return anonymizeService.anonymize(file);
}

@PostMapping("/images/anonymize/path")
@SentinelResource(value = "imageAnonymizePath")
public ApiResponse anonymize(@RequestParam(value = "filePath") String filePath) {
    return ApiResponse.success(anonymizeService.anonymize(filePath));
}

  sentinel:
    enable: true
    rules: 
      - resource: imageAnonymize
        limitApp: default
        grade: 1
        count: 3
        strategy: 0
        controlBehavior: 2
        maxQueueingTimeMs: 2000
        clusterMode: false
      - resource: imageAnonymizePath
        limitApp: default
        grade: 1
        count: 1
        strategy: 0
        controlBehavior: 0
        clusterMode: false

流控策略

0.直接：当api大达到限流条件时，直接限流
1.关联：当关联的资源到达阈值，就限流自己
2.链路：只记录指定路上的流量，指定资源从入口资源进来的流量，如果达到阈值，就进行限流，api级别的限流