2-中间件

```mindmap
# 中间件
## 原始中间件
## 中间件变体1
## 中间件变体2
## 强类型中间件
### 原始
### 基于约定的中间件：构造函数注入
### 基于约定的中间件： 方法注入

```
# 中间键定义
>i RequestDelegate MiddlewareXXX(RequestDelegate next)
Func<HttpContext, RequestDelegate, Task>
Func<HttpContext, Func\<Task>, Task>

# 中间件分类

## 原始形态中间件
>Microsoft.AspNetCore.Http.Abstractions
namespace Microsoft.AspNetCore.Builder
IApplicationBuilder
```java
var app = WebApplication.Create(args);
IApplicationBuilder appBuilder = app;
appBuilder
    .Use(middleware: HelloMiddleware)
    .Use(middleware: WorldMiddleware);
app.Run();

static RequestDelegate HelloMiddleware(RequestDelegate next)
    => async httpContext => {
    await httpContext.Response.WriteAsync("Hello,");
    await next(httpContext);
};

static RequestDelegate WorldMiddleware(RequestDelegate next)=> httpContext => httpContext.Response.WriteAsync("World!");
```
>Microsoft.AspNetCore.Http.Abstractions.dll
Microsoft.AspNetCore.Builder
UseExtensions

## 中间件委托变体
```java
var app = WebApplication.Create(args);
app
    .Use(middleware: HelloMiddleware)
    .Use(middleware: WorldMiddleware);
app.Run();

static async Task HelloMiddleware(HttpContext httpContext, RequestDelegate next)
{
    await httpContext.Response.WriteAsync("Hello, ");
    await next(httpContext);
};

static Task WorldMiddleware(HttpContext httpContext, RequestDelegate next) => httpContext.Response.WriteAsync("World!");
```

```java
var app = WebApplication.Create(args);
app
    .Use(middleware: HelloMiddleware)
    .Use(middleware: WorldMiddleware);
app.Run();

static async Task HelloMiddleware(HttpContext httpContext, Func<Task> next)
{
    await httpContext.Response.WriteAsync("Hello, ");
    await next();
};

static Task WorldMiddleware(HttpContext httpContext, Func<Task> next)    => httpContext.Response.WriteAsync("World!");
```

## 强类型中间件
```java
namespace App
{
    public interface IGreeter
    {
        string Greet(DateTimeOffset time);
    }

public class Greeter : IGreeter
    {
        public string Greet(DateTimeOffset time) => time.Hour switch
        {
            var h when h >= 5 && h < 12 	=> "Good morning!",
            var h when h >= 12 && h < 17 	=> "Good afternoon!",
            _ 				        => "Good evening!"
        };
    }
}
```
```java
public class GreetingMiddleware : IMiddleware
{
    private readonly IGreeter _greeter;
    public GreetingMiddleware(IGreeter greeter)    => _greeter = greeter;

public Task InvokeAsync(HttpContext context, RequestDelegate next) => context.Response.WriteAsync(_greeter.Greet(DateTimeOffset.Now));
}
```

```java
using App;
var builder = WebApplication.CreateBuilder(args);
builder.Services
    .AddSingleton<IGreeter, Greeter>()
    .AddSingleton<GreetingMiddleware>();
var app = builder.Build();
app.UseMiddleware<GreetingMiddleware>();
app.Run();
```

## 基于约定的中间件：构造函数注入
```java
public class GreetingMiddleware
{
    private readonly IGreeter _greeter;
    public GreetingMiddleware(RequestDelegate next, IGreeter greeter)   => _greeter = greeter;
    public Task InvokeAsync(HttpContext context) => context.Response.WriteAsync(_greeter.Greet(DateTimeOffset.Now));
}

using App;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddSingleton<IGreeter, Greeter>();
var app = builder.Build();
app.UseMiddleware<GreetingMiddleware>();
app.Run();
```

## 基于约定的中间件： 方法注入
```java
public class GreetingMiddleware
{
    public GreetingMiddleware(RequestDelegate next){}
    public Task InvokeAsync(HttpContext context, IGreeter greeter) => context.Response.WriteAsync(greeter.Greet(DateTimeOffset.Now));
}
```