ABP VNext 系列：框架启动流程以及依赖注入原理和源码分析
简单介绍 ABP VNext
Github 地址：https://github.com/abpframework/abp
官网文档地址：https://abp.io/docs/latest
官网：https://abp.io/
- ABP VNext 框架是一个基于 ASP.NET Core 的完整基础架构，也就是我们现在称的 ABP 框架，它遵循软件开发最佳实践和最新技术来创建现代 Web 应用程序和 API。
- ABP vNext 是 ABP 框架作者所发起的新项目，ABP vNext 框架核心库比 ABP 框架更加精简，因为将原有许多的组件从其核心库抽离成独立的组件。这样开发人员可以更加灵活的选择自己需要的功能进行集成，使项目远离臃肿的库。
- ABP 提供了基于领域驱动设计原则和模式的完整、模块化和分层的软件架构。它还提供了实现此架构所需的基础架构和指导。
- ABP 框架提供了许多功能来更轻松地实现实际场景，例如事件总线、后台作业系统、审计日志、BLOB 存储、数据播种、数据过滤等。
框架启动流程
模块化文档：https://abp.io/docs/latest/framework/architecture/modularity/basics
下载源码：https://github.com/abpframework/abp/tree/dev/framework
参考构建一个新 ASP.NET Core MVC 的项目：https://abp.io/docs/latest/get-started/empty-aspnet-core-application
public class Program
{
public static async Task Main(string[] args)
{
var builder = WebApplication.CreateBuilder(args);
builder.Host.UseAutofac(); //推荐使用Autofac作为依赖注入框架
//注入ABP相关服务
await builder.Services.AddApplicationAsync<MCodeAbpWebModule>();
var app = builder.Build();
//初始化程序
await app.InitializeApplicationAsync();
await app.RunAsync();
}
}
/// <summary>
/// 需要什么模块引入什么模块，才会注入
/// </summary>
[DependsOn(
typeof(AbpAspNetCoreMvcModule),
typeof(AbpSwashbuckleModule),
typeof(MCodeAbpApplicationModule),
typeof(AbpAutofacModule)
)]
public class MCodeAbpWebModule : AbpModule
{
/// <summary>
/// 将你的服务添加到依赖注入系统并配置其他模块的
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override Task ConfigureServicesAsync(ServiceConfigurationContext context)
{
var service = context.Services;
//设置api格式
service.AddControllers();
//动态Api
Configure<AbpAspNetCoreMvcOptions>(options =>
{
options.ConventionalControllers.Create(typeof(MCodeAbpApplicationModule).Assembly, options => options.RemoteServiceName = "v1");
//统一前缀
options.ConventionalControllers.ConventionalControllerSettings.ForEach(x => x.RootPath = "api/app");
});
///配置 Swagger
service.AddAbpSwaggerGen(options =>
{
var serviceProvider = service.BuildServiceProvider();
var mvcOptions = serviceProvider.GetRequiredService<IOptions<AbpAspNetCoreMvcOptions>>();
var mvcSettings = mvcOptions.Value.ConventionalControllers.ConventionalControllerSettings.DistinctBy(x => x.RemoteServiceName);
options.SwaggerDoc("v1", new OpenApiInfo { Title = "mcode.abp.api", Version = "v1", Description = "mcode.abp.api" });
// 根据分组名称过滤 API 文档(必须) *****
options.DocInclusionPredicate((docName, apiDesc) =>
{
if (apiDesc.ActionDescriptor is ControllerActionDescriptor controllerActionDescriptor)
{
var settingOrNull = mvcSettings.Where(x => x.Assembly == controllerActionDescriptor.ControllerTypeInfo.Assembly).FirstOrDefault();
if (settingOrNull is not null)
{
return docName == settingOrNull.RemoteServiceName;
}
}
return false;
});
//配置模型标识，默认type.Name,名称一样，不同明明空间会报错，所以改成FullName,加上命名空间区分
options.CustomSchemaIds(type => type.FullName);
});
return Task.CompletedTask;
}
/// <summary>
/// 在应用程序启动时执行代码
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override Task OnApplicationInitializationAsync(ApplicationInitializationContext context)
{
var app = context.GetApplicationBuilder();
app.UseStaticFiles();
app.UseRouting();
app.UseSwagger();
app.UseAbpSwaggerUI(c =>
{
c.SwaggerEndpoint("/swagger/v1/swagger.json", "mcode.abp.api");
});
app.UseConfiguredEndpoints();
return Task.CompletedTask;
}
}
public class MCodeAbpApplicationModule : AbpModule
{
}
/// <summary>
///扩展示例
/// </summary>
[Route("[controller]/[action]")]
public class TestService : ApplicationService
{
/// <summary>
/// 动态Api
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
[HttpGet]
public string GetHelloWorld(string? name)
{
return name ?? "HelloWord";
}
}
源码分析
替换 IOC 容器
通过 UseServiceProviderFactory() 方法 ，构建 Abp 自定义的 Autofac 容器工厂，实际上就是做了一层包装
public static class AbpAutofacHostBuilderExtensions
{
public static IHostBuilder UseAutofac(this IHostBuilder hostBuilder)
{
//初始化AutoFac容器构建对象
var containerBuilder = new ContainerBuilder();
return hostBuilder.ConfigureServices((_, services) =>
{
services.AddObjectAccessor(containerBuilder);
})
//注册Abp自定义的Autofac容器工厂
.UseServiceProviderFactory(new AbpAutofacServiceProviderFactory(containerBuilder));
}
}
添加 ABP 应用程序
通过 AbpApplicationFactory 类工厂创建启动模块程序
public async static Task<IAbpApplicationWithExternalServiceProvider> AddApplicationAsync<TStartupModule>(
[NotNull] this IServiceCollection services,
Action<AbpApplicationCreationOptions>? optionsAction = null)
where TStartupModule : IAbpModule
{
return await AbpApplicationFactory.CreateAsync<TStartupModule>(services, optionsAction);
}
/// <summary>
/// 通过 AbpApplicationFactory 创建 ABP 应用程序
/// </summary>
/// <typeparam name="TStartupModule"></typeparam>
/// <param name="services"></param>
/// <param name="optionsAction"></param>
/// <returns></returns>
public async static Task<IAbpApplicationWithExternalServiceProvider> CreateAsync<TStartupModule>(
[NotNull] IServiceCollection services,
Action<AbpApplicationCreationOptions>? optionsAction = null)
where TStartupModule : IAbpModule
{
var app = Create(typeof(TStartupModule), services, options =>
{
options.SkipConfigureServices = true;
optionsAction?.Invoke(options);
});
//调用配置服务
await app.ConfigureServicesAsync();
return app;
}
创建 ABP 外部服务提供者
AbpApplicationWithExternalServiceProvider 中构造方法只做了了一件事，就是添加自己到服务中去。
核心是继承了 AbpApplicationBase 基类,实例化后会调用基类的构造方法
/// <summary>
/// 创建 ABP 外部服务提供者（实例化应用程序基类）
/// </summary>
/// <param name="startupModuleType"></param>
/// <param name="services"></param>
/// <param name="optionsAction"></param>
/// <returns></returns>
public static IAbpApplicationWithExternalServiceProvider Create(
[NotNull] Type startupModuleType,
[NotNull] IServiceCollection services,
Action<AbpApplicationCreationOptions>? optionsAction = null)
{
//会实例化ABP应用程序基类
return new AbpApplicationWithExternalServiceProvider(startupModuleType, services, optionsAction);
}
初始化 ABP 程序基类
模块的初始化动作是在 AbpApplicationBase 基类开始的，在该基类当中除了注入模块相关的基础设施以外。
还定义了模块的初始化方法，即 LoadModules() 方法，在该方法内部是调用的 IModuleLoader 去执行具体的加载操作
/// <summary>
/// 初始化 Abp 程序
/// </summary>
/// <param name="startupModuleType"></param>
/// <param name="services"></param>
/// <param name="optionsAction"></param>
internal AbpApplicationBase(
[NotNull] Type startupModuleType,
[NotNull] IServiceCollection services,
Action<AbpApplicationCreationOptions>? optionsAction)
{
Check.NotNull(startupModuleType, nameof(startupModuleType));
Check.NotNull(services, nameof(services));
StartupModuleType = startupModuleType;
Services = services;
services.TryAddObjectAccessor<IServiceProvider>();
var options = new AbpApplicationCreationOptions(services);
//将Services添加到配置中去
optionsAction?.Invoke(options);
//获取应用程序名称
ApplicationName = GetApplicationName(options);
//添加当前对象为各种服务实例
services.AddSingleton<IAbpApplication>(this);
services.AddSingleton<IApplicationInfoAccessor>(this);
services.AddSingleton<IModuleContainer>(this);
//添加环境变量
services.AddSingleton<IAbpHostEnvironment>(new AbpHostEnvironment()
{
EnvironmentName = options.Environment
});
//添加日志、选项等
services.AddCoreServices();
//添加核心Abp服务，以及模块的四个应用程序生命周期
services.AddCoreAbpServices(this, options);
//读取所有的模块，并按照预加载、初始化、初始化完成的顺序执行其生命周期方法
Modules = LoadModules(services, options);
//默认为true,不执行
if (!options.SkipConfigureServices)
{
ConfigureServices();
}
}
添加核心 ABP 服务
AddCoreServices() 方法中是添加包括常规的日志、选项、本地化。
AddCoreAbpServices() 方法则是 添加 Abp 的核心服务，包括各种读取器，配置
/// <summary>
/// 添加核心服务
/// </summary>
/// <param name="services"></param>
internal static void AddCoreServices(this IServiceCollection services)
{
//添加选项
services.AddOptions();
//添加日志
services.AddLogging();
//添加本地化
services.AddLocalization();
}
/// <summary>
/// 添加核心ABP服务
/// </summary>
/// <param name="services"></param>
/// <param name="abpApplication"></param>
/// <param name="applicationCreationOptions"></param>
internal static void AddCoreAbpServices(this IServiceCollection services,
IAbpApplication abpApplication,
AbpApplicationCreationOptions applicationCreationOptions)
{
var moduleLoader = new ModuleLoader();
var assemblyFinder = new AssemblyFinder(abpApplication);
var typeFinder = new TypeFinder(assemblyFinder);
if (!services.IsAdded<IConfiguration>())
{
services.ReplaceConfiguration(
ConfigurationHelper.BuildConfiguration(
applicationCreationOptions.Configuration
)
);
}
//添加各种读取器和查找器
services.TryAddSingleton<IModuleLoader>(moduleLoader);
services.TryAddSingleton<IAssemblyFinder>(assemblyFinder);
services.TryAddSingleton<ITypeFinder>(typeFinder);
services.TryAddSingleton<IInitLoggerFactory>(new DefaultInitLoggerFactory());
//添加 AbpApplication所在程序集的类型
services.AddAssemblyOf<IAbpApplication>();
services.AddTransient(typeof(ISimpleStateCheckerManager<>), typeof(SimpleStateCheckerManager<>));
//配置生命周期选项
services.Configure<AbpModuleLifecycleOptions>(options =>
{
options.Contributors.Add<OnPreApplicationInitializationModuleLifecycleContributor>();
options.Contributors.Add<OnApplicationInitializationModuleLifecycleContributor>();
options.Contributors.Add<OnPostApplicationInitializationModuleLifecycleContributor>();
options.Contributors.Add<OnApplicationShutdownModuleLifecycleContributor>();
});
}
读取模块
进入 IModuleLoader 的默认实现 ModuleLoader，在它的 LoadModules() 方法中，基本逻辑如下：
扫描当前应用程序的所有模块类，并构建模块描述对象。
基于模块描述对象，使用拓扑排序算法来按照模块的依赖性进行排序。
排序完成之后，遍历排序完成的模块描述对象，依次执行它们的三个生命周期方法。
protected virtual IReadOnlyList<IAbpModuleDescriptor> LoadModules(IServiceCollection services, AbpApplicationCreationOptions options)
{
//通过ModelLoader实例读取模块，LoadModules的时候会将实例添加到容器中
return services
.GetSingletonInstance<IModuleLoader>()
.LoadModules(
services,
StartupModuleType,
options.PlugInSources
);
}
/// <summary>
/// 读取模块
/// </summary>
/// <param name="services"></param>
/// <param name="startupModuleType"></param>
/// <param name="plugInSources"></param>
/// <returns></returns>
public IAbpModuleDescriptor[] LoadModules(
IServiceCollection services,
Type startupModuleType,
PlugInSourceList plugInSources)
{
Check.NotNull(services, nameof(services));
Check.NotNull(startupModuleType, nameof(startupModuleType));
Check.NotNull(plugInSources, nameof(plugInSources));
//获取模块说明
var modules = GetDescriptors(services, startupModuleType, plugInSources);
//排序
modules = SortByDependency(modules, startupModuleType);
return modules.ToArray();
}
/// <summary>
/// 获取模块说明
/// </summary>
/// <param name="services"></param>
/// <param name="startupModuleType"></param>
/// <param name="plugInSources"></param>
/// <returns></returns>
private List<IAbpModuleDescriptor> GetDescriptors(
IServiceCollection services,
Type startupModuleType,
PlugInSourceList plugInSources)
{
var modules = new List<AbpModuleDescriptor>();
//查找Module
FillModules(modules, services, startupModuleType, plugInSources);
//添加到当前模块描述对象的 Dependencies 属性
SetDependencies(modules);
return modules.Cast<IAbpModuleDescriptor>().ToList();
}
/// <summary>
/// 查找所有的模块
/// </summary>
/// <param name="modules"></param>
/// <param name="services"></param>
/// <param name="startupModuleType"></param>
/// <param name="plugInSources"></param>
protected virtual void FillModules(
List<AbpModuleDescriptor> modules,
IServiceCollection services,
Type startupModuleType,
PlugInSourceList plugInSources)
{
var logger = services.GetInitLogger<AbpApplicationBase>();
//查找到所有的模块
//All modules starting from the startup module
foreach (var moduleType in AbpModuleHelper.FindAllModuleTypes(startupModuleType, logger))
{
//创建模块说明并添加到容器中去
modules.Add(CreateModuleDescriptor(services, moduleType));
}
//Plugin modules
foreach (var moduleType in plugInSources.GetAllModules(logger))
{
if (modules.Any(m => m.Type == moduleType))
{
continue;
}
modules.Add(CreateModuleDescriptor(services, moduleType, isLoadedAsPlugIn: true));
}
}
配置服务(注入上下文、执行其生命周期方法)
创建完 Abp 应用程序后会调用 ConfigureServicesAsync() 方法 ,
会执行每个模块中的：ConfigureServices()、PreConfigureServices()、PostConfigureServices() 方法等
/// <summary>
/// 配置服务
/// </summary>
/// <returns></returns>
/// <exception cref="AbpInitializationException"></exception>
public virtual async Task ConfigureServicesAsync()
{
CheckMultipleConfigureServices();
//将服务配置上下文对象添加到容器中
var context = new ServiceConfigurationContext(Services);
Services.AddSingleton(context);
//遍历所有的容器中的模块，并指定上下文对象
foreach (var module in Modules)
{
if (module.Instance is AbpModule abpModule)
{
abpModule.ServiceConfigurationContext = context;
}
}
//遍历执行模块中PreConfigureServicesAsync方法（ConfigureServices之前执行）
foreach (var module in Modules.Where(m => m.Instance is IPreConfigureServices))
{
try
{
await ((IPreConfigureServices)module.Instance).PreConfigureServicesAsync(context);
}
catch (Exception ex)
{
throw new AbpInitializationException($"An error occurred during {nameof(IPreConfigureServices.PreConfigureServicesAsync)} phase of the module {module.Type.AssemblyQualifiedName}. See the inner exception for details.", ex);
}
}
var assemblies = new HashSet<Assembly>();
////遍历模块，将所有的模块中需要注入的进行注入
foreach (var module in Modules)
{
if (module.Instance is AbpModule abpModule)
{
if (!abpModule.SkipAutoServiceRegistration)
{
foreach (var assembly in module.AllAssemblies)
{
if (!assemblies.Contains(assembly))
{
Services.AddAssembly(assembly);
assemblies.Add(assembly);
}
}
}
}
try
{
//执行模块实例中的方法
await module.Instance.ConfigureServicesAsync(context);
}
catch (Exception ex)
{
throw new AbpInitializationException($"An error occurred during {nameof(IAbpModule.ConfigureServicesAsync)} phase of the module {module.Type.AssemblyQualifiedName}. See the inner exception for details.", ex);
}
}
//遍历执行模块中PostConfigureServicesAsync方法（ConfigureServices之后执行）
foreach (var module in Modules.Where(m => m.Instance is IPostConfigureServices))
{
try
{
await ((IPostConfigureServices)module.Instance).PostConfigureServicesAsync(context);
}
catch (Exception ex)
{
throw new AbpInitializationException($"An error occurred during {nameof(IPostConfigureServices.PostConfigureServicesAsync)} phase of the module {module.Type.AssemblyQualifiedName}. See the inner exception for details.", ex);
}
}
//遍历所有的容器中的模块，并清空上下文对象
foreach (var module in Modules)
{
if (module.Instance is AbpModule abpModule)
{
abpModule.ServiceConfigurationContext = null!;
}
}
_configuredServices = true;
TryToSetEnvironment(Services);
}
组件自动注册源码分析
ABP 提供了三种接口：ISingletonDependency 和 ITransientDependency 、IScopedDependency 接口的方式进行注入
方便我们的类型/组件自动注册，这三种接口分别对应了对象的 单例、瞬时、范围 生命周期。
只要任何类型/接口实现了以上任意接口，ABP vNext 就会在系统启动时候，将这些对象注册到 IoC 容器当中
也可以通过 DependencyAttribute 特性 去标记服务的类型，指定服务的生命周期
在模块系统调用模块的 ConfigureServicesAsync() 的时候，就会有一个 services.AddAssembly()方法，
他会将模块的所属的程序集传入
//ConfigureServices
foreach (var module in Modules)
{
if (module.Instance is AbpModule abpModule)
{
//是否跳过服务的自动注册，默认为 false
if (!abpModule.SkipAutoServiceRegistration)
{
foreach (var assembly in module.AllAssemblies)
{
if (!assemblies.Contains(assembly))
{
//注入当前程序集
Services.AddAssembly(assembly);
assemblies.Add(assembly);
}
}
}
}
try
{
module.Instance.ConfigureServices(context);
}
catch (Exception ex)
{
throw new AbpInitializationException($"An error occurred during {nameof(IAbpModule.ConfigureServices)} phase of the module {module.Type.AssemblyQualifiedName}. See the inner exception for details.", ex);
}
}
通过获取规则注册器进行注册，Abp 框架中自带默认的注册器 DefaultConventionalRegistrar ,也可以自定义注册器
通过实现 ConventionalRegistrarBase 抽象类去自定义
public static IServiceCollection AddAssembly(this IServiceCollection services, Assembly assembly)
{
///获得所有注册器，然后调用注册器的 AddAssembly 方法注册类型。
foreach (var registrar in services.GetConventionalRegistrars())
{
registrar.AddAssembly(services, assembly);
}
return services;
}
//抽象基类
public abstract class ConventionalRegistrarBase : IConventionalRegistrar
{
/// <summary>
///
/// </summary>
/// <param name="services"></param>
/// <param name="assembly"></param>
public virtual void AddAssembly(IServiceCollection services, Assembly assembly)
{
//获得程序集内的所有类型，过滤掉抽象类和泛型类型。
var types = AssemblyHelper
.GetAllTypes(assembly)
.Where(
type => type != null &&
type.IsClass &&
!type.IsAbstract &&
!type.IsGenericType
).ToArray();
AddTypes(services, types);
}
//添加类型
public virtual void AddTypes(IServiceCollection services, params Type[] types)
{
foreach (var type in types)
{
AddType(services, type);
}
}
public abstract void AddType(IServiceCollection services, Type type);
}
- 通过的默认注册器进行注册
public class DefaultConventionalRegistrar : ConventionalRegistrarBase
{
/// <summary>
/// 添加类型
/// </summary>
/// <param name="services"></param>
/// <param name="type"></param>
public override void AddType(IServiceCollection services, Type type)
{
//如果标记了：DisableConventionalRegistrationAttribute特性的，不进行注入
if (IsConventionalRegistrationDisabled(type))
{
return;
}
//获取Dependency依赖特性
var dependencyAttribute = GetDependencyAttributeOrNull(type);
//获取生命周期
var lifeTime = GetLifeTimeOrNull(type, dependencyAttribute);
if (lifeTime == null)
{
return;
}
//转成服务标识
var exposedServiceAndKeyedServiceTypes = GetExposedKeyedServiceTypes(type).Concat(GetExposedServiceTypes(type).Select(t => new ServiceIdentifier(t))).ToList();
//生成服务
TriggerServiceExposing(services, type, exposedServiceAndKeyedServiceTypes);
foreach (var exposedServiceType in exposedServiceAndKeyedServiceTypes)
{
var allExposingServiceTypes = exposedServiceType.ServiceKey == null
? exposedServiceAndKeyedServiceTypes.Where(x => x.ServiceKey == null).ToList()
: exposedServiceAndKeyedServiceTypes.Where(x => x.ServiceKey?.ToString() == exposedServiceType.ServiceKey?.ToString()).ToList();
//创建服务描述
var serviceDescriptor = CreateServiceDescriptor(
type,
exposedServiceType.ServiceKey,
exposedServiceType.ServiceType,
allExposingServiceTypes,
lifeTime.Value
);
if (dependencyAttribute?.ReplaceServices == true)
{
services.Replace(serviceDescriptor);
}
else if (dependencyAttribute?.TryRegister == true)
{
services.TryAdd(serviceDescriptor);
}
else
{
services.Add(serviceDescriptor);
}
}
}
}
- 从
GetLifeTimeOrNull方法中 获取生命周期
/// <summary>
/// 获取生命周期
/// </summary>
/// <param name="type"></param>
/// <param name="dependencyAttribute"></param>
/// <returns></returns>
protected virtual ServiceLifetime? GetLifeTimeOrNull(Type type, DependencyAttribute? dependencyAttribute)
{
// 特性中设置了生命周期或者继承了接口
return dependencyAttribute?.Lifetime ?? GetServiceLifetimeFromClassHierarchy(type) ?? GetDefaultLifeTimeOrNull(type);
}
/// <summary>
/// 从接口中获取生命周期
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
protected virtual ServiceLifetime? GetServiceLifetimeFromClassHierarchy(Type type)
{
if (typeof(ITransientDependency).GetTypeInfo().IsAssignableFrom(type))
{
return ServiceLifetime.Transient;
}
if (typeof(ISingletonDependency).GetTypeInfo().IsAssignableFrom(type))
{
return ServiceLifetime.Singleton;
}
if (typeof(IScopedDependency).GetTypeInfo().IsAssignableFrom(type))
{
return ServiceLifetime.Scoped;
}
return null;
}
初始化 ABP 应用程序
- 通过
await app.InitializeApplicationAsync();方法会初始化应用程序，然后执行每一个模块中的生命周期的方法
/// <summary>
/// 异步初始化 ABP 应用程序
/// </summary>
/// <param name="app"></param>
/// <returns></returns>
public async static Task InitializeApplicationAsync([NotNull] this IApplicationBuilder app)
{
Check.NotNull(app, nameof(app));
app.ApplicationServices.GetRequiredService<ObjectAccessor<IApplicationBuilder>>().Value = app;
var application = app.ApplicationServices.GetRequiredService<IAbpApplicationWithExternalServiceProvider>();
var applicationLifetime = app.ApplicationServices.GetRequiredService<IHostApplicationLifetime>();
//注册程序生命周期停止事件
applicationLifetime.ApplicationStopping.Register(() =>
{
//执行 Abp程序中的 ShutdownAsync 方法， 会调用每个模块中的 ShutdownAsync 方法
AsyncHelper.RunSync(() => application.ShutdownAsync());
});
//释放 Abp 应用
applicationLifetime.ApplicationStopped.Register(() =>
{
application.Dispose();
});
// 执行 初始化 Abp 方法 ，初始化 每个模块，执行每一个模块中的 InitializeAsync 方法
await application.InitializeAsync(app.ApplicationServices);
}
- 初始化每一个模块生命周期方法
/// <summary>
/// 设置服务提供者
/// </summary>
/// <param name="serviceProvider"></param>
protected virtual void SetServiceProvider(IServiceProvider serviceProvider)
{
ServiceProvider = serviceProvider;
ServiceProvider.GetRequiredService<ObjectAccessor<IServiceProvider>>().Value = ServiceProvider;
}
/// <summary>
/// 初始化模块
/// </summary>
/// <returns></returns>
protected virtual async Task InitializeModulesAsync()
{
using (var scope = ServiceProvider.CreateScope())
{
WriteInitLogs(scope.ServiceProvider);
await scope.ServiceProvider
.GetRequiredService<IModuleManager>() //初始化模块
.InitializeModulesAsync(new ApplicationInitializationContext(scope.ServiceProvider));
}
}
/// <summary>
/// 初始化模块
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
/// <exception cref="AbpInitializationException"></exception>
public virtual async Task InitializeModulesAsync(ApplicationInitializationContext context)
{
// 原先在 AddCoreAbpServices() 方法中 配置的 生命周期，
foreach (var contributor in _lifecycleContributors)
{
foreach (var module in _moduleContainer.Modules)
{
try
{
//执行每个生命周期(加载之前、加载中、加载之后)中的 初始化方法
await contributor.InitializeAsync(context, module.Instance);
}
catch (Exception ex)
{
throw new AbpInitializationException($"An error occurred during the initialize {contributor.GetType().FullName} phase of the module {module.Type.AssemblyQualifiedName}: {ex.Message}. See the inner exception for details.", ex);
}
}
}
_logger.LogInformation("Initialized all ABP modules.");
}
- 四个生命周期
OnApplicationInitializationModuleLifecycleContributor、
OnPreApplicationInitializationModuleLifecycleContributor、
OnPostApplicationInitializationModuleLifecycleContributor
OnApplicationShutdownModuleLifecycleContributor中的方法，实际就是调用到具体模块中的生命周期各个方法
public class OnApplicationInitializationModuleLifecycleContributor : ModuleLifecycleContributorBase
{
public async override Task InitializeAsync(ApplicationInitializationContext context, IAbpModule module)
{
if (module is IOnApplicationInitialization onApplicationInitialization)
{
await onApplicationInitialization.OnApplicationInitializationAsync(context);
}
}
public override void Initialize(ApplicationInitializationContext context, IAbpModule module)
{
(module as IOnApplicationInitialization)?.OnApplicationInitialization(context);
}
}
public class OnApplicationShutdownModuleLifecycleContributor : ModuleLifecycleContributorBase
{
public async override Task ShutdownAsync(ApplicationShutdownContext context, IAbpModule module)
{
if (module is IOnApplicationShutdown onApplicationShutdown)
{
await onApplicationShutdown.OnApplicationShutdownAsync(context);
}
}
public override void Shutdown(ApplicationShutdownContext context, IAbpModule module)
{
(module as IOnApplicationShutdown)?.OnApplicationShutdown(context);
}
}
public class OnPreApplicationInitializationModuleLifecycleContributor : ModuleLifecycleContributorBase
{
public async override Task InitializeAsync(ApplicationInitializationContext context, IAbpModule module)
{
if (module is IOnPreApplicationInitialization onPreApplicationInitialization)
{
await onPreApplicationInitialization.OnPreApplicationInitializationAsync(context);
}
}
public override void Initialize(ApplicationInitializationContext context, IAbpModule module)
{
(module as IOnPreApplicationInitialization)?.OnPreApplicationInitialization(context);
}
}
public class OnPostApplicationInitializationModuleLifecycleContributor : ModuleLifecycleContributorBase
{
public async override Task InitializeAsync(ApplicationInitializationContext context, IAbpModule module)
{
if (module is IOnPostApplicationInitialization onPostApplicationInitialization)
{
await onPostApplicationInitialization.OnPostApplicationInitializationAsync(context);
}
}
public override void Initialize(ApplicationInitializationContext context, IAbpModule module)
{
(module as IOnPostApplicationInitialization)?.OnPostApplicationInitialization(context);
}
}
微信：17873041739
