AspNetCore中的中间件详解

1 什么叫做中间件？

ASP.NET Core处理请求的方式看做是一个管道，中间件是组装到应用程序管道中用来处理请求和响应的组件。通常是一个可重用的类方法每个中间件可以：（1）选择是否将请求传递给管道中的下一个组件。（2）可以在调用管道中的下一个组件之前和之后执行业务逻辑。

其中关于请求管道配置的一个重要方法在startup中的Configure(IApplicationBuilder app, IWebHostEnvironment env)方法。可用Use、Map、Run方法来配置需要使用的中间件。通常使用IApplicationBuilder的拓展方法来配置请求管道，加入指定的中间件。

IApplicationBuilder Use(Func<RequestDelegate, RequestDelegate> middleware);中间件类的本质其实是委托类

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
//判断是否为开发环境
if (env.IsDevelopment())
{
//使用异常开发页面中间件
app.UseDeveloperExceptionPage();
}
//静态文件中间件
app.UseStaticFiles();
//HTTP请求转HTTPS请求
app.UseHttpsRedirection();
//身份验证
app.UseAuthentication();
//相较于netcore2来说,Routing 中间件是拆分出来的，原来是属于MVC中间件的一部分
app.UseRouting();
//端点中间件，请求处理路径,结合Routing中间件一起使用的
app.UseEndpoints(endpoints =>
{
//当请求\”/\”时，响应输出HelloWorld【可通过lamda表达式进行配置】
endpoints.MapGet(\”/\”, async context =>
{
await context.Response.WriteAsync(\”Hello World!\”);
});
//请求路径匹配到 /home/index/1 这种路径时，将会到指定的handler处理器上,默认会处理到
endpoints.MapControllerRoute(\”default\”,\”/{controller=home}/{action=index}/{id?}\”);
});
}

2 请求短路与中间件顺序

请求会按照顺序依次经过每个加入管道的中间件，值得注意的是，中间件可以决定是否将请求交给下一个委托，当中间件拒绝将请求传递到下一个中间件时，叫做请求短路，可以避免不必要的工作。中间件的执行与调用的顺序有关，在响应式以相反的顺序返回。请求在每一步都有可能短路，所以需要正确的添加中间件，如异常处理的中间件，需要放在请求管道的前面，这样就可以一开始捕获异常，以及后面中间件中可能发生的异常，做出返回处理。

3 中间件配置方法Use、Run、Map

ASP.NET 中的核心请求管道是通过一个个请求委托串联而来的，具体是通过IApplicationBuilder的Use、Run、Map方法来实现的。

在讲解中间件配置方法之前，需要了解什么是RequestDelegate、和代码语言描述的中间件Func<RequestDelegate, RequestDelegate> middleware

//一个能处理请求的方法
public delegate Task RequestDelegate(HttpContext context);
//中间件原生定义，委托，输入是一个RequestDelegate，输出也是一个RequestDelegate，
Func<RequestDelegate, RequestDelegate> middleware = new Func<RequestDelegate, RequestDelegate>((RequestDelegate requestdelegate) =>
{
return new RequestDelegate(async (context) =>
{
await context.Response.WriteAsync(\”接收1个带RequestDelegate类型的参数，返回RequestDelegate类型的委托\”);
});
});
// 上述中间件的定义代码可根据lamda表达式规则进行缩写
Func<RequestDelegate, RequestDelegate> middleware = new Func<RequestDelegate, RequestDelegate>((RequestDelegate requestdelegate) =>
{
return new RequestDelegate(async (context) =>
{
await context.Response.WriteAsync(\”接收1个带RequestDelegate类型的参数，返回RequestDelegate类型的委托\”);
});
});
Func<RequestDelegate, RequestDelegate> middleware = (request=>{
return new RequestDelegate(async (context) =>
{
await context.Response.WriteAsync(\”接收1个带RequestDelegate类型的参数，返回RequestDelegate类型的委托\”);
});
});

3.1Use 方法配置中间件

//增加中间件到请求管道中
IApplicationBuilder Use(Func<RequestDelegate, RequestDelegate> middleware);

Use 扩展可以使用两个重载：一个重载采用 HttpContext 和 Func < Task >。不使用任何参数调用 Func< Task >。

app.Use(async (context, next) =>
{
await context.Response.WriteAsync(\” Rquest The first middleware\”);
//调用下一个中间件
await next.Invoke();
await context.Response.WriteAsync(\” Response The first middleware\”);
});

另一个重载采用 HttpContext 和 RequestDelegate。通过传递 HttpContext 调用 RequestDelegate。优先使用后面的重载，因为它省去了使用其他重载时所需的两个内部每请求分配。

app.Use(next =>
{
return new RequestDelegate(async context =>
{
await context.Response.WriteAsync(\” Rquest The first middleware\”);
await next.Invoke(context);
await context.Response.WriteAsync(\” Response The first middleware\”);
});
}
);

上面两种方法实现的功能一致。值得注意的是，next参数表示管道中的下一个中间件。通过不调用下一个中间件，会导致请求短路或中断，所以需要谨慎的选择是否需要调用下一个中间件。

3.2Run 方法配置中间件

public static void Run(this IApplicationBuilder app, RequestDelegate handler);

Run 方法配置请求管道时，会使得请求管道短路，因为它不调用下一个请求。因此Run方法一般只在管道的底部使用。

app.Run( async context=> {
await context.Response.WriteAsync(\” Rquest The final middleware\”);
});

3.2Map 方法配置中间件

//pathMatch 请求路径匹配字符串
//configuration 符合匹配规则时采取的请求处理逻辑.
//configuration 是一个无返回，请求参数类型为 IApplicationBuilder的回调函数。
public static IApplicationBuilder Map(this IApplicationBuilder app, PathString pathMatch, Action<IApplicationBuilder> configuration);

Map 方法是一种可以基于请求路径的不同来配置分支中间件。

app.Map(\”/secondturl\”, appBuilder => {
appBuilder.Run(async context =>
{
await context.Response.WriteAsync(\” the request\’url is secondturl\” + \”\\n\”);
});
});

且可以在嵌套使用Map方法去配置分支中间件

4 自定义中间件

虽然中间件的本质是一个Func<RequestDelegate, RequestDelegate> middleware 对象，中间件的类型可分为两种,下面自定义实现以及记录请求IP地址的中间件

弱类型中间件（1）定义Ip中间件

public class RequestIpMiddleware
{
private readonly RequestDelegate requestDelegate;
public RequestIpMiddleware(RequestDelegate requestDelegate) {
this.requestDelegate = requestDelegate;
}
public async Task Invoke(HttpContext context) {
context.Response.WriteAsync(\”The Request Ip is \” + context.Request.HttpContext.Connection.RemoteIpAddress.ToString()+\”\\n\”);
//调用下一个请求中间件
await requestDelegate.Invoke(context);
}
}

（2）增加Use的拓展方法

/// <summary>
/// 调用中间件的扩展方法
/// </summary>
public static class MiddlewareExtensions
{
/// <summary>
///this 关键字不能省略
/// </summary>
/// <param name=\”app\”></param>
/// <returns></returns>
public static IApplicationBuilder UseIpMiddleware( this IApplicationBuilder app )
{
return app.UseMiddleware<RequestIpMiddleware>();
}
}

（3）Configure方法中使用该中间件

app.UseIpMiddleware();

强类型中间件

可以在Use方法中调用这个匿名内部类，但是最好是将中间件定义成一个强类型，利于阅读，且符合编程习惯。IApplicationBuilder 提供了一种拓展方法来配置强类型的中间件

public static IApplicationBuilder UseMiddleware<TMiddleware>(this IApplicationBuilder app, params object[] args);
/// <summary>
/// 自定义中间件
/// </summary>
public class IPMiddleware : IMiddleware
{
/// <summary>
/// IMiddleware接口定义了唯一的InvokeAsync方法，用来实现对请求的处理。
/// </summary>
/// <param name=\”context\”> 当前请求上下文</param>
/// <param name=\”next\”>下一个请求requestDelegate</param>
/// <returns></returns>
public Task InvokeAsync(HttpContext context, RequestDelegate next)
{
//获取请求的IP
var ip = context.Request.HttpContext.Connection.RemoteIpAddress.ToString();
context.Response.WriteAsync(\”IP is \”+ip+\”\\n\”);
//调用下一个中间件
return next.Invoke(context);
}
}