.NET Core之 ABP从入门到精通

ABP是一套基于WEB的快速开发引用框架，和DDD领域驱动开发有很好的结合。
主要特性：模块化，多租户，认证授权，虚拟文件系统，主题系统，后台作业，事件总线，对象映射，依赖注入，数据过滤等。
接下来用代码的方式介绍ABP框架的使用。

一.VS创建一个ABP控制台程序打出Hello word!

1.首先引入框架包

Nuget中安装volo.abp.core
2.创建模块
所谓的ABP模块在代码中体现就是类，我们创建一个HelloABPModule的类，然后引入using Volo.Abp.Modularity;

using Volo.Abp.Modularity;

namespace HelloABP
{
    public class HelloABPModule:AbpModule
    {

    }
}
1
2
3
4
5
6
7
8
9

这样就创建好了一个最简单的ABP模块。模块一般不写业务逻辑。

3.我们创建一个服务
创建一个HelloWorldService用于书写业务逻辑。

using Volo.Abp.DependencyInjection;

namespace HelloABP
{
   public class HelloWorldService:ITransientDependency
    {
        public void Run() 
        {
            Console.WriteLine("Hello world!");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

ABP可以按照约定去实现自己的依赖注入，也可以通过接口的形式去实现注入。我们引入using Volo.Abp.DependencyInjection;然后继承ITransientDependency这样我们就用注入了周期为瞬时的HelloWorldService进入了我们IOC容器。

手动注入服务
上面是自动注入服务的方式，接着看下手动注入的方式，手动注入服务的方式和我们直接在Statup中注入是一样的。

using Volo.Abp.Modularity;
//添加注入服务
using Microsoft.Extensions.DependencyInjection;

namespace HelloABP
{
    public class HelloABPModule:AbpModule
    {
        public override void ConfigureServices(ServiceConfigurationContext context)
        {
            context.Services.AddTransient<HelloWorldService>();
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

我们在HelloABPModule启动模块类进行注入就行，注入方式和原生注入一样。

4.使用
在MAIN方法中创建启动模块。

using System;
using Volo.Abp;
using Microsoft.Extensions.DependencyInjection;
namespace HelloABP
{
    class Program
    {
        static void Main(string[] args)
        {
            //创建启动模块，一般一个项目只有一个启动模块，
            var application = AbpApplicationFactory.Create<HelloABPModule>();
            //初始化
            application.Initialize();
            //调用服务
            var service = application.ServiceProvider.GetService<HelloWorldService>();
            service.Run();

        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

这样一个最简单的ABP应用就跑起来了。

二.创建一个ASP.Net Core应用。

1.安装依赖包

abp.aspnetcore.mvc该包已经包含了第一部分的基础包，如果做WEB开发，安装这一个包就够了。

2.创建应用启动模块
配置启动中间件管道，因为用了ABP进行项目启动，就不需要再用Statup类进行中间件配置了。
我们创建一个ABP模块类APPModule代码如下：

using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.Hosting;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Volo.Abp;
using Volo.Abp.AspNetCore.Mvc;
using Volo.Abp.Modularity;

namespace WebApplication1
{
    //DependsOn注解可以定义在类和方法上，意思是我这个组件要依赖于另一个组件，也就是说被依赖的组件会比该组件先注册到IOC容器中。
    [DependsOn(typeof(AbpAspNetCoreMvcModule))]
    public class APPModule:AbpModule
    {
        public override void OnApplicationInitialization(ApplicationInitializationContext context)
        {
           // 直接从根容器获取     
           //等同于Statup类Configure方法中的参数一
            var app = context.GetApplicationBuilder();
             //等同于Statup类Configure方法中的参数二
            var env = context.GetEnvironment();

            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            else
            {
                app.UseExceptionHandler("/Error");
             
                app.UseHsts();
            }

            app.UseHttpsRedirection();
            app.UseStaticFiles();

            app.UseRouting();

            app.UseAuthorization();

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapRazorPages();
            });
        }

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

上面大部分代码都是Statup类中配置中间件的代码，我们把Statup中Configure方法中的中间件全部写到了ABP启动模块中，原来的Configure只需要写启动模块的初始化代码就行了。

3.注入ABP启动模块和初始化
打开Statup类，代码如下:

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.HttpsPolicy;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

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

        public IConfiguration Configuration { get; }

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddRazorPages();
            //注入ABP模块
            services.AddApplication<APPModule>();
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            //初始化模块
            app.InitializeApplication();
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

这2句注释的代码，和标题一中的控制台程序Mian方法的代码是一个意思，先注入服务，再初始化。这样我们就配置好了web应用的APB配置。接下来的业务操作，和控制台都是一样的了。

4.在ABP中使用控制器
创建一个控制器，代码如下：

using Microsoft.AspNetCore.Mvc;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Volo.Abp.AspNetCore.Mvc;

namespace WebApplication1.Controllers
{
   //需要继承ABP的控制器
    public class HellloController:AbpController
    {
        public IActionResult Index() 
        {
            return Content("Hello world");
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

并且需要把APPModule终结点的配置换成默认的，代码如下：

            //app.UseEndpoints(endpoints =>
            //{
            //    endpoints.MapRazorPages();
            //});
            //配置为默认
           app.UseConfiguredEndpoints();
1
2
3
4
5
6

这样我们就可以用ABP访问控制器了。

三.模块的生命周期。

ABP模块生命周期就三步：配置，初始化，销毁。
配置分为配置前，和配置后。
我们点进去AbpModule可以看到Pre和Post这类方法，只要带Pre的就是操作之前的，Post为该方法操作之后的。
服务配置前

  public virtual void PreConfigureServices(ServiceConfigurationContext context);
1

配置之后

  public virtual void PostConfigureServices(ServiceConfigurationContext context);
1

初始化

 public virtual void OnApplicationInitialization(ApplicationInitializationContext context);
1

程序结束做的事情

 public virtual void OnApplicationShutdown(ApplicationShutdownContext context);
1

上面都是虚方法，自己有需要的业务可以重写。