ABP模块设计

返回ABP系列

ABP是“ASP.NET Boilerplate Project (ASP.NET样板项目)”的简称。

ASP.NET Boilerplate是一个用最佳实践和流行技术开发现代WEB应用程序的新起点,它旨在成为一个通用的WEB应用程序框架和项目模板。

ABP的官方网站:http://www.aspnetboilerplate.com

ABP官方文档:http://www.aspnetboilerplate.com/Pages/Documents

Github上的开源项目:https://github.com/aspnetboilerplate

一、摘要

研究过orchard和nopcommerce的都应该知道模块概念,ABP的模块也和他们是一回事。实现原理也都一样:应用程序一般都是先定义模块接口,然后把模块编译的dll放到固定的目录中(ABP只能放到bin下),应用程序主程序通过加载那些实现了插件接口的dll来实现插件的使用。

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

nopcommerce插件实现可以到:ASP.NET MVC5 插件化机制简单实现了解下。

二、基本概念

下面的例子,我们开发一个可以在多个不同应用中被调用MybolgApplication模块,代码如下:

        public class MyBlogApplicationModule : AbpModule //定义
{
public override void Initialize() //初始化
{
IocManager.RegisterAssemblyByConvention(Assembly.GetExecutingAssembly());
//这行代码的写法基本上是不变的。它的作用是把当前程序集的特定类或接口注册到依赖注入容器中。
}
}

ABP框架会扫描所有的程序集,并且发现AbpModule类中所有已经导入的所有类,如果你已经创建了包含多个程序集的应用,对于ABP,我们的建议是为每一个程序集创建一个Module(模块)。

生命周期:

在一个应用中,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

下面是具体方法的说明:

PreInitialize 预初始化:当应用启动后,第一次会调用这个方法。在依赖注入注册之前,你可以在这个方法中指定自己的特别代码。举个例子吧:假如你创建了一个传统的登记类,那么你要先注册这个类(使用IocManager对登记类进行注册),你可以注册事件到IOC容器。

Initialize初始化:在这个方法中一般是来进行依赖注入的注册,一般我们通过IocManager.RegisterAssemblyByConvention这个方法来实现。如果你想实现自定义的依赖注入,那么请参考依赖注入的相关文档。

PostInitialize提交初始化:最后一个方法,这个方法用来解析依赖关系。

Shutdown关闭:当应用关闭以后,这个方法被调用。

模块依赖:

Abp框架会自动解析模块之间的依赖关系,但是我们还是建议你通过重载GetDependencies方法来明确的声明依赖关系。

[DependsOn(typeof(MyBlogCoreModule))]//通过注解来定义依赖关系
public class MyBlogApplicationModule : AbpModule
{
public override void Initialize()
{
IocManager.RegisterAssemblyByConvention(Assembly.GetExecutingAssembly());
}
}

例如上面的代码,我们就声明了MyBlogApplicationModule和MyBlogCoreModule的依赖关系(通过属性attribute),MyBlogApplicationModule这个应用模块依赖于MyBlogCoreModule核心模块,并且,MyBlogCoreModule核心模块会在MyBlogApplicationModule模块之前进行初始化。

自定义的模块方法:

我们自己定义的模块中可能有方法被其他依赖于当前模块的模块调用,下面的例子,假设模块2依赖于模块1,并且想在预初始化的时候调用模块1的方法。

public class MyModule1 : AbpModule
{
public override void Initialize() //初始化模块
{
IocManager.RegisterAssemblyByConvention(Assembly.GetExecutingAssembly());//这里,进行依赖注入的注册。
} public void MyModuleMethod1()
{
//这里写自定义的方法。
}
} [DependsOn(typeof(MyModule1))]
public class MyModule2 : AbpModule
{
private readonly MyModule1 _myModule1; public MyModule2(MyModule1 myModule1)
{
_myModule1 = myModule1;
} public override void PreInitialize()
{
_myModule1.MyModuleMethod1(); //调用MyModuleMethod1的方法。
} public override void Initialize()
{
IocManager.RegisterAssemblyByConvention(Assembly.GetExecutingAssembly());
}
}

就这样,就把模块1注入到了模块2,因此,模块2就能调用模块1的方法了。

三、基本原理

1、获取bin下全部dll

            /// <summary>
/// 获取bin下全部dll
/// </summary>
public List<Assembly> GetAllAssemblies()
{
var allReferencedAssemblies = BuildManager.GetReferencedAssemblies().Cast<Assembly>().ToList();
var dllFiles = Directory.GetFiles(HttpRuntime.AppDomainAppPath + "bin\\", "*.dll", SearchOption.TopDirectoryOnly).ToList();
return dllFiles.Select(dllFile => allReferencedAssemblies.FirstOrDefault(asm => AssemblyName.ReferenceMatchesDefinition(asm.GetName(), AssemblyName.GetAssemblyName(dllFile)))).Where(locatedAssembly => locatedAssembly != null).ToList();
}

2、判断是否继承了AbpModule接口

            /// <summary>
/// 判断与AbpModule的Types是否有关
/// </summary>
public static bool IsAbpModule(Type type)
{
return
type.IsClass &&
!type.IsAbstract &&
typeof(AbpModule).IsAssignableFrom(type);
}

3、循环相关的依赖,把他们填在到modules集合中

#region 循环相关的依赖,把他们填在到modules集合中
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)) continue;
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)) return list;
var dependsOnAttributes = moduleType.GetCustomAttributes(typeof(DependsOnAttribute), true).Cast<DependsOnAttribute>();
list.AddRange(dependsOnAttributes.SelectMany(dependsOnAttribute => dependsOnAttribute.DependedModuleTypes)); return list;
}
#endregion

4、控制反转

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using Abp.Configuration.Startup;
using Abp.Dependency;
using Castle.Core.Logging; namespace Abp.Modules
{
/// <summary>
/// This class is used to manage modules.
/// </summary>
internal class AbpModuleManager : IAbpModuleManager
{
public ILogger Logger { get; set; } private readonly AbpModuleCollection _modules; private readonly IIocManager _iocManager;
private readonly IModuleFinder _moduleFinder; public AbpModuleManager(IIocManager iocManager, IModuleFinder moduleFinder)
{
_modules = new AbpModuleCollection();
_iocManager = iocManager;
_moduleFinder = moduleFinder;
Logger = NullLogger.Instance;
} /// <summary>
/// 初始化模块
/// </summary>
public virtual void InitializeModules()
{
LoadAll(); //加载所有 var sortedModules = _modules.GetSortedModuleListByDependency();
//初始化Modules的事件
sortedModules.ForEach(module => module.Instance.PreInitialize());
sortedModules.ForEach(module => module.Instance.Initialize());
sortedModules.ForEach(module => module.Instance.PostInitialize());
}
/// <summary>
/// 关闭模块
/// </summary>
public virtual void ShutdownModules()
{
var sortedModules = _modules.GetSortedModuleListByDependency();
sortedModules.Reverse();
sortedModules.ForEach(sm => sm.Instance.Shutdown());
} /// <summary>
///
/// </summary>
private void LoadAll()
{
Logger.Debug("Loading Abp modules..."); var moduleTypes = AddMissingDependedModules(_moduleFinder.FindAll());
Logger.Debug("Found " + moduleTypes.Count + " ABP modules in total."); //注册到IOC容器
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中
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);
} EnsureKernelModuleToBeFirst(); SetDependencies(); Logger.DebugFormat("{0} modules loaded.", _modules.Count);
} /// <summary>
/// AbpKernelModule must be the first module
/// </summary>
private void EnsureKernelModuleToBeFirst()
{
var kernelModuleIndex = _modules.FindIndex(m => m.Type == typeof (AbpKernelModule));
if (kernelModuleIndex > 0)
{
var kernelModule = _modules[kernelModuleIndex];
_modules.RemoveAt(kernelModuleIndex);
_modules.Insert(0, kernelModule);
}
} private void SetDependencies()
{
foreach (var moduleInfo in _modules)
{
//Set dependencies according to assembly dependency
foreach (var referencedAssemblyName in moduleInfo.Assembly.GetReferencedAssemblies())
{
var referencedAssembly = Assembly.Load(referencedAssemblyName);
var dependedModuleList = _modules.Where(m => m.Assembly == referencedAssembly).ToList();
if (dependedModuleList.Count > 0)
{
moduleInfo.Dependencies.AddRange(dependedModuleList);
}
} //Set dependencies for defined DependsOnAttribute attribute(s).
foreach (var dependedModuleType in AbpModule.FindDependedModuleTypes(moduleInfo.Type))
{
var dependedModuleInfo = _modules.FirstOrDefault(m => m.Type == dependedModuleType);
if (dependedModuleInfo == null)
{
throw new AbpInitializationException("Could not find a depended module " + dependedModuleType.AssemblyQualifiedName + " for " + moduleInfo.Type.AssemblyQualifiedName);
} if ((moduleInfo.Dependencies.FirstOrDefault(dm => dm.Type == dependedModuleType) == null))
{
moduleInfo.Dependencies.Add(dependedModuleInfo);
}
}
}
} 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);
}
}
}
}
}

四、ABP底层如何描述Module

AbpModule:模块抽象类

AbpModuleInfo:模块信息

AbpModuleCollection:AbpModuleInfo的集合

IAbpModuleManager:模块管理接口

AbpModuleManager:模块管理类实现模块管理接口

IModuleFinder:负责找所有模块的接口

DefaultModuleFinder:实现IModuleFinder接口

DependsOnAttribute:用来定义ABP模块依赖其他模块

AbpModuleInfo用于封装AbpModule的基本信息。 AbpModuleCollection则是AbpModuleInfo的集合。

五、Module注册到ABP底层流程

Abp底层框架发现Module是从AbpBootstrapper在执行Initialize方法的时候开始的,该方法会调用IAbpModuleManager实例的InitializeModules方法,这个方法接着调用DefaultModuleFinder的FindAll方法(该方法用于过滤出AbpModule的assembly),而FindAll方法调用TypeFinder得到所有的assembly. 所以只要你定义的assembly中有一个继承至AbpModule的类,并且该assembly被引用到你的项目中,那么这个Module就可以说会被Abp底层框架集成了。

最后、加关注

ABP模块设计的更多相关文章

  1. 基于DDD的.NET开发框架 - ABP模块设计

    返回ABP系列 ABP是“ASP.NET Boilerplate Project (ASP.NET样板项目)”的简称. ASP.NET Boilerplate是一个用最佳实践和流行技术开发现代WEB应 ...

  2. abp模块生命周期设计思路剖析

    abp中将生命周期事件抽象为4个接口: //预初始化 public interface IOnPreApplicationInitialization { void OnPreApplicationI ...

  3. ABP(现代ASP.NET样板开发框架)系列之4、ABP模块系统

    点这里进入ABP系列文章总目录 基于DDD的现代ASP.NET开发框架--ABP系列之4.ABP模块系统 ABP是“ASP.NET Boilerplate Project (ASP.NET样板项目)” ...

  4. ABP分层设计

    ABP分层设计 一.为什么要分层 分层架构是所有架构的鼻祖,分层的作用就是隔离,不过,我们有时候有个误解,就是把层和程序集对应起来,就比如简单三层架构中,在你的解决方案中,一般会有三个程序集项目:XX ...

  5. ABP模块系统

    ABP模块系统 基于DDD的现代ASP.NET开发框架--ABP系列之4.ABP模块系统 ABP是“ASP.NET Boilerplate Project (ASP.NET样板项目)”的简称. ABP ...

  6. ABP+AdminLTE+Bootstrap Table权限管理系统第三节--abp分层体系,实体相关及ABP模块系统

    返回总目录:ABP+AdminLTE+Bootstrap Table权限管理系统一期 ABP模块系统 说了这么久,还没有详细说到abp框架,abp其实基于DDD(领域驱动设计)原则的细看分层如下: 再 ...

  7. ABP架构设计交流群-上海线下交流会的内容分享(有高清录像视频的链接)

    点这里进入ABP系列文章总目录 ABP架构设计交流群-7月18日上海线下交流会内容分享 因为最近工作特别忙,很久没有更新博客了,真对不起关注我博客和ABP系列文章的朋友! 原计划在7月11日举行的AB ...

  8. 解析大型.NET ERP系统 权限模块设计与实现

    权限模块是ERP系统的核心模块之一,完善的权限控制机制给系统增色不少.总结我接触过的权限模块,以享读者. 1 权限的简明定义 ERP权限管理用一句简单的话来说就是:谁 能否 做 那些 事. 文句 含义 ...

  9. .NET 缓存模块设计

    上一篇谈了我对缓存的概念,框架上的理解和看法,这篇承接上篇讲讲我自己的缓存模块设计实践. 基本的缓存模块设计 最基础的缓存模块一定有一个统一的CacheHelper,如下: public interf ...

随机推荐

  1. 不老的新丁 Python何以让人着迷

    Python是一门美丽的语言.它简单易学,跨平台,而且运转良好.达成了许多Java一直求索的技术目标.一言以蔽之就是:其他的语言是与时代同 步,而Python则是未雨绸缪,而且计划得颇为出色.当然,这 ...

  2. 多线程之线程通信条件Condition

    Condition是Locks锁下的还有一种线程通信之间唤醒.堵塞的实现.它以下的await,和signal可以实现Object下的wait,notify和notifyAll的所有功能,除此之外改监视 ...

  3. CString——Left、Right、Find、ReverseFind

    CString--Left.Right.Find.ReverseFind http://hi.baidu.com/shawmar/item/08b30afb0f32d46f3c1485ec CStri ...

  4. 离散傅立叶变换与快速傅立叶变换(DFT与FFT)

    自从去年下半年接触三维重构以来,听得最多的词就是傅立叶变换,后来了解到这个变换在图像处理里面也是重点中的重点. 本身自己基于高数知识的理解是傅立叶变换是将一个函数变为一堆正余弦函数的和的变换.而图像处 ...

  5. ZOJ 3594 年份水题 【注意:没有0年】

    #include<iostream> #include<cstdio> #include<cstring> #include<algorithm> #i ...

  6. Windows Phone 8初学者开发的翻译终于过半

    从2013年7月19日开始,到2013年12月9日,一共花了143天时间完成了18篇Windows Phone 8初学者开发的翻译,还剩下17篇文章需要翻译,看到了完成的希望! I love Wind ...

  7. 四个流行的Java连接池之Proxool篇

    Proxool是一个JavaSQL Driver驱动程序,提供了对你选择的其它类型的驱动程序的连接池封装.可以非常简单的移植到现存的代码中.完全可配置.快速,成熟,健壮.可以透明地为你现存的JDBC驱 ...

  8. Oracle、DB2、MySql、SQLServer JDBC驱动

    四种数据库JDBC驱动,还列出了连接的Class驱动名和Url Pattern,DB2包括Type 2.Type 3和Type 4三种模式.注意驱动包名称的大小写. Oralce连接驱动包名和URL ...

  9. 怎样在Ubuntu中使用条件布局

    我们知道现代手机能够随着手持的方位发生改变而使得手机的方位也随着发生改变.对有些应用来说,我们也希望手机的布局也能尾随发生变化.第二种情况是当我们的应用安装到不同屏幕尺寸的平台上,我们希望我们的布局会 ...

  10. ASP.NET - 页面传值 Request.QuerString[].ToString();

    public partial class WebForm2 : System.Web.UI.Page { BLL.CategoryBLL categorybll = new CategoryBLL() ...