ASP.NET Core模块化前后端分离快速开发框架介绍之4、模块化实现思路

栏目: ASP.NET · 发布时间: 5年前

内容简介：地址：账户：admin密码：admin

地址： http://129.211.40.240:6220

账户：admin

密码：admin

前端框架演示地址(临时)

地址： http://progqx5cu.bkt.clouddn.com/skins/index.html#/

账户：admin

密码：admin

获取官方源码

为了方便查看源码，我们先获取下官方的源码

下载 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 目录，该目录专门用于保存所有模块的信息，它的结构如下：

ASP.NET Core模块化前后端分离快速开发框架介绍之4、模块化实现思路

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

模块中的依赖注入和中间件处理

先看一下一个模块中包含哪些数据：

ASP.NET Core模块化前后端分离快速开发框架介绍之4、模块化实现思路

模块中的注入分为两类：

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

至此，模块的所有信息都已集成到了系统当中~

以上就是本文的全部内容，希望本文的内容对大家的学习或者工作能带来一定的帮助，也希望大家多多支持码农网

查看所有标签

猜你喜欢:

本站部分资源来源于网络，本站转载出于传递更多信息之目的，版权归原作者或者来源机构所有，如转载稿涉及版权问题，请联系我们。

码农书籍

Programming Amazon Web Services

James Murty / O'Reilly Media / 2008-3-25 / USD 49.99

Building on the success of its storefront and fulfillment services, Amazon now allows businesses to "rent" computing power, data storage and bandwidth on its vast network platform. This book demonstra......一起来看看《Programming Amazon Web Services》这本书的介绍吧!

码农工具