本章节介绍熔断和降级。大家应该都知道每个网关都必备熔断和降级相关策略。而Polly为啥也会有熔断和降级呢?难道是个鸡肋?还是说熔断和鸡肋是让 HttpClient结合Polly专门来做网关用的,而我们在做实际的业务场景中根本用不着?这2个问题我思考了很久,我的答案是否定的。我分析的原因有如下几点,(限于自身能力和眼界只能考虑这几点,若有其他的欢迎告诉我。)

1、Polly是业界顶顶有名的组件,他既然有熔断和降级这2个功能,那必然有很多用处,绝对不可能是个鸡肋。

2、如果想要自己开发一个网关,我觉得用Polly完全是可以用的。

3、如果不是专门做网关,那么他在什么样的场景下使用呢?我们在使用HttpClient的时候,都是调用第3方接口或公司内部接口,那么万一因网络问题、对方服务器异常、超时、接口程序异常等一些不可抗拒因素,调用接口失败了!也就是服务不可用时,我们的程序该如何应对?首先是重试机制,重试够用吗?好像不够用,重试几次一直失败,我们不能因为对方接口挂了影响自己程序的业务逻辑吧,所以得来再使用熔断和降级一起处理,我们就可以非常快速和优雅的给出一个熔断或降级的结果,也避免我们的程序一直 请求这些不可用的服务,造成资源的浪费以及影响性能。

当然降级和熔断两者也可以单独使用。

 4、那熔断是否还有比用的地方呢?有,比如对方接口有防刷机制,万一我们不小心碰触到该机制了,或者是我们提前知道该机制,我们就可以使用熔断或限流来控制不碰触该机制,并且我们的程序可以优雅的处理这类情况。

5、限流比较好理解, 调用对方的服务,我们程序作为客户端HttpClient,我们来限制我们调用对方服务的最大的流量和队列,这样可以避免因为我们的请求量过大而让对方的服务奔溃,第4点就是一个例子。



熔断也叫断路器,英文Circuit Breaker,

降级也叫 回退,英文Fallback,

限流 也叫 舱壁隔离,英文Bulkhead。

步骤一:在Startup的ConfigureServices里配置

我们先上代码加上完整的注释


//<1>、降级后的返回值
HttpResponseMessage fallbackResponse = new HttpResponseMessage
{
Content = new StringContent("降级,服务暂时不可用"),
StatusCode = HttpStatusCode.InternalServerError,

};
//<2>、降级策略
var FallBackPolicy = Policy<HttpResponseMessage>.Handle<Exception>().FallbackAsync(fallbackResponse, async b =>
{
// 1、降级打印异常
Console.WriteLine($"服务开始降级,异常消息:{b.Exception.Message}");
// 2、降级后的数据
Console.WriteLine($"服务降级内容响应:{await fallbackResponse.Content.ReadAsStringAsync()}");
await Task.CompletedTask;
});

//<3>、熔断策略/断路器策略
var CircuitBreakPolicy = Policy<HttpResponseMessage> // HttpResponseMessage 为HttpClient的返回值
.Handle<Exception>() //捕获Exception异常
.OrResult(res => res.StatusCode == HttpStatusCode.InternalServerError || res.StatusCode == HttpStatusCode.RequestTimeout)
.CircuitBreakerAsync(
3, // 出现3次异常
TimeSpan.FromSeconds(20), // 断路器的时间(例如:设置为20秒,断路器两秒后自动由开启到关闭)
(ex, ts) =>
{ //熔断器开启事件触发
Console.WriteLine($"服务断路器开启,异常消息:{ex.Result}");
Console.WriteLine($"服务断路器开启的时间:{ts.TotalSeconds}s");
}, //断路器重置事件触发
() => { Console.WriteLine($"服务断路器重置"); }, //断路器半开启事件触发
() => { Console.WriteLine($"服务断路器半开启(一会开,一会关)"); }
);

//<4>、限流策略
var bulk = Policy.BulkheadAsync<HttpResponseMessage>(
maxParallelization: 30,//最大请求并发数
maxQueuingActions: 20,//可以有20个请求在队列里排队
onBulkheadRejectedAsync: context =>//当我们的请求超出了并发数时怎么处理 这里可以定义自己的规则
{
return Task.CompletedTask;
}


);

services.AddHttpClient();
services.AddHttpClient("myhttpclienttest", client =>
{
client.BaseAddress = new Uri("http://localhost:9002/");
// client.Timeout = TimeSpan.FromSeconds(1);
})
//<5>、添加 降级策略
.AddPolicyHandler(FallBackPolicy)
//<6>、添加 熔断策略
.AddPolicyHandler(CircuitBreakPolicy)
//<7>、添加限流策略
.AddPolicyHandler(bulk)
;




先看下带括号<>的大步骤,<1>到<7> ,注释已经写的非常清楚了。

注意: 第一、  <3>熔断的策略里,我们加了   .OrResult(res => res.StatusCode == HttpStatusCode.InternalServerError || res.StatusCode == HttpStatusCode.RequestTimeout) ,网上的教程一般没有,这句话的意思是说,当请求返回的状态是500服务器异常或者请求超时,都计算在内。若没有这句话,对方的接口必须要抛异常,才计算在内。

         第二、这些策略可以组合起来使用;


步骤二:HttpClient调用远程接口服务


using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;

namespace HttpClientDemo.Controllers
{


[ApiController]
[Route("[controller]")]
public class WeatherForecastController : ControllerBase
{

private readonly ILogger<WeatherForecastController> _logger;

private readonly IHttpClientFactory _clientFactory;
public WeatherForecastController(ILogger<WeatherForecastController> logger, IHttpClientFactory clientFactory)
{
_logger = logger;
_clientFactory = clientFactory;

}

/// <summary>
/// 测试HttpClient和Polly
/// </summary>
/// <returns></returns>

[HttpGet]
public async Task<MyResult> Get()
{
MyResult result = new MyResult();
try
{


Console.WriteLine("请求处理开始。。。。");
var client = _clientFactory.CreateClient("myhttpclienttest");

var request = new HttpRequestMessage(HttpMethod.Get, "api/values/testtimeout");
HttpResponseMessage response = await client.SendAsync(request);
var content = await response.Content.ReadAsStringAsync();
if(response.StatusCode== HttpStatusCode.InternalServerError)
{
result.code = "400";
result.msg = content;
}
else
{
result.code = "200";
result.msg = content;
}
return result;
}
catch (Exception ex)
{
result.code = "401";
result.msg = ex.Message;
Console.WriteLine($"出理异常:{ex.Message}");
return result;
}
}
}
}


这里有个坑,httpClient最后一定要返回的是 HttpResponseMessage ,不然无法返回降级的返回内容。


步骤三、Polly在.NetCore项目中封装

 根据步骤一,我们将这些代码封起来。使用配置文件来配置相关参数。

3.1 新建配置文件:pollyconfig.json,并且将该json文件保存的格式为UTF-8,不然会有中文乱码问题。


{
"Polly": [
{
"ServiceName": [ "myhttpclienttest", "myhttpclienttest2" ], //服务名称,可以多个服务使用同一个配置
"TimeoutTime": 5, //超时时间设置,单位为秒
"RetryCount": 2, //失败重试次数
"CircuitBreakerOpenFallCount": 2, //执行多少次异常,开启短路器(例:失败2次,开启断路器)
"CircuitBreakerDownTime": 6, //断路器关闭的时间(例如:设置为2秒,短路器两秒后自动由开启到关闭)
"HttpResponseMessage": "系统繁忙,请稍后再试!", //降级处理提示信息
"HttpResponseStatus": 200 //降级处理响应状态码
},
{
"ServiceName": [ "myhttpclienttest3" ], //假如服务名称存在相同的,则后面的会替换掉前面的
"TimeoutTime": 2,
"RetryCount": 5,
"CircuitBreakerOpenFallCount": 2,
"CircuitBreakerDownTime": 8,
"HttpResponseMessage": "系统繁忙,请稍后再试~!",
"HttpResponseStatus": 503
}
]
}


3.2 创建配置实体类:PollyHttpClientConfig.cs对应配置文件里的节点


public class PollyHttpClientConfig
{
/// <summary>
/// 服务名称
/// </summary>
public List<string> ServiceName { set; get; }

/// <summary>
/// 超时时间设置,单位为秒
/// </summary>
public int TimeoutTime { set; get; }

/// <summary>
/// 失败重试次数
/// </summary>
public int RetryCount { set; get; }

/// <summary>
/// 执行多少次异常,开启短路器(例:失败2次,开启断路器)
/// </summary>
public int CircuitBreakerOpenFallCount { set; get; }

/// <summary>
/// 断路器关闭的时间(例如:设置为2秒,短路器两秒后自动由开启到关闭)
/// </summary>
public int CircuitBreakerDownTime { set; get; }

/// <summary>
/// 降级处理消息(将异常消息封装成为正常消息返回,然后进行响应处理,例如:系统正在繁忙,请稍后处理.....)
/// </summary>
public string HttpResponseMessage { set; get; }
/// <summary>
/// 降级处理状态码(将异常消息封装成为正常消息返回,然后进行响应处理,例如:系统正在繁忙,请稍后处理.....)
/// </summary>
public int HttpResponseStatus { set; get; }
}


3.3 封装拓展类:PollyHttpClientServiceCollectionExtension.cs 


using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Polly;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Threading.Tasks;

namespace HttpClientDemo
{
public static class PollyHttpClientServiceCollectionExtension
{
public static void AddPollyHttpClient(this IServiceCollection service)
{
//读取服务配置文件
try
{
var config = new ConfigurationBuilder().AddJsonFile("pollyconfig.json").Build(); //nuget: Microsoft.Extensions.Configuration.Json
List<PollyHttpClientConfig> configList = config.GetSection("Polly").Get<List<PollyHttpClientConfig>>(); // nuget: Microsoft.Extensions.Options.ConfigurationExtensions
if (configList != null && configList.Count > 0)
{
configList.ForEach((pollyHttpClientConfig) =>
{
service.AddPollyHttpClient(pollyHttpClientConfig);

});
}
}
catch (Exception ex)
{
throw new Exception("请正确配置pollyconfig.json");
}
}
public static void AddPollyHttpClient(this IServiceCollection service, PollyHttpClientConfig pollyHttpClientConfig)
{
if (pollyHttpClientConfig == null)
throw new Exception("请配置:pollyHttpClientConfig");

if (pollyHttpClientConfig.ServiceName == null || pollyHttpClientConfig.ServiceName.Count < 1)
throw new Exception("请配置:pollyHttpClientConfig.Polly.ServiceName");

for (int i = 0; i < pollyHttpClientConfig.ServiceName.Count; i++)
{
var builder = service.AddHttpClient(pollyHttpClientConfig.ServiceName[i]);

builder.BuildFallbackAsync(pollyHttpClientConfig.HttpResponseMessage, pollyHttpClientConfig.HttpResponseStatus);
builder.BuildCircuitBreakerAsync(pollyHttpClientConfig.CircuitBreakerOpenFallCount, pollyHttpClientConfig.CircuitBreakerDownTime);
builder.BuildRetryAsync(pollyHttpClientConfig.RetryCount);
builder.BuildTimeoutAsync(pollyHttpClientConfig.TimeoutTime);
}
}


//降级
private static void BuildFallbackAsync(this IHttpClientBuilder builder, string httpResponseMessage, int httpResponseStatus)
{

if (httpResponseStatus < 1 || string.IsNullOrEmpty(httpResponseMessage))
return;

HttpResponseMessage fallbackResponse = new HttpResponseMessage
{
Content = new StringContent(httpResponseMessage),
StatusCode = (HttpStatusCode)httpResponseStatus
};

builder.AddPolicyHandler(Policy<HttpResponseMessage>.HandleInner<Exception>().FallbackAsync(fallbackResponse, async b =>
{
// 1、降级打印异常
Console.WriteLine($"服务开始降级,异常消息:{b.Exception.Message}");
// 2、降级后的数据
Console.WriteLine($"服务降级内容响应:{await fallbackResponse.Content.ReadAsStringAsync()}");
await Task.CompletedTask;
}));
}
//熔断
private static void BuildCircuitBreakerAsync(this IHttpClientBuilder builder, int circuitBreakerOpenFallCount, int circuitBreakerDownTime)
{
if (circuitBreakerOpenFallCount < 1 || circuitBreakerDownTime < 1)
return;

builder.AddPolicyHandler(
Policy<HttpResponseMessage> // HttpResponseMessage 为HttpClient的返回值
.Handle<Exception>() //捕获Exception异常
.OrResult(res => res.StatusCode == HttpStatusCode.InternalServerError || res.StatusCode == HttpStatusCode.RequestTimeout)
.CircuitBreakerAsync(
circuitBreakerOpenFallCount, // 出现3次异常
TimeSpan.FromSeconds(circuitBreakerDownTime), //10秒之内; 结合上面就是:10秒之内出现3次异常就熔断
(res, ts) =>
{ //熔断器开启事件触发
Console.WriteLine($"服务断路器开启,异常消息:{res.Result}");
Console.WriteLine($"服务断路器开启的时间:{ts.TotalSeconds}s");
}, //断路器重置事件触发
() => { Console.WriteLine($"服务断路器重置"); }, //断路器半开启事件触发
() => { Console.WriteLine($"服务断路器半开启(一会开,一会关)"); }
)
);

}
//失败重试
private static void BuildRetryAsync(this IHttpClientBuilder builder, int retryCount)
{
if (retryCount > 0)//失败重试
builder.AddPolicyHandler(Policy<HttpResponseMessage>.Handle<Exception>().RetryAsync(retryCount));
}
//超时
private static void BuildTimeoutAsync(this IHttpClientBuilder builder, int timeoutTime)
{
if (timeoutTime > 0)//超时
builder.AddPolicyHandler(Policy.TimeoutAsync<HttpResponseMessage>(TimeSpan.FromSeconds(timeoutTime)));
}
}
}


3.4 在startup.cs类的ConfigureServices方法中注册,放在所有命名模式的HttpClient客户端注册之后。


services.AddPollyHttpClient();


3.5 HttpClient调用远程接口服务的方法不变。

作者:沐雪