4.1 高并发带来的问题
在微服务架构中，我们将业务拆分成一个个的服务，服务与服务之间可以相互调用，但是由于网络原因或者自身的原因，服务并不能保证服务的100%可用，如果单个服务出现问题，调用这个服务就会出现网络延迟，此时若有大量的网络涌入，会形成任务堆积，最终导致服务瘫痪。
例如: 对于一个依赖于30个服务的应用程序，每个服务都有99.99%的正常运行时间，你可以期望如下：
99.9930 = 99.7% 可用
也就是说一亿个请求的0.3% = 3000000 会失败
接下来，我们来模拟一个高并发的场景
1 编写java代码
@GetMapping("/order/prod/{pid}")
public Order order(@PathVariable("pid")Integer pid){
log.info(">>客户下单，这时候要调用商品微服务查询商品信息");
//这里直接使用productFeign调用接口中的方法，和我们原来controller调用service一样啊
Product product = productFeign.findById(pid);
//这里模拟shop-product 响应时间为2秒
try {
Thread.sleep(2000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
log.info(">>商品信息,查询结果:" + JSON.toJSONString(product));
Order order = new Order();
order.setPid(product.getPid());
order.setPname(product.getPname());
order.setPprice(product.getPprice());
order.setNumber(1);
//为了不产生大量冗余数据 我们把添加订单的调用注释
//orderService.save(order);
return order;
}
@RequestMapping("order/ceshi")
public String ceshi(){
return "这是测试数据";
}2 修改application.yml
server:
port: 8091
tomcat: # 为了测试方便 我们把Tomcat中最大的线程数改为10个
max-threads: 103 接下来使用压测工具,对请求进行压力测试
下载地址https://jmeter.apache.org/
第一步：修改配置，并启动软件
进入bin目录,修改jmeter.properties文件中的语言支持为language=zh_CN，然后点击jmeter.bat
启动软件。
第二步：添加线程组
第三步：配置线程并发数
第四步：添加Http取样
第五步：配置取样，并启动测试
第六步：访问ceshi方法观察效果
结论:
此时会发现, 由于a方法囤积了大量请求, 导致b方法的访问出现了问题，这就是服务雪崩的雏形。
4.2 服务雪崩效应
在分布式系统中,由于网络原因或自身的原因,服务一般无法保证 100% 可用。如果一个服务出现了问题，调用这个服务就会出现线程阻塞的情况，此时若有大量的请求涌入，就会出现多条线程阻塞等待，进而导致服务瘫痪。
由于服务与服务之间的依赖性，故障会传播，会对整个微服务系统造成灾难性的严重后果，这就是服务故障的 “雪崩效应” 。
雪崩发生的原因多种多样，有不合理的容量设计，或者是高并发下某一个方法响应变慢，亦或是某台机器的资源耗尽。我们无法完全杜绝雪崩源头的发生，只有做好足够的容错，保证在一个服务发生问题，不会影响到其它服务的正常运行。也就是＂雪落而不雪崩＂。
4.3 常见容错方案
要防止雪崩的扩散，我们就要做好服务的容错，容错说白了就是保护自己不被猪队友拖垮的一些措施, 下面介绍常见的服务容错思路和组件。
常见的容错思路 ----> 造出相应得产品
常见的容错思路有隔离、超时、限流、熔断、降级这几种，下面分别介绍一下。
隔离
它是指将系统按照一定的原则划分为若干个方法模块，各个模块之间相对独立，无强依赖。当有故障发生时，能将问题和影响隔离在某个模块内部，而不扩散风险，不波及其它模块，不影响整体的 系统服务。
超时
在上游服务调用下游服务的时候，设置一个最大响应时间，如果超过这个时间，下游未作出反应，
就断开请求，释放掉线程。
限流
限流就是限制系统的输入和输出流量已达到保护系统的目的。一般来说系统的吞吐量是可以被测算的，为了保证系统的稳固运行，一旦达到的需要限制的阈值，就需要限制流量并采取少量措施以完成限制流量的目的。比方：推迟解决，拒绝解决，或者者部分拒绝解决等等。
熔断 在互联网系统中，当下游服务因访问压力过大而响应变慢或失败，上游服务为了保护系统整
体的可用性，可以暂时切断对下游服务的调用。这种牺牲局部，保全整体的措施就叫做熔断。
服务熔断一般有三种状态：
（1）熔断关闭状态（Closed）
服务没有故障时，熔断器所处的状态，对调用方的调用不做任何限制
（2）熔断开启状态（Open）
后续对该服务接口的调用不再经过网络，直接执行本地的fallback方法
（3）半熔断状态（Half-Open）
尝试恢复服务调用，允许有限的流量调用该服务，并监控调用成功率。如果成功率达到预期，则说明服务已恢复，进入熔断关闭状态；如果成功率仍旧很低，则重新进入熔断关闭状态。
降级
降级其实就是为服务提供一个托底方案，一旦服务无法正常调用，就使用托底方案。
常见的容错组件 hystrix sentinel
Hystrix
Hystrix是由Netflix开源的一个延迟和容错库，用于隔离访问远程系统、服务或者第三方库，防止级联失败，从而提升系统的可用性与容错性。
Resilience4J
Resilicence4J一款非常轻量、简单，并且文档非常清晰、丰富的熔断工具，这也是Hystrix官方推荐的替代产品。不仅如此，Resilicence4j还原生支持Spring Boot 1.x/2.x，而且监控也支持和 prometheus等多款主流产品进行整合。
Sentinel
Sentinel 是阿里巴巴开源的一款断路器实现，本身在阿里内部已经被大规模采用，非常稳定。
下面是三个组件在各方面的对比：
为什么需要使用服务容错管理。
如何保存服务的容错? (1.限流 2. 隔离 3.超时 4.熔断降级)
容错的组件有哪些? (hystrix, sentinel) 微服务第二代
4.4 Sentinel入门
4.4.1 什么是Sentinel
Sentinel (分布式系统的流量防卫兵) 是阿里开源的一套用于服务容错的综合性解决方案。它以流量为切入点, 从流量控制、熔断降级、系统负载保护等多个维度来保护服务的稳定性。
Sentinel 分为两个部分:
核心库（Java 客户端 微服务） 不依赖任何框架/库,能够运行于所有 Java 运行时环境，同时对 Dubbo /Spring Cloud 等框架也有较好的支持。
控制台（Dashboard==sentinel服务）基于 Spring Boot 开发，打包后可以直接运行，不需要额外的 Tomcat 等应用容器
4.4.2 微服务集成Sentinel
为微服务集成Sentinel非常简单, 只需要加入Sentinel的依赖即可
1 在pom.xml中加入下面依赖
<!--引入sentinal的依赖jar文件-->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>2 编写一个Controller测试使用
@RestController
@Slf4j
public class OrderController2 {
@RequestMapping("order/message1")
public String message1(){
return "message1";
}
@RequestMapping("order/message2")
public String message2(){
return "message2";
}
}4.4.3 安装Sentinel控制台
Sentinel 提供一个轻量级的控制台, 它提供机器发现、单机资源实时监控以及规则管理等功能。
1 下载jar包,解压到文件夹
https://github.com/alibaba/Sentinel/releases
2 启动控制台
java -jar sentinel-dashboard-1.7.0.jar# 直接使用jar命令启动项目(控制台本身是一个SpringBoot项目)
java -Dserver.port=8888 -Dcsp.sentinel.dashboard.server=localhost:8888 -
Dproject.name=sentinel-dashboard -jar sentinel-dashboard-1.7.0.jar3 修改 shop-order ,在里面加入有关控制台的配置
spring:
cloud:
sentinel:
transport:
port: 9999 # 该端口号为sentinal于服务之间的交互 随便写只要不被占用
dashboard: localhost:8888 #sentinal服务所在的地址和端口号第4步: 通过浏览器访问localhost:8080 进入控制台 ( 默认用户名密码是 sentinel/sentinel )
补充：了解控制台的使用原理
Sentinel的控制台其实就是一个SpringBoot编写的程序。我们需要将我们的微服务程序注册到控制台上, 即在微服务中指定控制台的地址, 并且还要开启一个跟控制台传递数据的端口, 控制台也可以通过此端口调用微服务中的监控程序获取微服务的各种信息。
4.4.4 实现一个接口的限流
1 通过控制台为message1添加一个流控规则
2 通过控制台快速频繁访问, 观察效果
4.5 Sentinel的概念和功能
4.5.1 基本概念
资源
资源: 就是sentinel要保护的内容。
资源是 Sentinel 的关键概念。它可以是 Java 应用程序中的任何内容，可以是一个服务，也可以是
一个方法，甚至可以是一段代码。
| 我们入门案例中的message1方法就可以认为是一个资源
规则
规则: 以什么的方式来保护你的资源。
作用在资源之上, 定义以什么样的方式保护资源，主要包括流量控制规则、熔断降级规则以及系统
保护规则。
| 我们入门案例中就是为message1资源设置了一种流控规则, 限制了进入message1的流量
4.5.2 重要功能
Sentinel的主要功能就是容错，主要体现为下面这三个：
流量控制
流量控制在网络传输中是一个常用的概念，它用于调整网络包的数据。任意时间到来的请求往往是随机不可控的，而系统的处理能力是有限的。我们需要根据系统的处理能力对流量进行控制。Sentinel 作为一个调配器，可以根据需要把随机的请求调整成合适的形状。
熔断降级
当检测到调用链路中某个资源出现不稳定的表现，例如请求响应时间长或异常比例升高的时候，则对这个资源的调用进行限制，让请求快速失败，避免影响到其它的资源而导致级联故障。Sentinel 对这个问题采取了两种手段:
（1）通过并发线程数进行限制
Sentinel 通过限制资源并发线程的数量，来减少不稳定资源对其它资源的影响。当某个资源出现不稳定的情况下，例如响应时间变长，对资源的直接影响就是会造成线程数的逐步堆积。当线程数在特定资源上堆积到一定的数量之后，对该资源的新请求就会被拒绝。堆积的线程完成任务后才开始继续接收请求。
（2）通过响应时间对资源进行降级
除了对并发线程数进行控制以外，Sentinel 还可以通过响应时间来快速降级不稳定的资源。当依赖的资源出现响应时间过长后，所有对该资源的访问都会被直接拒绝，直到过了指定的时间窗口之后才重新恢复。
总之一句话: 我们需要做的事情，就是在Sentinel的资源上配置各种各样的规则，来实现各种容错的功能。
4.6 Sentinel规则
4.6.1 流控规则
流量控制，其原理是监控应用流量的QPS(每秒查询率) 或并发线程数等指标，当达到指定的阈值时对流量进行控制，以避免被瞬时的流量高峰冲垮，从而保障应用的高可用性。
第1步: 点击簇点链路,我们就可以看到访问过的接口地址，然后点击对应的流控按钮，进入流控规则配置页面。新增流控规则界面如下:
资源名：唯一名称，默认是请求路径，可自定义
针对来源：指定对哪个微服务进行限流，默认指default，意思是不区分来源，全部限制
阈值类型/单机阈值：
- QPS（每秒请求数量）: 当调用该接口的QPS达到阈值的时候，进行限流
- 线程数：当调用该接口的线程数达到阈值的时候，进行限流
是否集群：暂不需要集群
接下来我们以QPS为例来研究限流规则的配置
4.6.1.1 简单配置
我们先做一个简单配置，设置阈值类型为QPS，单机阈值为3。即每秒请求量大于3的时候开始限流
接下来，在流控规则页面就可以看到这个配置
然后快速访问 /order/message1 接口，观察效果。此时发现，当QPS > 3的时候，服务就不能正常响应，而是返回Blocked by Sentinel (flflow limiting)结果。
4.6.1.2 配置流控模式
点击上面设置流控规则的编辑按钮，然后在编辑页面点击高级选项，会看到有流控模式一栏。
sentinel共有三种流控模式，分别是：
- 直接（默认）：接口达到限流条件时，开启限流
- 关联：当关联的资源达到限流条件时，开启限流 [适合做应用让步]
- 链路：当从某个接口过来的资源达到限流条件时，开启限流
下面呢分别演示三种模式：
直接流控模式
直接流控模式是最简单的模式，当指定的接口达到限流条件时开启限流。上面案例使用的就是直接流控模式。
关联流控模式
关联流控模式指的是，当指定接口关联的接口达到限流条件时，开启对指定接口开启限流。
第1步：配置限流规则, 将流控模式设置为关联，关联资源设置为的 /order/message2。
第2步：访问/order/message1,会发现已经被限流
链路流控模式（了解）
链路流控模式指的是，当从某个接口过来的资源达到限流条件时，开启限流。它的功能有点类似于针对来源配置项，区别在于：针对来源是针对上级微服务，而链路流控是针对上级接口，也就是说它的粒度更细。
第1步： 编写一个service，在里面添加一个方法message
@Service
public class OrderServiceImpl3 {
@SentinelResource("message")
public void message() {
System.out.println("message");
}
}第2步： 在Controller中声明两个方法，分别调用service中的方法
@RestController
@Slf4j
public class OrderController3 {
@Autowired
private OrderServiceImpl3 orderServiceImpl3;
@RequestMapping("/order/message1")
public String message1() {
orderServiceImpl3.message();
return "message1";
}
@RequestMapping("/order/message2")
public String message2() {
orderServiceImpl3.message();
return "message2";
}
}
第3步: 禁止收敛URL的入口 context
从1.6.3 版本开始，Sentinel Web fifilter默认收敛所有URL的入口context，因此链路限流不生效。
1.7.0 版本开始（对应SCA的2.1.1.RELEASE)，官方在CommonFilter 引入了
WEB_CONTEXT_UNIFY 参数，用于控制是否收敛context。将其配置为 false 即可根据不同的
URL 进行链路限流。
SCA 2.1.1.RELEASE之后的版本,可以通过配置spring.cloud.sentinel.web-context-unify=false即
可关闭收敛
我们当前使用的版本是SpringCloud Alibaba 2.1.0.RELEASE，无法实现链路限流。
目前官方还未发布SCA 2.1.2.RELEASE，所以我们只能使用2.1.1.RELEASE，需要写代码的形式实现
(1) 暂时将SpringCloud Alibaba的版本调整为2.1.1.RELEASE
(1) 暂时将SpringCloud Alibaba的版本调整为2.1.1.RELEASE(2) 配置文件中关闭sentinel的CommonFilter实例化
spring:
cloud:
sentinel:
filter:
enabled: false(3) 添加一个配置类，自己构建CommonFilter实例
@Configuration
public class FilterContextConfig {
@Bean
public FilterRegistrationBean sentinelFilterRegistration() {
FilterRegistrationBean registration = new FilterRegistrationBean();
registration.setFilter(new CommonFilter());
registration.addUrlPatterns("/*");
// 入口资源关闭聚合
registration.addInitParameter(CommonFilter.WEB_CONTEXT_UNIFY, "false");
registration.setName("sentinelFilter");
registration.setOrder(1);
return registration;
}
} （4） 控制台配置限流规则
（5）分别通过 /order/message1 和 /order/message2 访问, 发现2没问题, 1的被限流了
4.6.1.3 配置流控效果
- 快速失败（默认）: 直接失败，抛出异常，不做任何额外的处理，是最简单的效果
- Warm Up：它从开始阈值到最大QPS阈值会有一个缓冲阶段，一开始的阈值是最大QPS阈值的1/3，然后慢慢增长，直到最大阈值，适用于将突然增大的流量转换为缓步增长的场景。
- 排队等待：让请求以均匀的速度通过，单机阈值为每秒通过数量，其余的排队等待； 它还会让设置一个超时时间，当请求超过超时间时间还未处理，则会被丢弃。
4.6.2 降级规则
降级规则就是设置当满足什么条件的时候，对服务进行降级。Sentinel提供了三个衡量条件：
平均响应时间 ：当资源的平均响应时间超过阈值（以 ms 为单位）之后，资源进入准降级状态。如果接下来 1s 内持续进入 5 个请求，它们的 RT都持续超过这个阈值，那么在接下的时间窗口（以 s 为单位）之内，就会对这个方法进行服务降级。
异常比例：
当资源的每秒请求量>=5,并且每秒异常总数占通过量的比值超过阈值之后，资源进入降级状态，即在接下的时间窗口智能，对这个方法的调用都会自动地返回。异常比率的阈值范围是[0.0,1.0],代表0%~100%
第1步: 首先模拟一个异常
private int i=0;
@RequestMapping("order/message2")
public String message2(){
i++;
if(i%3==0){
throw new RuntimeException("异常");
}
return "message2";
}
第2步: 设置异常比例为0.25
异常数 ：当资源近 1 分钟的异常数目超过阈值之后会进行服务降级。注意由于统计时间窗口是分钟级别的，若时间窗口小于 60s，则结束熔断状态后仍可能再进入熔断状态。
4.6.3 热点规则
热点参数流控规则是一种更细粒度的流控规则, 它允许将规则具体到参数上。
热点规则简单使用
第1步: 编写代码
@RequestMapping("/order/message3")
@SentinelResource(value = "message3")
//注意这里必须使用这个注解标识,热点规则不生效
public String message3(String name, Integer age) { return name + age; }
第2步: 分别用两个参数访问,会发现只对第一个参数限流了
热点规则增强使用
参数例外项允许对一个参数的具体值进行流控编辑刚才定义的规则,增加参数例外项
扩展: 自定义异常返回
//异常处理页面
@Component
public class ExceptionHandlePage implements UrlBlockHandler {
//BlockException 异常接口,包含Sentinel的五个异常
// FlowException 限流异常
// DegradeException 降级异常
// ParamFlowException 参数限流异常
// AuthorityException 授权异常
// SystemBlockException 系统负载异常
@Override
public void blocked(HttpServletRequest request, HttpServletResponse response, BlockException e) throws IOException {
response.setContentType("application/json;charset=utf-8");
ResponseData data = null;
if (e instanceof FlowException) {
data = new ResponseData(-1, "接口被限流了...");
}
else if (e instanceof DegradeException) {
data = new ResponseData(-2, "接口被降级了...");
}
response.getWriter().write(JSON.toJSONString(data));
}
@Data
@AllArgsConstructor
@NoArgsConstructor
class ResponseData{
private Integer id;
private String msg;
}
}思考：如果订单服务调用商品服务时，商品服务出错，那么就会导致订单服务也给客户显示错误，我们应该设置一个兜底的方法。可以使用sentinelSource中的fallback属性
4.7 Feign整合sentinel
第1步: 引入sentinel的依赖
<!--引入sentinal的依赖jar文件-->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>第2步: 在配置文件中开启Feign对Sentinel的支持
feign:
sentinel:
enabled: true 第3步: 创建容错类
@Component
public class ProductFeignHandler implements ProductFeign {
@Override
public Product findById(Integer pid) {
return null;
}
public Product find2(@PathVariable("pid") Integer pid){
Product product = new Product();
product.setPid(-1);
product.setPname("服务出错");
return product;
}
}第4步: 为被容器的接口指定容错类
@FeignClient(value = "shop-product",fallback = ProductFeignHandler.class)
public interface ProductFeign {
@RequestMapping("/product/{pid}")
public Product findById(@PathVariable("pid") Integer pid);
@RequestMapping("/find2/{pid}")
public Product find2(@PathVariable("pid") Integer pid);
}第5步: 修改controller
@GetMapping("/order/prod/{pid}")
public Order order(@PathVariable("pid")Integer pid){
log.info(">>客户下单，这时候要调用商品微服务查询商品信息");
//这里直接使用productFeign调用接口中的方法，和我们原来controller调用service一样啊
Product product = productFeign.find2(pid);
if(product.getPid()==-1){
Order order = new Order();
order.setPname("下单失败");
return order;
}
log.info(">>商品信息,查询结果:" + JSON.toJSONString(product));
Order order = new Order();
order.setPid(product.getPid());
order.setPname(product.getPname());
order.setPprice(product.getPprice());
order.setNumber(1);
order.setUid(1);
order.setUsername("闫克起");
//为了不产生大量冗余数据 我们把添加订单的调用注释
//orderService.save(order);
return order;
}第6步: 停止所有 shop-product 服务,重启 shop-order 服务,访问请求,观察容错效果
扩展: 如果想在容错类中拿到具体的错误,可以使用下面的方式
@FeignClient(
value = "service-product",
//fallback = ProductServiceFallBack.class,
fallbackFactory = ProductServiceFallBackFactory.class)
public interface ProductService {
//@FeignClient的value + @RequestMapping的value值 其实就是完成的请求地址
"http://service-product/product/" + pid
@RequestMapping("/product/{pid}")//指定请求的URI部分
Product findByPid(@PathVariable Integer pid);
}@Component
public class ProductServiceFallBackFactory implements
FallbackFactory<ProductService> {
@Override
public ProductService create(Throwable throwable) {
return new ProductService() {
@Override
public Product findByPid(Integer pid) {
throwable.printStackTrace();
Product product = new Product();
product.setPid(-1);
return product;
}
};
}
}注意: fallback和fallbackFactory只能使用其中一种方式
4.8 Sentinel规则持久化
通过前面的讲解，我们已经知道，可以通过Dashboard来为每个Sentinel客户端设置各种各样的规则，但是这里有一个问题，就是这些规则默认是存放在内存中，极不稳定，所以需要将其持久化。
本地文件数据源会定时轮询文件的变更，读取规则。这样我们既可以在应用本地直接修改文件来更新规则，也可以通过 Sentinel 控制台推送规则。以本地文件数据源为例，推送过程如下图所示：
首先 Sentinel 控制台通过 API 将规则推送至客户端并更新到内存中，接着注册的写数据源会将新的规则保存到本地的文件中。
1 编写处理类
public class FilePersistence implements InitFunc {
@Value("${spring.application.name}")
private String appcationName;
@Override
public void init() throws Exception {
String ruleDir = System.getProperty("user.home") + "/sentinel-rules/" + appcationName;
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.register2Property(flowRuleRDS.getProperty());
WritableDataSource<List<FlowRule>> flowRuleWDS = new FileWritableDataSource<>(
flowRulePath,
this::encodeJson
);
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);
}
}2 添加配置
在resources下创建配置目录 META-INF/services ,然后添加文件
com.alibaba.csp.sentinel.init.InitFunc
在文件中添加配置类的全路径
com.wmd.config.FilePersistenceHystrix介绍
Hystrix是由Netflix开源的一个延迟和容错库，用于隔离访问远程系统、服务或者第三方库，防止级联失 败，从而提升系统的可用性与容错性。Hystrix主要通过以下几点实现延迟和容错。
- 跳闸机制：当某服务的错误率超过一定的阈值时，Hystrix可以自动或手动跳闸，停止请求该服务一段时间。
- 资源隔离：Hystrix为每个依赖都维护了一个小型的线程池（或者信号量）。如果该线程池已满， 发往该依赖的请求就被立即拒绝，而不是排队等待，从而加速失败判定。
- 监控：Hystrix可以近乎实时地监控运行指标和配置的变化，例如成功、失败、超时、以及被拒绝的请求等。
- 回退机制：当请求失败、超时、被拒绝，或当断路器打开时，执行回退逻辑。回退逻辑由开发人员自行提供，例如返回一个缺省值。
- 自我修复：断路器打开一段时间后，会自动进入“半开”状态。
5804
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
