Process reuse method and device, electronic equipment and nonvolatile storage medium
By constructing target node and transit node objects, controlling the execution order of nodes using target relationship data, and setting pointers to sub-processes, the problem of insufficient process configuration reuse mechanism in existing technologies is solved, and process configuration is simplified and efficiency is improved.
Patent Information
- Authority / Receiving Office
- CN · China
- Patent Type
- Patents(China)
- Current Assignee / Owner
- CHINA TELECOM CORP LTD
- Filing Date
- 2022-09-06
- Publication Date
- 2026-06-09
Smart Images
Figure CN115794079B_ABST
Abstract
Description
Technical Field
[0001] This application relates to the field of software development technology, and more specifically, to a process reuse method, apparatus, electronic device, and non-volatile storage medium. Background Technology
[0002] With the rapid development of the intelligent era, the voice navigation systems of major telecom operators all include intelligent process management modules for intelligent management of voice processes. These intelligent process management modules allow operators to configure processes directly through a graphical configuration interface, including configuring what audio to play to users and transferring user calls to the corresponding human agents.
[0003] In practical work, many scenarios involve similar or even identical functions. For example, receiving user key input and determining whether the input content / key length meets expectations, judging the success of semantic understanding and providing corresponding error messages, etc. These similar or identical functions are often widely used in different scenarios. However, most existing process configuration, construction, and execution methods do not support reuse mechanisms, resulting in cumbersome and complex process configuration work and low efficiency.
[0004] There is currently no effective solution to the above problems. Summary of the Invention
[0005] This application provides a process reuse method, apparatus, electronic device, and non-volatile storage medium to at least solve the technical problems of cumbersome and complex process configuration and low efficiency caused by the fact that most existing process configuration, construction, and execution methods do not support reuse mechanisms.
[0006] According to one aspect of the embodiments of this application, a process reuse method is provided, comprising: constructing a first target node object and a first transit node object corresponding to the first target node object based on target node data, wherein the first target node object is a target node object in a parent process, and the first transit node object is used to obtain a first target result returned after the first target node object is executed, wherein the target node data includes at least one of the following: subprocess node data; according to target relationship data, sequentially controlling the first transit node object to execute the business logic corresponding to the first target node object, and setting a first target pointer to point to the first target node object being executed, wherein the target relationship data is used to characterize the execution order of each target node object; and when the next target node object to be executed is jumped to a subprocess, setting a second target pointer to point to a second target node object being executed in the subprocess to realize the reuse of the subprocess, wherein the second target node object is a target node object in the subprocess.
[0007] Optionally, controlling the first relay node object to execute the business logic corresponding to the first target node object in sequence, and setting the first target pointer to point to the first target node object being executed includes: controlling the first relay node object to send a target execution instruction to the first target node object to execute the business logic corresponding to the first target node object; obtaining the first target result returned after the first target node object is executed, wherein the first target result includes at least one of the following: rotating the process, rotating to a subsequent node, or the process ends; determining the next planned first target node object to be executed based on the first target result, and setting the first target pointer to point to the next planned first target node object to be executed.
[0008] Optionally, when the next target node object to be executed jumps to a sub-process, setting the second target pointer to point to the second target node object being executed in the sub-process includes: if the first target node object being executed is a sub-process node object, obtaining the first target result returned after the execution of the first target node object being executed, wherein the sub-process node object is the first target node object constructed based on the sub-process node data; if the first target result is a rotor process, jumping to the sub-process; according to the target relationship data corresponding to the sub-process, sequentially controlling the second transfer node object to execute the business logic corresponding to the second target node object, and setting the second target pointer to point to the second target node object being executed.
[0009] Optionally, sequentially controlling the second transit node object to execute the business logic corresponding to the second target node object, and setting the second target pointer to point to the second target node object being executed includes: when jumping to a sub-process and not executing the business logic corresponding to the second target node object in the sub-process, setting the second target pointer to point to the initial second target node object, wherein the initial second target node object is the second target node object that is executed first in the sub-process; executing the business logic corresponding to the initial second target node object by controlling the initial second transit node object to send a target execution instruction to the initial second target node object, wherein the initial second transit node object is the second transit node object corresponding to the initial second target node object; obtaining the second target result returned after the initial second target node object is executed, wherein the second target result includes at least one of the following: rotating the process, rotating to a subsequent node, or ending the process; determining the next planned second target node object to be executed based on the second target result, and setting the second target pointer to point to the next planned second target node object to be executed.
[0010] Optionally, after determining the next planned execution second target node object based on the second target result, the process further includes: if the second target result is the end of the process, ending the subprocess and returning to the parent process; obtaining the first target result returned after the execution of the first target node object pointed to by the first target pointer, which is the subprocess node object; and determining the next planned execution first target node object based on the first target result.
[0011] Optionally, if the second target result is the end of the process, ending the sub-process and returning to the parent process further includes: obtaining the label status information corresponding to the sub-process, wherein the label status information includes: a first state and a second state, the first state being used to indicate that the second target node object in the sub-process has been executed, and the second state being used to indicate that the second target node object in the sub-process has not been executed; if the label status information is the first state, setting the first target result returned by the first target node object corresponding to the sub-process to proceed to the subsequent node; if the label status information is the second state, setting the first target result returned by the first target node object corresponding to the sub-process to proceed to the subsequent process.
[0012] Optionally, determining the first target node object to be executed next according to the first target result includes: if the first target result is a subsequent node, determining the first target node object to be executed next according to the target relationship data corresponding to the parent process; if the first target result is a subprocess, jumping to the subprocess to control the second transit node object in the subprocess to execute the business logic corresponding to the second target node object.
[0013] According to another aspect of the embodiments of this application, a process reuse apparatus is also provided, comprising: an object construction module, configured to construct a first target node object and a first transit node object corresponding to the first target node object based on target node data, wherein the first target node object is a target node object in a parent process, and the first transit node object is configured to obtain a first target result returned after the execution of the first target node object, wherein the target node data includes at least one of the following: subprocess node data; an object execution module, configured to control the first transit node object to execute the business logic corresponding to the first target node object sequentially based on target relationship data, and set a first target pointer to point to the first target node object being executed, wherein the target relationship data is used to characterize the execution order of each target node object; and a process reuse module, configured to set a second target pointer to point to a second target node object being executed in the subprocess when the next target node object to be executed jumps to the subprocess, so as to realize the reuse of the subprocess, wherein the second target node object is a target node object in the subprocess.
[0014] According to another aspect of the embodiments of this application, an electronic device is also provided, the electronic device including a processor, the processor being used to run a program, wherein the program executes a flow reuse method during runtime.
[0015] According to another aspect of the embodiments of this application, a non-volatile storage medium is also provided, the non-volatile storage medium including a stored computer program, wherein the device where the non-volatile storage medium is located executes a process reuse method by running the computer program.
[0016] In this embodiment, a first target node object and a first transit node object corresponding to the first target node object are constructed based on target node data. The first target node object is the target node object in the parent process. The first transit node object is used to obtain the first target result returned after the execution of the first target node object. The target node data includes at least one of the following: sub-process node data. Based on target relationship data, the first transit node object is sequentially controlled to execute the business logic corresponding to the first target node object, and a first target pointer is set to point to the first target node object being executed. The target relationship data is used to characterize the execution order of each target node object. In the next target node to be executed... When a point object jumps to a sub-process, a second target pointer is set to point to the second target node object being executed in the sub-process to achieve sub-process reuse. The second target node object is the target node object in the sub-process. By extracting common scenarios that recur during process configuration into sub-processes and modifying the pointers of process nodes during process configuration, a process reuse mechanism is achieved. This greatly simplifies the workload of process configuration and reduces the possibility of errors during process configuration. In turn, it solves the technical problem of cumbersome and inefficient process configuration caused by the fact that most existing process configuration, construction and execution methods do not support reuse mechanisms. Attached Figure Description
[0017] The accompanying drawings, which are included to provide a further understanding of this application and form part of this application, illustrate exemplary embodiments and are used to explain this application, but do not constitute an undue limitation of this application. In the drawings:
[0018] Figure 1 This is a schematic diagram of a process reuse method provided according to an embodiment of this application;
[0019] Figure 2 This is a schematic diagram of a graphical process configuration interface for IPM (Intelligent Process Management) provided according to an embodiment of this application;
[0020] Figure 3 This is a schematic diagram of process description data provided according to an embodiment of this application;
[0021] Figure 4 This is a schematic diagram of an existing IPM process structure and execution process provided according to an embodiment of this application;
[0022] Figure 5 This is a schematic diagram of an optimized IPM process structure and execution process provided according to an embodiment of this application;
[0023] Figure 6 This is a schematic diagram of an optimized process structure provided according to an embodiment of this application;
[0024] Figure 7 This is a schematic diagram of a sub-process for a user to input a number according to an embodiment of this application;
[0025] Figure 8 This is a schematic diagram of a balance query process that introduces sub-processes according to an embodiment of this application;
[0026] Figure 9 This is a schematic diagram of the structure of a process reuse device according to an embodiment of the present invention;
[0027] Figure 10 This is a hardware structure block diagram of a computer terminal (or electronic device) for implementing a process reuse method according to an embodiment of this application. Detailed Implementation
[0028] To enable those skilled in the art to better understand the present application, the technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present application, and not all embodiments. Based on the embodiments in the present application, all other embodiments obtained by those of ordinary skill in the art without creative effort should fall within the scope of protection of the present application.
[0029] To facilitate a better understanding of the embodiments of this application by those skilled in the art, some technical terms or nouns involved in the embodiments of this application are explained as follows:
[0030] Interactive Voice Response (IVR): This service allows users to access the service center simply by making a phone call. Users can listen to mobile entertainment products based on prompts or receive information based on their input.
[0031] JSON (JavaScript Object Notation) is a lightweight data interchange format.
[0032] It should be noted that the terms "first," "second," etc., in the specification, claims, and accompanying drawings of this application are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence. It should be understood that such data can be interchanged where appropriate so that the embodiments of this application described herein can be implemented in orders other than those illustrated or described herein. Furthermore, the terms "comprising" and "having," and any variations thereof, are intended to cover non-exclusive inclusion; for example, a process, method, system, product, or apparatus that comprises a series of steps or units is not necessarily limited to those steps or units explicitly listed, but may include other steps or units not explicitly listed or inherent to such processes, methods, products, or apparatus.
[0033] Example 1
[0034] In this embodiment, the intelligent process management module that enables intelligent management of the voice process is the IPM (Intelligent Process Management) module.
[0035] The IPM module allows operations personnel to configure processes directly through a graphical configuration interface. Figure 2 This is a schematic diagram of a graphical process configuration interface for IPM (Intelligent Process Management) provided according to an embodiment of this application. The interface effect is as follows: Figure 2 As shown.
[0036] Currently, after the graphical process configuration tool in the IPM module is configured, it generates process description data in JSON format and sends it to the IPM process execution module for saving and loading. This process description data describes the types of nodes and data contained in the process, as well as the relationships between the nodes. Figure 3 This is a schematic diagram illustrating process description data according to an embodiment of this application, such as... Figure 3 As shown, in this embodiment, the process description data includes: target node data and target relationship data.
[0037] After receiving the process description data, the IPM process execution module parses the data, constructs the necessary node objects in the process using the reflection mechanism provided by the Java language, and constructs a linked list data structure based on the sequential relationships between the node objects as shown in the process description data. Figure 4This is a schematic diagram of an existing IPM process structure and execution process provided according to an embodiment of this application, such as... Figure 4 As shown.
[0038] by Figure 4 Taking the process consisting of three nodes as an example, once the process starts executing, the entire execution process is as follows:
[0039] 1) The process executes from the starting node forward, which is usually... Figure 2 The circular nodes in the graphical configuration interface shown;
[0040] 2) The starting node itself does not have any logic, so it cannot get the return result of the entire process. Therefore, the starting node requests the execution result from its subsequent node, namely node A.
[0041] 3) Node A executes its function and finds that it cannot obtain the overall execution result of the process itself, so it requests the execution result from its subsequent node, namely Node B;
[0042] 4) Node B processes similarly to node A, requesting the execution result from its subsequent node, node C;
[0043] 5) When the final node C executes, it finds that it can obtain the execution result of the process, such as playing the recording to the user / transferring the user's call to a human agent, so it returns this execution result to its predecessor node, namely node B;
[0044] 6) After obtaining the result, point B returns to its predecessor node, namely node A, and so on. Finally, the starting node of the process receives the execution result and outputs this result as the result of the entire process.
[0045] The existing IPM process structure and execution process described above do not support a reuse mechanism, resulting in cumbersome and inefficient process configuration. This is mainly because, in actual needs, the processes that need to be reused are usually not all processes in a scenario, but only a part of a process. For example, the part that receives user numbers is extracted as a general process, and then this shared process is introduced into processes that need to use this part of the functionality. However, the current process execution adopts a recursive-like implementation method, that is, if the current node cannot output a return result, it directly calls the function of the same name of the subsequent node to return the execution result. Therefore, the process cannot achieve the effect of "pausing the execution of the current process and switching to another process" during execution, because for the same process, the execution entry point is always fixed at the starting node of the process. In addition, it is also necessary to consider that after entering the shared process, other shared processes may also be nested inside the shared process, and the nesting level is uncertain. The requirement is that after the current process is completed, it should return to the previous level process, and a specific implementation method needs to be considered.
[0046] To address the aforementioned issues, an embodiment of the present application provides a method for process reuse. It should be noted that the steps shown in the flowcharts of the accompanying drawings can be executed in a computer system such as a set of computer-executable instructions. Furthermore, although a logical order is shown in the flowcharts, in some cases, the steps shown or described may be executed in a different order than that shown here.
[0047] Figure 1 This is a schematic diagram of a process reuse method provided according to an embodiment of this application, such as... Figure 1 As shown, the method includes the following steps:
[0048] Step S102: Construct a first target node object and a first transit node object corresponding to the first target node object based on the target node data. The first target node object is the target node object in the parent process. The first transit node object is used to obtain the first target result returned after the first target node object is executed. The target node data includes at least one of the following: subprocess node data.
[0049] Specifically, Figure 5 This is a schematic diagram of an optimized IPM process structure and execution process provided in an embodiment of this application, as shown below. Figure 5 As shown, the first transit node object mentioned above is... Figure 5 The current nodes on the left side of the middle, including the aforementioned first target node object. Figure 5 The starting node, node A, node B, and node C on the right side of the middle.
[0050] Specifically, a set of data types for node execution results (i.e., the type corresponding to the first transit node object mentioned above) will be added to the existing process structure, such as: transfer to subsequent nodes, audio playback, call transfer, transfer to other processes, and entry into sub-processes; at the same time, the execution rules of each type of node in the process will be modified to require that each node should return data of the node execution result type (i.e., the first target result mentioned above) when it is executed.
[0051] Step S104: Based on the target relationship data, control the first transit node object to execute the business logic corresponding to the first target node object in sequence, and set the first target pointer to point to the first target node object being executed. The target relationship data is used to represent the execution order of each target node object.
[0052] In some embodiments of this application, sequentially controlling the first relay node object to execute the business logic corresponding to the first target node object and setting the first target pointer to point to the first target node object being executed includes: controlling the first relay node object to send a target execution instruction to the first target node object to execute the business logic corresponding to the first target node object; obtaining the first target result returned after the first target node object is executed, wherein the first target result includes at least one of the following: rotating the process, rotating to a subsequent node, or the process ends; determining the next planned first target node object to be executed based on the first target result, and setting the first target pointer to point to the next planned first target node object to be executed.
[0053] In this embodiment, the original mechanisms for process parsing, process construction, and data structure of individual processes are kept unchanged to ensure that the graphical configuration function and the generated process description data do not need to be adjusted too much. In addition, a pointer to the current node of the process (i.e. the first target pointer mentioned above) is added. When the process has just been constructed but has not yet started execution, the pointer of the current node points to the starting node of the process.
[0054] Specifically, the function of parsing the execution results of nodes is added. That is, based on the first target result, the first target node object to be executed next is determined. For example, when the node execution result (i.e. the first target result mentioned above) is "send audio playback command", a command message is constructed and sent to the IVR server.
[0055] Step S106: If the next target node object to be executed jumps to the sub-process, set the second target pointer to point to the second target node object being executed in the sub-process to realize the reuse of the sub-process. The second target node object is the target node object in the sub-process.
[0056] In this embodiment, to support the transition to other shared processes during process execution, and the requirement that other shared processes may reference several levels of other shared processes, the process structure during execution has been optimized. Figure 6 This is a schematic diagram of an optimized process structure provided according to an embodiment of this application, such as... Figure 6 As shown.
[0057] Specifically, the data structure of the process is divided into a pointer to the current node to be executed (i.e., the second target pointer mentioned above) and a pointer to the current node of the upper-level process (i.e., the parent process mentioned above) (i.e., the first target pointer mentioned above). When entering a new process, the pointer of the current node to be executed points to the starting node of the new process, and the pointer of the upper-level process is null. If the execution result of the node (i.e., the target result mentioned above) is to move to the subsequent node, then the pointer of the current node is modified to the subsequent node in the current process, and execution continues.
[0058] In some embodiments of this application, when the next target node object to be executed is jumped to a sub-process, setting the second target pointer to point to the second target node object being executed in the sub-process includes: when the first target node object being executed is a sub-process node object, obtaining the first target result returned after the execution of the first target node object being executed, wherein the sub-process node object is a first target node object constructed based on the sub-process node data; when the first target result is a rotor process, jumping to the sub-process; according to the target relationship data corresponding to the sub-process, sequentially controlling the second transfer node object to execute the business logic corresponding to the second target node object, and setting the second target pointer to point to the second target node object being executed.
[0059] In this embodiment, a "subprocess" node is added to the graphical configuration interface, requiring the specification of the process number to be loaded. The code related to the subprocess node is added to the IPM process execution module, and the returned result is "Load new shared process". The process identifier to be loaded is the process number specified during process configuration. When the first target node object being executed is a subprocess node object, the process number and data in the first target result returned after the execution of the first target node object being executed are obtained, and a subroutine is constructed for jump.
[0060] Specifically, if the execution result of a node (i.e., the first target result mentioned above) is to load a shared process (equivalent to the rotor process mentioned above), then the shared process specified in the result is loaded from the storage medium and constructed into a new process (i.e., the sub-process mentioned above). The new process data structure also contains a pointer to the currently executed node (i.e., the second target pointer mentioned above) and a pointer to the current node of the upper-level process (i.e., the parent process) (i.e., the second target pointer mentioned above). The currently executing node (i.e., the currently executing process and its execution status) is transferred to the pointer of the upper-level process of the newly constructed process. Then, the pointer of the currently executed node is pointed to the starting node of the newly constructed process, thus achieving the effect of loading and executing the shared process.
[0061] In some embodiments of this application, sequentially controlling the second transit node object to execute the business logic corresponding to the second target node object, and setting the second target pointer to point to the second target node object being executed includes: when jumping to a sub-process and not executing the business logic corresponding to the second target node object in the sub-process, setting the second target pointer to point to the initial second target node object, wherein the initial second target node object is the second target node object that is executed first in the sub-process; executing the business logic corresponding to the initial second target node object by controlling the initial second transit node object to send a target execution instruction to the initial second target node object, wherein the initial second transit node object is the second transit node object corresponding to the initial second target node object; obtaining the second target result returned after the initial second target node object is executed, wherein the second target result includes at least one of the following: rotating the process, rotating to a subsequent node, or ending the process; determining the next planned second target node object to be executed based on the second target result, and setting the second target pointer to point to the next planned second target node object to be executed.
[0062] Specifically, when the subprocess has just been built but has not yet started execution, the pointer of the current node (i.e. the second target pointer) points to the starting node of the process (i.e. the initial second target node object mentioned above).
[0063] In some embodiments of this application, after determining the next planned second target node object based on the second target result, the method further includes: if the second target result is the end of the process, ending the sub-process and returning to the parent process; obtaining the first target result returned after the execution of the first target node object pointed to by the first target pointer, which is the sub-process node object; and determining the next planned first target node object based on the first target result.
[0064] Specifically, when the execution result of a node is "process ended", the pointer of the currently executed node is pointed back to the current node of the upper-level process, that is, the sub-process ends, and the node pointed to by the first target pointer in the parent process is returned. The function of the current node is then executed, which achieves the effect of exiting from the shared process and returning to the upper-level process.
[0065] In some embodiments of this application, when the second target result is the end of the process, ending the sub-process and returning to the parent process further includes: obtaining the tag status information corresponding to the sub-process, wherein the tag status information includes: a first state and a second state, the first state being used to indicate that the second target node object in the sub-process has been executed, and the second state being used to indicate that the second target node object in the sub-process has not been executed; when the tag status information is the first state, setting the first target result returned by the first target node object corresponding to the sub-process to proceed to the subsequent node; when the tag status information is the second state, setting the first target result returned by the first target node object corresponding to the sub-process to proceed to the next process.
[0066] Specifically, to prevent the sub-process from being executed repeatedly and causing an infinite loop, a boolean variable "executed" (i.e., the label status information mentioned above) is added inside the sub-process. The initial value is false (i.e., the second state mentioned above). When this node function is executed, if the executed status is false, the execution result of "loading shared process" (equivalent to the rotor process mentioned above) is returned and the executed status is set to true (i.e., the first state mentioned above). Otherwise, the result of "go to subsequent node" is returned, so that the process can continue to be executed.
[0067] In some embodiments of this application, determining the next planned first target node object based on the first target result includes: if the first target result is a subsequent node, determining the next planned first target node object based on the target relationship data corresponding to the parent process; if the first target result is a subprocess, jumping to the subprocess to control the second transit node object in the subprocess to execute the business logic corresponding to the second target node object.
[0068] Specifically, when the execution result of a node is "transfer to subsequent node", the pointer of the current node (i.e. the first target pointer mentioned above) is pointed to the subsequent node; when the execution result of a node is "transfer to other process" (i.e. the above-mentioned rotor process), the process is reloaded and reconstructed according to the process number specified in the execution result, the current node is re-pointed to the starting node of the new process and execution continues.
[0069] According to the process reuse method provided in the embodiments of this application, compared with the current version of the IPM module, adding sub-process support will make the existing intelligent voice navigation function more intelligent and flexible, which will improve the user experience and simplify the workload of operators.
[0070] Through the above steps, common scenarios that recur during process configuration are extracted into sub-processes. By modifying the pointers of process nodes during process configuration, a process reuse mechanism is achieved, which greatly simplifies the workload of process configuration and reduces the possibility of errors during process configuration. This solves the technical problem of cumbersome and inefficient process configuration caused by the fact that most existing process configuration, construction and execution methods do not support reuse mechanisms.
[0071] Example 2
[0072] Taking the function of a user inputting a number to query and inferring the number type as an example, describe the use case of the shared process. This process may be applied to various scenarios such as real-time call charge inquiry, balance inquiry, and bill inquiry. Therefore, consider extracting this function as a sub-process and referencing it where it is necessary to guide the user to input the number.
[0073] Figure 7 This is a schematic diagram of a sub-process for user input of a number according to an embodiment of this application; the configuration effect of this shared process is as follows. Figure 7 As shown, a brief description of the function of this process is as follows:
[0074] 1) Prompt users to enter the number to be queried by pressing the key, such as "Please enter the number you want to query, and end with the hash symbol key";
[0075] 2) After receiving the number entered by the user, perform a preliminary verification of the number's correctness, such as determining whether the number's length is greater than or equal to 11 digits;
[0076] 3) If the user's number is determined to be invalid, continue to check if the number of incorrect attempts exceeds 3. If the number of incorrect attempts does not exceed 3, give an error message such as "Sorry, the number is incorrect, please re-enter" and return to the number input receiving stage to receive it again; if the number of incorrect attempts has reached 3, give a corresponding error message such as "Sorry, your input is still incorrect" and exit the process.
[0077] 4) After confirming that the user's entered number is correct, try to deduce the type of the user's number. For example, if the entered number starts with 1, it is considered a mobile phone type, and if it starts with 0, it is considered a landline type. Save the user's entered number and the deduced number type to two variables, "Query Number" and "Query Number Type", respectively, for use in subsequent steps.
[0078] 5) After the variables are saved, mechanisms such as calling the corresponding interface to determine whether it is the number of this network can be added according to the specific business rules. In this embodiment, the process is directly terminated.
[0079] Figure 8This is a schematic diagram of a balance query process that introduces sub-processes according to an embodiment of this application. Specifically, it is an example of introducing the above-mentioned shared process for balance query in a real-world scenario, such as... Figure 8 As shown. For Figure 8 The scene functions are briefly described below:
[0080] 1) After entering the process, the first prompt will be: "Press 1 to check the balance of this number, or press 2 to check the balance of other numbers".
[0081] 2) If the user presses 1, save the device number and device number type to the variables "Query Number" and "Query Number Type" respectively;
[0082] 3) If the user presses key 2, then introduce... Figure 7 The system is configured to receive user-input numbers and ultimately save the verified query numbers and the inferred number type to two variables: "Query Number" and "Query Number Type".
[0083] 4) When calling the "Balance Inquiry" interface, the "Target Number" parameter in the query parameters uses the value of the "Query Number" variable, and the "Number Type" parameter uses the value of the "Query Number Type" variable;
[0084] 5) Organize the broadcast content to the user based on the result of the interface call, such as broadcasting "Your balance is XX yuan" when the query is successful, and broadcasting "Sorry, the system is busy, please try again later" when the query fails.
[0085] Similarly, in scenarios involving user input of phone numbers, such as checking real-time fees, inquiring about bills, and reporting faults, this can be achieved by introducing [a similar feature]. Figure 7 The shared processes configured in the system allow operations personnel to directly reference reusable processes at specified stages through a graphical configuration interface without the need for developer intervention, thereby simplifying process configuration.
[0086] Example 3
[0087] According to an embodiment of the present invention, an embodiment of a process reuse apparatus is also provided. Figure 9 This is a schematic diagram of a process reuse device according to an embodiment of the present invention. Figure 9 As shown, the device includes:
[0088] The object construction module 90 is used to construct a first target node object and a first transit node object corresponding to the first target node object based on the target node data. The first target node object is the target node object in the parent process. The first transit node object is used to obtain the first target result returned after the first target node object is executed. The target node data includes at least one of the following: subprocess node data.
[0089] The object execution module 92 is used to control the first transit node object to execute the business logic corresponding to the first target node object in sequence according to the target relationship data, and to set the first target pointer to point to the first target node object being executed. The target relationship data is used to represent the execution order of each target node object.
[0090] The process reuse module 94 is used to set a second target pointer to point to the second target node object being executed in the subprocess when the next target node object to be executed is jumped to the subprocess, so as to realize the reuse of the subprocess. The second target node object is the target node object in the subprocess.
[0091] It should be noted that the process reuse device provided in this embodiment can be used to execute... Figure 1 The process reuse method shown above is also applicable to the embodiments of this application, and will not be repeated here.
[0092] According to an embodiment of the present invention, an embodiment of a computer terminal for implementing a process reuse method is also provided. Figure 10 This is a hardware structure block diagram of a computer terminal (or electronic device) for implementing a process reuse method according to an embodiment of the present invention. Figure 10 As shown, the computer terminal 100 (or electronic device 100) may include one or more processors (shown as 1002a, 1002b, ..., 1002n in the figure) (the processor may include, but is not limited to, a microprocessor MCU or a programmable logic device FPGA, etc.), a memory 1004 for storing data, and a transmission module 1006 for communication functions. In addition, it may also include: a display, an input / output interface (I / O interface), a universal serial bus (USB) port (which may be included as one of the ports of the I / O interface), a network interface, a power supply, and / or a camera. Those skilled in the art will understand that... Figure 10 The structure shown is for illustrative purposes only and does not limit the structure of the aforementioned electronic device. For example, the computer terminal 100 may also include... Figure 10 The more or fewer components shown, or having the same Figure 10 The different configurations shown.
[0093] It should be noted that the aforementioned one or more processors and / or other data processing circuits are generally referred to herein as "data processing circuits". These data processing circuits can be implemented wholly or partially as software, hardware, firmware, or any other combination. Furthermore, the data processing circuits can be a single, independent processing module, or wholly or partially integrated into any other element within the computer terminal 100 (or electronic device). As involved in the embodiments of this application, the data processing circuit serves as a processor control mechanism (e.g., selection of a variable resistor termination path connected to an interface).
[0094] The memory 1004 can be used to store software programs and modules of application software, such as the program instructions / data storage device corresponding to the process multiplexing method in this embodiment. The processor executes various functional applications and data processing by running the software programs and modules stored in the memory 1004, thereby realizing the above-mentioned process multiplexing method. The memory 1004 may include high-speed random access memory, and may also include non-volatile memory, such as one or more magnetic storage devices, flash memory, or other non-volatile solid-state memory. In some instances, the memory 1004 may further include memory remotely located relative to the processor, and these remote memories can be connected to the computer terminal 100 via a network. Examples of such networks include, but are not limited to, the Internet, corporate intranets, local area networks, mobile communication networks, and combinations thereof.
[0095] The transmission module 1006 is used to receive or send data via a network. Specific examples of the network described above may include a wireless network provided by the communication provider of the computer terminal 100. In one example, the transmission module 1006 includes a network interface controller (NIC), which can connect to other network devices via a base station to communicate with the Internet. In another example, the transmission module 1006 may be a radio frequency (RF) module, used for wireless communication with the Internet.
[0096] The display may be, for example, a touchscreen liquid crystal display (LCD) that allows the user to interact with the user interface of the computer terminal 100 (or electronic device).
[0097] It should be noted here that, in some optional embodiments, the above... Figure 10 The computer device (or electronic device) shown may include hardware elements (including circuitry), software elements (including computer code stored on a computer-readable medium), or a combination of both hardware and software elements. It should be noted that... Figure 10This is only one instance of a particular specific instance, and is intended to illustrate the types of components that may exist in the aforementioned computer equipment (or electronic equipment).
[0098] It should be noted that, Figure 10 The electronic devices shown for process multiplexing are used to perform Figure 1 The process reuse method shown above also applies to the electronic device using this process reuse method, and will not be repeated here.
[0099] According to an embodiment of this application, an embodiment of a non-volatile storage medium is also provided. The non-volatile storage medium includes a stored program, wherein, during program execution, a method for controlling the device where the non-volatile storage medium is located to perform the following process reuse is provided: constructing a first target node object and a first transit node object corresponding to the first target node object based on target node data, wherein the first target node object is a target node object in a parent process, and the first transit node object is used to obtain a first target result returned after the execution of the first target node object, wherein the target node data includes at least one of the following: sub-process node data; according to target relationship data, sequentially controlling the first transit node object to execute the business logic corresponding to the first target node object, and setting a first target pointer to point to the first target node object being executed, wherein the target relationship data is used to characterize the execution order of each target node object; when the next target node object to be executed is jumped to a sub-process, setting a second target pointer to point to the second target node object being executed in the sub-process to realize the reuse of the sub-process, wherein the second target node object is a target node object in the sub-process.
[0100] The sequence numbers of the embodiments in this application are for descriptive purposes only and do not represent the superiority or inferiority of the embodiments.
[0101] In the above embodiments of this application, the descriptions of each embodiment have different focuses. For parts not described in detail in a certain embodiment, please refer to the relevant descriptions of other embodiments.
[0102] In the several embodiments provided in this application, it should be understood that the disclosed technical content can be implemented in other ways. The device embodiments described above are merely illustrative; for example, the division of units can be a logical functional division, and in actual implementation, there may be other division methods. For instance, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the displayed or discussed mutual coupling, direct coupling, or communication connection may be through some interfaces; the indirect coupling or communication connection between units or modules may be electrical or other forms.
[0103] The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple units. Some or all of the units can be selected to achieve the purpose of this embodiment according to actual needs.
[0104] Furthermore, the functional units in the various embodiments of this application can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The integrated unit can be implemented in hardware or as a software functional unit.
[0105] If the integrated unit is implemented as a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, or all or part of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods described in the various embodiments of this application. The aforementioned storage medium includes various media capable of storing program code, such as a USB flash drive, read-only memory (ROM), random access memory (RAM), portable hard drive, magnetic disk, or optical disk.
[0106] The above description is only a preferred embodiment of this application. It should be noted that for those skilled in the art, several improvements and modifications can be made without departing from the principle of this application, and these improvements and modifications should also be considered within the scope of protection of this application.
Claims
1. A process reuse method, characterized in that, include: A first target node object and a first transit node object corresponding to the first target node object are constructed based on the target node data. The first target node object is the target node object in the parent process. The first transit node object is used to obtain the first target result returned after the first target node object is executed. The target node data includes at least one of the following: subprocess node data. Based on the target relationship data, the first transit node object is sequentially controlled to execute the business logic corresponding to the first target node object, and a first target pointer is set to point to the first target node object being executed. The target relationship data is used to characterize the execution order of each target node object. When the next target node object to be executed jumps to a sub-process, a second target pointer is set to point to the second target node object being executed in the sub-process to achieve the reuse of the sub-process, wherein the second target node object is the target node object in the sub-process; In the event that the next target node object to be executed in the planned execution jumps to a sub-process, setting the second target pointer to point to the second target node object being executed in the sub-process includes: If the first target node object being executed is a sub-process node object, obtain the first target result returned after the first target node object being executed is executed, wherein the sub-process node object is the first target node object constructed based on the sub-process node data; If the first target result is a rotor process, then jump to the sub-process; Based on the target relationship data corresponding to the sub-process, the second transit node object is sequentially controlled to execute the business logic corresponding to the second target node object, and the second target pointer is set to point to the second target node object that is being executed.
2. The process reuse method according to claim 1, characterized in that, The process of sequentially controlling the first relay node object to execute the business logic corresponding to the first target node object, and setting the first target pointer to point to the first target node object being executed includes: The business logic corresponding to the first target node object is executed by controlling the first relay node object to send a target execution instruction to the first target node object; Obtain the first target result returned after the first target node object is executed, wherein the first target result includes at least one of the following: rotating the process, rotating to a subsequent node, or the process ends; Based on the first target result, determine the next first target node object to be executed, and set the first target pointer to point to the next first target node object to be executed.
3. The process reuse method according to claim 1, characterized in that, The process of sequentially controlling the second relay node object to execute the business logic corresponding to the second target node object, and setting the second target pointer to point to the second target node object being executed includes: If the user jumps to the sub-process and has not executed the business logic corresponding to the second target node object in the sub-process, the second target pointer is set to point to the initial second target node object, wherein the initial second target node object is the second target node object that is executed first in the sub-process. The business logic corresponding to the initial second target node object is executed by controlling the initial second relay node object to send a target execution instruction to the initial second target node object. The initial second relay node object is the second relay node object corresponding to the initial second target node object. Obtain the second target result returned after the initial second target node object is executed, wherein the second target result includes at least one of the following: rotating the process, rotating to the subsequent node, or the process ends; Based on the second target result, determine the next second target node object to be executed, and set the second target pointer to point to the next second target node object to be executed.
4. The process reuse method according to claim 3, characterized in that, Based on the second objective result, after determining the next planned execution node object of the second objective, the process further includes: If the second objective result is the end of the process, the sub-process ends and returns to the parent process; Obtain the first target result returned after the first target node object, which is the subprocess node object pointed to by the first target pointer, is executed; Based on the first target result, determine the next first target node object to be executed.
5. The process reuse method according to claim 4, characterized in that, If the second objective result is the end of the process, ending the sub-process and returning to the parent process further includes: Obtain the tag status information corresponding to the sub-process, wherein the tag status information includes: a first state and a second state, wherein the first state is used to indicate that the second target node object in the sub-process has been executed, and the second target node object in the sub-process has not been executed; When the label status information is in the first state, the first target result returned by the first target node object corresponding to the sub-process is set as the subsequent node; When the label status information is in the second state, the first target result returned by the first target node object corresponding to the subprocess is set as the rotor process.
6. The process reuse method according to claim 4, characterized in that, Based on the first target result, the next first target node object to be executed in the plan includes: If the first target result is the subsequent node, the next first target node object to be executed is determined based on the target relationship data corresponding to the parent process; If the first target result is the rotor process, jump to the sub-process and control the second transit node object in the sub-process to execute the business logic corresponding to the second target node object.
7. A process reuse device, characterized in that, include: An object construction module is used to construct a first target node object and a first transit node object corresponding to the first target node object based on the target node data. The first target node object is a target node object in the parent process. The first transit node object is used to obtain the first target result returned after the first target node object is executed. The target node data includes at least one of the following: subprocess node data. The object execution module is used to control the first transit node object to execute the business logic corresponding to the first target node object in sequence according to the target relationship data, and to set the first target pointer to point to the first target node object being executed, wherein the target relationship data is used to characterize the execution order of each target node object; The process reuse module is used to set a second target pointer to point to the second target node object being executed in the sub-process when the next target node object to be executed is jumped to the sub-process, so as to realize the reuse of the sub-process, wherein the second target node object is the target node object in the sub-process; The process reuse module is further configured to, when the first target node object being executed is a sub-process node object, obtain the first target result returned after the first target node object being executed is executed, wherein the sub-process node object is the first target node object constructed based on the sub-process node data; If the first target result is a rotor process, then jump to the sub-process; Based on the target relationship data corresponding to the sub-process, the second transit node object is sequentially controlled to execute the business logic corresponding to the second target node object, and the second target pointer is set to point to the second target node object that is being executed.
8. An electronic device, the electronic device comprising a processor, characterized in that, The processor is used to run a program, wherein the program executes the process reuse method according to any one of claims 1 to 6 when it runs.
9. A non-volatile storage medium, characterized in that, The non-volatile storage medium includes a stored computer program, wherein the device containing the non-volatile storage medium executes the process multiplexing method of any one of claims 1 to 6 by running the computer program.