SpringCloudAliBaba篇 之 Sentinel：图解分布式系统的流量防卫兵（上）

<!--sentinel核心库-->
<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-core</artifactId>
    <version>1.8.4</version>
</dependency>
<!--如果要使用@SentinelResource-->
<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-annotation-aspectj</artifactId>
    <version>1.8.4</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>

@RestController
@Slf4j
public class HelloController {
    private static final String RESOURCE_NAME = "hello";
    @RequestMapping("/hello")
    public String hello(){
        Entry entry = null;
        try {
            // sentinel针对资源进行限制
            entry = SphU.entry(RESOURCE_NAME);
            // 被保护的业务逻辑
            String str = "hello world";
            log.info("======="+str+"=======");
            return str;
        }catch (BlockException e){
            // 资源访问组织，被限流或被降级,进行响应的处理操作
            log.info("block");
            return "被监控了";
        }catch (Exception ex){
            // 若需要配置降级规则，则需要通过这种方式记录业务异常
            Tracer.traceEntry(ex,entry);
        }finally {
            if(entry != null){
                entry.exit();
            }
        }
        return null;
    }
    /**
     * spring的初始化方法
     *
     **/
    @PostConstruct
    private static void initFlowRules(){
        // 流控规则
        List<FlowRule> rules = new ArrayList<>();
        // 流控
        FlowRule rule = new FlowRule();
        // 为哪个资源设置流控
        rule.setResource(RESOURCE_NAME);
        // 设置流程规则 QPS(每秒的一个访问数)
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        // 设置受保护的资源阈值（1秒当中访问一次）
        rule.setCount(1);
        // 加入集合
        rules.add(rule);
        // 加载配置好的规则
        FlowRuleManager.loadRules(rules);
    }
}

<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-annotation-aspectj</artifactId>
    <version>1.8.4</version>
</dependency>

/**
 * 注解支持的配置Bean
 */
@Bean
public SentinelResourceAspect sentinelResourceAspect(){
    return new SentinelResourceAspect();
}

@RestController
@Slf4j
public class HelloController {
    private static final String RESOURCE_NAME = "hello";
    /**
     * value: 定义的资源
     * blockHandler: 设置流控降级后的处理方法(默认该方法必须声明在同一个类)
     *   如果不想在同一个类中blockHandLerClass但是方法必须是static静态的
     * fallback : 当接口出现了异常，可以调用的方法
     *    如果不想在同一个类中fallbackClass但是方法必须是static静态的
     * 如果blockHandler和fallback同时指定，则blockHandler优先级更高
     * exceptionsToIgnore 排除哪些异常不处理
     **/
    @RequestMapping("/hello")
    @SentinelResource(value = RESOURCE_NAME,blockHandler = "blockHandlerForHello",fallback = "fallbackHandlerHello",exceptionsToIgnore = {})
    public String hello(String id){
        // int i = 1/0;
        return "hello world";
    }
    /**
     * 注意：
     * 1、一定要public
     * 2、返回值一定要和原方法一直，参数也要包含原函数的参数
     */
    public String blockHandlerForHello(String id , BlockException ex){
        ex.printStackTrace();
        return "流控";
    }
    /**
     * 异常会走这个方法
     */
    public String fallbackHandlerHello(String id , Throwable e){
        e.printStackTrace();
        return "异常处理";
    }
    /**
     * spring的初始化方法
     *
     **/
    @PostConstruct
    private static void initFlowRules(){
        // 流控规则
        List<FlowRule> rules = new ArrayList<>();
        // 流控
        FlowRule rule = new FlowRule();
        // 为哪个资源设置流控
        rule.setResource(RESOURCE_NAME);
        // 设置流程规则 QPS(每秒的一个访问数)
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        // 设置受保护的资源阈值（1秒当中访问一次）
        rule.setCount(1);
        // 加入集合
        rules.add(rule);
        // 加载配置好的规则
        FlowRuleManager.loadRules(rules);
    }
}

#需以这种方式启动即可
java -Dserver.port=8810 -Dsentinel.dashboard.auth.username=lili -Dsentinel.dashboard.auth.password=211314 -jar D:\a-mysource\sentinel\sentinel-dashboard-1.8.1.jar

<!--整合控制台-->
<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-transport-simple-http</artifactId>
    <version>1.8.4</version>
</dependency>

-Dcsp.sentinel.dashboard.server=127.0.0.1:8010

<!--sentinel依赖-->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>

server:
  port: 8005
# 服务名称
spring:
  application:
    name: order-sentinel
  cloud:
    sentinel:
      transport:
        #配置sentinel的地址以及端口号
        dashboard: 127.0.0.1:8010

@RestController
@RequestMapping("/order")
public class OrderController {
    @GetMapping("/orderList")
    public String getOrder() {
        return "orderList";
    }    
    @GetMapping("/hello")
    public String getHello() {
        return "hello";
    }
}

@RestController
@RequestMapping("/order")
public class OrderController {
    @GetMapping("/hello")
    @SentinelResource(value = "hello",blockHandler = "helloHandler")
    public String getHello() {
        return "hello";
    }
    public String helloHandler(BlockException e) {
        return "被流控了";
    }
}

@RequestMapping("/threadHello")
@SentinelResource(value = "threadHello",blockHandler = "helloHandler")
public String threadHello() throws InterruptedException {
    TimeUnit.SECONDS.sleep(5);
    return "hello";
}

@GetMapping("/add")
public String add() {
    return "生成订单";
}
@GetMapping("/get")
public String get() {
    return "查询订单";
}

public interface UserService {
    String getUser();
}

@Service
public class UserServiceImpl implements UserService{
    @Override
    @SentinelResource(value = "getUser",blockHandler = "userHandler")
    public String getUser() {
        return "User";
    }
    public String userHandler(BlockException e){
        return "被链路流控了";
    }
}

@Autowired
UserService userService;
@GetMapping("/getUser1")
public String getUser1() {
    return userService.getUser();
}
@GetMapping("/getUser2")
public String getUser2() {
    return userService.getUser();
}

spring:
  cloud:
    sentinel:
      web-context-unify: false # 默认将调用链路收敛