ToB企服应用市场:ToB评测及商务社交产业平台

标题: 【.NET源码解读】深入剖析中间件的设计与实现 [打印本页]
作者: 惊落一身雪    时间: 2023-6-29 21:43
标题: 【.NET源码解读】深入剖析中间件的设计与实现
.NET本身就是一个基于中间件（middleware）的框架，它通过一系列的中间件组件来处理HTTP请求和响应。在之前的文章《.NET源码解读kestrel服务器及创建HttpContext对象流程》中，已经通过源码介绍了如何将HTTP数据包转换为.NET的HttpContext对象。接下来，让我们深入了解一下.NET是如何设计中间件来处理HttpContext对象。
通过本文，您可以了解以下内容：
一、重新认识中间件

1. 中间件的实现方式

在介绍中间件之前，让我们先了解一下管道设计模式：
管道设计模式是一种常见的软件设计模式，用于将一个复杂的任务或操作分解为一系列独立的处理步骤。每个步骤按特定顺序处理数据并传递给下一个步骤，形成线性的处理流程。每个步骤都是独立且可重用的组件。
在.NET中，针对每个HTTP请求的处理和响应任务被分解为可重用的类或匿名方法，这些组件被称为中间件。中间件的连接顺序是特定的，它们在一个管道中按顺序连接起来，形成一个处理流程。这种设计方式可以根据需求自由地添加、删除或重新排序中间件。
中间件的实现非常简单，它基于一个委托，接受一个HttpContext对象和一个回调函数（表示下一个中间件）作为参数。当请求到达时，委托执行自己的逻辑，并将请求传递给下一个中间件组件。这个过程会持续进行，直到最后一个中间件完成响应并将结果返回给客户端。
  1. /*
  2. * 入参1 string：代表HttpContext
  3. * 入参2 Func<Task>：下一个中间件的方法
  4. * 结果返回 Task：避免线程阻塞
  5. * **/
  6. Func<string, Func<Task>, Task> middleware = async (context, next) =>
  7. {
  8.     Console.WriteLine($"Before middleware: {context}");
  10.     await next(); // 调用下一个中间件
  12.     Console.WriteLine($"After middleware: {context}");
  13. };
复制代码
  1. Func<Task> finalMiddleware = () =>
  2. {
  3.     // 最后一个中间件的逻辑
  4.     Console.WriteLine("Final middleware");
  5.     return Task.CompletedTask;
  6. };
复制代码
为了给所有的中间件和终端处理器提供统一的委托类型，使得它们在请求处理管道中可以无缝地连接起来。所以引入了RequestDelegate委托。上文中Func方法，最终都会转换成RequestDelegate委托，这一点放在下文源码解析中。
  1. public delegate Task RequestDelegate(HttpContext context);
复制代码
2. 中间件管道构建器原理

下面是从源码中提取出的一个简单的中间件管道构建器实现示例。它包含一个 _middlewares 列表，用于存储中间件委托，并提供了 Use 方法用于添加中间件，以及 Build 方法用于构建最终的请求处理委托。
这个实现示例虽然代码不多，但却能充分展示中间件的构建原理。你可以仔细阅读这段代码，深入理解中间件是如何构建和连接的。
  1. public class MiddlewarePipeline
  2. {
  3.     private readonly List<Func<RequestDelegate, RequestDelegate>> _middlewares =
  4.         new List<Func<RequestDelegate, RequestDelegate>>();
  6.     public void Use(Func<RequestDelegate, RequestDelegate> middleware)
  7.     {
  8.         _middlewares.Add(middleware);
  9.     }
  11.     public RequestDelegate Build()
  12.     {
  13.         RequestDelegate next = context => Task.CompletedTask;
  14.         
  15.         for (int i = _middlewares.Count - 1; i >= 0; i--)
  16.         {
  17.             next = _middlewares[i](next);
  18.         }
  20.         return next;
  21.     }
  22. }
复制代码
二、实现自定义中间件

如果您想了解中间件中Run、Use、Map、MapWhen等方法，可以直接看官方文档
1. 使用内联中间件

该中间件通过查询字符串设置当前请求的区域性：
  1. using System.Globalization;
  3. var builder = WebApplication.CreateBuilder(args);
  4. var app = builder.Build();
  6. app.UseHttpsRedirection();
  8. app.Use(async (context, next) =>
  9. {
  10.     var cultureQuery = context.Request.Query["culture"];
  11.     if (!string.IsNullOrWhiteSpace(cultureQuery))
  12.     {
  13.         var culture = new CultureInfo(cultureQuery);
  15.         CultureInfo.CurrentCulture = culture;
  16.         CultureInfo.CurrentUICulture = culture;
  17.     }
  19.     // Call the next delegate/middleware in the pipeline.
  20.     await next(context);
  21. });
  23. app.Run(async (context) =>
  24. {
  25.     await context.Response.WriteAsync(
  26.         $"CurrentCulture.DisplayName: {CultureInfo.CurrentCulture.DisplayName}");
  27. });
  29. app.Run();
复制代码
2.中间件类

以下代码将中间件委托移动到类：
该类必须具备：
  1. using System.Globalization;
  3. namespace Middleware.Example;
  5. public class RequestCultureMiddleware
  6. {
  7.     private readonly RequestDelegate _next;
  9.     public RequestCultureMiddleware(RequestDelegate next)
  10.     {
  11.         _next = next;
  12.     }
  14.     public async Task InvokeAsync(HttpContext context)
  15.     {
  16.         var cultureQuery = context.Request.Query["culture"];
  17.         if (!string.IsNullOrWhiteSpace(cultureQuery))
  18.         {
  19.             var culture = new CultureInfo(cultureQuery);
  21.             CultureInfo.CurrentCulture = culture;
  22.             CultureInfo.CurrentUICulture = culture;
  23.         }
  25.         // Call the next delegate/middleware in the pipeline.
  26.         await _next(context);
  27.     }
  28. }
  30. // 封装扩展方法
  31. public static class RequestCultureMiddlewareExtensions
  32. {
  33.     public static IApplicationBuilder UseRequestCulture(
  34.         this IApplicationBuilder builder)
  35.     {
  36.         return builder.UseMiddleware<RequestCultureMiddleware>();
  37.     }
  38. }
复制代码
3. 基于工厂的中间件

该方法具体描述请看官方文档
上文描述的自定义类，其实是按照约定来定义实现的。也可以根据IMiddlewareFactory/IMiddleware 中间件的扩展点来使用：
  1. // 自定义中间件类实现 IMiddleware 接口
  2. public class CustomMiddleware : IMiddleware
  3. {
  4.     public async Task InvokeAsync(HttpContext context, RequestDelegate next)
  5.     {
  6.         // 中间件逻辑
  7.         await next(context);
  8.     }
  9. }
  11. // 自定义中间件工厂类实现 IMiddlewareFactory 接口
  12. public class CustomMiddlewareFactory : IMiddlewareFactory
  13. {
  14.     public IMiddleware Create(IServiceProvider serviceProvider)
  15.     {
  16.         // 在这里可以进行一些初始化操作，如依赖注入等
  17.         return new CustomMiddleware();
  18.     }
  19. }
  21. // 在 Startup.cs 中使用中间件工厂模式添加中间件
  22. public void Configure(IApplicationBuilder app)
  23. {
  24.     app.UseMiddleware<CustomMiddlewareFactory>();
  25. }
复制代码
详细具体的自定义中间件方式请参阅官方文档
三、源码解读中间件

以下是源代码的部分删减和修改，以便于更好地理解
1. 创建主机构建器

为了更好地理解中间件的创建和执行在整个框架中的位置，我们仍然从 Program 开始。在 Program 中使用 CreateBuilder 方法创建一个默认的主机构建器，配置应用程序的默认设置，并注入基础服务。
  1. // 在Program.cs文件中调用
  2. var builder = WebApplication.CreateBuilder(args);
复制代码
CreateBuilder方法返回了WebApplicationBuilder实例
  1. public static WebApplicationBuilder CreateBuilder(string[] args) =>
  2.     new WebApplicationBuilder(new WebApplicationOptions(){ Args = args });
复制代码
在 WebApplicationBuilder 的构造函数中，将配置并注册中间件
  1. internal WebApplicationBuilder(WebApplicationOptions options, Action<IHostBuilder>? configureDefaults = null)
  2. {
  3.     // 创建BootstrapHostBuilder实例
  4.     var bootstrapHostBuilder = new BootstrapHostBuilder(_hostApplicationBuilder);
  6.     // bootstrapHostBuilder 上调用 ConfigureWebHostDefaults 方法，以进行特定于 Web 主机的配置
  7.     bootstrapHostBuilder.ConfigureWebHostDefaults(webHostBuilder =>
  8.     {
  9.         // 配置应用程序包含了中间件的注册过程和一系列的配置
  10.         webHostBuilder.Configure(ConfigureApplication);
  11.     });
  13.     var webHostContext = (WebHostBuilderContext)bootstrapHostBuilder.Properties[typeof(WebHostBuilderContext)];
  14.     Environment = webHostContext.HostingEnvironment;
  16.     Host = new ConfigureHostBuilder(bootstrapHostBuilder.Context, Configuration, Services);
  17.     WebHost = new ConfigureWebHostBuilder(webHostContext, Configuration, Services);
  18. }
复制代码
ConfigureApplication 方法是用于配置应用程序的核心方法。其中包含了中间件的注册过程。本篇文章只关注中间件，路由相关的内容会在下一篇文章进行详细解释。
  1. private void ConfigureApplication(WebHostBuilderContext context, IApplicationBuilder app)
  2. {
  3.     Debug.Assert(_builtApplication is not null);
  5.     // 在 WebApplication 之前调用 UseRouting，例如在 StartupFilter 中，
  6.     // 我们需要移除该属性并在最后重新设置，以免影响过滤器中的路由
  7.     if (app.Properties.TryGetValue(EndpointRouteBuilderKey, out var priorRouteBuilder))
  8.     {
  9.         app.Properties.Remove(EndpointRouteBuilderKey);
  10.     }
  12.     // ...
  14.     // 将源管道连接到目标管道
  15.     var wireSourcePipeline = new WireSourcePipeline(_builtApplication);
  16.     app.Use(wireSourcePipeline.CreateMiddleware);
  18.     // ..
  20.     // 将属性复制到目标应用程序构建器
  21.     foreach (var item in _builtApplication.Properties)
  22.     {
  23.         app.Properties[item.Key] = item.Value;
  24.     }
  26.     // 移除路由构建器以清理属性，我们已经完成了将路由添加到管道的操作
  27.     app.Properties.Remove(WebApplication.GlobalEndpointRouteBuilderKey);
  29.     // 如果之前存在路由构建器，则重置它，这对于 StartupFilters 是必要的
  30.     if (priorRouteBuilder is not null)
  31.     {
  32.         app.Properties[EndpointRouteBuilderKey] = priorRouteBuilder;
  33.     }
  34. }
复制代码
通过新构建的RequestDelegate委托处理请求，在目标中间件管道中连接源中间件管道
  1. private sealed class WireSourcePipeline(IApplicationBuilder builtApplication)
  2. {
  3.     private readonly IApplicationBuilder _builtApplication = builtApplication;
  5.     public RequestDelegate CreateMiddleware(RequestDelegate next)
  6.     {
  7.         _builtApplication.Run(next);
  8.         return _builtApplication.Build();
  9.     }
  10. }
复制代码
2. 启动主机，并侦听HTTP请求

从Program中app.Run()开始，启动主机，最终会调用IHost的StartAsync方法。
  1. // Program调用Run
  2. app.Run();
  4. // 实现Run();
  5. public void Run([StringSyntax(StringSyntaxAttribute.Uri)] string? url = null)
  6. {
  7.     Listen(url);
  8.     HostingAbstractionsHostExtensions.Run(this);
  9. }
  11. // 实现HostingAbstractionsHostExtensions.Run(this);
  12. public static async Task RunAsync(this IHost host, CancellationToken token = default)
  13. {
  14.     try
  15.     {
  16.         await host.StartAsync(token).ConfigureAwait(false);
  18.         await host.WaitForShutdownAsync(token).ConfigureAwait(false);
  19.     }
  20.     finally
  21.     {
  22.         if (host is IAsyncDisposable asyncDisposable)
  23.         {
  24.             await asyncDisposable.DisposeAsync().ConfigureAwait(false);
  25.         }
  26.         else
  27.         {
  28.             host.Dispose();
  29.         }
  30.     }
  31. }
复制代码
将中间件和StartupFilters扩展传入HostingApplication主机，并进行启动
  1. public async Task StartAsync(CancellationToken cancellationToken)
  2. {
  3.     // ...省略了从配置中获取服务器监听地址和端口...
  5.     // 通过配置构建中间件管道
  6.     RequestDelegate? application = null;
  7.     try
  8.     {
  9.         IApplicationBuilder builder = ApplicationBuilderFactory.CreateBuilder(Server.Features);
  11.         foreach (var filter in StartupFilters.Reverse())
  12.         {
  13.             configure = filter.Configure(configure);
  14.         }
  15.         configure(builder);
  16.         // Build the request pipeline
  17.         application = builder.Build();
  18.     }
  19.     catch (Exception ex)
  20.     {
  21.         Logger.ApplicationError(ex);
  22.     }
  24.     /*
  25.      * application:中间件
  26.      * DiagnosticListener:事件监听器
  27.      * HttpContextFactory：HttpContext对象的工厂
  28.      */
  29.     HostingApplication httpApplication = new HostingApplication(application, Logger, DiagnosticListener, ActivitySource, Propagator, HttpContextFactory, HostingEventSource.Log, HostingMetrics);
  31.     await Server.StartAsync(httpApplication, cancellationToken);
  33. }
复制代码
IApplicationBuilder 提供配置应用程序请求管道的机制，Build方法生成此应用程序用于处理HTTP请求的委托。
  1. public RequestDelegate Build()
  2. {
  3.     // 构建一个 RequestDelegate 委托，代表请求的处理逻辑
  4.     RequestDelegate app = context =>
  5.     {
  6.         var endpoint = context.GetEndpoint();
  7.         var endpointRequestDelegate = endpoint?.RequestDelegate;
  8.         if (endpointRequestDelegate != null)
  9.         {
  10.             throw new InvalidOperationException(message);
  11.         }
  13.         return Task.CompletedTask;
  14.     };
  16.     // 逐步构建了包含所有中间件的管道
  17.     for (var c = _components.Count - 1; c >= 0; c--)
  18.     {
  19.         app = _components[c](app);
  20.     }
  22.     return app;
  23. }
复制代码
3. IApplicationBuilder作用及实现

这里对IApplicationBuilder做个整体了解，然后再回归上文流程。
IApplicationBuilder的作用是提供了配置应用程序请求管道的机制。它定义了一组方法和属性，用于构建和配置应用程序的中间件管道，处理传入的 HTTP 请求。
  1. public partial class ApplicationBuilder : IApplicationBuilder
  2.   {
  3.       private readonly List<Func<RequestDelegate, RequestDelegate>> _components = new();
  4.       private readonly List<string>? _descriptions;
  6.       /// <summary>
  7.       /// Adds the middleware to the application request pipeline.
  8.       /// </summary>
  9.       /// <param name="middleware">The middleware.</param>
  10.       /// <returns>An instance of <see cref="IApplicationBuilder"/> after the operation has completed.</returns>
  11.       public IApplicationBuilder Use(Func<RequestDelegate, RequestDelegate> middleware)
  12.       {
  13.           _components.Add(middleware);
  14.           _descriptions?.Add(CreateMiddlewareDescription(middleware));
  16.           return this;
  17.       }
  19.       private static string CreateMiddlewareDescription(Func<RequestDelegate, RequestDelegate> middleware)
  20.       {
  21.           if (middleware.Target != null)
  22.           {
  23.               // To IApplicationBuilder, middleware is just a func. Getting a good description is hard.
  24.               // Inspect the incoming func and attempt to resolve it back to a middleware type if possible.
  25.               // UseMiddlewareExtensions adds middleware via a method with the name CreateMiddleware.
  26.               // If this pattern is matched, then ToString on the target returns the middleware type name.
  27.               if (middleware.Method.Name == "CreateMiddleware")
  28.               {
  29.                   return middleware.Target.ToString()!;
  30.               }
  32.               return middleware.Target.GetType().FullName + "." + middleware.Method.Name;
  33.           }
  35.           return middleware.Method.Name.ToString();
  36.       }
  38.       /// <summary>
  39.       /// Produces a <see cref="RequestDelegate"/> that executes added middlewares.
  40.       /// </summary>
  41.       /// <returns>The <see cref="RequestDelegate"/>.</returns>
  42.       public RequestDelegate Build()
  43.       {
  44.           RequestDelegate app = context =>
  45.           {
  46.               // If we reach the end of the pipeline, but we have an endpoint, then something unexpected has happened.
  47.               // This could happen if user code sets an endpoint, but they forgot to add the UseEndpoint middleware.
  48.               var endpoint = context.GetEndpoint();
  49.               var endpointRequestDelegate = endpoint?.RequestDelegate;
  50.               if (endpointRequestDelegate != null)
  51.               {
  52.                   var message =
  53.                       $"The request reached the end of the pipeline without executing the endpoint: '{endpoint!.DisplayName}'. " +
  54.                       $"Please register the EndpointMiddleware using '{nameof(IApplicationBuilder)}.UseEndpoints(...)' if using " +
  55.                       $"routing.";
  56.                   throw new InvalidOperationException(message);
  57.               }
  59.               // Flushing the response and calling through to the next middleware in the pipeline is
  60.               // a user error, but don't attempt to set the status code if this happens. It leads to a confusing
  61.               // behavior where the client response looks fine, but the server side logic results in an exception.
  62.               if (!context.Response.HasStarted)
  63.               {
  64.                   context.Response.StatusCode = StatusCodes.Status404NotFound;
  65.               }
  67.               // Communicates to higher layers that the request wasn't handled by the app pipeline.
  68.               context.Items[RequestUnhandledKey] = true;
  70.               return Task.CompletedTask;
  71.           };
  73.           for (var c = _components.Count - 1; c >= 0; c--)
  74.           {
  75.               app = _components[c](app);
  76.           }
  78.           return app;
  79.       }
  81.   }
复制代码
回归上文流程，将生成的管道传入HostingApplication中，并在处理Http请求时，进行执行。
  1. // Execute the request
  2. public Task ProcessRequestAsync(Context context)
  3. {
  4.     return _application(context.HttpContext!);
  5. }
复制代码
还是不清楚执行位置的同学，可以翻阅《.NET源码解读kestrel服务器及创建HttpContext对象流程》文章中的这块代码来进行了解。

四、小结

.NET 中间件就是基于管道模式和委托来进行实现。每个中间件都是一个委托方法，接受一个 HttpContext 对象和一个 RequestDelegate 委托作为参数，可以对请求进行修改、添加额外的处理逻辑，然后调用 RequestDelegate 来将请求传递给下一个中间件或终止请求处理。
如果您觉得这篇文章有所收获，还请点个赞并关注。如果您有宝贵建议，欢迎在评论区留言，非常感谢您的支持！
(也可以关注我的公众号噢：Broder,万分感谢_)

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4