（4）ASP.NET Core 中间件

时间 2019-12-08

原文原文链接

1.前言

整个HTTP Request请求跟HTTP Response返回结果之间的处理流程是一个请求管道（request pipeline）。而中间件（middleware）则是一种装配到请求管道以处理请求和响应的组件。每一个组件：
●可选择是否将请求传递到管道中的下一个组件。
●可在管道中的下一个组件先后执行工做。
中间件（middleware）处理流程以下图所示：浏览器

2.使用中间件

ASP.NET Core请求管道中每一个中间件都包含一系列的请求委托（request delegates）来处理每一个HTTP请求，依次调用。请求委托经过使用IApplicationBuilder类型的Run、Use和Map扩展方法在Strartup.Configure方法中配置。下面咱们经过配置Run、Use和Map扩展方法示例来了解下中间件。安全

2.1 Run

public class Startup
{
    public void Configure(IApplicationBuilder app)
    {
    //第一个请求委托Run
    app.Run(async context =>//内嵌匿名方法
    {
        await context.Response.WriteAsync("Hello, World!");
    });
    //第二个请求委托Run
    app.Run(async context =>//内嵌匿名方法
    {
        await context.Response.WriteAsync("Hey, World!");
    });
    }
}

响应结果：服务器

由上述代码可知，Run方法指定为一个内嵌匿名方法（称为并行中间件，in-line middleware），而内嵌匿名方法中并无指定执行下一个请求委托，这一个过程叫管道短路，而该中间件又叫“终端中间件”（terminal middleware），由于它阻止中间件下一步处理请求。因此在Run第一个请求委托的时候就已经终止请求，并无执行第二个请求委托直接返回Hello, World!输出文本。而根据官网解释，Run是一种约定，有些中间件组件可能会暴露他们本身的Run方法，而这些方法只能在管道末尾处运行（也就是说Run方法只在中间件执行最后一个请求委托时才使用）。app

2.2 Use

public void Configure(IApplicationBuilder app)
{
    app.Use(async (context, next) =>
    {
        context.Response.ContentType = "text/plain; charset=utf-8";
        await context.Response.WriteAsync("进入第一个委托 执行下一个委托以前\r\n");
        //调用管道中的下一个委托
        await next.Invoke();
        await context.Response.WriteAsync("结束第一个委托 执行下一个委托以后\r\n");
    });
    app.Run(async context =>
    {
        await context.Response.WriteAsync("进入第二个委托\r\n");
        await context.Response.WriteAsync("Hello from 2nd delegate.\r\n");
        await context.Response.WriteAsync("结束第二个委托\r\n");
    });
}

响应结果：async

由上述代码可知，Use方法将多个请求委托连接在一块儿。而next参数表示管道中的下一个委托。若是不调用next参数调用下一个请求委托则会使管道短路。好比，一个受权（authorization）中间件只有经过身份验证以后才能调用下一个委托，不然它就会被短路，并返回“Not Authorized”的响应。因此应尽早在管道中调用异常处理委托，这样它们就能捕获在管道的后期阶段发生的异常。性能

2.3 Map和MapWhen

●Map：Map扩展基于请求路径建立管道分支。
●MapWhen：MapWhen扩展基于请求条件建立管道分支。
Map示例：测试

public class Startup
{
    private static void HandleMapTest1(IApplicationBuilder app)
    {
        app.Run(async context =>
        {
            await context.Response.WriteAsync("Map Test 1");
        });
    }

    private static void HandleMapTest2(IApplicationBuilder app)
    {
        app.Run(async context =>
        {
            await context.Response.WriteAsync("Map Test 2");
        });
    }

    public void Configure(IApplicationBuilder app)
    {
        app.Map("/map1", HandleMapTest1);
        app.Map("/map2", HandleMapTest2);

        app.Run(async context =>
        {
            await context.Response.WriteAsync("Hello from non-Map delegate. <p>");
        });
    }
}

下面表格使用前面的代码显示来自http://localhost:5001的请求和响应。ui

请求this	响应spa
localhost:5001	Hello from non-Map delegate.
localhost:5001/map1	Map Test 1
localhost:5001/map2	Map Test 2
localhost:5001/map3	Hello from non-Map delegate.

由上述代码可知，Map方法将从HttpRequest.Path中删除匹配的路径段，并针对每一个请求将该路径追加到HttpRequest.PathBase。也就是说当咱们在浏览器上输入map1请求地址的时候，系统会执行map1分支管道输出其请求委托信息，同理执行map2就会输出对应请求委托信息。
MapWhen示例：

public class Startup
{
    private static void HandleBranch(IApplicationBuilder app)
    {
        app.Run(async context =>
        {
            var branchVer = context.Request.Query["branch"];
            await context.Response.WriteAsync($"Branch used = {branchVer}");
        });
    }
    public void Configure(IApplicationBuilder app)
    {
        app.MapWhen(context => context.Request.Query.ContainsKey("branch"),
                               HandleBranch);
        app.Run(async context =>
        {
            await context.Response.WriteAsync("Hello from non-Map delegate. <p>");
        });
    }
}

下面表格使用前面的代码显示来自http://localhost:5001的请求和响应。

请求	响应
http://localhost:5001	Hello from non-Map delegate. <p>
https://localhost:5001/?branch=master	Branch used = master

由上述代码可知，MapWhen是基于branch条件而建立管道分支的，咱们在branch条件上输入master就会建立其对应管道分支。也就是说，branch条件上输入任何一个字符串条件，都会建立一个新的管理分支。
并且还Map支持嵌套，例如：

public void Configure(IApplicationBuilder app)
{
    app.Map("/level1", level1App => {
        level1App.Map("/level2a", level2AApp => {
            // "/level1/level2a" processing
        });
        level1App.Map("/level2b", level2BApp => {
            // "/level1/level2b" processing
        });
    });
}

还可同时匹配多个段：

public class Startup
{
    private static void HandleMultiSeg(IApplicationBuilder app)
    {
        app.Run(async context =>
        {
            await context.Response.WriteAsync("Map multiple segments.");
        });
    }
    public void Configure(IApplicationBuilder app)
    {
        app.Map("/map1/seg1", HandleMultiSeg);

        app.Run(async context =>
        {
            await context.Response.WriteAsync("Hello from non-Map delegate.");
        });
    }
}

3.顺序

向Startup.Configure方法添加中间件组件的顺序定义了在请求上调用它们的顺序，以及响应的相反顺序。此排序对于安全性、性能和功能相当重要。
如下Startup.Configure方法将为常见应用方案添加中间件组件：
●异常/错误处理（Exception/error handling）
●HTTP严格传输安全协议（HTTP Strict Transport Security Protocol）
●HTTPS重定向（HTTPS redirection）
●静态文件服务器（Static file server）
●Cookie策略实施（Cookie policy enforcement）
●身份验证（Authentication）
●会话（Session）
●MVC
请看以下代码：

public void Configure(IApplicationBuilder app)
{
    if (env.IsDevelopment())
    {
        // When the app runs in the Development environment:
        //   Use the Developer Exception Page to report app runtime errors.
        //   Use the Database Error Page to report database runtime errors.
        app.UseDeveloperExceptionPage();
        app.UseDatabaseErrorPage();
    }
    else
    {
        // When the app doesn't run in the Development environment:
        //   Enable the Exception Handler Middleware to catch exceptions
        //     thrown in the following middlewares.
        //   Use the HTTP Strict Transport Security Protocol (HSTS)
        //     Middleware.
        app.UseExceptionHandler("/Error");
        app.UseHsts();
    }
    // Return static files and end the pipeline.
    app.UseStaticFiles();
    // Authenticate before the user accesses secure resources.
    app.UseAuthentication();
}

从上述示例代码中，每一个中间件扩展方法都经过Microsoft.AspNetCore.Builder命名空间在 IApplicationBuilder上公开。可是为何咱们要按照这个顺序去添加中间件组件呢？下面咱们挑几个中间件来了解下。
●UseExceptionHandler（异常/错误处理）是添加到管道的第一个中间件组件。所以咱们能够捕获在应用程序调用中发生的任何异常。那为何要将异常/错误处理放在第一位呢？那是由于这样咱们就不用担忧因前面中间件短路而致使捕获不到整个应用程序全部异常信息。
●UseStaticFiles（静态文件）中间件在管道中提早调用，方便它能够处理请求和短路，而无需经过剩余中间组件。也就是说静态文件中间件不用通过UseAuthentication（身份验证）检查就能够直接访问，便可公开访问由静态文件中间件服务的任何文件，包括wwwroot下的文件。
●UseAuthentication（身份验证）仅在MVC选择特定的Razor页面或Controller和Action以后才会发生。
通过上面描述，你们都了解中间件顺序的重要性了吧。

4.编写中间件（重点）

虽然ASP.NET Core为咱们提供了一组丰富的内置中间件组件，但在某些状况下，你可能须要写入自定义中间件。

4.1中间件类

下面咱们自定义一个查询当前区域性的中间件：

public class Startup
{
    public void Configure(IApplicationBuilder app)
    {
        app.Use((context, next) =>
        {
            var cultureQuery = context.Request.Query["culture"];
            if (!string.IsNullOrWhiteSpace(cultureQuery))
            {
                var culture = new CultureInfo(cultureQuery);
                CultureInfo.CurrentCulture = culture;
                CultureInfo.CurrentUICulture = culture;
            }
            // Call the next delegate/middleware in the pipeline
            return next();
        });
        app.Run(async (context) =>
        {
            await context.Response.WriteAsync(
                $"Hello {CultureInfo.CurrentCulture.DisplayName}");
        });
    }
}

可经过传入区域性参数条件进行测试。例如http://localhost:7997/?culture=zh、http://localhost:7997/?culture=en。
可是若是每一个自定义中间件都在Startup.Configure方法中编写如上一大堆代码，那么对于程序来讲，将是灾难性的（不利于维护和调用）。为了更好管理代码，咱们应该把内嵌匿名方法封装到新建的自定义类（示例自定义RequestCultureMiddleware类）里面去：

public class RequestCultureMiddleware
{
    private readonly RequestDelegate _next;
    public RequestCultureMiddleware(RequestDelegate next)
    {
        _next = next;
    }
    public async Task InvokeAsync(HttpContext context)
    {
        context.Response.ContentType = "text/plain; charset=utf-8";
        var cultureQuery = context.Request.Query["culture"];
        if (!string.IsNullOrWhiteSpace(cultureQuery))
        {
            var culture = new CultureInfo(cultureQuery);
            CultureInfo.CurrentCulture = culture;
            CultureInfo.CurrentUICulture = culture;
        }
        // Call the next delegate/middleware in the pipeline
        await _next(context);
    }
}

经过Startup.Configure方法调用中间件：

public class Startup
{
    public void Configure(IApplicationBuilder app)
    {
        app.UseMiddleware<RequestCultureMiddleware>();
        app.Run(async (context) =>
        {
            await context.Response.WriteAsync(
                $"Hello {CultureInfo.CurrentCulture.DisplayName}");
        });
    }
}

4.2中间件扩展方法

Startup.Configure方法调用中间件设置能够经过自定义的扩展方法将其公开（调用内置IApplicationBuilder公开中间件）。示例建立一个RequestCultureMiddlewareExtensions扩展类并经过IApplicationBuilder公开：

public static class RequestCultureMiddlewareExtensions
{
    public static IApplicationBuilder UseRequestCulture(this IApplicationBuilder builder)
    {
        return builder.UseMiddleware<RequestCultureMiddleware>();
    }
}

再经过Startup.Configure方法调用中间件：

public class Startup
{
    public void Configure(IApplicationBuilder app)
{
        app.UseRequestCulture();
        app.Run(async (context) =>
        {
            await context.Response.WriteAsync(
                $"Hello {CultureInfo.CurrentCulture.DisplayName}");
        });
    }
}

响应结果：

经过委托构造中间件，应用程序在运行时建立这个中间件，并将它添加到管道中。这里须要注意的是，中间件的建立是单例的，每一个中间件在应用程序生命周期内只有一个实例。那么问题来了，若是咱们业务逻辑须要多个实例时，该如何操做呢？请继续往下看。

6.按每次请求建立依赖注入（DI）

在中间件的建立过程当中，内置的IOC容器会为咱们建立一个中间件实例，而且整个应用程序生命周期中只会建立一个该中间件的实例。一般咱们的程序不容许这样的注入逻辑。其实，咱们能够把中间件理解成业务逻辑的入口，真正的业务逻辑是经过Application Service层实现的，咱们只须要把应用服务注入到Invoke方法中便可。ASP.NET Core为咱们提供了这种机制，容许咱们按照请求进行依赖的注入，也就是每次请求建立一个服务。示例：

public class CustomMiddleware
{
    private readonly RequestDelegate _next;
    public CustomMiddleware(RequestDelegate next)
    {
        _next = next;
    }
    // IMyScopedService is injected into Invoke
    public async Task Invoke(HttpContext httpContext, IMyScopedService svc)
    {
        svc.MyProperty(1000);
        await _next(httpContext);
    }
}
public static class CustomMiddlewareExtensions
{
    public static IApplicationBuilder UseCustomMiddleware(this IApplicationBuilder builder)
    {
        return builder.UseMiddleware<CustomMiddleware>();
    }
}
public interface IMyScopedService
{
    void MyProperty(decimal input);
}
public class MyScopedService : IMyScopedService
{
    public void MyProperty(decimal input)
    {
        Console.WriteLine("MyProperty is " + input);
    }
}
public void ConfigureServices(IServiceCollection services)
{
    //注入DI服务
    services.AddScoped<IMyScopedService, MyScopedService>();
}

响应结果：

参考文献：
ASP.NET Core中间件
 写入自定义ASP.NET Core中间件