Le ha enseñado cómo construir las interfaces API de servicios con Mons vNext

ABP es un framework de aplicaciones de código abierto, el proyecto es la generación siguiente estructura de aplicaciones ASP.NET Web plancha de caldera, centrándose en las aplicaciones Web basadas en el desarrollo ASP.NET Core, también apoya el desarrollo de aplicaciones de consola.

Página oficial: https://abp.io/
documento oficial: https://docs.abp.io/

En primer lugar, el uso de ABP marco para construir rápidamente una aplicación que sólo requiere unos pocos pasos para completar:

1. Instalar ABP CLI

ABP ABP CLI está usando nuevo marco solución de la manera más rápida para empezar. Si no instala ABP CLI, utilice la instalación de la ventana de línea de comandos CLI ABP:

dotnet tool install -g Volo.Abp.Cli

2. Crear un proyecto mediante el nuevo comando ABP en una carpeta vacía:

abp new Acme.BookStore

Se pueden utilizar diferentes niveles de espacios de nombres. Por ejemplo librería, Acme.BookStore o Acme.Retail.BookStore.

De esta manera, se ha completado la construcción de una aplicación.

A continuación, sólo tenemos que modificar la configuración para ejecutar otras aplicaciones, los desarrolladores sobre la base de este marco puede ser una línea agradable y código.

Sin embargo, el aprendizaje ABP acaba de comenzar. ABP abandonó la arquitectura original MVC utiliza una arquitectura modular que soporta micro-servicios, de acuerdo con el modo y los principios de diseño y desarrollo DDD, proporcionan un modelo en capas para la aplicación. Para los programadores sin experiencia en el desarrollo de micro-servicios, el aprendizaje ABP difícil. Empecemos con una solución Web vacío, paso a paso para construir servicios de interfaz API.

En segundo lugar, construir una API de servicios de interfaz de usuario del Centro con la infraestructura APB

Entorno de desarrollo: Visual Studio Código Mac
SDK: DOTNET Core 3.1

1. En primer lugar, crear una carpeta Lemon.UserCenter, y abra la carpeta en la terminal.

Utilizar comandos para crear un vacío de soluciones web:

dotnet new web -o Lemon.UserCenter.HttpApi.Hosting

2. a continuación, utilizar el comando para crear otro programa de bibliotecas:

创建api层
dotnet new classlib -o Lemon.UserCenter.HttpApi
创建应用层
dotnet new classlib -o Lemon.UserCenter.Application
创建领域层
dotnet new classlib -o Lemon.UserCenter.Domain
创建基于EntityFrameworkCore的数据层
dotnet new classlib -o Lemon.UserCenter.EntityFrameworkCore

3. todas las bibliotecas añaden soluciones y, a continuación, se refieren a la otra entre la biblioteca:

创建解决方案
dotnet new sln
所有类库加入解决方案
dotnet sln Lemon.UserCenter.sln add Lemon.UserCenter.HttpApi.Hosting/Lemon.UserCenter.HttpApi.Hosting.csproj
dotnet sln Lemon.UserCenter.sln add Lemon.UserCenter.HttpApi/Lemon.UserCenter.HttpApi.csproj
dotnet sln Lemon.UserCenter.sln add Lemon.UserCenter.Application/Lemon.UserCenter.Application.csproj
dotnet sln Lemon.UserCenter.sln add Lemon.UserCenter.Domain/Lemon.UserCenter.Domain.csproj
dotnet sln Lemon.UserCenter.sln add Lemon.UserCenter.EntityFrameworkCore/Lemon.UserCenter.EntityFrameworkCore.csproj
添加项目引用
dotnet add Lemon.UserCenter.HttpApi.Hosting/Lemon.UserCenter.HttpApi.Hosting.csproj reference Lemon.UserCenter.HttpApi/Lemon.UserCenter.HttpApi.csproj
dotnet add Lemon.UserCenter.HttpApi.Hosting/Lemon.UserCenter.HttpApi.Hosting.csproj reference Lemon.UserCenter.EntityFrameworkCore/Lemon.UserCenter.EntityFrameworkCore.csproj
dotnet add Lemon.UserCenter.HttpApi/Lemon.UserCenter.HttpApi.csproj reference Lemon.UserCenter.Application/Lemon.UserCenter.Application.csproj
dotnet add Lemon.UserCenter.Application/Lemon.UserCenter.Application.csproj reference Lemon.UserCenter.Domain/Lemon.UserCenter.Domain.csproj
dotnet add Lemon.UserCenter.EntityFrameworkCore/Lemon.UserCenter.EntityFrameworkCore.csproj reference Lemon.UserCenter.Domain/Lemon.UserCenter.Domain.csproj

4. Añadir una nueva entidad en la capa de dominio.

CAMPO añadió Volo.Abp.Identity.Domain referencias paquete de capas:

dotnet add Lemon.UserCenter.Domain/Lemon.UserCenter.Domain.csproj package Volo.Abp.Identity.Domain

Crear una clase de módulo de la capa de dominio:

using Volo.Abp.Identity;
using Volo.Abp.Modularity;

namespace Lemon.UserCenter.Domain
{
    [DependsOn(typeof(AbpIdentityDomainModule))]
    public class UserCenterDomainModule : AbpModule
    {
        
    }
}

Crear clases de entidad:

using System;
using Volo.Abp.Domain.Entities;

namespace Lemon.UserCenter.Domain
{
    public class UserData : Entity<Guid>
    {
        /// <summary>
        /// 账号
        /// </summary>
        /// <value>The account.</value>
        public string Account { get; set; }

        /// <summary>
        /// 昵称
        /// </summary>
        /// <value>The name of the nike.</value>
        public string NickName { get; set; } = "";

        /// <summary>
        /// 头像
        /// </summary>
        /// <value>The head icon.</value>
        public string HeadIcon { get; set; } = "";

        /// <summary>
        /// 手机号码
        /// </summary>
        /// <value>The mobile.</value>
        public string Mobile { get; set; } = "";

        /// <summary>
        /// 电子邮箱
        /// </summary>
        /// <value>The email.</value>
        public string Email { get; set; } = "";

        /// <summary>
        /// 删除注记
        /// </summary>
        /// <value><c>true</c> if deleted; otherwise, <c>false</c>.</value>
        public bool Deleted { get; set; }
    }
}

5. Crear una capa de datos

Añadir una capa de datos de referencia:

dotnet add Lemon.UserCenter.EntityFrameworkCore/Lemon.UserCenter.EntityFrameworkCore.csproj package Volo.Abp.EntityFrameworkCore
dotnet add Lemon.UserCenter.EntityFrameworkCore/Lemon.UserCenter.EntityFrameworkCore.csproj package Volo.Abp.EntityFrameworkCore.PostgreSQL
dotnet add Lemon.UserCenter.EntityFrameworkCore/Lemon.UserCenter.EntityFrameworkCore.csproj package Microsoft.EntityFrameworkCore.Design
dotnet add Lemon.UserCenter.EntityFrameworkCore/Lemon.UserCenter.EntityFrameworkCore.csproj package Microsoft.EntityFrameworkCore
dotnet add Lemon.UserCenter.EntityFrameworkCore/Lemon.UserCenter.EntityFrameworkCore.csproj package Microsoft.EntityFrameworkCore.Relational

Aquí estamos utilizando la base de datos PostgreSQL, citado Volo.Abp.EntityFrameworkCore.PostgreSQL, si está utilizando MySQL, se refieren Volo.Abp.EntityFrameworkCore.MySQL, si está utilizando SQL Server, se refieren Volo.Abp. EntityFrameworkCore.SQLServer.

Únete categorías UserCenterDbContext:

using Lemon.UserCenter.Domain;
using Microsoft.EntityFrameworkCore;
using Volo.Abp.Data;
using Volo.Abp.EntityFrameworkCore;

namespace Lemon.UserCenter.EntityFrameworkCore
{
    [ConnectionStringName("Default")]
    public class UserCenterDbContext : AbpDbContext<UserCenterDbContext>
    {
        public DbSet<UserData> UserData { get; set; }
        
        public UserCenterDbContext(DbContextOptions<UserCenterDbContext> options)
            : base(options)
        {

        }

        protected override void OnModelCreating(ModelBuilder builder)
        {
            base.OnModelCreating(builder);
        }

    }
}

Únete categorías UserCenterDbContextFactory:

using System.IO;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Design;
using Microsoft.Extensions.Configuration;

namespace Lemon.UserCenter.EntityFrameworkCore
{
    public class UserCenterDbContextFactory: IDesignTimeDbContextFactory<UserCenterDbContext>
    {
        public UserCenterDbContext CreateDbContext(string[] args)
        {
            var configuration = BuildConfiguration();

            var builder = new DbContextOptionsBuilder<UserCenterDbContext>()
                .UseNpgsql(configuration.GetConnectionString("Default"));

            return new UserCenterDbContext(builder.Options);
        }

        private static IConfigurationRoot BuildConfiguration()
        {
            var builder = new ConfigurationBuilder()
                .SetBasePath(Directory.GetCurrentDirectory())
                .AddJsonFile("appsettings.json", optional: false);

            return builder.Build();
        }
    }
}

Añadir appsettings.json configurado para el código de migración de datos de generación:

{
    "ConnectionStrings": {
      "Default": "server=127.0.0.1;port=5432;Database=abp-samples-user-center;uid=postgres;pwd=123456"
    }
}

Crear una capa de datos clases del módulo:

using Lemon.UserCenter.Domain;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Volo.Abp.EntityFrameworkCore;
using Volo.Abp.EntityFrameworkCore.PostgreSql;
using Volo.Abp.Modularity;

namespace Lemon.UserCenter.EntityFrameworkCore
{
    [DependsOn(typeof(UserCenterDomainModule),
        typeof(AbpEntityFrameworkCoreModule),
        typeof(AbpEntityFrameworkCorePostgreSqlModule))]
    public class UserCenterentityFrameworkCoreModule : AbpModule
    {
        public override void ConfigureServices(ServiceConfigurationContext context)
        {
            context.Services.AddAbpDbContext<UserCenterDbContext>(options => {
                options.AddDefaultRepositories(includeAllEntities: true);
            });

            Configure<AbpDbContextOptions>(options =>
            {
                options.Configure(ctx =>
                {
                    if (ctx.ExistingConnection != null)
                    {
                        ctx.DbContextOptions.UseNpgsql(ctx.ExistingConnection);
                    }
                    else
                    {
                        ctx.DbContextOptions.UseNpgsql(ctx.ConnectionString);
                    }
                });
            });

            #region 自动迁移数据库

            context.Services.BuildServiceProvider().GetService<UserCenterDbContext>().Database.Migrate();

            #endregion 自动迁移数据库
        }
    }
}

Generar un código de migración de datos:

dotnet ef migrations add InitialCreate --project Lemon.UserCenter.EntityFrameworkCore/Lemon.UserCenter.EntityFrameworkCore.csproj

Generar en una carpeta de Migraciones de la capa de datos, que es el código de la migración de datos de código, ejecutar los comandos generan automáticamente una tabla de base de datos en la base de datos:

dotnet ef database update --project Lemon.UserCenter.EntityFrameworkCore/Lemon.UserCenter.EntityFrameworkCore.csproj

6. lograr la lógica de negocio específico en la capa de aplicación

Añadir Volo.Abp.Identity.Application aplicación de capa de aplicación:

dotnet add Lemon.UserCenter.Application/Lemon.UserCenter.Application.csproj package Volo.Abp.Identity.Application

La creación de una clase de módulo de capa de aplicación:

using Volo.Abp.Modularity;
using Volo.Abp.Identity;

namespace Lemon.UserCenter.Application
{
    [DependsOn(typeof(AbpIdentityApplicationModule))]
    public class UserCenterApplicationModule : AbpModule
    {
        
    }
}

Crear una interfaz de usuario:

using System.Threading.Tasks;
using Lemon.UserCenter.Domain;

namespace Lemon.UserCenter.Application
{
    public interface IUserService
    {
         Task<UserData> Create(UserData data);
    }
}

Implementar servicios de usuario:

using System;
using System.Threading.Tasks;
using Lemon.UserCenter.Domain;
using Volo.Abp.Application.Services;
using Volo.Abp.Domain.Repositories;

namespace Lemon.UserCenter.Application
{
    public class UserService : ApplicationService, IUserService
    {
        private readonly IRepository<UserData, Guid> _repository;
        public UserService(IRepository<UserData, Guid> repository)
        {
            this._repository = repository;
        }

        public async Task<UserData> Create(UserData data)
        {
            return await _repository.InsertAsync(data);
        }
    }
}

7. controlador capa api implementado WebAPI

capa api añadir Volo.Abp.Identity.HttpApi Cita:

dotnet add Lemon.UserCenter.HttpApi/Lemon.UserCenter.HttpApi.csproj package Volo.Abp.Identity.HttpApi

Crear una clase de módulo:

using Lemon.UserCenter.Application;
using Volo.Abp.Identity;
using Volo.Abp.Modularity;

namespace Lemon.UserCenter.HttpApi
{
    [DependsOn(typeof(AbpIdentityHttpApiModule),
    typeof(UserCenterApplicationModule))]
    public class UserCenterHttpApiModule : AbpModule
    {
        
    }
}

Crear un controlador:

using System.Threading.Tasks;
using Lemon.UserCenter.Application;
using Lemon.UserCenter.Domain;
using Microsoft.AspNetCore.Mvc;
using Volo.Abp.AspNetCore.Mvc;

namespace Lemon.UserCenter.HttpApi.Controllers
{
    [Route("api/user")]
    public class UserController : AbpController
    {
        private readonly IUserService _userService;
        public UserController(IUserService userService)
        {
            this._userService = userService;
        }

        [HttpPost("create")]
        public async Task<IActionResult> Create(UserData data)
        {
            var result = await _userService.Create(data);
            return Json(result);
        }
    }
}

7. Para lograr el proyecto de elementos de inicio api de alojamiento

Añadir Volo.Abp.Autofac Cita:

dotnet add Lemon.UserCenter.HttpApi.Hosting/Lemon.UserCenter.HttpApi.Hosting.csproj package Volo.Abp.Autofac

Crear un módulo de clase

using Lemon.UserCenter.Domain;
using Lemon.UserCenter.EntityFrameworkCore;
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.Hosting;
using Volo.Abp;
using Volo.Abp.AspNetCore.Mvc;
using Volo.Abp.Autofac;
using Volo.Abp.Modularity;

namespace Lemon.UserCenter.HttpApi.Hosting
{
    [DependsOn(typeof(UserCenterHttpApiModule),
                typeof(UserCenterDomainModule),
                typeof(UserCenterentityFrameworkCoreModule),
                typeof(AbpAspNetCoreMvcModule),
                typeof(AbpAutofacModule))]
    public class UserCenterHttpApiHostingModule: AbpModule
    {
        public override void OnApplicationInitialization(
            ApplicationInitializationContext context)
        {
            var app = context.GetApplicationBuilder();
            var env = context.GetEnvironment();

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

            app.UseStaticFiles();
            app.UseRouting();
            app.UseMvcWithDefaultRouteAndArea();
        }
    }
}

clase del Programa de modificar, añadir UseAutofac:

using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Hosting;

namespace Lemon.UserCenter.HttpApi.Hosting
{
    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>();
                }).UseAutofac();
    }
}

Modificar categorías de inicio:

using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;

namespace Lemon.UserCenter.HttpApi.Hosting
{
    public class Startup
    {
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddApplication<UserCenterHttpApiHostingModule>();
        }

        public void Configure(IApplicationBuilder app)
        {
            app.InitializeApplication();
        }
    }
}

8. Ejecutar el servicio

cd Lemon.UserCenter.HttpApi.Hosting
dotnet watch run

9. Por último, se utiliza para probar si los servicios de interfaz API cartero se puede utilizar normalmente.

La figura funciona como sigue:

resultados de base de datos son los siguientes:

resumen

Estos son los servicios de interfaz proceso de construcción, se refieren principalmente a la estructura del proyecto ABP CLI genera, pero son diferentes. Toda la arquitectura de capas también puede seguir optimizando esto en una cuestión de opinión. El seguimiento continuará compartiendo ABP conocimientos relevantes, tales como la identidad del servidor 4, caché, micro-servicios.