前言

上一篇介紹了使用Steeltoe來處理服務熔斷，這篇我們將用Polly來處理服務熔斷。

不廢話了，直接進正題。

簡單的例子

同樣先定義一個簡單的服務。

[Route("api/[controller]")]
public class ValuesController : Controller
{
    // GET api/values
    [HttpGet]
    public string Get()
    {
        return "service--a";
    }
}

再來一個新服務去呼叫上面的服務。

定義一個用於訪問服務的Service介面和實現。

public interface IAService
{
    Task<string> GetAsync();
}

public class AService : IAService
{
    private PolicyWrap<string> _policyWrap;

    private ILogger _logger;

    public AService(ILoggerFactory loggerFactory)
    {
        _logger = loggerFactory.CreateLogger<AService>();

        //超時
        var timeout = Policy
              .TimeoutAsync(1, Polly.Timeout.TimeoutStrategy.Pessimistic, (context, ts, task) =>
              {
                  _logger.LogInformation("AService timeout");
                  return Task.CompletedTask;
              });
        
        //熔斷
        var circuitBreaker = Policy
            .Handle<Exception>()
            .CircuitBreakerAsync(2, TimeSpan.FromSeconds(5), (ex, ts) =>
            {
                _logger.LogInformation($"AService OnBreak -- ts = {ts.Seconds}s ,ex.message = {ex.Message}");
            }, () =>
            {
                _logger.LogInformation("AService OnReset");
            });
        
        //Fallback + 熔斷 + 超時
        _policyWrap = Policy<string>
            .Handle<Exception>()
            .FallbackAsync(GetFallback(), (x) =>
            {
                _logger.LogInformation($"AService Fallback -- {x.Exception.Message}");                    
                return Task.CompletedTask;
            })
            .WrapAsync(circuitBreaker)
            .WrapAsync(timeout);
    }

    //降級處理
    private string GetFallback()
    {
        return "fallback";
    }

    public async Task<string> GetAsync()
    {
        return await _policyWrap.ExecuteAsync(() =>
        {
            return QueryAsync();
        });
    }

    private async Task<string> QueryAsync()
    {
        using (var client = new HttpClient())
        {
            var res = await client.GetStringAsync("http://localhost:9001/api/values");
            return res;
        }
    }
}
 

要注意的有幾個地方。

Polly沒有既包含熔斷又包含降級又包含超時的，這個需要自己去組合。相對來說，Hystrix在這一方面似乎好一點點。

但是，各有各的好，Polly分離了每一個模組，讓我們自由組合，也是很靈活的。

所以可以看到，我們定義了3個Policy，再把它們Wrap起來。

另外，還在觸發每一個Policy的時候，都會輸出相應的日記，方便我們後面看效果。

對於寫日記這一塊，個人認為對比Steeltoe，Polly的方式要更加方便和簡單。

下面是控制器的使用。

// GET api/values
[HttpGet]
public async Task<string> A([FromServices]IAService aService)
{
    return await aService.GetAsync();
}
 

還有一個關鍵的步驟：在Startup註冊我們的AService。

services.AddSingleton<IAService, AService>();

切記是Singleton！不然熔斷就不會起作用了！！

直接上效果圖

簡單說明一下這張圖，一開始，服務A和呼叫方都是正常的，後面中斷服務A，使其不可用，這個時候呼叫方就會走降級處理。

呼叫方多請求幾次，就可以看到OnBreak的日記輸出，說明斷路器已經處於Open狀態，不會直接走真正的請求，而是走的Fallback。

最後啟動服務A，可以看到OnReset的日記輸出，說明斷路器已經處於Closed狀態了，瀏覽器顯示的也是服務A的返回結果。

再來模擬一下超時的情形。

因為上面設定的超時時間是1秒，所以讓其休息1001毫秒就可以模擬了。

// GET api/values
[HttpGet]
public string Get()
{
    System.Threading.Thread.Sleep(1001);
    return "service--a";
}

再來看看效果圖

呼叫方一直是提示因為超時而降級，而熔斷。從日記也可以看出，是因為超時而導致熔斷的。

前面還提到一個註冊服務的問題，這裡解釋一下為什麼我們要讓其註冊成Singleton？

我們先把註冊服務這一塊調整為不是Singleton，這裡以Scope為例，Transient也是一樣的。

public void ConfigureServices(IServiceCollection services)
{
    services.AddScoped<IAService, AService>();
    //services.AddSingleton<IAService, AService>();
    services.AddMvc();
}

效果如下：

可以看到，日記一直輸出超時！並沒有提示熔斷相關的資訊！這說明我們設定的熔斷並沒有起作用！！

這個問題與例項的生命週期有著密不可分的關係！

試想一下，如果每次請求，都建立一個AService的例項，同樣的每次都會重新建立一個新的熔斷器，那熔斷還會生效嗎？

反之，如果熔斷器只有一個，那麼無論發起多少次請求，它都是唯一的，所以它才能統計到有多少次異常，從而去觸發熔斷。

這也是一個我們需要特別注意的地方。不然一個不小心就入坑了。

總結

Polly用起來還是比較簡單，比較靈活的，我們可以組合多種不同的Policy來達到我們想要的結果。

本文的示例程式碼：