Implementing DDD based on ABP -- domain logic and application logic

This paper mainly introduces the problem of multiple application layers , Including the reason and realization . Through understanding, it introduces how to distinguish domain logic and application logic , What are the right practices , Which are not recommended or wrong practices .

One . The problem of multiple application layers

1. Introduction to multiple application layers

I wonder if you will encounter a situation , adopt ABP Build a backend API project , At first it was for Web End item ( such as ,Vue) Providing back-end interface services , With the development of the project and the complexity of the business , Added the mobile terminal App, The official account 、 Small program etc. , Not only for Web End supply API service , But also for mobile terminals App, The official account 、 Applets, etc API service . This scenario is the problem of multiple application layers . In other words, you now need to build a system with multiple applications ：

• Web Applications  ： For example, the ASP.NET Core MVC technology , It is mainly used to show products to users , Visitors can view products , Login and authentication are not required .
• Back end management applications  ： For example, the front end is Vue, Back end ASP.NET Core API, It is mainly used to add, delete and modify products .
• Mobile applications  ： For example, the front end is uni-app, The back end is ASP.NET Core API, adopt REST Interface and back-end communication .

2. Examples of multiple application layers

Because of the complexity of the business , Each application system has its own different application service methods , Different inputs and outputs DTO, Unused authentication and authorization rules, etc , So if you integrate all business logic into an application system , It will make the system more difficult to develop 、 Maintenance and testing , And lead to potential Bug risk . therefore , Create a separate application layer for each application , And they all share the core domain logic with a single domain layer . For more specific explanation , Create different for each application type .csproj project ：

• Back end management applications  ：IssueTracker.Admin.Application and IssueTracker.Admin.Application.Contracts project
• Web Applications  ：IssueTracker.Public.Application and IssueTracker.Public.Application.Contracts project
• Mobile applications  ：IssueTracker.Mobile.Application and IssueTracker.Mobile.Application.Contracts project

Two . How to distinguish domain logic and application logic

Usually ,DDD Business logic in includes domain logic and application logic . Domain logic consists of the core domain rules of the system , Application logic implements application specific use cases . That's all , But it is not easy to distinguish between domain logic and application logic .

1. Create an organization in the domain services layer Organization

Let's create in the domain service Organization This example , To explain as briefly as possible ：

public class OrganizationManager:DomainService
{
    private readonly IRepository<Organization> _organizationRepository; //Organization The warehouse of 
    private readonly ICurrentUser _currentUser; // The current user 
    private readonly IAuthorizationService _authorizationService; //Authorization Service for 
    private readonly IEmailSender _emailSender; // Email service 
    
    //  Public constructors , Dependency injection 
    public OrganizationManager(IRepository<Organization> organizationRepository, ICurrentUser currentUser, IAuthorizationService authorizationService, IEmailSender emailSender)
    {
        _organizationRepository=organizationRepository;
        _currentUser=currentUser;
        _authorizationService=authorizationService;
        _emailSender=emailSender;
    }
    
    //  Create a new organization 
    public async Task<Organization> CreateAsync(string name)
    {
        //  If the organization has the same name , So throw an exception [ correct ]
        if(await _organizationRepository.AnyAsync(x=>x.Name==name))
        {
            throw new BusinessException("IssueTracking:DuplicateOrganizationName");
        }
        
        //  Check whether you have the permission to create [ error ]
        await _authorizationService.CheckAsync("OrganizationCreationPermission");
        
        //  Record ⽇ Records [ error ]
        Logger.LogDebug($"Creating organization {name} by {_currentUser.UserName}");
        
        //  Create a new organization 
        var organization = new Organization();
        
        //  Send an email to remind [ error ]
        await _emailSender.SendAsync("[email protected]", " New organization ", " New organization name ："+name);
        
        //  Return an organization instance 
        return organization;
    }
}

• Domain services do not do permission verification , Permission verification is done in the application layer
• User concept is related to application layer or presentation layer , The log should not contain the user name of the current user
• Create a new organization , And send mail , This business logic should also be placed in the application layer

2. Use domain services in the application layer to create organizations Organization

public class OrganizationAppService:ApplicationService
{
    private readonly OrganizationManager _organizationManager; // The domain services of the organization 
    private readonly IPaymentService _paymentService; // Payment services 
    private readonly IEmailSender _emailSender; // The mail service 
    
    //  Public constructors , Dependency injection 
    public OrganizaitonAppService(OrganizationManager organizationManager, IPaymentService paymentService, IEmailSender emailSender)
    {
        _organizationManager=organizationManager;
        _paymentService=paymentService;
        _emailSender=emailSender;
    }
    
    //  Create organization 
    [UnitOfWork][ correct ] // The unit of work , Used to commit transactions 
    [Authorize("OrganizationCreationPermission")][ correct ]
    public async Task<Organization> CreateAsync(CreateOrganizationDto input)
    {
        // ⽀ Pay the organization fee ⽤[ correct ]
        await _paymentService.ChargeAsync(CurrentUser.Id, GetOrganizationPrice());
        
        //  Through domain service , Create a new organization instance 
        var organization = await _organizationManager.CreateAsync(input.Name);
        
        //  Save and update the organization into the database [ correct ]
        await _organizationManager.InsertAsync(organization);
        
        //  Send a reminder email [ correct ]
        await _emailSender.SendAsync("[email protected]", " New organization ", " New organization name ："+name);
        
        // Return instance [ error ]
        return organization;
    }
    private double GetOrganizationPrice()
    {
        return 42;//Gets form somewhere...
    }
}

The input and output parameters of the application service layer are DTO, Cannot return entity .  As for why not put payment in domain services , It can only be said that business is not necessarily important in domain services , For detailed reasons, please refer to  [1].

reference ：

[1] be based on ABP Framework Implement domain-driven design ： https://url39.ctfile.com/f/2501739-616007877-f3e258?p=2096 ( Access password : 2096)