ASP.NET Core Middleware 抽丝剥茧
一. 宏观概念
ASP.NET Core Middleware是在应用程序处理管道pipeline中用于处理请求和操作响应的组件。
每个组件是pipeline 中的一环。
-
自行决定是否将请求传递给下一个组件
-
在处理管道的下个组件执行之前和之后执行业务逻辑
二. 特性和行为
![](https://img2023.cnblogs.com/blog/587720/202304/587720-20230414152345954-71259009.png)
每个中间件还可以决定不将请求转发给下一个委托,这称为请求管道的短路。
短路是有必要的,某些特殊中间件比如 StaticFileMiddleware 可以在完成功能之后,避免请求被转发到其他动态处理过程 。
三. 标准Middleware 使用方式
using System.Threading.Tasks; using Alyio.AspNetCore.ApiMessages; using Gridsum.WebDissector.Common; using Microsoft.AspNetCore.Http; namespace Gridsum.WebDissector { sealed class AuthorizationMiddleware { private readonly RequestDelegate _next; // 下一个中间件执行委托的引用 public AuthorizationMiddleware(RequestDelegate next) { _next = next; } public Task Invoke(HttpContext context) // 贯穿始终的HttpContext对象 { if (context.Request.Path.Value.StartsWith("/api/")) { return _next(context); } if (context.User.Identity.IsAuthenticated && context.User().DisallowBrowseWebsite) { throw new ForbiddenMessage("You are not allow to browse the website."); } return _next(context); } } } public static IApplicationBuilder UserAuthorization(this IApplicationBuilder app) { return app.UseMiddleware<AuthorizationMiddleware>(); } // 启用该中间件,也就是注册该中间件 app.UserAuthorization();
四. 观察标准中间件的定义方式,带着几个问题探究源码实现
① 中间件传参是怎样完成的: app.UseMiddleware<Authorization>(AuthOption); 我们传参的时候,为什么能自动注入中间件构造函数非第1个参数?
② 编写中间件的时候,为什么必须要定义特定的 Invoke/InvokeAsync 函数?
③ 设定中间件的顺序很重要,中间件的嵌套顺序是怎么确定的 ?
思考标准中间件的行为:
- 输入下一个中间件的执行委托Next;
- 定义当前中间件的执行委托Invoke/InvokeAsync;
每个中间件完成了 Func<RequestDelegate,RequestDelegate>这样的行为;
通过参数next与下一个中间件的执行委托Invoke/InvokeAsync 建立"链式"关系。
public delegate Task RequestDelegate(HttpContext context);
//-----------------节选自 Microsoft.AspNetCore.Builder.UseMiddlewareExtensions------------------ /// <summary> /// Adds a middleware type to the application's request pipeline. /// </summary> /// <typeparam name="TMiddleware">The middleware type.</typeparam> /// <param name="app">The <see cref="IApplicationBuilder"/> instance.</param> /// <param name="args">The arguments to pass to the middleware type instance's constructor.</param> /// <returns>The <see cref="IApplicationBuilder"/> instance.</returns> public static IApplicationBuilder UseMiddleware<TMiddleware>(this IApplicationBuilder app, params object[] args) { return app.UseMiddleware(typeof(TMiddleware), args); } /// <summary> /// Adds a middleware type to the application's request pipeline. /// </summary> /// <param name="app">The <see cref="IApplicationBuilder"/> instance.</param> /// <param name="middleware">The middleware type.</param> /// <param name="args">The arguments to pass to the middleware type instance's constructor.</param> /// <returns>The <see cref="IApplicationBuilder"/> instance.</returns> public static IApplicationBuilder UseMiddleware(this IApplicationBuilder app, Type middleware, params object[] args) { if (typeof(IMiddleware).GetTypeInfo().IsAssignableFrom(middleware.GetTypeInfo())) { // IMiddleware doesn't support passing args directly since it's // activated from the container if (args.Length > 0) { throw new NotSupportedException(Resources.FormatException_UseMiddlewareExplicitArgumentsNotSupported(typeof(IMiddleware))); } return UseMiddlewareInterface(app, middleware); } var applicationServices = app.ApplicationServices; return app.Use(next => { var methods = middleware.GetMethods(BindingFlags.Instance | BindingFlags.Public);
// 执行委托名称被限制为Invoke/InvokeAsync var invokeMethods = methods.Where(m => string.Equals(m.Name, InvokeMethodName, StringComparison.Ordinal) || string.Equals(m.Name, InvokeAsyncMethodName, StringComparison.Ordinal) ).ToArray(); if (invokeMethods.Length > 1) { throw new InvalidOperationException(Resources.FormatException_UseMiddleMutlipleInvokes(InvokeMethodName, InvokeAsyncMethodName)); } if (invokeMethods.Length == 0) { throw new InvalidOperationException(Resources.FormatException_UseMiddlewareNoInvokeMethod(InvokeMethodName, InvokeAsyncMethodName, middleware)); } var methodInfo = invokeMethods[0]; if (!typeof(Task).IsAssignableFrom(methodInfo.ReturnType)) { throw new InvalidOperationException(Resources.FormatException_UseMiddlewareNonTaskReturnType(InvokeMethodName, InvokeAsyncMethodName, nameof(Task))); } var parameters = methodInfo.GetParameters(); if (parameters.Length == 0 || parameters[0].ParameterType != typeof(HttpContext)) { throw new InvalidOperationException(Resources.FormatException_UseMiddlewareNoParameters(InvokeMethodName, InvokeAsyncMethodName, nameof(HttpContext))); } var ctorArgs = new object[args.Length + 1]; ctorArgs[0] = next; Array.Copy(args, 0, ctorArgs, 1, args.Length);
// 通过反射形成中间件实例的时候,构造函数第一个参数被指定为 下一个中间件的执行委托
var instance = ActivatorUtilities.CreateInstance(app.ApplicationServices, middleware, ctorArgs); if (parameters.Length == 1) { return (RequestDelegate)methodInfo.CreateDelegate(typeof(RequestDelegate), instance); }
// 当前执行委托除了可指定HttpContext参数以外, 还可以注入更多的依赖参数 var factory = Compile<object>(methodInfo, parameters); return context => { var serviceProvider = context.RequestServices ?? applicationServices; if (serviceProvider == null) { throw new InvalidOperationException(Resources.FormatException_UseMiddlewareIServiceProviderNotAvailable(nameof(IServiceProvider))); } return factory(instance, context, serviceProvider); }; }); } //-------------------节选自 Microsoft.AspNetCore.Builder.Internal.ApplicationBuilder------------------- private readonly IList<Func<RequestDelegate, RequestDelegate>> _components = new List<Func<RequestDelegate, RequestDelegate>>(); publicIApplicationBuilder Use(Func<RequestDelegate,RequestDelegate> middleware) { this._components.Add(middleware); return this; } public RequestDelegate Build() { RequestDelegate app = context => { context.Response.StatusCode = 404; return Task.CompletedTask; }; foreach (var component in _components.Reverse()) { app = component(app); } return app;
}
通过以上代码我们可以看出:
-
注册中间件的过程实际上,是给一个 Type为List<Func<RequestDelegate, RequestDelegate>> 的容器依次添加元素的过程;
-
容器中每个元素对应每个中间件的行为委托Func<RequestDelegate, RequestDelegate>, 这个行为委托包含2个关键行为:输入下一个中间件的执行委托next:RequestDelegate, 完成当前中间件的Invoke函数: RequestDelegate;
-
通过build方法完成前后中间件的链式传值关系
![](https://img2018.cnblogs.com/blog/587720/201901/587720-20190129153340260-182458269.png)
分析源码:回答上面的问题:
① 使用反射构造中间件的时候,第一个参数Array[0] 是下一个中间件的执行委托
② 当前中间件执行委托 函数名称被限制为: Invoke/InvokeAsync, 函数支持传入除HttpContext之外的参数
③ 按照代码顺序添加进入 _components容器, 通过后一个中间件的执行委托 ------> 前一个中间件的输入执行委托建立链式关系。
httpHandler 子收到请求开始构造 req,resp等对象, 在请求结束释放对象。 是怎么释放的?
在请求初始,构造的都是局部变量指向 对象,之后req,resp在pipeline中传递,一直使用的引用传递指向的同一块对象,
在原初始函数退出的时候,局部变量自行释放,指向的堆对象由gc释放。
附:非标准中间件的用法
短路中间件、 分叉中间件、条件中间件
整个处理管道的形成,存在一些管道分叉或者临时插入中间件的行为,一些重要方法可供使用
-
Use方法是一个注册中间件的简便写法
-
Run方法是一个约定,一些中间件使用Run方法来完成管道的结尾
-
Map扩展方法:Path满足指定条件,将会执行分叉管道
-
MapWhen方法:HttpContext满足条件,将会执行分叉管道,相比Map有更灵活的匹配功能
-
UseWhen方法:HttpContext满足条件则插入中间件
码甲拙见,如有问题请下方留言大胆斧正;码字+Visio制图,均为原创,看官请不吝好评+关注, ~。。~
本文欢迎转载,请转载页面明显位置注明原作者及原文链接。
本文来自博客园,作者:{有态度的马甲},转载请注明原文链接:https://www.cnblogs.com/JulianHuang/p/10334472.html
欢迎关注我的原创技术、职场公众号, 加好友谈天说地,一起进化![](https://blog-static.cnblogs.com/files/JulianHuang/QR.gif)