Low-code implementation method and device supporting continuous generation of production environment and computer system

Abstract

The invention provides a low-code implementation method and device supporting continuous generation of a production environment and a computer system, and relates to the technical field of computer software development. The method comprises the steps of receiving an update instruction in a production environment and generating a source code; if the code is the front-end code, a new version resource bundle is generated through real-time packaging at a server side, and an old bundle is covered in a non-inductive mode through atomization replacement operation; and if the code is the back-end code, performing dynamic compiling to generate a byte code, and loading the new logic to the running process by utilizing a hot loading mechanism. According to the method, a traditional offline generation mode is broken through, continuous generation and dynamic updating of the production environment are achieved on the premise that service is not restarted, the service continuity is effectively guaranteed, and the iteration efficiency of low-code application is remarkably improved.

Description

Technical Field

[0001] This invention relates to the field of computer software development and technology, specifically to a low-code implementation method, apparatus, and computer system that supports continuous production environment generation. Background Technology

[0002] With the acceleration of enterprise digital transformation, low-code development platforms have greatly improved software application development efficiency due to their ability to quickly build business logic and data models through graphical interfaces and configurable methods, and automatically generate front-end and back-end code. In the traditional low-code development lifecycle, code generation is usually regarded as a one-time or offline action during the development phase. Once the application is first developed, compiled, packaged, and deployed to the production environment, its software architecture and functional logic are in a relatively static state.

[0003] However, in actual production operations, with rapidly changing business needs, applications often face frequent demands for feature iteration, logic correction, or interface adjustments. Under the existing technology framework, there are typically two main methods to synchronize changes from the low-code platform to the production environment. The first is a full redeployment model, where developers modify the design on the low-code platform, regenerate the entire source code, and then use a standard continuous integration / continuous deployment (CI / CD) process to build a new software package (such as a front-end static resource package or a back-end JAR / WAR package) and push it to the server. This method usually requires stopping the currently running service processes, replacing files, and then restarting the service when deploying a new version. This inevitably leads to interruptions in business services, affecting system availability and user experience, and cannot meet the needs of high-frequency agile iteration.

[0004] The second type is the manual maintenance mode for secondary development scenarios. In many practical applications, developers manually modify the low-code generated code to meet specific customization needs. When the business model changes and the low-code platform needs to generate code again, the newly generated code often overwrites or conflicts with the previously manually modified parts. Developers must perform complex code comparison and merging operations, a process that is not only time-consuming, labor-intensive, and error-prone, but also severely restricts the low-code platform's ability to continuously evolve after the application is launched.

[0005] In summary, existing low-code deployment and update technologies mainly rely on offline code generation and static compilation and deployment processes. They lack the ability to dynamically generate, compile, and seamlessly update application logic and interfaces while running in a production environment, making it difficult to achieve efficient and continuous application iteration while ensuring business continuity. Summary of the Invention

[0006] The purpose of this invention is to provide a low-code implementation method, apparatus, and computer system that supports continuous generation in a production environment. It has the ability to dynamically generate, compile, and seamlessly update application logic and interface while running in a production environment, which can achieve efficient continuous iteration of applications while ensuring business continuity, thus solving the above-mentioned technical problems.

[0007] To achieve the above objectives, the present invention provides the following technical solution: A low-code implementation method supporting continuous production environment generation, the method being applied to a system consisting of a low-code platform, a front-end runtime environment, and a back-end runtime environment, the method comprising the following steps: S1: Receive an update instruction for the target application, the update instruction containing metadata definitions generated based on user changes; S2: In response to the update command in the production environment, the code generation engine is invoked to generate the corresponding source code based on the metadata definition; S3: Execute the corresponding runtime dynamic update process according to the type of the source code; If the source code is front-end source code, the server calls the build tool to package the front-end source code in real time to generate a new version of the resource package, and uses atomic replacement operation to replace the currently running old version of the resource package with the new version of the resource package. If the source code is backend source code, the backend source code is dynamically compiled to generate bytecode files, and the bytecode files are loaded into the running application process using a hot loading mechanism to update the business logic without restarting the application process.

[0008] Further: the step of calling the build tool on the server side to package the front-end source code in real time to generate a new resource package includes: Monitor the source code directory in the front-end runtime environment, and trigger the runtime packaging module when the front-end source code is detected to be written; The runtime packaging module calls the built-in build tool API to perform incremental or full builds on the front-end source code based on the existing front-end project dependencies, and outputs the new resource package containing static resources.

[0009] Further: The step of replacing the currently running old version resource package with the new version resource package using atomic replacement operation includes: Generate the new resource package to the specified directory or temporary directory; After ensuring the complete construction of the new resource package, the target of service requests can be instantly switched from the old resource package to the new resource package by renaming the directory or modifying the symbolic links, so as to achieve seamless updates of the front-end service.

[0010] Further: The step of dynamically compiling the backend source code to generate bytecode files includes: Monitor the source code directory in the backend runtime environment, and trigger the dynamic compilation module when the backend source code is detected to be written. The dynamic compilation module calls the compiler interface built into the programming language to compile the backend source code into binary bytecode files and output them to the specified classpath.

[0011] Further: The method of loading the bytecode file into the running application process using the hot-loading mechanism includes: Monitor changes to bytecode files in the classpath using a custom class loader; When a new or modified bytecode file is detected, a new class loader object is instantiated to load the bytecode file, thereby generating a new class definition in memory and achieving isolation or replacement from the old version of the class.

[0012] Furthermore: the application process runs in a framework with a dependency injection container, and the step of loading the bytecode file into the running application process using a hot-loading mechanism further includes: After the new class definition is loaded, the registry of the dependency injection container is manipulated to unregister the old component definition and register the new component definition. Refresh the application context so that the system can create instances based on the new component definitions and inject them into the business process.

[0013] The present invention also provides a low-code implementation device that supports continuous production environment generation, deployed in a production environment, the device comprising: The control module is used to receive update instructions for a target application, the update instructions including metadata definitions generated based on user changes; and to call the code generation engine to generate corresponding source code based on the metadata definitions; The front-end update module is used to call the build tool interface on the server side to package the front-end source code in real time to generate a new version of the resource package when the generated source code is the front-end source code, and to replace the currently running old version of the resource package with the new version of the resource package using atomic replacement operation; The backend update module is used to dynamically compile the backend source code to generate bytecode files when the generated source code is backend source code, and to load the bytecode files into the running application process using a hot loading mechanism.

[0014] The present invention also provides a computer system, comprising: A low-code platform is used to provide a visual design environment and generate the update instructions; A production server for running the apparatus as described in claim 7, and for hosting the front-end runtime environment and the back-end runtime environment; The low-code platform is connected to the production server via a network, and pushes the update instructions to the production server in real time to trigger continuous generation and updates.

[0015] Compared with the prior art, the present invention has the following advantages: I. This invention enables uninterrupted dynamic updates in a production environment, ensuring business continuity. Existing technologies typically require stopping the service process, replacing files, and restarting the service during version updates, leading to business interruptions. This invention, through dynamic compilation and class loader-based hot reloading mechanisms on the backend, dynamically injects new business logic (bytecode) into runtime memory without restarting the application process (such as the JVM). Simultaneously, the frontend employs server-side real-time packaging and atomic replacement operations (such as directory renaming or symbolic link switching) to ensure the integrity and consistency of user-accessed resources. The combination of these two mechanisms allows applications to iterate or fix features without experiencing the traditional "downtime maintenance" window, achieving truly seamless updates and significantly improving system availability and user experience.

[0016] Second, it significantly improves the iteration efficiency and response speed of low-code applications. Traditional low-code development relies on a long chain process of "local / development environment generation - full packaging - upload and deployment," and is easily limited by the complexity of manual code merging. This invention brings the capabilities of code generation, compilation, and packaging down to the production environment runtime, building a real-time update channel from the low-code designer to the production server. For changes in metadata, the system can automatically trigger incremental build and hot deployment processes, shortening the feature launch cycle from the traditional hours or even days to minutes or even seconds, thereby enabling rapid response to rapidly changing business needs.

[0017] Third, it breaks the limitations of "offline generation" in low-code platforms, enabling continuous evolution throughout the entire lifecycle. This invention changes the traditional low-code platform's "static maintenance" cycle after application deployment. By introducing generation and deployment control services into the production environment, it ensures a real-time, strong correlation between the low-code model (metadata) and the runtime code implementation. This not only avoids inconsistencies between code and the environment caused by offline generation but also empowers deployed applications with the ability to continuously evolve, enabling them to adapt to best practices in agile development and DevOps. Attached Figure Description

[0018] Figure 1 This is a flowchart illustrating a method for supporting continuous low-code generation in a production environment according to an embodiment of the present invention. Figure 2 This is a schematic diagram of the system architecture according to an embodiment of the present invention; Figure 3 This is a flowchart of the dynamic update of the front-end during runtime in step S3 of this embodiment of the invention. Detailed Implementation

[0019] The technical solution of the present invention will now be clearly and completely described with reference to the accompanying drawings. Obviously, the described embodiments are only some, not all, of the embodiments of the present invention. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0020] This invention provides a low-code implementation method, apparatus, and system that supports continuous generation in production environments, aiming to solve the problem that existing low-code platforms cannot continuously iterate without interrupting services after application deployment.

[0021] The system architecture in this embodiment mainly consists of two parts: a low-code platform and a production environment. The low-code platform, serving as the development end, includes a designer, a metadata storage module, and a code generation engine. The designer allows users to design the application's interface and business logic visually (e.g., dragging and dropping components, configuring properties); the metadata storage module stores the application's design information, such as page structure trees, component property configurations, and data model definitions; and the code generation engine is responsible for generating standard front-end source code (e.g., Vue, React files) and back-end source code (e.g., Java source code) based on this metadata.

[0022] like Figure 2 As shown, the production environment is the server environment where the application actually runs. In this embodiment, a critical build and deployment control service, along with supporting front-end and back-end runtime environments, are deployed in the production environment. The build and deployment control service acts as a bridge between the low-code platform and the production runtime, responsible for receiving update instructions and coordinating subsequent build and update processes. The front-end runtime environment, in addition to including a traditional static resource server (such as Nginx), also integrates a runtime packaging module and a distribution and overriding module. The runtime packaging module has built-in API interfaces for front-end build tools (such as Webpack or Vite), enabling it to monitor specific directories and execute build tasks; the distribution and overriding module is responsible for file-level replacement operations. The back-end runtime environment runs the application's main program (such as a Spring Boot application) and integrates a dynamic compilation module and a hot-loading module. The dynamic compilation module uses the compiler interface built into the programming language (such as the JavaCompiler API) to convert source code into bytecode; the hot-loading module implements dynamic loading and replacement of classes based on a custom class loader mechanism.

[0023] Based on the above system architecture, the method flow of this embodiment is as follows: like Figure 1 As shown, firstly, S1: Receive an update instruction for the target application, which includes metadata definitions generated based on user changes. Specifically, the user completes modifications to the target application in the designer of the low-code platform. For example, the user adds a "Submit for Review" button to an existing form page and configures a corresponding click event for this button; simultaneously, the user adds a new business processing logic called "Review Service" in the backend logic. After the user clicks "Publish," the designer saves the changed metadata and generates an update instruction containing these change definitions.

[0024] S2: In response to the update command in the production environment, the code generation engine is invoked to generate the corresponding source code based on the metadata definition. Specifically, the production environment's build and deployment control service receives the update command. This service first parses the command and identifies that the changes involve both the front-end and back-end.

[0025] S3: Execute the corresponding runtime dynamic update process according to the type of the source code.

[0026] Specifically, such as Figure 3 As shown, for the front-end changes, the generation and deployment control service calls the code generation engine to generate the corresponding front-end source code files, such as a new Vue component file and an updated route configuration file. These source codes are then transferred to the specified source code directory in the front-end runtime environment. Upon detecting file write events in this directory, the runtime packaging module immediately triggers the build process. Unlike traditional local packaging, this module directly calls the build tool's API on the server side, performing incremental or full builds on the newly added source code based on existing project dependencies (node_modules) on the server. After the build is complete, a new static resource package (dist_new) is generated in a specified or temporary path. At this point, the distribution and overriding module intervenes, performing an atomic replacement operation. Specifically, this module uses operating system-level commands to instantly change the directory name or symbolic link that originally pointed to the old resource package (dist) to point to the new resource package (dist_new). Because renaming or symbolic link switching is an atomic operation, at the moment of switching, user requests either access the old resource or the new resource, avoiding access to intermediate state files. The user will see the newly added "Submit for Review" button on the next request in the browser or when receiving a push notification via WebSocket and refreshing a local component. The entire process does not require restarting the Nginx service.

[0027] For the backend changes, the code generation engine generates corresponding backend source code files, such as "AuditService.java" and "AuditController.java". These files are transferred to the source code monitoring directory of the backend runtime environment. Upon detecting the new files, the dynamic compilation module calls the JavaCompiler API to compile these .java files into corresponding .class bytecode files in memory or a temporary directory. After compilation, the hot-loading module begins its work. This module loads these new bytecode files using a custom class loader. In Spring-based applications, the hot-loading module not only loads classes but also manipulates the Spring context (ApplicationContext). It utilizes the BeanDefinitionRegistry interface to unregister old bean definitions (if they exist) and register new bean definitions, subsequently triggering a partial refresh of the context. In this way, the new "audit service" is instantiated and injected into the application's dependency network. The application's main program can immediately respond to calls to the new interface without restarting the JVM process.

[0028] In another embodiment, the present invention also provides a low-code implementation apparatus that supports continuous production environment generation, deployed in a production environment, the apparatus comprising: The control module is used to receive update instructions for a target application, the update instructions including metadata definitions generated based on user changes; and to call the code generation engine to generate corresponding source code based on the metadata definitions; The front-end update module is used to call the build tool on the server side to package the front-end source code in real time to generate a new version of the resource package when the generated source code is the front-end source code, and to replace the currently running old version of the resource package with the new version of the resource package using atomic replacement operation; The backend update module is used to dynamically compile the backend source code to generate bytecode files when the generated source code is backend source code, and to load the bytecode files into the running application process using a hot loading mechanism.

[0029] In summary, this embodiment, by building a runtime environment with dynamic compilation, real-time packaging, and hot reloading capabilities on the production environment side, and in conjunction with the instruction-driven low-code platform, achieves continuous generation and seamless updates throughout the entire application lifecycle, effectively solving the business interruption and maintenance problems of traditional deployment models.

[0030] The above embodiments are only for illustrating the technical concept and features of the present invention, and are intended to enable those skilled in the art to understand the content of the present invention and implement it accordingly. They should not be construed as limiting the scope of protection of the present invention. All equivalent transformations or modifications made in accordance with the spirit and essence of the present invention should be covered within the scope of protection of the present invention.

Claims

1. A low-code implementation method that supports continuous production environment generation, characterized in that, The method is applied to a system consisting of a low-code platform, a front-end runtime environment, and a back-end runtime environment, and the method includes the following steps: S1: Receive an update instruction for the target application, the update instruction containing metadata definitions generated based on user changes; S2: In response to the update command in the production environment, the code generation engine is invoked to generate the corresponding source code based on the metadata definition; S3: Execute the corresponding runtime dynamic update process according to the type of the source code; If the source code is front-end source code, the server calls the build tool interface to package the front-end source code in real time to generate a new resource package, and uses atomic replacement operation to replace the currently running old resource package with the new resource package. If the source code is backend source code, the backend source code is dynamically compiled to generate bytecode files, and the bytecode files are loaded into the running application process using a hot loading mechanism to update the business logic without restarting the application process.

2. The method according to claim 1, characterized in that, The step of calling the build tool interface on the server side to package the front-end source code in real time to generate a new resource package includes: Monitor the source code directory in the front-end runtime environment, and trigger the runtime packaging module when the front-end source code is detected to be written; The runtime packaging module calls the built-in build tool API to perform incremental or full builds on the front-end source code based on the existing front-end project dependencies, and outputs the new resource package containing static resources.

3. The method according to claim 1, characterized in that, The process of replacing the currently running old version of the resource package with the new version using atomic replacement operations includes: Generate the new resource package to the specified directory or temporary directory; After ensuring the complete construction of the new resource package, the target of service requests can be instantly switched from the old resource package to the new resource package by renaming the directory or modifying the symbolic links, so as to achieve seamless updates of the front-end service.

4. The method according to claim 1, characterized in that, The dynamic compilation of the backend source code to generate bytecode files includes: Monitor the source code directory in the backend runtime environment, and trigger the dynamic compilation module when the backend source code is detected to be written. The dynamic compilation module calls the compiler tools built into the programming language to compile the backend source code into binary bytecode files and output them to the specified classpath.

5. The method according to claim 1, characterized in that, The process of loading the bytecode file into the running application process using a hot-loading mechanism includes: Monitor changes to bytecode files in the classpath using a custom class loader; When a new or modified bytecode file is detected, a new class loader object is instantiated to load the bytecode file, thereby generating a new class definition in memory and achieving isolation or replacement from the old version of the class.

6. The method according to claim 5, characterized in that, The application process runs in a framework with a dependency injection container, and the step of loading the bytecode file into the running application process using a hot-loading mechanism further includes: After the new class definition is loaded, the registry of the dependency injection container is manipulated to unregister the old component definition and register the new component definition. Refresh the application context so that the system can create instances based on the new component definitions and inject them into the business process.

7. A low-code implementation device that supports continuous production environment generation, characterized in that, Deployed in a production environment, the device includes: The control module is used to receive update instructions for a target application, the update instructions including metadata definitions generated based on user changes; and to call the code generation engine to generate corresponding source code based on the metadata definitions; The front-end update module is used to call the build tool on the server side to package the front-end source code in real time to generate a new version of the resource package when the generated source code is the front-end source code, and to replace the currently running old version of the resource package with the new version of the resource package using atomic replacement operation; The backend update module is used to dynamically compile the backend source code to generate bytecode files when the generated source code is backend source code, and to load the bytecode files into the running application process using a hot loading mechanism.

8. A computer system, characterized in that, include: A low-code platform is used to provide a visual design environment and generate the update instructions; A production server for running the apparatus as described in claim 7, and for hosting the front-end runtime environment and the back-end runtime environment; The low-code platform is connected to the production server via a network, and pushes the update instructions to the production server in real time to trigger continuous generation and updates.

Images