请求如何进入ASP.NET MVC框架

一、前言

　　对于WebForm开发，请求通常是一个以.aspx结尾的url，对应一个物理文件，从代码的角度来说它其实是一个控件（Page)。而在MVC中，一个请求对应的是一个Controller里的Action。熟悉asp.net的朋友都知道，asp.net请求实际都是交给HttpHandler处理（实现了IHttpHandler的类型）。无论是.aspx，.ashx，.asmx 还是MVC里的Action，请求都会交给HttpHandler。具体是在管道事件中，会根据请求创建一个HttpHandler，并执行它的PR方法。对于aspx和ashx都很好理解，因为它们本身就实现了IHttpHandler接口，而MVC的Controller和Action都和HttpHandler没有关系，它是如何实现的呢？接下来我们就看一个请求是如何进入mvc框架内部的。

二、例子

　　WebForm和MVC都是建立在asp.net平台上的，Webform出现得比较早，那么MVC是如何做到在不影响底层框架，实现扩展的呢？这主要得益于asp.net的路由机制。路由机制并不属于MVC，WebForm也可以使用它。它的目的是让一个请求与物理文件分离，原理是通过映射关系，将请求映射到指定的HttpHandler。例如我们也可以将一个/Admin/User.aspx?name=张三 的请求映射成可读性更好的/Admin/张三。下面是两种url的注册方式：

        public static void RegisterRoutes(RouteCollection routes)
        {
            //MVC
            routes.MapRoute(
                name: "Default",
                url: "{controller}/{action}/{id}",
                defaults: new { controller = "Home", action = "Index", id = UrlParameter.Optional }
            );

            //WebForm
            routes.MapPageRoute(
                routeName: "WebForm",
                routeUrl: "Admin/{user}",
                physicalFile: "~/Admin/User.aspx"
            );
        }

　　RouteCollection是一个Route集合，Route封装了名称、url模式、约束条件、默认值等路由相关信息。其中，MapPageRoute是RouteCollection定义的方法，而MapRoute是MVC扩展出来的(扩展方法的好处就是可以在不修改原有代码的情况下添加所需的功能)。它们的目的都是一样的，创建一个Route对象，添加到集合当中；我们也可以new 一个Route对象，然后调用RouteCollection.Add，效果是一样的。下面我们主要关注MVC的实现过程，WebForm其实也是类似的。

三、分析源码

　　接下来我们看MVC是如何利用路由机制实现扩展的。路由机制是通过一个UrlRoutingModule完成的，它是一个实现了IHttpModule的类，路由模块已经默认帮我们注册好了。HttpModule通过注册HttpApplication事件参与到管道处理请求中，具体是订阅HttpApplication某个阶段的事件。路由机制就是利用这个原理，UrlRoutingModule订阅了PostResolveRequestCache 事件，实现url的映射。为什么是该事件呢？因为该事件的下一步就要完成请求和物理文件的映射，所以必须要此之前进行拦截。核心代码如下：

    public class UrlRoutingModule : IHttpModule {
        public RouteCollection RouteCollection {
            get {
                if (_routeCollection == null) {
                    //全局的RouteCollection集合
                    _routeCollection = RouteTable.Routes;
                }
                return _routeCollection;
            }
            set {
                _routeCollection = value;
            }
        }
 
        protected virtual void Init(HttpApplication application) {
            //注册PostResolveRequestCache事件
            application.PostResolveRequestCache += OnApplicationPostResolveRequestCache;
        }
 
        private void OnApplicationPostResolveRequestCache(object sender, EventArgs e) {
            //创建上下文
            HttpApplication app = (HttpApplication)sender;
            HttpContextBase context = new HttpContextWrapper(app.Context);
            PostResolveRequestCache(context);
        }
 
        public virtual void PostResolveRequestCache(HttpContextBase context) {
            //1.获取RouteData
            RouteData routeData = RouteCollection.GetRouteData(context);
            if (routeData == null) {
                return;
            }
            //2.获取IRouteHandler
            IRouteHandler routeHandler = routeData.RouteHandler;
            if (routeHandler == null) {
                
            }
            
            //RequestContext保证了HttpContext和RouteData,在后续使用
            RequestContext requestContext = new RequestContext(context, routeData);
 
            context.Request.RequestContext = requestContext;

            //3.获取IHttpHandler
            IHttpHandler httpHandler = routeHandler.GetHttpHandler(requestContext);

            //重新映射到处理程序
            context.RemapHandler(httpHandler);
        }
    }　　

　　我们关注主要方法PostResolveRequestCache，这里有三个关键步骤。

　　步骤一. 获取RouteData

　　RouteData是对Route的包装，在后续的处理中使用。它的获取是通过RouteCollection获得的，这个和上面注册用到的RouteTable.Routes是同一个集合对象。调用RouteCollection的GetRouteData会遍历它的每一个项，也就是Route对象，然后调用Route对象的GetRouteData方法（MVC内部很多集合都用到了这种设计）。如下代码：

        public RouteData GetRouteData(HttpContextBase httpContext) {
            using (GetReadLock()) {
                foreach (RouteBase route in this) {
                    RouteData routeData = route.GetRouteData(httpContext);
                    if (routeData != null) {                       
                        return routeData;
                    }
                }
            }
            return null;
        }

　　Route对象的GetRouteData方法如下：

        public override RouteData GetRouteData(HttpContextBase httpContext) {
            string requestPath = httpContext.Request.AppRelativeCurrentExecutionFilePath.Substring(2) + httpContext.Request.PathInfo;
 
            //结合默认值，匹配url
            RouteValueDictionary values = _parsedRoute.Match(requestPath, Defaults);
 
            if (values == null) {
                return null;
            }
 
            //包装成RouteData，这里为什么不放在if后面呢？
            RouteData routeData = new RouteData(this, RouteHandler);
 
            //匹配约束
            if (!ProcessConstraints(httpContext, values, RouteDirection.IncomingRequest)) {
                return null;
            }
 
            //RouteData的Values和DataTokens都来自于Route
            foreach (var value in values) {
                routeData.Values.Add(value.Key, value.Value);
            }
            if (DataTokens != null) {
                foreach (var prop in DataTokens) {
                    routeData.DataTokens[prop.Key] = prop.Value;
                }
            }
 
            return routeData;
        }

　　可以看到，Route对象的GetRouteData方法会匹配url模式，和检查约束条件，如何不符合会返回null。如果匹配，则new一个RouteData。

　　步骤二、获取IRouteHandler接口对象

　　上面创建RouteData，参数分别是当前Route对象和它的RouteHandler属性。RouteHandler是一个IRouteHandler，这是一个重要接口，它的定义如下：

    public interface IRouteHandler {
        IHttpHandler GetHttpHandler(RequestContext requestContext);
    }

　　很明显，它是用于获取IHttpHandler的。那么Route对象的RouteHandler属性又是在哪里初始化的呢？我们回到开始的注册方法，routes.MapRoute，这个方法根据传递的参数创建一个Route对象，该方法的实现如下：

        public static Route MapRoute(this RouteCollection routes, string name, string url, object defaults, object constraints, string[] namespaces)
        {
            //创建一个Route对象，它的IRouteHandler为MvcRouteHandler
            Route route = new Route(url, new MvcRouteHandler())
            {
                Defaults = CreateRouteValueDictionary(defaults),
                Constraints = CreateRouteValueDictionary(constraints),
                DataTokens = new RouteValueDictionary()
            };

            if ((namespaces != null) && (namespaces.Length > 0))
            {
                route.DataTokens["Namespaces"] = namespaces;
            }

            //将Route注册到RouteCollection中
            routes.Add(name, route);

            return route;
        }

　　在创建Route时，除了传递url模式外，还默认帮我们传递了一个MvcRouteHandler，它实现了IRouteHandler接口。
　　步骤三、获取IHttpHandler接口对象

　　有了MvcRouteHandler，就可以调用它的GetHttpHandler方法获取IHttpHandler了，该方法实现如下：

        protected virtual IHttpHandler GetHttpHandler(RequestContext requestContext)
        {
            //设置session状态
            requestContext.HttpContext.SetSessionStateBehavior(GetSessionStateBehavior(requestContext));

            //返回一个实现了IHttpHandler的MvcHandler
            return new MvcHandler(requestContext);
        }

　　可以看到，它返回了一个MvcHandler，MvcHandler就实现了IHttpHandler接口。所以开头说的，请求本质都是交给HttpHandler的，其实MVC也是这样的，请求交给了MvcHandler处理。我们可以看MvcHandler定义和主要方法：

    public class MvcHandler : IHttpAsyncHandler, IHttpHandler, IRequiresSessionState
    {
         protected internal virtual IAsyncResult BeginProcessRequest(HttpContextBase httpContext, AsyncCallback callback, object state)
        {
            IController controller;
            IControllerFactory factory;

            //这个方法里会激活Controller对象
            ProcessRequestInit(httpContext, out controller, out factory);

            IAsyncController asyncController = controller as IAsyncController;
            if (asyncController != null)
            {
                // asynchronous controller
                BeginInvokeDelegate beginDelegate = delegate(AsyncCallback asyncCallback, object asyncState)
                {
                    try
                    {
                        //调用Controller的BeginExecute方法
                        return asyncController.BeginExecute(RequestContext, asyncCallback, asyncState);
                    }
                    catch
                    {
                        factory.ReleaseController(asyncController);
                        throw;
                    }
                };

                EndInvokeDelegate endDelegate = delegate(IAsyncResult asyncResult)
                {
                    try
                    {
                        asyncController.EndExecute(asyncResult);
                    }
                    finally
                    {
                        factory.ReleaseController(asyncController);
                    }
                };

                SynchronizationContext syncContext = SynchronizationContextUtil.GetSynchronizationContext();
                AsyncCallback newCallback = AsyncUtil.WrapCallbackForSynchronizedExecution(callback, syncContext);
                return AsyncResultWrapper.Begin(newCallback, state, beginDelegate, endDelegate, _processRequestTag);
            }
            else
            {
                // synchronous controller
                Action action = delegate
                {
                    try
                    {
                        controller.Execute(RequestContext);
                    }
                    finally
                    {
                        factory.ReleaseController(controller);
                    }
                };

                return AsyncResultWrapper.BeginSynchronous(callback, state, action, _processRequestTag);
            }
        }
    }

　　可以看到，MvcHandler的任务就是激活Controller，并执行它的Execute方法。这个过程和Webform里的页面处理是很相似的，.aspx请求到来，会根据虚拟路径找到实现IHttpHandler的Page（类似于路由机制根据url模式找到MvcHandler）,然后进入Page的页面周期（类似于Mvc的激活Controller，然后执行Action过程）。

四、总结

接下来，简单总结一下请求进入到MVC框架的过程：

1.添加路由对象Route到全局的RouteCollection，Route的IRouteHandler初始化为MvcRouteHandler。

2. UrlRoutingModule注册 HttpApplication PostResolveRequestCache事件，实现请求拦截。

3. 请求到来， 在处理事件中遍历RouteCollection，调用每一个Route对象的GetRouteData获取RouteData包装对象。

4. 调用MvcRouteHandler的GetHttpHandler获取MvcHandler。

5. 调用HttpContext的RemapHandler将请求映射到MvcHandler处理程序。

6. 执行MvcHandler的PR方法，激活Controller，执行Action。