asp.net core 自定义中间件 的基本使用

作者： 分类：所有,中间件 字数：9481

'# asp.net core 自定义中间件 的基本使用

一、背景与问题

在ASP.NET Core中，中间件（Middleware）是构建请求处理管道的核心组件。它允许开发者通过分层的方式处理HTTP请求和响应，实现诸如身份验证、日志记录、请求过滤等功能。然而，在实际开发中，开发者常遇到以下问题：

  1. 请求处理流程不透明：如何理解中间件的执行顺序和作用？
  2. 功能耦合：如何避免将业务逻辑与请求处理逻辑混杂？
  3. 性能瓶颈：如何避免中间件导致不必要的性能开销？
  4. 异常处理：如何确保中间件中的异常不会导致整个应用崩溃？

本文将通过深入原理分析、代码实践和案例对比，全面解析ASP.NET Core中间件的设计与应用。

二、基本原理

ASP.NET Core的中间件通过IApplicationBuilder构建请求处理管道，其核心机制如下：

  1. 管道构建：通过Use()方法注册中间件，每个中间件包含一个Invoke或InvokeAsync方法，用于处理请求。
  2. 执行顺序：中间件按照注册顺序依次执行，最后通过Run()方法终止管道。
  3. 上下文传递：通过HttpContext对象传递请求信息，支持跨中间件的数据共享。
  4. 异常处理：通过UseExceptionHandler等机制处理异常，避免程序崩溃。

关键特性：

  • 可组合性：中间件可组合成复杂逻辑，如日志记录+缓存控制+身份验证。
  • 灵活性：支持异步处理和请求条件过滤。
  • 可扩展性：可自定义IApplicationBuilder扩展方法。

三、环境准备

  1. 开发环境：.NET 6.0+，Visual Studio或Visual Studio Code

  2. 项目结构：

    src/
├── MyMiddlewareApp/
│   ├── Program.cs
│   ├── Startup.cs (可选)
│   ├── Services/
│   │   └── ILoggerService.cs
│   ├── Middlewares/
│   │   └── LoggingMiddleware.cs
│   └── Controllers/
│       └── HomeController.cs

  3. 依赖项：

    <ItemGroup>
  <PackageReference Include="Microsoft.AspNetCore.Diagnostics" Version="6.0.0" />
  <PackageReference Include="Microsoft.AspNetCore.Http" Version="6.0.0" />
</ItemGroup>

四、核心实现

1. 基础中间件实现

// Middlewares/LoggingMiddleware.cs
public class LoggingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILoggerService _logger;

    public LoggingMiddleware(RequestDelegate next, ILoggerService logger)
    {
        _next = next;
        _logger = logger;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        _logger.Log($"Request received: {context.Request.Method} {context.Request.Path}");
        await _next(context);
        _logger.Log($"Response sent: {context.Response.StatusCode}");
    }
}

关键代码解释：

  • RequestDelegate是中间件的委托类型，表示处理请求的函数。
  • ILoggerService通过依赖注入传递，实现日志记录的解耦。
  • InvokeAsync方法处理请求，记录日志并调用下一个中间件。

2. 使用依赖注入的中间件

// Startup.cs
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseMiddleware<LoggingMiddleware>(new LoggerFactory());
    ...
}

关键点：

  • 通过UseMiddleware方法注册中间件，并传递依赖项。
  • 支持复杂依赖的注入，提升模块化程度。

3. 条件执行中间件

// Middlewares/ConditionalMiddleware.cs
public class ConditionalMiddleware
{
    private readonly RequestDelegate _next;
    private readonly string _path;

    public ConditionalMiddleware(RequestDelegate next, string path)
    {
        _next = next;
        _path = path;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        if (context.Request.Path == _path)
        {
            await _next(context);
        }
        else
        {
            context.Response.StatusCode = 404;
        }
    }
}

关键点：

  • 通过路径匹配实现条件执行，避免不必要的处理。
  • 适用于路由过滤、权限控制等场景。

五、完整案例

场景：创建一个支持日志记录、异常处理和响应压缩的完整中间件管道。

1. 项目结构

src/
├── MyMiddlewareApp/
│   ├── Program.cs
│   ├── Middlewares/
│   │   ├── LoggingMiddleware.cs
│   │   ├── ExceptionHandlingMiddleware.cs
│   │   └── CompressionMiddleware.cs
│   ├── Services/
│   │   └── ILoggerService.cs
│   └── Controllers/
│       └── HomeController.cs

2. 代码实现

Program.cs:

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

// 注册服务
app.Services.AddHttpClient();
app.Services.AddSingleton<ILoggerService, ConsoleLoggerService>();

// 注册中间件
app.Use(async (context, next) =>
{
    await next();
    context.Response.Headers.Add("X-Response-Compressed", "true");
});

app.UseMiddleware<LoggingMiddleware>();
app.UseMiddleware<ExceptionHandlingMiddleware>();
app.UseMiddleware<CompressionMiddleware>();

app.Map("/", () => 
    Console.WriteLine("Hello from HomeController"));

app.Run();

LoggingMiddleware.cs:

public class LoggingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILoggerService _logger;

    public LoggingMiddleware(RequestDelegate next, ILoggerService logger)
    {
        _next = next;
        _logger = logger;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        _logger.Log($"Request: {context.Request.Method} {context.Request.Path}");
        await _next(context);
        _logger.Log($"Response: {context.Response.StatusCode}");
    }
}

ExceptionHandlingMiddleware.cs:

public class ExceptionHandlingMiddleware
{
    private readonly RequestDelegate _next;

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

    public async Task InvokeAsync(HttpContext context)
    {
        try
        {
            await _next(context);
        }
        catch (Exception ex)
        {
            context.Response.StatusCode = 500;
            await context.Response.WriteAsync("Internal Server Error");
            Console.WriteLine($"Exception: {ex.Message}");
        }
    }
}

CompressionMiddleware.cs:

public class CompressionMiddleware
{
    private readonly RequestDelegate _next;

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

    public async Task InvokeAsync(HttpContext context)
    {
        if (context.Request.Headers["Accept-Encoding"].Contains("gzip"))
        {
            context.Response.Headers["Content-Encoding"] = "gzip";
            await CompressResponse(context);
        }
        await _next(context);
    }

    private async Task CompressResponse(HttpContext context)
    {
        var originalBody = context.Response.Body;
        var memoryStream = new MemoryStream();
        context.Response.Body = memoryStream;

        await _next(context);

        context.Response.Body = originalBody;
        var buffer = memoryStream.ToArray();
        var compressed = GZipCompress(buffer);
        memoryStream.Dispose();
        await originalBody.WriteAsync(compressed);
    }

    private byte[] GZipCompress(byte[] data)
    {
        using var memoryStream = new MemoryStream();
        using var gzipStream = new GZipStream(memoryStream, CompressionMode.Compress);
        gzipStream.Write(data);
        return memoryStream.ToArray();
    }
}

LoggerService.cs:

public interface ILoggerService
{
    void Log(string message);
}

public class ConsoleLoggerService : ILoggerService
{
    public void Log(string message)
    {
        Console.WriteLine(message);
    }
}

HomeController.cs:

public class HomeController
{
    public void Index()
    {
        Console.WriteLine("Hello from HomeController");
    }
}

六、源码解析

以LoggingMiddleware为例，深入分析其执行流程：

  1. 构造函数：接收RequestDelegate和ILoggerService，通过依赖注入实现解耦。

  2. InvokeAsync方法：

    • 日志记录：在请求处理前记录日志，便于调试和监控。
    • 调用下一个中间件：通过await _next(context)传递控制权。
    • 响应记录：在响应完成后记录状态码，便于分析性能。

关键设计点：

  • 异步支持：使用await确保不阻塞线程。
  • 可扩展性：通过ILoggerService接口实现日志记录的多态性。

七、进阶使用

1. 自定义中间件管道

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

使用方式：

app.UseCustomLogging();

2. 异步中间件

public async Task InvokeAsync(HttpContext context)
{
    await Task.Delay(100); // 模拟耗时操作
    await _next(context);
}

3. 路由过滤

public class RouteFilterMiddleware
{
    private readonly RequestDelegate _next;
    private readonly string _route;

    public RouteFilterMiddleware(RequestDelegate next, string route)
    {
        _next = next;
        _route = route;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        if (context.Request.Path == _route)
        {
            await _next(context);
        }
        else
        {
            context.Response.StatusCode = 404;
        }
    }
}

八、性能与工程实践

1. 性能优化

  • 避免阻塞操作：使用异步处理和非阻塞I/O。
  • 缓存中间件：通过UseResponseCompression减少传输数据量。
  • 条件执行：仅在必要时执行中间件逻辑，如ConditionalMiddleware。

2. 异常处理

  • 全局异常处理：使用UseExceptionHandler统一处理未处理的异常。
  • 中间件级异常处理：在中间件中捕获异常，避免影响后续处理。

3. 安全考虑

  • 避免敏感信息泄露：日志中不要记录用户密码、敏感数据。
  • 输入验证：在中间件中进行基础输入验证，防止注入攻击。
  • CSRF防护：通过UseAntiforgery中间件增强安全。

4. 代码组织

  • 分层目录：将中间件按功能划分，如Logging/、Auth/。
  • 依赖注入：通过构造函数注入服务，确保可测试性。

九、常见问题与踩坑

1. 中间件未执行

错误示例：

app.UseMiddleware<LoggingMiddleware>(); // 错误：缺少参数

原因：UseMiddleware需要传递依赖项，否则无法注入服务。

解决方法：使用UseMiddleware<LoggingMiddleware>(new LoggerFactory())。

2. 异常未处理

错误示例：

public async Task InvokeAsync(HttpContext context)
{
    throw new Exception("Test error");
}

原因：未捕获异常会导致整个应用崩溃。

解决方法：在中间件中添加try-catch块，或使用UseExceptionHandler。

3. 性能瓶颈

错误示例：

public async Task InvokeAsync(HttpContext context)
{
    await Task.Delay(1000); // 模拟高延迟操作
    await _next(context);
}

原因：高延迟操作会阻塞请求处理。

解决方法：将耗时操作移出中间件，或使用异步处理。

十、最佳实践

  1. 分层设计：将中间件按功能分组，如日志、安全、缓存。
  2. 依赖注入：通过构造函数注入服务，提高可测试性。
  3. 条件执行：仅在必要时执行中间件逻辑，减少资源消耗。
  4. 异常处理：为每个中间件添加异常处理逻辑，避免程序崩溃。
  5. 性能监控：使用日志记录和性能分析工具，优化中间件效率。

十一、总结

ASP.NET Core中间件是构建高性能、可维护Web应用的核心工具。通过合理设计中间件管道，可以实现复杂的业务逻辑，同时保持代码的清晰度和可扩展性。本文深入解析了中间件的工作原理，提供了多个代码示例和完整案例，并讨论了性能优化、安全风险和常见错误。在实际开发中，应根据具体需求选择合适的中间件方案，避免过度设计或功能耦合，以确保系统的稳定性和可维护性。

评论已关闭

推荐阅读

AIGC实战——Transformer模型
2024年12月01日
python , AI , 机器学习
Socket TCP 和 UDP 编程基础（Python）
2024年11月30日
python , tcp , udp
如何使用 ChatGPT 进行学术润色？你需要这些指令
2024年12月01日
AI
最新 Python 调用 OpenAi 详细教程实现问答、图像合成、图像理解、语音合成、语音识别（详细教程）
2024年11月24日
python , AI
ChatGPT 和 DALL·E 2 配合生成故事绘本
2024年12月01日
python , AI
omegaconf，一个超强的 Python 库！
2024年11月24日
python
【视觉AIGC识别】误差特征、人脸伪造检测、其他类型假图检测
2024年12月01日
python , AI
［超级详细］如何在深度学习训练模型过程中使用 GPU 加速
2024年11月29日
python , AI , 机器学习
Python 物理引擎pymunk最完整教程
2024年11月27日
python
MediaPipe 人体姿态与手指关键点检测教程
2024年11月27日
python
深入了解 Taipy：Python 打造 Web 应用的全面教程
2024年11月26日
python
基于Transformer的时间序列预测模型
2024年11月25日
python , Matplotlib , 机器学习
Python在金融大数据分析中的AI应用（股价分析、量化交易）实战
2024年11月25日
python , Matplotlib , 机器学习
AIGC Gradio系列学习教程之Components
2024年12月01日
python , AI
Python3 `asyncio` — 异步 I/O，事件循环和并发工具
2024年11月30日
python
llama-factory SFT系列教程：大模型在自定义数据集 LoRA 训练与部署
2024年12月01日
python , AI , 机器学习
Python 多线程和多进程用法
2024年11月24日
python
Python socket详解，全网最全教程
2024年11月27日
python , http , websocket
python之plot()和subplot()画图
2024年11月26日
python , Matplotlib
理解 DALL·E 2、Stable Diffusion 和 Midjourney 工作原理
2024年12月01日
python , AI , 机器学习
Copyright © 2026 Tech Blog
All Right Reserved | 京ICP备19053165号