探索ASP.NET MVC框架之控制器的查找与激活机制
引言
前面一篇博文我们介绍了MVC框架的路由机制，我们知道一个URL请求如何从ASP.NET处理管线到达了IHttpHandler实例（MvcHandler）。今天我们从MvcHandler来进行下一步骤的分析，看看MVC框架是如何找到指定的控制器并且激活（创建）控制器实例的。
一切从MvcHandler的ProcessRequest方法开始（获取控制器工厂实例）
我们知道Http请求到达服务端，找到相应的IHttpHandler后，会执行ProcessRequest方法来处理请求，现在我们就来看看MvcHandler是怎么处理请求的。上源码：
1 IController controller;
2 IControllerFactory factory;
3 ProcessRequestInit(httpContext, out controller, out factory);
4 try
5 {
6 controller.Execute(RequestContext);
7 }
8 finally
9 {
10 factory.ReleaseController(controller);
11 }
从这段代码我们看到，在获取控制器实例时，是通过控制器工厂来创建的，下面我们来看一下ProcessRequestInit方法。看源代码：
1 private void ProcessRequestInit(HttpContextBase httpContext, out IController controller, out IControllerFactory factory) 2 { 3 // If request validation has already been enabled, make it lazy. This allows attributes like [HttpPost] (which looks 4 // at Request.Form) to work correctly without triggering full validation. 5 // Tolerate null HttpContext for testing. 6 HttpContext currentContext = HttpContext.Current; 7 if (currentContext != null) 8 { 9 bool? isRequestValidationEnabled = ValidationUtility.IsValidationEnabled(currentContext); 10 if (isRequestValidationEnabled == true) 11 { 12 ValidationUtility.EnableDynamicValidation(currentContext); 13 } 14 } 15 16 AddVersionHeader(httpContext); 17 RemoveOptionalRoutingParameters(); 18 19 // Get the controller type 20 string controllerName = RequestContext.RouteData.GetRequiredString("controller"); 21 22 // Instantiate the controller and call Execute 23 factory = ControllerBuilder.GetControllerFactory(); 24 controller = factory.CreateController(RequestContext, controllerName); 25 if (controller == null) 26 { 27 throw new InvalidOperationException( 28 String.Format( 29 CultureInfo.CurrentCulture, 30 MvcResources.ControllerBuilder_FactoryReturnedNull, 31 factory.GetType(), 32 controllerName)); 33 } 34 }
我们看这个方法从20行开始，该方法先获取控制器的名称，然后获取控制器工厂实例（代码23行）。然后使用控制器工厂实例来创建控制器实例。下面我们就来看一下ControllerBuilder来创建控制器工厂实例的过程。
下面我们来看一下GetControllerFactory方法的内部实现，源码很简单，就一行代码：
1 public IControllerFactory GetControllerFactory() 2 { 3 return _serviceResolver.Current; 4 }
很明显，这是读取了_serviceResolver实例的Current属性值，那么我们需要仔细查看下_serviceResolver实例的创建及其Current属性的赋值，通过看源代码，我们看到了以下代码：
1 private static ControllerBuilder _instance = new ControllerBuilder(); 2 private Func<IControllerFactory> _factoryThunk = () => null; 3 private HashSet<string> _namespaces = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 4 private IResolver<IControllerFactory> _serviceResolver; 5 6 public ControllerBuilder() : this(null) { } 7 8 internal ControllerBuilder(IResolver<IControllerFactory> serviceResolver) 9 { 10 _serviceResolver = serviceResolver ?? new SingleServiceResolver<IControllerFactory>( 11 () => _factoryThunk(), 12 new DefaultControllerFactory { ControllerBuilder = this }, 13 "ControllerBuilder.GetControllerFactory"); 14 } 15 16 [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate", Justification = "Calling method multiple times might return different objects.")] 17 public IControllerFactory GetControllerFactory() 18 { 19 return _serviceResolver.Current; 20 }
我们看到ControllerBuilder类中有一个静态字段 _instance，静态字段是在程序执行前加载的，那么由代码可知，就需要执行该类的构造函数，即执行public ControllerBuilder(): this(null)，而其后的: this(null)则表示要去执执行带一个参数的构造函数 ControllerBuilder(IResolver<IControllerFactory> serviceResolver)，这个构造函数中首先判断传入的参数是否为空，如果为空的话就实例化一个 SingleServiceResolver<IControllerFactory>对象（暂且理解为封装 ControllerFactory的一个类），并赋值给私有变量_serviceResolver，通过调用_serviceResolver的 Current属性来获取当前封装的ControllerFactory实例。
通过上面的分析，我们知道了大致的流程，下面我们深入SingleServiceResolve内部看看其实例的Current到底是怎么计算的。默认情况下_factoryThunk委托传递的值是null。看源码：
1 internal class SingleServiceResolver<TService> : IResolver<TService> 2 where TService : class 3 { 4 private Lazy<TService> _currentValueFromResolver; 5 private Func<TService> _currentValueThunk; 6 private TService _defaultValue; 7 private Func<IDependencyResolver> _resolverThunk; 8 private string _callerMethodName; 9 10 public SingleServiceResolver(Func<TService> currentValueThunk, TService defaultValue, string callerMethodName) 11 { 12 if (currentValueThunk == null) 13 { 14 throw new ArgumentNullException("currentValueThunk"); 15 } 16 if (defaultValue == null) 17 { 18 throw new ArgumentNullException("defaultValue"); 19 } 20 //默认情况下是DefaultDependencyResolver 21 _resolverThunk = () => DependencyResolver.Current; 22 _currentValueFromResolver = new Lazy<TService>(GetValueFromResolver); 23 _currentValueThunk = currentValueThunk; 24 _defaultValue = defaultValue; 25 _callerMethodName = callerMethodName; 26 } 27 28 internal SingleServiceResolver(Func<TService> staticAccessor, TService defaultValue, IDependencyResolver resolver, string callerMethodName) 29 : this(staticAccessor, defaultValue, callerMethodName) 30 { 31 if (resolver != null) 32 { 33 _resolverThunk = () => resolver; 34 } 35 } 36 37 public TService Current 38 { 39 get { return _currentValueFromResolver.Value ?? _currentValueThunk() ?? _defaultValue; } 40 } 41 42 private TService GetValueFromResolver() 43 { 44 TService result = _resolverThunk().GetService<TService>(); 45 46 if (result != null && _currentValueThunk() != null) 47 { 48 throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, MvcResources.SingleServiceResolver_CannotRegisterTwoInstances, typeof(TService).Name.ToString(), _callerMethodName)); 49 } 50 51 return result; 52 } 53 }
我们看到Current属性的求值涉及到3个过程，看代码的红色部分。下面我们来看这3个步骤。
第一个步骤我们看_currentValueFromResolver.Value的值。我们知道_currentValueFromResolver绑定了GetValueFromResolver方法。该方法内部使用了resolverThunk委托，该委托返回DependencyResolver.Current。我在以上的代码中已经进行了注释。DependencyResolver.Current实际使用的是DefaultDependencyResolver类。使用DefaultDependencyResolver类的GetService方法。我们深入该方法内部发现其逻辑是这样的：
1 public object GetService(Type serviceType) 2 { 3 // Since attempting to create an instance of an interface or an abstract type results in an exception, immediately return null 4 // to improve performance and the debugging experience with first-chance exceptions enabled. 5 if (serviceType.IsInterface || serviceType.IsAbstract) 6 { 7 return null; 8 } 9 10 try 11 { 12 return Activator.CreateInstance(serviceType); 13 } 14 catch 15 { 16 return null; 17 } 18 }
我们看到，如果传递的Type类型是接口或者抽象类的话就返回null。很明显我们传递的serviceType是一个接口。第一步骤返回时null。接下来我们继续分析第二个步骤。
第二个步骤我们看到调用的是_currentValueThunk委托。这个委托默认值是返回null的。当然我们在自定义控制器工厂的时候其实就是重新设置这个委托值。这是MVC框架的一个扩展点。我们来看一下设置自定义控制器工厂内部发生的事，看源代码：
1 public void SetControllerFactory(IControllerFactory controllerFactory) 2 { 3 if (controllerFactory == null) 4 { 5 throw new ArgumentNullException("controllerFactory"); 6 } 7 8 _factoryThunk = () => controllerFactory; 9 }
看到了把，通过SetControllerFactory方法，我们相当于让_factoryThunk委托返回我们自定义的控制器工厂实例。这样在获取Current属性值的时候，第二个步骤就是调用这个委托返回控制器工厂实例，只是默认值是null而已。如果我们设置了自定义的值，就会返回自定义控制器工厂值。
第三个步骤我们看到返回的是_defaultValue的值。很明显MVC框架默认值是DefaultControllerFactory。所以MVC框架默认的控制器工厂是DefaultControllerFactory。到此为止我们已经分析出该开始ProcessRequest中获取的控制器工厂实例就是DefaultControllerFactory的实例了。我们继续往下看。
激活（创建）控制器实例
通过上面的分析我们知道控制器工厂是DefaultControllerFactory，下面我们深入其内部看看控制器实例到底是怎么创建出来的。通过最开始部分代码的逻辑（即ProcessRequest方法），我们知道创建控制器的方法是CreateController方法，那么我们就从这个方法入手。
1 public virtual IController CreateController(RequestContext requestContext, string controllerName) 2 { 3 if (requestContext == null) 4 { 5 throw new ArgumentNullException("requestContext"); 6 } 7 if (String.IsNullOrEmpty(controllerName)) 8 { 9 throw new ArgumentException(MvcResources.Common_NullOrEmpty, "controllerName"); 10 } 11 Type controllerType = GetControllerType(requestContext, controllerName); 12 IController controller = GetControllerInstance(requestContext, controllerType); 13 return controller; 14 }
我们看到整个过程主要分成两个部分。第一步：获取控制器类型。第二步：根据控制器类型获取控制器实例。下面我们就分两步来介绍这个过程。
第一步获取控制器类型：
1 protected internal virtual Type GetControllerType(RequestContext requestContext, string controllerName) 2 { 3 if (String.IsNullOrEmpty(controllerName)) 4 { 5 throw new ArgumentException(MvcResources.Common_NullOrEmpty, "controllerName"); 6 } 7 8 // first search in the current route's namespace collection 9 object routeNamespacesObj; 10 Type match; 11 if (requestContext != null && requestContext.RouteData.DataTokens.TryGetValue("Namespaces", out routeNamespacesObj)) 12 { 13 IEnumerable<string> routeNamespaces = routeNamespacesObj as IEnumerable<string>; 14 if (routeNamespaces != null && routeNamespaces.Any()) 15 { 16 HashSet<string> namespaceHash = new HashSet<string>(routeNamespaces, StringComparer.OrdinalIgnoreCase); 17 match = GetControllerTypeWithinNamespaces(requestContext.RouteData.Route, controllerName, namespaceHash); 18 19 // the UseNamespaceFallback key might not exist, in which case its value is implicitly "true" 20 if (match != null || false.Equals(requestContext.RouteData.DataTokens["UseNamespaceFallback"])) 21 { 22 // got a match or the route requested we stop looking 23 return match; 24 } 25 } 26 } 27 28 // then search in the application's default namespace collection 29 if (ControllerBuilder.DefaultNamespaces.Count > 0) 30 { 31 HashSet<string> namespaceDefaults = new HashSet<string>(ControllerBuilder.DefaultNamespaces, StringComparer.OrdinalIgnoreCase); 32 match = GetControllerTypeWithinNamespaces(requestContext.RouteData.Route, controllerName, namespaceDefaults); 33 if (match != null) 34 { 35 return match; 36 } 37 } 38 39 // if all else fails, search every namespace 40 return GetControllerTypeWithinNamespaces(requestContext.RouteData.Route, controllerName, null /* namespaces */); 41 }
我们看到这段代码的结构很清晰。第一步先在当前路由设置的命名空间中寻找符合条件的控制器。如果找不到就从工程中设置的命名空间中寻找。如果还是找不到就一个一个命名空间的遍历寻找。
第二步根据控制器类型创建其实例
我们接下来看第二个步骤，创建控制器实例，逻辑中也是封装在另一个方法中的（GetControllerInstance）。下面我们来看看其内部实现。
1 /// <summary> 2 /// 通过控制器类型来创建控制器实例 3 /// </summary> 4 /// <param name="requestContext"></param> 5 /// <param name="controllerType"></param> 6 /// <returns></returns> 7 protected internal virtual IController GetControllerInstance(RequestContext requestContext, Type controllerType) 8 { 9 if (controllerType == null) 10 { 11 throw new HttpException(404, 12 String.Format( 13 CultureInfo.CurrentCulture, 14 MvcResources.DefaultControllerFactory_NoControllerFound, 15 requestContext.HttpContext.Request.Path)); 16 } 17 if (!typeof(IController).IsAssignableFrom(controllerType)) 18 { 19 throw new ArgumentException( 20 String.Format( 21 CultureInfo.CurrentCulture, 22 MvcResources.DefaultControllerFactory_TypeDoesNotSubclassControllerBase, 23 controllerType), 24 "controllerType"); 25 } 26 return ControllerActivator.Create(requestContext, controllerType); 27 }
我们看到创建控制器本质上是交给控制器激活器来创建的。看来我们需要好好看看这个控制器激活器是如何工作的了。首先我们应该先找到ControllerActivator的值。我们看到了如下代码：
1 private IControllerActivator ControllerActivator 2 { 3 get 4 { 5 if (_controllerActivator != null) 6 { 7 return _controllerActivator; 8 } 9 _controllerActivator = _activatorResolver.Current; 10 return _controllerActivator; 11 } 12 }
我们接着往下看：
1 public DefaultControllerFactory() 2 : this(null, null, null) 3 { 4 } 5 6 public DefaultControllerFactory(IControllerActivator controllerActivator) 7 : this(controllerActivator, null, null) 8 { 9 } 10 11 internal DefaultControllerFactory(IControllerActivator controllerActivator, IResolver<IControllerActivator> activatorResolver, IDependencyResolver dependencyResolver) 12 { 13 //如果不存在自定义的控制器激活器，就使用默认的DefaultControllerActivator控制器激活器 14 if (controllerActivator != null) 15 { 16 _controllerActivator = controllerActivator; 17 } 18 else 19 { 20 _activatorResolver = activatorResolver ?? new SingleServiceResolver<IControllerActivator>( 21 () => null, 22 new DefaultControllerActivator(dependencyResolver), 23 "DefaultControllerFactory constructor"); 24 } 25 }
我们在这里又看到了熟悉的代码（红色部分），相信大家对于SingleServiceResolver泛型类比较熟悉了。我们看到MVC框架默认的控制器激活器是DefaultControllerActivator。我们接下来来看DefaultControllerActivator类内部逻辑。
1 /// <summary> 2 /// MVC框架默认的自定义控制器激活器 3 /// </summary> 4 private class DefaultControllerActivator : IControllerActivator 5 { 6 private Func<IDependencyResolver> _resolverThunk; 7 8 public DefaultControllerActivator() 9 : this(null) 10 { 11 } 12 13 public DefaultControllerActivator(IDependencyResolver resolver) 14 { 15 if (resolver == null) 16 { 17 //DependencyResolver.Current默认是DefaultDependencyResolver 18 _resolverThunk = () => DependencyResolver.Current; 19 } 20 else 21 { 22 _resolverThunk = () => resolver; 23 } 24 } 25 26 public IController Create(RequestContext requestContext, Type controllerType) 27 { 28 try 29 { 30 return (IController)(_resolverThunk().GetService(controllerType) ?? Activator.CreateInstance(controllerType)); 31 } 32 catch (Exception ex) 33 { 34 throw new InvalidOperationException( 35 String.Format( 36 CultureInfo.CurrentCulture, 37 MvcResources.DefaultControllerFactory_ErrorCreatingController, 38 controllerType), 39 ex); 40 } 41 } 42 }
我们来看激活器的Create方法，控制器的实例就是由这个方法来创建。我们看到控制器的实例就是根据控制器类型来创建的。到此为止，我们终于知道了如何激活控制器实例。下面一篇文章我们还会沿着请求的步骤继续往下探索。
