ASP.NET Core Middleware 抽絲剝繭

時間 2019-12-20

標籤 asp.net asp core middleware 抽絲剝繭欄目 ASP 简体版

原文原文鏈接

一. 宏觀概念

ASP.NET Core Middleware是在應用程序處理管道pipeline中用於處理請求和操做響應的組件。javascript

每一個組件是pipeline 中的一環。java

自行決定是否將請求傳遞給下一個組件web
在處理管道的下個組件執行以前和以後執行業務邏輯api

二. 特性和行爲

ASP.NET Core處理管道由一系列請求委託組成，一環接一環的被調用，pipeline封裝了其中的處理環節，下面是更細化的Middleware 處理管道時序圖：

從上圖能夠看出，請求自進入處理管道，經歷了四個中間件，每一箇中間件都包含後續緊鄰中間件執行委託（next）的引用，同時每一箇中間件在交棒以前和交棒以後能夠自行決定參與一些Http請求和響應的邏輯處理。app

每一箇中間件還能夠決定不將請求轉發給下一個委託，這稱爲請求管道的短路。ide

短路是有必要的，某些特殊中間件好比 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個參數？ui

　　 ② 編寫中間件的時候，爲何必需要定義特定的 Invoke/InvokeAsync 函數？this

　　 ③ 設定中間件的順序很重要，中間件的嵌套順序是怎麼肯定的？spa

思考標準中間件的行爲：

輸入下一個中間件的執行委託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;
}