设计一个秒杀系统之熔断降级

<dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
        </dependency>

@RestController
public class OrderController {

    @Resource
    private OrderService orderService;

    /**
     * 获取订单信息
     */
    @GetMapping("/order")
    public String getOrderInfo(@RequestParam Long orderId) {
        return orderService.orderDetail(orderId);
    }
}

@Service
@EnableHystrix
public class OrderService {

    @HystrixCommand(fallbackMethod = "fallbackException")
    public String orderDetail(Long orderId) {
        //模拟远程调用订单详情服务
        return remoteOrderDetail(orderId);
    }

    /**
     * 远程调用订单失败从缓存获取订单详情
     */
    public String fallbackException(Long orderId) {
        //模拟缓存查询
        return "获取缓存订单成功";
    }

    public String remoteOrderDetail(Long orderId) {
        //模拟调用远程订单详情服务
        if (orderId < 0) {
            throw new IllegalArgumentException("订单号非法");
        }
        return "获取db订单成功";
    }
}

package com.lht.boot.distribution.hystrix;

import com.netflix.hystrix.HystrixCommand;
import com.netflix.hystrix.HystrixCommandGroupKey;
import com.netflix.hystrix.HystrixCommandProperties;


/**
 * 自定义
 */
public class HystrixStubbedFallback extends HystrixCommand<String> {

    public HystrixStubbedFallback() {
        super(setter());

    }

    private static Setter setter() {
        HystrixCommandProperties.Setter commandProperties = HystrixCommandProperties
                .Setter()
                .withExecutionIsolationStrategy(HystrixCommandProperties.ExecutionIsolationStrategy.THREAD)
                //是否 启用降级，如果启用则在超时或异常时调用
                .withFallbackEnabled(true)
                //fallback方法的信号量配置，如果超过了信号量配置，则不会再调用getFallback方法，而是快速失败
                .withFallbackIsolationSemaphoreMaxConcurrentRequests(100)
                //隔离策略为THREAD时，当执行线程执行超时时，是否 进行中断处理，即Future#cancel(true) 处理，默认为false
                .withExecutionIsolationThreadInterruptOnFutureCancel(true)
                //隔离策略为THREAD时，当执行线程执行超时时，是否 进行中断处理，默认为true
                .withExecutionIsolationThreadInterruptOnTimeout(true)
                //是否启用执行超时机制，默认为true
                .withExecutionTimeoutEnabled(true)
                //执行超时时间，默认为1000毫秒，如果命令时线程隔离，且配置了withExecutionIsolationThreadInterruptOnTimeout=true
                //则执行线程中断处理，如果命令是信号量隔离，则进行终止操作，因为信号量隔离与主线程是在一个线程中执行，其不会中断线程处理，所以要
                //根据实际情况来采用是否用信号量隔离，尤其涉及网络访问的情况
                .withExecutionTimeoutInMilliseconds(1000);
        return Setter
                .withGroupKey(HystrixCommandGroupKey.Factory.asKey("ExampleGroup"))
                .andCommandPropertiesDefaults(commandProperties);
    }

   /**
    * 触发业务的方法
    */
    @Override
    protected String run() {
        throw new RuntimeException("failure for example"); //模拟异常用于触发回滚
    }

    /**
    * run方法失败后执行
    */
    @Override
    protected String getFallback() {
        return "有货";
    }


}

@Test
    public void test() {
        HystrixStubbedFallback command = new HystrixStubbedFallback();
        //执行结果
        String result = command.execute();
        //执行是否失败了，如抛出了异常
        boolean failedExecution = command.isFailedExecution();
        //响应是否超时
        boolean responseTimedOut = command.isResponseTimedOut();
        //是否是getFallback返回的响应
        boolean responseFromFallback = command.isResponseFromFallback();
        //获取失败后执行的异常。即run方法抛出的异常
        Throwable failedExecutionException = command.getFailedExecutionException();

        System.out.println("响应是否超时: " + responseTimedOut);
        System.out.println("执行是否失败了: " + failedExecution);
        System.out.println("是否是getFallback返回的响应: " + responseFromFallback);
        System.out.println("返回的结果: " + result);
        System.out.println("获取失败后执行的异常: "+failedExecutionException.getMessage());
    }

<dependency>
            <groupId>com.alibaba.csp</groupId>
            <artifactId>sentinel-core</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
        </dependency>
        <!-- Sentinel 针对 Nacos 作了适配，底层可以采用 Nacos 作为规则配置数据源 -->
        <dependency>
            <groupId>com.alibaba.csp</groupId>
            <artifactId>sentinel-datasource-nacos</artifactId>
        </dependency>

spring：
   cloud:
     sentinel:
       transport:
         dashboard: XXXXXXXXXX:8070 #配置sentinel dashboard地址
         port: 8721 #指定和控制通信的端口，默认值8719，如不设置，会自动从8719开始扫描，依次+1，直到找到未被占用的端口
       datasource:
          #degrade是数据源名，可以自行随意修改
         degrade:
           nacos:
             server-addr: 10.100.217.145:8848
             dataId: ${spring.application.name}-degrade-rules
             groupId: SENTINEL_GROUP
             rule-type: degrade

/**
     * 根据id查询
     *
     * @param id 主键
     * @return 查询结果话题
     */
    @ApiOperation("根据id查询（降级）")
    @ApiImplicitParams({
            @ApiImplicitParam(paramType = PATH, dataType = INTEGER, name = "id", value = "主键id", required = true)
    })
    @GetMapping("/{id}")
    @ResponseBody
    @SentinelResource(value = "tcly-operations-center-degrade-rules", blockHandlerClass = TopicExceptionUtils.class, blockHandler = "queryException")
    public CommonResult<TopicVO> query(@PathVariable Long id) {
        if (id <= 0) {
            //模拟接口运行时抛出异常
            throw new IndexOutOfBoundsException();
        }
        return CommonResult.success(entityToVo(service.getById(id)));
    }

public class TopicExceptionUtils {

    /**
     * 隐藏构造器
     */
    private TopicExceptionUtils(){}
    /**
     * 话题查询降级处理
     * @param id 查询条件
     * @param blockException 降级异常
     * @return 失败结果
     */
    public static CommonResult<TopicVO> queryException(Long id, BlockException blockException) {
        return CommonResult.failed("根据id：" + id + "查询失败，进行降级处理");
    }