public class Startup
{
  public void ConfigureServices(IServiceCollection services)
  {
    services.AddResponseCompression();
  }

  public void Configure(IApplicationBuilder app, IHostingEnvironment env)
  {
    app.UseResponseCompression();
  }
}

public void ConfigureServices(IServiceCollection services)
{
  services.AddResponseCompression(options =>
  {
    //可以添加多種壓縮類型，程序會(huì)根據(jù)級別自動(dòng)獲取最優(yōu)方式
    options.Providers.Add<BrotliCompressionProvider>();
    options.Providers.Add<GzipCompressionProvider>();
    //添加自定義壓縮策略
    options.Providers.Add<MyCompressionProvider>();
    //針對指定的MimeType來使用壓縮策略
    options.MimeTypes = 
      ResponseCompressionDefaults.MimeTypes.Concat(
        new[] { "application/json" });
  });
  //針對不同的壓縮類型，設(shè)置對應(yīng)的壓縮級別
  services.Configure<GzipCompressionProviderOptions>(options => 
  {
    //使用最快的方式進(jìn)行壓縮，單不一定是壓縮效果最好的方式
    options.Level = CompressionLevel.Fastest;

    //不進(jìn)行壓縮操作
    //options.Level = CompressionLevel.NoCompression;

    //即使需要耗費(fèi)很長的時(shí)間，也要使用壓縮效果最好的方式
    //options.Level = CompressionLevel.Optimal;
  });
}

public static class ResponseCompressionServicesExtensions
{
  public static IServiceCollection AddResponseCompression(this IServiceCollection services)
  {
    services.TryAddSingleton<IResponseCompressionProvider, ResponseCompressionProvider>();
    return services;
  }

  public static IServiceCollection AddResponseCompression(this IServiceCollection services, Action<ResponseCompressionOptions> configureOptions)
  {
    services.Configure(configureOptions);
    services.TryAddSingleton<IResponseCompressionProvider, ResponseCompressionProvider>();
    return services;
  }
}

public class ResponseCompressionOptions
{
  // 設(shè)置需要壓縮的類型
  public IEnumerable<string> MimeTypes { get; set; }

  // 設(shè)置不需要壓縮的類型
  public IEnumerable<string> ExcludedMimeTypes { get; set; }

  // 是否開啟https支持
  public bool EnableForHttps { get; set; } = false;

  // 壓縮類型集合
  public CompressionProviderCollection Providers { get; } = new CompressionProviderCollection();
}

public ResponseCompressionProvider(IServiceProvider services, IOptions<ResponseCompressionOptions> options)
{
  var responseCompressionOptions = options.Value;
  _providers = responseCompressionOptions.Providers.ToArray();
  //如果沒有設(shè)置壓縮類型默認(rèn)采用Br和Gzip壓縮算法
  if (_providers.Length == 0)
  {
    _providers = new ICompressionProvider[]
    {
      new CompressionProviderFactory(typeof(BrotliCompressionProvider)),
      new CompressionProviderFactory(typeof(GzipCompressionProvider)),
    };
  }
  //根據(jù)CompressionProviderFactory創(chuàng)建對應(yīng)的壓縮算法Provider比如GzipCompressionProvider
  for (var i = 0; i < _providers.Length; i++)
  {
    var factory = _providers[i] as CompressionProviderFactory;
    if (factory != null)
    {
      _providers[i] = factory.CreateInstance(services);
    }
  }
  //設(shè)置默認(rèn)的壓縮目標(biāo)類型默認(rèn)為text/plain、text/css、text/html、application/javascript、application/xml
  //text/xml、application/json、text/json、application/was
  var mimeTypes = responseCompressionOptions.MimeTypes;
  if (mimeTypes == null || !mimeTypes.Any())
  {
    mimeTypes = ResponseCompressionDefaults.MimeTypes;
  }
  //將默認(rèn)MimeType放入HashSet
  _mimeTypes = new HashSet<string>(mimeTypes, StringComparer.OrdinalIgnoreCase);
  _excludedMimeTypes = new HashSet<string>(
    responseCompressionOptions.ExcludedMimeTypes ?? Enumerable.Empty<string>(),
    StringComparer.OrdinalIgnoreCase
  );
  _enableForHttps = responseCompressionOptions.EnableForHttps;
}

public class GzipCompressionProvider : ICompressionProvider
{
  public GzipCompressionProvider(IOptions<GzipCompressionProviderOptions> options)
  {
    Options = options.Value;
  }

  private GzipCompressionProviderOptions Options { get; }

  // 對應(yīng)的Encoding名稱
  public string EncodingName { get; } = "gzip";

  public bool SupportsFlush => true;

  // 核心代碼就是這句 將原始的輸出流轉(zhuǎn)換為壓縮的GZipStream
  // 我們設(shè)置的Level壓縮級別將決定壓縮的性能和質(zhì)量
  public Stream CreateStream(Stream outputStream)
    => new GZipStream(outputStream, Options.Level, leaveOpen: true);
}

public class ResponseCompressionMiddleware
{
  private readonly RequestDelegate _next;
  private readonly IResponseCompressionProvider _provider;

  public ResponseCompressionMiddleware(RequestDelegate next, IResponseCompressionProvider provider)
  {
    _next = next;
    _provider = provider;
  }

  public async Task Invoke(HttpContext context)
  {
    //判斷是否包含Accept-Encoding頭信息，不包含直接大喊一聲"抬走下一個(gè)"
    if (!_provider.CheckRequestAcceptsCompression(context))
    {
      await _next(context);
      return;
    }
    //獲取原始輸出Body
    var originalBodyFeature = context.Features.Get<IHttpResponseBodyFeature>();
    var originalCompressionFeature = context.Features.Get<IHttpsCompressionFeature>();
    //初始化響應(yīng)壓縮Body
    var compressionBody = new ResponseCompressionBody(context, _provider, originalBodyFeature);
    //設(shè)置成壓縮Body
    context.Features.Set<IHttpResponseBodyFeature>(compressionBody);
    context.Features.Set<IHttpsCompressionFeature>(compressionBody);

    try
    {
      await _next(context);
      await compressionBody.FinishCompressionAsync();
    }
    finally
    {
      //恢復(fù)原始Body
      context.Features.Set(originalBodyFeature);
      context.Features.Set(originalCompressionFeature);
    }
  }
}

internal class ResponseCompressionBody : Stream, IHttpResponseBodyFeature, IHttpsCompressionFeature
{
}

public override void Write(byte[] buffer, int offset, int count)
{
  //這是核心方法有關(guān)于壓縮相關(guān)的輸出都在這
  OnWrite();
  //_compressionStream初始化在OnWrite方法里
  if (_compressionStream != null)
  {
    _compressionStream.Write(buffer, offset, count);
    if (_autoFlush)
    {
      _compressionStream.Flush();
    }
  }
  else
  {
    _innerStream.Write(buffer, offset, count);
  }
}

private void OnWrite()
{
  if (!_compressionChecked)
  {
    _compressionChecked = true;
    //判斷是否滿足執(zhí)行壓縮相關(guān)的邏輯
    if (_provider.ShouldCompressResponse(_context))
    {
      //匹配Vary頭信息對應(yīng)的值
      var varyValues = _context.Response.Headers.GetCommaSeparatedValues(HeaderNames.Vary);
      var varyByAcceptEncoding = false;
      //判斷Vary的值是否為Accept-Encoding
      for (var i = 0; i < varyValues.Length; i++)
      {
        if (string.Equals(varyValues[i], HeaderNames.AcceptEncoding, StringComparison.OrdinalIgnoreCase))
        {
          varyByAcceptEncoding = true;
          break;
        }
      }
      if (!varyByAcceptEncoding)
      {
        _context.Response.Headers.Append(HeaderNames.Vary, HeaderNames.AcceptEncoding);
      }
      //獲取最佳的ICompressionProvider即最佳的壓縮方式
      var compressionProvider = ResolveCompressionProvider();
      if (compressionProvider != null)
      {
        //設(shè)置選定的壓縮算法，放入Content-Encoding頭的值里
        //客戶端可以通過Content-Encoding頭信息判斷服務(wù)端采用的哪種壓縮算法
        _context.Response.Headers.Append(HeaderNames.ContentEncoding, compressionProvider.EncodingName);
        //進(jìn)行壓縮時(shí)，將 Content-MD5 刪除該標(biāo)頭，因?yàn)檎膬?nèi)容已更改且哈希不再有效。
        _context.Response.Headers.Remove(HeaderNames.ContentMD5); 
        //進(jìn)行壓縮時(shí)，將 Content-Length 刪除該標(biāo)頭，因?yàn)樵趯憫?yīng)進(jìn)行壓縮時(shí)，正文內(nèi)容會(huì)發(fā)生更改。
        _context.Response.Headers.Remove(HeaderNames.ContentLength);
        //返回壓縮相關(guān)輸出流
        _compressionStream = compressionProvider.CreateStream(_innerStream);
      }
    }
  }
}

private ICompressionProvider ResolveCompressionProvider()
{
  if (!_providerCreated)
  {
    _providerCreated = true;
    //調(diào)用ResponseCompressionProvider的方法返回最合適的壓縮算法
    _compressionProvider = _provider.GetCompressionProvider(_context);
  }
  return _compressionProvider;
}

public virtual ICompressionProvider GetCompressionProvider(HttpContext context)
{
  var accept = context.Request.Headers[HeaderNames.AcceptEncoding];
  //判斷請求頭是否包含Accept-Encoding信心
  if (StringValues.IsNullOrEmpty(accept))
  {
    Debug.Assert(false, "Duplicate check failed.");
    return null;
  }
  //獲取Accept-Encoding里的值，判斷是否包含gzip、br、identity等，并返回匹配信息
  if (!StringWithQualityHeaderValue.TryParseList(accept, out var encodings) || !encodings.Any())
  {
    return null;
  }
  //根據(jù)請求信息和設(shè)置信息計(jì)算匹配優(yōu)先級
  var candidates = new HashSet<ProviderCandidate>();
  foreach (var encoding in encodings)
  {
    var encodingName = encoding.Value;
    //Quality涉及到一個(gè)非常復(fù)雜的算法，有興趣的可以自行查閱
    var quality = encoding.Quality.GetValueOrDefault(1);
    //quality需大于0
    if (quality < double.Epsilon)
    {
      continue;
    }
    //匹配請求頭里encodingName和設(shè)置的providers壓縮算法里EncodingName一致的算法
    //從這里可以看出匹配的優(yōu)先級和注冊providers里的順序也有關(guān)系
    for (int i = 0; i < _providers.Length; i++)
    {
      var provider = _providers[i];
      if (StringSegment.Equals(provider.EncodingName, encodingName, StringComparison.OrdinalIgnoreCase))
      {
        candidates.Add(new ProviderCandidate(provider.EncodingName, quality, i, provider));
      }
    }
    //如果請求頭里EncodingName是*的情況則在所有注冊的providers里進(jìn)行匹配
    if (StringSegment.Equals("*", encodingName, StringComparison.Ordinal))
    {
      for (int i = 0; i < _providers.Length; i++)
      {
        var provider = _providers[i];
        candidates.Add(new ProviderCandidate(provider.EncodingName, quality, i, provider));
      }
      break;
    }
    //如果請求頭里EncodingName是identity的情況，則不對響應(yīng)進(jìn)行編碼
    if (StringSegment.Equals("identity", encodingName, StringComparison.OrdinalIgnoreCase))
    {
      candidates.Add(new ProviderCandidate(encodingName.Value, quality, priority: int.MaxValue, provider: null));
    }
  }

  ICompressionProvider selectedProvider = null;
  //如果匹配的只有一個(gè)則直接返回
  if (candidates.Count <= 1)
  {
    selectedProvider = candidates.FirstOrDefault().Provider;
  }
  else
  {
    //如果匹配到多個(gè)則按照Quality倒序和Priority正序的負(fù)責(zé)匹配第一個(gè)
    selectedProvider = candidates
      .OrderByDescending(x => x.Quality)
      .ThenBy(x => x.Priority)
      .First().Provider;
  }
  //如果沒有匹配到selectedProvider或是identity的情況直接返回null
  if (selectedProvider == null)
  {
    return null;
  }
  return selectedProvider;
}