ASP.NET Core 接口代理转发实现前后端分离

引言
在现代软件开发实践中，前后端分离已成为一种常见的架构模式。它通过将前端用户界面和后端服务逻辑分离，提高了开发效率和应用性能。然而，在某些情况下，由于各种原因，我们可能需要在 ASP.NET Core 应用中实现接口代理转发，以满足特定的开发需求。

本文将介绍如何在 ASP.NET Core 中实现接口代理转发，以支持在 MVC 视图渲染中使用 Web API。这种方案适用于那些希望在 .NET Core 上托管前端应用，但又需要通过 Web API 提供服务的场景。

首先，我们需要定义一个 `IUrlRewriter` 接口，用于检测请求的 URL 是否符合特定的前缀规则，并据此生成新的 URL。

```csharp
public interface IUrlRewriter
{
    Task<Uri> RewriteUri(HttpContext context);
}
```


接下来，实现这个接口，以支持 URL 重写逻辑：


```csharp
public class PrefixRewriter : IUrlRewriter
{
    private readonly PathString _prefix;
    private readonly string _newHost;


    public PrefixRewriter(PathString prefix, string newHost)
    {
        _prefix = prefix;
        _newHost = newHost;
    }


    public async Task<Uri> RewriteUri(HttpContext context)
    {
        if (context.Request.Path.StartsWithSegments(_prefix))
        {
            var newUri = context.Request.Path.Value.Remove(0, _prefix.Value.Length) + context.Request.QueryString;
            var targetUri = new Uri(_newHost + newUri);
            return targetUri;
        }
        return null;
    }
}
```

为了专门处理代理转发的 HTTP 请求，我们创建一个 `ProxyHttpClient` 类，它封装了 `HttpClient` 实例。

```csharp
public class ProxyHttpClient
{
    public HttpClient Client { get; private set; }


    public ProxyHttpClient(HttpClient httpClient)
    {
        Client = httpClient;
    }
}
```

中间件是 ASP.NET Core 中处理请求和响应的核心组件。我们将创建一个 `ProxyMiddleware` 类来实现接口代理转发。

```csharp
public class ProxyMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<ProxyMiddleware> _logger;


    public ProxyMiddleware(RequestDelegate next, ILogger<ProxyMiddleware> logger)
    {
        _next = next;
        _logger = logger;
    }


    public async Task Invoke(HttpContext context, IUrlRewriter urlRewriter, ProxyHttpClient proxyHttpClient)
    {
        var targetUri = await urlRewriter.RewriteUri(context);
        if (targetUri != null)
        {
            // 构建代理请求并发送
            var requestMessage = GenerateProxifiedRequest(context, targetUri);
            await SendAsync(context, requestMessage, proxyHttpClient);
        }
        else
        {
            await _next(context);
        }
    }


    // 实现请求内容和头信息复制的辅助方法
    private static HttpRequestMessage GenerateProxifiedRequest(HttpContext context, Uri targetUri)
    {
        // ...
    }


    // 实现发送代理请求的辅助方法
    private async Task SendAsync(HttpContext context, HttpRequestMessage requestMessage, ProxyHttpClient proxyHttpClient)
    {
        // ...
    }
}
```

在 `Startup.cs` 中的 `ConfigureServices` 方法中，注入 `ProxyHttpClient` 和 `IUrlRewriter`。

```csharp
services.AddHttpClient<ProxyHttpClient>()
    .ConfigurePrimaryHttpMessageHandler(x => new HttpClientHandler
    {
        // 配置 HttpClientHandler
    });


services.AddSingleton<IUrlRewriter>(new PrefixRewriter("/webapp", "http://localhost:63445"));
```


在 `Configure` 方法中，启用中间件。


```csharp
app.UseMiddleware<ProxyMiddleware>();
```

编写前端代码，使用 axios 发送请求，并测试中间件是否正确转发。

```javascript
axios.get("/webapp/api/values/get").then(res => alert(res.data[0]));
axios.post("/webapp/api/values/post", { value: 'david' }).then(res => alert(res.data.message));
```

通过上述步骤，我们实现了一个简单的接口代理转发中间件，它允许 ASP.NET Core 应用将前端请求代理到指定的后端服务。这种方法可以有效地支持前后端分离的开发模式，并提供了一种灵活的解决方案来处理跨域请求问题。

如果喜欢我的文章，那么
“在看”和转发是对我最大的支持！