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