探究ASP.NET Core Middleware实现方法

概念

ASP.NET Core Middleware是在应用程序处理管道pipeline中用于处理请求和操作响应的组件。

每个组件:

  • 在pipeline中判断是否将请求传递给下一个组件
  • 在处理管道的下个组件执行之前和之后执行一些工作, HttpContxt对象能跨域请求、响应的执行周期

特性和行为

ASP.NET Core处理管道由一系列请求委托组成,一环接一环的被调用, 下面给出自己绘制的Middleware pipeline流程图:

从上图可以看出,请求自进入处理管道,经历了四个中间件,每个中间件都包含后续紧邻中间件 执行委托(next)的引用,同时每个中间件在交棒之前和交棒之后可以自行决定参与一些Http请求和响应的逻辑处理。

每个中间件还可以决定不将请求转发给下一个委托,这称为请求管道的短路(短路是有必要的,某些专有中间件比如 StaticFileMiddleware 可以在完成功能之后,避免请求被转发到其他动态处理过程)。

源码实现

观察一个标准的中间件代码的写法和用法:

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();

标准的中间件使用方式是如此简单明了,带着几个问题探究一下源码实现

(1).中间件传参是怎样完成的: app.UseMiddleware<Authorization>(AuthOption); 我们传参的时候,为什么能自动注入中间件构造函数非第1个参数

(2).编写中间件的时候,为什么必须要定义特定的 Invoke/InvokeAsync 函数?

(3).设定中间件的顺序很重要,中间件的嵌套顺序是怎么确定的 ?

思考以上标准中间件的行为: 输入下一个中间件的执行委托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方法完成前后中间件的链式传值关系

分析源码:回答上面的问题:

  1. 使用反射构造中间件的时候,第一个参数Array[0] 是下一个中间件的执行委托
  2. 当前中间件执行委托 函数名称被限制为: Invoke/InvokeAsync, 函数支持传入除HttpContext之外的参数
  3. 按照代码顺序添加进入 _components容器, 通过后一个中间件的执行委托 -----(指向)----> 前一个中间件的输入执行委托建立链式关系。

附:非标准中间件的用法

短路中间件、 分叉中间件、条件中间件

整个处理管道的形成,存在一些管道分叉或者临时插入中间件的行为,一些重要方法可供使用

  • Use方法是一个注册中间件的简便写法
  • Run方法是一个约定,一些中间件使用Run方法来完成管道的结尾
  • Map扩展方法:请求满足指定路径,将会执行分叉管道,强调满足 path
  • MapWhen方法:HttpContext满足条件,将会执行分叉管道:
  • UseWhen方法:HttpContext满足条件 则插入中间件

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

(0)

相关推荐

  • ASP.NET Core应用错误处理之StatusCodePagesMiddleware中间件针对响应码呈现错误页面

    前言 StatusCodePagesMiddleware中间件与ExceptionHandlerMiddleware中间件比较类似,它们都是在后续请求处理过程中"出错"的情况下利用一个错误处理器来完成最终的请求处理与响应的任务.它们之间的差异在于对"错误"的界定上,对于ExceptionHandlerMiddleware中间件来说,它所谓的错误就是抛出异常,但是对于StatusCodePagesMiddleware中间件来说,则将介于400~599之间的响应状态码视

  • ASP.NET Core应用错误处理之ExceptionHandlerMiddleware中间件呈现“定制化错误页面”

    前言 DeveloperExceptionPageMiddleware中间件利用呈现出来的错误页面实现抛出异常和当前请求的详细信息以辅助开发人员更好地进行纠错诊断工作,而ExceptionHandlerMiddleware中间件则是面向最终用户的,我们可以利用它来显示一个友好的定制化的错误页面.按照惯例,我们还是先来看看ExceptionHandlerMiddleware的类型定义. public class ExceptionHandlerMiddleware { public Excepti

  • ASP.NET Core Middleware的实现方法详解

    概念 ASP.NET Core Middleware是在应用程序处理管道pipeline中用于处理请求和操作响应的组件. 每个组件: 在pipeline中判断是否将请求传递给下一个组件 在处理管道的下个组件执行之前和之后执行一些工作, HttpContxt对象能跨域请求.响应的执行周期 特性和行为 ASP.NET Core处理管道由一系列请求委托组成,一环接一环的被调用, 下面给出自己绘制的Middleware pipeline流程图: 从上图可以看出,请求自进入处理管道,经历了四个中间件,每个

  • 利用Asp.Net Core的MiddleWare思想如何处理复杂业务流程详解

    前言 最近利用Asp.Net Core 的MiddleWare思想对公司的古老代码进行重构,在这里把我的设计思路分享出来,希望对大家处理复杂的流程业务能有所帮助. 背景 一个流程初始化接口,接口中根据传入的流程类型,需要做一些不同的工作. 1.有的工作是不管什么类型的流程都要做的(共有),有的工作是某一流程特有的. 2.各个处理任务基本不存在嵌套关系,所以代码基本是流水账式的. 3.流程的种类较多,代码中if或者switch判断占了很大的篇幅. 4.这些处理工作大致可分为三大类,前期准备工作(参

  • ASP.NET Core应用错误处理之DeveloperExceptionPageMiddleware中间件呈现“开发者异常页面”

    前言 在<ASP.NET Core应用的错误处理[1]:三种呈现错误页面的方式>中,我们通过几个简单的实例演示了如何呈现一个错误页面,这些错误页面的呈现分别由三个对应的中间件来完成,接下来我们将对这三个中间件进行详细介绍.在开发环境呈现的异常页面是通过一个类型为DeveloperExceptionPageMiddleware中间件实现的. public class DeveloperExceptionPageMiddleware { public DeveloperExceptionPageM

  • 探究ASP.NET Core Middleware实现方法

    概念 ASP.NET Core Middleware是在应用程序处理管道pipeline中用于处理请求和操作响应的组件. 每个组件: 在pipeline中判断是否将请求传递给下一个组件 在处理管道的下个组件执行之前和之后执行一些工作, HttpContxt对象能跨域请求.响应的执行周期 特性和行为 ASP.NET Core处理管道由一系列请求委托组成,一环接一环的被调用, 下面给出自己绘制的Middleware pipeline流程图: 从上图可以看出,请求自进入处理管道,经历了四个中间件,每个

  • xUnit 编写 ASP.NET Core 单元测试的方法

    还记得 .NET Framework 的 ASP.NET WebForm 吗?那个年代如果要在 Web 层做单元测试简直就是灾难啊..NET Core 吸取教训,在设计上考虑到了可测试性,就连 ASP.NET Core 这种 Web 或 API 应用要做单元测试也是很方便的.其中面向接口和依赖注入在这方面起到了非常重要的作用. 本文就来手把手教你如何用 xUnit 对 ASP.NET Core 应用做单元测试..NET Core 常用的测试工具还有 NUnit 和 MSTest,我本人习惯用 x

  • 深入探究ASP.NET Core Startup初始化问题

    前言 Startup类相信大家都比较熟悉,在我们使用ASP.NET Core开发过程中经常用到的类,我们通常使用它进行IOC服务注册,配置中间件信息等.虽然它不是必须的,但是将这些操作统一在Startup中做处理,会在实际开发中带来许多方便.当我们谈起Startup类的时候你有没有好奇过以下几点 为何我们自定义的Startup可以正常工作. 我们定义的Startup类中ConfigureServices和Configure只能叫这个名字才能被调用到吗? 在使用泛型主机(IHostBuilder)

  • ASP.NET Core发送邮件的方法

    前言 我们知道目前 .NET Core 还不支持 SMTP 协议,当我么在使用到发送邮件功能的时候,需要借助于一些第三方组件来达到目的,今天给大家介绍两款开源的邮件发送组件,它们分别是MailKit 和FluentEmail,下面我对它们分别进行介绍. MailKit 在 ASP.NET Core 中,可以使用 MailKit 来发送邮件,它支持跨平台,并且支持 IMAP, POP3, SMTP 等协议. 你可以使用下面的方式安装: Install-Package MailKit 下面是一个简单

  • 理解ASP.NET Core 中间件(Middleware)

    目录 中间件 中间件管道 Run Use UseWhen Map MapWhen Run & Use & UseWhen & Map & Map 编写中间件并激活 基于约定的中间件 基于工厂的中间件 基于约定的中间件 VS 基于工厂的中间件 中间件 先借用微软官方文档的一张图: 可以看到,中间件实际上是一种配置在HTTP请求管道中,用来处理请求和响应的组件.它可以: 决定是否将请求传递到管道中的下一个中间件 可以在管道中的下一个中间件处理之前和之后进行操作 此外,中间件的注

  • ASP.NET Core基础之Main方法讲解

    为什么ASP.NET Core采用Main方法? 需要记住的最重要的一点是,ASP.NET Core Web 应用程序最初作为控制台应用程序启动,Main() 方法是应用程序的入口点.因此,当我们执行ASP.NET Core Web应用程序时,首先它寻找 Main() 方法,这是执行开始的方法.然后,Main()方法将ASP.NET配置并启动它.此时,应用程序将成为ASP.NET Core Web应用程序. 如果进一步查看 Main() 方法的正文,则会发现它通过将命令行参数 args 作为参数

  • ASP.NET Core 3.0 gRPC拦截器的使用

    一. 前言 前面两篇文章给大家介绍了使用gRPC的入门以及双向流的使用,今天介绍的是gRPC中的拦截器.拦截器就像MVC的过滤器或者是ASP.NET Core middleware 一样,具有面向切面的思想,可以在调用服务的时候进行一些统一处理, 很适合在这里处理验证.日志等流程.本片文章就以记录日志为例来进行讲解. 二. Interceptor 类介绍 Interceptor类是gRPC服务拦截器的基类,是一个抽象类,它定了几个虚方法,分别如下: public virtual TRespons

  • ASP.NET Core AutoWrapper 自定义响应输出实现

    前言 AutoWrapper是一个简单可自定义全局异常处理程序和ASP.NET Core API响应的包装.他使用ASP.NET Core middleware拦截传入的HTTP请求,并将最后的结果使用统一的格式来自动包装起来.目的主要是让我们更多的关注业务特定的代码要求,并让包装器自动处理HTTP响应.这可以在构建API时加快开发时间,同时为HTTP响应试试我们统一的标准. 安装 AutoWrapper.Core从NuGet或通过CLI下载并安装 PM> Install-Package Aut

  • ASP.NET Core使用HostingStartup增强启动操作方法详解

    概念 在ASP.NET Core中我们可以使用一种机制来增强启动时的操作,它就是HostingStartup.如何叫"增强"操作,相信了解过AOP概念的同学应该都非常的熟悉.我们常说AOP使用了关注点分离的方式,增强了对现有逻辑的操作.而我们今天要说的HostingStartup就是为了"增强"启动操作,这种"增强"的操作甚至可以对现有的程序可以做到无改动的操作.例如,外部程序集可通过HostingStartup实现为应用提供配置服务.注册服务或

随机推荐