Low-code system supporting full code generation function and development method therefor

Abstract

A low-code system supporting a full code generation function and a development method therefor, relating to the technical field of software development. The development method for the low-code system supporting the full code generation function comprises: building an independent operation center, configuring the environment of a running state service, and exporting data when a design state application is released; for a cloud environment, using application management package Helm technology to manage a Kubernetes application, and creating and starting a running state microservice; implementing independent operation of a running state by pre-setting static configuration of the running state runtime; and adding a code generation function to implement full code generation. The low-code system supporting the full code generation function and the development method therefor, implementing separation and independent operation of a design state and a running state, not only enable quick creation and iteration of an application and lower the development threshold, but also satisfy diverse customization requirements of customers.

Description

A low-code system supporting full code output and its development method

[0001] This application claims priority to Chinese Patent Application No. 202411419342.7, filed on October 12, 2024, entitled "A Low-Code System Supporting Full Code Output Function and Its Development Method", the entire contents of which are incorporated herein by reference. Technical Field

[0002] This invention relates to the field of software development technology, and in particular to a low-code system and its development method that supports full code output. Background Technology

[0003] With the development of low-code platforms, visual development environments and pre-built components enable both developers and non-developers to quickly create and iterate applications, lowering the development threshold. While low-code platforms offer the advantage of rapid development, in real-world use cases, there are many customization needs, and general-purpose low-code platforms cannot meet the diverse customization requirements of customers.

[0004] Currently, there are relatively mature solutions in the industry for front-end code generation on low-code platforms, but there are no solutions for back-end code generation or full code generation integrating front-end and back-end.

[0005] To achieve a full code generation solution that integrates backend and frontend / backend, this invention proposes a low-code system and its development method that supports full code generation. Summary of the Invention

[0006] To overcome the shortcomings of existing technologies, this invention provides a simple and efficient low-code system and its development method that supports full code output.

[0007] This invention is achieved through the following technical solution:

[0008] A low-code system that supports full code output, supports microservice architecture and modular design, and decouples the design state and runtime state into independent microservices; including a design center, a runtime center and a runtime host;

[0009] The design center is responsible for design and development, application version release, and code generation using an Abstract Syntax Tree (AST). The code generation function and the application version release function share a data schema to achieve full code generation.

[0010] The operation center is responsible for using the template system to define deployment configuration files and environment variables, enabling the same code to be flexibly deployed in different environments; at the same time, it exports dependent components, menus and view data when the application is published in design mode.

[0011] The running host is responsible for managing Kubernetes applications in the cloud environment using the application management package Helm technology, creating and starting runtime microservices; by pre-setting the static configurations required for runtime, the runtime can run as a container or independently on a separate virtual machine after obtaining basic configuration information.

[0012] A development method for a low-code system that supports full code output includes the following steps:

[0013] Step S1: Build an independent runtime center, configure the runtime service environment, and export the dependent components, menus, and view data when publishing the design-state application.

[0014] Step S2: Use the Helm application management package to manage Kubernetes applications in the cloud environment, and create and start running microservices;

[0015] By pre-setting the static configurations required for runtime, the runtime can run as a container or independently on a virtual machine after obtaining the basic configuration information;

[0016] Step S3: Add a code generation function to the independently deployed system. The code generation function and the version release function of the design center share the same data schema to achieve full code generation.

[0017] In step S1, the operation center uses a template system to define deployment configurations and supports the automated generation of configuration files for different environments.

[0018] In the design phase, the development and design of the application to be released are completed, and the corresponding application information is released to generate the release application package; the generated release application package is uploaded to the runtime center and deployed to the corresponding runtime host;

[0019] Use configuration files or environment variables to manage the configuration of different deployment environments (such as development, testing, and production), so that the same code can be flexibly deployed in different environments;

[0020] The exported information, including but not limited to application information, form information, and dictionary information, is stored in persistent files.

[0021] In step S2, the design state and runtime state are decoupled into independent microservices. Functional separation is achieved through microservice architecture, thereby enabling independent deployment and maintenance of each service.

[0022] When running independently as containers, the application and its dependencies are packaged into containers (such as the application container engine Docker) to ensure consistency and portability across different environments; Kubernetes container orchestration tools are used to manage the deployment, scaling, and operation of containers to improve system reliability and scalability.

[0023] For containerization and orchestration, the application management package Helm is used to start services. The designed application image is published and saved. Then, a template file is written using the Helm chart (in other words, a Helm diagram) infrastructure template managed by the application management package Helm, passing in the name of the running service image to be deployed. Finally, the service is started using the `Helm install` command from the application management package Helm.

[0024] In step S2, when the runtime state is running independently as an independent virtual machine, the Ansible tool is used to automatically start the remote virtual machine or deploy the runtime application service, supporting independent deployment.

[0025] First, configure the basic Ansible environment and control node in the deployment center; create Ansible Playbook script files for management, and create a virtual machine startup module for managing virtual machines; the host information in the file is dynamically adjusted according to the configuration center parameters;

[0026] Then, deploy the application service for the low-code standalone service, write the middleware (MariaDB, Minio, Nginx, Nacos) and application service module information for the low-code platform, and finally configure the Ansible Inventory manifest file and run the Ansible Playbook script file to automatically start and deploy the service.

[0027] In step S3, in order to ensure that the basic information of the release version function and the code generation function of the design center has the same data structure, the version release application package and the code generation function of the design center share a set of data schema, which is extracted into a unified JSON schema (JSON schema, a standard for defining JSON (JavaScript Object Notation) data structure). Its root node is the application identifier ID, and the content includes forms, menus, static resources, tags, and roles, positions and dictionary information within the application.

[0028] Each item is composed of its own distinct components.

[0029] The root node of the form is the form identifier ID. The content is further decomposed downwards, including components, rules, and printing information. The components are further decomposed, including component identifier ID, component attributes, and associated dictionary information. This separates the logical structure of the data from its physical storage. The logical structure of the data is extracted to form the output code and application release package. Then, by parsing the logical structure, the management and operation of the data are imported.

[0030] In step S3, the custom-designed specific forms and application information are exported to the application package, and the data is written into the code output template to generate a full set of front-end and back-end codes.

[0031] Variable substitution is performed using module technology, and new output files are generated by combining the provided source code modules.

[0032] In step S3, the front-end code generation uses Lowcode-Engine technology, and the back-end code generation uses mature template technologies such as FreeMarker and Velocity. Module technology is used to replace variables in the JSON schema and generate new code files based on the provided source code modules.

[0033] A computing device, comprising:

[0034] One or more processors, one or more memories, and one or more programs, wherein the one or more programs are stored in the one or more memories and configured to be executed by the one or more processors, and the one or more programs include instructions for performing any of the methods described above.

[0035] A readable storage medium storing a computer program that, when executed by a processor, implements the method described above.

[0036] The beneficial effects of this invention are: the low-code system and its development method that support full code output function, by realizing the separation and independent operation of design state and runtime state, can not only quickly create and iterate applications and reduce the development threshold, but also meet the diverse customization needs of customers. Attached Figure Description

[0037] 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 some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0038] Figure 1 is a schematic diagram of the development method architecture of the low-code system that supports full code output function according to the present invention. Detailed Implementation

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

[0040] Low-code platforms are divided into design state and runtime state. The runtime state depends on data from the design state, including component information, permissions, rules, and configurations, resulting in severe coupling. Therefore, to achieve full code output, it is first necessary to separate and allow independent operation of the design and runtime states. Most importantly, the runtime state should be able to be deployed and run independently after the design is completed. Achieving independent deployment of the runtime state requires extracting the common and differential content required by different applications running in the runtime state. Clearly, the common content is the functionality of the program itself, which supports the operation of runtime services; the differential content includes configuration information and environment information that the program depends on when it starts up.

[0041] This low-code system, which supports full code output, supports microservice architecture and modular design, decoupling the design state and runtime state into independent microservices; including a design center, a runtime center, and a runtime host;

[0042] The design center is responsible for design and development, application version release, and code generation using an Abstract Syntax Tree (AST). The code generation function and the application version release function share a data schema to achieve full code generation.

[0043] The operation center is responsible for using the template system to define deployment configuration files and environment variables, enabling the same code to be flexibly deployed in different environments; at the same time, it exports dependent components, menus and view data when the application is published in design mode.

[0044] The running host is responsible for managing Kubernetes applications in the cloud environment using the application management package Helm technology, creating and starting runtime microservices; by pre-setting the static configurations required for runtime, the runtime can run as a container or independently on a separate virtual machine after obtaining basic configuration information.

[0045] The development method for this low-code system that supports full code output includes the following steps:

[0046] Step S1: Build an independent runtime center, configure the runtime service environment, and export the dependent components, menus, and view data when publishing the design-state application.

[0047] Step S2: Use the Helm application management package to manage Kubernetes applications in the cloud environment, and create and start running microservices;

[0048] By pre-setting the static configurations required for runtime, the runtime can run as a container or independently on a virtual machine after obtaining the basic configuration information;

[0049] Step S3: Add a code generation function to the independently deployed system. The code generation function and the version release function of the design center share the same data schema to achieve full code generation.

[0050] In step S1, the operation center uses a template system to define deployment configurations and supports the automated generation of configuration files for different environments.

[0051] In the design phase, the development and design of the application to be released are completed, and the corresponding application information is released to generate the release application package; the generated release application package is uploaded to the runtime center and deployed to the corresponding runtime host;

[0052] Use configuration files or environment variables to manage the configuration of different deployment environments (such as development, testing, and production), so that the same code can be flexibly deployed in different environments;

[0053] The exported information, including but not limited to application information, form information, and dictionary information, is stored in persistent files.

[0054] In step S2, the design state and runtime state are decoupled into independent microservices. Functional separation is achieved through microservice architecture, thereby enabling independent deployment and maintenance of each service.

[0055] When running independently as containers, the application and its dependencies are packaged into containers (such as the application container engine Docker) to ensure consistency and portability across different environments; Kubernetes container orchestration tools are used to manage the deployment, scaling, and operation of containers to improve system reliability and scalability.

[0056] For containerization and orchestration, the application management package Helm is used to start the service. The designed application is published as an image and saved. Then, a template file is written using the infrastructure template Helm chart (i.e., Helm diagram) managed by the application management package Helm, and the name of the running service image to be deployed is passed in. The service is started by using the Helm install command of the application management package Helm.

[0057] In step S2, when the runtime state is running independently as an independent virtual machine, the Ansible tool is used to automatically start the remote virtual machine or deploy the runtime application service, supporting independent deployment.

[0058] First, configure the basic Ansible environment and control node in the deployment center; create Ansible Playbook script files for management, and create a virtual machine startup module for managing virtual machines; the host information in the file is dynamically adjusted according to the configuration center parameters;

[0059] Then, deploy the application service for the low-code standalone service, write the middleware (MariaDB, Minio, Nginx, Nacos) and application service module information for the low-code platform, and finally configure the Ansible Inventory manifest file and run the Ansible Playbook script file to automatically start and deploy the service.

[0060] In this design, the schema plays a central role. The data schema is a description of the logical structure and characteristics of the data, and it defines the data items, security, and integrity rules.

[0061] In step S3, in order to ensure that the basic information of the release version function and the code generation function of the design center has the same data structure, the version release application package and the code generation function of the design center share a set of data schema, which is extracted into a unified JSON schema (JSON schema, a standard for defining JSON (JavaScript Object Notation) data structure). Its root node is the application identifier ID, and the content includes forms, menus, static resources, tags, and roles, positions and dictionary information within the application.

[0062] Each item is composed of its own distinct components.

[0063] The root node of the form is the form identifier ID. The content is further decomposed downwards, including components, rules, and printing information. The components are further decomposed, including component identifier ID, component attributes, and associated dictionary information. This separates the logical structure of the data from its physical storage. The logical structure of the data is extracted to form the output code and application release package. Then, by parsing the logical structure, the management and operation of the data are imported.

[0064] In step S3, the custom-designed specific forms and application information are exported to the application package, and the data is written into the code output template to generate a full set of front-end and back-end codes.

[0065] Variable substitution is performed using module technology, and new output files are generated by combining the provided source code modules.

[0066] In step S3, the front-end code generation uses Lowcode-Engine technology, and the back-end code generation uses mature template technologies such as FreeMarker and Velocity. Module technology is used to replace variables in the JSON schema and generate new code files based on the provided source code modules.

[0067] The computer-readable storage medium stores one or more programs, the one or more programs including instructions that, when executed by a computing device, cause the computing device to perform any of the methods described above.

[0068] The computing device includes:

[0069] One or more processors, one or more memories, and one or more programs, wherein the one or more programs are stored in the one or more memories and configured to be executed by the one or more processors, and the one or more programs include instructions for performing any of the methods described above.

[0070] The embodiments described above are merely one specific implementation of the present invention. Ordinary changes and substitutions made by those skilled in the art within the scope of the technical solution of the present invention should be included within the protection scope of the present invention.

Claims

1. A low-code system supporting full code output, characterized in that: It supports microservice architecture and modular design, decoupling the design state and runtime state into independent microservices; Includes a design center, an operations center, and a mainframe; The design center is responsible for design and development, releasing application versions, and using Abstract Syntax Tree (AST) to implement code generation functionality. The code generation function and the application version release function share the same data schema to achieve full code generation; The operation center is responsible for using the template system to define deployment configuration files and environment variables, enabling the same code to be flexibly deployed in different environments; at the same time, it exports dependent components, menus and view data when the application is published in design mode. The running host is responsible for managing Kubernetes applications in the cloud environment using the Helm application management package technology, and for creating and starting running microservices. By pre-setting the static configurations required for runtime, the runtime can run as a container or independently on a virtual machine after obtaining basic configuration information.

2. A development method for a low-code system supporting full code output, characterized in that: Includes the following steps: Step S1: Build an independent runtime center, configure the runtime service environment, and export the dependent components, menus, and view data when publishing the design-state application. Step S2: Use the Helm application management package to manage Kubernetes applications in the cloud environment, and create and start running microservices; By pre-setting the static configurations required for runtime, the runtime can run as a container or independently on a virtual machine after obtaining the basic configuration information; Step S3: Add a code generation function to the independently deployed system. The code generation function and the version release function of the design center share the same data schema to achieve full code generation.

3. The development method of a low-code system supporting full code output function according to claim 2, characterized in that: In step S1, the operation center uses a template system to define deployment configurations and supports the automated generation of configuration files for different environments. Complete the development and design of the application to be released in the design phase, publish the corresponding application information, and generate the release application package; The generated application package is uploaded to the runtime center and deployed to the corresponding runtime host; Use configuration files or environment variables to manage the configuration of different deployment environments, so that the same code can be flexibly deployed in different environments; The exported information, including but not limited to application information, form information, and dictionary information, is stored in persistent files.

4. The development method of a low-code system supporting full code output function according to claim 2, characterized in that: In step S2, the design state and runtime state are decoupled into independent microservices. Functional separation is achieved through microservice architecture, thereby enabling independent deployment and maintenance of each service. When running independently as containers, the application and its dependencies are packaged into containers to ensure consistency and portability across different environments; Kubernetes container orchestration tools are used to manage the deployment, scaling, and operation of containers to improve system reliability and scalability. For containerization and orchestration, the application management package Helm is used to start the service. The designed application is published as an image and saved. Then, a template file is written using the infrastructure template Helm chart managed by the application management package Helm, and the name of the running service image to be deployed is passed in. The service is started using the application management package Helm install command.

5. The development method of a low-code system supporting full code output function according to claim 2 or 4, characterized in that: In step S2, when the runtime state is running independently as an independent virtual machine, the Ansible tool is used to automatically start the remote virtual machine or deploy the runtime application service, supporting independent deployment. First, configure the basic Ansible environment and control node in the deployment center; create Ansible Playbook script files for management, and create a virtual machine startup module for managing virtual machines; the host information in the file is dynamically adjusted according to the configuration center parameters; Then, deploy the application service for the low-code standalone service, write the middleware and application service module information for the low-code platform, and finally configure the Ansible Inventory manifest file and run the Ansible Playbook script file to automatically start the deployment service.

6. The development method of a low-code system supporting full code output function according to claim 2, characterized in that: In step S3, in order to ensure that the basic information of the release version function and the code generation function of the design center has the same data structure, the version release application package and the code generation function of the design center share a set of data schema, which is extracted into a unified JSON schema. Its root node is the application identifier ID, and the content includes forms, menus, static resources, tags, and roles, positions and dictionary information within the application. The root node of the form is the form identifier ID. The content is further decomposed downwards, including components, rules, and printing information. The components are further decomposed, including component identifier ID, component attributes, and associated dictionary information. This separates the logical structure of the data from its physical storage. The logical structure of the data is extracted to form the output code and application release package. Then, by parsing the logical structure, the management and operation of the data are imported.

7. The development method of a low-code system supporting full code output function according to claim 2, characterized in that: In step S3, the custom-designed specific forms and application information are exported to the application package, and the data is written into the code output template to generate a full set of front-end and back-end codes. Variable substitution is performed using module technology, and new output files are generated by combining the provided source code modules.

8. The development method of a low-code system supporting full code output function according to claim 7, characterized in that: The front-end code generation uses Lowcode-Engine technology, while the back-end code generation uses mature template technologies such as FreeMarker and Velocity. Module technology is used to replace variables in the JSON schema and generate new code files based on the provided source code modules.

9. A computer-readable storage medium for storing one or more programs, characterized in that: The one or more programs include instructions that, when executed by a computing device, cause the computing device to perform any of the methods according to claims 2 to 8.

10. A computing device, characterized in that, include: One or more processors, one or more memories, and one or more programs, wherein the one or more programs are stored in the one or more memories and configured to be executed by the one or more processors, the one or more programs including instructions for performing any of the methods according to claims 2 to 8.

Images