百度360必应搜狗淘宝本站头条
mqtt服务器xftp6mybatiscollectionkeyerrorc#var
当前位置：网站首页 > 热门文章 > 正文

仿ABP实现模块注入方法（adp模块）

bigegpt 2024-08-02 10:45 8 浏览

ABP的模块注入非常不错，但是ABP太臃肿了，单独的模块或者功能不能抽出来单独使用，所以就想自己实现一个模块注入方法。

ABP的模块注入原理，是程序启动时扫描所有dll模块，进行批量注入，下面是实现方法。

一、模块抽象类

查看代码

二、每个子项目下添加DependencyModule类

查看代码

namespace Core
{
    public class DependencyModule : ICoreModule
    {
        public override void Register()
        {
            //可以根据启动项目/项目环境来判断注入，例如单元测试项目
            if (this.CurrentDomainName == "UnitTest" || this.IsDevelopment)
            {
                AutofacFactory.RegisterAssemblyTypes(Assembly.GetExecutingAssembly());
                AutofacFactory.RegisterTypeAs(typeof(IAuthContext), typeof(AuthContext));
            }
            else 
            {
                AutofacFactory.RegisterAssemblyTypes(typeof(BaseRepository<>).Assembly,
                    x => x.IsClass && !x.IsInterface,
                    x => x.BaseType.IsGenericType && x.BaseType.GetGenericTypeDefinition() == typeof(BaseRepository<>));

                AutofacFactory.RegisterAssemblyTypes(typeof(BaseEs<>).Assembly,
                    x => x.IsClass && !x.IsInterface,
                    x => x.BaseType.IsGenericType && x.BaseType.GetGenericTypeDefinition() == typeof(BaseEs<>));
            }
        }
    }
}

查看代码


namespace ServerApi
{
    public class DependencyModule : ICoreModule
    {
        public override void Register()
        {
            AutofacFactory.RegisterAssemblyTypes(typeof(Startup).Assembly,
                             x => x.IsClass && !x.IsInterface,
                             x => x.BaseType.IsGenericType && x.BaseType.GetGenericTypeDefinition() == typeof(IHandler<>));
        }
    }
}

三、项目启动时，注入autofac容器

1、.netcore2.1

关键代码 return new AutofacServiceProvider(AutofacExt.InitAutofac(services));

查看代码


namespace WebApi
{
    public class Startup
    {
        public Startup(IConfiguration configuration, IOptions<AppSetting> appConfiguration)
        {
            Configuration = configuration;
            _appConfiguration = appConfiguration;
        }

        public IConfiguration Configuration { get; }
        public IOptions<AppSetting> _appConfiguration;
        
        public IServiceProvider ConfigureServices(IServiceCollection services)
        {
            services.Configure<AppSetting>(Configuration.GetSection("AppSetting"));
            services.AddMvc(config =>
            {
                config.Filters.Add<BasicFrameFilter>();
            })
            .AddControllersAsServices()
            .SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
            services.AddMemoryCache();
            services.AddCors();
            var dbType = ((ConfigurationSection)Configuration.GetSection("AppSetting:DbType")).Value;
            if (dbType == Define.DBTYPE_SQLSERVER)
            {
                services.AddDbContext<BasicFrameDBContext>(options =>
                    options.UseSqlServer(Configuration.GetConnectionString("DBContext")));
            }
            else  //mysql
            {
                services.AddDbContext<BasicFrameDBContext>(options =>
                    options.UseMySql(Configuration.GetConnectionString("DBContext")));
            }
            services.AddHttpClient();

            return new AutofacServiceProvider(AutofacExt.InitAutofac(services));
        }

        public void Configure(IApplicationBuilder app, IHostingEnvironment env)
        {
            app.UseAuthentication();
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            else
            {
                app.UseExceptionHandler("/Error");
            }

            app.UseStaticFiles();
            app.UseCookiePolicy();

            app.UseMvc(route =>
            {
                route.MapRoute(
                name: "default",
                template: "{controller=Home}/{action=Index}/{id?}");

                route.MapRoute(
                name: "areas",
                template: "{area:exists}/{controller=Home}/{action=Index}/{id?}");
            });

        }
    }
}

2、.netcore3.1

关键代码

.UseServiceProviderFactory(new AutofacServiceProviderFactory());

AutofacFactory.InitAutofac(builder);
builder.RegisterBuildCallback(scope =>
{
AutofacFactory.SetContainer((IContainer)scope);
});

查看代码


    public class Program
    {
        public static void Main(string[] args)
        {
            CreateHostBuilder(args).Build().Run();
        }

        public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureWebHostDefaults(webBuilder =>
                {
                    webBuilder.UseStartup<Startup>();
                })
               .UseServiceProviderFactory(new AutofacServiceProviderFactory());
    }

查看代码


    public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllersWithViews().AddControllersAsServices();

            services.AddControllers()
                    .AddNewtonsoftJson(options =>
                    {
                        options.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();//修改属性名称的序列化方式，首字母小写
                        options.SerializerSettings.Converters.Add(new DateTimeConverter());//修改时间的序列化方式
                        options.SerializerSettings.Converters.Add(new LongConverter());
                    });

            services.AddOptions();
            services.AddMemoryCache();
            services.AddCors(options => options.AddPolicy("cors", builder => { builder.AllowAnyMethod().SetIsOriginAllowed(_ => true).AllowAnyHeader().AllowCredentials(); }));
            services.AddSignalR();
        }

        //Autofac注册
        public void ConfigureContainer(ContainerBuilder builder)
        {
            AutofacFactory.InitAutofac(builder);
            builder.RegisterBuildCallback(scope =>
            {
                AutofacFactory.SetContainer((IContainer)scope);
            });
        }

        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment() || env.IsEnvironment("Debug"))
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseCors("cors");
            app.UseWebSockets();
            //错误拦截中间件
            app.UseMiddleware<ExceptionMiddleware>();

            app.UseHttpsRedirection();
            app.UseStaticFiles();            
            app.UseRouting();
            app.UseAuthorization();

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllers();     
                endpoints.MapHub<MessageHub>("/MessageHub");
                endpoints.Map("/", context =>
                {
                    context.Response.Redirect(#34;/api/Home/Index");
                    return Task.CompletedTask;
                });
            });
        }
    }

四、AutofacFactory类

查看代码


    public static class AutofacFactory
    {
        private static IContainer _container;
        private static ContainerBuilder _builder;

        static AutofacFactory()
        {
        }

        public static IContainer InitAutofac(IServiceCollection services)
        {
            _builder = new ContainerBuilder();

            RegisterAllModule();

            if (services.All(u => u.ServiceType != typeof(IHttpContextAccessor)))
            {
                services.AddScoped(typeof(IHttpContextAccessor), typeof(HttpContextAccessor));
            }

            _builder.Populate(services);
            _container = _builder.Build();
            return _container;
        }

        public static IContainer InitAutofac()
        {
            _container = _builder.Build();
            return _container;
        }

        public static void InitAutofac(ContainerBuilder builder)
        {
            _builder = builder;
            RegisterAllModule();
        }

        public static void SetContainer(IContainer container)
        {
            _container = container;
        }

        public static IContainer GetContainer()
        {
            return _container;
        }

        public static ContainerBuilder GetBuilder()
        {
            return _builder;
        }

        public static void RegisterAssemblyTypes(params Assembly[] assemblies)
        {
            _builder.RegisterAssemblyTypes(assemblies);
        }

        public static void RegisterAssemblyTypes(Assembly assemblie, params Func<Type, bool>[] predicates)
        {
            var regBuilder = _builder.RegisterAssemblyTypes(assemblie);
            foreach (var pre in predicates)
            {
                regBuilder.Where(pre);
            }
        }

        public static void RegisterTypeAs(Type iServiceType, Type implementationType, AutofacLifetime lifetime = AutofacLifetime.InstancePerDependency)
        {
            var regbuilder = _builder.RegisterType(implementationType).As(iServiceType);
            if (lifetime == AutofacLifetime.SingleInstance)
            {
                regbuilder.SingleInstance();
            }
            else if (lifetime == AutofacLifetime.InstancePerLifetimeScope)
            {
                regbuilder.InstancePerLifetimeScope();
            }
        }

        public static void RegisterType(Type serviceType, AutofacLifetime lifetime = AutofacLifetime.InstancePerDependency)
        {
            var regbuilder = _builder.RegisterType(serviceType);
            if (lifetime == AutofacLifetime.SingleInstance)
            {
                regbuilder.SingleInstance();
            }
            else if (lifetime == AutofacLifetime.InstancePerLifetimeScope)
            {
                regbuilder.InstancePerLifetimeScope();
            }
        }

        /// <summary>
        /// 泛型类型注册
        /// </summary>
        public static void RegisterGeneric(Type iServiceType, Type implementationType, AutofacLifetime lifetime = AutofacLifetime.InstancePerDependency)
        {
            var regbuilder = _builder.RegisterGeneric(implementationType).As(iServiceType);
            if (lifetime == AutofacLifetime.SingleInstance)
            {
                regbuilder.SingleInstance();
            }
            else if (lifetime == AutofacLifetime.InstancePerLifetimeScope)
            {
                regbuilder.InstancePerLifetimeScope();
            }
        }

        public static void RegisterGeneric(Type serviceType, AutofacLifetime lifetime = AutofacLifetime.InstancePerDependency)
        {
            var regbuilder = _builder.RegisterGeneric(serviceType);
            if (lifetime == AutofacLifetime.SingleInstance)
            {
                regbuilder.SingleInstance();
            }
            else if (lifetime == AutofacLifetime.InstancePerLifetimeScope)
            {
                regbuilder.InstancePerLifetimeScope();
            }
        }

        public static void RegisterType<iserviceType, implementationType>(AutofacLifetime lifetime = AutofacLifetime.InstancePerDependency)
        {
            var regbuilder = _builder.RegisterType<implementationType>().As<iserviceType>();
            if (lifetime == AutofacLifetime.SingleInstance)
            {
                regbuilder.SingleInstance();
            }
            else if (lifetime == AutofacLifetime.InstancePerLifetimeScope)
            {
                regbuilder.InstancePerLifetimeScope();
            }
        }

        public static void Register<serviceType>(object obj, AutofacLifetime lifetime = AutofacLifetime.InstancePerDependency)
        {
            var regbuilder = _builder.Register(x => obj).As<serviceType>();
            if (lifetime == AutofacLifetime.SingleInstance)
                regbuilder.SingleInstance();
            else if (lifetime == AutofacLifetime.InstancePerLifetimeScope)
                regbuilder.InstancePerLifetimeScope();
        }

        public static T Resolve<T>()
        {
            return _container.Resolve<T>();
        }

        public static object Resolve(Type type)
        {
            return _container.Resolve(type);
        }

        /// <summary>
        /// 注册全部模块
        /// </summary>
        public static void RegisterAllModule(params string[] dllnames)
        {
            var assembles = DependencyContext.Default.RuntimeLibraries.Select(x => x);
            if (dllnames.Count() > 0)
            {
                foreach (string dllname in dllnames)
                {
                    assembles = assembles.Where(o => o.Name.StartsWith(dllname));
                }
                var dlls = assembles.Select(o => Assembly.Load(new AssemblyName(o.Name))).ToArray();
            }
            else
            {
                var dlls = assembles.Where(o => o.Type == "project")
                                    .Select(o => Assembly.Load(new AssemblyName(o.Name))).ToArray();
            }

            //根据抽象类查找
            var types = AppDomain.CurrentDomain.GetAssemblies()
                        .SelectMany(a => a.GetTypes().Where(t => t.BaseType == typeof(ICoreModule) && t.BaseType.IsAbstract))
                        .ToArray();

            //根据接口查找
            //var types = AppDomain.CurrentDomain.GetAssemblies()
            //            .SelectMany(a => a.GetTypes().Where(t => t.GetInterfaces().Contains(typeof(ICoreModule))))
            //            .ToArray();

            foreach (var t in types)
            {
                var instance = (ICoreModule)Activator.CreateInstance(t);
                instance.Register();
            }
        }
    }

    /// <summary>
    /// 生命周期
    /// </summary>
    public enum AutofacLifetime
    {
        /// <summary>
        /// 默认生命周期,每次请求都创建新的对象
        /// </summary>
        InstancePerDependency,
        /// <summary>
        /// 每次都用同一个对象
        /// </summary>
        SingleInstance,
        /// <summary>
        /// 同一个Lifetime生成的对象是同一个实例
        /// </summary>
        InstancePerLifetimeScope
    }

相关推荐

当Frida来“敲”门（frida是什么）

0x1渗透测试瓶颈目前，碰到越来越多的大客户都会将核心资产业务集中在统一的APP上，或者对自己比较重要的APP，如自己的主业务，办公APP进行加壳，流量加密，投入了很多精力在移动端的防护上。而现在挖...

服务端性能测试实战3-性能测试脚本开发

前言在前面的两篇文章中，我们分别介绍了性能测试的理论知识以及性能测试计划制定，本篇文章将重点介绍性能测试脚本开发。脚本开发将分为两个阶段：阶段一：了解各个接口的入参、出参，使用Python代码模拟前端...

Springboot整合Apache Ftpserver拓展功能及业务讲解(三)

今日分享每天分享技术实战干货，技术在于积累和收藏，希望可以帮助到您，同时也希望获得您的支持和关注。架构开源地址：https://gitee.com/msxyspringboot整合Ftpserver参...

Linux和Windows下:Python Crypto模块安装方式区别

一、Linux环境下：fromCrypto.SignatureimportPKCS1_v1_5如果导包报错：ImportError:Nomodulenamed'Crypt...

Python 3 加密简介（python des加密解密）

Python3的标准库中是没多少用来解决加密的，不过却有用于处理哈希的库。在这里我们会对其进行一个简单的介绍，但重点会放在两个第三方的软件包：PyCrypto和cryptography上，我...

怎样从零开始编译一个魔兽世界开源服务端Windows

第二章：编译和安装我是艾西，上期我们讲述到编译一个魔兽世界开源服务端环境准备，那么今天跟大家聊聊怎么编译和安装我们直接进入正题（上一章没有看到的小伙伴可以点我主页查看）编译服务端：在D盘新建一个文件夹...

附1-Conda部署安装及基本使用（conda安装教程）

Windows环境安装安装介质下载下载地址：https://www.anaconda.com/products/individual安装Anaconda安装时，选择自定义安装，选择自定义安装路径：配置...

如何配置全世界最小的 MySQL 服务器

配置全世界最小的MySQL服务器——如何在一块IntelEdison为控制板上安装一个MySQL服务器。介绍在我最近的一篇博文中，物联网，消息以及MySQL，我展示了如果Partic...

如何使用Github Action来自动化编译PolarDB-PG数据库

随着PolarDB在国产数据库领域荣膺桂冠并持续获得广泛认可，越来越多的学生和技术爱好者开始关注并涉足这款由阿里巴巴集团倾力打造且性能卓越的关系型云原生数据库。有很多同学想要上手尝试，却卡在了编译数据...

面向NDK开发者的Android 7.0变更（ndk android.mk）

订阅Google官方微信公众号：谷歌开发者。与谷歌一起创造未来！受Android平台其他改进的影响，为了方便加载本机代码，AndroidM和N中的动态链接器对编写整洁且跨平台兼容的本机...

信创改造--人大金仓(Kingbase)数据库安装、备份恢复的问题纪要

问题一：在安装KingbaseES时，安装用户对于安装路径需有“读”、“写”、“执行”的权限。在Linux系统中，需要以非root用户执行安装程序，且该用户要有标准的home目录，您可...

OpenSSH 安全漏洞，修补操作一手掌握

1.漏洞概述近日，国家信息安全漏洞库（CNNVD）收到关于OpenSSH安全漏洞（CNNVD-202407-017、CVE-2024-6387）情况的报送。攻击者可以利用该漏洞在无需认证的情况下，通...

Linux:lsof命令详解（linux lsof命令详解）

介绍欢迎来到这篇博客。在这篇博客中，我们将学习Unix/Linux系统上的lsof命令行工具。命令行工具是您使用CLI（命令行界面）而不是GUI（图形用户界面）运行的程序或工具。lsoflsof代表&...

幻隐说固态第一期:固态硬盘接口类别

前排声明所有信息来源于网络收集，如有错误请评论区指出更正。废话不多说，目前固态硬盘接口按速度由慢到快分有这几类：SATA、mSATA、SATAExpress、PCI-E、m.2、u.2。下面我们来...

新品轰炸 影驰SSD多款产品登Computex

分享泡泡网SSD固态硬盘频道6月6日台北电脑展作为全球第二、亚洲最大的3C/IT产业链专业展，吸引了众多IT厂商和全球各地媒体的热烈关注，全球存储新势力—影驰，也积极参与其中，为广大玩家朋友带来了...

一周热门
最近发表
标签列表