Asp.Net Core EndPoint 終點路由工作原理解讀
阿新 • • 發佈：2020-03-06
## 一、背景
在本打算寫一篇關於`Identityserver4` 的文章時候，確發現自己對`EndPoint` -終結點路由還不是很瞭解，故暫時先放棄了`IdentityServer4` 的研究和編寫；所以才產生了今天這篇關於`EndPoint` (終結點路由) 的文章。
還是跟往常一樣，開啟電腦使用強大的Google 和百度搜索引擎查閱相關資料，以及開啟Asp.net core 3.1 的原始碼進行拜讀，同時終於在我的實踐及測試中對`EndPoint` 有了不一樣的認識，說到這裡更加敬佩微軟對Asp.net core 3.x 的框架中管道模型的設計。
我先來提出以下幾個問題：
1. 當訪問一個Web 應用地址時，Asp.Net Core 是怎麼執行到`Controller` 的`Action`的呢？
2. `EndPoint` 跟普通路由又存在著什麼樣的關係？
3. `UseRouing()` 、`UseAuthorization()`、`UserEndpoints()` 這三個中介軟體的關係是什麼呢？
4. 怎麼利用`EndPoint` 終結者路由來攔截Action 的執行並且記錄相關操作日誌？(時間有限，下一篇文章再來分享整理)
## 二、拜讀原始碼解惑
### `Startup` 程式碼
我們先來看一下`Startup`中簡化版的程式碼，程式碼如下：
```
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
}
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
app.UseRouting();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
}
```
程式啟動階段：
- 第一步：執行services.AddControllers()
將`Controller`的核心服務註冊到容器中去
- 第二步：執行app.UseRouting()
將`EndpointRoutingMiddleware`中介軟體註冊到http管道中
- 第三步：執行app.UseAuthorization()
將`AuthorizationMiddleware`中介軟體註冊到http管道中
- 第四步：執行app.UseEndpoints(encpoints=>endpoints.MapControllers())
有兩個主要的作用：
呼叫`endpoints.MapControllers()`將本程式集定義的所有`Controller`和`Action`轉換為一個個的`EndPoint`放到路由中介軟體的配置物件`RouteOptions`中
將`EndpointMiddleware`中介軟體註冊到http管道中
### `app.UseRouting()` 原始碼如下：
```
public static IApplicationBuilder UseRouting(this IApplicationBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
VerifyRoutingServicesAreRegistered(builder);
var endpointRouteBuilder = new DefaultEndpointRouteBuilder(builder);
builder.Properties[EndpointRouteBuilder] = endpointRouteBuilder;
return builder.UseMiddleware(endpointRouteBuilder);
}
```
`EndpointRoutingMiddleware` 中介軟體程式碼如下：
```
internal sealed class EndpointRoutingMiddleware
{
private const string DiagnosticsEndpointMatchedKey = "Microsoft.AspNetCore.Routing.EndpointMatched";
private readonly MatcherFactory _matcherFactory;
private readonly ILogger _logger;
private readonly EndpointDataSource _endpointDataSource;
private readonly DiagnosticListener _diagnosticListener;
private readonly RequestDelegate _next;
private Task _initializationTask;
public EndpointRoutingMiddleware(
MatcherFactory matcherFactory,
ILogger logger,
IEndpointRouteBuilder endpointRouteBuilder,
DiagnosticListener diagnosticListener,
RequestDelegate next)
{
if (endpointRouteBuilder == null)
{
throw new ArgumentNullException(nameof(endpointRouteBuilder));
}
_matcherFactory = matcherFactory ?? throw new ArgumentNullException(nameof(matcherFactory));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_diagnosticListener = diagnosticListener ?? throw new ArgumentNullException(nameof(diagnosticListener));
_next = next ?? throw new ArgumentNullException(nameof(next));
_endpointDataSource = new CompositeEndpointDataSource(endpointRouteBuilder.DataSources);
}
public Task Invoke(HttpContext httpContext)
{
// There's already an endpoint, skip maching completely
var endpoint = httpContext.GetEndpoint();
if (endpoint != null)
{
Log.MatchSkipped(_logger, endpoint);
return _next(httpContext);
}
// There's an inherent race condition between waiting for init and accessing the matcher
// this is OK because once `_matcher` is initialized, it will not be set to null again.
var matcherTask = InitializeAsync();
if (!matcherTask.IsCompletedSuccessfully)
{
return AwaitMatcher(this, httpContext, matcherTask);
}
var matchTask = matcherTask.Result.MatchAsync(httpContext);
if (!matchTask.IsCompletedSuccessfully)
{
return AwaitMatch(this, httpContext, matchTask);
}
return SetRoutingAndContinue(httpContext);
// Awaited fallbacks for when the Tasks do not synchronously complete
static async Task AwaitMatcher(EndpointRoutingMiddleware middleware, HttpContext httpContext, Task matcherTask)
{
var matcher = await matcherTask;
await matcher.MatchAsync(httpContext);
await middleware.SetRoutingAndContinue(httpContext);
}
static async Task AwaitMatch(EndpointRoutingMiddleware middleware, HttpContext httpContext, Task matchTask)
{
await matchTask;
await middleware.SetRoutingAndContinue(httpContext);
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private Task SetRoutingAndContinue(HttpContext httpContext)
{
// If there was no mutation of the endpoint then log failure
var endpoint = httpContext.GetEndpoint();
if (endpoint == null)
{
Log.MatchFailure(_logger);
}
else
{
// Raise an event if the route matched
if (_diagnosticListener.IsEnabled() && _diagnosticListener.IsEnabled(DiagnosticsEndpointMatchedKey))
{
// We're just going to send the HttpContext since it has all of the relevant information
_diagnosticListener.Write(DiagnosticsEndpointMatchedKey, httpContext);
}
Log.MatchSuccess(_logger, endpoint);
}
return _next(httpContext);
}
// Initialization is async to avoid blocking threads while reflection and things
// of that nature take place.
//
// We've seen cases where startup is very slow if we allow multiple threads to race
// while initializing the set of endpoints/routes. Doing CPU intensive work is a
// blocking operation if you have a low core count and enough work to do.
private Task InitializeAsync()
{
var initializationTask = _initializationTask;
if (initializationTask != null)
{
return initializationTask;
}
return InitializeCoreAsync();
}
private Task InitializeCoreAsync()
{
var initialization = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
var initializationTask = Interlocked.CompareExchange(ref _initializationTask, initialization.Task, null);
if (initializationTask != null)
{
// This thread lost the race, join the existing task.
return initializationTask;
}
// This thread won the race, do the initialization.
try
{
var matcher = _matcherFactory.CreateMatcher(_endpointDataSource);
// Now replace the initialization task with one created with the default execution context.
// This is important because capturing the execution context will leak memory in ASP.NET Core.
using (ExecutionContext.SuppressFlow())
{
_initializationTask = Task.FromResult(matcher);
}
// Complete the task, this will unblock any requests that came in while initializing.
initialization.SetResult(matcher);
return initialization.Task;
}
catch (Exception ex)
{
// Allow initialization to occur again. Since DataSources can change, it's possible
// for the developer to correct the data causing the failure.
_initializationTask = null;
// Complete the task, this will throw for any requests that came in while initializing.
initialization.SetException(ex);
return initialization.Task;
}
}
private static class Log
{
private static readonly Action _matchSuccess = LoggerMessage.Define(
LogLevel.Debug,
new EventId(1, "MatchSuccess"),
"Request matched endpoint '{EndpointName}'");
private static readonly Action _matchFailure = LoggerMessage.Define(
LogLevel.Debug,
new EventId(2, "MatchFailure"),
"Request did not match any endpoints");
private static readonly Action _matchingSkipped = LoggerMessage.Define(
LogLevel.Debug,
new EventId(3, "MatchingSkipped"),
"Endpoint '{EndpointName}' already set, skipping route matching.");
public static void MatchSuccess(ILogger logger, Endpoint endpoint)
{
_matchSuccess(logger, endpoint.DisplayName, null);
}
public static void MatchFailure(ILogger logger)
{
_matchFailure(logger, null);
}
public static void MatchSkipped(ILogger logger, Endpoint endpoint)
{
_matchingSkipped(logger, endpoint.DisplayName, null);
}
}
}
```
我們從它的原始碼中可以看到，`EndpointRoutingMiddleware`中介軟體先是建立`matcher`，然後呼叫`matcher.MatchAsync(httpContext)`去尋找Endpoint，最後通過`httpContext.GetEndpoint()`驗證了是否已經匹配到了正確的`Endpoint`並交個下箇中間件繼續執行！
### `app.UseEndpoints()` 原始碼
```
public static IApplicationBuilder UseEndpoints(this IApplicationBuilder builder, Action configure)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (configure == null)
{
throw new ArgumentNullException(nameof(configure));
}
VerifyRoutingServicesAreRegistered(builder);
VerifyEndpointRoutingMiddlewareIsRegistered(builder, out var endpointRouteBuilder);
configure(endpointRouteBuilder);
// Yes, this mutates an IOptions. We're registering data sources in a global collection which
// can be used for discovery of endpoints or URL generation.
//
// Each middleware gets its own collection of data sources, and all of those data sources also
// get added to a global collection.
var routeOptions = builder.ApplicationServices.GetRequiredService>();
foreach (var dataSource in endpointRouteBuilder.DataSources)
{
routeOptions.Value.EndpointDataSources.Add(dataSource);
}
return builder.UseMiddleware();
}
internal class DefaultEndpointRouteBuilder : IEndpointRouteBuilder
{
public DefaultEndpointRouteBuilder(IApplicationBuilder applicationBuilder)
{
ApplicationBuilder = applicationBuilder ?? throw new ArgumentNullException(nameof(applicationBuilder));
DataSources = new List();
}
public IApplicationBuilder ApplicationBuilder { get; }
public IApplicationBuilder CreateApplicationBuilder() => ApplicationBuilder.New();
public ICollection DataSources { get; }
public IServiceProvider ServiceProvider => ApplicationBuilder.ApplicationServices;
}
```
程式碼中構建了`DefaultEndpointRouteBuilder` 終結點路由構建者物件，該物件中儲存了`Endpoint`的集合資料；同時把終結者路由集合資料儲存在了`routeOptions` 中，並註冊了`EndpointMiddleware` 中介軟體到http管道中；
`Endpoint`物件程式碼如下：
```
///
/// Represents a logical endpoint in an application.
///
/// Creates a new instance of
/// The delegate used to process requests for the endpoint.
///
/// The endpoint
/// Gets the informational display name of this endpoint.
///
/// Gets the collection of metadata associated with this endpoint.
///
public EndpointMetadataCollection Metadata { get; }
///
/// Gets the delegate used to process requests for the endpoint.
///
public RequestDelegate RequestDelegate { get; }
public override string ToString() => () != null &&
!httpContext.Items.ContainsKey(AuthorizationMiddlewareInvokedKey))
{
ThrowMissingAuthMiddlewareException(endpoint);
}
if (endpoint.Metadata.GetMetadata() != null &&
!httpContext.Items.ContainsKey(CorsMiddlewareInvokedKey))
{
ThrowMissingCorsMiddlewareException(endpoint);
}
}
Log.ExecutingEndpoint(_logger, endpoint);
try
{
var requestTask = endpoint.RequestDelegate(httpContext);
if (!requestTask.IsCompletedSuccessfully)
{
return AwaitRequestTask(endpoint, requestTask, _logger);
}
}
catch (Exception exception)
{
Log.ExecutedEndpoint(_logger, endpoint);
return Task.FromException(exception);
}
Log.ExecutedEndpoint(_logger, endpoint);
return Task.CompletedTask;
}
return _next(httpContext);
static async Task AwaitRequestTask(Endpoint endpoint, Task requestTask, ILogger logger)
{
try
{
await requestTask;
}
finally
{
Log.ExecutedEndpoint(logger, endpoint);
}
}
}
```
#### 疑惑解答：
###### 1. 當訪問一個Web 應用地址時，Asp.Net Core 是怎麼執行到`Controller` 的`Action`的呢？
答：程式啟動的時候會把所有的Controller 中的Action 對映儲存到`routeOptions` 的集合中，Action 對映成`Endpoint`終結者 的`RequestDelegate` 委託屬性，最後通過`UseEndPoints` 新增`EndpointMiddleware` 中介軟體進行執行，同時這個中介軟體中的`Endpoint` 終結者路由已經是通過`Rouing`匹配後的路由。
###### 2. `EndPoint` 跟普通路由又存在著什麼樣的關係？
答：`Ednpoint` 終結者路由是普通路由map 轉換後的委託路由，裡面包含了路由方法的所有元素資訊`EndpointMetadataCollection` 和`RequestDelegate` 委託。
###### 3. `UseRouing()` 、`UseAuthorization()`、`UseEndpoints()` 這三個中介軟體的關係是什麼呢？
答：`UseRouing` 中介軟體主要是路由匹配，找到匹配的終結者路由`Endpoint` ；`UseEndpoints` 中介軟體主要針對`UseRouing` 中介軟體匹配到的路由進行 委託方法的執行等操作。
`UseAuthorization` 中介軟體主要針對 `UseRouing` 中介軟體中匹配到的路由進行攔截 做授權驗證操作等，通過則執行下一個中介軟體`UseEndpoints()`,具體的關係可以看下面的流程圖：
上面流程圖中省略了一些部分，主要是把UseRouing 、UseAuthorization 、UseEndpoint 這三個中介軟體的關係突顯出來。
如果您覺的不錯，請微信掃碼關注 【dotNET 博士】公眾號，後續給您帶來更精彩的分享
以上如果有錯誤得地方，請大家積極糾正，謝謝大家得支