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

Abstract

The present invention relates to the field of software development technology, and in particular to a low-code system supporting a full-scale code output function and a development method thereof. The development method of the low-code system supporting the full-scale code output function builds an independent operation center, configures the environment of the running state service, and exports data when the design state application is released; uses the application management package Helm technology to manage Kubernetes applications for the cloud environment, creates and starts the running state microservices; realizes independent operation of the running state by setting the static configuration of the running state in advance; adds a code output function to realize full-scale code output. The low-code system supporting the full-scale code output function and the development method thereof, by realizing the separation and independent operation of the design state and the running state, can not only quickly create and iterate applications, lower the development threshold, but also meet the diverse customization needs of customers.

Description

Technical Field

[0001] The present invention relates to the field of software development technology, and in particular to a low-code system supporting a full-code output function and a development method thereof. Background Art

[0002] With the development of low-code platforms, developers and non-developers can quickly create and iterate applications through visual development environments and pre-built components, which lowers the development threshold. Although low-code platforms provide the advantage of rapid development, in actual usage scenarios, there are many customization requirements, and common low-code platforms cannot meet customers' diverse customization needs.

[0003] At present, the industry has relatively mature solutions for front-end coding of low-code platforms, but there is no solution for back-end coding or full-scale coding with integrated front-end and back-end.

[0004] In order to realize the full-quantity code output solution of back-end code output and front-end and back-end integration, the present invention proposes a low-code system and a development method thereof that supports the full-quantity code output function. Summary of the invention

[0005] In order to remedy the defects of the prior art, the present invention provides a simple and efficient low-code system and a development method thereof that supports full-volume code output function.

[0006] The present invention is achieved through the following technical solutions:

[0007] A low-code system that supports full-scale code generation, supports microservice architecture and modular design, and decouples the design state and operation state into independent microservices; including a design center, an operation center, and an operation host;

[0008] The design center is responsible for implementing design and development, releasing application versions, and using the Abstract Syntax Tree (AST) to implement the code output function; the code output function and the application version release function share a set of data schemas to achieve full code output;

[0009] The operation center is responsible for using the template system to define deployment configuration files and environment variables, so that the same set of code can be flexibly deployed in different environments; at the same time, the dependent components, menus and view data are exported when the design state application is released;

[0010] The running host is responsible for managing Kubernetes applications using the application management package Helm technology for the cloud environment, creating and starting the running state microservices; by setting the static configuration required for the running state in advance, the running state can be run independently in the form of a container or on an independent virtual machine after obtaining the basic configuration information.

[0011] A method for developing a low-code system that supports full-volume code generation includes the following steps:

[0012] Step S1: Build an independent operation center, configure the environment of the operation state service, and export the dependent components, menus and view data when publishing the design state application;

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

[0014] By setting the static configuration required for the running state in advance, the running state can be run independently in the form of a container or on an independent virtual machine after obtaining the basic configuration information;

[0015] Step S3: Add a new code output function based on the independently deployed system. The code output function and the version release function of the design center share a set of data schema to achieve full code output.

[0016] In step S1, the operation center uses a template system to define the deployment configuration, supporting automatic generation of configuration files for different environments;

[0017] In the design state, the development and design of the application to be released is completed, and the corresponding application information is released to generate a release application package; the generated release application package is uploaded to the operation center and deployed to the corresponding operation host;

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

[0019] The corresponding export information is stored in a persistent file, including but not limited to application information, form information, and dictionary information.

[0020] In step S2, the design state and the running state are decoupled into independent microservices, and functional separation is achieved through the microservice architecture, thereby achieving independent deployment and maintenance of each service;

[0021] When the runtime is run independently in the form of a container, the application and dependencies are packaged into a container (such as the application container engine Docker) to ensure consistency and portability in different environments; the Kubernetes container orchestration tool is used to manage the deployment, expansion, and operation of the container to improve the reliability and scalability of the system;

[0022] For containerization and orchestration, the application management package Helm is used to start the service. The designed application image is published and saved. Then, the template file is written through the infrastructure template Helm chart (i.e., 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 by installing the Helm install command through the application management package Helm.

[0023] In step S2, when the running state is independently running in the form of an independent virtual machine, the remote virtual machine is automatically started or the running state application service is deployed in an automated operation and maintenance manner using the Ansible tool, supporting independent deployment;

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

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

[0026] In step S3, in order to ensure that the basic information of the version release function and the code output function of the design have the same data structure, the version release application package and the code output function of the design center share a set of data model Schema, which is extracted into a unified JSON model Schema (JSON model, a standard for defining JSON (JavaScript Object Notation) data structure), whose 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.

[0027] Each of these items is composed of different contents.

[0028] Among them, the root node of the form is the form identifier ID, and the content continues to be decomposed downward, including components, rules and printing information; the components continue to be decomposed downward, including component identifier ID, component attributes and associated dictionary information, thereby separating the logical structure and physical storage of the data, and forming the code and application release application package by extracting the logical structure of the data, and then importing the management and operation of the data by parsing the logical structure.

[0029] In step S3, the custom designed specific form and application information are exported to the application package, and the data is written into the code output template to generate a full amount of front-end and back-end code output;

[0030] Use module technology to replace variables and generate new output files based on the provided source code module combination.

[0031] In step S3, the front-end coding adopts the Lowcode-Engine technology, and the back-end coding adopts the mature template technology on the market, such as the template engine FreeMarker and the template engine Velocity; the module technology is used to replace the variables in the JSON mode Schema, and the new coding file is generated by combining the provided source code modules.

[0032] A computing device, comprising:

[0033] 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 are configured to be executed by the one or more processors, and the one or more programs include instructions for executing any of the above methods.

[0034] A readable storage medium, characterized in that: a computer program is stored on the readable storage medium, and the computer program implements the above method when executed by a processor.

[0035] The beneficial effect of the present invention is that the low-code system and development method that supports the full-scale coding function, by realizing the separation and independent operation of the design state and the running state, can not only quickly create and iterate applications and lower the development threshold, but also meet the diverse customization needs of customers. BRIEF DESCRIPTION OF THE DRAWINGS

[0036] In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings required for use in the embodiments or the description of the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of the present invention. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying creative work.

[0037] Attached Figure 1 This is a schematic diagram of the architecture of the development method of the low-code system that supports the full-code output function of the present invention. DETAILED DESCRIPTION

[0038] In order to enable those skilled in the art to better understand the technical solutions in the present invention, the technical solutions in the embodiments of the present invention will be clearly and completely described below in conjunction with the embodiments of the present invention. Obviously, the described embodiments are only a part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without creative work should fall within the scope of protection of the present invention.

[0039] The low-code platform is divided into design state and running state. The operation of the running state depends on the data of the design state, including component information, permissions, rules, configuration, etc., and the coupling is serious. Therefore, in order to achieve full code output, it is first necessary to realize the separation and independent operation of the design state and the running state. The most important thing is that the running state can be deployed and run independently after the design is completed. To achieve independent deployment of the running state, it is necessary to extract the common content and difference content required for the operation of different applications in the running state. Obviously, the common content is the function of the program itself, which can support the operation of the running state service; the difference content includes the configuration information and environment information that the program depends on when it starts.

[0040] This low-code system that supports full-scale code generation supports microservice architecture and modular design, decoupling the design state and operation state into independent microservices; including the design center, operation center and operation host;

[0041] The design center is responsible for implementing design and development, releasing application versions, and using the Abstract Syntax Tree (AST) to implement the code output function; the code output function and the application version release function share a set of data schemas to achieve full code output;

[0042] The operation center is responsible for using the template system to define deployment configuration files and environment variables, so that the same set of code can be flexibly deployed in different environments; at the same time, the dependent components, menus and view data are exported when the design state application is released;

[0043] The running host is responsible for managing Kubernetes applications using the application management package Helm technology for the cloud environment, creating and starting the running state microservices; by setting the static configuration required for the running state in advance, the running state can be run independently in the form of a container or on an independent virtual machine after obtaining the basic configuration information.

[0044] The development method of the low-code system supporting the full-volume code output function includes the following steps:

[0045] Step S1: Build an independent operation center, configure the environment of the operation state service, and export the dependent components, menus and view data when publishing the design state application;

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

[0047] By setting the static configuration required for the running state in advance, the running state can be run independently in the form of a container or on an independent virtual machine after obtaining the basic configuration information;

[0048] Step S3: Add a new code output function based on the independently deployed system. The code output function and the version release function of the design center share a set of data schema to achieve full code output.

[0049] In step S1, the operation center uses a template system to define the deployment configuration, supporting automatic generation of configuration files for different environments;

[0050] In the design state, the development and design of the application to be released is completed, and the corresponding application information is released to generate a release application package; the generated release application package is uploaded to the operation center and deployed to the corresponding operation host;

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

[0052] The corresponding export information is stored in a persistent file, including but not limited to application information, form information, and dictionary information.

[0053] In step S2, the design state and the running state are decoupled into independent microservices, and functional separation is achieved through the microservice architecture, thereby achieving independent deployment and maintenance of each service;

[0054] When the runtime is run independently in the form of a container, the application and dependencies are packaged into a container (such as the application container engine Docker) to ensure consistency and portability in different environments; the Kubernetes container orchestration tool is used to manage the deployment, expansion, and operation of the container to improve the reliability and scalability of the system;

[0055] For containerization and orchestration, the application management package Helm is used to start the service. The designed application image is published and saved. Then, the template file is written through the infrastructure template Helm chart (i.e., 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 by installing the Helm install command through the application management package Helm.

[0056] In step S2, when the running state is independently running in the form of an independent virtual machine, the remote virtual machine is automatically started or the running state application service is deployed in an automated operation and maintenance manner using the Ansible tool, supporting independent deployment;

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

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

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

[0060] In step S3, in order to ensure that the basic information of the version release function and the code output function of the design have the same data structure, the version release application package and the code output function of the design center share a set of data model Schema, which is extracted into a unified JSON model Schema (JSON model, a standard for defining JSON (JavaScript Object Notation) data structure), whose 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.

[0061] Each of these items is composed of different contents.

[0062] Among them, the root node of the form is the form identifier ID, and the content continues to be decomposed downward, including components, rules and printing information; the components continue to be decomposed downward, including component identifier ID, component attributes and associated dictionary information, thereby separating the logical structure and physical storage of the data, and forming the code and application release application package by extracting the logical structure of the data, and then importing the management and operation of the data by parsing the logical structure.

[0063] In step S3, the custom designed specific form and application information are exported to the application package, and the data is written into the code output template to generate a full amount of front-end and back-end code output;

[0064] Use module technology to replace variables and generate new output files based on the provided source code module combination.

[0065] In step S3, the front-end coding adopts the Lowcode-Engine technology, and the back-end coding adopts the mature template technology on the market, such as the template engine FreeMarker, the template engine Velocity, etc.; the module technology is used to replace the variables in the JSON mode Schema, and according to the provided source code module, a new coding file is generated by combining.

[0066] The computer-readable storage medium stores one or more programs, wherein the one or more programs include instructions, and when the instructions are executed by a computing device, the computing device performs any one of the above methods.

[0067] The computing device comprises:

[0068] 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 are configured to be executed by the one or more processors, and the one or more programs include instructions for executing any of the above methods.

[0069] The embodiment described above is only one specific implementation of the present invention. Common changes and substitutions made by those skilled in the art within the scope of the technical solution of the present invention should be included in the protection scope of the present invention.

Claims

1. A low-code system that supports full-volume code generation, characterized by: Support microservice architecture and modular design, decoupling the design state and operation state into independent microservices; Including design center, operation center and operation host; The design center is responsible for implementing design and development, releasing application versions, and implementing the code output function using the abstract syntax tree AST; The code generation function and the application version release function share a set of 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, so that the same set of code can be flexibly deployed in different environments; at the same time, the dependent components, menus and view data are exported when the design state application is released; The running host is responsible for managing Kubernetes applications using the application management package Helm technology for the cloud environment, creating and starting running microservices; By setting the static configuration required for the running state in advance, the running state can run independently in the form of a container or on an independent virtual machine after obtaining the basic configuration information.

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

3. The method for developing a low-code system supporting full-volume code generation according to claim 2, characterized in that: In step S1, the operation center uses a template system to define the deployment configuration, supporting automatic generation of configuration files for different environments; In the design state, the development and design of the application to be released is completed, and the corresponding application information is released to generate a release application package; The generated release application package is uploaded to the operation center and deployed to the corresponding operation host; Use configuration files or environment variables to manage the configuration of different deployment environments, so that the same set of code can be flexibly deployed in different environments; The corresponding export information is stored in a persistent file, including but not limited to application information, form information, and dictionary information.

4. The method for developing a low-code system supporting full-volume code generation according to claim 2, characterized in that: In step S2, the design state and the running state are decoupled into independent microservices, and functional separation is achieved through the microservice architecture, thereby achieving independent deployment and maintenance of each service; When the runtime runs independently in the form of containers, the application and dependencies are packaged into containers to ensure consistency and portability in different environments; the Kubernetes container orchestration tool is used to manage the deployment, expansion, and operation of containers to improve the reliability and scalability of the system; For containerization and orchestration, use the application management package Helm to start the service, publish the designed application image and save it, then write the template file through the infrastructure template Helm chart managed by the application management package Helm, pass in the name of the running service image to be deployed, and start the service through the application management package Helm installation Helm install command.

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

6. The method for developing a low-code system supporting full-volume code generation according to claim 2, characterized in that: In step S3, in order to ensure that the basic information of the version release function and the code output function of the design have the same data structure, the version release application package and the code output function of the design center share a set of data schemas, which are extracted into a unified JSON schema, whose root node is the application identifier ID, and the content includes forms, menus, static resources, tags, and roles, positions and dictionary information in the application; Among them, the root node of the form is the form identifier ID, and the content continues to be decomposed downward, including components, rules and printing information; the components continue to be decomposed downward, including component identifier ID, component attributes and associated dictionary information, thereby separating the logical structure and physical storage of the data, and forming the code and application release application package by extracting the logical structure of the data, and then importing the management and operation of the data by parsing the logical structure.

7. The method for developing a low-code system supporting full-volume code generation according to claim 2, characterized in that: In step S3, the custom designed specific form and application information are exported to the application package, and the data is written into the code output template to generate a full amount of front-end and back-end code output; Use module technology to replace variables and generate new output files based on the provided source code module combination.

8. The method for developing a low-code system supporting full-volume code generation according to claim 7, characterized in that: The front-end coding adopts Lowcode-Engine technology, and the back-end coding adopts mature template technology on the market, such as FreeMarker and Velocity. The module technology is used to replace the variables in the JSON schema, and the new coding file is generated based on the provided source code module.

9. A computer-readable storage medium storing one or more programs, characterized in that: The one or more programs include instructions which, when executed by a computing device, cause the computing device to perform any one 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 are configured to be executed by the one or more processors, and the one or more programs include instructions for executing any of the methods according to claims 2 to 8.

Images