Sentinel控制台规则配置

@RequestMapping("/flow")
@SentinelResource(value = "flow",blockHandler = "flowBlockHandler")
public String flow() throws InterruptedException {
    return "正常访问";
}
public String flowBlockHandler(BlockException e){
    return "流控";
}

   public String flowBlockHandler(BlockException e){
        return "流控";
    }
    @RequestMapping("/flowThread")
    @SentinelResource(value = "flowThread",blockHandler = "flowBlockHandler")
    public String flowThread() throws InterruptedException {
        TimeUnit.SECONDS.sleep(15);
        System.out.println("正常访问");
        return "正常访问";
    }

public class Result<T> {
    private Integer code;
    private String msg;
    private T data;
    public Result(Integer code, String msg, T data) {
        this.code = code;
        this.msg = msg;
        this.data = data;
    }
    public Result(Integer code, String msg) {
        this.code = code;
        this.msg = msg;
    }
    public Integer getCode() {
        return code;
    }
    public void setCode(Integer code) {
        this.code = code;
    }
    public String getMsg() {
        return msg;
    }
    public void setMsg(String msg) {
        this.msg = msg;
    }
    public T getData() {
        return data;
    }
    public void setData(T data) {
        this.data = data;
    }
    public static Result error(Integer code, String msg){
        return new Result(code,msg);
    }
}

@Component
public class MyBlockExceptionHandler implements BlockExceptionHandler {
    Logger log= LoggerFactory.getLogger(this.getClass());
    @Override
    public void handle(HttpServletRequest httpServletRequest, HttpServletResponse response, BlockException e) throws Exception {
        // getRule() 资源  规则的详细信息
        log.info("BlockExceptionHandler BlockException================"+e.getRule());
        Result r = null;
        if (e instanceof FlowException) {
            r = Result.error(100,"接口限流了");
        } else if (e instanceof DegradeException) {
            r = Result.error(101,"服务降级了");
        } else if (e instanceof ParamFlowException) {
            r = Result.error(102,"热点参数限流了");
        } else if (e instanceof SystemBlockException) {
            r = Result.error(103,"触发系统保护规则了");
        } else if (e instanceof AuthorityException) {
            r = Result.error(104,"授权规则不通过");
        }
        //返回json数据
        response.setStatus(500);
        response.setCharacterEncoding("utf-8");
        response.setContentType(MediaType.APPLICATION_JSON_VALUE);
        new ObjectMapper().writeValue(response.getWriter(), r);
    }
}

@RestController
@RequestMapping("/order")
public class OrderSentinelController {
    @RequestMapping("/flow")
//    @SentinelResource(value = "flow",blockHandler = "flowBlockHandler")
    public String flow() throws InterruptedException {
        return "正常访问";
    }
    public String flowBlockHandler(BlockException e){
        return "流控";
    }
    @RequestMapping("/flowThread")
//    @SentinelResource(value = "flowThread",blockHandler = "flowBlockHandler")
    public String flowThread() throws InterruptedException {
        TimeUnit.SECONDS.sleep(15);
        System.out.println("正常访问");
        return "正常访问";
    }
    @RequestMapping("/add")
    public String add(){
        System.out.println("下单成功!");
        return "Hello World";
    }
}

public interface IOrderService {
    String getUser();
}
@Service
public class OrderSericeImpl implements IOrderService {
    @Override
    @SentinelResource(value="getUser",blockHandler = "blockHandlerGetUser")//把它定义成了sentinel的资源
    public String getUser() {
        return "查询用户";
    }
    public String blockHandlerGetUser(BlockException e) {
        return "流控用户";
    }
}

@RestController
@RequestMapping("/order")
public class OrderSentinelController {
        @Autowired
    IOrderService orderService;
    @RequestMapping("test1")
    public String test1(){
        return orderService.getUser();
    }
    @RequestMapping("test2")
    public String  test2(){
        return orderService.getUser();
    }
}

spring.cloud.sentinel.web‐context‐unify: false

  慢调用比例 ( SLOW_REQUEST_RATIO )：选择以慢调用比例作为阈值，需要设置允许的慢调用 RT（即最大的响应时间），请求的响应时间大于该值则统计为慢调用。**当单位统计时长（ statIntervalMs ）内请求数目大于设置的最小请求数目，并且慢调用的比例大于阈值，则接下来的熔断时长内请求会自动被熔断。**经过熔断时长后熔断器会进入探测恢复状态（HALF­OPEN 状态），若接下来的一个请求响应时间小于设置的慢调用 RT 则结束熔断，若大于设置的慢调用 RT 则会再次被熔断。

/**
 * 热点规则，必须使用@SentinelResource
 * @param id
 * @return
 * @throws InterruptedException
 */
@RequestMapping("/get/{id}")
@SentinelResource(value = "getById",blockHandler = "HotBlockHandler") 
public String getById(@PathVariable("id") Integer id) throws InterruptedException {
    System.out.println("正常访问");
    return "正常访问";
}
public String HotBlockHandler(@PathVariable("id") Integer id,BlockException e) throws InterruptedException {
    return "热点异常处理";
}