A software engineering full life cycle management method and system for low-code and high-code hybrid development

Abstract

The application discloses a kind of low code and high code fusion development software engineering whole life cycle management method and system, comprising the following steps: S101, project initiation and initialization;S102, guided configuration and engineering generation;S201, low code business configuration development;S202, high code business logic development;S301, low code configuration coding and version submission;S302, unified engineering view construction and logic binding;S401, low code and high code decoupling association;S402, joint CI / CD pipeline trigger;S501, application unified construction and packing;S502, unified deployment and whole life cycle management and control.The application realizes the whole life cycle automation management from project initialization, configuration coding, unified version management and control, logic binding to joint construction deployment;By automatically coding low code configuration and including in unified version management, the black box state of low code configuration is broken, while maintaining the flexibility of two types of development, effectively improving development and delivery efficiency.

Description

Technical Field

[0001] This invention relates to the field of computer software technology, specifically to a software engineering full lifecycle management method and system that integrates low-code and high-code development. Background Technology

[0002] As enterprises deepen their digital transformation, business needs are characterized by rapid iteration and high customization. Low-code development technology, due to its ability to significantly improve application delivery efficiency and lower the development threshold, has been widely used in enterprise software development practices. However, existing low-code development solutions have significant limitations at the engineering management level.

[0003] Currently, mainstream low-code development tools (such as form designers, workflow engines, and large-screen visualization tools) are typically provided by different vendors, each running independently, with configuration data stored in their own databases or private files. Enterprises often need to use multiple low-code tools simultaneously in a project, but due to the lack of a unified project-level management mechanism, these tools form typical tool silos. Developers cannot view the complete project assets in a unified engineering view, and there is a lack of correlation and traceability between the configurations produced by different tools.

[0004] Meanwhile, the connection between low-code development and high-code development (i.e., traditional coding development) is severely lacking. Low-code tools typically produce black-box configurations—metadata or binary files stored in platform-specific formats—which are difficult to incorporate into version control systems like Git for branch management, code review, difference comparison, and version rollback, unlike high-code source code. When business logic crosses the boundary between low-code and high-code (e.g., a high-code backend service calls a form page generated by low-code, or a low-code page needs to call an API interface developed by high-code), existing technologies lack effective dependency management and version consistency verification mechanisms, making it highly susceptible to online failures due to configuration changes being out of sync with the source code.

[0005] Furthermore, low-code deployment processes often rely on manual operations or independent scripts, making seamless integration with the CI / CD (Continuous Integration / Continuous Deployment) pipelines used in high-code development impossible. Testing, building, and deployment are disconnected, hindering end-to-end automated governance. When low-code and high-code source code need to be released simultaneously, existing technologies cannot provide unified joint build and deployment capabilities.

[0006] Several patent documents have attempted to address some of the aforementioned issues. For example, Chinese patent application CN202410498528.X discloses a front-end page development method based on bidirectional code-model conversion. It uses an Abstract Syntax Tree (AST) to achieve bidirectional conversion between file code and high- and low-code models, thereby improving the flexibility of front-end page development. However, this solution focuses primarily on the code-model conversion technology itself during the development phase and does not address the engineering-based full lifecycle management with the project as the sole management entity. It fails to solve the problems of unified version control, joint CI / CD construction, and unified deployment for low-code configuration and high-code source code. Other related documents, such as CN202311151118.X, CN202411629579.8, and CN202511958103.3, either only address low-code front-end page rendering or are limited to form design and management within the low-code platform. None of them propose an engineering management architecture that systematically integrates dispersed low-code tool clusters with high-code development pipelines.

[0007] Therefore, how to break down the barriers between low-code tools and high-code development, and achieve automated governance throughout the entire lifecycle from project initialization, configuration coding, unified version control, logical binding to joint build and deployment, is a technical problem that urgently needs to be solved in this field. Summary of the Invention

[0008] The purpose of this invention is to address the shortcomings of existing technologies by providing a method for automating the entire lifecycle of governance, from project initialization, configuration coding, unified version control, logical binding to joint build and deployment.

[0009] The technical objective of this invention is achieved through the following technical solution: A software engineering full lifecycle management method that integrates low-code and high-code development includes the following steps: S101, Project initiation and initialization: Initiate a new engineering project on the project management platform. The system automatically assigns a unique project identifier, creates an independent project space, divides the low-code configuration directory, high-code source code directory, CI / CD configuration directory and asset storage directory, and clarifies the basic configuration information of the project. S102, Guided Configuration and Project Generation: Through a guided visual interface, developers are guided to complete project configuration: select low-code toolchain, high-code development mode and reusable modules; the system automatically generates a standardized project structure based on the above configuration, including low-code configuration template, high-code project skeleton and CI / CD pipeline configuration file; S201, Low-code business configuration development: Receive visual configuration operations through a low-code tool cluster, generate low-code configuration changes, and record change logs; S202, High-code business logic development: Receive source code writing operations through the high-code development client, generate high-code source code, and submit it to the Git repository bound to the project according to the specifications. When submitting, associate the project identifier and developer information. S301, Low-code configuration coding and version commit: Through the configuration coding engine, low-code configuration changes are converted into structured, traceable code and automatically committed to the Git repository, which is in the same version management system as the high-code source code; S302. Unified Project View Construction and Logical Binding: Based on the low-code configuration code and high-code source code in the Git repository, the system generates a unified project view and establishes logical binding rules between low-code assets and high-code assets. S401, Decoupling and Association of Low-Code and High-Code: Decoupling and association of low-code assets and high-code main applications is achieved through a combination of standard API calls and page embedding; S402, Joint CI / CD Pipeline Trigger: In response to code commit events, a unified CI / CD pipeline is triggered to synchronize the two types of code in the Git repository, perform compilation testing and validity verification, and jointly build the two to generate a complete application package; S501, Unified Application Build and Packaging: The CI / CD pipeline integrates low-code configuration with high-code source code according to the association rules of the unified engineering view, and generates application installation packages and build reports; S502, Unified Deployment and Full Lifecycle Management: Deploy application packages to container operation and maintenance environments, incorporate them into the project-level full lifecycle management and maintenance system, and support iterative updates based on operation and maintenance feedback.

[0010] Preferably, in step S102, the low-code toolchain includes one or more of a form engine, a process engine, and a large-screen visualization tool; the high-code development mode includes a backend framework and a frontend framework; and the reusable module includes at least one of a pre-existing general permission module and a data acquisition module.

[0011] Preferably, in step S301, the structured traceable code is a configuration file and / or an executable script in JSON format; the Git repository generates an independent version record for each configuration change, supporting developers to view the configuration change history, perform version rollback, and perform branch management.

[0012] Preferably, in step S302, the logical binding rules include at least one of the following: data submission from the low-code page is associated with the high-code data interface, the triggering of low-code process nodes is associated with the high-code logic processing service, and the data display of the low-code data visualization component is associated with the high-code data statistics interface.

[0013] Preferably, in step S401, the standard API call is a RESTful API call; the page embedding includes integrating a low-code page into a high-code main page through page embedding technology.

[0014] Preferably, in step S402, the legality verification includes format verification and / or process definition legality verification of the low-code configuration code; the joint construction includes copying the low-code configuration file to the static resource directory of the high-code front-end build product, and packaging the high-code back-end compilation product and the front-end static resources together into a container image.

[0015] Preferably, in step S501, the build report records the build process, test results, and version information.

[0016] Preferably, the method is implemented based on a four-layer converged management architecture, which includes: The foundational support layer deploys Git repositories, container runtime environments, access control modules, and end-to-end log monitoring modules. The development resource layer integrates low-code tool clusters, high-code development pipelines, code snippet libraries, and reusable functional module libraries. The integrated management and control layer takes the project as the sole management entity and achieves unified management and control through a guided configuration engine, a unified project view, Git version control, and CI / CD linkage scheduling module. The application layer transforms the results of integrated development into deliverable and maintainable business systems.

[0017] A software engineering lifecycle management system that integrates low-code and high-code development, used to implement the software engineering lifecycle management method that integrates low-code and high-code development as described above, the system comprising: The project management platform is used to create and manage project spaces with projects as the sole management entity, assign unique project identifiers, create project spaces, and divide them into functional directories. The guided configuration engine provides a visual configuration interface, accepts developers' input on their choices of low-code toolchains, high-code development modes, and reusable modules, and automatically generates standardized project structures. A cluster of low-code tools is used to receive visual configuration operations from developers and generate low-code configuration changes; High-code development client, used to receive source code writing operations from developers and generate high-code source code; A configuration code engine is used to convert low-code configuration changes into structured, traceable code and commit it to the Git version control system. Git is a version control system used to store a unified repository of low-code configuration code and high-code source code, generating an independent version record for each change. The unified project view generation module is used by the system to generate a unified project view based on the low-code configuration code and high-code source code in the Git repository, and to establish logical binding rules between the low-code configuration and the high-code source code. The decoupling module achieves decoupling between low-code assets and high-code main applications through a combination of standard API calls and page embedding; the unified CI / CD pipeline engine is used to synchronize low-code configuration code and high-code source code in Git repositories, perform compilation testing and legality verification, and execute joint build to generate complete application packages; The container operation and maintenance environment is used to receive and deploy the application package and incorporate it into the project-level full lifecycle management.

[0018] Compared with the prior art, the beneficial effects of the present invention are: 1. The method of this invention integrates development scenario interaction with "projects" as the core link, focusing on the developer's business operation process to achieve seamless collaboration between low-code and high-code. Developers first use the project-guided configuration module to visually select the required low-code toolchain, high-code development mode, and reusable modules, completing project initialization and generating a standardized project. Subsequently, low-code visual configuration and high-code logic development can be carried out in parallel. Low-code configuration changes are automatically coded and submitted to the unified Git repository along with the high-code source code, forming a unified project view. After decoupling and associating the two through standard API calls or page embedding, the system triggers a unified CI / CD pipeline to complete joint building and packaging, ultimately deploying the application to the operations and maintenance platform. Developers can perform iterative optimization based on operations and maintenance feedback, efficiently completing the entire business development and delivery process. This invention achieves automated governance throughout the entire lifecycle, from project initialization, configuration coding, unified version control, logic binding to joint building and deployment. By automatically coding low-code configuration and incorporating it into unified version management, the black-box state of low-code configuration is broken, effectively improving development and delivery efficiency while maintaining the flexibility of both types of development.

[0019] 2. The system of the present invention integrates low-code and high-code development activities into a unified engineering management system based on projects, achieving full lifecycle management from initialization, development, version control, integration to deployment and maintenance. This technical approach leverages a project management platform and a guided configuration engine to rapidly generate standardized engineering structures, lowering the initialization threshold and ensuring project consistency. Through a configuration coding engine and Git version control system, all low-code configurations are automatically converted into traceable and rollbackable structured code, coexisting with high-code source code under the same version management system. This completely breaks the "black box" status of low-code and ensures the auditability of all assets. Based on a unified engineering view and decoupled modules, a clear and flexible logical binding and integration relationship is established between low-code configurations and the high-code main application, enabling visualized management and independent evolution of both types of development artifacts. A unified CI / CD pipeline engine automatically synchronizes the two types of code and performs joint building and verification, eliminating the risks of manual integration and ensuring the integrity and availability of the final application package. The containerized operation and maintenance environment further incorporates deliverables into the project-level full lifecycle management, thereby improving overall development efficiency, quality control, and long-term maintainability in low-code and high-code integrated development scenarios. Attached Figure Description

[0020] Figure 1 This is a schematic diagram illustrating the principle of the method of the present invention; Figure 2 This is a system interaction diagram of the present invention; Figure 3 This is a schematic diagram illustrating the implementation steps of the method of the present invention. Detailed Implementation

[0021] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. The components of the embodiments of the present invention described and shown in the accompanying drawings can generally be arranged and designed in various different configurations.

[0022] Therefore, the following detailed description of the embodiments of the invention provided in the accompanying drawings is not intended to limit the scope of the claimed invention, but merely to illustrate selected embodiments of the invention. All other embodiments obtained by those skilled in the art based on the embodiments of the invention without inventive effort are within the scope of protection of the invention.

[0023] It should be noted that similar labels and letters in the following figures indicate similar items; therefore, once an item is defined in one figure, it does not need to be further defined and explained in subsequent figures. Furthermore, the terms "first," "second," etc., are used only to distinguish descriptions and should not be construed as indicating or implying relative importance.

[0024] Example 1 like Figure 1 — Figure 3 As shown, a software engineering lifecycle management method that integrates low-code and high-code development includes the following steps: S101. Project Initiation and Initialization: Initiate a new engineering project on the project management platform. The system automatically assigns a unique project identifier, creates an independent project space, divides the low-code configuration directory, high-code source code directory, CI / CD configuration directory and asset storage directory, and clarifies the basic configuration information of the project. S102, Guided Configuration and Project Generation: Through a guided visual interface, developers are guided to complete project configuration: select low-code toolchain, high-code development mode and reusable modules; the system automatically generates a standardized project structure based on the above configuration, including low-code configuration template, high-code project skeleton and CI / CD pipeline configuration file; S201, Low-code business configuration development: Receive visual configuration operations through a low-code tool cluster, generate low-code configuration changes, and record change logs; S202, High-code business logic development: Receive source code writing operations through the high-code development client, generate high-code source code, and submit it to the Git repository bound to the project according to the specifications. When submitting, associate the project identifier and developer information. S301, Low-code configuration coding and version commit: Through the configuration coding engine, low-code configuration changes are converted into structured, traceable code and automatically committed to the Git repository, which is in the same version management system as the high-code source code; S302. Unified Project View Construction and Logical Binding: Based on the low-code configuration code and high-code source code in the Git repository, the system generates a unified project view and establishes logical binding rules between low-code assets and high-code assets. S401, Decoupling and Association of Low-Code and High-Code: Decoupling and association of low-code assets and high-code main applications is achieved through a combination of standard API calls and page embedding; S402, Joint CI / CD Pipeline Trigger: In response to code commit events, a unified CI / CD pipeline is triggered to synchronize the two types of code in the Git repository, perform compilation testing and validity verification, and jointly build the two to generate a complete application package; S501, Unified Application Build and Packaging: The CI / CD pipeline integrates low-code configuration with high-code source code according to the association rules of the unified engineering view, and generates application installation packages and build reports; S502, Unified Deployment and Full Lifecycle Management: Deploy application packages to container operation and maintenance environments, incorporate them into the project-level full lifecycle management and maintenance system, and support iterative updates based on operation and maintenance feedback.

[0025] This embodiment uses an "Industrial Internet Operation and Maintenance Management System" as an example to detail the complete implementation process of the software engineering full lifecycle management method of the present invention, which integrates low-code and high-code development. This scenario requires the implementation of core functions such as equipment monitoring, data statistics, and operation and maintenance work order management, involving low-code operations such as form configuration, process definition, and large-screen visualization, as well as high-code development work such as data interface development and complex logic processing. It should be understood that the specific embodiments described herein are for illustrative purposes only and are not intended to limit the scope of the invention.

[0026] In this embodiment, S101, Project Initiation and Initialization: The developer initiates the creation of a new "Industrial Internet Operation and Maintenance Management System" project on the project management platform. The system automatically assigns a unique project identifier to the project, creates an independent project space, divides the low-code configuration directory, high-code source code directory, CI / CD configuration directory and asset storage directory, and clarifies the basic configuration information of the project (such as development environment, deployment environment, permission allocation, etc.) to ensure that all subsequent development assets are bound to the project and realize unified asset management at the project level.

[0027] S102, Guided Configuration and Project Generation: Through a guided visual interface, developers are guided to complete project configuration: select low-code toolchain, high-code development mode and reusable modules; the system automatically generates a standardized project structure based on the above configuration, including low-code configuration template, high-code project skeleton and CI / CD pipeline configuration file.

[0028] In specific implementation, step S102 includes a low-code toolchain comprising one or more of a form engine, a process engine, and a large-screen visualization tool; a high-code development model comprising a backend framework and a frontend framework; and a reusable module comprising at least one of a pre-existing general permission module and a data acquisition module. In practical use, the backend framework can be a Java / SpringBoot backend framework, etc., and the frontend framework can be a Vue frontend framework, etc.

[0029] S201, Low-code business configuration development: Receive visual configuration operations through a low-code tool cluster, generate low-code configuration changes, and record change logs.

[0030] In this embodiment, the developer enters the low-code tool cluster, designs device information entry forms and maintenance work order forms based on the form engine, and configures the form validation rules and data association relationships; designs the entire process of initiating, reviewing, processing, and archiving maintenance work orders through the process engine, and configures process nodes, approval roles, and flow rules; and designs a device monitoring dashboard through the large-screen visualization tool, configures data display charts and real-time data refresh frequency, and completes the low-code level business function configuration. All configuration operations are saved in real time and change logs are recorded.

[0031] S202, High-Code Business Logic Development: Receive source code writing operations through the high-code development client, generate high-code source code, and submit it to the Git repository bound to the project according to the specifications. When submitting, associate the project identifier and developer information.

[0032] In this embodiment, developers develop core business logic on the high-code development side, while the backend, based on the Java / SpringBoot backend framework, develops device data interfaces, work order data processing interfaces, and permission verification interfaces to realize the collection, storage, and analysis of device data, as well as the logical processing and permission control of maintenance work orders. The frontend, based on the Vue frontend framework, develops the system's main page, navigation menu, and data statistics module to achieve seamless integration with the low-code configuration page. The completed source code is submitted to the Git repository bound to the project according to the specifications, and the project identifier and developer information are associated with the submission to ensure the traceability of the source code.

[0033] S301, Low-code configuration coding and version commit: Through the configuration coding engine, low-code configuration changes are converted into structured, traceable code and automatically committed to the Git repository, which is under the same version management system as the high-code source code.

[0034] In step S301, the structured traceable code is a configuration file and / or an executable script in JSON format; the Git repository generates an independent version record for each configuration change, allowing developers to view the configuration change history, perform version rollback, and perform branch management.

[0035] In this embodiment, after all configuration changes of the low-code tool are completed, the system automatically converts the visual configuration into structured, traceable code through the configuration coding engine and automatically submits it to the Git repository, which is in the same version management system as the high-code source code. Each configuration change generates an independent version record, and developers can view the configuration change history and roll back to the previous version at any time, completely breaking the traditional "black box" configuration mode of low-code.

[0036] S302. Unified Project View Construction and Logical Binding: Based on the low-code configuration code and high-code source code in the Git repository, the system generates a unified project view and establishes logical binding rules between low-code assets and high-code assets. Logical binding rules include at least one of the following: associating data submissions from low-code pages with high-code data interfaces; associating the triggering of low-code process nodes with high-code logic processing services; and associating data display from low-code data visualization components with high-code data statistics interfaces.

[0037] In this embodiment, the system automatically generates a unified project view based on the low-code configuration code and high-code source code in the Git repository. This view clearly displays the relationship between low-code pages, processes, and high-code interfaces and services, and establishes logical binding rules: data submissions from low-code forms are associated with high-code data interfaces, node triggers in low-code processes are associated with high-code logical processing services, and data displays on low-code dashboards are associated with high-code data statistics interfaces. This ensures the consistency and collaboration between low-code and high-code assets, facilitating unified management and problem troubleshooting for developers.

[0038] S401, Decoupling and Association of Low-Code and High-Code: The decoupling and association of low-code assets and high-code main applications is achieved through a combination of standard API calls and page embedding; the standard API calls are RESTful API calls; page embedding includes integrating low-code pages into high-code main pages through page embedding technology.

[0039] In this embodiment, the decoupling of low-code assets and high-code main applications is achieved by combining standard API calls with page embedding: low-code forms and large-screen pages obtain device data and work order data by calling the RESTful API developed by high-code, thus achieving data synchronization; the high-code main page integrates the low-code-developed operation and maintenance work order process page and device monitoring large screen into the system through page embedding technology, achieving seamless functional connection, which not only ensures the independent iteration of low-code and high-code, but also avoids the coupling and dependence between the two.

[0040] S402, Joint CI / CD Pipeline Trigger: In response to a code commit event, a unified CI / CD pipeline is triggered to synchronize the two types of code in the Git repository, perform compilation testing and validity checks, and jointly build the two to generate a complete application package; the validity checks include format checks and / or process definition validity checks on the low-code configuration code; the joint build includes copying the low-code configuration file to the static resource directory of the high-code front-end build artifact, and packaging the high-code back-end compilation artifact and the front-end static resources together into a container image.

[0041] In this embodiment, after the developer completes the low-code configuration submission and high-code source code submission, the system automatically triggers a unified CI / CD pipeline. The pipeline first synchronizes the low-code configuration code and high-code source code in the Git repository, compiles and tests the high-code source code, performs legality verification on the low-code configuration code, and then combines the two to build and package a complete application package containing front-end pages, back-end services, and configuration files. During the build process, dependency conflicts and configuration errors are automatically checked to ensure the availability of the application package.

[0042] S501. Unified Application Build and Packaging: The CI / CD pipeline integrates low-code configuration with high-code source code according to the association rules of the unified engineering view, generating application installation packages and build reports; the build reports record the build process, test results, and version information.

[0043] In this embodiment, the CI / CD pipeline deeply integrates low-code configuration with high-code source code according to the association rules of the unified engineering view, optimizes application performance, removes redundant code and configuration, generates an application installation package adapted to the deployment environment, and generates a build report that records the build process, test results, and version information in detail, making it easier for developers to trace the build process and troubleshoot build anomalies.

[0044] S502, Unified Deployment and Full Lifecycle Management: Deploy application packages to container operation and maintenance environments, incorporate them into the project-level full lifecycle management and maintenance system, and support iterative updates based on operation and maintenance feedback.

[0045] In this embodiment, the system uniformly deploys the completed application package to the K8s container operation and maintenance environment and incorporates it into the project-level full lifecycle management and control system. Operation and maintenance personnel monitor the application's running status through the operation and maintenance platform, including device data collection, work order flow efficiency, system response speed, etc., and set alarm thresholds to trigger alarms in a timely manner when anomalies occur. Developers can adjust configurations through low-code tools and optimize logic through high-code development based on operation and maintenance feedback. After submitting changes, they can trigger the CI / CD pipeline again to achieve iterative updates of the application and complete the complete business loop from development to operation and maintenance.

[0046] A software engineering lifecycle management method that integrates low-code and high-code development, the method being implemented based on a four-layer integrated management architecture, the four-layer integrated management architecture comprising: The foundational support layer deploys a Git repository, container runtime environment, access control module, and end-to-end log monitoring module. The end-to-end log monitoring module records complete operation logs from project creation to deployment and maintenance. In this embodiment, the base support layer serves as the foundational guarantee layer of the entire architecture, undertaking the core responsibility of supporting unified infrastructure. It deploys a Git repository, a container runtime environment, an access control module, and a full-link log monitoring module, providing a trusted, traceable, and highly available runtime environment for all development activities and control behaviors at the upper layer. This solves the problems of fragmented infrastructure, chaotic permissions, and untraceable operations in existing technologies, laying a solid foundation for the collaborative operation of subsequent layers.

[0047] The development resource layer integrates low-code tool clusters, high-code development pipelines, code snippet libraries, and reusable functional module libraries.

[0048] In this embodiment, the development resource layer serves as an aggregation layer for development assets, integrating various independently operating low-code tool clusters, a complete high-code development pipeline, and existing code snippet libraries and reusable functional module libraries. This breaks through the pain point of existing low-code tools operating independently and being separated from the high-code development pipeline, achieving centralized management of development resources and providing a unified resource entry point for subsequent integration and control. It ensures that all kinds of resources required for low-code and high-code development can be uniformly scheduled and managed.

[0049] The integrated management layer uses projects as the sole management entity and achieves unified management through a guided configuration engine, a unified project view, Git version control, and a CI / CD linkage scheduling module.

[0050] In this embodiment, the integration and control layer serves as the core control layer of the invention. Using the "project" as the sole management entity, it supports the infrastructure of the foundational support layer and coordinates various resources from the development resource layer. Through core modules such as a guided configuration engine, a unified project view, Git version control, and CI / CD coordinated scheduling, it achieves unified control over the entire low-code and high-code development process. This layer standardizes project initialization through guided configuration, breaks the "black box" configuration model through low-code configuration coding, and achieves unified version management of low-code assets and high-code source code through Git version control. It addresses the core pain points of insufficient unified control and weak correlation between low-code and high-code in existing technologies, serving as the core hub for realizing the "project-through" architecture. The application layer transforms the results of integrated development into deliverable and maintainable business systems.

[0051] In this embodiment, the application layer, as the output layer of the architecture, takes over the management results of the integration and control layer, transforms the results of low-code and high-code integrated development into a deliverable and maintainable business system, realizes the integration of business system delivery, version release, and operation and maintenance management, and finally completes the full-link automated governance from code submission, low-code configuration synchronization, joint construction to unified deployment and operation and maintenance, filling the technical gap in project-level engineering process management in a distributed low-code tool environment.

[0052] Example 2 A software engineering lifecycle management system integrating low-code and high-code development is provided to implement the software engineering lifecycle management method integrating low-code and high-code development in Embodiment 1. The system includes: The project management platform is used to create and manage project spaces with projects as the sole management entity, assign unique project identifiers, create project spaces, and divide them into functional directories. The guided configuration engine provides a visual configuration interface, accepts developers' input on their choices of low-code toolchains, high-code development modes, and reusable modules, and automatically generates standardized project structures. A cluster of low-code tools is used to receive visual configuration operations from developers and generate low-code configuration changes; High-code development client, used to receive source code writing operations from developers and generate high-code source code; A configuration code engine is used to convert low-code configuration changes into structured, traceable code and commit it to the Git version control system. Git is a version control system used to store a unified repository of low-code configuration code and high-code source code, generating an independent version record for each change. The unified project view generation module is used by the system to generate a unified project view based on the low-code configuration code and high-code source code in the Git repository, and to establish logical binding rules between the low-code configuration and the high-code source code. The decoupling module achieves a decoupled connection between low-code assets and high-code main applications through a combination of standard API calls and page embedding. A unified CI / CD pipeline engine is used to synchronize low-code configuration code and high-code source code in Git repositories, perform compilation testing and validity checks, and execute joint builds to generate complete application packages; The container operation and maintenance environment is used to receive and deploy the application package and incorporate it into the project-level full lifecycle management.

[0053] This invention's system integrates low-code and high-code development activities into a unified, project-based engineering management system, achieving full lifecycle connectivity from initialization, development, version control, integration to deployment and maintenance. This approach leverages a project management platform and a guided configuration engine to rapidly generate standardized engineering structures, lowering the initialization threshold and ensuring project consistency. A configuration coding engine and Git version control system automatically convert all low-code configurations into traceable, rollback-capable structured code, placing them within the same version management system as high-code source code, completely breaking the "black box" status of low-code and ensuring the auditability of all assets. Based on a unified engineering view and decoupled modules, a clear and flexible logical binding and integration relationship is established between low-code configurations and the main high-code application, enabling visualized management and independent evolution of both types of development deliverables. A unified CI / CD pipeline engine automatically synchronizes the two types of code and performs joint construction and verification, eliminating the risks of manual integration and ensuring the integrity and availability of the final application package. The containerized operation and maintenance environment further integrates deliverables into project-level full lifecycle management, thereby comprehensively improving development efficiency, quality control, and long-term maintainability in low-code and high-code integrated development scenarios.

[0054] The technical solutions provided by the embodiments of the present invention have been described in detail above. Specific examples have been used to illustrate the principles and implementation methods of the embodiments of the present invention. The descriptions of the embodiments above are only for helping to understand the principles of the embodiments of the present invention. At the same time, for those skilled in the art, there will be changes in the specific implementation methods and application scope based on the embodiments of the present invention. Therefore, the content of this specification should not be construed as a limitation of the present invention.

Claims

1. A software engineering lifecycle management method that integrates low-code and high-code development, characterized in that, Includes the following steps: S101. Project Initiation and Initialization: Initiate a new engineering project on the project management platform. The system automatically assigns a unique project identifier, creates an independent project space, divides the low-code configuration directory, high-code source code directory, CI / CD configuration directory and asset storage directory, and clarifies the basic configuration information of the project. S102, Guided Configuration and Project Generation: Through a guided visual interface, developers are guided to complete project configuration: select low-code toolchain, high-code development mode and reusable modules; the system automatically generates a standardized project structure based on the above configuration, including low-code configuration template, high-code project skeleton and CI / CD pipeline configuration file; S201, Low-code business configuration development: Receive visual configuration operations through a low-code tool cluster, generate low-code configuration changes, and record change logs; S202, High-code business logic development: Receive source code writing operations through the high-code development client, generate high-code source code, and submit it to the Git repository bound to the project according to the specifications. When submitting, associate the project identifier and developer information. S301, Low-code configuration coding and version commit: Through the configuration coding engine, low-code configuration changes are converted into structured, traceable code and automatically committed to the Git repository, which is in the same version management system as the high-code source code; S302. Unified Project View Construction and Logical Binding: Based on the low-code configuration code and high-code source code in the Git repository, the system generates a unified project view and establishes logical binding rules between low-code assets and high-code assets. S401, Decoupling and Association of Low-Code and High-Code: Decoupling and association of low-code assets and high-code main applications is achieved through a combination of standard API calls and page embedding; S402, Joint CI / CD Pipeline Trigger: In response to code commit events, a unified CI / CD pipeline is triggered to synchronize the two types of code in the Git repository, perform compilation testing and validity verification, and jointly build the two to generate a complete application package; S501, Unified Application Build and Packaging: The CI / CD pipeline integrates low-code configuration with high-code source code according to the association rules of the unified engineering view, and generates application installation packages and build reports; S502, Unified Deployment and Full Lifecycle Management: Deploy application packages to container operation and maintenance environments, incorporate them into the project-level full lifecycle management and maintenance system, and support iterative updates based on operation and maintenance feedback.

2. The software engineering full lifecycle management method for the integrated development of low-code and high-code technologies according to claim 1, characterized in that, In step S102, the low-code toolchain includes one or more of a form engine, a process engine, and a large-screen visualization tool; the high-code development mode includes a backend framework and a frontend framework; and the reusable module includes at least one of a pre-existing general permission module and a data acquisition module.

3. The software engineering full lifecycle management method for the integrated development of low-code and high-code technologies according to claim 1, characterized in that, In step S301, the structured traceable code is a configuration file and / or an executable script in JSON format; the Git repository generates an independent version record for each configuration change, allowing developers to view the configuration change history, perform version rollback, and perform branch management.

4. The software engineering full lifecycle management method for the integrated development of low-code and high-code technologies as described in claim 1, characterized in that, In step S302, the logical binding rules include at least one of the following: data submission on the low-code page is associated with the high-code data interface, the triggering of low-code process nodes is associated with the high-code logic processing service, and the data display of the low-code data visualization component is associated with the high-code data statistics interface.

5. The software engineering full lifecycle management method for the integrated development of low-code and high-code technologies according to claim 1, characterized in that, In step S401, the standard API call is a RESTful API call; the page embedding includes integrating the low-code page into the high-code main page through page embedding technology.

6. The software engineering full lifecycle management method for the integrated development of low-code and high-code technologies according to claim 1, characterized in that, In step S402, the validity verification includes format verification and / or process definition validity verification of the low-code configuration code; the joint construction includes copying the low-code configuration file to the static resource directory of the high-code front-end build product, and packaging the high-code back-end compilation product and the front-end static resources together into a container image.

7. The software engineering lifecycle management method for the integrated development of low-code and high-code technologies according to claim 1, characterized in that, In step S501, the build report records the build process, test results, and version information.

8. The software engineering full lifecycle management method for the integrated development of low-code and high-code technologies according to claim 1, characterized in that, The method is implemented based on a four-layer converged management architecture, which includes: The foundational support layer deploys Git repositories, container runtime environments, access control modules, and end-to-end log monitoring modules. The development resource layer integrates low-code tool clusters, high-code development pipelines, code snippet libraries, and reusable functional module libraries. The integrated management and control layer takes the project as the sole management entity and achieves unified management and control through a guided configuration engine, a unified project view, Git version control, and CI / CD linkage scheduling module. The application layer transforms the results of integrated development into deliverable and maintainable business systems.

9. A software engineering lifecycle management system that integrates low-code and high-code development, characterized in that, The system is used to implement the software engineering lifecycle management method for the integrated development of low-code and high-code technologies as described in any one of claims 1 to 8, the system comprising: The project management platform is used to create and manage project spaces with projects as the sole management entity, assign unique project identifiers, create project spaces, and divide them into functional directories. The guided configuration engine provides a visual configuration interface, accepts developers' input on their choices of low-code toolchains, high-code development modes, and reusable modules, and automatically generates standardized project structures. A cluster of low-code tools is used to receive visual configuration operations from developers and generate low-code configuration changes; High-code development client, used to receive source code writing operations from developers and generate high-code source code; A configuration code engine is used to convert low-code configuration changes into structured, traceable code and commit it to the Git version control system. Git is a version control system used to store a unified repository of low-code configuration code and high-code source code, generating an independent version record for each change. The unified project view generation module is used by the system to generate a unified project view based on the low-code configuration code and high-code source code in the Git repository, and to establish logical binding rules between the low-code configuration and the high-code source code. The decoupling module achieves a decoupled connection between low-code assets and high-code main applications through a combination of standard API calls and page embedding. A unified CI / CD pipeline engine is used to synchronize low-code configuration code and high-code source code in Git repositories, perform compilation testing and validity checks, and execute joint builds to generate complete application packages; The container operation and maintenance environment is used to receive and deploy the application package and incorporate it into the project-level full lifecycle management.

Images