System flow control method, device, equipment and computer storage medium

Abstract

The present application relates to the technical field of Fintech, and discloses a system flow control method, which comprises the following steps: receiving an introduced toolkit, uniformly specifying navigation of each request entrance of a system according to a demand task of the system to obtain a unified entrance, determining each atomic task corresponding to the system based on the demand task, and assigning each atomic task with a preset label by a code decoupling tool according to the toolkit, wherein the preset label has execution logic sequence information corresponding to the demand task, controlling the code decoupling tool to perform label analysis on each preset label to obtain a processing flow corresponding to the demand task, and outputting the processing flow through the unified entrance. The present application also discloses a system flow control device, equipment and a computer storage medium. The present application improves the efficiency of obtaining a business processing flow.

Description

Technical Field

[0001] This invention relates to the field of financial technology (Fintech), and more particularly to system process control methods, apparatus, equipment, and computer storage media. Background Technology

[0002] With the development of computer technology, more and more technologies (big data, distributed systems, blockchain, artificial intelligence, etc.) are being applied in the financial field. The traditional financial industry is gradually transforming into Fintech. However, due to the security and real-time requirements of the financial industry, higher demands are being placed on technology. Currently, the Fintech field employs various techniques for updating code within programs. For example, when developers receive requirement 1: an interface is needed to implement the account opening, card binding, and password setting process, they often write a class method to call these operations separately. When they receive requirement 2: implementing account opening and password setting logic, they will again write a class method to call these operations separately. However, when they receive requirement 3: implementing account opening, card binding, password setting, and activation, the code needs to be modified again. In other words, developers often write code fixed to specific, personalized requirements, lacking generality. As the number of requirements increases, this easily leads to repetitive code development, increased redundant code, and the need to constantly provide call entry points, severely impacting the efficiency of obtaining business processing flows. Therefore, improving the efficiency of obtaining business processing flows has become an urgent technical problem to be solved. Summary of the Invention

[0003] The main objective of this invention is to provide a system process control method, apparatus, device, and computer storage medium, which aims to improve the efficiency of acquiring business processing flow, thereby improving the efficiency of business development.

[0004] To achieve the above objectives, the present invention provides a system flow control method, which includes the following steps:

[0005] The system receives the imported toolkit and, based on the system's requirements and tasks, performs unified navigation to specify the various request entry points of the system to obtain a unified entry point.

[0006] Based on the required task, the corresponding atomic tasks of the system are determined, and the code decoupling tool is called according to the toolkit to assign a preset label to each atomic task, wherein the preset label has the execution logic order information corresponding to the required task;

[0007] The code decoupling tool is controlled to parse the preset tags to obtain the processing flow corresponding to the required task, and the processing flow is output through the unified entry point.

[0008] Optionally, after determining the atomic tasks corresponding to the system based on the required tasks, the process includes:

[0009] The atomic tasks are traversed sequentially. The data collector in the code decoupling tool is called to receive the input parameters corresponding to the currently traversed atomic task, and the input parameters are checked to see if they match the required task.

[0010] If there are input parameters that match the required task, then save the input parameters that match the required task until all atomic tasks have been traversed.

[0011] Optionally, the step of assigning preset labels to each of the atomic tasks by calling the code decoupling tool according to the toolkit includes:

[0012] Identify the atomic tasks corresponding to the input parameters that match the required task, and assign preset labels to the atomic tasks corresponding to the input parameters that match the required task by calling the code decoupling tool according to the toolkit.

[0013] Optionally, the step of controlling the code decoupling tool to perform tag parsing on each of the preset tags to obtain the processing flow corresponding to the required task includes:

[0014] The tag parser in the code decoupling tool is controlled to parse each of the preset tags to obtain the process tags composed of the preset tags;

[0015] The process controller in the code decoupling tool parses the process tags to obtain the processing flow corresponding to the required task.

[0016] Optionally, the step of controlling the tag parser in the code decoupling tool to parse each of the preset tags includes:

[0017] Iterate through each of the preset tags and control the tag parser in the code decoupling tool to determine whether there is a routing tag in the currently traversed preset tags;

[0018] If the current preset tag contains a routing tag, then determine whether the atomic task corresponding to the current preset tag matches the required task based on the attributes of the current preset tag;

[0019] If a match is found, the current preset tag is saved until all preset tags have been traversed.

[0020] Optionally, after determining whether a routing tag exists in the current preset tags, the process includes:

[0021] If the routing tag is not present in the current preset tags, a new current preset tag is obtained from each of the preset tags, and a prompt message indicating that the atomic task corresponding to the current preset tag is abnormal is output.

[0022] Optionally, after the step of controlling the tag parser in the code decoupling tool to determine whether a routing tag exists in the currently traversed preset tags, the process includes:

[0023] The tag parser is controlled to obtain the target tag parsing class corresponding to the current preset tag, and the current preset tag is parsed according to the target tag parsing class to determine whether the current preset tag contains a routing tag.

[0024] Furthermore, to achieve the above objectives, the present invention also provides a system process control device, the system process control device comprising:

[0025] The receiving module is used to receive the imported toolkit and, based on the system's requirements and tasks, to uniformly navigate and specify the various request entry points of the system in order to obtain a unified entry point;

[0026] The determination module is used to determine each atomic task corresponding to the system based on the requirement task, and to assign a preset label to each atomic task by calling the code decoupling tool according to the toolkit, wherein the preset label has the execution logic order information corresponding to the requirement task;

[0027] The acquisition module is used to control the code decoupling tool to perform tag parsing on each of the preset tags in order to obtain the processing flow corresponding to the required task, and to output the processing flow through the unified entry point.

[0028] In addition, to achieve the above objectives, the present invention also provides a system flow control device, the system flow control device comprising: a memory, a processor, and a system flow control program stored in the memory and executable on the processor, wherein the system flow control program, when executed by the processor, implements the steps of the system flow control method as described above.

[0029] In addition, to achieve the above objectives, the present invention also provides a computer storage medium storing a system flow control program, which, when executed by a processor, implements the steps of the system flow control method as described above.

[0030] This invention receives an imported toolkit and, based on the system's requirements, uniformly navigates and designates each request entry point of the system to obtain a unified entry point. Based on the requirements, it determines the corresponding atomic tasks of the system and assigns preset tags to each atomic task using a code decoupling tool called from the toolkit. These preset tags contain execution logic order information corresponding to the requirements. The code decoupling tool is then controlled to parse these preset tags to obtain the processing flow corresponding to the requirements, and the processing flow is output through the unified entry point. By unifying the system's request entry points according to the requirements to obtain a unified entry point, this invention avoids the need to continuously provide call entry points after process development, eliminates duplicate code, and improves the efficiency of obtaining processing flows by assigning preset tags to each atomic task and parsing these tags to obtain the processing flow. This also improves the efficiency of business development. Attached Figure Description

[0031] Figure 1 This is a schematic diagram of the device structure of the hardware operating environment involved in the embodiments of the present invention;

[0032] Figure 2 This is a flowchart illustrating the first embodiment of the system process control method of the present invention;

[0033] Figure 3 This is a schematic diagram of the device modules of the system process control device of the present invention;

[0034] Figure 4 This is a schematic diagram of the tool composition of the code decoupling tool in the system flow control method of the present invention.

[0035] The realization of the objective, functional features and advantages of the present invention will be further explained in conjunction with the embodiments and with reference to the accompanying drawings. Detailed Implementation

[0036] It should be understood that the specific embodiments described herein are merely illustrative of the invention and are not intended to limit the invention.

[0037] like Figure 1 As shown, Figure 1 This is a schematic diagram of the device structure of the hardware operating environment involved in the embodiments of the present invention.

[0038] The system process control device in this embodiment of the invention can be a PC or a server device, on which a Java Virtual Machine runs.

[0039] like Figure 1As shown, the system flow control device may include: a processor 1001, such as a CPU; a network interface 1004; a user interface 1003; a memory 1005; and a communication bus 1002. The communication bus 1002 is used to enable communication between these components. The user interface 1003 may include a display screen or an input unit such as a keyboard; optionally, the user interface 1003 may also include a standard wired interface or a wireless interface. The network interface 1004 may optionally include a standard wired interface or a wireless interface (such as a Wi-Fi interface). The memory 1005 may be high-speed RAM or non-volatile memory, such as a disk drive. Optionally, the memory 1005 may also be a storage device independent of the aforementioned processor 1001.

[0040] Those skilled in the art will understand that Figure 1 The device structure shown does not constitute a limitation on the device and may include more or fewer components than shown, or combine certain components, or have different component arrangements.

[0041] like Figure 1 As shown, the memory 1005, which serves as a computer storage medium, may include an operating system, a network communication module, a user interface module, and a system flow control program.

[0042] exist Figure 1 In the device shown, the network interface 1004 is mainly used to connect to the backend server and communicate with the backend server; the user interface 1003 is mainly used to connect to the client (user terminal) and communicate with the client; and the processor 1001 can be used to call the system flow control program stored in the memory 1005 and execute the operations in the following system flow control method.

[0043] Based on the above hardware structure, an embodiment of the system flow control method of the present invention is proposed.

[0044] Reference Figure 2 , Figure 2 This is a flowchart illustrating the first embodiment of the system flow control method of the present invention, the method comprising:

[0045] Step S10: Receive the input toolkit, and perform unified navigation specification for each request entry point of the system according to the system's requirements and tasks to obtain a unified entry point;

[0046] In this embodiment, the toolkit can be an SDK (Software Development Kit) toolkit, used to enable the system to perform a series of operations using the code decoupling tool. The requirement task can be the business logic that the user needs the system to implement. The request entry point can be the interface for developers to debug program code. In this embodiment, specific business requirements (such as deposit business, loan business, etc.) need to request a certain business logic (for example, a part of the business logic of various businesses of banks and other financial institutions, where the business includes but is not limited to loan business, deposit business, etc.). A unified navigation point needs to be specified for this request, i.e., a unified entry point. This unified entry point is used for protocol conversion, front-end and back-end interaction restrictions, and other controls. The toolkit is implemented in JAVA, encapsulating a complete SDK toolkit to facilitate quick access to the code decoupling tool by the business system. That is, the system's background program receives the input toolkit, obtains the system's requirement task, determines the number of request entry points needed in the system program based on the requirement task, and uniformly navigates all request entry points to obtain the unified entry point.

[0047] Step S20: Based on the required task, determine each atomic task corresponding to the system, and according to the toolkit, call the code decoupling tool through the unified entry point to assign a preset label to each atomic task, wherein the preset label has the execution logic order information corresponding to the required task;

[0048] Code decoupling tools can handle business logic processes. They are based on the Spring container and provide custom tags and corresponding configuration parsing classes. Business systems import the toolkit, requiring developers to write relatively independent atomic task code and configure the business process through a process configuration file. The toolkit parses the process configuration file and controls the code flow to quickly implement business requirements. To further illustrate the various functions of the code decoupling tool, examples are provided below. For instance... Figure 4As shown, the code decoupling tool mainly consists of: custom tags, tag parsers, flow controllers, data collectors, exception handling, and atomic tasks. Custom tags are primarily used to mark flow nodes, informing the flow controller of the next step in the flow, such as `tk:task`, `tk:subtask`, and `tk:routing` tags. Tag parsers are mainly used to translate tags. Tag translation primarily uses the `spring.handlers` file (the container's handlers) to specify the `FlowNamespaceHandlerSupport` class (tag namespace support class) for tag parsing to the Spring container, such as `task`, `sub`, and `routing` parsing. The flow controller is mainly used to parse the flow composed of tags, obtain the processing flow of specific business logic, and control the jump processing between atomic tasks, such as flow configuration files, flow parsing, and flow routing control. The data collector is mainly responsible for passing the input and return parameters of each atomic task. Exception handling mainly handles exception capture during system execution, providing corresponding prompts and responses for business processing problems, such as catching exceptions, task exceptions, and routing exceptions. Atomic tasks can be code logic that developers need to write based on business requirements. This part is the business processing logic and needs to be implemented separately in the business system, requiring specific task processing. It should also be noted that process controllers can be configured via XML configuration files, database configurations, or other readable files.

[0049] The default tags include the tk.xsd file and the spring.schemas file (a collection of database objects in the container); the tk.xsd file defines which tags the code decoupling tool supports and the attribute configurations supported by each tag (such as the id attribute and the start attribute). The spring.schemas file specifies the location of custom tk:xsd files for use by the Spring container.

[0050] After receiving the requirement task and writing relatively independent atomic task code, the developer still needs to obtain atomic tasks with parameter information related to the requirement task based on the logical relationship of the requirement task. It should be noted that in this embodiment, the atomic tasks can be combined to obtain the processing flow. To combine atomic tasks, it is necessary to obtain the information of the atomic tasks. Therefore, the code decoupling tool can be called through a unified entry point in the toolkit to assign tags to each atomic task. Then, the required process tags can be obtained through tag parsing. The processing flow of the atomic tasks can be determined based on the process tags. That is, the execution logic order information corresponding to the requirement task exists in the preset tags. Thus, the process tags can be obtained based on the execution logic order in the preset tags.

[0051] Step S30: Control the code decoupling tool through the unified entry point to perform tag parsing on each of the preset tags in order to obtain the processing flow corresponding to the required task.

[0052] The system uses a unified entry point to control the decoupling tool's process controller, which retrieves preset tags from atomic tasks based on the process control file. Then, a tag parser parses these preset tags. Tag parsing requires specifying the `FlowNamespaceHandlerSupport` class for tag parsing to the Spring container via the `spring.handlers` file. The `FlowNamespaceHandlerSupport` class is responsible for registering the corresponding tag parsing classes, such as `FlowStopDefinitionPareser` (process node parsing class), `FlowTaskDefinitionParser` (task parsing class), and `FlowTaskFactoryDefinitionParser` (task factory parsing class). Based on the tag parsing results, the system obtains the processing flow corresponding to the required task. To further illustrate the tag parsing process, an example is provided below. For instance, when the process control file is an XML file, such as `bindCardAndSetPwd.xml` (binding and setting), and `bindCardAndSetPwd.xml` configures a complete business logic, primarily performing user information checks, binding other bank cards, and setting passwords, it can be considered a card binding and password setting interface. When a card binding and password setting request is sent to the demand processing system via the upstream, the system first reads the bindCardAndSetPwd.xml file from the requested address. It then reads the tk:task tag through the FlowTaskFactoryDefinitionParser class and loads its corresponding attributes. The start attribute of the tk:task tag indicates the starting node in the process, pointing to the tk:stop tag with the id checkInfoStop (check information stop). The FlowStopDefinitionParser class is responsible for processing the tk:stop tag. The ref attribute of tk:stop points to the atomic task class that handles the check information logic, and the method attribute is the name of the specific method used to perform the processing operation. The tk:routing tag acts as the routing controller for the flow to the next atomic task, specifying the target atomic task to jump to. If no tk:routing atomic task is configured, the next atomic task is executed by default.

[0053] This embodiment receives an imported toolkit and, based on the system's requirements, uniformly navigates and specifies each request entry point of the system to obtain a unified entry point. Based on the requirements, it determines each atomic task corresponding to the system and assigns a preset label to each atomic task using a code decoupling tool called from the toolkit. The preset label contains execution logic order information corresponding to the requirements task. The code decoupling tool is controlled to parse each preset label to obtain the processing flow corresponding to the requirements task, and the processing flow is output through the unified entry point. By unifying the system's request entry points according to the requirements to obtain a unified entry point, the phenomenon of constantly providing call entry points during process development in existing technologies is avoided, eliminating duplicate code. Furthermore, by assigning preset labels to each atomic task through the unified entry point and the toolkit, and parsing the preset labels to obtain the processing flow, the efficiency of obtaining the processing flow is improved, thereby also improving the efficiency of business development.

[0054] Furthermore, based on the first embodiment of the system flow control method of the present invention, a second embodiment of the system flow control method of the present invention is proposed. This embodiment is step S20 of the first embodiment of the present invention, which, after determining the atomic tasks corresponding to the system based on the required tasks, includes:

[0055] Step a: Iterate through each atomic task in sequence, and receive the input parameters corresponding to the currently traversed atomic task by calling the data collector in the code decoupling tool, and check whether each input parameter matches the required task;

[0056] After obtaining each atomic task, the data receiver in the code decoupling tool is needed to obtain the input parameters carried by each atomic task and check these input parameters to determine whether they match the system's required tasks. If they do not match, these input parameters are returned and a response message is sent. If they match, these input parameters are saved and a new response message is sent. This is the data collector, which is used to receive the information carried by the atomic tasks and respond to this information.

[0057] Step b: If there are input parameters that match the required task, save the input parameters that match the required task until all atomic tasks have been traversed.

[0058] If, after evaluation, an input parameter matching the required task is found, these matching input parameters need to be saved, and the corresponding atomic task needs to be determined to respond, until all atomic tasks have been traversed and completed.

[0059] In this embodiment, the accuracy of the acquired atomic tasks is ensured by obtaining the input parameters of each atomic task and determining whether the input parameters match the required task. If they match, the input parameters are saved.

[0060] Furthermore, the step of assigning preset labels to each atomic task by calling the code decoupling tool through the unified entry point according to the toolkit includes:

[0061] Step c: Determine the atomic task corresponding to the input parameters that match the required task, and assign a preset label to the atomic task corresponding to the input parameters that match the required task by calling the code decoupling tool according to the toolkit.

[0062] The system identifies the atomic tasks corresponding to the input parameters that match the required tasks. It can also assign corresponding preset tags to the atomic tasks corresponding to the input parameters that match the required tasks by calling the custom tag function of the code decoupling tool in the toolkit, thus determining which atomic tasks are needed by the user.

[0063] In this embodiment, by assigning preset labels to the atomic tasks corresponding to the input parameters that match the required tasks, the accuracy of the obtained required tasks is also ensured.

[0064] Furthermore, based on any one of the first to second embodiments of the system flow control method of the present invention, a third embodiment of the system flow control method of the present invention is proposed. This embodiment is step S30 of the first embodiment of the present invention, which involves controlling the code decoupling tool to perform tag parsing on each of the preset tags to obtain the processing flow corresponding to the required task, including:

[0065] Step d: Control the tag parser in the code decoupling tool to parse each of the preset tags to obtain the process tags composed of the preset tags;

[0066] After setting preset tags on atomic tasks, the tag parser in the code decoupling tool needs to parse the acquired preset tags. That is, for each preset tag acquired on an atomic task, the tag needs to be translated to determine the corresponding parsing class in the tag parser. After parsing the tag using the corresponding parsing class, it is determined whether the atomic task corresponding to the preset tag is required by the current task at the current time and position. This process continues until all preset tags on all atomic tasks have been parsed, resulting in a flow tag composed of preset tags. The order of the flow tags corresponds similarly to the execution logic order of the required tasks.

[0067] Step e: Control the process controller in the code decoupling tool to parse the process tag to obtain the processing flow corresponding to the required task.

[0068] Once the process tags are obtained, the process controller in the code decoupling tool can be used to parse the process tags to obtain the processing flow corresponding to the requirement task and control the jump processing between atomic tasks and requirement tasks.

[0069] In this embodiment, process tags composed of preset tags are obtained, and the processing flow corresponding to the required task is obtained based on the process tags, thereby ensuring the accuracy of the obtained processing flow.

[0070] Specifically, the step of parsing each preset tag through the tag parser in the code decoupling tool includes:

[0071] Step d1: Traverse each of the preset tags and control the tag parser in the code decoupling tool to determine whether there is a routing tag in the current preset tag being traversed.

[0072] The current preset tag is the preset tag being parsed. It iterates through each preset tag, using the tag parser in the code decoupling tool to retrieve the current preset tag from each preset tag, and then parses the current preset tag to determine if a routing tag exists. If not, it jumps directly to the next preset tag; if it exists, it determines the attributes of the current preset tag.

[0073] Step d2: If the current preset tag contains a routing tag, determine whether the atomic task corresponding to the current preset tag matches the required task based on the attributes of the current preset tag.

[0074] If the current preset tag is found to contain a routing tag, the atomic task corresponding to the current preset tag can be determined based on its attributes. In other words, the atomic task in the current process node matches the task in the process node corresponding to the requirement task. If they do not match, an error message is output. If they match, the current preset tag is retained, and the next preset tag is obtained.

[0075] Step d3: If a match is found, the current preset tag is saved until all preset tags have been traversed.

[0076] If, after evaluation, the atomic task corresponding to the current preset tag matches the requirement task, the current preset tag can be saved. The tag parser then retrieves the second preset tag from among all preset tags. It continues to check if a "routing" tag exists in the second preset tag. If it does, it checks if the atomic task corresponding to the second preset tag matches the requirement task. If they match, the second preset tag is saved. This process continues until all preset tags have been traversed and parsed. The second preset tag is one type of preset tag, the next preset tag retrieved after the current preset tag has been parsed.

[0077] In this embodiment, the required current preset label is determined based on the routing label, and the second preset label is obtained only when the atomic task corresponding to the current preset label matches the requirement task. This improves the accuracy of the obtained current preset label and ensures the accuracy of the acquisition process.

[0078] Specifically, after determining whether a routing tag exists in the current preset tags, the process includes:

[0079] Step f: If the routing tag is not present in the current preset tags, a new current preset tag is obtained from each of the preset tags, and a prompt message indicating that the atomic task corresponding to the current preset tag is abnormal is output.

[0080] If the `routing` tag is found to be absent from the current preset tags, a new current preset tag needs to be retrieved from the various preset tags. The exception handling function in the code decoupling tool will then output a message indicating an exception in the atomic task corresponding to the current preset tag. This exception handling function can handle exceptions during system execution and provide appropriate prompts and responses for issues in business processing.

[0081] In this embodiment, by outputting a prompt message when the routing tag is not present in the current preset tags, users can detect and handle abnormal issues in a timely manner, thereby improving the efficiency of obtaining the processing flow.

[0082] Furthermore, the step of controlling the tag parser in the code decoupling tool to determine whether a routing tag exists in the currently traversed preset tags includes:

[0083] Step k: Control the tag parser to obtain the target tag parsing class corresponding to the current preset tag, and parse the current preset tag according to the target tag parsing class to determine whether the current preset tag contains a routing tag.

[0084] The target tag parsing class can be a tool for parsing tags. After obtaining the current preset tag, it is also necessary to control the tag parser to obtain the target tag parsing class corresponding to the current preset tag, and then parse the current preset tag using the target tag parsing class to determine whether the current preset tag contains a routing tag, whether the tag attribute of the current preset tag points to an atomic task that processes the inspection information logic, etc.

[0085] By obtaining the target tag parsing class corresponding to the current preset tag and parsing the current preset tag according to the target tag parsing class, the success rate of parsing the current preset tag is guaranteed, and the success rate of the acquisition and processing process is improved.

[0086] The present invention also provides a system process control device, with reference to Figure 3 The system process control device includes:

[0087] The receiving module is used to receive the imported toolkit and, based on the system's requirements and tasks, to uniformly navigate and specify the various request entry points of the system in order to obtain a unified entry point;

[0088] The determination module is used to determine each atomic task corresponding to the system based on the requirement task, and to assign a preset label to each atomic task by calling the code decoupling tool according to the toolkit, wherein the preset label has the execution logic order information corresponding to the requirement task;

[0089] The acquisition module is used to control the code decoupling tool to perform tag parsing on each of the preset tags in order to obtain the processing flow corresponding to the required task, and to output the processing flow through the unified entry point.

[0090] Optionally, the determining module is further configured to:

[0091] The atomic tasks are traversed sequentially. The data collector in the code decoupling tool is called to receive the input parameters corresponding to the currently traversed atomic task, and the input parameters are checked to see if they match the required task.

[0092] If there are input parameters that match the required task, then save the input parameters that match the required task until all atomic tasks have been traversed.

[0093] Optionally, the determining module is further configured to:

[0094] Identify the atomic tasks corresponding to the input parameters that match the required task, and assign preset labels to the atomic tasks corresponding to the input parameters that match the required task by calling the code decoupling tool according to the toolkit.

[0095] Optionally, the acquisition module is further configured to:

[0096] The tag parser in the code decoupling tool is controlled to parse each of the preset tags to obtain the process tags composed of the preset tags;

[0097] The process controller in the code decoupling tool parses the process tags to obtain the processing flow corresponding to the required task.

[0098] Optionally, the acquisition module is further configured to:

[0099] Iterate through each of the preset tags and control the tag parser in the code decoupling tool to determine whether a routing tag exists in the currently traversed preset tag;

[0100] If the current preset tag contains a routing tag, then determine whether the atomic task corresponding to the current preset tag matches the required task based on the attributes of the current preset tag;

[0101] If a match is found, the current preset tag is saved until all preset tags have been traversed.

[0102] Optionally, the acquisition module is further configured to:

[0103] If the routing tag is not present in the current preset tags, a new current preset tag is obtained from each of the preset tags, and a prompt message indicating that the atomic task corresponding to the current preset tag is abnormal is output.

[0104] Optionally, the acquisition module is further configured to:

[0105] The tag parser is controlled to obtain the target tag parsing class corresponding to the current preset tag, and the current preset tag is parsed according to the target tag parsing class to determine whether the current preset tag contains a routing tag.

[0106] The methods executed by the above-mentioned program modules can be referred to in the various embodiments of the system flow control method of the present invention, and will not be repeated here.

[0107] The present invention also provides a computer storage medium.

[0108] The present invention provides a system flow control program stored on a computer storage medium, which, when executed by a processor, implements the steps of the system flow control method described above.

[0109] The method implemented when the system flow control program running on the processor is executed can be referred to in various embodiments of the system flow control method of the present invention, and will not be repeated here.

[0110] It should be noted that, in this document, the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or system that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or system. Unless otherwise specified, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or system that includes that element.

[0111] The sequence numbers of the above embodiments of the present invention are for descriptive purposes only and do not represent the superiority or inferiority of the embodiments.

[0112] Through the above description of the embodiments, those skilled in the art can clearly understand that the methods of the above embodiments can be implemented by means of software plus necessary general-purpose hardware platforms. Of course, they can also be implemented by hardware, but in many cases the former is a better implementation method. Based on this understanding, the technical solution of the present invention, or the part that contributes to the prior art, can be embodied in the form of a software product. This computer software product is stored in a storage medium (such as ROM / RAM, magnetic disk, optical disk) as described above, and includes several instructions to cause a terminal device (which may be a mobile phone, computer, server, air conditioner, or network device, etc.) to execute the methods described in the various embodiments of the present invention.

[0113] The above are merely preferred embodiments of the present invention and do not limit the scope of the patent. Any equivalent structural or procedural transformations made based on the description and drawings of the present invention, or direct or indirect applications in other related technical fields, are similarly included within the scope of patent protection of the present invention.

Claims

1. A system process control method, characterized in that, The system process control release method includes the following steps: The system receives the imported toolkit and, based on the system's requirements and tasks, performs unified navigation to specify the various request entry points of the system to obtain a unified entry point. Based on the required task, the corresponding atomic tasks of the system are determined, and the code decoupling tool is called according to the toolkit to assign a preset label to each atomic task, wherein the preset label has the execution logic order information corresponding to the required task; The tag parser in the code decoupling tool is controlled to parse each preset tag, determine whether the atomic task corresponding to the preset tag is required by the current task at the current time and current position, until the preset tags on each atomic task are parsed, thereby obtaining the process tag composed of the preset tags; The process controller in the code decoupling tool parses the process tags to obtain the processing flow corresponding to the required task, and outputs the processing flow through the unified entry point.

2. The system flow control method as described in claim 1, characterized in that, After the step of determining the atomic tasks corresponding to the system based on the required task, the following steps are included: The atomic tasks are traversed sequentially. The data collector in the code decoupling tool is called to receive the input parameters corresponding to the currently traversed atomic task, and the input parameters are checked to see if they match the required task. If there are input parameters that match the required task, then save the input parameters that match the required task until all atomic tasks have been traversed.

3. The system process control method as described in claim 2, characterized in that, The step of assigning preset labels to each atomic task by calling the code decoupling tool according to the toolkit includes: Identify the atomic tasks corresponding to the input parameters that match the required task, and assign preset labels to the atomic tasks corresponding to the input parameters that match the required task by calling the code decoupling tool according to the toolkit.

4. The system flow control method as described in claim 1, characterized in that, The step of controlling the tag parser in the code decoupling tool to parse each of the preset tags includes: Iterate through each of the preset tags and control the tag parser in the code decoupling tool to determine whether there is a routing tag in the currently traversed preset tags; If the current preset tag contains a routing tag, then determine whether the atomic task corresponding to the current preset tag matches the required task based on the attributes of the current preset tag; If a match is found, the current preset tag is saved until all preset tags have been traversed.

5. The system flow control method as described in claim 4, characterized in that, After determining whether a routing label exists in the currently traversed preset labels, the process includes: If the routing tag is not present in the current preset tags, a new current preset tag is obtained from each of the preset tags, and a prompt message indicating that the atomic task corresponding to the current preset tag is abnormal is output.

6. The system flow control method as described in claim 4, characterized in that, The tag parser in the control code decoupling tool determines whether a routing tag exists among the preset tags currently being traversed, including: The tag parser is controlled to obtain the target tag parsing class corresponding to the current preset tag, and the current preset tag is parsed according to the target tag parsing class to determine whether the current preset tag contains a routing tag.

7. A system process control device, characterized in that, The system process control device includes: The receiving module is used to receive the imported toolkit and, based on the system's requirements and tasks, to uniformly navigate and specify the various request entry points of the system in order to obtain a unified entry point; The determination module is used to determine each atomic task corresponding to the system based on the requirement task, and to assign a preset label to each atomic task by calling the code decoupling tool according to the toolkit, wherein the preset label has the execution logic order information corresponding to the requirement task; The acquisition module is used to control the tag parser in the code decoupling tool to perform tag parsing on each of the preset tags, determine whether the atomic task corresponding to the preset tag is required by the demand task at the current time and current position, until the preset tags on each atomic task are parsed, thereby obtaining the process tag composed of the preset tags; The process controller in the code decoupling tool parses the process tags to obtain the processing flow corresponding to the required task, and outputs the processing flow through the unified entry point.

8. A system process control device, characterized in that, The system flow control device includes: a memory, a processor, and a system flow control program stored in the memory and executable on the processor. When the system flow control program is executed by the processor, it implements the steps of the system flow control method as described in any one of claims 1 to 6.

9. A computer storage medium, characterized in that, The computer storage medium stores a system flow control program, which, when executed by a processor, implements the steps of the system flow control method as described in any one of claims 1 to 6.

Images