Automated orchestration system and implementation method based on event driving and context management

Abstract

The application relates to the technical field of process arrangement, and discloses an automatic arrangement system based on event driving and context management and an implementation method, the system comprising: a model arrangement module which receives external requests through OpenAPI, performs model encapsulation based on namespace attributes, and abstracts workflow execution capability into configurable model entities; a workflow engine module which provides a dynamic arrangement and execution mechanism based on a directed graph structure and performs unified context management; a parameter configuration module which constructs a global data constraint and management mechanism of a parameter-result double-layer model and establishes a data mapping relationship between an execution layer and a display layer of a process; and a data source management module which uniformly manages and configures external service capability units that can be called by nodes in the workflow. The application can realize asynchronous, self-driven and distributed parallel execution of workflow nodes, improve operation efficiency in a high-concurrency scenario, and realize the organic unification of performance, stability and expansibility.

Description

Technical Field

[0001] This invention relates to the field of process orchestration technology, specifically to an automated orchestration system and implementation method based on event-driven and context management. Background Technology

[0002] As enterprises deepen their digital transformation, automated orchestration systems are widely used in complex scenarios such as financial risk control, credit approval, and operational scheduling. The core objective of automated orchestration is to organize dispersed and independent tasks and resources into a coordinated, orderly, and efficient workflow through predefined logic and strategies, thereby automating the execution of complex processes. The industry commonly uses workflow engines or orchestration systems to achieve cross-system data interaction and process automation. A workflow is a directed graph composed of nodes and edges, used for orchestrating logic such as invocation, judgment, and merging; it is bound to a model one-to-one. Early workflow systems often adopted a centralized architecture, relying on BPMN process languages ​​or XML configuration, executing tasks sequentially in a synchronous blocking manner. The process state was maintained by a single node and persisted to a database, suitable for scenarios with fixed structures and short links.

[0003] In recent years, the Low-Code / No-Code (LCNC) concept has encouraged business users to participate in process construction, and graphical process editors have lowered the barrier to entry by using drag-and-drop nodes and form configuration. However, existing platforms still have significant shortcomings in key areas such as execution triggering mechanisms and context state management, making it difficult to balance performance, reliability, and scalability in high-concurrency scenarios. Existing distributed workflow engines or process orchestration systems generally suffer from the following core defects:

[0004] First, the lack of an event-driven mechanism results in high system coupling and poor scalability. Existing workflow systems generally adopt synchronous or centralized scheduling architectures, triggering node execution sequentially after the master node periodically polls the process status. This design has the following problems: the execution chain is fixed and dependent on the central controller; true asynchronous decoupling is not achieved between nodes; once the central task is blocked, the entire process will stagnate; the centralized scheduler easily becomes a performance bottleneck, limiting system throughput and making elastic scaling difficult; event triggering and task scheduling are tightly coupled, preventing tasks from dynamically driving subsequent nodes based on execution results, leading to sluggish system response and low resource utilization. Synchronous or polling architectures can no longer meet the requirements of distributed automated processes for high concurrency, low latency, and self-driven execution.

[0005] Secondly, node synchronization and state consistency issues are prominent in distributed environments. Existing systems lack a unified mechanism for context state management. Each node executes tasks independently, and output results need to be manually passed or shared via database to achieve context transmission. This model leads to: context data relying on external persistent storage, resulting in low access efficiency and high maintenance costs; a lack of isolation and version control for shared data when multiple nodes execute in parallel, easily causing state overwriting or result corruption; and difficulty in recovering to the precise execution point after abnormal process interruption, affecting task reliability and traceability. Especially in asynchronous event and cross-thread execution scenarios, the lack of a system-level context passing mechanism results in scattered process execution data and difficulty in unified state management.

[0006] To address these issues, we have invented an automated orchestration system and implementation method based on event-driven and context management, which solves the aforementioned technical problems. Summary of the Invention

[0007] This invention provides an automated orchestration system and implementation method based on event-driven and context management, which can improve the operating efficiency in high-concurrency scenarios and achieve an organic unity of performance, stability and scalability.

[0008] Therefore, the present invention provides the following technical solution:

[0009] An automated orchestration system based on event-driven and context management, the system comprising:

[0010] The model orchestration module receives external requests through OpenAPI, performs model encapsulation based on namespace attributes, and abstracts workflow execution capabilities into configurable model entities.

[0011] The workflow engine module, connected to the model orchestration module, provides a dynamic orchestration and execution mechanism based on a directed graph structure and performs unified context management;

[0012] The parameter configuration module, connected to the workflow engine module, constructs a global data constraint and management mechanism for a parameter-result two-layer model, and establishes a data mapping relationship between the execution layer and the presentation layer of the process.

[0013] The data source management module is connected to the workflow engine module and manages and configures the external service capability units that can be called by nodes in the workflow.

[0014] Optionally, the model orchestration module receives external requests through OpenAPI, identifies and loads the workflow associated with the model based on the model identifier corresponding to the request, and each node in the workflow implements business functions by calling the configured data source and passes method parameters during execution.

[0015] Optionally, when the model orchestration module abstracts the workflow execution capability into configurable model entities, it binds each model to a namespace to describe the resource combination and orchestration logic under that namespace. The status of the model includes unpublished, pending review, published, and obsolete. The system performs lifecycle management functions such as model creation, review, publication, ordering, and recycling through the model orchestration module.

[0016] Optionally, the workflow engine module formally describes the process structure using a graph model G=(V, E,ζ,τ), where:

[0017] V={v1, v2, ..., v n} represents a set of nodes, where each node v i Has type(v) i )∈{START,PROCESS, DECISION, SPLIT,MERGE, END};

[0018] E V×V is a set of edges that represent execution dependencies;

[0019] ζ:E→Condition is the edge labeling function, which supports defining branch conditions using SpEL expressions;

[0020] τ:V→Action is the node action mapping function, which defines the node execution logic.

[0021] Optionally, the workflow engine module describes the process logic in the form of a directed acyclic graph, defining node types such as START, END, DECISION, SPLIT, MERGE, and PROCESS to express complex control flows such as sequential, conditional branching, and parallel execution. The execution mechanism includes an event-driven mechanism based on a message queue, where the execution result of each node is published to the message bus in the form of an event. The system automatically triggers the execution of subsequent nodes according to the event type and dependencies, thereby achieving asynchronous decoupling and high-concurrency scheduling of tasks.

[0022] Optionally, when performing unified context management, the workflow engine module creates an independent context object for each process instance to record node input and output parameters, execution status, and intermediate results. It also achieves efficient access and reliable synchronization of context data through a multi-level storage system consisting of memory caching, Redis distributed caching, and persistent database storage. The context is automatically updated after each node execution to ensure the consistency and traceability of the process status in a distributed environment and supports snapshot-based breakpoint recovery.

[0023] Optionally, the parameter configuration module elevates the input and output parameters in the traditional workflow into structured data entities with semantics, reusability, computability, and manageability, and completes the decoupling of data definition and use through the parameter-result two-layer model.

[0024] Optionally, the parameters in the parameter-result two-layer model represent the input and output parameters that are dynamically passed during the execution of the process, serving as the basic carrier for cross-node data sharing and reuse, and supporting cross-node data sharing and reuse; the results are used to aggregate, statistically analyze or derive calculations on the result data based on preset rules after the process instance is executed, supporting multi-dimensional analysis and visualization output.

[0025] An implementation method based on event-driven and context management, the method comprising:

[0026] Step 1: Receive external requests through OpenAPI, encapsulate the model based on namespace attributes, and abstract the workflow execution capability into a configurable model entity;

[0027] Step 2: Implement a dynamic orchestration and execution mechanism based on a directed graph structure;

[0028] Step 3: Perform unified context management;

[0029] Step 4: Construct a global data constraint and management mechanism for the parameter-result two-layer model, and establish a data mapping relationship between the execution layer and the presentation layer of the process.

[0030] A computer-readable storage medium having a computer program stored thereon, the computer program being executed by a processor to perform the steps of the event-driven and context-managed implementation method.

[0031] This invention addresses the problems of high coupling, poor scalability, complex state synchronization, and insufficient data consistency in existing automated orchestration systems regarding execution triggering and context management. It proposes a distributed automated orchestration system and implementation method based on event-driven and context management, aiming to fundamentally improve the execution efficiency, stability, and maintainability of workflows from the system architecture level. This invention employs a message queue-based event-driven workflow execution mechanism, a context-consistent distributed state management mechanism, and a full-link data governance mechanism based on a "parameter-result" two-layer model. By constructing a workflow orchestration system that combines a message queue-based event-driven asynchronous execution architecture with a unified context management model, it achieves asynchronous, self-driven, and distributed parallel execution of workflow nodes, improving operational efficiency in high-concurrency scenarios. Through unified context management and a state snapshot mechanism, it ensures data consistency and reliable recovery capabilities during process execution, ultimately achieving an organic unity of performance, stability, and scalability. Compared with existing technologies, this invention has the following technical advantages:

[0032] First, this invention addresses how to implement an asynchronous, decoupled execution mechanism in high-concurrency scenarios, avoiding performance bottlenecks and scheduling blocking issues caused by centralized scheduling. Existing systems generally employ centralized or synchronous scheduling architectures, where node execution relies on the sequential triggering of a global controller, failing to achieve true parallel execution and easily creating performance bottlenecks as the workload increases. This invention introduces a message queue-based event-driven mechanism, transforming the execution triggering and state transition of process nodes into an asynchronous event message distribution process, achieving complete decoupling between nodes. This mechanism enables dynamic task triggering and concurrent processing in a distributed environment through event routing, thereby significantly improving system throughput and scalability.

[0033] Secondly, this invention addresses how to achieve unified context state management and data flow control in a distributed concurrent execution environment, ensuring the consistency and traceability of process execution. In existing solutions, data transfer between nodes relies on external databases or temporary storage, leading to inconsistent states, context loss, and difficulties in process recovery. This invention designs a multi-layered context management mechanism to achieve unified storage and dynamic updates of the process's global state, node execution results, and intermediate parameters. The system employs a layered strategy of memory caching, distributed caching (Redis), and persistent storage to achieve efficient reading and reliable synchronization of context data. Simultaneously, snapshot and isolation mechanisms are introduced, enabling recovery to the precise execution point based on the context after abnormal process interruption, ensuring task reliability and traceability. Attached Figure Description

[0034] To more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the accompanying drawings used in the embodiments will be briefly described below. Obviously, the drawings described below are merely some embodiments of the present invention, and those skilled in the art can obtain other drawings based on these drawings without any creative effort.

[0035] Figure 1 This is an architecture diagram of an automated orchestration system based on event-driven and context management in a specific embodiment of the present invention;

[0036] Figure 2 This is a diagram of an event handling model for an implementation method based on event-driven and context management in a specific embodiment of the present invention.

[0037] Figure 3 This is a schematic diagram of the dynamic workflow execution topology based on a directed graph in a specific embodiment of the present invention. Detailed Implementation

[0038] The specific embodiments of the present invention will be described in detail below with reference to the accompanying drawings. It should be understood that the specific embodiments described herein are for illustration and explanation only and are not intended to limit the present invention.

[0039] To enable those skilled in the art to better understand the present invention, the technical solutions of the present invention will be clearly and completely described below with reference to the accompanying drawings of the embodiments. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort should fall within the scope of protection of the present invention.

[0040] This invention proposes an automated orchestration system based on event-driven and context management, the architecture of which is as follows: Figure 1 As shown, this system, by introducing a message queue bus and a hierarchical context state management mechanism, achieves asynchronous node execution, traceable process states, and data consistency control in distributed scenarios, fundamentally solving the core problems of existing automated orchestration systems such as "centralized scheduling, delayed triggering, fragmented states, and difficult recovery."

[0041] This event-driven and context-managed automated orchestration system includes a model orchestration module, a workflow engine module, a data source management module, and a parameter configuration module.

[0042] The model orchestration module is used to abstract, encapsulate, and manage the configuration of external requests. The specific business functions or service goals that users wish to achieve are referred to as "models," and mainly include:

[0043] 1) Model definition: Supports user-defined business models, defining their input / output interfaces and processing logic;

[0044] 2) Workflow Association: Combining multiple models into complex workflow tasks;

[0045] 3) Standardized output: Unify the return format of different models to facilitate downstream consumption;

[0046] 4) Key distribution: Provides secure authentication support for model calls;

[0047] 5) Call Log: Records the time, parameters, results, and other information of each model call for auditing and monitoring.

[0048] This module abstracts workflow execution capabilities into configurable "model" entities. A model is an exposed "method / service" that can be invoked externally; its business logic is implemented by a workflow. Each model is bound to a specific namespace, describing the resource composition and orchestration logic within that namespace. A namespace is an enterprise-level resource isolation unit, similar to the tenant concept in a multi-tenant system; users associated with a namespace can create models and workflows within it. The system uses this module to implement lifecycle management functions such as model creation, approval, publication, ordering, and recycling. Model states include "unpublished," "pending approval," "published," and "deprecated," and the system automatically controls its visibility and callability in service orchestration based on its state. When a model is in the "published" state, the system exposes service capabilities through a unified interface protocol (OpenAPI), ensuring consistency and traceability between model publication and external system calls. OpenAPI serves as the system's unified external service entry point, and each namespace calls its models through a standard interface.

[0049] The workflow engine module is responsible for the dynamic orchestration and execution control of workflows, specifically including:

[0050] 1) Visual orchestration: Provides a graphical interface for users to drag and drop to configure workflows;

[0051] 2) Event-driven based on message queues: Decoupling task scheduling and execution through message middleware to achieve asynchronous processing;

[0052] 3) Service Node: As the basic execution unit in the workflow, it is responsible for calling specific services;

[0053] 4) Context management mechanism: Maintain global context variables during process execution to ensure data consistency across nodes;

[0054] 5) Rule-based judgment: Determines the flow direction (such as branching or looping) based on preset conditions;

[0055] 6) Version Management: Supports multiple versions of workflows coexisting and canary releases.

[0056] 7) Fault tolerance and recovery: Supports strategies such as failure retry, exception skipping, and manual intervention;

[0057] 8) Parallel Invocation: Supports simultaneous execution of multiple service nodes, improving process processing efficiency and suitable for business scenarios requiring concurrent processing.

[0058] This module provides a dynamic orchestration and execution mechanism based on a directed graph structure. The system formally describes the process structure using a graph model G=(V, E,ζ,τ), where:

[0059] V={v1, v2, ..., vn} represents a set of nodes, where each node v i Has type(v) i )∈{START,PROCESS, DECISION, SPLIT,MERGE, END}; where START represents the start, PROCESS represents the process, DECISION represents the decision, SPLIT represents the branch, MERGE represents the convergence, and END represents the end, all of which are standard symbols in flowcharts.

[0060] E V×V is a set of edges that represent execution dependencies;

[0061] ζ: E→Condition is the edge labeling function, which supports defining branch conditions using SpEL expressions;

[0062] τ: V→Action is the node action mapping function, which defines the node execution logic.

[0063] It uses a JSON structure for storage and parsing to support asynchronous, parallel, and dynamic execution of processes. This design clearly expresses the dependencies between nodes, adapts to complex business logic and concurrent execution scenarios, and ensures consistency between process control and execution results.

[0064] The data source management module is used to uniformly manage and configure external service capability units that can be invoked by nodes in the workflow. The "data source" is not the original connection resource, but rather an abstract encapsulation of a set of function-related interfaces. Each data source explicitly defines the operations it supports, the input parameter structure of each operation, and the output parameter structure. This module mainly includes:

[0065] 1) Data source definition: Users can create data sources and name them (such as "Order Service" or "Payment Gateway") to serve as capability references for workflow nodes;

[0066] 2) Interface configuration: Define one or more specific interfaces within the data source, including interface name, calling method, authentication method, timeout policy, etc., and explicitly declare the input parameter fields required by the interface and the output parameter fields of the returned result;

[0067] 3) Node circuit breaker configuration: Configure circuit breaker rules for each data source, and automatically trigger the protection mechanism when a workflow node fails to call the data source;

[0068] 4) Call Log: Records details of each call to the data source, facilitating subsequent auditing, performance analysis, and anomaly troubleshooting.

[0069] This module proposes a hierarchical data source unified management and fine-grained access control scheme, aiming to solve the security risks caused by duplicate third-party data source access, inconsistent calling methods, and shared access credentials in multi-tenant environments in existing systems. Through an abstract data source model, interface layering, and security authentication mechanisms, this module achieves a data access system of "one-time access, multiple reuses, and unified governance."

[0070] The parameter configuration module implements full lifecycle management of process parameters, including:

[0071] 1) Parameter definition: Define the name, type, default value, etc. of the input / output parameters;

[0072] 2) Parameter classification: Classify parameters according to their purpose (e.g., system-level, business-level);

[0073] 3) Parameter Management: Supports adding, deleting, modifying, and querying parameters, as well as access control;

[0074] 4) Version management: Records parameter change history to ensure parameter consistency.

[0075] This module constructs a global data constraint and management mechanism based on a two-layer "parameter-result" model, elevating input and output parameters in traditional workflows into structured data entities with semantics, reusability, computability, and governability. Parameters are used to store external inputs or assignment information during process execution. As a dynamically transmitted data carrier during process execution, parameters support cross-node data sharing and reuse. Results are derived data units used for statistical analysis and visualization of output data after process completion, supporting multi-dimensional aggregation and visualization. This layered model decouples data definition from usage, establishing a clear data mapping relationship between the execution and presentation layers.

[0076] This invention introduces a message queue-based event-driven architecture to decouple the triggering and execution of workflow nodes from the central scheduler, enabling asynchronous, parallel, and high-concurrency task processing. Each node's execution is triggered by an event, and the system automatically distributes messages to the corresponding execution units based on message type, achieving independent processing and dynamic scaling of nodes. This mechanism supports on-demand expansion of the number of consumer instances and provides message persistence and idempotency guarantees, effectively avoiding blocking and resource contention issues in large-scale concurrent task execution scenarios, thereby constructing a high-throughput, elastically scalable distributed workflow execution system.

[0077] This invention proposes a hierarchical workflow context data management and consistency control scheme to maintain the consistency of node execution state and business data in a distributed environment. The system achieves isolation and dynamic transmission of node execution data, global process state, and business input parameters through a hierarchical context structure; simultaneously, it combines distributed caching to achieve state sharing and data persistence between nodes, supporting anomaly recovery and process backtracking. This scheme effectively solves problems such as "branch node state asynchrony and uncertain JOIN node triggering" in traditional systems, achieving lock-free, low-latency, and highly reliable distributed coordination and state consistency control.

[0078] This invention constructs a reusable, computable, and governable structured data entity model, separating and managing process input parameters and output results, and establishing a clear data mapping relationship between the execution and presentation layers. This mechanism supports hierarchical registration and permission binding based on namespaces or tenant identities, enabling cross-node data sharing and reuse as well as cross-tenant logical isolation. Through a context mechanism, parameter states are dynamically parsed and maintained, and result calculation and persistence are automatically triggered after process termination, achieving traceability of the entire process data state and breakpoint recovery, providing end-to-end data governance capabilities for complex business scenarios.

[0079] This invention proposes an implementation method based on event-driven and context management, with the event handling flow model as follows: Figure 2 As shown. The system receives external requests through OpenAPI, which are routed through models. Each model is associated with a specific workflow orchestration logic. Each node in the workflow implements its business function by calling the configured data source and passing method parameters during execution. The data source serves as a unified management view for both the interface and the data. Before the process executes, the system loads the corresponding workflow definition from the configuration library and caches it in memory, while simultaneously initializing an independent execution context for this call. Utilizing a distributed lock mechanism, the system sends the execution task of the first node to the message queue according to the workflow orchestration order, initiating the asynchronous execution process. Specifically, this includes:

[0080] Step 21, Model Arrangement.

[0081] This invention proposes a model-based service encapsulation mechanism based on namespace attributes. By modularizing and standardizing the interface encapsulation of workflow execution capabilities, it achieves controllable service release and unified management. The model layer defines the functional characteristics and interface specifications of the service, while the dedicated layer defines the ownership and access boundaries of the model. The combination of these two layers enables differentiated service distribution strategies for different tenants or business domains. The system supports restricting the subscription and invocation of models to specified users or tenants, achieving secure isolation and controllable authorization in a multi-tenant environment.

[0082] Step 22, Workflow execution.

[0083] The module provides a dynamic orchestration and execution mechanism based on a directed graph structure, formally describing the process logic using a directed acyclic graph (DAG). It defines various node types, such as start node (START), end node (END), decision node (DECISION), parallel branch (SPLIT), merge node (MERGE), and process node (PROCESS). Figure 3 As shown in the figure, it clearly expresses complex control flows such as sequential, conditional branching, and parallel execution.

[0084] To overcome the performance and scalability bottlenecks of traditional synchronous scheduling architectures, this invention introduces a message queue-based event-driven mechanism into the workflow engine. The execution result of each node is published to the message bus as an event. The system automatically triggers the execution of subsequent nodes based on the event type and dependencies, thereby achieving asynchronous decoupling and high-concurrency scheduling of tasks. This mechanism supports event backlog and peak smoothing, ensuring stable operation of the process under high load, while message acknowledgment and retry strategies ensure the reliability of event delivery.

[0085] Step 23, Unify context management.

[0086] To address the issues of state synchronization and data consistency in complex processes, this invention further proposes a unified context management mechanism. The system creates an independent context object for each process instance to record node input / output parameters, execution status, and intermediate results. A multi-level storage system, comprising memory caching, Redis distributed caching, and persistent database storage, enables efficient access and reliable synchronization of context data. The context is automatically updated after each node execution, ensuring the consistency and traceability of the process state in a distributed environment and supporting snapshot-based breakpoint recovery.

[0087] Step 24, parameter configuration.

[0088] "Parameters" represent the input and output parameters dynamically passed during process execution, serving as the basic carrier for cross-node data sharing and reuse. "Results" are used to aggregate, statistically analyze, or perform derived calculations on the result data based on preset rules after the process instance is completed, supporting multi-dimensional analysis and visualization output. This two-layer model establishes a clear data mapping relationship between the process execution layer and the presentation layer, achieving decoupling between data definition and usage logic, and providing a structured foundation for global data governance.

[0089] This invention constructs a scalable hierarchical management system that supports the classification, registration, and permission binding of parameters and results based on business type, namespace identifier, or tenant identity. Parameters and results can be efficiently reused within the same namespace, while logical isolation is achieved through access control policies across tenant scenarios, ensuring data security and compliance. This hierarchical system supports policy inheritance and dynamic overriding, facilitating flexible adaptation to differentiated business needs within multi-level organizational structures.

[0090] During the process execution phase, the system dynamically parses and maintains the status of parameters and results through a unified context mechanism: the context object is initialized when the process starts and continuously updates parameter values ​​as nodes are executed; after the process terminates, the system automatically triggers result generation according to preset calculation rules, performs aggregation operations, anomaly detection, and result marking, and persistently stores the final result data, while also supporting rule-based dynamic display strategies. Both parameters and results have embedded version identifiers and change logs, and combined with the context snapshot mechanism, the system achieves traceability of the entire process data status and breakpoint recovery capabilities.

[0091] This invention provides an automated workflow orchestration system based on event-driven and context-consistent architecture. Through the organic integration of a unified service entry point, model-based encapsulation, a dynamic workflow engine, and structured data governance, it constructs an end-to-end highly reliable, high-concurrency, and governable process execution system. The system uses OpenAPI as its standardized external interface and implements secure authentication and model routing based on namespace keys. Through a "model-workflow" binding mechanism, complex business logic is encapsulated into publishable, isolable, and authorizable service units. The workflow engine employs directed acyclic graph modeling, combined with an event-driven architecture and message queues, to achieve node-level asynchronous scheduling and high-concurrency execution. A unified context mechanism based on multi-level storage collaboration ensures state consistency and breakpoint recovery capabilities in a distributed environment. A two-layer "parameter-result" data model is introduced to achieve end-to-end structured governance from process input and intermediate transmission to result output, supporting hierarchical isolation, automatic calculation, and dynamic display. The above modules work together to effectively solve the technical bottlenecks in traditional automation systems, such as high service coupling, coarse access control, chaotic data definitions, and unreliable execution. They significantly improve the flexibility, security, consistency, and intelligence of process orchestration in complex business scenarios, and provide a feasible, scalable, and auditable technical foundation for highly compliant fields such as finance, risk control, and operations.

[0092] This invention revolves around two core innovations: an "event-driven distributed workflow execution mechanism" and "unified context dynamic data management," constructing a scalable, traceable, and highly reliable automated orchestration system. Through systematic architecture design and modular implementation, this invention achieves significant technical advancements in performance, stability, and security, specifically reflected in the following aspects:

[0093] (1) It realizes asynchronous execution of the process and high concurrency capability.

[0094] Traditional workflow systems generally rely on synchronous scheduling mechanisms, which are prone to performance bottlenecks in high-concurrency scenarios. This invention introduces a message queue-based event-driven mechanism to achieve complete decoupling between nodes, enabling automatic scheduling of process execution based on event triggers. This mechanism significantly improves the system's concurrent processing capabilities and task throughput, and ensures the stability and reliability of process execution through event accumulating and retry strategies.

[0095] (2) Unified context management and consistency maintenance of process data have been achieved.

[0096] The context management mechanism proposed in this invention maintains an independent data space for each process instance, providing unified management of node inputs and outputs, execution status, and intermediate results. Context data is dynamically updated and persistently stored during execution, ensuring data consistency and traceability across nodes and services. This mechanism effectively avoids common data synchronization delays and state inconsistencies in distributed environments.

[0097] (3) A unified access and security control mechanism for data sources based on hierarchical abstraction and dynamic reuse has been implemented.

[0098] By unifying the modeling of external systems and implementing layered interface management, this invention achieves a "one-time access, multiple reuses" data governance model, significantly reducing system integration costs. Simultaneously, the two-tiered permission model ensures granular and secure data access, supports policy-based authorization and dynamic auditing, and significantly enhances the system's security governance capabilities in multi-source, multi-scenario environments.

[0099] It should be noted that, for the sake of simplicity, the foregoing method embodiments are all described as a series of actions. However, those skilled in the art should understand that the present invention is not limited to the described order of actions, because according to the present invention, some steps can be performed in other orders or simultaneously. Furthermore, those skilled in the art should also understand that the embodiments described in the specification are preferred embodiments, and the actions and modules involved are not necessarily essential to the present invention.

[0100] The present invention also provides a storage medium, which is a computer-readable storage medium storing a computer program thereon, the computer program being executable when it runs. Figure 2The method shown may include some or all of the steps. The storage medium may include read-only memory (ROM), random access memory (RAM), magnetic disk or optical disk, etc. The storage medium may also include non-volatile memory or non-transitory memory, etc.

[0101] 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. The computer program product includes one or more computer instructions or computer programs. When the computer instructions or computer program are loaded or executed on a computer, all or part of the processes or functions described in 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. The computer instructions can be stored in a computer-readable storage medium or transmitted from one computer-readable storage medium to another. For example, the computer instructions can be transmitted from one website, computer, server, or data provider to another website, computer, server, or data provider via wired or wireless means.

[0102] The embodiments of the present invention have been described in detail above. Specific implementation methods have been used to illustrate the present invention. The descriptions of the embodiments above are only for the purpose of helping to understand the method of the present invention, and are merely some, not all, embodiments of the present invention. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort should fall within the scope of protection of the present invention, and the content of this specification should not be construed as a limitation of the present invention. Therefore, any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the scope of protection of the present invention.

Claims

1. An automated orchestration system based on event-driven and context management, characterized in that, The system includes: The model orchestration module receives external requests through OpenAPI, performs model encapsulation based on namespace attributes, and abstracts workflow execution capabilities into configurable model entities. The workflow engine module, connected to the model orchestration module, provides a dynamic orchestration and execution mechanism based on a directed graph structure and performs unified context management; The parameter configuration module, connected to the workflow engine module, constructs a global data constraint and management mechanism for a parameter-result two-layer model, and establishes a data mapping relationship between the execution layer and the presentation layer of the process. The data source management module is connected to the workflow engine module and manages and configures external service capability units that can be called by nodes in the workflow in a unified manner. The workflow engine module formally describes the process structure using a graph model G=(V,E,ζ,τ), where: V={v1,v2,...,v n } represents a set of nodes, where each node v i Has type(v) i )∈{START,PROCESS,DECISION,SPLIT,MERGE,END}; E V×V is a set of edges that represent execution dependencies; ζ:E→Condition is the edge labeling function, which supports defining branch conditions using SpEL expressions; τ:V→Action is the node action mapping function, which defines the node execution logic.

2. The automated orchestration system based on event-driven and context management according to claim 1, characterized in that, The model orchestration module receives external requests through OpenAPI, identifies and loads the workflow associated with the model based on the model identifier corresponding to the request, and each node in the workflow implements business functions by calling the configured data source and passes method parameters during execution.

3. The automated orchestration system based on event-driven and context management according to claim 2, characterized in that, When the model orchestration module abstracts the workflow execution capability into configurable model entities, it binds each model to a namespace to describe the resource combination and orchestration logic under that namespace. The status of a model includes unpublished, pending review, published, and obsolete. The system performs lifecycle management functions such as model creation, review, publication, ordering, and recycling through the model orchestration module.

4. The automated orchestration system based on event-driven and context management according to claim 1, characterized in that, The workflow engine module describes the process logic in the form of a directed acyclic graph, defining node types such as START, END, DECISION, SPLIT, MERGE, and PROCESS to express complex control flows such as sequential, conditional branching, and parallel execution. The execution mechanism includes an event-driven mechanism based on message queues, where the execution result of each node is published to the message bus in the form of an event. The system automatically triggers the execution of subsequent nodes according to the event type and dependencies, thereby achieving asynchronous decoupling and high-concurrency scheduling of tasks.

5. The automated orchestration system based on event-driven and context management according to claim 4, characterized in that, When performing unified context management, the workflow engine module creates an independent context object for each process instance to record node input and output parameters, execution status, and intermediate results. It also achieves efficient access and reliable synchronization of context data through a multi-level storage system consisting of memory caching, Redis distributed caching, and persistent database storage. The context is automatically updated after each node execution to ensure the consistency and traceability of the process status in a distributed environment and supports breakpoint recovery based on snapshots.

6. The automated orchestration system based on event-driven and context management according to claim 1, characterized in that, The parameter configuration module elevates the input and output parameters in the traditional workflow into structured data entities with semantics, reusability, computability, and manageability, and completes the decoupling of data definition and use through the parameter-result two-layer model.

7. The automated orchestration system based on event-driven and context management according to claim 6, characterized in that, The parameters in the parameter-result two-layer model represent the input and output parameters that are dynamically passed during the execution of the process. They serve as the basic carrier for cross-node data sharing and reuse, supporting cross-node data sharing and reuse. The results are used to aggregate, statistically analyze, or perform derivative calculations on the result data based on preset rules after the process instance is executed, supporting multi-dimensional analysis and visualization output.

8. An implementation method based on event-driven and context management, characterized in that, The method includes: Step 1: Receive external requests through OpenAPI, encapsulate the model based on namespace attributes, and abstract the workflow execution capability into a configurable model entity; Step 2: Implement a dynamic orchestration and execution mechanism based on a directed graph structure; Step 3: Perform unified context management; Step 4: Construct a global data constraint and management mechanism for the parameter-result two-layer model, and establish a data mapping relationship between the execution layer and the presentation layer of the process; In step 2, the process structure is formally described using a graphical model G=(V,E,ζ,τ), where: V={v1,v2,...,v n } represents a set of nodes, where each node v i Has type(v) i )∈{START,PROCESS,DECISION,SPLIT,MERGE,END}; E V×V is a set of edges that represent execution dependencies; ζ:E→Condition is the edge labeling function, which supports defining branch conditions using SpEL expressions; τ:V→Action is the node action mapping function, which defines the node execution logic.

9. A computer-readable storage medium having a computer program stored thereon, characterized in that, The computer program is executed by the processor to perform the steps of the implementation method based on event-driven and context management as described in claim 8.

Images