ABP之模块分析

本篇作为我ABP介绍的第三篇文章，这次想讲下模块的，ABP文档已经有模块这方面的介绍，但是它只讲到如何使用模块，我想详细讲解下它模块的设计思路。

ABP 框架提供了创建和组装模块的基础，一个模块能够依赖于另一个模块。在通常情况下，一个程序集就可以看成是一个模块。在 ABP 框架中，一个模块通过一个类来定义，而这个类要继承自 AbpModule。

其实它的设计思路很简单：

1、加载bin目录下的所有dll

    public class WebAssemblyFinder : IAssemblyFinder

    {

        /// <summary>

        /// This return all assemblies in bin folder of the web application.

        /// </summary>

        /// <returns>List of assemblies</returns>

        public List<Assembly> GetAllAssemblies()

        {

            var assembliesInBinFolder = new List<Assembly>();

            var allReferencedAssemblies = BuildManager.GetReferencedAssemblies().Cast<Assembly>().ToList();

            var dllFiles = Directory.GetFiles(HttpRuntime.AppDomainAppPath + "bin\\", "*.dll", SearchOption.TopDirectoryOnly).ToList();

            foreach (string dllFile in dllFiles)

            {

                var locatedAssembly = allReferencedAssemblies.FirstOrDefault(asm => AssemblyName.ReferenceMatchesDefinition(asm.GetName(), AssemblyName.GetAssemblyName(dllFile)));

                if (locatedAssembly != null)

                {

                    assembliesInBinFolder.Add(locatedAssembly);

                }

            }

            return assembliesInBinFolder;

        }

    }

2、循环判断获取所有与AbpModule的Types有关

        public static bool IsAbpModule(Type type)

        {

            return

                type.IsClass &&

                !type.IsAbstract &&

                typeof(AbpModule).IsAssignableFrom(type);

        }

并递归获取没有只在所有的DependsOnAttribute，把他们填在到modules集合中（请详细看AbpModule.FindDependedModuleTypes方法）

        private static ICollection<Type> AddMissingDependedModules(ICollection<Type> allModules)

        {

            var initialModules = allModules.ToList();

            foreach (var module in initialModules)

            {

                FillDependedModules(module, allModules);

            }

            return allModules;

        }

        private static void FillDependedModules(Type module, ICollection<Type> allModules)

        {

            foreach (var dependedModule in AbpModule.FindDependedModuleTypes(module))

            {

                if (!allModules.Contains(dependedModule))

                {

                    allModules.Add(dependedModule);

                    FillDependedModules(dependedModule, allModules);

                }

            }

        }

        public static List<Type> FindDependedModuleTypes(Type moduleType)

        {

            if (!IsAbpModule(moduleType))

            {

                throw new AbpInitializationException("This type is not an ABP module: " + moduleType.AssemblyQualifiedName);

            }

            var list = new List<Type>();

            if (moduleType.IsDefined(typeof(DependsOnAttribute), true))

            {

                var dependsOnAttributes = moduleType.GetCustomAttributes(typeof(DependsOnAttribute), true).Cast<DependsOnAttribute>();

                foreach (var dependsOnAttribute in dependsOnAttributes)

                {

                    foreach (var dependedModuleType in dependsOnAttribute.DependedModuleTypes)

                    {

                        list.Add(dependedModuleType);

                    }

                }

            }

            return list;

        }

所有关于模块的重要代码都在AbpModuleManager中，在上面我们已经加载了所有的模块的类型，那么ABP到底有多少个Modules呢

在我下载的Demo中包含了十三个Module，都继承字AbpModule类

3、既然我得到了所有的moduleTypes了，那么我就通过Castle Windsor循环注册了，并反转

        private void LoadAll()

        {

            Logger.Debug("Loading Abp modules...");

            //通过bin加载所有的module集合

            var moduleTypes = AddMissingDependedModules(_moduleFinder.FindAll());

            Logger.Debug("Found " + moduleTypes.Count + " ABP modules in total.");

            //通过castle windsor注册所有的模块 Register to IOC container.

            foreach (var moduleType in moduleTypes)

            {

                if (!AbpModule.IsAbpModule(moduleType))

                {

                    throw new AbpInitializationException("This type is not an ABP module: " + moduleType.AssemblyQualifiedName);

                }

                if (!_iocManager.IsRegistered(moduleType))

                {

                    _iocManager.Register(moduleType);

                }

            }

            //模块反转并添加到_modules中 Add to module collection

            foreach (var moduleType in moduleTypes)

            {

                var moduleObject = (AbpModule)_iocManager.Resolve(moduleType);

                moduleObject.IocManager = _iocManager;

                moduleObject.Configuration = _iocManager.Resolve<IAbpStartupConfiguration>();

                _modules.Add(new AbpModuleInfo(moduleObject));

                Logger.DebugFormat("Loaded module: " + moduleType.AssemblyQualifiedName);

            }

            //确保AbpKernelModule是_modules中第一个module，AbpKernelModule must be the first module

            var startupModuleIndex = _modules.FindIndex(m => m.Type == typeof(AbpKernelModule));

            if (startupModuleIndex > 0)

            {

                var startupModule = _modules[startupModuleIndex];

                _modules.RemoveAt(startupModuleIndex);

                _modules.Insert(0, startupModule);

            }

            SetDependencies();

            Logger.DebugFormat("{0} modules loaded.", _modules.Count);

        }

上面代码有注释，详细请看注释

4、就是初始化所有模块的事件，早AbpModule中作者定义了三个事件，在实践应用在我们会依次执行下面三个方法

        public virtual void PreInitialize()

        {

        }

        /// <summary>

        /// This method is used to register dependencies for this module.

        /// </summary>

        public virtual void Initialize()

        {

        }

        /// <summary>

        /// This method is called lastly on application startup.

        /// </summary>

        public virtual void PostInitialize()

        {

        }

在一个应用中，ABP 框架调用了 Module 模块的一些指定的方法来进行启动和关闭模块的操作。我们可以重载这些方法来完成我们自己的任务。 ABP 框架通过依赖关系的顺序来调用这些方法，

假如：模块 A 依赖于模块 B,那么模块 B 要在模块 A 之前初始化，模块启动的方法顺序如下：

1) PreInitialize-B

2) PreInitialize-A

3) Initialize-B

4) Initialize-A

5) PostInitialize-B

6) PostInitialize-A

那么我们是怎么执行上面的方法的呢，方案在AbpModuleManager的InitializeModules方法中

        public virtual void InitializeModules()

        {

            LoadAll();

            var sortedModules = _modules.GetSortedModuleListByDependency();

            sortedModules.ForEach(module => module.Instance.PreInitialize());

            sortedModules.ForEach(module => module.Instance.Initialize());

            sortedModules.ForEach(module => module.Instance.PostInitialize());

        }

那么我们在自定义模块的时候是要重写上面三个方法的，有点像管道的事件，我们会依次执行这些事件，现在我们随便看个AbpEntityFrameworkModule模块它重写了其中两个

       public override void PreInitialize()

        {

            IocManager.AddConventionalRegistrar(new EntityFrameworkConventionalRegisterer());

        }

        public override void Initialize()

        {

            IocManager.RegisterAssemblyByConvention(Assembly.GetExecutingAssembly());

            IocManager.IocContainer.Register(

                Component.For(typeof (IDbContextProvider<>))

                    .ImplementedBy(typeof (UnitOfWorkDbContextProvider<>))

                    .LifestyleTransient()

                );

            RegisterGenericRepositories();

        }

一般的我们都要在Initialize方法中加上这句IocManager.RegisterAssemblyByConvention(Assembly.GetExecutingAssembly()); 也就是注册当前程序集，IOC初始化用的哦，好了，至此终于把ABP模块的思路讲完啦，大家可以配合ABP的文档的相关章节进行研究，希望对初学者有帮助。

参考文章：

https://github.com/ABPFrameWorkGroup/AbpDocument2Chinese

巴特西

ABP之模块分析

最新文章

热门文章