详解ASP.NET Core MVC 源码学习：Routing 路由

前言

最近打算抽时间看一下 ASP.NET Core MVC 的源码，特此把自己学习到的内容记录下来，也算是做个笔记吧。

路由作为 MVC 的基本部分，所以在学习 MVC 的其他源码之前还是先学习一下路由系统，ASP.NET Core 的路由系统相对于以前的 Mvc 变化很大，它重新整合了 Web Api 和 MVC。

路由源码地址 ：Routing-dev_jb51.rar

路由（Routing）功能介绍

路由是 MVC 的一个重要组成部分，它主要负责将接收到的 Http 请求映射到具体的一个路由处理程序上，在MVC 中也就是说路由到具体的某个 Controller 的 Action 上。

路由的启动方式是在ASP.NET Core MVC 应用程序启动的时候作为一个中间件来启动的，详细信息会在下一篇的文章中给出。

通俗的来说就是，路由从请求的 URL 地址中提取信息，然后根据这些信息进行匹配，从而映射到具体的处理程序上，因此路由是基于URL构建的一个中间件框架。
 路由还有一个作用是生成响应的的URL，也就是说生成一个链接地址可以进行重定向或者链接。

路由中间件主要包含以下几个部分：

1. URL 匹配
2. URL 生成
3. IRouter 接口
4. 路由模板
5. 模板约束

Getting Started

ASP.NET Core Routing 主要分为两个项目，分别是 Microsoft.AspNetCore.Routing.Abstractions,Microsoft.AspNetCore.Routing。前者是一个路由提供各功能的抽象，后者是具体实现。

我们在阅读源码的过程中，我建议还是先大致浏览一下项目结构，然后找出关键类，再由入口程序进行阅读。

Microsoft.AspNetCore.Routing.Abstractions

大致看完整个结构之后，我可能发现了几个关键的接口，理解了这几个接口的作用后能够帮助我们在后续的阅读中事半功倍。

IRouter

在 Microsoft.AspNetCore.Routing.Abstractions 中有一个关键的接口就是 IRouter:

public interface IRouter
{
 Task RouteAsync(RouteContext context);

 VirtualPathData GetVirtualPath(VirtualPathContext context);
}

这个接口主要干两件事情，第一件是根据路由上下文来进行路由处理，第二件是根据虚拟路径上下文获取 VirtualPathData。

IRouteHandler

另外一个关键接口是 IRouteHandler , 根据名字可以看出主要是对路由处理程序机型抽象以及定义的一个接口。

public interface IRouteHandler
{
 RequestDelegate GetRequestHandler(HttpContext httpContext, RouteData routeData);
}

它返回一个 RequestDelegate 的一个委托，这个委托可能大家比较熟悉了，封装了处理Http请求的方法，位于Microsoft.AspNetCore.Http.Abstractions 中，看过我之前博客的同学应该比较了解。

这个接口中 GetRequestHandler 方法有两个参数，第一个是 HttpContext，就不多说了，主要是来看一下第二个参数 RouteData。

RouteData，封装了当前路由中的数据信息，它包含三个主要属性，分别是 DataTokens, Routers, Values。

DataTokens： 是匹配的路径中附带的一些相关属性的键值对字典。

Routers： 是一个 Ilist<IRouter> 列表，说明RouteData 中可能会包含子路由。

Values： 当前路由的路径下包含的键值。

还有一个 RouteValueDictionary, 它是一个集合类，主要是用来存放路由中的一些数据信息的，没有直接使用 IEnumerable<KeyValuePair<string, string>> 这个数据结构是应为它的内部存储转换比较复杂，它的构造函数接收一个 Object 的对象，它会尝试将Object 对象转化为自己可以识别的集合。

IRoutingFeature

我根据这个接口的命名一眼就看出来了这个接口的用途，还记得我在之前博客中讲述Http管道流程中得时候提到过一个叫 工具箱 的东西么，这个 IRoutingFeature 也是其中的一个组成部分。我们看一下它的定义：

public interface IRoutingFeature
{
 RouteData RouteData { get; set; }
}

原来他只是包装了 RouteData，到 HttpContext 中啊。

IRouteConstraint

这个接口我在阅读的时候看了一下注释，原来路由中的参数参数检查主要是靠这个接口来完成的。

我们都知道在我们写一个 Route Url地址表达式的时候，有时候会这样写：Route("/Product/{ProductId:long}") , 在这个表达式中有一个 {ProductId:long} 的参数约束，那么它的主要功能实现就是靠这个接口来完成的。

/// Defines the contract that a class must implement in order to check whether a URL parameter
/// value is valid for a constraint.
public interface IRouteConstraint
{
 bool Match(
  HttpContext httpContext,
  IRouter route,
  string routeKey,
  RouteValueDictionary values,
  RouteDirection routeDirection);
}

Microsoft.AspNetCore.Routing

Microsoft.AspNetCore.Routing 主要是对 Abstractions 的一个主要实现，我们阅读代码的时候可以从它的入口开始阅读。

RoutingServiceCollectionExtensions 是一个扩展ASP.NET Core DI 的一个扩展类，在这个方法中用来进行 ConfigService，Routing 对外暴露了一个 IRoutingBuilder 接口用来让用户添加自己的路由规则，我们来看一下：

public static IApplicationBuilder UseRouter(this IApplicationBuilder builder, Action<IRouteBuilder> action)
{
 //...略
 
 // 构造一个RouterBuilder 提供给action委托宫配置
 var routeBuilder = new RouteBuilder(builder);
 action(routeBuilder);
 
 //调用下面的一个扩展方法，routeBuilder.Build() 见下文
 return builder.UseRouter(routeBuilder.Build());
}

public static IApplicationBuilder UseRouter(this IApplicationBuilder builder, IRouter router)
{
  //...略
  
 return builder.UseMiddleware<RouterMiddleware>(router);
}

routeBuilder.Build() 构建了一个集合 RouteCollection，用来保存所有的 IRouter 处理程序信息，包括用户配置的Router。

RouteCollection 本身也实现了 IRouter , 所以它也具有路由处理的能力。

Routing 中间件的入口是 RouterMiddleware 这个类，通过这个中间件注册到 Http 的管道处理流程中， ASP.NET Core MVC 会把它默认的作为其配置项的一部分，当然你也可以把Routing单独拿出来使用。

我们来看一下 Invoke 方法里面做了什么，它位于RouterMiddleware.cs 文件中。

public async Task Invoke(HttpContext httpContext)
{
  var context = new RouteContext(httpContext);
  context.RouteData.Routers.Add(_router);

  await _router.RouteAsync(context);

  if (context.Handler == null)
  {
    _logger.RequestDidNotMatchRoutes();
    await _next.Invoke(httpContext);
  }
  else
  {
    httpContext.Features[typeof(IRoutingFeature)] = new RoutingFeature()
    {
      RouteData = context.RouteData,
    };

    await context.Handler(context.HttpContext);
  }
}

首先，通过 httpContext 来初始化路由上下文（RouteContext），然后把用户配置的路由规则添加到路由上下文RouteData中的Routers中去。

接下来 await _router.RouteAsync(context) , 就是用到了 IRouter 接口中的 RouteAsync 方法了。

我们接着跟踪 RouteAsync 这个函数，看其内部都做了什么？ 我们又跟踪到了RouteCollection.cs 这个类：

我们看一下 RouteAsync 的流程：

public async virtual Task RouteAsync(RouteContext context)
{
  var snapshot = context.RouteData.PushState(null, values: null, dataTokens: null);

  for (var i = 0; i < Count; i++)
  {
    var route = this[i];
    context.RouteData.Routers.Add(route);

    try
    {
      await route.RouteAsync(context);

      if (context.Handler != null)
      {
        break;
      }
    }
    finally
    {
      if (context.Handler == null)
      {
        snapshot.Restore();
      }
    }
  }
}

我觉得这个类，包括函数设计的很巧妙，如果是我的话，我不一定能够想的出来，所以我们通过看源码也能够学到很多新知识。

为什么说设计的巧妙呢？ RouteCollection 继承了 IRouter 但是并没有具体的对路由进行处理，而是通过循环来重新将路由上下文分发的具体的路由处理程序上。我们来看一下他的流程：

1、为了提高性能，创建了一个RouteDataSnapshot 快照对象，RouteDataSnapshot是一个结构体，它存储了 Route 中的路由数据信息。

2、循环当前 RouteCollection 中的 Router，添加到 RouterContext里的Routers中，然后把RouterContext交给Router来处理。

3、当没有处理程序处理当前路由 snapshot.Restore() 重新初始化快照状态。

接下来就要看具体的路由处理对象了，我们从 RouteBase 开始。

1、RouteBase 的构造函数会初始化 RouteTemplate, Name, DataTokens, Defaults.
 Defaults 是默认配置的路由参数。

2、RouteAsync 中会进行一系列检查，如果没有匹配到URL对应的路由就会直接返回。

3、使用路由参数匹配器 RouteConstraintMatcher 进行匹配，如果没有匹配到，同样直接返回。

4、如果匹配成功，会触发 OnRouteMatched(RouteContext context)函数，它是一个抽象函数，具体实现位于 Route.cs 中。

然后，我们再继续跟踪到 Route.cs 中的 OnRouteMatch，一起来看一下：

protected override Task OnRouteMatched(RouteContext context)
{
  
  context.RouteData.Routers.Add(_target);
  return _target.RouteAsync(context);
}

_target 值得当前路由的处理程序，那么具体是哪个路由处理程序呢？ 我们一起探索一下。

我们知道，我们创建路由一共有MapRoute,MapGet,MapPost,MapPut,MapDelete,MapVerb... 等等这写方式，我们分别对应说一下每一种它的路由处理程序是怎么样的，下面是一个示例：

app.UseRouter(routes =>{
  routes.DefaultHandler = new RouteHandler((httpContext) =>
  {
    var request = httpContext.Request;
    return httpContext.Response.WriteAsync($"");
  });
          
  routes
  .MapGet("api/get/{id}", (request, response, routeData) => {})
  .MapMiddlewareRoute("api/middleware", (appBuilder) => 
             appBuilder.Use((httpContext, next) => httpContext.Response.WriteAsync("Middleware!")
           ))
  .MapRoute(
     name: "AllVerbs",
     template: "api/all/{name}/{lastName?}",
     defaults: new { lastName = "Doe" },
     constraints: new { lastName = new RegexRouteConstraint(new Regex("[a-zA-Z]{3}",RegexOptions.CultureInvariant, RegexMatchTimeout)) });
});

按照上面的示例解释一下，

MapRoute：使用这种方式的话，必须要给 DefaultHandler 赋值处理程序，否则会抛出异常，通常情况下我们会使用RouteHandler类。

MapVerb： MapPost,MapPut 等等都和它类似，它将处理程序作为一个 RequestDelegate 委托提供了出来，也就是说我们实际上在自己处理HttpContext的东西，不会经过RouteHandler处理。

MapMiddlewareRoute：需要传入一个 IApplicationBuilder 委托，实际上 IApplicationBuilder Build之后也是一个 RequestDelegate，它会在内部 new 一个 RouteHandler 类，然后调用的 MapRoute。

这些所有的矛头都指向了 RouteHandler ， 我们来看看 RouteHandler 吧。

public class RouteHandler : IRouteHandler, IRouter
{
  // ...略

  public Task RouteAsync(RouteContext context)
  {
    context.Handler = _requestDelegate;
    return TaskCache.CompletedTask;
  }
}

什么都没干，仅仅是将传入进来的 RequestDelegate 赋值给了 RouteContext 的处理程序。

最后，代码会执行到 RouterMiddleware 类中的 Invoke 方法的最后一行 await context.Handler(context.HttpContext)，这个时候开始调用Handler委托，执行用户代码。

总结

我们来总结一下以上流程：

首先传入请求会到注册的 RouterMiddleware 中间件，然后它 RouteAsync 按顺序调用每个路由上的方法。当一个请求到来的时候，IRouter实例选择是否处理已经设置到 RouteContext Handler 上的一个非空 RequestDelegate。如果Route已经为该请求设置处理程序，则路由处理会中止并且开始调用设置的Hanlder处理程序以处理请求。如果当前请求尝试了所有路由都没有找到处理程序的话，则调用next，将请求交给管道中的下一个中间件。

关于路由模板和参数约束源码处理流程就不一一说了，有兴趣可以直接看下源码。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持站长技术。

原文链接：https://m.jb51.net/article/109421.htm
本站部分内容转载于网络，版权归原作者所有，转载之目的在于传播更多优秀技术内容，如有侵权请联系QQ/微信：153890879删除，谢谢！