ASP.NET Core模組化前後端分離快速開發框架介紹之4、模組化實現思路

oldli發表於2019-05-29
ASP.NET後端框架

原始碼

GitHub：https://github.com/iamoldli/NetModular

演示地址

地址：http://129.211.40.240:6220
賬戶：admin
密碼：admin

前端框架演示地址(臨時)

地址：http://progqx5cu.bkt.clouddn.com/skins/index.html#/
賬戶：admin
密碼：admin

目錄

1、開篇
2、快速建立一個業務模組
3、資料訪問模組介紹
4、模組化實現思路

獲取官方原始碼

為了方便檢視原始碼，我們先獲取下官方的原始碼

下載 AspNetCore 原始碼

git clone --recursive https://github.com/aspnet/AspNetCore

下載 Extensions 原始碼

git clone https://github.com/aspnet/Extensions.git

ASP.NET Core控制器的載入機制

參考文件：ASP.NET Core 中的應用程式部件

在ASP.NET Core中通過應用程式部件ApplicationPart來發現控制器、檢視元件或標記幫助程式等 MVC 功能，應用程式部件是由ApplicationPartManager類來管理。當呼叫AddMvc或者AddMvcCore方法新增MVC相關功能時，ASP.NET Core內部會建立ApplicationPartManager的例項，然後以入口程式集為起點，查詢其依賴項樹中的所有非官方包的程式集，並新增到它的ApplicationParts屬性中，最後將ApplicationPartManager的例項以單例模式注入到容器中。下面是相關的原始碼：

原始碼路徑：AspNetCore\src\Mvc.Core\src\DependencyInjection\MvcCoreServiceCollectionExtensions.cs

public static IMvcCoreBuilder AddMvcCore(this IServiceCollection services)
{
    if (services == null)
    {
        throw new ArgumentNullException(nameof(services));
    }

    var partManager = GetApplicationPartManager(services);
    //單例模式注入ApplicationPartManager
    services.TryAddSingleton(partManager);

    ConfigureDefaultFeatureProviders(partManager);
    ConfigureDefaultServices(services);
    AddMvcCoreServices(services);

    var builder = new MvcCoreBuilder(services, partManager);

    return builder;
}

//獲取ApplicationPartManager例項
private static ApplicationPartManager GetApplicationPartManager(IServiceCollection services)
{
    var manager = GetServiceFromCollection<ApplicationPartManager>(services);
    if (manager == null)
    {
        manager = new ApplicationPartManager();

        var environment = GetServiceFromCollection<IHostingEnvironment>(services);
        var entryAssemblyName = environment?.ApplicationName;
        if (string.IsNullOrEmpty(entryAssemblyName))
        {
            return manager;
        }

       
        manager.PopulateDefaultParts(entryAssemblyName);
    }

    return manager;
}

原始碼路徑：AspNetCore\src\Mvc.Core\src\ApplicationParts\ApplicationPartManager.cs

internal void PopulateDefaultParts(string entryAssemblyName)
{
    var entryAssembly = Assembly.Load(new AssemblyName(entryAssemblyName));
    var assembliesProvider = new ApplicationAssembliesProvider();

    //載入入口程式集的依賴項樹中的所有非官方包的依賴程式集
    var applicationAssemblies = assembliesProvider.ResolveAssemblies(entryAssembly);

    foreach (var assembly in applicationAssemblies)
    {
        var partFactory = ApplicationPartFactory.GetApplicationPartFactory(assembly);
        foreach (var part in partFactory.GetApplicationParts(assembly))
        {
            ApplicationParts.Add(part);
        }
    }
}

因為我們的所有模組都是通過nuget包安裝的，所以在編譯時會自動引入到依賴項樹中，也就是說，我們不需要手動載入模組中的程式集。

對於在編譯時未引用的程式集，我們可以通過應用程式部件來手動載入

// create an assembly part from a class's assembly
var assembly = typeof(Startup).GetTypeInfo().Assembly;
services.AddMvc()
    .AddApplicationPart(assembly);

// OR
var assembly = typeof(Startup).GetTypeInfo().Assembly;
var part = new AssemblyPart(assembly);
services.AddMvc()
    .ConfigureApplicationPartManager(apm => apm.ApplicationParts.Add(part));

模組的載入機制

NetModular的規則是在專案啟動時，查詢程式根目錄下的modules目錄，該目錄專門用於儲存所有模組的資訊，它的結構如下：

結構圖

modules目錄下的每個子目錄表示一個模組，每個子目錄裡面都有一個module.json檔案，該檔案用於描述模組資訊，其結構如下：

{"Id": "Admin","Name":"許可權管理","Version":"1.0.0"}
  • Note：module.json檔案是在模組編譯的時候自動生成並打包進Nuget包，當安裝模組時會自動包含在專案中。這裡用到了MSBuild，有興趣的可以看看。 *

以下是生成module.json檔案對應的配置資訊

<Project>

  <PropertyGroup>
    <ModulesDir>modules\$(Id)</ModulesDir>
    <ModuleInfo>{"Id": "$(Id)","Name":"$(Name)","Version":"$(Version)"}</ModuleInfo>
  </PropertyGroup>

  <ItemGroup>
    <Content Include="$(ModulesDir)\**">
      <Pack>true</Pack>
      <PackagePath>contentFiles\any\any\$(ModulesDir)</PackagePath>
      <PackageCopyToOutput>true</PackageCopyToOutput>
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
      <TargetPath>Modules\$(Id)\%(RecursiveDir)%(FileName)%(Extension)</TargetPath>
    </Content>
  </ItemGroup>

  <Target Name="ModulesBuildBefore" AfterTargets="Build">

    <!--建立modules目錄-->
    <MakeDir Directories="$(ModulesDir)"/>

    <!--生成module.json檔案，Note：專案需要生成兩次，否則Nuget包中的檔案不是最新的-->
    <WriteLinesToFile File="$(ModulesDir)\module.json" Overwrite="true" Lines="$(ModuleInfo)" />
    
  </Target>

</Project>

NetModular定義了一個描述模組資訊的ModuleInfo.cs類和一個儲存模組資訊的IModuleCollection.cs介面

/// <summary>
/// 模組資訊
/// </summary>
public class ModuleInfo
{
    /// <summary>
    /// 編號
    /// </summary>
    public string Id { get; set; }

    /// <summary>
    /// 名稱
    /// </summary>
    public string Name { get; set; }

    /// <summary>
    /// 版本
    /// </summary>
    public string Version { get; set; }

    /// <summary>
    /// 模組初始化器
    /// </summary>
    public IModuleInitializer Initializer { get; set; }

    /// <summary>
    /// 程式集資訊
    /// </summary>
    public ModuleAssembliesInfo AssembliesInfo { get; set; }
}

/// <summary>
/// 模組集合
/// </summary>
public interface IModuleCollection : IList<ModuleInfo>
{

}

IModuleCollection有一個實現類ModuleCollection.cs，在該類的建構函式中執行載入模組列表的操作：

public ModuleCollection()
{
    var moduleJsonFiles = Directory.GetFiles(Path.Combine(AppContext.BaseDirectory, "modules"), "module.json", SearchOption.AllDirectories);

    foreach (var file in moduleJsonFiles)
    {
        var moduleInfo = JsonConvert.DeserializeObject<ModuleInfo>(File.ReadAllText(file));
        if (moduleInfo != null)
        {
            //判斷是否已存在
            if (_moduleInfos.Any(m => m.Name.Equals(moduleInfo.Name)))
                continue;
            var assemblyHelper = new AssemblyHelper();
            //此處預設模組名稱空間字首與當前專案相同
            moduleInfo.AssembliesInfo = new ModuleAssembliesInfo
            {
                Domain = assemblyHelper.Load(m => m.Name.EndsWith("Module." + moduleInfo.Id + ".Domain")).FirstOrDefault(),
                Infrastructure = assemblyHelper.Load(m => m.Name.EndsWith("Module." + moduleInfo.Id + ".Infrastructure")).FirstOrDefault(),
                Application = assemblyHelper.Load(m => m.Name.EndsWith("Module." + moduleInfo.Id + ".Application")).FirstOrDefault(),
                Web = assemblyHelper.Load(m => m.Name.EndsWith("Module." + moduleInfo.Id + ".Web")).FirstOrDefault(),
            };

            Check.NotNull(moduleInfo.AssembliesInfo.Domain, moduleInfo.Id + "模組的Domain程式集未發現");
            Check.NotNull(moduleInfo.AssembliesInfo.Infrastructure, moduleInfo.Id + "模組的Infrastructure程式集未發現");
            Check.NotNull(moduleInfo.AssembliesInfo.Application, moduleInfo.Id + "模組的Application程式集未發現");
            Check.NotNull(moduleInfo.AssembliesInfo.Web, moduleInfo.Id + "模組的Web程式集未發現");

            //載入模組初始化器
            var moduleInitializerType = moduleInfo.AssembliesInfo.Web.GetTypes().FirstOrDefault(t => typeof(IModuleInitializer).IsAssignableFrom(t));
            if (moduleInitializerType != null && (moduleInitializerType != typeof(IModuleInitializer)))
            {
                moduleInfo.Initializer = (IModuleInitializer)Activator.CreateInstance(moduleInitializerType);
            }

            Add(moduleInfo);
        }
    }
}

當專案啟動時，首先建立ModuleCollection的例項，在它的建構函式中會載入所有模組資訊，然後使用單例模式注入，這樣就可以在系統中隨時取用模組資訊了。

/// <summary>
/// 新增模組
/// </summary>
/// <param name="services"></param>
/// <param name="env"></param>
/// <returns></returns>
public static IModuleCollection AddModules(this IServiceCollection services, IHostingEnvironment env)
{
    //建立模組集合物件
    var modules = new ModuleCollection();
    services.AddSingleton<IModuleCollection>(modules);

    var cfgHelper = new ConfigurationHelper();
    var cfg = cfgHelper.Load("module", env.EnvironmentName, true);

    //通用配置
    services.Configure<ModuleCommonOptions>(cfg);

    foreach (var module in modules)
    {
        if (module == null)
            continue;

        services.AddApplicationServices(module);

        if (module.Initializer != null)
        {
            module.Initializer.ConfigureServices(services);

            module.Initializer.ConfigOptions(services, cfg.GetSection(module.Id));

            services.AddSingleton(module);
        }
    }

    return modules;
}

模組中的依賴注入和中介軟體處理

先看一下一個模組中包含哪些資訊：

結構圖

模組中的注入分為兩類：

1、約定的

每個模組中都有配置項(Options)、實體(Entity)、倉儲(Repository)、資料庫上下文(DbContext)、工作單元(UnitOfWork)、服務(Service)，他們都是約定好的，包括命名、目錄、用法等，所以使用者只需要按照規則去使用即可，不需要關心注入的事情，它們在系統中是自動注入的。

以資料訪問為例，資料訪問相關的倉儲(Repository)、資料庫上下文(DbContext)、工作單元(UnitOfWork)是根據配置資訊和模組來自動進行注入的，同時都是以Scoped方式注入。具體程式碼檢視Data.AspNetCore專案。

2、自定義的

每個模組都可能會有一些獨有的需要注入的服務，那麼這些服務是屬於自定義的，需要開發者自己手動注入。比如許可權管理(Admin)模組中的許可權驗證處理(PermissionValidateHandler.cs)，該類實現IPermissionValidateHandler介面，專門用於做許可權驗證功能。

除了注入以外，每個模組還有獨有的中介軟體以及對某些功能的特殊配置，為了把這些資訊一起整合到專案中，NetModular抽象了一個IModuleInitializer介面，該介面包括以下四個方法：

/// <summary>
/// 模組初始化器介面
/// </summary>
public interface IModuleInitializer
{
    /// <summary>
    /// 注入服務
    /// </summary>
    /// <param name="services"></param>
    void ConfigureServices(IServiceCollection services);

    /// <summary>
    /// 配置中介軟體
    /// </summary>
    /// <param name="app"></param>
    /// <param name="env"></param>
    void Configure(IApplicationBuilder app, IHostingEnvironment env);

    /// <summary>
    /// 配置MVC
    /// </summary>
    /// <param name="mvcOptions"></param>
    void ConfigureMvc(MvcOptions mvcOptions);

    /// <summary>
    /// 配置選項
    /// </summary>
    /// <param name="services"></param>
    /// <param name="configuration"></param>
    void ConfigOptions(IServiceCollection services, IConfiguration configuration);
}

方法說明：

1、ConfigureServices：用於注入服務

2、Configure：用於配置中介軟體

3、ConfigureMvc：用於配置MVC相關功能

4、ConfigOptions：用於配置模組的配置項

在每個模組中，都必須包含一個IModuleInitializer的實現ModuleInitializer，已許可權管理(Admin)模組為例：

public class ModuleInitializer : IModuleInitializer
{
    public void ConfigureServices(IServiceCollection services)
    {
        //許可權驗證服務
        services.AddScoped<IPermissionValidateHandler, PermissionValidateHandler>();
    }

    public void Configure(IApplicationBuilder app, IHostingEnvironment env)
    {
    }

    public void ConfigureMvc(MvcOptions mvcOptions)
    {
        // 審計日誌過濾器
        mvcOptions.Filters.Add(typeof(AuditingFilter));
    }

    public void ConfigOptions(IServiceCollection services, IConfiguration configuration)
    {
        // Admin配置項
        services.Configure<AdminOptions>(configuration);
    }
}

當系統在啟動的時候，會在指定的步驟，呼叫所有模組的對應方法，比如當呼叫service.AddModules方法時，會遍歷模組並注入自定義服務和配置項，

public static IModuleCollection AddModules(this IServiceCollection services, IHostingEnvironment env)
{
    var modules = new ModuleCollection();
    services.AddSingleton<IModuleCollection>(modules);

    var cfgHelper = new ConfigurationHelper();
    var cfg = cfgHelper.Load("module", env.EnvironmentName, true);

    services.Configure<ModuleCommonOptions>(cfg);

    // 遍歷模組
    foreach (var module in modules)
    {
        if (module == null)
            continue;

        services.AddApplicationServices(module);

        // 判斷IModuleInitializer實現是否存在
        if (module.Initializer != null)
        {
            // 注入服務
            module.Initializer.ConfigureServices(services);

            //配置配置項
            module.Initializer.ConfigOptions(services, cfg.GetSection(module.Id));

            services.AddSingleton(module);
        }
    }

    return modules;
}

至此，模組的所有資訊都已整合到了系統當中~

原文首發：ASP.NET Core模組化前後端分離快速開發框架介紹之4、模組化實現思路

相關文章