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);
    }
}