Ninject是一款.Net平台下的开源依赖注入框架

Ninject是一款.Net平台下的开源依赖注入框架.按照官方说法,它快如闪电、超级轻量,且充分利用了.Net的最新语法,使用Lambda表达式代替Xml文件完成类型绑定.Ninject结构精巧,功能强大,越来越受到各类开发者的关注,其开源社区非常活跃,众多开发者为它开发了各种各样的扩展应用.其中有一款名叫Ninject.Web.Common,是所有将Ninject应用于Web项目的基框架,而Ninject.MVC3则是将Ninject应用于Asp.Net Mvc中的框架.这两者是本文分析的主角.

书写本文时,Ninject的版本号为3.0.1,Ninject.Web.Common的版本号为3.0.0.3.,Ninject.MVC3的版本号为3.0.0.6.

OnePerRequestHttpModule是与对象生命周期有关的类,表示在同一次请求内同一类型会解析出相同的实例.这个是Web程序特有的生命周期,能在部分应用中节约资源,提高性能.此类实现了IHttpModule接口,如下:

public void Init(HttpApplication application)
{
    application.EndRequest += (o, e) => this.DeactivateInstancesForCurrentHttpRequest();
}

public void DeactivateInstancesForCurrentHttpRequest()
{
    if (this.ReleaseScopeAtRequestEnd)
    {
        var context = HttpContext.Current;
        this.MapKernels(kernel => kernel.Components.Get<ICache>().Clear(context));
    }
}

可以看到,在WebApplication生命周期的最后,其会将所有在请求过程中生成的且缓存于HttpContext.Current的对象手动清空.还可以看到,其实这个类只涉及到OnePerRequest生命周期的部分实现,即清空部分.对象的分配部分则内置于Ninject框架中.

IBootstrapper接口的实现类为Bootstrapper,如下所示:

private static IKernel kernelInstance;

public void Initialize(Func<IKernel> createKernelCallback)
{
    kernelInstance = createKernelCallback();

    kernelInstance.Components.GetAll<INinjectHttpApplicationPlugin>().Map(c => c.Start());
    kernelInstance.Bind<IHttpModule>().To<HttpApplicationInitializationHttpModule>();
    kernelInstance.Inject(this);
}

public void ShutDown()
{
    if (kernelInstance != null)
    {
        kernelInstance.Components.GetAll<INinjectHttpApplicationPlugin>().Map(c => c.Stop());
        kernelInstance.Dispose();
        kernelInstance = null;
    }
}

public void InitializeHttpApplication(HttpApplication httpApplication)
{
    kernelInstance.Inject(httpApplication);
}

Bootstrapper的中文意思是启动加载器,即管理程序启动时所需资源.IOC核心最终是保存在此对象的静态字段kernelInstance中.Initialize方法接受一个Func<IKernel>类型的委托,即通过它获取IOC核心.然后从中获取所有实现了INinjectHttpApplicationPlugin接口的类并立刻调用此接口Start方法.可以从名字猜出,这是一个简易的插件系统,在系统启动前首先启动所有插件.第二句先放一下.第三句则是将自己重新注入.只有由从IOC中获取的对象才能被注入,而Inject方法专门用于不是由IOC生成的对象,可以让其标记了[Inject]的且为空的属性重新获得对象注入.可以看到在默认情况下这一句不会产生实际效果.

InitializeHttpApplication则是将HttpApplication对象重注入.HttpApplication对象是由Asp.Net自动生成的.如果在实际使用的子类中进行了属性注入,则需要通过重注入的方式为属性获取合适的值.

ShutDown方法在系统关闭时被调用,用于插件的逐个卸载.

分析完这两个类我们再来分析Ninject.Web.Common的核心类:NinjectHttpApplication

private readonly OnePerRequestHttpModule onePerRequestHttpModule;

private readonly IBootstrapper bootstrapper;

protected NinjectHttpApplication()
{
    this.onePerRequestHttpModule = new OnePerRequestHttpModule();
    this.onePerRequestHttpModule.Init(this);
    this.bootstrapper = new Bootstrapper();
}

public void Application_Start()
{
    lock (this)
    {
        this.bootstrapper.Initialize(this.CreateKernel);
        this.onePerRequestHttpModule.ReleaseScopeAtRequestEnd = this.bootstrapper.Kernel.Settings.Get("ReleaseScopeAtRequestEnd", true);
        this.OnApplicationStarted();
    }
}

public void Application_End()
{
    this.bootstrapper.ShutDown();
    this.OnApplicationStopped();
}

protected abstract IKernel CreateKernel();

protected virtual void OnApplicationStarted() { }

protected virtual void OnApplicationStopped() { }

public override void Init()
{
    base.Init();
    this.bootstrapper.InitializeHttpApplication(this);
}

在此对象构造函数中,构造了上面所述的两个对象,并手动调用了OnePerRequestHttpModule对象的Init方法完成了此IHttpModule的挂载.然后在Application_Start()方法中调用了IBootstrapper对象的Initialize方法完成了插件的挂载.并设置了OnePerRequestHttpModule对象是否开启资源清理.最后调用OnApplicationStarted方法.Application_End()则完成插件的卸载和OnApplicationStopped()方法.

可以看到,此对象改变了传统HttpApplication对象的一般处理过程.按照其设计意图,应用程序开启时执行的方法由默认的Application_Start方法转移动OnApplicationStarted(),而应用程序终止时执行的方法则由Application_End方法转移到OnApplicationStopped方法中.

此对象实际是一个抽象对象,包含唯一一个抽象方法CreateKernel,方法最终将被用户重写,用于提供IOC核心.

在Init方法中调用Bootstrapper对象的InitializeHttpApplication方法完成对自身的重注入.Init方法与Application_Start方法不同.Init方法将在每个HttpApplication对象构造完成并加载了所有IHttpModule之后被调用,而Application_Start方法则是在应用程序启动时被调用,在整个应用程序中Init方法会被调用多次,而Application_Start方法只会被调用一次.如果HttpApplication对象池有剩余对象,则会取出一个来处理请求,这时不会触发Init方法,否则则会建立新的HttpApplication对象来处理新的请求,这时则会调用Init方法.

至此,Ninject.Web.Common的主体工程已分析完毕.但其仍提供了两个额外的HttoModule.这也是最容易让人引起困惑的地方.

NinjectHttpModule类提供了一种功能,即通过类型绑定而不是Web.Config来配置IHttpModule,如下:

private IList<IHttpModule> httpModules;

public void Init(HttpApplication context)
{
    this.httpModules = new Bootstrapper().Kernel.GetAll<IHttpModule>().ToList();
    foreach (var httpModule in this.httpModules)
    {
        httpModule.Init(context);
    }
}

public void Dispose()
{
    foreach (var httpModule in this.httpModules)
    {
        httpModule.Dispose();
    }

    this.httpModules.Clear();
}

代码比较简单,即在Init处获取所有已绑定的实现了IHttpModule接口的对象并循环调用它们的Init方法,在Dispose方法处循环调用它们各自的Dispose方法.

HttpApplicationInitializationHttpModule对象如下:

private readonly Func<IKernel> lazyKernel;

public HttpApplicationInitializationHttpModule(Func<IKernel> lazyKernel)
{
    this.lazyKernel = lazyKernel;
}

public void Init(HttpApplication context)
{
    this.lazyKernel().Inject(context);
}

这个更简单,就是将HttpApplication对象重新注入,只不过实现为了IHttpModule接口.还记得Bootstrapper对象的Initialize方法吗?在那里将IHttpModule与HttpApplicationInitializationHttpModule进行了绑定.

在Ninject.Web.Common官网上展示了使用这个框架的两种方式,一种是继承,一种是动态注入.现在问题来了:

1.如何使用HttpApplicationInitializationHttpModule对象?可以看到,其没有无参构造函数,如果直接配置于Web.Config,Asp.Net则会因为无法构造此对象而报错.此对象需配合NinjectHttpModule对象使用.

2.如果使用继承方式使用,同时在Web.Config中配置了NinjectHttpModule,则HttpApplication对象将被注入两次.一次在Bootstrapper对象的InitializeHttpApplication方法中,一次在HttpApplicationInitializationHttpModule对象的Init方法中.一开始我百思不得其解,后来看到一篇官方的反馈我才恍然大悟.原来HttpApplicationInitializationHttpModule并不应该用于使用继承方式中,而是用于动态注入方式中的.

3.同上,如果使用继承方式使用,同时在Web.Config中配置了NinjectHttpModule,则程序会报错,因为是HttpApplicationInitializationHttpModule对象是由IOC核心构造的,其需要知道Func<IKernel>类型的实际类型.

最后,我们来看一看官方推荐的动态注入使用方式

[assembly: WebActivator.PreApplicationStartMethod(typeof(WebApplication1.App_Start.NinjectWebCommon), "Start")]
[assembly: WebActivator.ApplicationShutdownMethodAttribute(typeof(WebApplication1.App_Start.NinjectWebCommon), "Stop")]
public static class NinjectWebCommon
{
    private static readonly Bootstrapper bootstrapper = new Bootstrapper();

    /// <summary>
    /// Starts the application
    /// </summary>
    public static void Start()
    {
        DynamicModuleUtility.RegisterModule(typeof(OnePerRequestHttpModule));
        DynamicModuleUtility.RegisterModule(typeof(NinjectHttpModule));
        bootstrapper.Initialize(CreateKernel);
    }

    public static void Stop()
    {
        bootstrapper.ShutDown();
    }

    private static IKernel CreateKernel()
    {
        var kernel = new StandardKernel();
        kernel.Bind<Func<IKernel>>().ToMethod(ctx => () => new Bootstrapper().Kernel);
        kernel.Bind<IHttpModule>().To<HttpApplicationInitializationHttpModule>();

        RegisterServices(kernel);
        return kernel;
    }

    private static void RegisterServices(IKernel kernel) { }
}

它充分使用Asp.Net 4.0的新技术,并使用了WebActivator框架,在Web程序启动前动态调用Start函数,在关闭前调用Stop函数.在Start函数中,动态注册了OnePerRequestHttpModule和NinjectHttpModule.而对于CreateKernel函数,首先新建了IOC核心,然后绑定了Func<IKernel>类型与IHttpModule类型.可以看到,由于在Bootstrapper对象的Initialize方法里已绑定过一次,这里重复绑定了.然后调用RegisterServices方法获取应用程序的各类具体类型绑定,最后将IOC核心返回以保存至Bootstrapper的静态变量kernelInstance中.

Ninject.MVC3的代码则比较简单

MvcModule类继承自GlobalKernelRegistrationModule<OnePerRequestHttpModule>类.GlobalKernelRegistrationModule<T>类继承自NinjectModule类.完成了各种类型绑定.GlobalKernelRegistrationModule<T>类与GlobalKernelRegistration类配合使用的,实现了一种反向绑定.一般的正向绑定,即某一个IOC核心绑定了多个接口到类的映射,而反向绑定则是记录某个接口在哪些IOC核心里进行了绑定.这个功能我暂时没有看到在哪里进行了使用,不过应该是有所目的的.

MvcModule类定义如下:

public override void Load()
{
    base.Load();
    this.Kernel.Components.Add<INinjectHttpApplicationPlugin, NinjectMvcHttpApplicationPlugin>();
    this.Kernel.Bind<IDependencyResolver>().To<NinjectDependencyResolver>();
    this.Kernel.Bind<IFilterProvider>().To<NinjectFilterAttributeFilterProvider>();
    this.Kernel.Bind<IFilterProvider>().To<NinjectFilterProvider>();
    this.Kernel.Bind<RouteCollection>().ToConstant(RouteTable.Routes);
    this.Kernel.Bind<HttpContext>().ToMethod(ctx => HttpContext.Current).InTransientScope();
    this.Kernel.Bind<HttpContextBase>().ToMethod(ctx => new HttpContextWrapper(HttpContext.Current)).InTransientScope();
    this.Kernel.Bind<ModelValidatorProvider>().To<NinjectDataAnnotationsModelValidatorProvider>();
    //this.Kernel.Bind<IModelBinderProvider>().To<NinjectModelBinderProvider>();
    //this.Kernel.Bind<IModelBinder>().To<NinjectModelBinder>();
}

那这个Load函数是何时执行的呢?这就要谈到Ninject的加载策略了.核心对象StandardKernel与其基类KernelBase的构造函数如下

public class StandardKernel : KernelBase
{
    public StandardKernel(params INinjectModule[] modules) : base(modules)
    {
    }
}

public abstract class KernelBase : BindingRoot, IKernel
{
    protected KernelBase()
        : this(new ComponentContainer(), new NinjectSettings(), new INinjectModule[0])
    {}

    protected KernelBase(IComponentContainer components, INinjectSettings settings, params INinjectModule[] modules)
    {
        if (this.Settings.LoadExtensions)
        {
            this.Load(this.Settings.ExtensionSearchPatterns);
        }
    }
}

可以看到,在KernelBase的构造函数中,有一个LoadExtensions的判断,默认在NinjectSettings类中,意思是加载本地扩展

public class NinjectSettings : INinjectSettings
{
    public bool LoadExtensions
    {
        get { return Get("LoadExtensions", true); }
        set { Set("LoadExtensions", value); }
    }

    public string[] ExtensionSearchPatterns
    {
        get { return Get("ExtensionSearchPatterns", new [] { "Ninject.Extensions.*.dll", "Ninject.Web*.dll" }); }
        set { Set("ExtensionSearchPatterns", value); }
    }
}

可以猜测,默认会去Bin目录下搜索所有以Ninject.Extensions或Ninject.Web开头的程序集.

具体的加载过程则比较简单

public void Load(IEnumerable<string> filePatterns)
{
    var moduleLoader = this.Components.Get<IModuleLoader>();
    moduleLoader.LoadModules(filePatterns);
}

加载管理器接口IModuleLoader的实现类为ModuleLoader

public void LoadModules(IEnumerable<string> patterns)
{
    var plugins = Kernel.Components.GetAll<IModuleLoaderPlugin>();

    var fileGroups = patterns
        .SelectMany(pattern => GetFilesMatchingPattern(pattern))
        .GroupBy(filename => Path.GetExtension(filename).ToLowerInvariant());

    foreach (var fileGroup in fileGroups)
    {
        string extension = fileGroup.Key;
        IModuleLoaderPlugin plugin = plugins.Where(p => p.SupportedExtensions.Contains(extension)).FirstOrDefault();

        if (plugin != null)
            plugin.LoadModules(fileGroup);
    }
}

第一句获取所有的加载分析器.程序自带了加载以dll为扩展名的文件型加载分析器,实现类为CompiledModuleLoaderPlugin.第二句获取传入的程序集全路径.第三句则是循环文件,为每一个文件获取一个加载分析器并进行操作.

public class CompiledModuleLoaderPlugin : NinjectComponent, IModuleLoaderPlugin
{
    public void LoadModules(IEnumerable<string> filenames)
    {
        var assembliesWithModules = this.assemblyNameRetriever.GetAssemblyNames(filenames, asm => asm.HasNinjectModules());
        this.Kernel.Load(assembliesWithModules.Select(asm => Assembly.Load(asm)));
    }
}

这里将实际功能委托给AssemblyNameRetriever类完成.

public class AssemblyNameRetriever : NinjectComponent, IAssemblyNameRetriever
{
    public IEnumerable<AssemblyName> GetAssemblyNames(IEnumerable<string> filenames, Predicate<Assembly> filter)
    {
        var assemblyCheckerType = typeof(AssemblyChecker);
        var temporaryDomain = CreateTemporaryAppDomain();
        try
        {
            var checker = (AssemblyChecker)temporaryDomain.CreateInstanceAndUnwrap(
                assemblyCheckerType.Assembly.FullName,
                assemblyCheckerType.FullName ?? string.Empty);

            return checker.GetAssemblyNames(filenames.ToArray(), filter);
        }
    }
}

这里创建了一个临时应用程序域,然后在其中创建AssemblyChecker对象,最终通过它来完成最后的任务

private class AssemblyChecker : MarshalByRefObject
{
    public IEnumerable<AssemblyName> GetAssemblyNames(IEnumerable<string> filenames, Predicate<Assembly> filter)
    {
        var result = new List<AssemblyName>();
        foreach (var filename in filenames)
        {
            Assembly assembly = Assembly.Load(filename);

            if (filter(assembly))
            {
                result.Add(assembly.GetName(false));
            }
        }

        return result;
    }
}

这里在临时应用程序域中创建程序集后,使用了一个判断来决定是否在此程序集中搜索,是由之前传入的,定义在ExtensionsForAssembly类中.

internal static class ExtensionsForAssembly
{
    public static bool HasNinjectModules(this Assembly assembly)
    {
        return assembly.GetExportedTypes().Any(IsLoadableModule);
    }

    public static IEnumerable<INinjectModule> GetNinjectModules(this Assembly assembly)
    {
        return assembly.GetExportedTypes()
                .Where(IsLoadableModule)
                .Select(type => Activator.CreateInstance(type) as INinjectModule);
    }

    private static bool IsLoadableModule(Type type)
    {
        return typeof(INinjectModule).IsAssignableFrom(type)
            && !type.IsAbstract
            && !type.IsInterface
            && type.GetConstructor(Type.EmptyTypes) != null;
    }
}

可以看到,这里就是说,在某一程序集中是否有实现了INinjectModule接口的类,且不是接口,不是抽象类,且还拥有无参构建函数.

获取到程序集名后,由KernelBase完全加载

public void Load(IEnumerable<Assembly> assemblies)
{
    this.Load(assemblies.SelectMany(asm => asm.GetNinjectModules()));
}

public void Load(IEnumerable<INinjectModule> m)
{
    Ensure.ArgumentNotNull(m, "modules");

    m = m.ToList();
    foreach (INinjectModule module in m)
    {
        module.OnLoad(this);

        this.modules.Add(module.Name, module);
    }
}

NinjectDependencyResolver类则实现了接口IDependencyResolver,其本质是一个配置器模式,即让Asp.Net MVC从IOC核心的获取资源.定义如下:

private readonly IResolutionRoot resolutionRoot;

public object GetService(Type serviceType)
{
    var request = this.resolutionRoot.CreateRequest(serviceType, null, new Parameter[0], true, true);
    return this.resolutionRoot.Resolve(request).SingleOrDefault();
}

public IEnumerable<object> GetServices(Type serviceType)
{
    return this.resolutionRoot.GetAll(serviceType).ToList();
}

NinjectMvcHttpApplicationPlugin类则是利用Ninject.Web.Common的插件机制,完成IOC与Asp.Net MVC的对接,其关键代码如下:

public void Start()
{
    ModelValidatorProviders.Providers.Remove(ModelValidatorProviders.Providers.OfType<DataAnnotationsModelValidatorProvider>().Single());
    DependencyResolver.SetResolver(this.CreateDependencyResolver());
    RemoveDefaultAttributeFilterProvider();
}

protected IDependencyResolver CreateDependencyResolver()
{
    return this.kernel.Get<IDependencyResolver>();
}

在CreateDependencyResolver方法中从IOC核心中获取IOC实例,在KernelBase对象的构造函数中完成了IKernel接口与IKernel实例的隐式绑定.如下

this.Bind<IKernel>().ToConstant(this).InTransientScope();
this.Bind<IResolutionRoot>().ToConstant(this).InTransientScope();

回到NinjectMvcHttpApplicationPlugin类,最后在其Start方法的第二行将获取到的IOC实例作为参数传入DependencyResolver对象的SetResolver方法,完成与Asp.Net MVC的对接.

至此,Ninject.MVC3的工作已全部完成!

参考的文章

Ninject官网

Ninject.Web.Common官网

Ninject.MVC3官网

How to inject dependencies in an HttpModule with a NinjectHttpApplication (no nuget)?

RC2, issue with HttpApplicationInitializationHttpModule Injection

IOC框架Ninject实践总结

Ninject 学习例子代码(一)

Ninject 学习例子代码(二)

ASP.NET MVC3 让依赖注入来的更简单（新补充了Ninject示例）

ASP.NET MVC3 + Ninject.Mvc3 依赖注入原来可以这么简单

ASP.NET MVC 3 Service Location, Part