Function request method and device based on domain drive, equipment and storage medium

Abstract

The embodiment of the invention provides a function request method and device based on domain driving, equipment and a storage medium, a first data object is generated by responding to a trigger request, the trigger request is used for triggering a target function of a target application program, and the first data object is realized based on a first data model. The server is used for bearing request content corresponding to the trigger request; according to the first data object, a target entity is obtained, and the target entity is achieved based on a second data model and used for representing domain logic corresponding to the request content; and based on the target entity, triggering the event processor to generate a processing result, and returning the processing result to the terminal equipment. The triggering request of the target function is converted into the first data object, the corresponding target entity is obtained based on the first data object, and the event processor is triggered based on the target entity to obtain the processing result, so that the triggering efficiency and speed of the target function are improved, and the time consumption of the triggering process of the target function is reduced.

Description

Technical Field

[0001] The embodiments of the present disclosure relate to the field of computer technology, and in particular to a domain-driven function request method, apparatus, device, and storage medium. Background Art

[0002] In the prior art, for applications developed based on domain-driven design in Web scenarios, the application client usually sends a request to the server, and the server responds to the request to complete the process of the function request in the application.

[0003] However, in the prior art, in the process of implementing function requests based on domain-driven applications, there are problems such as low function execution efficiency and long time consumption, which affects the program performance of the application. Summary of the invention

[0004] The embodiments of the present disclosure provide a domain-driven function request method, apparatus, device, and storage medium to overcome the problems of low execution efficiency and long time consumption in the process of executing the function request.

[0005] In a first aspect, an embodiment of the present disclosure provides a domain-driven function request method, including:

[0006] In response to a trigger request, a first data object is generated, wherein the trigger request is used to trigger a target function of a target application, and the first data object is implemented based on a first data model and is used to carry and implement request content corresponding to the trigger request; based on the first data object, a target entity is obtained, and the target entity is implemented based on a second data model and is used to characterize the domain logic corresponding to the request content; based on the target entity, a trigger event processor generates a processing result, and returns the processing result to the terminal device.

[0007] In a second aspect, an embodiment of the present disclosure provides a domain-driven function request device, including:

[0008] A response unit, configured to generate a first data object in response to a trigger request, wherein the trigger request is used to trigger a target function of a target application, and the first data object is implemented based on a first data model and is used to carry and implement request content corresponding to the trigger request;

[0009] A processing unit, configured to obtain a target entity according to the first data object, wherein the target entity is implemented based on a second data model and is configured to represent a domain logic corresponding to the request content;

[0010] A generating unit is used to trigger an event processor to generate a processing result based on the target entity, and return the processing result to the terminal device.

[0011] In a third aspect, an embodiment of the present disclosure provides an electronic device, including: a processor and a memory;

[0012] The memory stores computer-executable instructions;

[0013] The processor executes the computer-executable instructions stored in the memory, so that the at least one processor executes the domain-driven function request method described in the first aspect and various possible designs of the first aspect.

[0014] In a fourth aspect, an embodiment of the present disclosure provides a computer-readable storage medium, in which computer execution instructions are stored. When a processor executes the computer execution instructions, the domain-driven function request method described in the first aspect and various possible designs of the first aspect is implemented.

[0015] In a fifth aspect, an embodiment of the present disclosure provides a computer program product, including a computer program, which, when executed by a processor, implements the domain-driven function request method as described in the first aspect and various possible designs of the first aspect.

[0016] The domain-driven function request method, device, equipment and storage medium provided in this embodiment generate a first data object in response to a trigger request, wherein the trigger request is used to trigger the target function of the target application, and the first data object is implemented based on the first data model and is used to carry and implement the request content corresponding to the trigger request; according to the first data object, a target entity is obtained, and the target entity is implemented based on the second data model and is used to characterize the domain logic corresponding to the request content; based on the target entity, the trigger event processor generates a processing result and returns the processing result to the terminal device. By converting the trigger request of the target function into the first data object, and then obtaining the corresponding target entity based on the first data object, and triggering the event processor based on the target entity to obtain the processing result, and by orderly using the first data model and the second data model to transmit the request content, a rapid response to the trigger request is achieved, the triggering efficiency and speed of the target function are improved, and the time consumption of the target function triggering process is reduced. BRIEF DESCRIPTION OF THE DRAWINGS

[0017] In order to more clearly illustrate the embodiments of the present disclosure or the technical solutions in the prior art, the drawings required for use in the embodiments or the description of the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of the present disclosure. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying creative labor.

[0018] Figure 1An application scenario diagram of a domain-driven function request method provided in an embodiment of the present disclosure;

[0019] Figure 2 A schematic diagram of a process of a domain-driven function request method provided in an embodiment of the present disclosure Figure 1 ;

[0020] Figure 3 for Figure 2 A flowchart of a specific implementation method of step S102 in the illustrated embodiment;

[0021] Figure 4 A schematic diagram of a target entity provided by an embodiment of the present disclosure;

[0022] Figure 5 A schematic diagram of an event queue provided in an embodiment of the present disclosure;

[0023] Figure 6 A schematic diagram of a process of a domain-driven function request method provided in an embodiment of the present disclosure Figure 2 ;

[0024] Figure 7 for Figure 6 A flowchart of a specific implementation method of step S204 in the illustrated embodiment;

[0025] Figure 8 for Figure 7 A flowchart of a specific implementation method of step S2042 in the illustrated embodiment;

[0026] Fig. 9 for Figure 6 A flowchart of a specific implementation method of step S206 in the illustrated embodiment;

[0027] Fig.10 A schematic diagram of a process of requesting a target function provided by an embodiment of the present disclosure;

[0028] Fig.11 A structural block diagram of a domain-driven function request device provided in an embodiment of the present disclosure;

[0029] Fig.12 A schematic diagram of the structure of an electronic device provided in an embodiment of the present disclosure;

[0030] Fig.13 A schematic diagram of the hardware structure of an electronic device provided in an embodiment of the present disclosure. DETAILED DESCRIPTION

[0031] In order to make the purpose, technical solution and advantages of the embodiments of the present disclosure clearer, the technical solution in the embodiments of the present disclosure will be clearly and completely described below in conjunction with the drawings in the embodiments of the present disclosure. Obviously, the described embodiments are part of the embodiments of the present disclosure, not all of the embodiments. Based on the embodiments in the present disclosure, all other embodiments obtained by ordinary technicians in this field without creative work are within the scope of protection of the present disclosure.

[0032] It should be noted that the user information (including but not limited to user device information, user personal information, etc.) and data (including but not limited to data used for analysis, stored data, displayed data, etc.) involved in this disclosure are all information and data authorized by the user or fully authorized by all parties, and the collection, use and processing of relevant data must comply with the relevant laws, regulations and standards of relevant countries and regions, and provide corresponding operation entrances for users to choose to authorize or refuse.

[0033] The application scenarios of the embodiments of the present disclosure are explained below:

[0034] Figure 1 This is an application scenario diagram of the domain-driven function request method provided in the embodiment of the present disclosure. The domain-driven function request method provided in the embodiment of the present disclosure can be applied to the scenario of calling functions in an application developed based on Nodejs. More specifically, for example, it can be applied to the application scenario of function requests for Web applications developed based on Nodejs, such as data processing systems. The execution subject of this embodiment can be a server running the above-mentioned Web application, or other electronic devices that perform similar functions. Reference Figure 1 As shown in, taking the server as the execution subject as an example, the user sends a function trigger request for the target application to the server by operating the terminal device, such as a data query request, a configuration request, etc. After the server receives the function trigger request sent by the terminal device, it responds to the function trigger request based on the domain-driven function request method provided in this embodiment, and returns the processing result to the terminal device. The terminal device displays the received processing result, so that the user operating the terminal device can perform subsequent operations based on the processing result displayed by the terminal device.

[0035] In the prior art, for applications developed based on domain-driven design in Web scenarios, the application client usually sends a request to the server, and the server responds to the request to complete the process of function request in the application. However, in the process of implementing function request of domain-driven applications in the prior art, there are problems such as low function execution efficiency and long time consumption, which affects the program performance of the application.

[0036] The disclosed embodiment provides a domain-driven function request method to solve the above problems.

[0037] refer to Figure 2 , Figure 2 A schematic diagram of a process of a domain-driven function request method provided in an embodiment of the present disclosure Figure 1 The method of this embodiment can be applied to a server or an electronic device with similar functions. The domain-driven function request method includes:

[0038] Step S101: In response to a trigger request, a first data object is generated. The trigger request is used to trigger a target function of a target application. The first data object is implemented based on a first data model and is used to carry request content corresponding to the trigger request.

[0039] For example, reference Figure 1 In the schematic diagram of the application scenario shown in the figure, the trigger request is a request information sent by the terminal device to the execution subject server of the method of this embodiment to trigger the target function of the target application. More specifically, for example, the trigger request sent by the terminal device to the server is a query request, which is used to query a specific information of an item in the data processing system (i.e., the target application), such as product information. After receiving the above-mentioned trigger request sent by the terminal device, the server first converts the trigger request to generate a data object that can be processed by the server using the method provided by this embodiment, i.e., the first data object. Among them, the first data object is an anemic data object (i.e., the object does not contain business logic) implemented based on the first data model, and carries the request content corresponding to the trigger request. Further, the first data model is an anemic model. In contrast, the second data model is a congested model (involved in subsequent steps). The second data model refers to that "data" and the corresponding "business logic" are encapsulated in the same class, and has object-oriented encapsulation characteristics. The specific concepts of the first data model and the second data model are prior art known to those skilled in the art, and the specific concepts of the first data model and the second data model are not introduced in more detail here.

[0040] In a possible implementation, the first data object is a data transfer object (Data TransferObject, DTO). On the service side (i.e., the server side) of the target application, a functional module is deployed for converting external information such as a trigger request into data that can be processed by the server, such as a controller module (Controller). After obtaining the trigger request, the controller module encapsulates the request content in the trigger request into a data transfer object based on the first data model, and then sends the encapsulated data transfer object to the application service to execute subsequent steps. Through the above steps, the data transmission process can be simplified, the complexity and amount of data transmission can be reduced, thereby achieving the purpose of improving transmission efficiency.

[0041] Furthermore, the specific generation method of the above data transfer object can dynamically create the type of the data transfer object through the engineering function, and describe the data structure of the data transfer object through the Schema. Afterwards, based on specific needs, the factory function can be used to create a data transfer object of any data transfer object type, which will not be repeated here.

[0042] Step S102: According to the first data object, a target entity is obtained. The target entity is implemented based on the second data model and is used to represent the domain logic corresponding to the request content.

[0043] Exemplarily, after obtaining the first data object, the first data object is processed to obtain a target entity (Entity) based on the second data model implementation for characterizing the domain logic corresponding to the request content. Based on the introduction to the second data model in the previous step, the entity is a pure memory-intensive business model and is the main link in implementing domain logic. Domain logic is the business logic used to implement specific purposes in the domain-driven design pattern. The domain logic in this implementation step is the business logic used to implement the request content corresponding to the trigger request. The target entity can be created, loaded, or updated by the application service module. In one possible implementation, such as Figure 3 As shown, the specific implementation of step S102 includes:

[0044] Step S1021: Send the first data object to the application service, where the application service is used to obtain the target entity based on the command and query responsibility separation mode.

[0045] Step S1022: Process the first data object through application services to obtain a target entity, wherein the target entity has at least one entity attribute and / or at least one entity method, the entity attribute is used to obtain data elements of the first data object; the entity method is used to operate the first data object.

[0046] Exemplarily, the first data object is sent to the application service by the controller module introduced in the previous step, and the application service is implemented based on the command and query responsibility separation pattern (Command Query Responsibility Segregation, CQRS). Among them, the command and query responsibility separation pattern is an architectural pattern related to domain-driven design. Under the command and query responsibility separation pattern, each command (Command) and query (Query) needs to be split. Called uniformly through the command bus (Command Bus) or the query bus (QueryBus). In a specific implementation, the application service can be implemented using an ordinary injection service, that is, by setting a command service (Command Service) decorator and injecting the service into the decorator to implement the above-mentioned application service. Among them, the call to the command service can be implemented by injecting the command bus (Command Bus) into the controller module (Controller) introduced in the above steps.

[0047] Furthermore, by processing the first data object through the application service, the corresponding target entity can be obtained. For example, the request content carried by the first data object is, for example, a query request. Then, the application service creates a target entity based on the first data object. The target entity has at least one entity attribute and / or at least one entity method. The entity attribute is used to obtain the data element of the first data object; the entity method is used to operate the first data object. That is, an anemic data object (first data object) needs to be maintained inside the target entity for persistent storage. The attributes of the entity are all converted from the first data object, and all the methods of the entity are operating on the first data object.

[0048] Figure 4 A schematic diagram of a target entity provided by an embodiment of the present disclosure, such as Figure 4 As shown, exemplarily, within the target entity, an anemic data object Obj_1 is maintained, and the object Obj_1 contains two data elements in the form of key-value pairs (key:value), wherein the keyword key represents the data name corresponding to the data element, and the corresponding value value represents the numerical value corresponding to the data element; for example, as shown in the figure, the data elements are [Category:Cat] and [Quantity:19], respectively representing the object type as Cat and the quantity as 19. Further, the object Obj_1 may be generated by the first data object, or may be the first data object itself.

[0049] At the same time, the target entity has entity attributes attr_is_over and Category; the target entity also has an entity method set_Quantity, wherein when the entity attribute attr_is_over of the target entity is accessed by an external object, the internal object Obj_1 (shown as Obj_1 in the figure) will be processed, specifically, it is determined whether the value corresponding to the data element with the keyword Quantity in the object Obj_1 satisfies the preset condition, such as greater than 18 (shown as Quantity>18? in the figure). If the above preset condition is met, the entity attribute attr_is_over returns 1 when accessed by the external object, otherwise, it returns 0. The external object cannot directly obtain the data elements in the object Obj_1, but can only obtain the corresponding entity data through the encapsulated target entity, thereby ensuring data security. Similarly, when the entity attribute Category of the target entity is accessed by an external object, the internal object Obj_1 will be processed and the corresponding value "Cat" will be obtained directly based on the data element [Category:Cat]. The value "Cat" is then returned to the external object that accesses the entity attribute Category. On the other hand, when the external object calls the entity method set_Quantity, the data element [Quantity:19] of the object Obj_1 can be modified to achieve the purpose of operating the first data object. Through the entity attributes and entity methods provided by the above-mentioned target entity, the creation, update and loading of the target entity based on the second data model can be realized, and the specific implementation method will not be repeated here.

[0050] Furthermore, in a possible implementation, an event queue is maintained inside the target entity, and the event queue is used to store domain events thrown by entity methods, wherein domain events are the way to implement domain logic. After an entity method is called by an external object, a domain event corresponding to the entity method is generated. As the domain event is consumed, the calling process of the entity method ends. Among them, domain events are an important part of domain-driven design. Through domain events, the side effects (Effect) generated by the domain model (entity) method can be delayed to ensure the purity of the pure memory domain model (entity) and improve the scalability of the domain model (entity).

[0051] Furthermore, in the process of executing the corresponding domain logic, the generated domain events can be stored in the event queue inside the target entity, and the domain events can be published by operating the event queue. This can achieve buffering and asynchronous processing in the process of domain event publishing and improve the stability of the process of responding to the target function. Figure 5 A schematic diagram of an event queue provided by an embodiment of the present disclosure, such as Figure 5As shown, an event queue is set in the target entity. When the domain event thrown by the internal method (entity method) is stored in the event queue, when the event is published, the repository executes the publishing method in the target entity (shown as commit in the figure), thereby realizing the publication of the domain event in the event queue.

[0052] Step S103: Based on the target entity, the event processor is triggered to generate a processing result, and the processing result is returned to the terminal device.

[0053] Exemplarily, after obtaining the target entity, the target entity is further processed to implement the domain logic corresponding to the request content represented by the target entity, and the processing result corresponding to the final request content is generated based on the event handler. The processing result is the result of the server responding to the trigger request and executing the target function of the target application. After that, the server returns the processing result to the terminal device, completing the process of the terminal device (client) making a function request to the server (server).

[0054] The above process of processing the target entity can be achieved by publishing a domain event corresponding to the request content based on the target entity, and then the corresponding event processor processes the domain event, and finally completes the execution of the domain logic to obtain the processing result. The event processor can be obtained by injecting the corresponding service. In a possible implementation, before step S103, it also includes:

[0055] Step S100A: Get the decorator of the event handler, and associate the decorator with the target event

[0056] Step S100B: inject the target service into the decorator to generate an event handler, wherein the target service is used to process the target event to obtain a corresponding processing result.

[0057] Exemplarily, a decorator is a special function that can accept a class as a parameter. There is a specific parameter inside the decorator function, which is the decorated class itself. In the steps of this embodiment, the decorator of the event handler is first obtained. The decorator of the event handler is associated with the target event, and the target event is the domain event corresponding to the request content. After that, the target service for processing the target event is injected into the decorator, thereby generating an event handler that can process the target event, until the domain event (i.e., the target event) published by the target entity is processed based on the event handler, and the purpose of responding to the trigger request is completed.

[0058] Among them, the decorator is an existing technology implemented by technical personnel in this field, and has corresponding implementation methods in different development languages, which will not be described in detail here.

[0059] The steps of this embodiment are as follows: by responding to a trigger request, a first data object is generated, the trigger request is used to trigger the target function of the target application, the first data object is implemented based on the first data model, and is used to carry the request content corresponding to the trigger request; according to the first data object, a target entity is obtained, the target entity is implemented based on the second data model, and is used to characterize the domain logic corresponding to the request content; based on the target entity, the trigger event processor generates a processing result and returns the processing result to the terminal device. By converting the trigger request of the target function into a first data object, then obtaining the corresponding target entity based on the first data object, and triggering the event processor based on the target entity to obtain the processing result, by orderly using the first data model and the second data model to transmit the request content, a rapid response to the trigger request is achieved, the triggering efficiency and speed of the target function are improved, and the time consumption of the target function triggering process is reduced.

[0060] refer to Figure 6 , Figure 6 A schematic diagram of a process of a domain-driven function request method provided in an embodiment of the present disclosure Figure 2 In this embodiment Figure 2 On the basis of the embodiment shown, the solution is further refined, and the domain-driven function request method includes:

[0061] Step S201: In response to a trigger request, a first data object is generated. The trigger request is used to trigger a target function of a target application. The first data object is implemented based on a first data model and is used to carry request content corresponding to the trigger request.

[0062] Step S202: Send the first data object to the application service, where the application service is used to obtain the target entity based on the command and query responsibility separation mode.

[0063] Step S203: Process the first data object through application services to obtain a target entity.

[0064] Step S204: Publish a target event based on the target entity, where the target event is a domain event corresponding to the request content.

[0065] Exemplarily, after the application service processes the first data object and obtains the target entity, the corresponding domain logic can be implemented through the method provided by the target entity. Specifically, the corresponding target event can be published through the target entity, and the target event is the domain event corresponding to the request content. Previously, the corresponding domain logic was implemented by processing the target event.

[0066] For example, Figure 7 As shown, the specific implementation of step S204 includes:

[0067] Step S2041: Send the target entity to the repository.

[0068] Step S2042: Detect and persist the target entity through the repository.

[0069] Step S2043: Publish the target event corresponding to the target entity.

[0070] Exemplarily, the target event corresponding to the target entity is published, which is implemented by the repository module deployed in the server. Specifically, the repository can be used for the persistence of the domain model (entity), and it is also necessary to detect the domain model and publish the domain event in the repository. In a possible implementation, after the target entity is sent to the repository (that is, after the repository is called), the repository first detects the target entity, that is, the availability check, to verify whether the target entity is available (validate); then, after the test passes and it is determined that the target entity is available, the target entity is persisted. Furthermore, after the repository persists the target entity, the automatic publishing hook function is executed to complete the automatic publishing of the target event corresponding to the target entity.

[0071] For example, Figure 8 As shown, the specific implementation of step S2042 includes:

[0072] Step S2042A: Call the first hook function to perform detection on the target entity.

[0073] Step S2042B: After the detection is passed, execute the save function to persist the target entity.

[0074] Correspondingly, the specific implementation method of step S2043 includes: after the persistence is completed, calling the second hook function to publish the target event corresponding to the target entity.

[0075] Exemplarily, the hook function is also called a callback function or an event processing function. It is a function that can be triggered and executed when a certain event occurs. After the hook function is triggered, the calling function referred to by the parameters in the hook function will be executed, so that we can process the event at a specific moment. In this embodiment, the first hook function is used to perform a detection on the target entity to detect whether the target entity is available; and the second hook function is used to perform automatic publishing of the target event corresponding to the target entity. Among them, the specific implementation of detecting whether the target entity is available can be set based on needs, and the specific implementation of the automatic publishing of the target event corresponding to the target entity can be determined based on the specific request content, which will not be repeated here.

[0076] Step S205: Send the target event to the event bus.

[0077] Step S206: Process the target event in the event bus through the event processor to obtain a processing result.

[0078] Exemplarily, after publishing the target event, the target event is pushed to the event bus (Event Bus) for asynchronous processing. Afterwards, the target event in the event bus is processed by the event processor generated above, thereby obtaining a processing result. Among them, the event bus is a functional module under the domain-driven design framework, and its specific implementation method is the prior art, and its specific implementation principle is not repeated here.

[0079] For example, Fig. 9 As shown, the specific implementation of step S206 includes:

[0080] Step S2061: Locate the event constructor of the target event.

[0081] Step S2062: Obtain the corresponding target event handler by addressing and searching the event constructor of the target event.

[0082] Step S2063: Process the target event through the target event processor to obtain the processing result.

[0083] Exemplarily, the event bus is also a service that is annotated with lambda, and events can be published through a preset publishing method. The corresponding event handler is found by addressing the event constructor and called. The event handler queried by the addressing method is the target event handler for processing the target event. For example, if the target event is "verify the legality of the characters", the corresponding target event handler is a service for executing the above target event. Afterwards, based on the target event handler, the target event is processed to obtain the processing result. For example, if the processing result is a Boolean value "1" returned by the target event handler, it indicates that the character is legal; if the processing result is a Boolean value "0" returned by the target event handler, it indicates that the character is illegal. Among them, the specific implementation method of addressing the event constructor to obtain the corresponding target object is a prior art and will not be repeated here.

[0084] In a possible implementation, before the target event is processed by the target event processor, the method further includes: registering the event processor corresponding to the target event into the preset event processor cache data by the decorator. Accordingly, the specific implementation of step S2063 includes: obtaining at least two target event processors from the event processor cache data, and processing the corresponding target events on the event bus in parallel to obtain a processing result.

[0085] For example, in a possible implementation, during the process of registering an event processor, the event processor corresponding to the target event is stored in the event processor cache data, such as a set of Map data. Afterwards, when the target event is processed by the event processor, multiple target event processors are obtained from the processor cache data until the corresponding target event is processed synchronously by multiple target event processors, thereby achieving the purpose of synchronously processing multiple target events and improving the processing efficiency of target events. Among them, the above-mentioned event processor cache data is implemented based on Nodejs.

[0086] Step S207: Receive the processing result through the application service, and convert the processing result into a second data object.

[0087] Step S208: Return the processing result to the terminal device via the second data object.

[0088] Exemplarily, after obtaining the processing result, in the process of returning the processing result to the terminal device, it first passes through the above-mentioned application service, and the application service converts the processing result into an anemic data object again, that is, the second data object, that is, the data transmission object (DTO) that can be processed by the controller module. Thereafter, the data transmission object is processed by the controller module, and the processing result is returned to the terminal device. This can further simplify the data transmission process, reduce the complexity and amount of data transmission, and thus achieve the purpose of improving transmission efficiency.

[0089] In order to better introduce the specific implementation steps of the domain-driven function request method provided in this embodiment, Fig.10 , to illustrate with a more specific embodiment, Fig.10 A schematic diagram of a process of requesting a target function provided by an embodiment of the present disclosure, referring to Fig.10As shown, first, the terminal device sends a trigger request to the controller module of the server, and then the controller module parses the trigger request into a data transmission object; then, the controller module calls (Call) the application service and obtains the target entity through the application service. Among them, the application service can create (Create) the target entity, or read (Load) the target entity from the repository; at the same time, the application service can also update (Update) the obtained target entity and store (Save) the target entity to the repository. Further, after receiving the target entity sent by the application service, the repository detects and persists the target entity, and publishes the target event corresponding to the target entity to the event bus, and then the event processor processes the target event on the event bus to obtain the processing result. After that, the processing result is sent back to the terminal device through the event bus, the repository, the application service, and the controller module in sequence. In this process, the application service encapsulates the processing result into a data transmission object, and sends the data transmission object to the controller module. The controller module generates a response signal based on the data transmission object and the communication protocol, and sends it to the terminal device to realize the return of the processing result to the terminal device.

[0090] In this embodiment, the implementation method of steps S201 to S203 is the same as that of the present disclosure. Figure 2 The illustrated embodiments have been described in detail and will not be described in detail here.

[0091] Corresponding to the domain-driven function request method in the above embodiment, Fig.11 A structural block diagram of a domain-driven function request device provided in an embodiment of the present disclosure. For ease of explanation, only the parts related to the embodiment of the present disclosure are shown. Fig.11 , the domain-driven function request device 3 includes:

[0092] A response unit 31, configured to generate a first data object in response to a trigger request, wherein the trigger request is used to trigger a target function of a target application, and the first data object is implemented based on a first data model and is used to carry request content corresponding to the trigger request;

[0093] A processing unit 32 is used to obtain a target entity according to the first data object, where the target entity is implemented based on the second data model and is used to represent the domain logic corresponding to the request content;

[0094] The generating unit 33 is used to trigger the event processor to generate a processing result based on the target entity, and return the processing result to the terminal device.

[0095] In one embodiment of the present disclosure, the processing unit 32 is specifically used to: send the first data object to an application service, the application service is used to obtain a target entity based on a command and query responsibility separation pattern; process the first data object through the application service to obtain a target entity, wherein the target entity has at least one entity attribute and / or at least one entity method, the entity attribute is used to obtain a data element of the first data object; the entity method is used to operate on the first data object.

[0096] In one embodiment of the present disclosure, an event queue is maintained inside the target entity, and the event queue is used to store domain events thrown by entity methods.

[0097] In one embodiment of the present disclosure, the processing unit 32 is further used to: receive the processing result through the application service, and convert the processing result into a second data object; when the generation unit 33 returns the processing result to the terminal device, it is specifically used to: return the processing result to the terminal device through the second data object.

[0098] In one embodiment of the present disclosure, when the generation unit 33 triggers the event processor to generate a processing result based on the target entity, it is specifically used to: publish a target event based on the target entity, where the target event is a domain event corresponding to the request content; send the target event to the event bus; and process the target event in the event bus through the event processor to obtain a processing result.

[0099] In one embodiment of the present disclosure, when publishing a domain event based on a target entity, the generation unit 33 is specifically used to: send the target entity to a repository; and publish a target event corresponding to the target entity after the repository persists the target entity.

[0100] In one embodiment of the present disclosure, before publishing the target event corresponding to the target entity, the generating unit 33 is further used to: detect and persist the target entity through the repository.

[0101] In one embodiment of the present disclosure, when the target entity is detected and persisted through the repository, the generation unit 33 is specifically used to: call the first hook function to perform detection on the target entity; after the detection passes, execute the save function to persist the target entity; when the generation unit 33 publishes the target event corresponding to the target entity, the generation unit 33 is specifically used to: after persistence is completed, call the second hook function to publish the target event corresponding to the target entity.

[0102] In one embodiment of the present disclosure, when the generation unit 33 processes the target event on the event bus through the event processor and obtains the processing result, it is specifically used to: locate the event constructor of the target event; obtain the corresponding target event processor by addressing the event constructor; process the target event through the target event processor to obtain the processing result.

[0103] In one embodiment of the present disclosure, the generation unit 33 is also used to: register the event handler corresponding to the target event into the preset event handler cache data through the decorator; when the generation unit 33 processes the target event on the event bus through the event handler and obtains the processing result, it is specifically used to: obtain at least two target event handlers from the event handler cache data, and process the corresponding target events on the event bus in parallel to obtain the processing result.

[0104] In one embodiment of the present disclosure, the generation unit 33 is further used to: obtain a decorator of an event handler, the decorator being associated with a target event; inject a target service into the decorator to generate an event handler, wherein the target service is used to process the target event and obtain a corresponding processing result.

[0105] The response unit 31, the processing unit 32 and the generating unit 33 are connected in sequence. The domain-driven function request device 3 provided in this embodiment can execute the technical solution of the above method embodiment, and its implementation principle and technical effect are similar, which will not be repeated in this embodiment.

[0106] Fig.12 A schematic diagram of the structure of an electronic device provided by an embodiment of the present disclosure is shown in FIG. Fig.12 As shown, the electronic device 4 includes:

[0107] A processor 41, and a memory 42 communicatively connected to the processor 41;

[0108] The memory 42 stores computer executable instructions;

[0109] The processor 41 executes the computer execution instructions stored in the memory 42 to implement the following Figure 2-Figure 10 The domain-driven function request method in the illustrated embodiment.

[0110] Optionally, the processor 41 and the memory 42 are connected via a bus 43 .

[0111] For related instructions, please refer to Figure 2-Figure 10 The relevant descriptions and effects corresponding to the steps in the corresponding embodiments can be understood, and no further elaboration is made here.

[0112] The present invention provides a computer-readable storage medium, wherein the computer-readable storage medium stores computer-executable instructions, which are used to implement the present invention when executed by a processor. Figure 2-Figure 10 A domain-driven function request method is provided in any of the corresponding embodiments.

[0113] In order to implement the above embodiment, the embodiment of the present disclosure also provides an electronic device.

[0114] refer to Fig.13 , which shows a schematic diagram of the structure of an electronic device 900 suitable for implementing the embodiment of the present disclosure, and the electronic device 900 may be a terminal device or a server. The terminal device may include but is not limited to mobile terminals such as mobile phones, notebook computers, digital broadcast receivers, personal digital assistants (PDAs), tablet computers (Portable Android Devices, PADs), portable multimedia players (PMPs), vehicle terminals (such as vehicle navigation terminals), etc., and fixed terminals such as digital TVs, desktop computers, etc. Fig.13 The electronic device shown is only an example and should not bring any limitation to the functions and scope of use of the embodiments of the present disclosure.

[0115] like Fig.13 As shown, the electronic device 900 may include a processing device (e.g., a central processing unit, a graphics processing unit, etc.) 901, which can perform various appropriate actions and processes according to a program stored in a read-only memory (ROM) 902 or a program loaded from a storage device 908 to a random access memory (RAM) 903. In the RAM 903, various programs and data required for the operation of the electronic device 900 are also stored. The processing device 901, the ROM 902, and the RAM 903 are connected to each other via a bus 904. An input / output (I / O) interface 905 is also connected to the bus 904.

[0116] Typically, the following devices may be connected to the I / O interface 905: input devices 906 including, for example, a touch screen, a touch pad, a keyboard, a mouse, a camera, a microphone, an accelerometer, a gyroscope, etc.; output devices 907 including, for example, a liquid crystal display (LCD), a speaker, a vibrator, etc.; storage devices 908 including, for example, a magnetic tape, a hard disk, etc.; and communication devices 909. The communication device 909 may allow the electronic device 900 to communicate with other devices wirelessly or by wire to exchange data. Although Fig.13 The electronic device 900 is shown with various devices, but it should be understood that it is not required to implement or possess all the devices shown. More or fewer devices may be implemented or possessed instead.

[0117] In particular, according to an embodiment of the present disclosure, the process described above with reference to the flowchart can be implemented as a computer software program. For example, an embodiment of the present disclosure includes a computer program product, which includes a computer program carried on a computer-readable medium, and the computer program contains program code for executing the method shown in the flowchart. In such an embodiment, the computer program can be downloaded and installed from a network through a communication device 909, or installed from a storage device 908, or installed from a ROM 902. When the computer program is executed by the processing device 901, the above-mentioned functions defined in the method of the embodiment of the present disclosure are executed.

[0118] It should be noted that the computer-readable medium disclosed above may be a computer-readable signal medium or a computer-readable storage medium or any combination of the above two. The computer-readable storage medium may be, for example, but not limited to, an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, device or device, or any combination of the above. More specific examples of computer-readable storage media may include, but are not limited to: an electrical connection with one or more wires, a portable computer disk, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disk read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the above. In the present disclosure, a computer-readable storage medium may be any tangible medium containing or storing a program that may be used by or in combination with an instruction execution system, device or device. In the present disclosure, a computer-readable signal medium may include a data signal propagated in a baseband or as part of a carrier wave, in which a computer-readable program code is carried. This propagated data signal may take a variety of forms, including but not limited to an electromagnetic signal, an optical signal, or any suitable combination of the above. The computer readable signal medium may also be any computer readable medium other than a computer readable storage medium, which may send, propagate or transmit a program for use by or in conjunction with an instruction execution system, apparatus or device. The program code contained on the computer readable medium may be transmitted using any suitable medium, including but not limited to: wires, optical cables, RF (radio frequency), etc., or any suitable combination of the above.

[0119] The computer-readable medium may be included in the electronic device, or may exist independently without being incorporated into the electronic device.

[0120] The computer-readable medium carries one or more programs. When the one or more programs are executed by the electronic device, the electronic device executes the method shown in the above embodiment.

[0121] Computer program code for performing the operations of the present disclosure may be written in one or more programming languages ​​or a combination thereof, including object-oriented programming languages, such as Java, Smalltalk, C++, and conventional procedural programming languages, such as "C" or similar programming languages. The program code may be executed entirely on the user's computer, partially on the user's computer, as an independent software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In the case of a remote computer, the remote computer may be connected to the user's computer via any type of network, including a local area network (LAN) or a wide area network (WAN), or may be connected to an external computer (e.g., via the Internet using an Internet service provider).

[0122] The flow chart and block diagram in the accompanying drawings illustrate the possible architecture, function and operation of the system, method and computer program product according to various embodiments of the present disclosure. In this regard, each square box in the flow chart or block diagram can represent a module, a program segment or a part of a code, and the module, the program segment or a part of the code contains one or more executable instructions for realizing the specified logical function. It should also be noted that in some implementations as replacements, the functions marked in the square box can also occur in a sequence different from that marked in the accompanying drawings. For example, two square boxes represented in succession can actually be executed substantially in parallel, and they can sometimes be executed in the opposite order, depending on the functions involved. It should also be noted that each square box in the block diagram and / or flow chart, and the combination of the square boxes in the block diagram and / or flow chart can be implemented with a dedicated hardware-based system that performs a specified function or operation, or can be implemented with a combination of dedicated hardware and computer instructions.

[0123] The units involved in the embodiments described in the present disclosure may be implemented by software or hardware. The name of a unit does not limit the unit itself in some cases. For example, the first acquisition unit may also be described as a "unit for acquiring at least two Internet Protocol addresses".

[0124] The functions described above herein may be performed at least in part by one or more hardware logic components. For example, without limitation, exemplary types of hardware logic components that may be used include: field programmable gate arrays (FPGAs), application specific integrated circuits (ASICs), application specific standard products (ASSPs), systems on chips (SOCs), complex programmable logic devices (CPLDs), and the like.

[0125] In the context of the present disclosure, a machine-readable medium may be a tangible medium that may contain or store a program for use by or in conjunction with an instruction execution system, device, or equipment. A machine-readable medium may be a machine-readable signal medium or a machine-readable storage medium. A machine-readable medium may include, but is not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, device, or equipment, or any suitable combination of the foregoing. A more specific example of a machine-readable storage medium may include an electrical connection based on one or more lines, a portable computer disk, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disk read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing.

[0126] In a first aspect, according to one or more embodiments of the present disclosure, a domain-driven function request method is provided, including:

[0127] In response to a trigger request, a first data object is generated, wherein the trigger request is used to trigger a target function of a target application, and the first data object is implemented based on a first data model and is used to carry and implement request content corresponding to the trigger request; based on the first data object, a target entity is obtained, and the target entity is implemented based on a second data model and is used to characterize the domain logic corresponding to the request content; based on the target entity, a trigger event processor generates a processing result, and returns the processing result to the terminal device.

[0128] According to one or more embodiments of the present disclosure, obtaining the target entity based on the first data object includes: sending the first data object to an application service, the application service being used to obtain the target entity based on a command and query responsibility separation pattern; processing the first data object through the application service to obtain the target entity, wherein the target entity has at least one entity attribute and / or at least one entity method, the entity attribute being used to obtain data elements of the first data object; and the entity method being used to operate on the first data object.

[0129] According to one or more embodiments of the present disclosure, an event queue is maintained inside the target entity, and the event queue is used to store domain events thrown by the entity method.

[0130] According to one or more embodiments of the present disclosure, the method further includes: receiving the processing result through the application service, and converting the processing result into a second data object; returning the processing result to the terminal device includes: returning the processing result to the terminal device through the second data object.

[0131] According to one or more embodiments of the present disclosure, triggering an event processor to generate a processing result based on the target entity includes: publishing a target event based on the target entity, wherein the target event is a domain event corresponding to the request content; sending the target event to an event bus; and processing the target event in the event bus through an event processor to obtain the processing result.

[0132] According to one or more embodiments of the present disclosure, publishing a domain event based on the target entity includes: sending the target entity to a repository; and publishing a target event corresponding to the target entity after the repository persists the target entity.

[0133] According to one or more embodiments of the present disclosure, before publishing the target event corresponding to the target entity, the method further includes: detecting and persisting the target entity through the repository.

[0134] According to one or more embodiments of the present disclosure, the detection and persistence of the target entity through the repository includes: calling a first hook function to perform detection of the target entity; after the detection passes, executing a save function to persist the target entity; and publishing a target event corresponding to the target entity includes: after the persistence is completed, calling a second hook function to publish a target event corresponding to the target entity.

[0135] According to one or more embodiments of the present disclosure, a target event on the event bus is processed by an event processor to obtain the processing result, including: locating an event constructor of the target event; obtaining a corresponding target event processor by addressing and searching the event constructor; and processing the target event by the target event processor to obtain the processing result.

[0136] According to one or more embodiments of the present disclosure, the method also includes: registering an event handler corresponding to a target event into preset event handler cache data through a decorator; processing the target event on the event bus through the event handler to obtain the processing result, including: obtaining at least two target event handlers from the event handler cache data, and processing the corresponding target events on the event bus in parallel to obtain the processing result.

[0137] According to one or more embodiments of the present disclosure, the method further includes: obtaining a decorator of an event handler, the decorator being associated with the target event; injecting a target service into the decorator to generate the event handler, wherein the target service is used to process the target event to obtain a corresponding processing result.

[0138] In a second aspect, according to one or more embodiments of the present disclosure, a domain-driven function request device is provided, including:

[0139] A response unit, configured to generate a first data object in response to a trigger request, wherein the trigger request is used to trigger a target function of a target application, and the first data object is implemented based on a first data model and is used to carry and implement request content corresponding to the trigger request;

[0140] A processing unit, configured to obtain a target entity according to the first data object, wherein the target entity is implemented based on a second data model and is configured to represent a domain logic corresponding to the request content;

[0141] A generating unit is used to trigger an event processor to generate a processing result based on the target entity, and return the processing result to the terminal device.

[0142] According to one or more embodiments of the present disclosure, the processing unit is specifically used to: send the first data object to an application service, the application service is used to obtain a target entity based on a command and query responsibility separation pattern; process the first data object through the application service to obtain the target entity, wherein the target entity has at least one entity attribute and / or at least one entity method, the entity attribute is used to obtain data elements of the first data object; the entity method is used to operate on the first data object.

[0143] According to one or more embodiments of the present disclosure, an event queue is maintained inside the target entity, and the event queue is used to store domain events thrown by the entity method.

[0144] According to one or more embodiments of the present disclosure, the processing unit is further used to: receive the processing result through the application service, and convert the processing result into a second data object; when the generation unit returns the processing result to the terminal device, it is specifically used to: return the processing result to the terminal device through the second data object.

[0145] According to one or more embodiments of the present disclosure, when the generation unit triggers the event processor to generate a processing result based on the target entity, it is specifically used to: publish a target event based on the target entity, where the target event is a domain event corresponding to the request content; send the target event to an event bus; and process the target event in the event bus through the event processor to obtain the processing result.

[0146] According to one or more embodiments of the present disclosure, when the generating unit publishes a domain event based on the target entity, it is specifically used to: send the target entity to a repository; and publish a target event corresponding to the target entity after the repository persists the target entity.

[0147] According to one or more embodiments of the present disclosure, before publishing the target event corresponding to the target entity, the generating unit is further configured to: detect and persist the target entity through the repository.

[0148] According to one or more embodiments of the present disclosure, when the target entity is detected and persisted through the repository, the generation unit is specifically used to: call the first hook function to perform detection of the target entity; after the detection passes, execute the save function to persist the target entity; when the generation unit publishes the target event corresponding to the target entity, the generation unit is specifically used to: after the persistence is completed, call the second hook function to publish the target event corresponding to the target entity.

[0149] According to one or more embodiments of the present disclosure, when the generation unit processes the target event on the event bus through the event processor and obtains the processing result, it is specifically used to: locate the event constructor of the target event; obtain the corresponding target event processor by addressing the event constructor; and process the target event through the target event processor to obtain the processing result.

[0150] According to one or more embodiments of the present disclosure, the generation unit is also used to: register the event handler corresponding to the target event into the preset event handler cache data through the decorator; when the generation unit processes the target event on the event bus through the event handler to obtain the processing result, it is specifically used to: obtain at least two target event handlers from the event handler cache data, and process the corresponding target events on the event bus in parallel to obtain the processing result.

[0151] According to one or more embodiments of the present disclosure, the generation unit is further used to: obtain a decorator of an event handler, the decorator being associated with the target event; inject a target service into the decorator to generate the event handler, wherein the target service is used to process the target event and obtain a corresponding processing result.

[0152] In a third aspect, according to one or more embodiments of the present disclosure, there is provided an electronic device, comprising: at least one processor and a memory;

[0153] The memory stores computer-executable instructions;

[0154] The at least one processor executes the computer-executable instructions stored in the memory, so that the at least one processor executes the domain-driven function request method described in the first aspect and various possible designs of the first aspect.

[0155] In a fourth aspect, according to one or more embodiments of the present disclosure, a computer-readable storage medium is provided, wherein the computer-readable storage medium stores computer execution instructions. When a processor executes the computer execution instructions, the domain-driven function request method described in the first aspect and various possible designs of the first aspect is implemented.

[0156] In a fifth aspect, according to one or more embodiments of the present disclosure, a computer program product is provided, including a computer program, which, when executed by a processor, implements the domain-driven function request method as described in the first aspect and various possible designs of the first aspect.

[0157] The above description is only a preferred embodiment of the present disclosure and an explanation of the technical principles used. Those skilled in the art should understand that the scope of disclosure involved in the present disclosure is not limited to the technical solutions formed by a specific combination of the above technical features, but should also cover other technical solutions formed by any combination of the above technical features or their equivalent features without departing from the above disclosed concept. For example, the above features are replaced with the technical features with similar functions disclosed in the present disclosure (but not limited to) by each other to form a technical solution.

[0158] In addition, although each operation is described in a specific order, this should not be understood as requiring these operations to be performed in the specific order shown or in a sequential order. Under certain circumstances, multitasking and parallel processing may be advantageous. Similarly, although some specific implementation details are included in the above discussion, these should not be interpreted as limiting the scope of the present disclosure. Some features described in the context of a separate embodiment can also be implemented in a single embodiment in combination. On the contrary, the various features described in the context of a single embodiment can also be implemented in multiple embodiments individually or in any suitable sub-combination mode.

[0159] Although the subject matter has been described in language specific to structural features and / or methodological logical actions, it should be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or actions described above. On the contrary, the specific features and actions described above are merely example forms of implementing the claims.

Claims

1. A domain-driven function request method, characterized in that: include: In response to a trigger request, generating a first data object, wherein the trigger request is used to trigger a target function of a target application, and the first data object is implemented based on a first data model and is used to carry and implement request content corresponding to the trigger request; According to the first data object, a target entity is acquired, where the target entity is implemented based on a second data model and is used to represent the domain logic corresponding to the request content; Based on the target entity, the event processor is triggered to generate a processing result, and the processing result is returned to the terminal device.

2. The method according to claim 1, characterized in that: The acquiring a target entity according to the first data object includes: Sending the first data object to an application service, wherein the application service is used to obtain a target entity based on a preset mode; The first data object is processed through the application service to obtain the target entity, wherein the target entity has at least one entity attribute and / or at least one entity method, the entity attribute is used to obtain the data element of the first data object; the entity method is used to operate the first data object.

3. The method according to claim 2, characterized in that The target entity includes an event queue inside, and the event queue is used to store domain events output by the entity method.

4. The method according to claim 2, characterized in that: The method further comprises: receiving the processing result through the application service, and converting the processing result into a second data object, wherein the second data object is implemented based on the first data model; The returning the processing result to the terminal device comprises: The processing result is returned to the terminal device through the second data object.

5. The method according to claim 1, characterized in that The triggering the event processor to generate a processing result based on the target entity includes: Publishing a target event based on the target entity, where the target event is a domain event corresponding to the request content; Sending the target event to an event bus; The target event in the event bus is processed by an event processor to obtain the processing result.

6. The method according to claim 5, characterized in that Publish domain events based on the target entity, including: sending the target entity to a repository; After the repository persists the target entity, a target event corresponding to the target entity is published.

7. The method according to claim 6, characterized in that Before publishing the target event corresponding to the target entity, the method further includes: The target entity is detected and persisted through the repository.

8. The method according to claim 7, characterized in that The detecting and persisting the target entity through the repository includes: Call the first hook function to perform detection on the target entity; After the detection is passed, the save function is executed to persist the target entity; The publishing of the target event corresponding to the target entity includes: After the persistence is completed, the second hook function is called to publish the target event corresponding to the target entity.

9. The method according to claim 5, characterized in that Processing the target event on the event bus through the event processor to obtain the processing result includes: Obtain the corresponding target event handler by addressing and searching the event constructor of the target event; The target event is processed by the target event processor to obtain the processing result.

10. The method according to claim 5, characterized in that The method further comprises: Register the event handler corresponding to the target event to the preset event handler cache data through the decorator; The process of processing the target event on the event bus by the event processor to obtain the processing result includes: At least two target event processors are obtained from the event processor cache data, and corresponding target events on the event bus are processed in parallel to obtain the processing result.

11. The method according to claim 5, characterized in that The method further comprises: Get a decorator of an event handler, the decorator being associated with the target event; The target service is injected into the decorator to generate the event handler, wherein the target service is used to process the target event to obtain a corresponding processing result.

12. A domain-driven function request device, characterized in that: include: A response unit, configured to generate a first data object in response to a trigger request, wherein the trigger request is used to trigger a target function of a target application, and the first data object is implemented based on a first data model and is used to carry and implement request content corresponding to the trigger request; A processing unit, configured to obtain a target entity according to the first data object, wherein the target entity is implemented based on a second data model and is configured to represent a domain logic corresponding to the request content; A generating unit is used to trigger an event processor to generate a processing result based on the target entity, and return the processing result to the terminal device.

13. An electronic device, characterized in that: include: Processor and memory; The memory stores computer-executable instructions; The processor executes the computer-executable instructions stored in the memory, so that the processor executes the domain-driven function request method according to any one of claims 1 to 11.

14. A computer-readable storage medium, characterized in that: The computer-readable storage medium stores computer-executable instructions. When the processor executes the computer-executable instructions, the domain-driven function request method as described in any one of claims 1 to 1 is implemented.

15. A computer program product comprising a computer program, characterized in that When the computer program is executed by a processor, the domain-driven function request method according to any one of claims 1 to 11 is implemented.

Images