ABP 入門シリーズ (5) - アプリケーション サービスの作成

1. アプリケーション サービス層について説明します

アプリケーション サービスは、ドメイン (ビジネス) ロジックをプレゼンテーション層に公開するために使用されます。プレゼンテーション層は、DTO (データ転送オブジェクト) パラメーターを渡すことによってアプリケーション サービスを呼び出し、アプリケーション サービスはドメイン オブジェクトを通じて対応するビジネス ロジックを実行し、DTO をプレゼンテーション層に返します。したがって、プレゼンテーション層とドメイン層は完全に分離されます。
アプリケーション サービスを作成するときは、次の点に注意する必要があります:

ABP では、アプリケーション サービスは IApplicationService インターフェイスを実装する必要があります。ベスト プラクティスは、アプリケーション サービスごとに IApplicationService から継承された対応するインターフェイスを作成することです。 (このインターフェースを継承することで、ABP は依存関係の注入を自動的に支援します)

ABP は、IApplicationService のデフォルト実装 ApplicationService を提供します。この基本クラスは、便利なロギング機能とローカリゼーション機能を提供します。アプリケーション サービスを実装する場合は、ApplicationService を継承して、定義されたインターフェイスを実装するだけです。

ABP では、アプリケーション サービス メソッドはデフォルトで作業単位です。 ABP は、UOW モードのデータベース接続とトランザクション管理を自動的に実行し、データの変更を自動的に保存します。

2. ITaskAppService インターフェイスを定義します

1. まず、定義されたインターフェイスを見てみましょう

    public interface ITaskAppService : IApplicationService
    {        
    GetTasksOutput GetTasks(GetTasksInput input);        
    void UpdateTask(UpdateTaskInput input);        
    int CreateTask(CreateTaskInput input);        
    Task<TaskDto> GetTaskByIdAsync(int taskId);        
    TaskDto GetTaskById(int taskId);        
    void DeleteTask(int taskId);        
    IList<TaskDto> GetAllTasks();
    }

メソッドのパラメーターと戻り値を観察してください。Task エンティティ オブジェクトが直接使用されていないことがわかります。どうしてこれなの？プレゼンテーション層とアプリケーション サービス層はデータ転送オブジェクト (DTO) を通じてデータを送信するためです。

2. dto を介してデータを転送する必要があるのはなぜですか?

要約すると、データ送信に DTO を使用すると、次のような利点があります。

データの隠蔽

シリアル化と遅延読み込みの問題

ABPは、検証をサポートするDTOのコントラクトクラスを提供します

パラメータまたは戻り値の変更、Dtoによる簡単な拡張

詳細については、以下を参照してください:
ABPフレームワーク - データ転送オブジェクト

3、Dto 仕様 (フレキシブル アプリケーション)

ABP では、入出力パラメーターに MethodNameInput および MethodNameOutput

という名前を付け、アプリケーション サービス メソッドごとに個別の入力および出力 DTO を定義することを推奨しています (メソッドごとに入力の場合、出力が定義している場合)。 dto の場合、定義して維持する必要がある巨大な dto クラスが存在します。一般に、これはパブリック dto を定義することで共有されます)

メソッドが 1 つのパラメーターのみを受け取る/返す場合でも、DTO を作成することが最善です。 class

通常、Dto クラスを管理するために、対応するエンティティのアプリケーション サービス フォルダーの下に新しい Dtos フォルダーが作成されます。

3. アプリケーション サービス インターフェイスを定義するために必要な DTO を定義します

1. まずは TaskDto の定義を見てみましょう

TaskDto は EntityDto から直接継承する単純なクラスです。実在物。 TaskDto を直接定義する目的は、複数のアプリケーション サービス メソッド間で共有することです。

2. TaskDto を直接共有する GetTasksOutput

の定義を見てみましょう。

namespace LearningMpaAbp.Tasks.Dtos{    /// <summary>
    /// A DTO class that can be used in various application service methods when needed to send/receive Task objects.
    /// </summary>
    public class TaskDto : EntityDto
    {        
public long? AssignedPersonId { get; set; }        
public string AssignedPersonName { get; set; }        
public string Title { get; set; }        
public string Description { get; set; }        
public DateTime CreationTime { get; set; }        
public TaskState State { get; set; }        //This method is just used by the Console Application to list tasks
        public override string ToString()        
{            
return string.Format(                
"[Task Id={0}, Description={1}, CreationTime={2}, AssignedPersonName={3}, State={4}]",
                Id,
                Description,
                CreationTime,
                AssignedPersonId,
                (TaskState)State
                );
        }
    }
}

3. CreateTaskInput と UpdateTaskInput を見てみましょう

public class GetTasksOutput
    {        public List<TaskDto> Tasks { get; set; }
    }

  public class CreateTaskInput
    {        public int? AssignedPersonId { get; set; }

        [Required]        public string Description { get; set; }

        [Required]        public string Title { get; set; }        
  public TaskState State { get; set; }        
  public override string ToString()        
  {            return string.Format("[CreateTaskInput > AssignedPersonId = {0}, Description = {1}]", AssignedPersonId, Description);
        }
    }

その中で、UpdateTaskInput はカスタム検証を実装するための ICustomValidate インターフェイスを実装します。 DTO 検証を理解するには、ABP フレームワーク - 検証データ転送オブジェクト

##4 を参照してください。最後に、フィルタリング用の 2 つの属性を含む GetTasksInput

の定義を見てみましょう。

    /// <summary>
    /// This DTO class is used to send needed data to <see cref="ITaskAppService.UpdateTask"/> method.
    /// 
    /// Implements <see cref="ICustomValidate"/> for additional custom validation.
    /// </summary>
    public class UpdateTaskInput : ICustomValidate
    {
        [Range(1, Int32.MaxValue)] //Data annotation attributes work as expected.
        public int Id { get; set; }        
    public int? AssignedPersonId { get; set; }        
    public TaskState? State { get; set; }

        [Required]        
    public string Title { get; set; }

        [Required]       
     public string Description { get; set; }        
     //Custom validation method. It&#39;s called by ABP after data annotation validations.
        public void AddValidationErrors(CustomValidationContext context)        
     {            
     if (AssignedPersonId == null && State == null)
            {
                context.Results.Add(new ValidationResult("Both of AssignedPersonId and State can not be null in order to update a Task!", 
     new[] { "AssignedPersonId", "State" }));
            }
        }        
     public override string ToString()        
     {            
     return string.Format("[UpdateTaskInput > TaskId = {0}, AssignedPersonId = {1}, State = {2}]", Id, AssignedPersonId, State);
        }
    }

DTO を定義した後、プレゼンテーション層とアプリケーション サービス層でデータを送信するために DTO を使用していますが、最終的にはデータベースを直接処理するためにこれらの DTO をエンティティに変換する必要があります。 。各 DTO を対応するエンティティに手動で変換する必要がある場合、ワークロードを過小評価することはできません。

あなたは賢いので、この作業負荷を軽減する方法はないかときっと疑問に思うでしょう。

四、使用AutoMapper自动映射DTO与实体

1，简要介绍AutoMapper

开始之前，如果对AutoMapper不是很了解，建议看下这篇文章AutoMapper小结。

AutoMapper的使用步骤，简单总结下：

创建映射规则（Mapper.CreateMapbc1f4f6eceb5c3fe3046d7ce55a259f7();）

类型映射转换（Mapper.Mapaac097dc6d13bd23cbb7f49e52c14533(sourceModel)）

在Abp中有两种方式创建映射规则：

特性数据注解方式：

AutoMapFrom、AutoMapTo 特性创建单向映射

AutoMap 特性创建双向映射

代码创建映射规则：

Mapper.CreateMapbc1f4f6eceb5c3fe3046d7ce55a259f7();

2，为Task实体相关的Dto定义映射规则

2.1，为CreateTasksInput、UpdateTaskInput定义映射规则

其中CreateTasksInput、UpdateTaskInput中的属性名与Task实体的属性命名一致，且只需要从Dto映射到实体，不需要反向映射。所以通过AutoMapTo创建单向映射即可。

[AutoMapTo(typeof(Task))] //定义单向映射
    public class CreateTaskInput
    {
      ...
    }

     [AutoMapTo(typeof(Task))] //定义单向映射
    public class UpdateTaskInput
    {
      ...
    }

2.2，为TaskDto定义映射规则

TaskDto与Task实体的属性中，有一个属性名不匹配。TaskDto中的AssignedPersonName属性对应的是Task实体中的AssignedPerson.FullName属性。针对这一属性映射，AutoMapper没有这么智能需要我们告诉它怎么做；

var taskDtoMapper = mapperConfig.CreateMapfad4ed88b82bbc62dc7998055dd75070();
taskDtoMapper.ForMember(dto => dto.AssignedPersonName, map => map.MapFrom(m => m.AssignedPerson.FullName));

为TaskDto与Task创建完自定义映射规则后，我们需要思考，这段代码该放在什么地方呢？

四、创建统一入口注册AutoMapper映射规则

如果在映射规则既有通过特性方式又有通过代码方式创建，这时就会容易混乱不便维护。
为了解决这个问题，统一采用代码创建映射规则的方式。并通过IOC容器注册所有的映射规则类，再循环调用注册方法。

1，定义抽象接口IDtoMapping

应用服务层根目录创建IDtoMapping接口，定义CreateMapping方法由映射规则类实现。

namespace LearningMpaAbp{    /// <summary>
    ///     实现该接口以进行映射规则创建
    /// </summary>
    internal interface IDtoMapping
    {        void CreateMapping(IMapperConfigurationExpression mapperConfig);
    }
}

2，为Task实体相关Dto创建映射类

namespace LearningMpaAbp.Tasks{    public class TaskDtoMapping : IDtoMapping
    {        public void CreateMapping(IMapperConfigurationExpression mapperConfig)        
{            //定义单向映射
            mapperConfig.CreateMap<CreateTaskInput, Task>();
            mapperConfig.CreateMap<UpdateTaskInput, Task>();
            mapperConfig.CreateMap<TaskDto, UpdateTaskInput>();            //自定义映射
            var taskDtoMapper = mapperConfig.CreateMap<Task, TaskDto>();
            taskDtoMapper.ForMember(dto => dto.AssignedPersonName, map => map.MapFrom(m => m.AssignedPerson.FullName));
        }
    }
}

3，注册IDtoMapping依赖

在应用服务的模块中对IDtoMapping进行依赖注册，并解析以进行映射规则创建。

namespace LearningMpaAbp{
    [DependsOn(typeof(LearningMpaAbpCoreModule), typeof(AbpAutoMapperModule))]    
public class LearningMpaAbpApplicationModule : AbpModule
    {        public override void PreInitialize()        {
            Configuration.Modules.AbpAutoMapper().Configurators.Add(mapper =>
            {                //Add your custom AutoMapper mappings here...
            });
        }        public override void Initialize()        {           
           IocManager.RegisterAssemblyByConvention(Assembly.GetExecutingAssembly());            //注册IDtoMapping
            IocManager.IocContainer.Register(
                Classes.FromAssembly(Assembly.GetExecutingAssembly())
                    .IncludeNonPublicTypes()
                    .BasedOn<IDtoMapping>()
                    .WithService.Self()
                    .WithService.DefaultInterfaces()
                    .LifestyleTransient()
            );            //解析依赖，并进行映射规则创建
            Configuration.Modules.AbpAutoMapper().Configurators.Add(mapper =>
            {                var mappers = IocManager.IocContainer.ResolveAll<IDtoMapping>();               
 foreach (var dtomap in mappers)
                    dtomap.CreateMapping(mapper);
            });
        }
    }
}

通过这种方式，我们只需要实现IDtoMappting进行映射规则定义。创建映射规则的动作就交给模块吧。

五、万事俱备，实现ITaskAppService

认真读完以上内容，那么到这一步，就很简单了，业务只是简单的增删该查，实现起来就很简单了。可以自己尝试自行实现，再参考代码：

namespace LearningMpaAbp.Tasks
{    /// <summary>
    /// Implements <see cref="ITaskAppService"/> to perform task related application functionality.
    /// 
    /// Inherits from <see cref="ApplicationService"/>.
    /// <see cref="ApplicationService"/> contains some basic functionality common for application services (such as logging and localization).
    /// </summary>
    public class TaskAppService : LearningMpaAbpAppServiceBase, ITaskAppService
    {        //These members set in constructor using constructor injection.

        private readonly IRepository<Task> _taskRepository;
        private readonly IRepository<Person> _personRepository;        /// <summary>
        ///In constructor, we can get needed classes/interfaces.
        ///They are sent here by dependency injection system automatically.
        /// </summary>
        public TaskAppService(IRepository<Task> taskRepository, IRepository<Person> personRepository)
        {            _taskRepository = taskRepository;            _personRepository = personRepository;
        }

        public GetTasksOutput GetTasks(GetTasksInput input)
        {
            var query = _taskRepository.GetAll();            if (input.AssignedPersonId.HasValue)
            {
                query = query.Where(t => t.AssignedPersonId == input.AssignedPersonId.Value);
            }            if (input.State.HasValue)
            {
                query = query.Where(t => t.State == input.State.Value);
            }            //Used AutoMapper to automatically convert List<Task> to List<TaskDto>.
            return new GetTasksOutput
            {
                Tasks = Mapper.Map<List<TaskDto>>(query.ToList())
            };
        }

        public async Task<TaskDto> GetTaskByIdAsync(int taskId)
        {            //Called specific GetAllWithPeople method of task repository.
            var task = await _taskRepository.GetAsync(taskId);            //Used AutoMapper to automatically convert List<Task> to List<TaskDto>.
            return task.MapTo<TaskDto>();
        }

        public TaskDto GetTaskById(int taskId)
        {
            var task = _taskRepository.Get(taskId);

            return task.MapTo<TaskDto>();
        }

        public void UpdateTask(UpdateTaskInput input)
        {            //We can use Logger, it&#39;s defined in ApplicationService base class.
            Logger.Info("Updating a task for input: " + input);            //Retrieving a task entity with given id using standard Get method of repositories.
            var task = _taskRepository.Get(input.Id);            //Updating changed properties of the retrieved task entity.

            if (input.State.HasValue)
            {                task.State = input.State.Value;
            }            if (input.AssignedPersonId.HasValue)
            {                task.AssignedPerson = _personRepository.Load(input.AssignedPersonId.Value);
            }            //We even do not call Update method of the repository.
            //Because an application service method is a &#39;unit of work&#39; scope as default.
            //ABP automatically saves all changes when a &#39;unit of work&#39; scope ends (without any exception).
        }

        public int CreateTask(CreateTaskInput input)
        {            //We can use Logger, it&#39;s defined in ApplicationService class.
            Logger.Info("Creating a task for input: " + input);            //Creating a new Task entity with given input&#39;s properties
            var task = new Task
            {
                Description = input.Description,
                Title = input.Title,
                State = input.State,
                CreationTime = Clock.Now
            };            if (input.AssignedPersonId.HasValue)
            {                task.AssignedPerson = _personRepository.Load(input.AssignedPersonId.Value);
            }            //Saving entity with standard Insert method of repositories.
            return _taskRepository.InsertAndGetId(task);
        }

        public void DeleteTask(int taskId)
        {
            var task = _taskRepository.Get(taskId);            if (task != null)
            {                _taskRepository.Delete(task);
            }
        }
    }
}

到此，此章节就告一段落。为了加深印象，请自行回答如下问题：

什么是应用服务层？

如何定义应用服务接口？

DTO とは何ですか?DTO を定義する方法は?

DTO をエンティティに自動的にマッピングするにはどうすればよいですか?

統合マッピングルールを作成するにはどうすればよいですか?

上記は、ABP 入門シリーズ (5) - アプリケーション サービスの作成の内容です。その他の関連コンテンツについては、PHP 中国語 Web サイト (www.php.cn) をご覧ください。