5、服务熔断降级

<!-- 导入熔断器的启动器 -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>

@SpringBootApplication
@EnableEurekaClient
@EnableCircuitBreaker
public class OrdersApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrdersApplication.class,args);
    }

    @Bean
    @LoadBalanced
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }
}

@RestController
@RequestMapping("/orders")
public class OrdersController {   
    //如果该方法或服务提供者发生异常，那么会执行熔断降级方法
    @HystrixCommand(defaultFallback = "errorResult")
    @GetMapping("/findAllProduct")
    public ResultVO findAllProduct(Integer num){
        System.out.println(1 / num);
        ResultVO resultVO = restTemplate.getForObject("http://star-product/product/findAllProduct",ResultVO.class);
        return resultVO;
    }
    //熔断降级方法
    public ResultVO errorResult(){
        return ResultVO.fail("降级处理！");
    }
}

feign:
  hystrix:
    enabled: true

@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients
@EnableCircuitBreaker
public class OrdersApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrdersApplication.class,args);
    }
}

//fallback声明了用于降级处理类
@FeignClient(value = "star-product",fallback = ProductServerFeignImpl.class)
public interface ProductServerFeign {

    @GetMapping("/product/findAllByNum/{num}")
    ResultVO findAllByNum(@PathVariable("num") Integer num);
}

//需要被spring容器管理
@Component
public class ProductServerFeignImpl implements ProductServerFeign {

    public ResultVO findAllByNum(Integer num) {
        return ResultVO.fail("触发降级处理！");
    }
}

@RestController
@RequestMapping("/product")
public class ProductController {
    @Autowired
    private ProductService productService;
    //如果参数为1，则引发异常；如果参数为2，则引发超时
    @GetMapping("/findAllByNum/{num}")
    public ResultVO findAllByNum(@PathVariable("num") Integer num) throws InterruptedException {
        if(num == 1){
            System.out.println(1/0);
        }
        if(num == 2){
            Thread.sleep(2000);
        }
        List<Product> list =  productService.findAllProduct();
        return ResultVO.success("查询所有商品成功",list);
    }
}

hystrix:
  command:
    default:
      circuitBreaker:
        requestVolumeThreshold: 20 #10S范围内，熔断器至少接收20个请求，才会执行熔断判断逻辑，默认20个
        sleepWindowInMilliseconds: 5000  #熔断以后，5S内，熔断器的状态都出于半开状态，默认5秒
        errorThresholdPercentage: 50 #10S范围内，超过50%的请求出问题，服务开始熔断，默认50%
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 1000   #超过1秒钟，微服务调用将超时，默认1秒

@HystrixCommand(fallbackMethod="fallback",
	commandProperties = {
	     @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "1000" )
	}
)

hystrix:
  command:
    service-id:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 3000

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

server:
  port: 7070
spring:
  application:
    name: hystrix-dashBoard

@SpringBootApplication
@EnableHystrixDashboard
public class DashBoardApplication {
    public static void main(String[] args) {
        SpringApplication.run(DashBoardApplication.class,args);
    }
}

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

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

/**
 * 此配置是为了服务监控而配置，与服务器容器本身无关，springcloud升级后的坑
 * ServletRegistrationBean因为springboot的默认路径不是/hystrix.stream
 * 只要在自己的项目里配置下面的servlet就可以了
 */
@Bean
public ServletRegistrationBean getServlet() {
    HystrixMetricsStreamServlet streamServlet = new HystrixMetricsStreamServlet();
    ServletRegistrationBean registrationBean = new ServletRegistrationBean(streamServlet);
    registrationBean.setLoadOnStartup(1);
    registrationBean.addUrlMappings("/hystrix.stream");
    registrationBean.setName("HystrixMetricsStreamServlet");
    return registrationBean;
}

hystrix:
  dashboard:
    proxy-stream-allow-list: "localhost"

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

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

spring:
  cloud:
	sentinel:
      transport:
        port: 9999 # 与控制台交流的端口，随意指定一个未使用的端口即可
        dashboard: localhost:9090 # 指定控制台服务的地址

@Component
public class MyRequestOriginParser implements RequestOriginParser {
    @Override
    public String parseOrigin(HttpServletRequest httpServletRequest) {
        String comefrom = httpServletRequest.getParameter("comefrom");
        return comefrom;
    }
}

@Component
public class MyUrlBlockHandler implements UrlBlockHandler {
    @Override
    public void blocked(HttpServletRequest request, HttpServletResponse response, BlockException e) throws IOException {
        response.setContentType("application/json;charset=utf-8");

        ResultVO r = null;
        //BlockException  异常接口,包含Sentinel的五个异常
        //1、  FlowException  限流异常
        //2、  DegradeException  降级异常
        //3、  ParamFlowException  参数限流异常
        //4、  AuthorityException  授权异常
        //5、  SystemBlockException  系统负载异常
        if (e instanceof FlowException) {
            r = new ResultVO(-1, "接口被限流了...");
        } else if (e instanceof DegradeException) {
            r = new ResultVO(-2, "接口被降级了...");
        }
        response.getWriter().write(JSON.toJSONString(r));
    }
}

//blockHandler声明的方法需要有参数为BlockException，用于接收抛出的规则的异常
//fallbackHandler，用于其他异常
@SentinelResource(value = "test",blockHandler = "paramFlowHadler",fallback = "fallbackHandler")

public class FilePersistence implements InitFunc {
    @Override
    public void init() throws Exception {
        // TIPS: 如果你对这个路径不喜欢，可修改为你喜欢的路径
        String ruleDir = System.getProperty("user.home") + "/sentinel/rules";
        System.out.println(ruleDir);
        String flowRulePath = ruleDir + "/flow-rule.json";
        String degradeRulePath = ruleDir + "/degrade-rule.json";
        String systemRulePath = ruleDir + "/system-rule.json";
        String authorityRulePath = ruleDir + "/authority-rule.json";
        String paramFlowRulePath = ruleDir + "/param-flow-rule.json";

        this.mkdirIfNotExits(ruleDir);
        this.createFileIfNotExits(flowRulePath);
        this.createFileIfNotExits(degradeRulePath);
        this.createFileIfNotExits(systemRulePath);
        this.createFileIfNotExits(authorityRulePath);
        this.createFileIfNotExits(paramFlowRulePath);

        // 流控规则
        ReadableDataSource<String, List<FlowRule>> flowRuleRDS = new FileRefreshableDataSource<>(
            flowRulePath,
            flowRuleListParser
        );
        // 将可读数据源注册至FlowRuleManager
        // 这样当规则文件发生变化时，就会更新规则到内存
        FlowRuleManager.register2Property(flowRuleRDS.getProperty());
        WritableDataSource<List<FlowRule>> flowRuleWDS = new FileWritableDataSource<>(
            flowRulePath,
            this::encodeJson
        );
        // 将可写数据源注册至transport模块的WritableDataSourceRegistry中
        // 这样收到控制台推送的规则时，Sentinel会先更新到内存，然后将规则写入到文件中
        WritableDataSourceRegistry.registerFlowDataSource(flowRuleWDS);

        // 降级规则
        ReadableDataSource<String, List<DegradeRule>> degradeRuleRDS = new FileRefreshableDataSource<>(
            degradeRulePath,
            degradeRuleListParser
        );
        DegradeRuleManager.register2Property(degradeRuleRDS.getProperty());
        WritableDataSource<List<DegradeRule>> degradeRuleWDS = new FileWritableDataSource<>(
            degradeRulePath,
            this::encodeJson
        );
        WritableDataSourceRegistry.registerDegradeDataSource(degradeRuleWDS);

        // 系统规则
        ReadableDataSource<String, List<SystemRule>> systemRuleRDS = new FileRefreshableDataSource<>(
            systemRulePath,
            systemRuleListParser
        );
        SystemRuleManager.register2Property(systemRuleRDS.getProperty());
        WritableDataSource<List<SystemRule>> systemRuleWDS = new FileWritableDataSource<>(
            systemRulePath,
            this::encodeJson
        );
        WritableDataSourceRegistry.registerSystemDataSource(systemRuleWDS);

        // 授权规则
        ReadableDataSource<String, List<AuthorityRule>> authorityRuleRDS = new FileRefreshableDataSource<>(
            authorityRulePath,
            authorityRuleListParser
        );
        AuthorityRuleManager.register2Property(authorityRuleRDS.getProperty());
        WritableDataSource<List<AuthorityRule>> authorityRuleWDS = new FileWritableDataSource<>(
            authorityRulePath,
            this::encodeJson
        );
        WritableDataSourceRegistry.registerAuthorityDataSource(authorityRuleWDS);

        // 热点参数规则
        ReadableDataSource<String, List<ParamFlowRule>> paramFlowRuleRDS = new FileRefreshableDataSource<>(
            paramFlowRulePath,
            paramFlowRuleListParser
        );
        ParamFlowRuleManager.register2Property(paramFlowRuleRDS.getProperty());
        WritableDataSource<List<ParamFlowRule>> paramFlowRuleWDS = new FileWritableDataSource<>(
            paramFlowRulePath,
            this::encodeJson
        );
        ModifyParamFlowRulesCommandHandler.setWritableDataSource(paramFlowRuleWDS);
    }

    private Converter<String, List<FlowRule>> flowRuleListParser = source -> JSON.parseObject(
        source,
        new TypeReference<List<FlowRule>>() {
        }
    );
    private Converter<String, List<DegradeRule>> degradeRuleListParser = source -> JSON.parseObject(
        source,
        new TypeReference<List<DegradeRule>>() {
        }
    );
    private Converter<String, List<SystemRule>> systemRuleListParser = source -> JSON.parseObject(
        source,
        new TypeReference<List<SystemRule>>() {
        }
    );

    private Converter<String, List<AuthorityRule>> authorityRuleListParser = source -> JSON.parseObject(
        source,
        new TypeReference<List<AuthorityRule>>() {
        }
    );

    private Converter<String, List<ParamFlowRule>> paramFlowRuleListParser = source -> JSON.parseObject(
        source,
        new TypeReference<List<ParamFlowRule>>() {
        }
    );

    private void mkdirIfNotExits(String filePath) throws IOException {
        File file = new File(filePath);
        if (!file.exists()) {
            file.mkdirs();
        }
    }

    private void createFileIfNotExits(String filePath) throws IOException {
        File file = new File(filePath);
        if (!file.exists()) {
            file.createNewFile();
        }
    }

    private <T> String encodeJson(T t) {
        return JSON.toJSONString(t);
    }
}

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

feign:
  sentinel:
    enabled: true

//自定义类实现feign接口
@Service
public class ProductFallback implements IProductService {
    @Override
    public ResultVO findAllProduct() {
        return ResultVO.success("使用ProductFallback的备用方法");
    }
}

@FeignClient(
    value = "star-product",
    fallback = ProductFallback.class
)

//自定义类实现FallbackFactory接口，泛型为feign接口
@Service
public class ProductFallbackFactory implements FallbackFactory<IProductService> {
    @Override
    public IProductService create(Throwable throwable) {
        System.out.println("ProductFallbackFactory.create:"+throwable);
        return new IProductService() {
            @Override
            public ResultVO findAllProduct() {
                return ResultVO.success("这是ProductFallbackFactory中的备用方法！！");
            }
        };
    }
}

@FeignClient(
    value = "star-product",
    fallbackFactory = ProductFallbackFactory.class
)