当前位置：首页 > news >正文

自定义中间件进入管道中执行队列的流程

news 2026/5/12 19:31:38

自定义中间件进入管道中执行队列的流程

1. 自定义中间件类的标准写法

public class CustomLoggingMiddleware
{private readonly RequestDelegate _next;// 1. 构造函数必须包含 RequestDelegate next 参数public CustomLoggingMiddleware(RequestDelegate next){_next = next;}// 2. 必须包含名为 Invoke 或 InvokeAsync 的公共方法public async Task InvokeAsync(HttpContext context){//执行前动作...// 调用管道中的下一个中间件await _next(context);       //执行后动作...}
}

2. 使用扩展方法注册中间件

public static class CustomLoggingMiddlewareExtensions
{public static IApplicationBuilder UseCustomLogging(this IApplicationBuilder app){return app.UseMiddleware<CustomLoggingMiddleware>();}
}

3. 在管道中使用

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{app.UseCustomLogging();  // 我们的自定义中间件app.UseHttpsRedirection();app.UseStaticFiles();app.UseRouting();app.UseAuthorization();app.MapControllers();
}

4. 转换流程详解

现在来看 UseMiddleware<CustomLoggingMiddleware>() 是如何将类转换成管道方法的：

步骤 1: `UseMiddleware<T>` 扩展方法

// Microsoft.AspNetCore.Builder.UseMiddlewareExtensions
public static class UseMiddlewareExtensions
{public static IApplicationBuilder UseMiddleware<TMiddleware>(this IApplicationBuilder app){return app.UseMiddleware(typeof(TMiddleware));}public static IApplicationBuilder UseMiddleware(this IApplicationBuilder app, Type middlewareType){// 创建中间件工厂return app.Use(next =>{// 这里就是转换的关键！// 创建一个委托，它会在每次请求时实例化中间件并调用Invoke方法var middlewareFactory = (IMiddlewareFactory)app.ApplicationServices.GetService(typeof(IMiddlewareFactory));return async context =>{// 每次请求都会执行这个委托var middleware = middlewareFactory.Create(middlewareType);try{// 调用中间件的InvokeAsync方法await middleware.InvokeAsync(context, next);}finally{middlewareFactory.Release(middleware);}};});}
}

步骤 2: 运行时实际生成的委托

实际上，ASP.NET Core 使用更高效的代码生成机制。简化后的等效代码：

// 运行时生成的委托大致如下：
Func<RequestDelegate, RequestDelegate> generatedMiddleware = next =>
{return async context =>{// 创建中间件实例var middleware = new CustomLoggingMiddleware(next, logger);// 调用InvokeAsync方法await middleware.InvokeAsync(context);};
};

步骤 3: 管道构建过程

// 初始管道终点
RequestDelegate pipelineEnd = async context => 
{context.Response.StatusCode = 404; // 默认404
};// 应用我们的自定义中间件
var customMiddleware = generatedMiddleware(pipelineEnd);// 最终生成的委托
RequestDelegate finalPipeline = async context =>
{var logger = // 获取logger实例;var middlewareInstance = new CustomLoggingMiddleware(pipelineEnd, logger);await middlewareInstance.InvokeAsync(context);
};

完整的转换流程图示

自定义中间件类↓
UseMiddleware<T>() 扩展方法↓
反射分析中间件类的构造函数和方法↓
生成优化的委托代码 (Func<RequestDelegate, RequestDelegate>)↓
注册到 IApplicationBuilder 的中间件列表↓
管道构建时被包装成最终的 RequestDelegate↓
请求到达时执行生成的委托代码

支持多种方法签名的中间件

ASP.NET Core 支持多种方法签名，转换器会智能处理：

方式 1: 标准的 InvokeAsync 方法

csharp

public async Task InvokeAsync(HttpContext context)
{await _next(context);
}

方式 2: 带服务的 InvokeAsync 方法

csharp

public async Task InvokeAsync(HttpContext context, ISomeService service)
{// 依赖注入会自动注入服务await _next(context);
}

方式 3: 同步的 Invoke 方法

csharp

public void Invoke(HttpContext context)
{// 同步处理_next(context).Wait();
}

实际的复杂中间件示例

csharp

public class RateLimitingMiddleware
{private readonly RequestDelegate _next;private readonly IMemoryCache _cache;private readonly RateLimitOptions _options;// 构造函数注入public RateLimitingMiddleware(RequestDelegate next, IMemoryCache cache, IOptions<RateLimitOptions> options){_next = next;_cache = cache;_options = options.Value;}// 方法参数注入public async Task InvokeAsync(HttpContext context, ILogger<RateLimitingMiddleware> logger){var clientIp = context.Connection.RemoteIpAddress?.ToString();var cacheKey = $"rate_limit_{clientIp}";// 速率限制逻辑if (_cache.TryGetValue(cacheKey, out int requestCount) && requestCount >= _options.MaxRequests){logger.LogWarning("IP {IP} 触发速率限制", clientIp);context.Response.StatusCode = 429;await context.Response.WriteAsync("Too Many Requests");return;}// 更新计数器_cache.Set(cacheKey, requestCount + 1, TimeSpan.FromMinutes(1));await _next(context);}
}public class RateLimitOptions
{public int MaxRequests { get; set; } = 100;
}

依赖注入的自动处理

转换过程中，依赖注入容器会自动处理：

csharp

// 转换器会分析构造函数和方法参数
public async Task InvokeAsync(HttpContext context, ILogger<RateLimitingMiddleware> logger,        // 方法参数注入IMemoryCache cache,                            // 方法参数注入  IOptions<RateLimitOptions> options)            // 方法参数注入
{// 所有这些参数都会从DI容器自动解析
}