【Spring Cloud Alibaba】008-Sentinel

<!-- 引入 Sentinel 依赖 -->
<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-core</artifactId>
    <version>1.8.6</version>
</dependency>

package com.zibo.sentinel.controller;

import com.alibaba.csp.sentinel.Entry;
import com.alibaba.csp.sentinel.SphU;
import com.alibaba.csp.sentinel.slots.block.RuleConstant;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
import jakarta.annotation.PostConstruct;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.List;

/**
 * @author zibo
 * @date 2023/2/24 13:43
 */
@RestController
@RequestMapping("/sentinel")
public class HelloController {

    private static final String RESOURCE_NAME = "hello";

    @RequestMapping("/hello")
    public String hello() {
        Entry entry = null;
        try {
            entry = SphU.entry(RESOURCE_NAME);
            // 被保护的逻辑
            return "hello sentinel";
        } catch (Exception e) {
            // 处理被流控的逻辑
            return "被流控了";
        } finally {
            if (entry != null) {
                entry.exit();
            }
        }
    }

    @PostConstruct
    public void initFlowRules() {
        // 流控规则
        List<FlowRule> rules = new ArrayList<>();
        // 流控
        FlowRule flowRule = new FlowRule();
        // 设置资源
        flowRule.setResource(RESOURCE_NAME);
        // 设置规则类型
        flowRule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        // 设置阈值（每秒一次）
        flowRule.setCount(1);
        // 添加到规则列表
        rules.add(flowRule);
        // 加载规则
        FlowRuleManager.loadRules(rules);
    }

}

<!-- 引入 Sentinel 注解开发依赖 -->
<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-annotation-aspectj</artifactId>
    <version>1.8.6</version>
</dependency>

@Bean
public SentinelResourceAspect sentinelResourceAspect() {
    return new SentinelResourceAspect();
}

package com.zibo.sentinel.controller;

import com.alibaba.csp.sentinel.Entry;
import com.alibaba.csp.sentinel.SphU;
import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.RuleConstant;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
import jakarta.annotation.PostConstruct;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.List;

/**
 * @author zibo
 * @date 2023/2/24 13:43
 */
@RestController
@RequestMapping("/sentinel")
public class HelloController {

    // 原函数
    // blockHandler：指定限流处理方法！
    // fallback：指定异常熔断后的降级处理方法！
    @SentinelResource(value = "hello", blockHandler = "helloFallback", fallback = "exceptionHandler")
    @RequestMapping("/hello")
    public String hello() {
        return "Hello Sentinel";
    }

    // Fallback 函数，函数签名与原函数一致或加一个 Throwable 类型的参数.
    public String helloFallback() {
        return "被限流了";
    }

    // Block 异常处理函数，参数最后多一个 BlockException，其余与原函数一致.
    public String exceptionHandler(BlockException ex) {
        ex.printStackTrace();
        return "异常处理！";
    }

    @PostConstruct
    public void initFlowRules() {
        // 流控规则
        List<FlowRule> rules = new ArrayList<>();
        // 流控
        FlowRule flowRule = new FlowRule();
        // 设置资源
        flowRule.setResource("hello");
        // 设置规则类型
        flowRule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        // 设置阈值（每秒一次）
        flowRule.setCount(1);
        // 添加到规则列表
        rules.add(flowRule);
        // 加载规则
        FlowRuleManager.loadRules(rules);
    }

}

com.alibaba.csp.sentinel.slots.block.flow.FlowException

Entry entry = null;
try {
  entry = SphU.entry(key, EntryType.IN, key);

  // Write your biz code here.
  // <<BIZ CODE>>
} catch (Throwable t) {
  if (!BlockException.isBlockException(t)) {
    Tracer.trace(t);
  }
} finally {
  if (entry != null) {
    entry.exit();
  }
}

EventObserverRegistry.getInstance().addStateChangeObserver("logging",
    (prevState, newState, rule, snapshotValue) -> {
        if (newState == State.OPEN) {
            // 变换至 OPEN state 时会携带触发时的值
            System.err.println(String.format("%s -> OPEN at %d, snapshotValue=%.2f", prevState.name(),
                TimeUtil.currentTimeMillis(), snapshotValue));
        } else {
            System.err.println(String.format("%s -> %s at %d", prevState.name(), newState.name(),
                TimeUtil.currentTimeMillis()));
        }
    });

package com.zibo.sentinel.controller;

import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.RuleConstant;
import com.alibaba.csp.sentinel.slots.block.degrade.DegradeRule;
import com.alibaba.csp.sentinel.slots.block.degrade.DegradeRuleManager;
import jakarta.annotation.PostConstruct;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.List;

/**
 * @author zibo
 * @date 2023/2/24 13:43
 */
@RestController
@RequestMapping("/sentinel")
public class HelloController {

    // 原函数
    @SentinelResource(value = "hello", fallback = "fallbackExceptionHandler")
    @RequestMapping("/hello/{nickname}")
    public String hello(@PathVariable String nickname) {
        int a = 1 / 0;
        return "Hello Sentinel" + nickname;
    }

    // Fallback 函数，函数签名与原函数一致或加一个 Throwable 类型的参数.
    public String fallbackExceptionHandler(String nickname, Throwable t) {
        t.printStackTrace();
        return "服务被熔断了，不要调用！" + nickname;
    }

    /**
     * 降级规则
     */
    @PostConstruct
    public void initDegradeRules() {
        // 降级规则
        List<DegradeRule> rules = new ArrayList<>();
        // 降级
        DegradeRule degradeRule = new DegradeRule();
        // 设置资源
        degradeRule.setResource("hello");
        // 设置规则类型
        degradeRule.setGrade(RuleConstant.DEGRADE_GRADE_EXCEPTION_COUNT);
        // 设置阈值（异常数）
        degradeRule.setCount(3);
        // 触发熔断的最小请求数
        degradeRule.setMinRequestAmount(3);
        // 单位统计时长：1分钟
        degradeRule.setStatIntervalMs(60 * 1000);
        // 上述条件综合说明：1分钟内，如果至少有3个请求，且异常数为3，则触发熔断降级

        // 设置时间窗口
        // 熔断后多少秒后进入半熔断状态（探测恢复状态）
        // 比如：熔断10秒后，进入半熔断状态，此时如果请求成功，则恢复正常，如果失败，则继续熔断
        degradeRule.setTimeWindow(10);
        // 添加到规则列表
        rules.add(degradeRule);
        // 加载规则
        DegradeRuleManager.loadRules(rules);
    }

}

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

# 启动控制台命令
java -Dserver.port=8090 -jar sentinel-dashboard-1.8.5.jar

<!-- 引入 Sentinel 控制台 -->
<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-transport-simple-http</artifactId>
    <version>1.8.5</version>
</dependency>

<!-- Spring Cloud Alibaba Sentinel -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>

spring:
  application:
    name: sentinel-demo
  cloud:
    sentinel:
      transport:
        dashboard: localhost:8090

package com.zibo.sentinel.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author zibo
 * @date 2023/2/26 12:29
 */
@RestController
public class HiController {

    @RequestMapping("/hi")
    public String hi() {
        return "hi";
    }

}

package com.zibo.sentinel.controller;

import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author zibo
 * @date 2023/2/26 12:29
 */
@RestController
public class HiController {

    @RequestMapping("/hi")
    @SentinelResource(value = "hi", blockHandler = "blockExceptionHandler")
    public String hi() {
        return "hi";
    }
    
    public String blockExceptionHandler(BlockException e) {
        e.printStackTrace();
        return "限流了！";
    }

}

package com.zibo.sentinel.controller;

import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.RuleConstant;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.PostConstruct;
import java.util.ArrayList;
import java.util.List;

/**
 * @author zibo
 * @date 2023/2/26 12:29
 */
@RestController
public class HiController {

    @RequestMapping("/hi")
    @SentinelResource(value = "hi", blockHandler = "blockExceptionHandler")
    public String hi() {
        return "hi";
    }

    public String blockExceptionHandler(BlockException e) {
        e.printStackTrace();
        return "限流了！";
    }

    @RequestMapping("/hello")
    @SentinelResource(value = "hello", blockHandler = "blockExceptionHandler")
    public String hello() {
        // 睡眠 5 秒，模拟业务处理时间
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "hello";
    }

}

package com.zibo.sentinel.domain;

import lombok.Data;

@Data
public class R {

    /**
     * 返回码
     */
    private Integer code;

    /**
     * 返回消息
     */
    private String msg;

    /**
     * 私有化构造方法
     */
    private R() {
    }

    /**
     * 失败
     *
     * @param msg 返回消息
     * @return 统一返回结果类
     */
    public static R error(Integer code, String msg) {
        R r = new R();
        r.setCode(code);
        r.setMsg(msg);
        return r;
    }
}

package com.zibo.sentinel.common;

import com.alibaba.csp.sentinel.adapter.spring.webmvc.callback.BlockExceptionHandler;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.authority.AuthorityException;
import com.alibaba.csp.sentinel.slots.block.degrade.DegradeException;
import com.alibaba.csp.sentinel.slots.block.flow.FlowException;
import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowException;
import com.alibaba.csp.sentinel.slots.system.SystemBlockException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.zibo.sentinel.domain.R;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * @author zibo
 * @date 2023/2/26 13:13
 * @slogan 真正的大师永远怀着一颗学徒的心。——易大师
 */
@Component
public class MyBlockExceptionHandler implements BlockExceptionHandler {
    @Override
    public void handle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, BlockException e) throws Exception {
        R r = null;
        if (e instanceof FlowException) {
            r = R.error(100,"接口限流了");
        } else if (e instanceof DegradeException) {
            r = R.error(101,"接口降级了");
        } else if (e instanceof ParamFlowException) {
            r = R.error(102,"热点参数限流了");
        } else if (e instanceof SystemBlockException) {
            r = R.error(103,"触发系统保护规则了");
        } else if(e instanceof AuthorityException) {
            r = R.error(104,"授权规则不通过");
        }
        // 返回 json
        httpServletResponse.setStatus(500);
        httpServletResponse.setCharacterEncoding("UTF-8");
        httpServletResponse.setContentType(MediaType.APPLICATION_JSON_VALUE);
        new ObjectMapper().writeValue(httpServletResponse.getWriter(), r);
    }
}

package com.zibo.sentinel.controller;

import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.zibo.sentinel.common.MyBlockExceptionHandler;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author zibo
 * @date 2023/2/26 12:29
 */
@RestController
public class HiController {

    @RequestMapping("/hello")
    public String hello() {
        return "hello";
    }

}

@RequestMapping("/read")
public String read() {
    return "read";
}

@RequestMapping("/write")
public String write() {
    return "write";
}

package com.zibo.sentinel.service;

import com.alibaba.csp.sentinel.annotation.SentinelResource;
import org.springframework.stereotype.Service;

/**
 * @author zibo
 * @date 2023/2/26 16:12
 * @slogan 真正的大师永远怀着一颗学徒的心。——易大师
 */
@Service
public class TestService {

    @SentinelResource("myService")
    public String myService() {
        return "test service";
    }

}

package com.zibo.sentinel.controller;

import com.zibo.sentinel.service.TestService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HiController {

    @Autowired
    private TestService testService;

    @RequestMapping("/test1")
    public String read() {
        return "test1 " + testService.myService();
    }

    @RequestMapping("/test2")
    public String write() {
        return "test2 " + testService.myService();
    }

}

spring:
  application:
    name: sentinel-demo
  cloud:
    sentinel:
      transport:
        dashboard: localhost:8090
      web-context-unify: false # add this config

package com.zibo.sentinel.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author zibo
 * @date 2023/2/27 12:47
 * @slogan 真正的大师永远怀着一颗学徒的心。——易大师
 */
@RestController
public class TestController {

    @RequestMapping("/test")
    public String test() {
        return "test";
    }

}

package com.zibo.sentinel.controller;

import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author zibo
 * @date 2023/2/27 13:44
 * @slogan 真正的大师永远怀着一颗学徒的心。——易大师
 */
@RestController
public class HotController {

    @RequestMapping("/hot/{name}")
    @SentinelResource(value = "hot", blockHandler = "hotBlockHandler")
    public String hot(@PathVariable String name) {
        return "正常访问热点：" + name;
    }

    public String hotBlockHandler(@PathVariable String name, BlockException e) {
        e.printStackTrace();
        return "热点流控：" + name;
    }

}

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

spring:
  application:
    name: sentinel-demo
  cloud:
    sentinel:
      transport:
        dashboard: localhost:8090
      web-context-unify: false
      datasource:
        flow-rule:
          nacos:
            server-addr: localhost:8848
            username: nacos
            password: nacos
            dataId: sentinel-demo-flow-rule
            groupId: DEFAULT_GROUP
            data-type: json
            rule-type: flow