基于netcore的微服务——Polly（2）

一、什么是熔断降级

1.熔断

熔断就是“保险丝“，当初夏四年某种情况时，切断服务，防止应用程序不断得尝试执行失败得操作给系统造成雪崩，或者大量得超时等待，使系统卡死。

2.降级

目的是使某个服务提供者发生故障得时候，向调用方返回一个错误得响应或者替代响应。
例如：服务A失败，改用服务B，B失败，该为服务C，C失败，改为缓存加载，如果还失败，从本地加载，再失败就返回失败，逐层降级处理。

二、Polly简介

.Net Core中被.Net基金会认可得库，用来简化，熔断降级处理。

1.功能

重试（retry）
断路器（Circuit-breaker）
超时检测（Timeout）
降级（FallBack）
缓存不好用，所以不做学习
缓存（Cache）

2.组成

polly得策略又”故障“和”动作“两部分组成

（1）故障

包括异常，超时

（2）动作

包括FallBack（降级），重试（retry），熔断（Circuit-breaker）等

三、实例源码

引入包

    <PackageReference Include="Polly" Version="6.0.1" />

using Polly;
using Polly.Timeout;
using System;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;

namespace pollytest1
{
    internal class Program
    {
        static void Main(string[] args)
        {
            #region 降级策略
            定义故障
            //Policy<string> policy = Policy<string>.Handle<Exception>(ex=>ex.Message =="数据错误").
            //    //出现故障后得处理
            //    //降级处理
            //    Fallback(() =>
            //    {
            //        Console.WriteLine("fallback");
            //        return "降级后给你得值";
            //    });
            正真得业务逻辑
            //string result = policy.Execute(() =>
            //{
            //    Console.WriteLine("开始执行");
            //    throw new ArgumentException();
            //    Console.WriteLine("执行结束");
            //    return "正常值";
            //});
            //Console.WriteLine(result);
            #endregion
            #region 重试策略
            //try
            //{
            //    Policy policy = Policy.Handle<Exception>()
            //        //重试一次
            //        .Retry();
            //        //重试三次
            //        //.Retry(3);
            //    policy.Execute(() =>
            //    {
            //        Console.WriteLine("开始任务");
            //        if (DateTime.Now.Second % 10 != 0)
            //        {
            //            throw new Exception("出错");
            //        }
            //        Console.WriteLine("完成任务");
            //    });
            //}
            //catch
            //{
            //    Console.WriteLine("出现未捕获得异常");
            //}
            #endregion
            #region 策略得封装 可以将多个策略合并在一起使用
            //Policy policyRetry = Policy.Handle<Exception>()
            //       .Retry(3);
            //Policy policeFallback = Policy.Handle<Exception>()
            //    .Fallback(() =>
            //    {
            //        Console.WriteLine("fallback");         
            //    }); 
            wrap包裹，降级策略包裹了重试策略，先重试三次，再降级
            //Policy policy = policeFallback.Wrap(policyRetry);
            //policy.Execute(() =>
            //{
            //    Console.WriteLine("开始任务");
            //    if (DateTime.Now.Second % 10 != 0)
            //    {
            //        throw new Exception("出错");
            //    }
            //    Console.WriteLine("完成任务");
            //});
            #endregion
            #region 超时策略 ：避免接口长期没有响应造成系统卡死
            超时策略，如果规定时间没有响应，就抛出异常
            //Policy policytimeout = Policy.Timeout(3, TimeoutStrategy.Pessimistic);
            降级策略，出现异常，则实现降级
            //Policy policyFallback = Policy.Handle<TimeoutRejectedException>()
            //    .Fallback(() =>
            //    {
            //        Console.WriteLine("降级");
            //    });
            降级策略包裹超时策略
            //Policy policy = policyFallback.Wrap(policytimeout);
            //policy.Execute(() => 
            //{
            //    Console.WriteLine("开始任务");
            //    Thread.Sleep(5000);
            //    Console.WriteLine("任务完成");
            //});
            #endregion
            #region
            Test1();
            static async Task Test1()
            {
                Policy<byte[]> policy = Policy<byte[]>
                    .Handle<Exception>()
                    .FallbackAsync(async c =>
                    {
                        Console.WriteLine("执行出错");
                        return new byte[0];
                    },async r=>
                    {
                        Console.WriteLine(r.Exception);
                    });
                policy = policy.WrapAsync(Policy.TimeoutAsync(20, TimeoutStrategy.Pessimistic,async (context,timesapn,task)=>
                {
                    Console.WriteLine("timeout");
                }));
                var bytes = await policy.ExecuteAsync(async () =>
                {
                    Console.WriteLine("开始任务");
                    HttpClient httpClient = new HttpClient();
                    var result = await httpClient.GetByteArrayAsync("https://csdnnews.blog.csdn.net/article/details/124813425?spm=1000.2115.3001.5926");
                    Console.WriteLine("完成任务");
                    return result;
                });
                Console.WriteLine("bytes长度"+bytes.Length);
            }

            #endregion
            Console.ReadKey();
        }
    }
}