使用.NetCore 控制台演示 熔断 降级（polly）

1、熔断降级的概念：

　　　　熔断：我这里有一根长度一米的钢铁，钢铁的熔点1000度（假设），现在我想用力把这根钢铁折弯，但是人的力有限达不到折弯的点，然后我使用火给钢铁加热，每隔一段时间我就会尝试一下是否能折弯，在这个过程中我发现，随着不断的煅烧，折弯钢铁是花费的力气越小，在这个过程出现了意外因为我的疏忽，温度超过了钢铁的熔点了，导致一根变成的两根，和我最初的目的相违背了，早知道当初我装个报警的装置了还可以提想我。

　　如果在这个例子中我们把一根钢铁换成我们程序中的接口（接口能同时承受1000的访问），然后把火替换成我们的接口调用者，当接口的并发超过1000这个点的时候接口将会挂掉，作为调用者并不能控制这个点，当并发量上来的时候导致接口蹦了，为了防止我们的接口发生崩溃的情况，我们做一个报警的设置，当发生这个情况的时候占时切断服务，防止服务崩溃。

　　　降级：接着上一个例子：既然这个钢铁因为一个意外导致变成两个，不能进行使用了，我变找了一个绳子替代一下。

当我们的服务接口发生错误的时候，我们可以找到一个替代方法进行使用。这个方法可能是启用另一台服务器的接口，也可能是只返回“”服务器繁忙请重试的提示“”。总之不会把一个系统级别的问题暴露给用户，让使用者的程序也出现问题。

2、Polly的7中策略

　　　　处理熔断降级的框架本人所知 有NetFlix的Hystrix框架和Polly框架我们将使用Polly进行熔断降级处理。

　　　　Polly的概念：Polly是一个被.net基金会支持认可的框架，Polly是一个.NET弹性和瞬态故障处理库，允许开发人员以流畅和线程安全的方式表达策略，如重试、断路器、超时、舱壁隔离和回退。

　　　　Polly的7种策略：官方文档是这么说的：

　　　　1、重试（Retry）:当程序发生短暂的故障、并且故障在延迟后，可以自动纠正的，前期是暂时的我们可以配置自动重试。

　　　　2、断路器（Circuit-Breaker）:当一个系统陷入严重的问题时，让系统快速的失败，比让用户一直等待着要好的多，保护一个系统不受过载的影响，可以帮助它快速的恢复。

　　　　3、超时（Timeout）:在等待一定的时间后，没有返回相应的结果，保证程序不会一直等待下去，使调用者不必一直的等待下去。

　　　  4、隔离（Bulkhead Isolation）:当进程出现故障的时，一台主机中的多个失败的进程，对资源（例如线程/CPU）的一直占用，当下游的系统发生故障的时候，也可能导致上游对资源的调用失败、这两种风险的出现都将导致更大范围的影响、隔离策略是为了防止“一个点的失败导致整盘的失败”把受到管理的操作固定在某个资源中，避免影响到其他的资源。

　　　　5、缓存（Cache）:针对相同的请求，在第一次访问的时候将响应的数据进行缓存，再次访问的时候直接在缓存中提供响应的数据。

　　　　6、回退（FallBack）：当程序发生失败的情况的时候，我们将做些什么，定义一个在程序发生失败的时候要执行的动作。

　　　　7、策略组合（PolicyWrap）:Polly针对不同的故障有不同的策略，我们可以灵活的组合策略，上述的六种策略可以灵活组合使用。

3、Polly的基本用法

　　　　因为Polly对NetCore的友好支持，下面我们将使用Core的控制台对Polly的几种策略进行简单的演示

　　　　首先创建控制台程序

　　　　

　　　　在Nuget的控制台中使用 Install-Package Polly 命令进行安装

　　　　注意：在创建项目的时候命名尽量不要使用Polly命名

　　　　Polly 每个版本的介绍 https://www.nuget.org/packages/Polly/

　　　　执行命令进行安装如下图所示

　　　　

　　　　首先我们要学会并且指定希望Policy 处理的异常：

　　　

   /*
              *指定Policy希望策略处理的异常/错误
              * 这里只是制定Policy 处理异常的方案不做任何的处理
              */

             //单个不加对异常加条件
             Policy.Handle<Exception>();

             //单个对处理的异常加上条件 这里的条件指明了当异常的 HResult 值为 -2146233088 时处理异常
             Policy.Handle<Exception>(ex => ex.HResult == -);

             //多个使用Or即可 多个不加条件
             Policy.Handle<HttpRequestException>().
                Or<OperationCanceledException>();

             //多个加条件
             Policy.Handle<HttpRequestException>(ex => ex.HResult == ).
                 Or<OperationCanceledException>(ex => ex.HResult == );

             //多个混合加条件
             Policy.Handle<HttpRequestException>().
                 Or<OperationCanceledException>(ex => ex.HResult == ).
                 Or<ArgumentException>(ex => ex.HResult == ).
                 Or<ArgumentException>();

　　　　下面我们指定一个希望Policy处理的异常，并且完成调用

　　　　

  /*
             *指定Policy 处理的异常/错误为  错误的基类 Exception  并且给异常加上条件
             *如果条件不满足则不做任何处理
             * 不作处理程序将会报错

             var PolicyExecute = Policy.Handle<Exception>(ex => ex.HResult == -2146233088).Fallback(() =>//动作
             {
                 Console.WriteLine($"执行出错监控的异常为：Exception 异常 HResult值为：-2146233088 ");
                 //Console.WriteLine($"执行出错监控的异常为：ArgumentException 异常 HResult值为：-2147024809 ");
             });

             //执行
             PolicyExecute.Execute(() =>
             {
                 Console.WriteLine("********************开始执行程序**************************");
                 //直接抛出异常（Exception） HResult值为 -2146233088
                 throw new Exception();
                 //throw new ArgumentException();
             }
                 );
                  */

　　　　因为throw new Exception();的 HResult 的值为

　　　   如图所示

　　　　

　　　　　执行结果为：

　　　　 

　　　　当我们使用throw new ArgumentException(); 时 它的HResult 的值为

　　　 如图所示：

　　　　

　　　　

　　　　执行结果为：

　　　　因为我们没有做任何的处理所以程序直接报错

　　　　

　　　　上面演示了Policy的基本用法

4、Polly7种策略的使用

　　　　1、重试策略（Retry）:

　　　　

 /* Policy的重试策略  Retry
              * 如果程序发生错误将重新执行 3 次
             int Count = 0;
             var PolicyExecutes =
                 Policy<object>.Handle<Exception>(ex => ex.HResult == -2146233088)
                 .Retry(3, (ex, Index) => {
                     Console.WriteLine($"执行出错监控的异常为：Exception 异常 HResult值为：-2146233088 ");
                     Console.WriteLine($"第{Index}次 Retry(重试)");
                 }
                 ).Execute(() =>
               {
                   Console.WriteLine("********************开始执行程序**************************");
                   Count = Count + 1;
                   if (Count > 3)
                   {
                       Console.WriteLine("执行成功");
                       Console.WriteLine("********************结束执行程序**************************");
                       return "";
                   }
                   else
                   {
                       throw new Exception();
                   }

               });
               */

　　　　执行结果：

　　　　

　　　　2、断路器（Circuit-Breaker）

　　　　　

  /*******************************************************************************************************/
             /* Policy的断路器策略 Circuit-Breaker
             *  程序首次被访问如果连续出现三次错误后，将暂停3秒，三秒结束后 可以被继续访问
             *  继续访问时 如果第一次就出现错误 继续熔断

             var PolicyExecutes =
                 Policy<object>.Handle<Exception>()
                 .CircuitBreaker(3, TimeSpan.FromSeconds(3));

             //模拟访问十次
             for (int i = 0; i < 10; i++)
             {
                 try
                 {
                     PolicyExecutes.Execute(() =>
                     {
                         Console.WriteLine("********************开始执行程序**************************");
                         throw new Exception("异常");
                     });
                 }
                 catch (Exception ex)
                 {
                     Console.WriteLine($"Exception信息{i}" + ex.Message);
                 }
                 //一秒运行一次
                 Thread.Sleep(1000);
             }
              */

　　　　执行结果：

　　　　

　　　　3、 超时策略（Timeout）

 /*Policy的超时策略（Timeout）
              * 程序本身没有错误就是执行的时间超过了我们制定的超时策略的时间然后程序就抓捕到超时的异常

             try
             {
                 //超时策略
                 Policy policy = Policy.Timeout(3, TimeoutStrategy.Pessimistic);

                 policy.Execute(() =>
                 {
                     Console.WriteLine("********************开始执行程序**************************");
                     Thread.Sleep(5000);
                 });
             }
             catch (Exception ex)
             {
                 Console.WriteLine(ex.Message);
             }
              */

　　　　执行结果：

　　　　

　　　　4、隔离策略（Bulkhead Isolation）

 /*Policy的隔离策略（Bulkhead Isolation）
              *
             //制定策略最大的并发数为5
             Policy PolicyExecutes = Policy.Bulkhead(5);
             //程序运行6次 总会有一个失败的，但是这个失败的不会影响其他5个的执行结果
             for (int i = 0; i < 6; i++)
             {
                 Task.Factory.StartNew(() =>
                 {
                     try
                     {
                         PolicyExecutes.Execute(() =>
                         {
                             Console.WriteLine($"********************开始执行程序**************************");
                         });
                     }
                     catch (Exception ex)
                     {
                         Console.WriteLine(ex.Message);
                     }
                 });
             }
             */

　　　　执行结果：

　　　　

　　　　5、缓存策略（Cache）:

　　　　　

  /*Policy 缓存策略（Cache）
              *  控制台不方便演示
              *  Policy.Cache 可以指定 过期时间，绝对过期时间，滑动过期时间等

             //Policy 的缓存策略的制定
             MemoryCache memoryCache = null;
             var PolicyExecutes = Policy.Cache(memoryCache, TimeSpan.FromMinutes(5));
              */

　　　　6、 回退(FallBack）

　　　　

   /*Pollcy 的回退策略（FallBack）
              * FallBack 当主程序发生错误是我们启动备用的程序进行程序处理

             var PolicyExecute = Policy.Handle<Exception>().Fallback(() =>
             {
                 Console.WriteLine($"你的程序报错了，我是替代程序！");

             });

             //执行
             PolicyExecute.Execute(() =>
             {
                 Console.WriteLine("********************开始执行程序**************************");
                 throw new Exception();
             }
                 );
                  */

　　　　执行结果：

　　　　

　　　　7、策略组合(PolicyWrap）

　　　　　PolicyWrap的上面六种策略可以任意的组合起来使用：我们将超时策略（Timeout）加上回退(FallBack）策略组合使用

　　　　　

 //Fallback策略
             Policy PolicyExecute = Policy.Handle<Exception>().Fallback(() =>
             {
                 Console.WriteLine($"你的程序超时了，我是替代程序！");

             });
             //超时策略
             PolicyExecute = PolicyExecute.Wrap(Policy.Timeout(, TimeoutStrategy.Pessimistic));
             //执行
             PolicyExecute.Execute(() =>
             {
                 Thread.Sleep();
             }
                 );

　　　　执行结果：

　　　　

　　　　

　　　　　　OK

　　　　　　这些只是简单的演示，官方文档更加详细。

下一篇我们是使用 Aop 基于 AspNetCore 的过滤器 实现一下Policy 的使用。

有不足之处 希望大家指出相互学习，

                                   　　本文原创：转载请注明出处 谢谢！