A Dependency Graph-Based Integrated Development and Delivery Collaboration Method and System for Software Factory

By building a full-level dependency model using a dependency graph engine and a unified delivery bus, the problems of toolchain fragmentation and process collaboration gaps in the software development process are solved, realizing automated collaboration and intelligent decision-making in software development and delivery, and improving efficiency and quality.

CN123114520APending Publication Date: 2026-11-17NAT UNIV OF DEFENSE TECH
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
CN202511591585.3
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Filing Date
2025-11-03
Publication Date
2026-11-17

AI Technical Summary

Technical Problem

The existing software development process suffers from fragmented toolchains and broken process collaboration, making it difficult for development and delivery efficiency and quality to match the needs of business growth. It also lacks systematic management and automated identification capabilities for dependencies throughout the entire process, resulting in deviations between development content and requirements, insufficient testing, incorrect deployment order, and difficulties in troubleshooting.

Method used

The software factory integrated development and delivery collaboration method based on dependency graphs achieves automatic identification and collaborative decision-making of cross-stage dependencies through a unified delivery bus and a full-process dependency graph engine. This includes data preprocessing, automatic dependency identification, dependency propagation analysis, collaborative notification push, automated deployment, and fault tracing. It also builds a full-level dependency model and generates standardized collaborative notifications.

Benefits of technology

It has achieved automated collaboration and intelligent decision-making throughout the entire development and delivery process, which has improved development efficiency, reduced manual collaboration costs, lowered delivery risks, shortened fault repair cycles, and ensured the timeliness and stability of software delivery.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN123114520A_ABST
    Figure CN123114520A_ABST
Patent Text Reader

Abstract

This invention discloses a collaborative method and system for integrated development and delivery of a software factory based on dependency graphs. The method includes: acquiring development and delivery data throughout the entire lifecycle of the software factory and preprocessing the data; automatically identifying dependencies in the preprocessed data using a full-process dependency graph engine to construct a full-level dependency model; receiving data change events from each stage via a unified delivery bus; performing dependency propagation analysis on the data change events based on the full-process dependency graph to determine the downstream stages and related objects affected by the events, and generating standardized collaborative notification content; and pushing the standardized collaborative notification content to the corresponding execution role's workbench via the unified delivery bus, while simultaneously updating the dependency status of the full-process dependency graph. This invention enables automated collaboration and intelligent decision-making throughout the entire development and delivery process.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] This invention relates to the field of software technology, and more specifically, to a collaborative method and system for integrated development and delivery of software factories based on dependency graphs. Background Technology

[0002] In scenarios where large-scale R&D and delivery are conducted in software factories, CI / CD (Continuous Integration / Continuous Delivery) has become the core model supporting rapid software iteration. However, its full lifecycle management still faces dual technical bottlenecks: fragmented toolchains and broken process collaboration. This results in development and delivery efficiency and quality failing to meet the demands of business growth. In the current technology system, the entire software development process relies on multiple specialized tools to complete core stages such as requirements management, code development, build testing, deployment and delivery, and operation and maintenance monitoring. For example, the R&D process typically requires using requirements management tools (such as Jira) to sort out business requirements, relying on code repositories (such as GitLab) for version control, using build tools (such as Jenkins) to compile and package code, using test management platforms (such as TestRail) to execute test case verification, using deployment platforms (such as Kubernetes) to complete service release, and finally relying on operation and maintenance monitoring tools (such as Prometheus) to ensure the stability of online operation. However, these tools are mostly independently developed vertical products, lacking unified technical standards and data interaction mechanisms between tools, forming a "tool silo" phenomenon. This prevents efficient data flow between stages, hindering the development process from developing towards integrated collaboration.

[0003] From a process collaboration perspective, existing CI / CD models generally suffer from a fragmented "requirements-development-testing-delivery" chain, with core technical pain points manifesting in three dimensions. First, there is a disconnect between the requirements and development phases. Requirements change information (such as functional scope adjustments and priority updates) in requirements management tools must be manually communicated to the development team. The lack of automated dependency association and synchronization mechanisms makes it difficult for developers to quickly locate the code modules and technical dependencies involved in requirement changes, easily leading to deviations between development content and requirement goals, and potentially introducing compatibility risks due to the failure to promptly detect version updates of dependent components. Second, collaboration between development and testing phases is inefficient. After code submission to the code repository, the build tool must be manually triggered to generate software artifacts, and these artifacts must be manually associated with test cases. The testing team relies on manual notifications to obtain information about the versions to be tested, and cannot automatically identify the test scope to be covered (such as associated modules and interface test cases) based on code changes. This not only lengthens the test preparation cycle but may also lead to potential defects entering the delivery phase due to human error in overlooking key dependency test points. Thirdly, there is a disconnect in the collaboration between testing and delivery. The test results output by the testing platform need to be manually sorted and fed back to the deployment team. During the deployment process, the service deployment order needs to be manually judged to avoid dependency conflicts (such as the startup order of basic middleware and business services). There is a lack of automated deployment orchestration capabilities that can take into account the dependencies of the entire process. It is easy to cause service startup failure due to incorrect deployment order and increase the troubleshooting cost of delivery failures.

[0004] From a technical implementation perspective, existing collaborative R&D process solutions generally lack the ability to systematically manage and automatically identify dependencies across the entire process. In traditional collaborative models, dependencies (such as the relationships between requirements and code modules, version dependencies between code and components, and environmental dependencies between services and basic resources) must be manually identified by developers based on experience. This is not only inefficient but also prone to incomplete or inaccurate dependency identification due to individual differences in understanding. For example, developers need to manually consult documentation to confirm compatible versions of required components during code development; if documentation is not updated in a timely manner, version conflicts may occur. Testers need to manually determine the upstream and downstream modules associated with the function under test when designing test cases; if tests on indirectly dependent modules are omitted, integration testing may be insufficient. Operations personnel need to manually memorize the dependencies between services to determine the deployment order; if the service architecture is complex (e.g., modern microservice clusters often contain dozens of services), orchestration errors are highly likely. Furthermore, when a failure occurs during the delivery process (such as a service response timeout after deployment), due to the lack of end-to-end data tracing capabilities in the traditional model, technical personnel typically need to search across multiple toolchains for scattered information such as requirement documents, code commit records, test reports, and deployment logs, making it difficult to quickly locate the root cause of the failure. This further prolongs the failure repair cycle and affects the timeliness and stability of software delivery.

[0005] Some CI / CD platforms have begun to explore API integration for toolchain data aggregation, but this remains limited to data visualization and lacks a comprehensive dependency model, hindering automatic dependency identification and collaborative decision-making. Existing dependency management tools often only manage dependencies for code components, failing to cover cross-domain dependencies across requirements, testing, and deployment stages, thus hindering end-to-end collaboration. Therefore, overcoming tool silos and building an automated dependency identification mechanism to achieve seamless collaboration across requirements, development, testing, and delivery has become a core technical challenge for integrated CI / CD development and delivery in software factories. Summary of the Invention

[0006] The purpose of this invention is to provide a collaborative method and system for integrated development and delivery of software factories based on dependency graphs, so as to overcome the defects of the existing technology.

[0007] To achieve the above objectives, the technical solution adopted by the present invention is as follows:

[0008] The integrated development and delivery collaborative approach for software factories based on dependency graphs includes the following steps:

[0009] S1. Obtain development and delivery data throughout the entire lifecycle of the software factory, and preprocess the development and delivery data.

[0010] S2. Based on the full-process dependency graph engine, the dependencies of the preprocessed development and delivery data are automatically identified, and a full-level dependency model is constructed.

[0011] S3. Receive data change events from each stage through a unified delivery bus, whereby the data change events cover all stages of the requirements;

[0012] S4. Based on the full-process dependency graph, perform dependency propagation analysis on the data change event to determine the downstream links and related objects affected by the event, and generate standardized collaborative notification content.

[0013] S5. Push standardized collaborative notification content to the corresponding execution role's workbench through the unified delivery bus, and update the dependency status of the entire process dependency graph simultaneously.

[0014] S6. During the delivery and deployment phase, a deployment order without dependency conflicts is generated based on the topology sorting capability of the full-process dependency graph. Deployment instructions are issued to the deployment platform through a unified delivery bus to achieve automated and controllable delivery and deployment.

[0015] S7. During the operation and maintenance phase, receive fault alarm data from monitoring tools, trace the root cause of the fault through the full-process dependency graph, and generate collaborative fault repair tasks.

[0016] The present invention also provides a system for implementing the aforementioned collaborative development and delivery method for software factories based on dependency graphs, comprising:

[0017] The data aggregation module is used to acquire development and delivery data throughout the entire lifecycle of the software factory. This module includes a standardized interface unit, a data preprocessing unit, and a time synchronization unit. The standardized interface unit provides three types of interfaces: REST API, WebHook, and MQ message queue. Through preset interface parameters and adaptation logic, it achieves compatible connections with requirement management tools, code repositories, build tools, test management platforms, deployment platforms, and operation and maintenance monitoring tools. The data preprocessing unit is responsible for performing data cleaning, legality verification, and data anonymization operations. It ensures data integrity, legality, and security through regular expressions, key field rules, and character replacement strategies. The time synchronization unit calibrates the system time of each toolchain through the NTP protocol, controlling the time synchronization error to the millisecond level to ensure the consistency of time-series data.

[0018] The dependency graph construction module is used to build a full-level dependency model. It includes a dependency resolution unit, a graph database storage unit, and an incremental update unit. The dependency resolution unit uses LLM-based natural language processing to parse requirement data, abstract syntax tree parsing to parse code data, cosine similarity algorithm to parse test data, and configuration file parsing to parse deployment data, identifying multi-dimensional dependencies. The graph database storage unit uses a graph database to store node, dependency edge, and attribute information, supporting efficient node traversal and dependency querying. The incremental update unit triggers partial updates based on data change events, updating only the attributes of associated nodes and the state of dependency edges, without requiring a full graph reconstruction.

[0019] The event processing module is used to receive and distribute data change events at each stage. The event processing module includes an event filtering unit, a priority sorting unit, and a routing unit. The event filtering unit filters key events based on an event whitelist and removes invalid events. The priority sorting unit divides the events into priorities according to their impact and urgency, and assigns dedicated processing queues to events of different priorities. The routing unit accurately distributes events to the corresponding business modules based on the mapping relationship between event-related nodes and stages-processing modules.

[0020] The dependency propagation analysis module is used to trace the scope of event impact and generate standardized collaborative notifications. The dependency propagation analysis module includes a tracing algorithm unit, an operation suggestion generation unit, and a notification encapsulation unit. The tracing algorithm unit uses a breadth-first search algorithm to achieve forward / reverse dependency tracing; the operation suggestion generation unit combines the current state of the node and the event type to generate role-based operation guidelines; the notification encapsulation unit encapsulates the notification content according to a standardized template to ensure information integrity and format consistency.

[0021] The collaborative notification push module is used to push collaborative notifications and update dependency status. The collaborative notification push module includes a role mapping unit, a multi-channel push unit, and a receipt confirmation unit. The role mapping unit constructs a mapping relationship between roles, processes, permissions, and push channels based on the RBAC model; the multi-channel push unit adapts to the workbench and instant messaging tools, and pushes notifications according to role format requirements; the receipt confirmation unit implements notification delivery confirmation and retry mechanisms to ensure that notifications are delivered; at the same time, it synchronously pushes the results to the full-process dependency graph and updates the dependency edge status.

[0022] The delivery and deployment coordination module is used to generate the deployment order and issue deployment instructions. This module includes a topology sorting unit, a deployment instruction generation unit, and a status synchronization unit. The topology sorting unit uses the Kahn algorithm to sort the deployment objects topologically, generating a deployment order without dependency conflicts and handling circular dependency alarms. The deployment instruction generation unit encapsulates standardized deployment instructions according to the deployment order, including object identifiers, versions, environments, preconditions, and resource parameters. The status synchronization unit receives real-time deployment status feedback from the deployment platform, synchronously updates the status of corresponding nodes and dependency edges in the full-process dependency graph, and handles deployment failure pauses and alarms.

[0023] The operation and maintenance collaboration closed-loop module is used for fault tracing and repair closed-loop management. The operation and maintenance collaboration closed-loop module includes an alarm receiving unit, a root cause analysis unit, a task generation unit, and a verification unit. The alarm receiving unit receives alarm data pushed by monitoring tools; the root cause analysis unit determines the root cause of the fault and generates a tracing report through reverse dependency tracing and indicator comparison; the task generation unit assigns fault repair tasks according to roles, and clarifies the person in charge, time limit, and acceptance criteria; the verification unit automatically verifies the repair effect, forming a fault discovery-tracing-repair-verification closed loop.

[0024] The data security module is used to ensure the security of data flow and storage. The data security module includes a data desensitization unit and an access control unit. The data desensitization unit performs character replacement processing on sensitive information; the access control unit allocates data access permissions based on the RBAC model to prevent sensitive data leakage.

[0025] The present invention also provides a computer device, including a memory and a processor, wherein the memory stores a computer program, and the processor executes the computer program to implement the integrated development and delivery collaborative method for software factory based on dependency graph as described above.

[0026] Compared with existing technologies, the advantages of this invention are as follows: This invention provides a software factory integrated development and delivery collaboration method and system based on dependency graphs. It addresses the core technical pain points in the software factory lifecycle, such as toolchain data silos, high manual collaboration costs, difficulty in managing delivery risks, and low efficiency in troubleshooting. By constructing a cross-stage dependency automatic identification mechanism, a unified data flow center, and an end-to-end collaborative closed loop, it achieves automated collaboration and intelligent decision-making throughout the entire development and delivery process. Attached Figure Description

[0027] To more clearly illustrate the technical solutions in the embodiments of the present invention 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 the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0028] Figure 1 This is a flowchart of the method of the present invention;

[0029] Figure 2 This is an application scenario diagram of the present invention;

[0030] Figure 3 Build a flowchart for the full-level dependency model of the full-process dependency graph;

[0031] Figure 4 A flowchart illustrating the data flow and collaborative notification push process for a unified delivery bus;

[0032] Figure 5 Flowchart for topology sorting and instruction issuance during the delivery and deployment phase;

[0033] Figure 6 This is a framework diagram of the system of the present invention;

[0034] Figure 7 This is an internal structural diagram of a computer device in one embodiment. Detailed Implementation

[0035] The preferred embodiments of the present invention will now be described in detail with reference to the accompanying drawings, so that the advantages and features of the present invention can be more easily understood by those skilled in the art, thereby providing a clearer and more explicit definition of the scope of protection of the present invention.

[0036] In one embodiment, such as Figure 2As shown, an application scenario for a software factory-integrated development and delivery collaboration method based on dependency graphs is provided. The requirements management tool Jira, the code repository GitLab, the build tool Jenkins, the testing platform TestRail, the deployment platform Kubernetes (K8s), and the operation and maintenance monitoring tool Prometheus are connected to the system through the standardized interface of the unified delivery bus. The entire process relies on the dependency graph engine and the unified delivery bus engine to realize data interaction. Development, testing, and operation engineers receive collaborative notifications and perform corresponding operations through their respective workbenches (such as the GitLab workbench, TestRail workbench, and K8s workbench). For example, Jira synchronizes requirement REQ2024001 (user login function development) to the unified delivery bus. The unified delivery bus forwards the requirement data to the end-to-end dependency graph engine. The engine parses the UserAuth code module associated with the requirement and generates a "requirement-UserAuth" dependency relationship. When the development engineer submits the code of the UserAuth module in GitLab, GitLab pushes the code submission event to the unified delivery bus. The bus forwards it to the dependency graph engine. The engine traces forward to the test cases TC001 and TC002 that depend on UserAuth and generates a collaborative notification that "TC001 and TC002 need to be re-executed". This notification is pushed by the bus to the test engineer's TestRail workbench. After the test engineer executes the test, TestRail synchronizes the test results to the bus. The bus forwards them to the dependency graph engine. The engine updates the "UserAuth-TC001" dependency status to "test passed" and triggers the delivery deployment collaborative module to generate the deployment order (Redis→UserAuth→UserService). The deployment is then distributed to the K8s platform via the bus for execution, ultimately achieving end-to-end collaboration between requirement, development, testing, and delivery.

[0037] See Figures 1-5 As shown, this embodiment discloses a collaborative development and delivery method for software factories based on dependency graphs, including:

[0038] Step S1: Obtain development and delivery data for the entire lifecycle of the software factory, and preprocess the development and delivery data. Specifically:

[0039] First, development and delivery data throughout the entire software factory lifecycle is acquired. This data covers all stages, including requirements management, code development, build and testing, deployment and delivery, and operation and maintenance monitoring. The data originates from requirements management tools, code repositories, build tools, test management platforms, deployment platforms, and operation and maintenance monitoring tools. To achieve seamless integration across multiple toolchains, a standardized interface system is pre-defined for the unified delivery bus. This system includes three types of interfaces: REST API, WebHook, and MQ message queue. The API is suitable for periodic batch data synchronization, meeting the transmission needs of non-real-time data such as test case execution results and requirement progress statistics. It reduces data transmission volume through a pre-defined pagination query and incremental synchronization mechanism. WebHook is suitable for event-driven real-time data push, enabling immediate response to critical events such as code submissions, requirement status changes, and deployment status updates, ensuring information is delivered without delay. The MQ message queue is suitable for data buffering in high-concurrency scenarios, addressing data congestion issues during peak periods such as concentrated code submissions and batch deployments on release days. It avoids data loss through message persistence and retry mechanisms. All three types of interfaces support JSON-LD format data encapsulation. A pre-defined data schema defines the key fields and format specifications for data at each stage. For example, requirement data must include "requirement ID, function description, priority, associated module, and delivery deadline," while code data must include "branch name, committer, modified module, dependent component version, and commit time," ensuring structural consistency of data output from different toolchains and eliminating parsing barriers caused by format differences. For the raw data received, data preprocessing is required. The data cleaning stage uses regular expressions to filter special characters, comments, and invalid spaces in code submission records, removing duplicate requirement change information and test case execution results to ensure data integrity and uniqueness. The legality verification stage, based on the key field rules of each stage's data, marks data with missing key fields or abnormal field formats (such as incorrect date formats or non-standard version numbers) as "to be corrected," and feeds this back to the source toolchain via the unified delivery bus. Simultaneously, a unique checksum is generated for each batch of data using the SHA-256 algorithm, and compared with the checksum sent by the source toolchain to verify whether tampering occurred during data transmission. The data anonymization stage uses a character replacement strategy to replace sensitive fields such as code repository access tokens, deployment platform keys, and customer mobile phone numbers and email addresses in the requirement data with masked characters (e.g., tokens are replaced with "***"), ensuring the security of the data flow. In addition, to ensure consistency of time-series data throughout the entire process, the unified delivery bus has a built-in time synchronization module that uses the NTP protocol to calibrate the system time of each toolchain to the UTC+8 time zone. The time synchronization error is controlled within the millisecond level, ensuring that time-series data such as requirement change time, code submission time, test execution time, and deployment completion time can be accurately correlated, laying the foundation for subsequent time-dimensional analysis of dependencies and process progress tracking.

[0040] In one embodiment, the process of acquiring development and delivery data throughout the software factory's lifecycle is as follows: The standardized interface unit of the unified delivery bus pre-configures the access parameters for each toolchain. For example, the Jira WebHook address is set to " / api / jira / webhook" of the unified delivery bus, the GitLab MQ message queue topic is set to "gitlab-code-commit", and the K8s API token is stored through the key management module. When the requirement status in Jira changes to "pending development," the WebHook is automatically triggered, displaying the requirement ID (REQ2024001), function description ("Implement user mobile phone number login, associate UserAuth..."), and other relevant information. Data such as the "h module" and priority (high) are pushed to the unified delivery bus in JSON format; in GitLab, when a developer submits code (branch: feature / REQ2024001-UserAuth, submitter: Dev001, modified file: UserAuth.java, dependent component: Redis==6.2.0), GitLab pushes the above code submission record to the unified delivery bus via MQ message queue; in TestRail, when a test engineer creates test case TC001 (test case description: "Verify mobile number login interface returns 200", associated module: UserAuth), TestRail pushes the code submission record to the unified delivery bus via REST. The API (GET / api / testrail / cases) periodically (every 5 minutes) synchronizes test case data to the unified delivery bus; when deploying the UserService service in Kubernetes, the deployment manifest (service name: UserService, version: V1.0, dependent middleware: Redis, target environment: production environment) is pushed to the unified delivery bus via WebHook; when Prometheus detects a UserService response timeout (response time > 500ms), it pushes the alarm data (service name: UserService, alarm level: critical, occurrence time: 2024-05-20 15:00) to the unified delivery bus via WebHook, achieving real-time and complete aggregation of data across all stages.

[0041] Step S2: Based on the full-process dependency graph engine, automatically identify dependencies in the preprocessed development and delivery data, and construct a full-level dependency model. Specifically:

[0042] Based on the full-process dependency graph engine, the dependency relationship of the preprocessed development and delivery data is automatically identified, and a full-level dependency model of "requirements-code modules-components-test cases-deployment services-basic resources" is constructed to realize the systematic analysis and modeling of cross-stage and multi-dimensional dependency relationships. (1) For the requirement data, the entire process relies on the graph engine to use an LLM-based natural language processing model to perform semantic parsing of the requirement description. The pre-trained industry word vector library is used to identify the business entities involved in the requirement (such as “user payment function development” corresponding to “Payment business module”) and technical constraints (such as “requires compatibility with Redis 7.0 cache” corresponding to “Redis component”, “requires support for MySQL 8.0 database” corresponding to “MySQL basic resources”). Then, combined with the preset “requirement-module-resource” association rule library (such as “if the business entity contains ‘payment’, it is associated with the Payment code module”, “if the technical constraint contains ‘Redis’, it is associated with the Redis component”, “if the technical constraint contains ‘MySQL’, it is associated with the MySQL basic resources”), the “association dependency” between the requirement node and the code module node, component node, and basic resource node is established, and the effective scenario of the dependency is marked (such as “only production environment needs to depend on MySQL 8.0”). (2) For code data, the engine parses the code file through an abstract syntax tree (AST), traverses the syntax tree nodes to extract the function call relationship between code modules (such as the OrderService module calling the "createPayment" interface of the Payment module), forming "call dependencies" between code modules. At the same time, it parses package management files (such as pom.xml of Java projects, requirements.txt of Python projects, and go.mod of Go projects), extracts component dependency information (such as the Payment module depending on the FastJSON 2.0 component and the Gson 2.10 component), establishes "version dependencies" between code module nodes and component nodes, and records the compatible version range of components (such as "FastJSON requires ≥2.0 and <2.5"). (3) For test data, the engine uses the cosine similarity algorithm to calculate the semantic correlation between test cases and code modules based on the description text and associated tags of test cases (such as test case name "verify the availability of the createPayment interface of the Payment module", tag "associated module: Payment" "test type: interface test"). When the correlation is higher than the preset threshold, it is determined to be a valid correlation, and the "coverage dependency" between code module nodes and test case nodes is established, and the coverage of test cases is marked (such as "covering the payment interface and exception handling logic of the Payment module").(4) For deployment data, the engine parses the resource dependency configuration in the deployment configuration file (such as Kubernetes yaml file, Docker Compose file, Jenkins deployment script), extracts the middleware (such as OrderService depends on RabbitMQ 3.12), database (such as OrderService depends on MySQL 8.0) and upstream services (such as OrderService depends on UserService user information query interface), establishes the "environment dependency" between deployment service node and component node, basic resource node, and deployment service node, and records the startup order requirements of the dependency (such as "RabbitMQ must be started first, then UserService, and finally OrderService"). The full-level dependency model is stored in a graph database. The node types include requirement nodes, code module nodes, component nodes, test case nodes, deployment service nodes, and basic resource nodes. Each node contains a unique identifier and attribute information (e.g., requirement node attributes include priority, status, and delivery deadline; component node attributes include version, vendor, and download address; deployment service node attributes include deployment environment and resource quota). The dependency edges between nodes include dependency type (e.g., "related dependency", "call dependency", "version dependency", "coverage dependency", "environment dependency"), dependency status (e.g., "pending satisfaction", "satisfied", "abnormal"), and dependency strength (e.g., "strong dependency: the process will be interrupted if this dependency is not present; weak dependency: partial execution is still possible even if this dependency is not present"). To ensure the real-time performance of the dependency model, the engine is designed with an incremental update mechanism. When the unified delivery bus receives a new data change event, it only updates the node attributes and dependency edge status directly associated with the event (e.g., when a code module submits a new version, it updates the version attribute, submission time attribute, and status of the associated "version dependency" edge of the code module node; when the requirement status changes, it updates the status attribute of the requirement node and the status of the associated "related dependency" edge). There is no need to rebuild the entire graph, which reduces system resource consumption while ensuring that the dependency relationship is synchronized with the actual business.

[0043] In one embodiment, the process of building a full-level dependency model based on the full-process dependency graph engine is as follows: In the dependency resolution rule base of the full-process dependency graph engine, the requirement-module association rule is set to "if the requirement description contains 'login' and contains 'UserAuth', then associate it with the code module UserAuth", the code dependency resolution rule is set to "parse the AND of the tags in the pom.xml file and extract component dependencies", the test case-module association rule is set to "if the test case association tag contains 'UserAuth', then associate it with the code module UserAuth", and the deployment dependency resolution rule is set to "parse the spec.template.spec.conta in the K8s deployment manifest". The `REDIS_HOST` variable under `insers.env` is used to determine the dependency on Redis. For the Jira synchronization requirement `REQ2024001`, the Natural Language Processing Unit of the graph engine parses the requirement description "Implement user mobile phone number login, associated with the UserAuth module", matches the requirement-module association rules, determines the associated code module `UserAuth`, creates a requirement node (ID: `REQ2024001`, type: requirement, attribute: high priority) and a code module node (ID: `Mod001`, type: code module, name: `UserAuth`) in the graph database, and creates an "association dependency" edge (state) from `REQ2024001` to `Mod001`. (Under development); For GitLab synchronized code commit records, the engine's AST parsing unit parses the UserAuth.java file, extracts the dependent component Redis (version 6.2.0) from the pom.xml file, creates a component node (ID: Comp001, type: component, name: Redis, version: 6.2.0), and creates a "version dependency" edge from Mod001 to Comp001 (status: confirmed); For TestRail synchronized TC001, the engine matches the test case-module association rules based on the test case association tag "UserAuth" and creates a test case node (ID: TC001, type: test case, status: pending execution). The engine creates a "coverage dependency" edge from Mod001 to TC001 (status: pending testing); for the UserService deployment manifest synchronized with K8s, the engine parses out the dependency on Redis, creates a deployment service node (ID: Ser001, type: deployment service, name: UserService, version: V1.0) and a basic resource node (ID: Res001, type: basic resource, name: Redis, version: 6.2.0), and creates an "environment dependency" edge from Ser001 to Res001 (status: pending deployment); finally, a full-level dependency model containing 6 nodes and 4 dependency edges is formed in the graph database, supporting subsequent dependency analysis and collaborative decision-making.

[0044] Step S3: Receive data change events from each stage via the unified delivery bus. These data change events cover all aspects of the requirements, specifically:

[0045] Data change events at each stage are received through a unified delivery bus. These events cover the following: Requirements stage: "Requirement status change (under development → under development, under development → under testing, under testing → completed)" and "Requirement content modification (functional scope adjustment, priority update, delivery deadline change)"; Development stage: "Code commit (branch creation, code storage, code push)"; Code merging (branch merge to development branch, merge to main branch, merge conflict) and "Build result feedback (build successful, build failed, build interrupted)"; Testing stage: "Test case execution result update (passed, failed, blocked)". Skip to "Test report generation (interface test report, performance test report, security test report)", "Test defect submission (defect creation, defect repair, defect closure)", "Deployment request initiation (pending deployment → in deployment)", "Deployment status change (deployment successful, deployment failed, deployment rollback)", "Deployment resource adjustment (CPU quota change, memory limit adjustment)", "Monitoring alarm triggering (response timeout, error rate exceeding standard, resource utilization too high)", "Alarm recovery (indicators return to normal, fault resolution)", "Operation log reporting (service restart log, configuration change log)". The unified delivery bus has a built-in event handling module. This module first performs event filtering, selecting critical events based on a preset event whitelist. Events that directly affect the collaborative process (such as "code merged into main branch", "requirement status changed to pending test", "test case execution failed", "deployment failed", "monitoring alarm triggered") are retained, while non-critical events with no collaborative value (such as "code temporarily saved", "requirement draft saved", "test case editing") are filtered out, reducing the consumption of system resources by invalid events. Next, events are prioritized according to their impact on the delivery process and their urgency. Fault alarm events (such as "production environment service response timeout") have the highest priority, followed by requirement change events (such as "requirement priority increased to urgent"), and ordinary code submission events and test case execution pass events have the lowest priority. High-priority events enter a dedicated processing queue. A scheduling strategy combining "first-come, first-served" and "priority preemption" is adopted to ensure that critical events are responded to first, avoiding the blockage of emergency events by ordinary events. Finally, event routing is executed. Based on the node identifier associated with the event (such as the code module node ID associated with the code commit event, and the requirement node ID associated with the requirement change event), the entire process dependency graph is queried to determine the stage to which the event belongs (such as the development stage, testing stage, and delivery stage). Then, according to the "stage-processing module" mapping relationship (such as the development stage event being distributed to the dependency propagation analysis module, the testing stage event being distributed to the collaborative notification push module, the delivery stage event being distributed to the delivery deployment collaboration module, and the operation and maintenance stage event being distributed to the operation and maintenance collaboration closed-loop module), the event is accurately distributed to the corresponding business module. At the same time, the event routing log (including event ID, routing time, target module, and routing result) is recorded to facilitate subsequent traceability and problem investigation.

[0046] Step S4: Based on the full-process dependency graph, perform dependency propagation analysis on the data change event to determine the downstream links and related objects affected by the event, and generate standardized collaborative notification content, specifically:

[0047] Next, based on the full-process dependency graph, dependency propagation analysis is performed on the data change event to determine the downstream links and related objects affected by the event, generate standardized collaborative notification content, and realize accurate traceability of dependency relationships and standardized generation of collaborative instructions. When the dependency propagation analysis module receives a data change event, it first extracts the core nodes associated with the event (e.g., "Requirement REQ-2024-005 status changed to pending development" is associated with the requirement node REQ-2024-005, and "Code module MOD-Payment submitted a new version" is associated with the code module node MOD-Payment). Then, it selects the dependency tracing direction according to the stage to which the event belongs—events in the requirement and development stages use forward dependency tracing, that is, starting from the core node, querying the downstream nodes that directly or indirectly depend on the node layer by layer (e.g., the downstream node of the requirement node is the associated code module node, and the downstream node of the code module node is the associated component node, test case node, and deployment service node) to determine the scope of the event's impact on subsequent processes; events in the testing, delivery, and operation and maintenance stages use reverse dependency tracing, that is, starting from the core node, querying the upstream nodes that directly or indirectly depend on the node layer by layer (e.g., the upstream node of the test case node is the associated code module node, and the upstream node of the deployment service node is the associated component node, basic resource node, and other deployment service nodes) to determine the root cause of the event's impact. The tracing process employs a graph-based breadth-first search (BFS) algorithm. Starting from the core node, it traverses layer by layer in the order of "node → dependency edge → downstream / upstream node," recording the node type, node identifier, dependency type, and current state of each traversed node. For example, when tracing forward the requirement node REQ-2024-005 (status: pending development, associated module: MOD-Payment), it first traverses to the associated code module node MOD-Payment (status: pending development), and then traverses from MOD-Payment to the associated component node COMP-FastJSON (status: deployed to the development environment). The event involved several nodes: MOD-Payment, COMP-Gson (status: pending deployment), test case node TC-Payment-001 (status: pending design), and deployment service node SER-Payment (status: pending development). The downstream impact of the event was determined to be the development phase (MOD-Payment development needs to be completed), the testing phase (TC-Payment-001 needs to be designed and executed), and the delivery phase (SER-Payment needs to be deployed). The associated objects included MOD-Payment, COMP-Gson, TC-Payment-001, and SER-Payment.After tracing back, the module generates operation suggestions based on the current status and event type of the associated nodes. For example, if the current status of the code module node MOD-Payment is "Under Development" and the associated component COMP-Gson is not deployed, the operation suggestion is: "The development team needs to complete the development of the MOD-Payment module based on requirement REQ-2024-005. Before development, coordinate with the operations team to deploy COMP-Gson to the development environment. After development, submit the code and trigger the build. After the build is successful, notify the testing team to design the TC-Payment-001 test case." If the test case node TC-Payment-001 fails to execute (status: failed), trace back to the associated code module node MOD-Payment (status: built). The operation suggestion is: "The testing team needs to synchronize the failure details of TC-Payment-001 to the development team. The development team should check the MOD-Payment code logic, fix it, and resubmit the build. After the build is successful, the testing team should re-execute TC-Payment-001." The collaborative notification content uses a standardized template for encapsulation, including event identifiers (e.g., event ID: EVT-2024-1234), event sources (e.g., "requirement management tool Jira", "code repository GitLab", "testing platform TestRail"), event types (e.g., "requirement status change", "code submission", "test case execution failure"), a list of affected stages (e.g., "development stage, testing stage, delivery stage"), a list of associated objects (including object identifiers, object types, and current object status), operational suggestions (clearly defining the actions and time requirements for each role), and response time limits (e.g., a development response time limit of 3 working days for requirement change events and a development repair time limit of 1 working day for test failure events). This ensures that notification recipients (development engineers, test engineers, operations engineers, etc.) can quickly obtain key collaborative information without secondary interpretation or communication confirmation.

[0048] In one embodiment, the process of dependency propagation analysis and collaborative notification push is as follows: The event receiving module of the unified delivery bus receives a code commit event pushed by GitLab (commit ID: Commit001, associated code module: UserAuth, version: V1.2) and forwards the event data to the dependency propagation analysis module; the dependency propagation analysis module calls the forward dependency tracing unit of the full-process dependency graph engine, inputs the code module node ID: Mod001, and traces down to the downstream nodes that directly depend on Mod001: test case TC001 (ID: TC001) and deployment service UserService (ID: Ser001); queries the current status of the downstream nodes: TC001 status is "passed", and UserService status is "deployed"; based on the event type "code commit (version update)", it generates operation suggestions: "code module UserAuth" V1.2 has been submitted. Test case TC001 needs to be re-executed, and the dependency version of the deployment service UserService needs to be updated to V1.2. The event identifier (Commit001), affected stages (testing stage, delivery stage), associated object identifiers (TC001, Ser001), and operation suggestions should be integrated into a collaborative notification in JSON format. The collaborative notification push module calls the notification distribution unit of the unified delivery bus engine to query the role-stage mapping table. The testing stage corresponds to the test engineer (Test001), and the delivery stage corresponds to the operations engineer (Ops001). The workbench addresses of both individuals are obtained (TestRail interface: / api / testrail / notify, WeChat Work interface: / api / w (echat / notify); The notification distribution unit pushes the collaborative notification content to TestRail workbench of Test001 (displaying "TC001 needs to be re-executed") and WeChat of Ops001 (displaying "UserService dependency version needs to be updated"); After the push is successful, the status synchronization unit sends the feedback information to the full-process dependency graph engine. The engine updates the status of the "Mod001-TC001" dependency edge to "Pending retesting" and the status of the "Mod001-Ser001" dependency edge to "Pending version update", and records the change log (change time: 2024-05-20 15:30, operator: system, status before change: passed / deployed, status after change: pending retesting / pending version update).

[0049] Step S5: Push standardized collaborative notification content to the corresponding execution role's workbench via the unified delivery bus, and synchronously update the dependency status of the entire process dependency graph. Specifically,

[0050] Then, the collaborative notification content is pushed to the corresponding execution role's workbench through the unified delivery bus, and the dependency status of the entire process dependency graph is updated synchronously. This process needs to achieve accurate notification delivery and real-time synchronization of dependency status. The unified delivery bus has a built-in role collaboration module. Based on the RBAC (Role-Based Access Control) model, it constructs a "role-process-permission-push channel" mapping system, assigning each execution role a dedicated responsible process, data access permissions, and push channels: For example, a development engineer is responsible for the development process, with permissions including viewing code module dependencies, component dependency status, and receiving notifications related to code submissions and requirement changes, and push channels including GitLab Workbench (for receiving detailed notifications) and WeChat Work (for receiving SMS reminders); a test engineer is responsible for the testing process, with permissions including viewing test case dependencies, code module build status, and receiving test case execution results and code build-related notifications, and push channels including TestRail Workbench and WeChat Work; an operations engineer is responsible for the delivery and operations processes, with permissions including viewing deployment service dependencies, basic resource status, and receiving deployment requests and monitoring alarm notifications, and push channels including K8s Workbench and WeChat Work; and a requirements analyst is responsible for the requirements process, with permissions including viewing the status of code modules associated with requirements, and receiving notifications related to requirement changes and delivery progress, and push channels including Jira Workbench and WeChat Work. The push notification process first uses the impact mapping system in the collaborative notification to determine the corresponding execution role (e.g., if it affects the development stage, it corresponds to the development engineer; if it affects the testing stage, it corresponds to the test engineer). Then, the notification content is packaged according to the preset push format requirements of the role. Push notifications from the workbench use Markdown format, including title, event details, a list of related objects, operation suggestions, and response time limit, and support hyperlinks to the corresponding toolchain page (e.g., clicking the requirement ID jumps to the Jira requirement details page, clicking the code module ID jumps to the GitLab code repository). Push notifications from instant messaging tools use text format, extracting the core information of the notification (e.g., "[Requirement Change Notification] Requirement REQ-2024-005 has been changed to pending development, requiring the development of the MOD-Payment module, with a response time limit of 3 working days. See GitLab workbench for details"), ensuring that the information is concise and clear. After the notification is pushed, the unified delivery bus confirms the delivery status through the receipt mechanism. If the workbench does not return a "received" receipt within the preset time limit (e.g., 10 minutes), or the instant messaging tool does not return a "read" status, a retry is triggered. The retry interval increases exponentially (e.g., 5 minutes for the first retry, 10 minutes for the second, and 30 minutes for the third), with a maximum of 3 retries. If the notification is still not delivered after 3 retries, "push failed" is recorded and the system administrator is notified to intervene (e.g., check the role push channel configuration and tool connection port connectivity).Meanwhile, the entire process relies on the graph engine to receive collaborative notification push results and update the status of the corresponding dependency edges. For example, the "association dependency" edge between the requirement node REQ-2024-005 and the code module node MOD-Payment is in the state of "pending notification" before the notification is pushed to the development engineer. After the push is successful, the status is updated to "notified". After the development engineer confirms receipt on the workbench, the status is further updated to "pending processing". After the development is completed, the status is updated to "satisfied". This ensures that the dependency status matches the collaborative progress in real time, making it easier for managers to track the collaborative status of the entire process.

[0051] Step S6: In the delivery and deployment phase, based on the topology sorting capability of the full-process dependency graph, a deployment order without dependency conflicts is generated. Deployment instructions are then sent to the deployment platform via a unified delivery bus, achieving automated and controllable delivery and deployment. Specifically:

[0052] During the delivery and deployment phase, a topology sorting capability based on the end-to-end dependency graph generates a deployment order free of dependency conflicts. Deployment instructions are then sent to the deployment platform via a unified delivery bus, achieving automated and controllable delivery and deployment. When the deployment platform (such as Kubernetes or Jenkins) initiates a deployment request (containing a list of objects to be deployed, such as SER-Payment, SER-OrderService, COMP-Redis, and RES-MySQL), the unified delivery bus forwards the list of objects to be deployed to the topology sorting unit of the end-to-end dependency graph engine. This unit first queries the dependency edges between objects to be deployed, constructs a local dependency subgraph, and clarifies the dependency relationships between each object (e.g., SER-OrderService depends on the payment interface provided by SER-Payment, SER-Payment depends on COMP-Redis for caching payment data and RES-MySQL for storing payment records, COMP-Redis and RES-MySQL have no mutual dependency); then, the Kahn algorithm is used to perform topological sorting on the local dependency subgraph. The specific steps are: first, calculate the in-degree of each node (in-degree refers to the number of upstream nodes that depend on that node, such as RES-MySQL having an in-degree of 0, COMP-Redis having an in-degree of 0, and SER-Payment having an in-degree of 2). If the in-degree of SER-OrderService is 1, add nodes with an in-degree of 0 (RES-MySQL, COMP-Redis) to the sorting queue. Remove a node from the queue and add it to the deployment order list. Simultaneously, remove all outgoing edges associated with that node (i.e., the nodes' dependencies on downstream nodes), and update the in-degree of the downstream nodes (after removing the outgoing edges from RES-MySQL and COMP-Redis, the in-degree of SER-Payment changes from 2 to 0). Repeat these steps until the queue is empty and all nodes are added to the deployment order list, ultimately generating the deployment order: RES-MySQL → COMP-Redis → SER-Payment → SER-OrderService. If a circular dependency is detected during the sorting process (e.g., SER-Payment depends on SER-OrderService's user order information interface, and SER-OrderService depends on SER-Payment's payment interface, forming a "SER-Payment..." loop), the following steps will be taken. If a circular dependency occurs (e.g., "SER-OrderService" → "SER-Payment" → "SER-OrderService" → "SER-Payment"), the involved nodes, and the dependency type are identified in the alarm message. This alarm is then pushed to the operations engineer's workbench. After the operations and development teams collaboratively adjust the dependencies (e.g., splitting the interfaces in the circular dependency into independent modules), the topology sorting is restarted. Once the sorting is complete, the unified delivery bus generates standardized deployment instructions according to the deployment order. Each instruction includes the identifier of the object to be deployed (e.g., RES-MySQL, SER-Payment) and the deployment version (e.g., MySQL 8.0.36, SER-Payment). Version 1.0.0), target environment (e.g., development, testing, production), preconditions (e.g., "Preconditions for deploying SER-Payment: RES-MySQL has been successfully deployed and is connectable, COMP-Redis has been successfully deployed and the caching service is normal"), resource configuration parameters (e.g., CPU quota, memory limit, disk capacity, network port, environment variables), startup commands (e.g., "MySQL startup command: mysqld --defaults-file= / etc / my.cnf, SER-Payment startup command: java -jar / opt / ser-payment.jar --spring.profiles.active=prod"); deployed through interfaces supported by the platform (e.g., Kubernetes API, Jenkins). The API issues instructions sequentially, ensuring that the previous step is completed and the status is "successful" before issuing the next instruction. During deployment, the unified delivery bus receives deployment status (deploying, successful, failed, paused) returned by the deployment platform in real time and synchronizes it to the full-process dependency graph, updating the status of corresponding nodes and dependent edges: for example, after RES-MySQL is successfully deployed, the node status changes from "pending deployment" to "deployed", and the status of its "environment dependency" edge with SER-Payment changes from "to be satisfied" to "satisfied". If a deployment step fails (e.g., COMP-Redis fails due to a configuration file error), the unified delivery bus immediately pauses the issuance of subsequent instructions, generates a deployment failure notification (including the failure object, failure time, error code, and failure reason) and pushes it to the operations team. At the same time, it records the failure log to the system database to provide a basis for troubleshooting. After the operations team fixes the problem (e.g., corrects the configuration file), the deployment can be re-initiated from the failed step.

[0053] In one embodiment, the delivery and deployment collaboration process is as follows: An operations engineer initiates an update and deployment request for the UserService service through the Kubernetes workbench, including a list of services to be deployed: Redis (Res001), UserAuth (Ser002), and UserService (Ser001). The delivery and deployment collaboration module of the unified delivery bus receives the request and sends the list of services to be deployed to the topology sorting unit of the end-to-end dependency graph engine. The topology sorting unit queries the dependencies of each service: Ser001 depends on Ser002, Ser002 depends on Res001, and there are no circular dependencies. The Kahn algorithm is used to perform topological sorting of the dependencies, generating the deployment order: Res001 → Ser002 → Ser001. The topology sorting unit returns the deployment order to the delivery and deployment collaboration module, which generates deployment instructions in sequence: Step 1: "Deploy Redis 6.2.0 to the production environment, no preconditions," Step 2: "Deploy UserAuth V1.2 to the production environment, precondition: Redis deployment successful," Step 3: "Deploy UserService..." To deploy V1.2 to the production environment, prerequisites include: UserAuth deployment successfully; the standardized interface units of the unified delivery bus engine are implemented via K8s. The API ( / api / v1 / namespaces / default / pods) issues deployment instructions sequentially. The first step deploys Redis; Kubernetes returns a "deployment successful" status, and the delivery and deployment coordination module synchronizes the status to the dependency graph engine, which updates the "Ser002-Res001" dependency edge status to "deployed." The second step deploys UserAuth; Kubernetes returns a "deployment successful" status, and the engine updates the "Ser001-Ser002" dependency edge status to "deployed." The third step deploys UserService; Kubernetes returns a "deployment successful" status, and the engine updates the "Ser001" node status to "deployed." If the second step, deploying UserAuth, fails (e.g., due to an image pull error), Kubernetes returns a "deployment failed" status. The delivery and deployment coordination module immediately pauses issuing instructions for the third step, generates a notification stating "UserAuth deployment failed, image address needs to be checked," and pushes it to Ops001's WeChat account via the unified delivery bus. Simultaneously, the engine marks the "Ser002" node status as "deployment failed" to facilitate troubleshooting by operations engineers. Step S7: During the operation and maintenance phase, receive fault alarm data from monitoring tools, trace the root cause of the fault through the full-process dependency graph, and generate a fault repair collaborative task. Specifically:

[0054] During the operation and maintenance phase, fault alarm data from monitoring tools is received. The root cause of the fault is traced back through a full-process dependency graph, generating collaborative fault repair tasks and forming a collaborative closed loop of "fault discovery-source tracing-repair-verification". When operation and maintenance monitoring tools (such as Prometheus, ELK Stack, and Zabbix) detect a fault (such as SER-OrderService response timeout, excessive error rate, or excessive CPU utilization of the RES-Server server), they push alarm data (including alarm object identifier, alarm type, abnormal indicator value, normal threshold, occurrence time, and alarm level) to the unified delivery bus via WebHook. The bus forwards the alarm data to the operation and maintenance collaborative closed-loop module. The module first extracts the node corresponding to the alarm object (e.g., SER-OrderService response timeout corresponds to the deployment service node SER-OrderService, excessive CPU utilization corresponds to the basic resource node). Starting from the RES-Server node, the reverse dependency tracing function of the full-process dependency graph is invoked. Using this node as the starting point, a breadth-first search algorithm is used to trace the upstream nodes that are directly or indirectly dependent on it layer by layer. At the same time, the interface of the monitoring tool is invoked through the unified delivery bus to obtain the real-time monitoring indicators of each upstream node (such as the interface response time and error rate of the upstream node SER-Payment of SER-OrderService, the number of connections and cache hit rate of the upstream node COMP-Redis of SER-Payment, and the CPU utilization and memory utilization of the upstream node RES-Server of COMP-Redis). The operation and maintenance collaboration closed-loop module compares the real-time indicators of each node with preset normal thresholds to identify abnormal nodes. For example, if the CPU utilization of RES-Server reaches 92% (normal threshold <80%), the number of connections of COMP-Redis reaches 1100 (normal threshold <1000), the interface response time of SER-Payment reaches 500ms (normal threshold <100ms), and the response time of SER-OrderService reaches 650ms (normal threshold <200ms), then RES-Server, COMP-Redis, and SER-Payment are determined to be abnormal nodes. By analyzing the anomaly propagation path through dependency links (RES-Server high CPU utilization → COMP-Redis insufficient resources leading to connection limit exceedance → SER-Payment interface response delay → SER-OrderService response timeout), combined with the time sequence of occurrence of the anomalies of each node (RES-Server high CPU utilization occurs first, followed by COMP-Redis connection limit exceedance, SER-Payment response delay, and SER-OrderService timeout), the root cause of the fault is determined to be "RES-Server insufficient CPU resources".Based on the root cause of the fault, the module generates a fault tracing report, which includes basic fault information (alarm object, alarm time, alarm level), a fault chain diagram (visually displaying abnormal nodes and dependencies), a list of abnormal nodes (including node identifier, abnormal indicators, abnormal values, and normal thresholds), and the basis for root cause determination (e.g., "the highest CPU usage in RES-Server occurred earliest, and all other node anomalies were caused by it"). Simultaneously, it generates collaborative fault repair tasks, assigned by role: for example, "Operations Engineer task: Expand the CPU resources of RES-Server from the current 8 cores to 16 cores, ensuring that the CPU utilization rate is consistently below 80% after the expansion, with a completion time of 1 hour; Development Engineer task: Optimize the connection pool configuration of COMP-Redis, limiting the maximum number of connections to 1000 to avoid exceeding the limit, with a completion time of 2 hours." The task clearly defines the responsible person, completion time, and acceptance criteria (e.g., the acceptance criterion after CPU expansion is "CPU utilization <80% for 10 consecutive minutes," and the acceptance criterion after connection pool optimization is "Redis connection count <1000 and no connection rejection errors"). Collaborative tasks are pushed to the corresponding role's workbench via a unified delivery bus. The module tracks the task status in real time (pending → processing → completed → under acceptance → acceptance passed / acceptance failed). After the task leader completes the operation, they submit an acceptance application on the workbench. The module calls the monitoring tool interface to obtain relevant indicators for automatic acceptance: if the indicators meet the acceptance criteria (e.g., RES-Server CPU utilization drops to 65%, Redis connection count drops to 800), the acceptance is deemed passed, the status of the corresponding node in the full-process dependency graph is updated to "normal", and a fault repair closed-loop report (including fault handling process, repair measures, and acceptance results) is generated; if the indicators do not meet the acceptance criteria (e.g., CPU utilization still reaches 85% after CPU expansion), the acceptance is deemed failed, the task leader is notified to re-investigate the problem (e.g., check if there are other processes consuming CPU), and resubmit the acceptance application until the acceptance is passed, ensuring that the fault is completely resolved.

[0055] In one embodiment, the operation and maintenance collaboration closed-loop process is as follows: Prometheus detects a timeout in the UserService (Ser001) response (response time 600ms) and pushes the alarm data (Service ID: Ser001, alarm type: response timeout, metric value: 600ms, normal threshold: <100ms) to the operation and maintenance collaboration closed-loop module of the unified delivery bus via WebHook; the operation and maintenance collaboration closed-loop module forwards the alarm data to the dependency tracing unit of the full-process dependency graph engine, and the unit queries the upstream nodes of the reverse dependency based on Ser001: UserAuth (Ser002), Redis (Res001), and server CPU (Res002); the engine calls the monitoring data interface to obtain the real-time status of each upstream node: Ser002 interface response time 450ms (normal threshold <100ms), Res001 connection count 1200 (normal threshold <1000), Res002... CPU utilization is 95% (normal threshold <80%); based on the traceability unit analysis, the abnormal link is: Res002 CPU too high → Res001 connection limit exceeded → Ser002 response delay → Ser001 timeout, determining the root cause of the fault as "server Res002 CPU utilization too high"; a fault tracing report is generated, including the fault link (Res002→Res001→Ser002→Ser001), abnormal nodes (Res002, Res001, Ser002), and abnormal indicators (CPU 95%, connection count 1200, response time 450ms); based on the report, a fault repair collaborative task is generated: "Operation and Maintenance Task: Expand Res002". The CPU is upgraded to 16 cores, with Ops001 as the person in charge and a completion deadline of 1 hour. The development task is to optimize the Res001 connection pool configuration, limiting the maximum number of connections to 1000, with Dev001 as the person in charge and a completion deadline of 2 hours. The operation and maintenance collaboration closed-loop module pushes the task to the workbench of Ops001 and Dev001 via a unified delivery bus, tracking the task status in real time: After Ops001 completes the CPU upgrade, it marks the task as "completed," and the CPU utilization of Res002 drops to 60%; After Dev001 optimizes the connection pool configuration, it marks the task as "completed," and the number of connections in Res001 drops to 800. The operation and maintenance collaboration closed-loop module triggers the verification process, calls the Prometheus interface to query the Ser001 response time, returns "80ms" (returned to normal), and synchronizes the verification result to the dependency graph engine. The engine updates the status of the Ser001, Ser002, Res001, and Res002 nodes to "normal," completing the operation and maintenance collaboration closed loop.

[0056] It should be understood that, although Figure 1The steps in the flowchart are shown sequentially as indicated by the arrows, but these steps are not necessarily executed in the order indicated by the arrows. Unless otherwise specified herein, there is no strict order in which these steps are executed, and they can be performed in other orders. Figure 1 At least some of the steps in the process may include multiple sub-steps or multiple stages. These sub-steps or stages are not necessarily completed at the same time, but can be executed at different times. The execution order of these sub-steps or stages is not necessarily sequential, but can be executed in turn or alternately with other steps or at least some of the sub-steps or stages of other steps.

[0057] See Figure 6 As shown, the present invention also provides a system for implementing the aforementioned collaborative development and delivery method for software factories based on dependency graphs, comprising:

[0058] Data aggregation module 1 is used to acquire development and delivery data throughout the entire lifecycle of the software factory. This data aggregation module includes a standardized interface unit, a data preprocessing unit, and a time synchronization unit. The standardized interface unit provides three types of interfaces: REST API, WebHook, and MQ message queue. Through preset interface parameters and adaptation logic, it achieves compatible connections with requirement management tools, code repositories, build tools, test management platforms, deployment platforms, and operation and maintenance monitoring tools. The data preprocessing unit is responsible for performing data cleaning, legality verification, and data anonymization operations. It ensures data integrity, legality, and security through regular expressions, key field rules, and character replacement strategies. The time synchronization unit calibrates the system time of each toolchain through the NTP protocol, controlling the time synchronization error to the millisecond level to ensure the consistency of time-series data.

[0059] Dependency Graph Construction Module 2 is used to build a full-level dependency model. This module includes a dependency resolution unit, a graph database storage unit, and an incremental update unit. The dependency resolution unit uses LLM-based natural language processing to parse requirement data, abstract syntax tree parsing to parse code data, cosine similarity algorithm to parse test data, and configuration file parsing to parse deployment data, identifying multi-dimensional dependencies. The graph database storage unit uses a graph database to store node, dependency edge, and attribute information, supporting efficient node traversal and dependency querying. The incremental update unit triggers partial updates based on data change events, updating only the attributes of associated nodes and the state of dependency edges, without requiring a full graph reconstruction.

[0060] Event processing module 3 is used to receive and distribute data change events at each stage. The event processing module includes an event filtering unit, a priority sorting unit, and a routing unit. The event filtering unit filters key events based on an event whitelist and removes invalid events. The priority sorting unit divides the events into priorities according to their impact and urgency, and assigns dedicated processing queues to events of different priorities. The routing unit accurately distributes events to the corresponding business modules based on the mapping relationship between event-related nodes and stages-processing modules.

[0061] The dependency propagation analysis module 4 is used to trace the scope of event impact and generate standardized collaborative notifications. The dependency propagation analysis module includes a tracing algorithm unit, an operation suggestion generation unit, and a notification encapsulation unit. The tracing algorithm unit uses a breadth-first search algorithm to achieve forward / reverse dependency tracing; the operation suggestion generation unit combines the current state of the node and the event type to generate role-based operation guidelines; the notification encapsulation unit encapsulates the notification content according to a standardized template to ensure information integrity and format consistency.

[0062] The collaborative notification push module 5 is used to push collaborative notifications and update dependency status. The collaborative notification push module includes a role mapping unit, a multi-channel push unit, and a receipt confirmation unit. The role mapping unit constructs a role-step-permission-push channel mapping relationship based on the RBAC model; the multi-channel push unit adapts to the workbench and instant messaging tools and pushes notifications according to role format requirements; the receipt confirmation unit implements notification delivery confirmation and retry mechanism to ensure that notifications are delivered; at the same time, it synchronously pushes the results to the full-process dependency graph and updates the dependency edge status.

[0063] The delivery and deployment coordination module 6 is used to generate the deployment order and issue deployment instructions. The delivery and deployment coordination module includes a topology sorting unit, a deployment instruction generation unit, and a status synchronization unit. The topology sorting unit uses the Kahn algorithm to sort the deployment objects topologically, generating a deployment order without dependency conflicts and handling circular dependency alarms. The deployment instruction generation unit encapsulates standardized deployment instructions according to the deployment order, including object identifier, version, environment, preconditions, and resource parameters. The status synchronization unit receives the deployment status feedback from the deployment platform in real time, synchronously updates the status of corresponding nodes and dependency edges in the full-process dependency graph, and handles deployment failure pauses and alarms.

[0064] The Operation and Maintenance Collaboration Closed-Loop Module 7 is used for fault tracing and repair closed-loop management. This module includes an alarm receiving unit, a root cause analysis unit, a task generation unit, and a verification unit. The alarm receiving unit receives alarm data pushed by monitoring tools; the root cause analysis unit determines the root cause of the fault and generates a tracing report through reverse dependency tracing and indicator comparison; the task generation unit assigns fault repair tasks according to roles, clarifying the responsible person, time limit, and acceptance criteria; and the verification unit automatically verifies the repair effect, forming a fault discovery-tracing-repair-verification closed loop.

[0065] Data security module 8 is used to ensure the security of data flow and storage. The data security module includes a data desensitization unit and an access control unit. The data desensitization unit performs character replacement processing on sensitive information; the access control unit allocates data access permissions based on the RBAC model to prevent sensitive data leakage.

[0066] In one embodiment, a computer device is provided, which may be a server, and its internal structure diagram may be as follows: Figure 7 As shown, the computer device includes a processor, memory, network interface, and database connected via a system bus. The processor provides computing and control capabilities. The memory includes non-volatile storage media and internal memory. The non-volatile storage media stores the operating system, computer programs, and database. The internal memory provides the environment for the operating system and computer programs in the non-volatile storage media to run. The database stores node data, dependency edge data, collaborative notification logs, and development delivery data for the entire dependency graph. The network interface communicates with external toolchains (such as GitLab and Kubernetes) and engineer workbench via network connection. When the computer program is executed by the processor, it implements a collaborative development and delivery method based on a dependency graph-based software factory.

[0067] Those skilled in the art will understand that Figure 6 The structure shown is merely a block diagram of a portion of the structure related to the present application and does not constitute a limitation on the computer device to which the present application is applied. Specific computer devices may include more or fewer components than those shown in the figure, or combine certain components, or have different component arrangements.

[0068] In one embodiment, a computer device is provided, including a memory and a processor, the memory storing a computer program, the processor executing the computer program to implement the steps in the above-described method embodiments.

[0069] Those skilled in the art will understand that all or part of the processes in the methods of the above embodiments can be implemented by a computer program instructing related hardware. The computer program can be stored in a non-volatile computer-readable storage medium, and when executed, it can include the processes of the embodiments of the above methods. Any references to memory, storage, databases, or other media used in the embodiments provided in this application can include non-volatile and / or volatile memory. Non-volatile memory can include read-only memory (ROM), programmable ROM (PROM), electrically programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM), or flash memory. Volatile memory can include random access memory (RAM) or external cache memory. By way of illustration and not limitation, RAM is available in various forms, such as static RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), dual data rate SDRAM (DDRSDRAM), enhanced SDRAM (ESDRAM), synchronous link DRAM (SLDRAM), Rambus direct RAM (RDRAM), direct memory bus dynamic RAM (DRDRAM), and memory bus dynamic RAM (RDRAM), etc. Although embodiments of the present invention have been described in conjunction with the accompanying drawings, the patent owner may make various modifications or alterations within the scope of the appended claims, as long as they do not exceed the protection scope described in the claims of the present invention, they shall be within the protection scope of the present invention.

Claims

1. A collaborative development and delivery method for software factories based on dependency graphs, characterized in that, Includes the following steps: S1. Obtain development and delivery data throughout the entire lifecycle of the software factory, and preprocess the development and delivery data. S2. Based on the full-process dependency graph engine, the dependencies of the preprocessed development and delivery data are automatically identified, and a full-level dependency model is constructed. S3. Receive data change events from each stage through a unified delivery bus, whereby the data change events cover all stages of the requirements; S4. Based on the full-process dependency graph, perform dependency propagation analysis on the data change event to determine the downstream links and related objects affected by the event, and generate standardized collaborative notification content. S5. Push standardized collaborative notification content to the corresponding execution role's workbench through the unified delivery bus, and update the dependency status of the entire process dependency graph simultaneously. S6. During the delivery and deployment phase, a deployment order without dependency conflicts is generated based on the topology sorting capability of the full-process dependency graph. Deployment instructions are issued to the deployment platform through a unified delivery bus to achieve automated and controllable delivery and deployment. S7. During the operation and maintenance phase, receive fault alarm data from monitoring tools, trace the root cause of the fault through the full-process dependency graph, and generate collaborative fault repair tasks.

2. The integrated development and delivery collaborative method for software factories based on dependency graphs according to claim 1, characterized in that, The development and delivery data in step S1 covers the entire process of requirements management, code development, build testing, deployment and delivery, and operation and maintenance monitoring, and comes from requirements management tools, code repositories, build tools, test management platforms, deployment platforms, and operation and maintenance monitoring tools, respectively. The unified delivery bus has a pre-defined standardized interface system, which includes three types of interfaces: REST API, WebHook, and MQ message queue. The REST API is suitable for periodic batch data synchronization to meet the transmission needs of non-real-time data such as test case execution results and requirement progress statistics. Through the pre-defined pagination query and incremental synchronization mechanism, the amount of data transmission is reduced. The WebHook is suitable for event-driven real-time data push to respond instantly to key events such as code submission, requirement status changes, and deployment status updates, ensuring that information is delivered without delay. MQ message queues are suitable for data buffering in high-concurrency scenarios. They are used to deal with data congestion during peak periods of concentrated code submissions and batch deployments on release days. Through message persistence and retry mechanisms, they prevent data loss. All three types of interfaces support JSON-LD format data encapsulation, and define the key fields and format specifications of data in each stage through a preset data schema; The preprocessing steps for the development and delivery data include: In the data cleaning stage, special characters, comments, and invalid spaces in code submission records are filtered using regular expressions to remove duplicate pushes of requirement change information and test case execution results, ensuring data integrity and uniqueness; In the legality verification stage, based on the key field rules of data from each stage, data with missing key fields or abnormal field formats are marked as needing correction and fed back to the source toolchain through the unified delivery bus. Simultaneously, a unique checksum is generated for each batch of data using the SHA-256 algorithm, and compared with the checksum sent by the source toolchain to verify whether tampering occurred during data transmission. In the data anonymization process, sensitive information such as code repository access tokens, deployment platform keys, and customer mobile phone numbers and email addresses in the requirement data is replaced with mask characters using a character replacement strategy to ensure the security of data flow. The unified delivery bus has a built-in time synchronization module that uses the NTP protocol to calibrate the system time of each toolchain to the UTC+8 time zone, with time synchronization errors controlled at the millisecond level, ensuring that time-series data such as requirement change time, code submission time, test execution time, and deployment completion time can be accurately correlated.

3. The integrated development and delivery collaborative method for software factories based on dependency graphs according to claim 1, characterized in that, In step S2: For the requirement data, the full-process dependency graph engine uses an LLM-based natural language processing model to semantically parse the requirement description. It identifies the business entities and technical constraints involved in the requirement through a pre-trained industry word vector library, and then, combined with a pre-set requirement-module-resource association rule library, establishes the association dependencies between requirement nodes and code module nodes, component nodes, and basic resource nodes, and marks the effective scenarios of the dependencies. For the code data, the engine parses the code file through an abstract syntax tree, traverses the syntax tree nodes to extract the function call relationships between code modules, forming call dependencies between code modules. Simultaneously, it parses the package management file to extract component dependency information and establish code module dependencies. Version dependencies between block nodes and component nodes are recorded, and the compatible version range of components is also recorded. For test data, the engine uses a cosine similarity algorithm to calculate the semantic correlation between test cases and code modules based on the description text and associated tags of the test cases. When the correlation is higher than a preset threshold, it is considered a valid correlation. Coverage dependencies between code module nodes and test case nodes are established, and the coverage range of test cases is marked. For deployment data, the engine parses the resource dependency configuration in the deployment configuration file, extracts the middleware, database, and upstream services that the deployment service depends on, establishes the environment dependencies between deployment service nodes and component nodes, basic resource nodes, and deployment service nodes, and records the startup order requirements of the dependencies. The full-level dependency model is stored in a graph database, where the node types include requirement nodes, code module nodes, component nodes, test case nodes, deployment service nodes, and basic resource nodes. Each node contains a unique identifier and attribute information. The dependency edges between nodes include dependency type, dependency state, and dependency strength; the engine is designed with an incremental update mechanism, so that when the unified delivery bus receives a new data change event, it only updates the node attributes and dependency edge states directly associated with the event, without having to rebuild the entire graph.

4. The integrated development and delivery collaborative method for software factories based on dependency graphs according to claim 1, characterized in that, The data change events in step S3 cover all aspects of the requirements, including: requirement status change, requirement content modification, code submission, code merging, and build result feedback in the development stage; test case execution result update, test report generation, and test defect submission in the testing stage; deployment request initiation, deployment status change, and deployment resource adjustment in the delivery stage; and monitoring alarm triggering, alarm recovery, and operation and maintenance log reporting in the operation and maintenance stage. The unified delivery bus has a built-in event processing module. This module first performs event filtering, screening critical events based on a preset event whitelist, retaining events that directly affect the collaborative process, and filtering out non-critical events with no collaborative value to reduce the consumption of system resources by invalid events. Next, it prioritizes events according to their impact on the delivery process and their urgency, with fault alarm events having the highest priority, followed by requirement change events, and ordinary code submission events and test case execution pass events having the lowest priority. High-priority events enter a dedicated processing queue, employing a scheduling strategy that combines first-come, first-served with priority preemption to ensure that critical events are responded to first and to avoid ordinary events blocking urgent events. Finally, it performs event routing, querying the full-process dependency graph based on the node identifier associated with the event to determine the stage to which the event belongs, and then accurately distributing the event to the corresponding business module according to the stage-processing module mapping relationship, while recording event routing logs for subsequent traceability and troubleshooting.

5. The integrated development and delivery collaborative method for software factories based on dependency graphs according to claim 1, characterized in that, Step S4 is implemented based on the dependency transmission analysis module. After the dependency transmission analysis module receives the data change event, it first extracts the core node associated with the event, and then selects the dependency tracing direction according to the stage to which the event belongs. For events in the requirements stage and development stage, forward dependency tracing is adopted, that is, starting from the core node, the downstream nodes that directly or indirectly depend on the node are queried layer by layer to determine the scope of the event's impact on subsequent processes. Events in the testing, delivery, and operation and maintenance phases are traced using reverse dependency tracing. This means starting from the core node and querying the upstream nodes that directly or indirectly depend on it layer by layer to determine the root cause of the event and the affected object. The tracing process uses a graph-based breadth-first search algorithm, starting from the core node and traversing layer by layer in the order of node, dependent edge, and downstream / upstream node, recording the node type, node identifier, dependency type, and current state of the traversed node. After tracing is completed, the module generates operation suggestions by combining the current state of the associated nodes and the event type; The collaborative notification content is packaged using a standardized template, including event identifier, event source, event type, list of affected links, list of related objects, operation suggestions, and response time limit, ensuring that the notification recipient can quickly obtain key collaborative information without the need for secondary interpretation or communication confirmation.

6. The collaborative development and delivery method for software factory based on dependency graphs according to claim 1, characterized in that, The unified delivery bus in step S5 has a built-in role collaboration module. Based on the RBAC model, it constructs a role-step-permission-push channel mapping system, assigning each execution role a dedicated responsible step, data access permissions, and push channel. The push step first queries the mapping system based on the impact steps in the collaborative notification to determine the corresponding execution role. Then, it encapsulates the notification content according to the role's preset push format requirements. Workbench pushes use Markdown format, including title, event details, a list of related objects, operation suggestions, and response time limits, and support hyperlinks to the corresponding toolchain page. Instant messaging tool pushes use text format, extracting the core information of the notification. After push, the unified delivery bus confirms the notification delivery status through a receipt mechanism. If the workbench does not return a received receipt within the preset time limit, or the instant messaging tool does not return a read status, a retry push is triggered. The retry interval increases exponentially. If the notification is still not delivered after a set number of retries, the push failure is recorded and the system administrator is notified to intervene. The entire process relies on the graph engine to receive the collaborative notification push results and update the status of the corresponding dependent edges.

7. The integrated development and delivery collaborative method for software factories based on dependency graphs according to claim 1, characterized in that, In step S6: When the deployment platform initiates a deployment request, the unified delivery bus forwards the list of objects to be deployed to the topology sorting unit of the end-to-end dependency graph engine. The topology sorting unit first queries the dependency edges between the objects to be deployed, constructs a local dependency subgraph, and clarifies the dependency relationships between each object; then, it uses the Kahn algorithm to perform topology sorting on the local dependency subgraph. The specific steps are as follows: first, calculate the in-degree of each node, and add nodes with an in-degree of 0 to the sorting queue; take a node from the queue, add it to the deployment order list, remove all outgoing edges associated with the node, and update the in-degree of downstream nodes. Repeat the above steps until the queue is empty and all nodes have been added to the deployment order list, and finally generate the deployment order; If a circular dependency is detected during the sorting process, the topology sorting unit immediately generates a circular dependency alarm, marking the circular dependency link, the involved nodes, and the dependency type in the alarm information. This alarm is then pushed to the operations engineer's workbench. After the operations team and development team collaboratively adjust the dependency relationships, the topology sorting is restarted. Once sorting is complete, the unified delivery bus generates standardized deployment instructions according to the deployment order. Each instruction includes the identifier of the object to be deployed, the deployment version, the target environment, preconditions, resource configuration parameters, and the start command. Instructions are issued sequentially through interfaces supported by the deployment platform, ensuring that the previous step is completed and the status is successful before issuing the next instruction. During deployment, the unified delivery bus receives the deployment status returned by the deployment platform in real time and synchronizes it to the full-process dependency graph, updating the status of the corresponding nodes and dependency edges. If a deployment step fails, the unified delivery bus immediately pauses the issuance of subsequent instructions, generates a deployment failure notification and pushes it to the operations team, and records the failure log in the system database to provide a basis for troubleshooting. After the operations team fixes the problem, the deployment is restarted from the failed step.

8. The integrated development and delivery collaborative method for software factories based on dependency graphs according to claim 1, characterized in that, In step S7: after the monitoring tool detects a fault, it pushes the alarm data to the unified delivery bus via WebHook. The bus forwards alarm data to the operation and maintenance collaboration closed-loop module. The module first extracts the node corresponding to the alarm object, calls the reverse dependency tracing function of the full-process dependency graph, and uses the breadth-first search algorithm to trace the upstream nodes that are directly or indirectly dependent on it layer by layer, starting from the node. At the same time, it calls the interface of the monitoring tool through the unified delivery bus to obtain the real-time monitoring indicators of each upstream node. The operation and maintenance collaboration closed-loop module compares the real-time indicators of each node with the preset normal threshold to identify abnormal nodes. By analyzing the anomaly propagation path through dependency chain analysis and combining the time sequence of anomalies at each node, the root cause of the fault is determined. Based on the root cause, the module generates a fault tracing report, which includes basic fault information, a fault chain diagram, a list of abnormal nodes, and the basis for root cause determination. Simultaneously, a fault repair collaborative task is generated, assigned according to roles. The collaborative task is pushed to the corresponding role's workbench via a unified delivery bus. The module tracks the task status in real time. After the task leader completes the operation, they submit an acceptance application on the workbench. The module calls the monitoring tool interface to obtain relevant indicators for automatic acceptance: if the indicators meet the acceptance criteria, the acceptance is deemed successful, the status of the corresponding node in the full-process dependency graph is updated to normal, and a fault repair closed-loop report is generated; if the indicators do not meet the acceptance criteria, the acceptance is deemed unsuccessful, the task leader is notified to re-investigate the problem, resubmit the acceptance application, and so on until acceptance is successful, ensuring the fault is completely resolved.

9. A system for implementing the collaborative development and delivery method for software factory based on dependency graphs as described in any one of claims 1-8, characterized in that, include: The data aggregation module is used to acquire development and delivery data throughout the entire lifecycle of the software factory. This data aggregation module includes a standardized interface unit, a data preprocessing unit, and a time synchronization unit. The standardized interface unit provides three types of interfaces: REST API, WebHook, and MQ message queue. Through preset interface parameters and adaptation logic, it achieves adaptive connections with requirement management tools, code repositories, build tools, test management platforms, deployment platforms, and operation and maintenance monitoring tools. The data preprocessing unit is responsible for performing data cleaning, legality verification, and data desensitization operations. It ensures data integrity, legality, and security through regular expressions, key field rules, and character replacement strategies. The time synchronization unit calibrates the system time of each toolchain through the NTP protocol, controlling the time synchronization error to the millisecond level to ensure the consistency of time-series data. The dependency graph construction module is used to build a full-level dependency model. The dependency graph construction module includes a dependency resolution unit, a graph database storage unit, and an incremental update unit. The dependency resolution unit uses LLM-based natural language processing technology to parse requirement data, abstract syntax tree parsing technology to parse code data, cosine similarity algorithm to parse test data, and configuration file parsing technology to parse deployment data, thereby identifying multi-dimensional dependency relationships. The graph database storage unit uses a graph database to store node, dependency edge, and attribute information, supporting efficient node traversal and dependency query; the incremental update unit triggers partial updates based on data change events, updating only the attributes of associated nodes and the status of dependency edges, without requiring a full reconstruction of the graph; The event processing module is used to receive and distribute data change events at each stage. The event processing module includes an event filtering unit, a priority sorting unit, and a routing unit. The event filtering unit filters key events based on an event whitelist and removes invalid events. The priority sorting unit divides the events into priorities based on their impact and urgency, and assigns dedicated processing queues to events of different priorities. The routing unit accurately distributes events to the corresponding business modules based on the mapping relationship between event-related nodes and process-processing modules; The dependency propagation analysis module is used to trace the scope of event impact and generate standardized collaborative notifications. The dependency propagation analysis module includes a tracing algorithm unit, an operation suggestion generation unit, and a notification encapsulation unit. The tracing algorithm unit uses a breadth-first search algorithm to achieve forward / reverse dependency tracing; the operation suggestion generation unit combines the current state of the node and the event type to generate role-based operation guidelines; the notification encapsulation unit encapsulates the notification content according to a standardized template to ensure information integrity and format consistency. The collaborative notification push module is used to push collaborative notifications and update dependency status. The collaborative notification push module includes a role mapping unit, a multi-channel push unit, and a receipt confirmation unit. The role mapping unit constructs a mapping relationship between roles, processes, permissions, and push channels based on the RBAC model; the multi-channel push unit adapts to the workbench and instant messaging tools, and pushes notifications according to role format requirements; the receipt confirmation unit implements notification delivery confirmation and retry mechanisms to ensure that notifications are delivered; at the same time, it synchronously pushes the results to the full-process dependency graph and updates the dependency edge status. The delivery and deployment coordination module is used to generate the deployment order and issue deployment instructions. This module includes a topology sorting unit, a deployment instruction generation unit, and a status synchronization unit. The topology sorting unit uses the Kahn algorithm to sort the deployment objects topologically, generating a deployment order without dependency conflicts and handling circular dependency alarms. The deployment instruction generation unit encapsulates standardized deployment instructions according to the deployment order, including object identifiers, versions, environments, preconditions, and resource parameters. The status synchronization unit receives real-time deployment status feedback from the deployment platform, synchronously updates the status of corresponding nodes and dependency edges in the full-process dependency graph, and handles deployment failure pauses and alarms. The operation and maintenance collaboration closed-loop module is used for fault tracing and repair closed-loop management. The operation and maintenance collaboration closed-loop module includes an alarm receiving unit, a root cause analysis unit, a task generation unit, and a verification unit. The alarm receiving unit receives alarm data pushed by monitoring tools; the root cause analysis unit determines the root cause of the fault and generates a tracing report through reverse dependency tracing and indicator comparison; the task generation unit assigns fault repair tasks according to roles, and clarifies the person in charge, time limit, and acceptance criteria; the verification unit automatically verifies the repair effect, forming a fault discovery-tracing-repair-verification closed loop. The data security module is used to ensure the security of data flow and storage. The data security module includes a data desensitization unit and an access control unit. The data desensitization unit performs character replacement processing on sensitive information; the access control unit allocates data access permissions based on the RBAC model to prevent sensitive data leakage.

10. A computer device comprising a memory and a processor, wherein the memory stores a computer program, characterized in that, When the processor executes the computer program, it implements the integrated development and delivery collaborative method for software factory based on dependency graphs as described in any one of claims 1-8.