Data processing method and device based on policy tree management

Abstract

The invention provides a data processing method and device based on policy tree management, the method is applied to a server, and the method comprises the following steps: analyzing a policy structure indicated by a policy execution request to identify a node type of a current processing node; when the node type is a strategy node, executing an input parameter verification operation, and loading a corresponding sub-strategy topological structure; performing recursive execution operation on the sub-strategies to determine a target strategy result; updating a data set of the strategy structure and generating a version record according to the target strategy result, and executing a parameter-out verification operation on the target strategy result; and sequentially executing the next to-be-processed node in the strategy structure until each node in the strategy structure is executed, and outputting a final version chain and a final data set corresponding to the strategy structure. Thus, modular processing of complex business logic is realized through hierarchical management of the strategy tree, decision-making efficiency is improved, and traceability and data security of data processing are improved by adopting setting of a version chain, a data set and verification.

Description

Technical Field

[0001] This application belongs to the field of computer applications, and specifically relates to a data processing method and apparatus based on policy tree management. Background Technology

[0002] Currently, in traditional computer applications, policy trees are used in fields with complex rules and dynamic decision-making requirements. Specifically, they organize business rules hierarchically through a tree structure to achieve modular management and sequential execution of policies.

[0003] However, taking traditional strategy engine systems as an example, while the execution process is recorded during strategy tree execution, it is impossible to trace back the execution process of the underlying strategy tree. This poses a serious obstacle to in-depth analysis of decision-making processes, troubleshooting potential problems, and optimizing business logic. It makes it difficult to fully understand the decision-making process and to quickly and accurately identify the root cause of problems, significantly increasing operational costs and business risks. Furthermore, as business scale continues to expand, the amount of data processed by the decision-making system grows exponentially, placing higher demands on the storage and backtracking analysis capabilities of the strategy tree management system. The large volume of data also leads to poor stability of the decision-making system. Summary of the Invention

[0004] This application proposes a data processing method and apparatus based on policy tree management, aiming to achieve end-to-end closed-loop management of policy execution. Through the hierarchical management of the policy tree, it enables modular processing of complex business logic, supports recursive execution of policy nodes and dynamic loading of sub-policy topologies, and, combined with the setting of version chains, datasets and verification mechanisms, ensures the traceability of the policy execution process, data security and data consistency of each node.

[0005] In a first aspect, embodiments of this application provide a data processing method based on policy tree management, applied to a server, the method comprising:

[0006] In response to a policy execution request sent by a terminal device, the policy structure indicated by the policy execution request is parsed, and the node type of the current processing node is identified according to the policy structure. The node types include start node, policy node and execution node. The execution node is used to implement the preset business logic.

[0007] When the node type of the current processing node is a policy node, perform input parameter validation operation for the current processing node and load the sub-policy topology structure corresponding to the current processing node;

[0008] Recursively execute sub-strategies within the sub-strategy topology until all sub-strategies have been executed, and then determine the result of the target strategy.

[0009] Execute a callback update operation based on the result of the target policy to update the dataset of the policy structure; and,

[0010] Generate a version record for the current processing node based on the target strategy result, and perform output parameter verification operation on the target strategy result;

[0011] The next pending node in the strategy structure is executed sequentially until each node in the strategy structure is completed. The final version chain and dataset corresponding to the strategy structure are output. The version chain contains the version record corresponding to each node.

[0012] Secondly, embodiments of this application also provide a data processing apparatus based on policy tree management, applied to a server, the apparatus comprising:

[0013] The response unit is used to respond to the policy execution request sent by the terminal device, parse the policy structure indicated by the policy execution request, and identify the node type of the current processing node according to the policy structure. The node types include start node, policy node and execution node. The execution node is used to implement the preset business logic.

[0014] The loading unit is used to perform input parameter verification operations for the current processing node and load the sub-policy topology structure corresponding to the current processing node when the node type of the current processing node is a policy node.

[0015] The execution unit is used to perform recursive execution operations on the sub-strategies in the sub-strategy topology until the sub-strategy is completed and the result of the target strategy is determined.

[0016] The recording unit is used to perform callback update operations based on the target policy result to update the dataset of the policy structure; and to generate a version record of the current processing node based on the target policy result, and to perform output parameter verification operations on the target policy result.

[0017] The output unit is used to sequentially execute the next pending node in the strategy structure until each node in the strategy structure has been executed, and outputs the final version chain and dataset corresponding to the strategy structure. The version chain contains the version record corresponding to each node.

[0018] Thirdly, embodiments of this application provide a server including a processor, a memory, and one or more programs, the one or more programs being stored in the memory and configured to be executed by the processor, the programs including instructions for performing the steps as described in the first aspect of embodiments of this application.

[0019] Fourthly, embodiments of this application provide a computer-readable storage medium having a computer program / instructions stored thereon, which, when executed by a processor, implement the steps in the first aspect of embodiments of this application.

[0020] Fifthly, embodiments of this application provide a computer program product, including a computer program / instructions, which, when executed by a processor, implement some or all of the steps described in the first aspect of embodiments of this application.

[0021] As can be seen from this embodiment, the server parses the corresponding policy structure by responding to the policy execution request sent by the terminal device, and executes each node within the policy structure to achieve complex business logic. Furthermore, the server records corresponding data during execution using version chains and datasets, enabling the policy execution process to be traced back, improving decision-making process data, and enhancing the accuracy of data analysis, thereby reducing operational costs and business risks. Attached Figure Description

[0022] To more clearly illustrate the technical solutions in the embodiments of this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0023] Figure 1 This is a schematic diagram of the structure of a strategy tree execution system provided in an embodiment of this application;

[0024] Figure 2 This is a flowchart illustrating a data processing method based on strategy tree management provided in an embodiment of this application;

[0025] Figure 3 This is a flowchart illustrating a strategy tree execution process provided in an embodiment of this application;

[0026] Figure 4 This is a schematic diagram of a raw data stream provided in an embodiment of this application;

[0027] Figure 5 This is a flowchart illustrating a dynamic output stream provided in an embodiment of this application;

[0028] Figure 6 This is a functional unit block diagram of a data processing device based on strategy tree management provided in an embodiment of this application;

[0029] Figure 7 This is a functional unit block diagram of another data processing device based on strategy tree management provided in the embodiments of this application;

[0030] Figure 8 This is a structural block diagram of a server provided in an embodiment of this application. Detailed Implementation

[0031] 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 are within the scope of protection of the present application.

[0032] The terms "first," "second," etc., in the specification, claims, and accompanying drawings of this application are used to distinguish different objects, not to describe a specific order. 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 includes a series of steps or units is not limited to the listed steps or units, but may optionally include steps or units not listed, or may optionally include other steps or units inherent to these processes, methods, products, or apparatuses.

[0033] In this document, the term "embodiment" means that a particular feature, structure, or characteristic described in connection with an embodiment may be included in at least one embodiment of this application. The appearance of this phrase in various places throughout the specification does not necessarily refer to the same embodiment, nor is it a separate or alternative embodiment mutually exclusive with other embodiments. It will be explicitly and implicitly understood by those skilled in the art that the embodiments described herein can be combined with other embodiments.

[0034] Please see Figure 1 , Figure 1 This is a schematic diagram of the structure of a strategy tree execution system provided in an embodiment of this application. For example... Figure 1As shown, the policy tree execution system 100 includes a server 110 and a terminal device 120. The server 110's end-side architecture includes an interface layer 111, a policy management engine 112, and an execution engine 113. The interface layer 111 communicates with the terminal device 120 to receive policy execution nodes sent by the terminal device 120. The policy management engine 112 parses the policy execution nodes to obtain the policy structure, stores the policy structure corresponding to the policy tree, and provides rule templates (such as user rules and product rules) and dynamic tag matching for the business corresponding to the policy tree sent by the terminal device 120 to support input and output parameter validation during policy tree execution. The execution engine 113 runs the policy structure corresponding to the policy tree, executing each node to obtain the final dataset containing the decision content, and then sends the dataset back to the terminal device 120. The terminal device 120's end-side architecture includes a request initiator 121 and a result execution end 122. The request initiator 121 is specifically used to convert the policy tree that the user needs to execute into a policy execution request and submit the policy execution request to the server 110. The result execution end 122 is specifically used to receive the dataset containing decision content returned by the server and to execute specific actions based on the decision content. In addition, the result execution end 122 can also be used to return the execution result of the decision content to the server 110 to update the version chain and dataset corresponding to the policy tree. The server 110 can be a single server, a voice server cluster consisting of several servers, or a cloud computing service center. One server 110 can simultaneously correspond to multiple terminal devices 120, or the policy tree execution system 100 includes multiple servers 110, each server 110 corresponding to one or more terminal devices 120.

[0035] Based on this, the present application provides a data processing method based on strategy tree management. The embodiments of the present application will be described in detail below with reference to the accompanying drawings.

[0036] Please see Figure 2 , Figure 2 This is a flowchart illustrating a data processing method based on policy tree management provided in an embodiment of this application. The method is applied to server 110 and includes:

[0037] Step S201: In response to the policy execution request sent by the terminal device, parse the policy structure indicated by the policy execution request, and identify the node type of the current processing node based on the policy structure.

[0038] The node types include start nodes, strategy nodes, and execution nodes. Execution nodes are used to implement predefined business logic. Node type identification can be based on node attribute fields to determine the type of the currently processed node. Start nodes are the process entry point and have no business logic, while strategy nodes contain sub-strategy invocation logic. Execution nodes are bound to specific business logic (such as risk control rule calculation). The uniqueness of start nodes must be verified to ensure that the strategy tree has only one entry point.

[0039] The server can configure a policy library to pre-store the policy structures of multiple policy trees frequently used by users. Then, when a user sends a policy execution request carrying a policy ID through their terminal device, the server loads the corresponding policy tree structure from the policy library and parses the node topology relationships within it.

[0040] Step S202: When the node type of the current processing node is a policy node, perform input parameter verification operation for the current processing node and load the sub-policy topology structure corresponding to the current processing node.

[0041] The input parameter validation operation is used to verify whether the input parameters conform to preset rules (such as numerical range, non-empty check), and if the validation fails, the process terminates and returns an error code. During the loading of the sub-policy topology structure, the server establishes a parent-child policy relationship, allowing the child policy to inherit the input parameters of the parent policy.

[0042] Please see Figure 3 , Figure 3 This is a flowchart illustrating a strategy tree execution process provided in an embodiment of this application. The following is based on... Figure 3 The process illustrated, along with various specific embodiments, is used to explain the technical solution of this application:

[0043] In one possible embodiment, after identifying the node type of the current processing node according to the strategy structure, the method further includes: when the node type of the current processing node is a start node, skipping the input parameter verification operation and the input parameter recording operation; temporarily storing the original input corresponding to the start node in the isolation buffer; when the execution node associated with the current processing node executes successfully, detecting whether the original variable in the original input of the isolation buffer exists in the current version chain; if the original variable exists in the current version chain, determining that the original value corresponding to the original variable stored in the original input is the current value of the original variable.

[0044] When the server detects that the current processing node is the starting node, it will perform the following optimization process: skipping redundant checksum records, temporarily storing the original input in an isolation buffer, and performing version chain association and variable backtracking (corresponding to...). Figure 3The server determines the current processing node as the start node, but the input parameters are not validated or recorded temporarily. It's important to note that, as described in step S202 above, when the server detects the current processing node as a policy node, it will also skip redundant checksums and records (corresponding to...). Figure 3 The server determines that the current processing node is a policy node, but the input parameters are not validated and are not recorded for the time being.

[0045] Skipping redundant checks and records is because the starting node only serves as the entry point to the policy tree (without business logic). The system automatically skips input parameter checks (such as format checks and non-empty checks) and input parameter recording operations, reducing unnecessary calculations. Specifically, a fast track can be triggered through node type flags to directly enter the data temporary storage stage. Temporarily storing raw input in the isolated cache means storing the raw input received by the starting node (such as user request parameters) in an isolated cache (memory or distributed cache) instead of directly writing it to the main dataset. This can be implemented by assigning an independent cache identifier to each policy execution request and using copy-on-write technology to ensure that the raw input is not modified by subsequent nodes. Version chain association and variable backtracking refer to the system checking whether the original variable in the isolated cache exists in the version chain after the associated execution node executes successfully. If it exists, it means that the variable was modified during policy execution, and the system automatically restores its current value to the original value stored in the isolated cache. If it does not exist, the new variable generated by the execution node is retained to avoid data loss (corresponding to...). Figure 3 (This refers to the "callback update start node input parameter record" in the code). The specific implementation method is to record the variable modification history through the version chain, and to quickly locate existing conflicting variables through hash comparison.

[0046] As can be seen in this example, when executing the start node, the server reduces unnecessary calculations and lowers system overhead by skipping redundant checks (which have no actual business logic) for the start node. An isolated cache temporarily stores the original input, avoiding frequent reads and writes of initial data and improving I / O efficiency. Furthermore, by checking for the existence of existing variables in the version chain, it ensures that if variables are modified during execution, they can be automatically rolled back to their original values, preventing dirty data from contaminating subsequent processes. In addition, the server supports stateless backtracking, preserving the original input and associating it with the version chain, allowing for rapid restoration of the initial context during backtracking and simplifying the fault recovery process.

[0047] In one possible embodiment, after identifying the node type of the current processing node according to the strategy structure, the method further includes: when the node type of the current processing node is an execution node, performing input parameter verification and input parameter recording operations on the current processing node; executing the current execution node to obtain the node output result; generating a version record of the current processing node based on the node output result; and if the current version chain does not contain the original variables in the original input of the isolation cache, storing the new variables in the node output result and the current values ​​corresponding to the new variables in the dataset.

[0048] The input parameter validation operation can specifically employ a three-level validation rule: format validation (JSON Schema), business rule validation (such as numerical range), and dependency validation (checking the integrity of the output of preceding nodes). If validation fails, a circuit breaker mechanism is triggered, immediately stopping the process and generating an error snapshot to record in the dataset and version chain. The input parameter recording stage refers to recording the complete input context, including the original input source (start node / parent strategy node), parameter conversion history (such as type conversion records), and associated version chain pointers. (Corresponding to...) Figure 3 (Input parameter validation and input parameter recording before execution of the execution node)

[0049] The server executes the current execution node to implement the corresponding business logic. During execution, execution metrics (CPU / memory / time consumption) can be monitored in real time, and the system automatically interrupts when thresholds are exceeded, improving system stability. Version records can be generated using a blockchain-style record structure, where the execution node's node ID is bound to the input fingerprint (indicating parameter hash values), output fingerprint (indicating result hash values), timestamp, and execution environment fingerprint. (This corresponds to...) Figure 3 (Execute current node)

[0050] In the case where the original variables in the original input of the current version chain do not exist in the isolation cache, the choice to store the new variables and their corresponding current values ​​in the node output results to the dataset is to perform first assignment protection. That is, a read-only mark is added to the original variables passed in by the starting node, and the initial value is protected by copy-on-write technology. Any modification operation generates a new copy, so that when the input parameters of the starting node are accumulated, only the first value of the variable is recorded. This prevents the variable from being calculated and resulting in a value that is not the original input. Recording the first value makes it easier to track the original input and eliminate interference from subsequent calculations.

[0051] As can be seen, in this example, the server strictly controls the input / output of business logic by mandating checksum recording of execution nodes, thus preventing error propagation. Furthermore, the server generates version records for node output results, enabling fine-grained auditing and tracing, meeting compliance requirements. Moreover, by combining this with the implementation process corresponding to the start node described above, the server can implement the initial assignment rules for the start node's input parameters, facilitating the tracking of original inputs and eliminating interference from subsequent calculations.

[0052] Step S203: Perform recursive execution operations on the sub-strategies in the sub-strategy topology until the sub-strategies are executed, and determine the result of the target strategy.

[0053] In one possible embodiment, recursive execution operations are performed on sub-policies within the sub-policy topology until the sub-policies are completed, and the target policy result is determined. This includes: determining the topological order of the sub-policy topology; performing the following operations sequentially for each sub-policy according to the policy execution order: if the node type corresponding to the currently processed sub-policy is a policy node, then performing input parameter validation operations and loading the sub-policy topology corresponding to the currently processed sub-policy; performing recursive execution operations on the sub-policy topology corresponding to the currently processed sub-policy until the sub-policy corresponding to the currently processed sub-policy is completed, and determining the sub-policy result corresponding to the currently processed sub-policy; if the node type corresponding to the currently processed sub-policy is an execution node, then executing the currently processed sub-policy and determining the sub-policy result corresponding to the currently processed sub-policy; and determining the target policy result based on the sub-policy results corresponding to each sub-policy.

[0054] Topology sorting is used to indicate the policy execution order determined based on the dependencies between multiple sub-policies. This embodiment mainly protects nested topology discovery (i.e., when a policy node is encountered, the system actively loads its internal sub-policy topology structure and recursively executes the same process) and hierarchical decoupling (i.e., decomposing complex policies into multi-layered nested topologies (such as policy trees)), thereby enabling each layer to be processed through a unified interface and achieving unlimited hierarchical expansion capabilities.

[0055] The data execution flow in this example corresponds to... Figure 3The "sub-policy section" refers to the process where, after the node type corresponding to the currently processed sub-policy is a policy node, the server executes the policy node. If a policy node exists (i.e., the sub-policy topology structure is loaded, confirming the existence of a sub-policy), input parameter validation and temporary parameter recording are performed for the sub-policy before execution. If a grandchild policy (the sub-policy corresponding to the currently processed sub-policy) exists, the above steps are repeated to traverse each policy node in the policy tree from shallow to deep. When the server detects during recursive execution that the currently executed sub-policy does not belong to a policy node (i.e., an execution node), that node is executed to output the corresponding sub-policy result. After executing the current processing node of the policy structure, the server obtains the corresponding target policy result and then performs subsequent callback update operations, node output parameter validation, and node output parameter recording, which will be described in the subsequent implementation examples.

[0056] In traditional policy tree execution systems, nested calls to sub-policies often lead to problems such as disordered execution order and data pollution. Traditional methods, employing depth-first traversal, cannot effectively handle complex dependencies and lack fine-grained management of variable lifecycles. This application addresses these issues by recursively executing sub-policies before executing complex policy tree structures. Specifically, the server preprocesses the sub-policy topology to analyze dependencies, generate a topology sequence, and then establish a dependency matrix to store input-output constraints between policies. The policy tree structure is essentially a recursive control flow based on topological sorting. The recursive process strictly follows the dependency order generated by the topological sorting, ensuring that the sibling nodes of a parent policy's dependent topologies are completed before the parent policy's sub-topologies are executed.

[0057] Furthermore, the server traverses the sub-policies in topological order. For policy nodes, it recursively calls the execution engine; for execution nodes, it generates a version snapshot after execution. The recursion terminates when a sub-policy becomes an execution node (leaf node), returning results layer by layer from bottom to top. After returning the sub-policy results and determining the target policy result for merging, variable arbitration is performed. Variable arbitration involves checking each variable during execution to determine if there are conflicting variables. There are three types of variables: inherited variables from the parent policy, original variables in the isolation zone, and newly generated variables from the sub-policies. If conflicting variables exist, a conflict resolution strategy is executed: first, the value corresponding to the original variable in the isolation zone is retained; second, the inherited value of the inherited variable corresponding to the parent policy is selected; and finally, the new value of the newly generated variable is adopted.

[0058] As can be seen in this example, by recursively loading sub-topologies, a tree structure of parent, child, and grandchild policies can be constructed, solving the problem of modular expression of ultra-complex policies. This data processing method can improve resource utilization, recursively load sub-topologies only when a policy node is encountered, avoiding the memory overhead of loading the entire policy tree at once, and retrying the current sub-topology when encountering a failure, without needing to roll back the entire policy.

[0059] In one possible embodiment, after loading the sub-policy topology structure corresponding to the current processing node, the current processing node is determined as the parent policy; the target policy result is determined according to the sub-policy result corresponding to each sub-policy, including: obtaining the sub-policy result corresponding to each sub-policy in sequence according to the topological sorting of the sub-policy topology structure; storing the input values ​​of reference variables in the input parameters of the starting node of the sub-policy that do not conflict with the original variables in the original input of the isolation buffer as the original value data of the target policy result; determining the output variables that are not covered by multiple reference variables recorded in the input parameters of the starting node of the parent policy as new variables according to the output variables generated by the execution nodes within the sub-policy stored in the sub-policy result, and storing the output values ​​corresponding to the new variables in the dynamic output value data of the target policy result.

[0060] The start node of a sub-strategy receives input data from its parent strategy, which includes the input values ​​of multiple reference variables. The start node is the node where recursion occurs. The trigger condition is that the parent strategy encounters a strategy node and begins loading the sub-strategy; the sub-strategy process then starts from the "start" node. The operations performed at the start node include skipping validation, temporarily not recording input parameters, and inheriting the parent strategy's input. The input to the start node comes from the parent strategy's strategy node, not directly reused from the parent strategy's start node input.

[0061] Here, the parent policy start node refers to the node where the parent policy begins execution. The input parameters of the parent policy start node are the inherited variables mentioned above, along with their corresponding inherited values. By executing the variable conflict resolution strategy mentioned above, multiple variables are categorized and stored separately for quick location during subsequent data backtracking. Furthermore, a composite key can be used to label variable parameters during storage to facilitate subsequent data retrieval. The composite key format can be: [Policy ID]_[Variable ID]_[Version Number].

[0062] As can be seen, in this example, the server employs a multi-level strategy to improve the accuracy of variable passing and eliminate the risk of data contamination. Furthermore, topological sorting enhances the execution efficiency of nested strategies. Finally, hierarchical variable management and categorized data storage facilitate rapid location of data sources within the dataset.

[0063] Step S204: Execute a callback update operation based on the target policy result to update the dataset of the policy structure; and generate a version record of the current processing node based on the target policy result, and perform an output parameter verification operation on the target policy result.

[0064] Specifically, step S204 corresponds to the following implementation method: Figure 3 The process shown includes "callback to update the input parameters of the parent strategy's strategy node", "callback to update the input parameters of the parent strategy's start node", and "node output parameter verification and output parameter recording".

[0065] In one possible embodiment, a callback update operation is performed based on the target policy result to update the dataset of the policy structure, including: sending the original value data in the target policy result back to the dataset to update the input parameters of the policy node corresponding to the parent policy; sending the dynamic output value in the target policy result back to the dataset to add the dynamic output value and the corresponding new variable to the input parameters of the start node corresponding to the parent policy.

[0066] The implementation principles of this example include a data layered callback architecture and a dataset update algorithm. Specifically, the data layered callback architecture includes a raw value data stream and a dynamic output stream.

[0067] Further, please refer to Figure 4 , Figure 4 This is a schematic diagram of a raw data stream provided in an embodiment of this application; as shown... Figure 4 As shown, the implementation process of the raw value data stream is as follows: the sub-policy execution result is filtered through the raw values. If it does not match the isolation buffer (i.e., the variable in the sub-policy execution result is not overwritten by the original variable in the original input of the isolation buffer), the input parameters of the policy node corresponding to the parent policy are updated via callback. If it matches the isolation buffer (i.e., the variable in the sub-policy execution result is overwritten by the original variable in the original input of the isolation buffer), it is discarded. Specifically, hash fingerprint comparison technology can be used to only return the unmodified initial parameters.

[0068] Further, please refer to Figure 5 , Figure 5 This is a flowchart illustrating a dynamic output stream provided in an embodiment of this application; as shown... Figure 5 As shown, the implementation process of the dynamic output stream involves the following steps: New variables in the sub-policy are checked through the namespace. If they are not covered by multiple reference variables recorded in the start node input parameters of the parent policy, they are added to the start node input parameters of the parent policy; otherwise, they are discarded. The dataset update algorithm refers to data update operations on the dataset implemented based on a bidirectional data channel.

[0069] As can be seen in this example, the server achieves efficient synchronization and accurate updating of data during the execution of the strategy tree through a hierarchical callback mechanism and dynamic variable management, thereby reducing system overhead while ensuring data consistency.

[0070] In one possible embodiment, after generating the version record of the current processing node based on the target policy result and performing output parameter verification on the target policy result, and before outputting the final version chain and dataset corresponding to the policy structure, the method further includes: determining the node type and operation sequence corresponding to each node based on the version record in the version chain to reconstruct the execution path of the policy structure; if the reconstructed execution path is inconsistent with the expected path of the policy execution request, triggering an alarm and rolling back the version chain and dataset to the nearest node version consistent with the expected path; comparing the dynamic output value in the dataset with the output record of the corresponding execution node in the version chain to determine the comparison result; if the comparison result indicates a difference, overwriting the dynamic output value in the dataset based on the output record; and clearing the original input associated with the policy execution request in the isolation buffer when all nodes of the policy structure have been executed.

[0071] The execution principle of this example includes a path reconstruction engine, differential data adjustment, and resource release management. Differential data adjustment refers to ensuring strong data consistency by overwriting the dataset with the version chain when there are differences between the dynamic output values ​​in the dataset and the output records of the corresponding execution nodes in the version chain, thus avoiding data conflicts during subsequent backtracking. Resource release management refers to optimizing resource utilization and improving subsequent data processing efficiency by clearing the original inputs associated with the policy execution request from the isolation buffer after all nodes in the policy structure have completed execution.

[0072] The path reconstruction engine refers to a reverse push algorithm based on a version chain. First, the server extracts the node sequence from the version record, then constructs an execution dependency graph based on the node sequence, and finally determines path consistency by comparing the graph isomorphism of the expected path of the policy execution request. Path consistency is required to ensure the integrity of business logic, meet system reliability requirements, and comply with auditing needs. The expected path is a pre-verified compliant execution process (e.g., financial risk control must follow a strict order of "identity verification → credit assessment → final approval"). Path deviations may lead to the bypassing of business rules (e.g., skipping key risk control nodes). The node dependencies in the policy tree are established based on topological sorting (e.g., node B must wait for the output of node A). Unexpected paths will break dependency constraints, causing data race conditions or deadlocks. Furthermore, to meet compliance auditing requirements, paths must also be consistent to avoid gaps in audit trails due to untraceable business processes.

[0073] Furthermore, when the execution path deviates from the expected path, the server triggers an alarm and performs a data rollback. Data rollback can employ a three-tiered recovery strategy, including: a first-tier node-level rollback (single-node state recovery), a second-tier sub-strategy-level rollback (nested strategy recovery), and a third-tier end-to-end rollback (complete strategy tree reset). This allows for different levels of recovery strategies to be applied to different levels of path discrepancies, effectively shortening the average recovery time, improving strategy execution effectiveness, ensuring end-to-end traceability, and enabling rapid self-healing from faults.

[0074] Furthermore, different levels of data rollback correspond to different alarm levels. The first level alarm is a warning, the second level alarm is an error, and the third level alarm is a critical. The trigger condition for the first level alarm can be a deviation in the order of non-critical nodes, the trigger condition for the second level alarm can be a missing critical dependency node, and the trigger condition for the third level alarm can be that a core verification node is skipped.

[0075] As can be seen in this example, the server achieves real-time anomaly detection and recovery after the strategy is executed through path verification and precise rollback. Furthermore, it ensures strong data consistency by covering the dataset with a version chain, avoiding data conflicts during subsequent backtracking. In addition, it optimizes resource utilization and improves subsequent data processing efficiency by clearing the isolation buffer.

[0076] Step S205: Execute the next pending node in the policy structure in sequence until each node in the policy structure has been executed, and output the final version chain and dataset corresponding to the policy structure.

[0077] The version chain contains version records for each node. It's a chain-like data structure that records variable changes throughout the entire policy execution lifecycle. Records include node ID, timestamp, policy level, and the changed value. Its purpose is to support end-to-end auditing. The version chain enables process tracking (change history).

[0078] The dataset can be understood as a collection of variables representing the final state of policy execution. Its contents may include storing only the final valid values ​​of variables, as well as verifying read / write attribute flags during updates (writable attributes: allow overwriting, read-only attributes: prohibit modification, conditionally writable: require rule engine verification). The dataset's role is to store the final state results (final values).

[0079] As can be seen, in this embodiment, the server parses the corresponding policy structure by responding to the policy execution request sent by the terminal device, and executes each node within the policy structure to realize complex business logic. Furthermore, the server records corresponding data during execution using version chains and datasets, enabling the policy execution process to be traced back, improving decision-making process data, and enhancing the accuracy of data analysis, thereby reducing operational costs and business risks.

[0080] The following are embodiments of the apparatus of this application. These embodiments of the apparatus and the embodiments of the method of this application belong to the same concept and are used to execute the methods described in the embodiments of this application. For ease of explanation, only the parts related to the apparatus embodiments of this application are shown in the embodiments of this application. For specific technical details not disclosed, please refer to the description of the embodiments of the method of this application, which will not be repeated here.

[0081] This application provides a data processing device based on policy tree management, applied to server 110 in a policy tree execution system 100. Specifically, the policy tree-based data processing device is used to execute the steps performed by server 110 in the above-described policy tree-based data processing method. The policy tree-based data processing device provided in this application may include modules corresponding to the respective steps.

[0082] This application embodiment can divide the data processing device based on policy tree management into functional modules according to the above method example. For example, each function can be divided into its own functional module, or two or more functions can be integrated into one processing module. The integrated module can be implemented in hardware or as a software functional module. The module division in this application embodiment is illustrative and only represents one logical functional division; other division methods may be used in actual implementation.

[0083] When dividing each function into modules according to its corresponding function. Figure 6 This is a functional unit block diagram of a data processing device based on strategy tree management provided in an embodiment of this application; the data processing device based on strategy tree management is applied to... Figure 1The server 110 in the policy tree execution system 100 shown. A data processing device 60 based on policy tree management, applied to a server, includes: a response unit 601, used to respond to a policy execution request sent by a terminal device, parse the policy structure indicated by the policy execution request, and identify the node type of the current processing node according to the policy structure. The node types include start node, policy node, and execution node, and the execution node is used to implement preset business logic; a loading unit 602, used to perform input parameter verification operation for the current processing node when the node type of the current processing node is a policy node, and to load the sub-policy topology structure corresponding to the current processing node; an execution unit 603, used to perform recursive execution operation on the sub-policies in the sub-policy topology structure until the sub-policies are executed and to determine the target policy result; a recording unit 604, used to perform a callback update operation according to the target policy result to update the dataset of the policy structure; and to generate a version record of the current processing node according to the target policy result and perform an output parameter verification operation on the target policy result; and an output unit 605, used to sequentially execute the next node to be processed in the policy structure until each node in the policy structure is executed, and output the final version chain and dataset corresponding to the policy structure. The version chain contains the version record corresponding to each node.

[0084] In one possible embodiment, after identifying the node type of the current processing node according to the strategy structure, the response unit 601 is further configured to: skip the input parameter verification operation and the input parameter recording operation when the node type of the current processing node is a start node; temporarily store the original input corresponding to the start node in the isolation buffer; after the execution node associated with the current processing node executes successfully, detect whether the original variable in the original input of the isolation buffer exists in the current version chain; if the original variable exists in the current version chain, determine that the original value corresponding to the original variable stored in the original input is the current value of the original variable.

[0085] In one possible embodiment, after identifying the node type of the current processing node according to the strategy structure, the response unit 601 is further configured to: when the node type of the current processing node is an execution node, perform input parameter verification and input parameter recording operations for the current processing node; execute the current execution node to obtain the node output result; generate a version record of the current processing node based on the node output result; and if the current version chain does not contain the original variables in the original input of the isolation cache, store the new variables in the node output result and the current values ​​corresponding to the new variables in the dataset.

[0086] In one possible embodiment, in terms of performing recursive execution operations on sub-strategies in the sub-strategy topology until the sub-strategies are executed and determining the target strategy result, the execution unit 603 is specifically used to: determine the topological order of the sub-strategy topology, whereby the topological order is used to indicate the strategy execution order determined based on the dependencies between multiple sub-strategies; according to the strategy execution order, perform the following operations sequentially for each sub-strategy: if the node type corresponding to the currently processed sub-strategy is a strategy node, then perform input parameter verification operations on the currently processed sub-strategy and load the sub-strategy topology corresponding to the currently processed sub-strategy; perform recursive execution operations on the sub-strategy topology corresponding to the currently processed sub-strategy until the sub-strategy corresponding to the currently processed sub-strategy is executed and determine the sub-strategy result corresponding to the currently processed sub-strategy; if the node type corresponding to the currently processed sub-strategy is an execution node, then execute the currently processed sub-strategy and determine the sub-strategy result corresponding to the currently processed sub-strategy; and determine the target strategy result based on the sub-strategy result corresponding to each sub-strategy.

[0087] In one possible embodiment, after loading the sub-policy topology structure corresponding to the current processing node, the current processing node is determined to be the parent policy. Regarding determining the target policy result based on the sub-policy result corresponding to each sub-policy, the execution unit 603 is specifically used to: sequentially obtain the sub-policy result corresponding to each sub-policy according to the topological sorting of the sub-policy topology structure; store the input values ​​of reference variables in the starting node input parameters of the sub-policy that do not conflict with the original variables in the original input of the isolation buffer as the original value data of the target policy result, where the starting node input parameters of the sub-policy are the input data of the parent policy inherited by the sub-policy, and the input data includes the input values ​​of multiple reference variables; determine the output variables not covered by the multiple reference variables recorded in the starting node input parameters of the parent policy as new variables based on the output variables generated by the execution nodes within the sub-policy stored in the sub-policy result, and store the output values ​​corresponding to the new variables in the dynamic output value data of the target policy result.

[0088] In one possible embodiment, in performing a callback update operation based on the target policy result to update the dataset of the policy structure, the recording unit 604 is specifically used to: send the original value data in the target policy result back to the dataset to update the input parameters of the policy node corresponding to the parent policy; send the dynamic output value in the target policy result back to the dataset to add the dynamic output value and the corresponding new variable to the input parameters of the start node corresponding to the parent policy.

[0089] In one possible embodiment, after generating the version record of the current processing node based on the target policy result and performing output parameter verification on the target policy result, and before outputting the final version chain and dataset corresponding to the policy structure, the output unit 605 is further configured to: determine the node type and operation sequence corresponding to each node based on the version record in the version chain to reconstruct the execution path of the policy structure; if the reconstructed execution path is inconsistent with the expected path of the policy execution request, trigger an alarm and roll back the version chain and dataset to the nearest node version consistent with the expected path; and compare the dynamic output value in the dataset with the output record of the corresponding execution node in the version chain to determine the comparison result; if the comparison result indicates a difference, overwrite the dynamic output value in the dataset according to the output record; and when all nodes of the policy structure have been executed, clear the original input associated with the policy execution request in the isolation buffer.

[0090] When using integrated units, such as Figure 7 As shown, Figure 7 This is a functional unit block diagram of another data processing device based on strategy tree management provided in this application embodiment. Figure 7 The data processing apparatus 60 based on policy tree management includes a processing module 702 and a communication module 701. The processing module 702 controls and manages the actions of the policy tree-based data processing apparatus 60, such as the steps of the response unit 601, loading unit 602, execution unit 603, recording unit 604, and output unit 605, and / or other processes for executing the techniques described herein. The communication module 701 supports interaction between the policy tree-based data processing apparatus and other devices. Figure 7 As shown, the data processing device based on policy tree management may include a storage module 703, which is used to store the program code and data of the data processing device based on policy tree management.

[0091] The processing module 702 can be a processor or server, such as a central processing unit (CPU), a general-purpose processor, a digital signal processor (DSP), an ASIC, an FPGA, or other programmable logic devices, transistor logic devices, hardware components, or any combination thereof. It can implement or execute the various exemplary logic blocks, modules, and circuits described in conjunction with the disclosure of this application. The processor can also be a combination that implements computational functions, such as a combination of one or more microprocessors, a combination of a DSP and a microprocessor, etc. The communication module 701 can be a transceiver, RF circuitry, or a communication interface, etc. The storage module 703 can be a memory.

[0092] All relevant content in each scenario involved in the above method embodiments can be referenced from the functional descriptions of the corresponding functional modules, and will not be repeated here. The data processing device 60 based on strategy tree management described above can execute the above... Figure 2 The data processing method shown is based on strategy tree management.

[0093] The above embodiments can be implemented, in whole or in part, by software, hardware, firmware, or any other combination thereof. When implemented using software, the above embodiments can be implemented, in whole or in part, as a computer program product. A computer program product includes one or more computer instructions or computer programs. When the computer instructions or computer programs are loaded or executed on a computer, all or part of the processes or functions according to the embodiments of this application are generated. The computer can be a general-purpose computer, a special-purpose computer, a computer network, or other programmable device. Computer instructions can be stored in a computer-readable storage medium or transmitted from one computer-readable storage medium to another. For example, computer instructions can be transmitted from one website, computer, server, or data center to another website, computer, server, or data center via wired or wireless means. A computer-readable storage medium can be any available medium that a computer can access or a data storage device such as a server or data center that includes one or more sets of available media. Available media can be magnetic media (e.g., floppy disks, hard disks, magnetic tapes), optical media (e.g., DVDs), or semiconductor media. Semiconductor media can be solid-state drives.

[0094] Figure 8 This is a structural block diagram of a server provided in an embodiment of this application. For example... Figure 8 As shown, server 110 may include one or more of the following components: processor 801, memory 802 coupled to processor 801, wherein memory 802 may store one or more computer programs 803, the one or more computer programs 803 being configured to implement the methods described in the above embodiments when executed by one or more processors 801.

[0095] Processor 801 may include one or more processing cores. Processor 801 connects to various parts of server 110 using various interfaces and lines, and performs various functions and processes data of server 110 by running or executing instructions, programs, code sets, or instruction sets stored in memory 802, and by calling data stored in memory 802. Optionally, processor 801 may be implemented using at least one hardware form of Digital Signal Processing (DSP), Field-Programmable Gate Array (FPGA), or Programmable Logic Array (PLA). Processor 801 may integrate one or a combination of several of the following: Central Processing Unit (CPU), Graphics Processing Unit (GPU), and modem. The CPU primarily handles the operating system, user interface, and applications; the GPU is responsible for rendering and drawing the displayed content; and the modem handles wireless communication. It is understood that the modem may also not be integrated into processor 801 and may be implemented separately using a communication chip.

[0096] The memory 802 may include random access memory (RAM) or read-only memory (ROM). The memory 802 can be used to store instructions, programs, code, code sets, or instruction sets. The memory 802 may include a program storage area and a data storage area. The program storage area may store instructions for implementing an operating system, instructions for implementing at least one function (such as touch functionality, sound playback functionality, image playback functionality, etc.), and instructions for implementing the various method embodiments described above. The data storage area may also store data created by the server 110 during use.

[0097] It is understood that server 110 may include more or fewer structural elements than those shown in the above block diagram, and this is not limited thereto.

[0098] This application also provides a computer storage medium storing a computer program / instructions thereon, which, when executed by a processor, implements some or all of the steps of any of the methods described in the above method embodiments.

[0099] This application also provides a computer program product, which includes a non-transitory computer-readable storage medium storing a computer program operable to cause a computer to perform some or all of the steps of any of the methods described in the above method embodiments.

[0100] It should be understood that in the various embodiments of this application, the order of the above-mentioned processes does not imply the order of execution. The execution order of each process should be determined by its function and internal logic, and should not constitute any limitation on the implementation process of the embodiments of this application.

[0101] In the several embodiments provided in this application, it should be understood that the disclosed methods, apparatuses, and systems can be implemented in other ways. For example, the apparatus embodiments described above are merely illustrative; for example, the division of units is merely a logical functional division, and there may be other division methods in actual implementation; for example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the coupling or direct coupling or communication connection shown or discussed may be through some interfaces, and the indirect coupling or communication connection between devices or units may be electrical, mechanical, or other forms.

[0102] 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 network units. Some or all of the units can be selected to achieve the purpose of this embodiment according to actual needs.

[0103] Furthermore, the functional units in the various embodiments of the present invention can be integrated into one processing unit, or each unit can be physically comprised separately, or two or more units can be integrated into one unit. The integrated unit described above can be implemented in hardware or in the form of hardware plus software functional units.

[0104] The integrated units implemented as software functional units described above can be stored in a computer-readable storage medium. These software functional units, stored in a storage medium, include several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute partial steps of the methods of the various embodiments of the present invention. The aforementioned storage medium includes: a USB flash drive, a portable hard drive, a magnetic disk, an optical disk, volatile memory, or non-volatile memory. The non-volatile memory can be read-only memory (ROM), programmable read-only memory (PROM), erasable programmable read-only memory (EPROM), electrically erasable programmable read-only memory (EEPROM), or flash memory. The volatile memory can be random access memory (RAM), which is used as an external cache. By way of example, but not limitation, many forms of random access memory (RAM) are available, such as static RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), double data rate synchronous DRAM (DDR SDRAM), enhanced synchronous DRAM (ESDRAM), synchronous linked DRAM (SLDRAM), and direct rambus RAM (DR RAM), etc., which are various media capable of storing program code.

[0105] While the present invention has been disclosed above, it is not limited thereto. Any person skilled in the art can easily conceive of variations or substitutions without departing from the spirit and scope of the present invention, and various modifications and alterations can be made, including combinations of the different functions and implementation steps described above, as well as software and hardware implementation methods, all of which are within the protection scope of the present invention.

Claims

1. A data processing method based on strategy tree management, characterized in that, Applied to a server, the method includes: In response to a policy execution request sent by a terminal device, the policy structure indicated by the policy execution request is parsed, and the node type of the current processing node is identified according to the policy structure. The node type includes a start node, a policy node, and an execution node. The execution node is used to implement preset business logic. When the node type of the current processing node is a policy node, an input parameter verification operation is performed on the current processing node, and the sub-policy topology structure corresponding to the current processing node is loaded. Recursive execution operations are performed on the sub-strategies in the sub-strategy topology until the sub-strategy is completed, and the result of the target strategy is determined. Execute a callback update operation based on the result of the target policy to update the dataset of the policy structure; and, Generate a version record for the current processing node based on the target strategy result, and perform an output parameter verification operation on the target strategy result; The next node to be processed in the strategy structure is executed sequentially until each node in the strategy structure has been executed. The final version chain and dataset corresponding to the strategy structure are output, and the version chain contains the version record corresponding to each node.

2. The method according to claim 1, characterized in that, After identifying the node type of the current processing node according to the strategy structure, the method further includes: When the node type of the current processing node is the starting node, skip the input parameter verification operation and the input parameter recording operation; The original input corresponding to the starting node is temporarily stored in the isolation buffer. After the execution node associated with the current processing node executes successfully, it is checked whether the original variables in the original input of the isolation cache exist in the current version chain; If the original variable exists in the current version chain, then the original value corresponding to the original variable stored in the original input is determined to be the current value of the original variable.

3. The method according to claim 2, characterized in that, After identifying the node type of the current processing node according to the strategy structure, the method further includes: When the node type of the current processing node is the execution node, the input parameter verification operation and the input parameter recording operation are performed on the current processing node; Execute the execution node to obtain the node output result; Based on the node output, generate a version record for the currently processed node; and, If the original variable in the original input of the isolated cache does not exist in the current version chain, then the new variable in the node output and the current value corresponding to the new variable are stored in the dataset.

4. The method according to claim 3, characterized in that, The recursive execution operation for sub-strategies in the sub-strategy topology until the sub-strategy is completed, and the determination of the target strategy result, includes: Determine the topological order of the sub-strategy topology, the topological order being used to indicate the strategy execution order determined based on the dependencies between the multiple sub-strategies; According to the execution order of the strategy, the following operations are performed sequentially for each of the sub-strategies: If the node type corresponding to the currently processed sub-strategy is a strategy node, then the input parameter verification operation is performed for the currently processed sub-strategy, and the sub-strategy topology structure corresponding to the currently processed sub-strategy is loaded. The recursive execution operation is performed on the sub-strategy topology corresponding to the currently processed sub-strategy until the sub-strategy corresponding to the currently processed sub-strategy is executed, and the sub-strategy result corresponding to the currently processed sub-strategy is determined. If the node type corresponding to the currently processed sub-strategy is the execution node, then the currently processed sub-strategy is executed, and the result of the sub-strategy corresponding to the currently processed sub-strategy is determined; The target strategy result is determined based on the sub-strategy result corresponding to each sub-strategy.

5. The method according to claim 4, characterized in that, After loading the sub-policy topology structure corresponding to the current processing node, the current processing node is determined as the parent policy; determining the target policy result based on the sub-policy result corresponding to each sub-policy includes: Based on the topological sorting of the sub-strategy topology, the sub-strategy results corresponding to each sub-strategy are obtained sequentially. The input values ​​of the reference variables in the starting node input parameters of the sub-strategy that do not conflict with the original variables in the original input of the isolation buffer are stored as the original value data of the target strategy result. The starting node input parameters of the sub-strategy are the input data of the parent strategy inherited by the sub-strategy, and the input data includes the input values ​​of multiple reference variables. Based on the output variables generated by the execution nodes within the sub-strategy stored in the sub-strategy result, the output variables not covered by the multiple reference variables recorded in the start node input parameters of the parent strategy are determined as the new variables, and the output values ​​corresponding to the new variables are stored in the dynamic output value data of the target strategy result.

6. The method according to claim 5, characterized in that, The step of performing a callback update operation based on the result of the target policy to update the dataset of the policy structure includes: The original value data in the target policy result is sent back to the dataset to update the input parameters of the policy node corresponding to the parent policy; The dynamic output value from the target policy result is sent back to the dataset to add the dynamic output value and the corresponding new variable to the input parameters of the starting node corresponding to the parent policy.

7. The method according to claim 6, characterized in that, After generating the version record of the current processing node based on the target policy result and performing output parameter verification on the target policy result, and before outputting the final version chain and dataset corresponding to the policy structure, the method further includes: The node type and operation sequence corresponding to each node are determined based on the version record in the version chain, so as to reconstruct the execution path of the strategy structure; If the reconstructed execution path is inconsistent with the expected path of the policy execution request, an alarm is triggered, and the version chain and the dataset are rolled back to the most recent node version consistent with the expected path; and, Compare the dynamic output values ​​in the dataset with the output records of the corresponding execution nodes in the version chain to determine the comparison result; If the comparison result indicates a difference, then the dynamic output values ​​in the dataset are overwritten according to the output records; and, When all nodes of the policy structure have been executed, the original input associated with the policy execution request in the isolation buffer is cleared.

8. A data processing device based on strategy tree management, characterized in that, Applied to a server, the device includes: The response unit is used to respond to a policy execution request sent by the terminal device, parse the policy structure indicated by the policy execution request, and identify the node type of the current processing node according to the policy structure. The node type includes a start node, a policy node, and an execution node. The execution node is used to implement preset business logic. The loading unit is used to perform input parameter verification operation for the current processing node and load the sub-policy topology structure corresponding to the current processing node when the node type of the current processing node is a policy node. An execution unit is used to perform recursive execution operations on the sub-strategies in the sub-strategy topology until the sub-strategy is completed and to determine the target strategy result. The recording unit is configured to perform a callback update operation based on the target strategy result to update the dataset of the strategy structure; and to generate a version record of the current processing node based on the target strategy result, and to perform an output parameter verification operation on the target strategy result. The output unit is used to sequentially execute the next pending node in the strategy structure until each node in the strategy structure has been executed, and output the final version chain and dataset corresponding to the strategy structure, wherein the version chain contains the version record corresponding to each node.

9. A server, characterized in that, It includes a processor, a memory, and one or more programs, said one or more programs being stored in the memory and configured to be executed by the processor, said programs including instructions for performing the steps in the method as claimed in any one of claims 1-7.

10. A computer program product comprising a computer program / instructions, characterized in that, When the computer program / instructions are executed by the processor, they implement the steps of the method according to any one of claims 1-7.

Images