中间件是个什么玩意儿？官网是这样说的

1
2
3
4
5

中间件是一种装配到应用管道以处理请求和响应的软件。 每个组件：

* 选择是否将请求传递到管道中的下一个组件。
* 可在管道中的下一个组件前后执行工作。
使用 RunMap 和 Use 扩展方法来配置请求委托,请求委托用于生成请求管道,每个 HTTP 请求都交由请求委托处理。

其实，ASP.NET Core内置许多实用的中间件，不过，有时候这些内置中间件可能无法满足我们的需求，这时候就需要我们进行自定了。

使用 WebApplication 创建中间件管道

ASP.NET Core 请求管道包含一系列请求委托，依次调用,调用图序如下。

中间件使用使用 RunMap 和 Use 扩展方法来配置。我们来个例子实践一下，先在Program中基于Use添加一个简单的中间件

1
2
3
4
5
6
7

var logger = app.Services.GetService<ILogger<Program>>();
app.Use(async (context, next) =>
{
    logger.LogInformation("这是Use调用前");
    await next.Invoke();
    logger.LogInformation("这是Use调用后");
});

再新建一个Controller类并新增一个Get请求，逻辑就用简单的日志打印吧

1
2
3
4
5
6
7
8
9
10
11
12
13

[Route("api/[controller]")]
[ApiController]
public class MiddlewareController : ControllerBase
{
    private readonly ILogger<MiddlewareController> _logger;
    public MiddlewareController(ILogger<MiddlewareController> logger) { _logger = logger; }
    [HttpGet]
    public string Print()
    {
        _logger.LogInformation("Print");
        return "Hello";
    }
}

我们再来看看Run作用

1
2
3
4
5

app.Run(async(context) =>
{
    logger.LogInformation("这是调用Run");
    await context.Response.WriteAsync("OK");
});

• Use 将多个请求委托链接在一起。 Next 参数表示管道中的下一个委托。使用Next便可继续执行
• Run 委托不会收到 Next 参数。 第一个 Run 委托始终为终端，执行后便直接返回，不会继续执行下一个委托，用于终止管道，如果在Run后添加的委托，不管是Use或者Run，都不会执行

我们再来看一个例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

var logger = app.Services.GetService<ILogger<Program>>();
app.Use(async (context, next) =>
{
    logger.LogInformation("这是Use调用前");
    await next.Invoke();
    logger.LogInformation("这是Use调用后");
});
app.Use(async (context, next) =>
{
    logger.LogInformation("这是Use调用前2");
    await next.Invoke();
    logger.LogInformation("这是Use调用后2");
});

app.Run(async(context) =>
{
    logger.LogInformation("这是调用Run");
    await context.Response.WriteAsync("OK");
});
app.Use(async (context, next) =>
{
    logger.LogInformation("这是Use调用前1");
    await next.Invoke();
    logger.LogInformation("这是Use调用后1");
});

可以看到，前面是一次执行，最后一个Use是没有执行的，因为前面的Run已经直接返回了。

自定义异常处理中间件

自定义中间件有两个必备条件:

• 具有类型为 RequestDelegate 的参数的公共构造函数
• 名为 Invoke 或 InvokeAsync 的公共方法。 此方法必须：1.返回 Task;2.接受类型 HttpContext 的第一个参数。
  新建一个名为ExceptionMiddleware的类，

public class ExceptionMiddleware
    {
        private readonly RequestDelegate _next;

        public ExceptionMiddleware(RequestDelegate next)
        {
            _next = next;
        }

        public async Task InvokeAsync(HttpContext context)
        {
            try
            {
                await _next(context);
            }
            catch (Exception ex)
            {
                context.Response.ContentType = "application/json;charset=utf-8";
                if (ex is BizException)
                {
                    BizException bizException = (BizException)ex;
                    await context.Response.WriteAsync(JsonConvert.SerializeObject(new { Code = bizException.Status, Msg = bizException.Tips }));
                }
                else
                {
                    await context.Response.WriteAsync(JsonConvert.SerializeObject(new { Code = 502, Msg = "服务端异常" }));
                }
            }
        }
    }

中间件是写好了，现在就是调用，有两种方式:

1.直接在Program.cs中调用，如:app.UseMiddleware<ExceptionMiddleware>();
2.写一个中间件扩展方法，然后去Program.cs调用，这里我们新建一个名为ExceptionMiddlewareExtensions的静态类

1
2
3
4
5
6
7
8

public static class ExceptionMiddlewareExtensions
{
    public static IApplicationBuilder UseException(
        this IApplicationBuilder builder)
    {
        return builder.UseMiddleware<ExceptionMiddleware>();
    }
}

然后在Program.cs加入app.UseException();即可引用。

中间件就暂时先学这么多，更多强大实用的中间件则需要我们结合自身实际情况来开发了，下一节，继续学习ASP.NET Core 中的配置