A project building method and system based on a low-code platform

Abstract

This invention relates to the field of project building technology, specifically disclosing a project building method and system based on a low-code platform. The method includes receiving project requirements input by a user; creating a database based on the project requirements to receive and expand the data pairs input by the user; matching UI components for any tag in the project requirements according to the data structure of the data pairs in the database; combining the matched UI components to determine the UI interaction interface; matching and executing code for any tag in the project requirements according to the data pairs in the database in a preset code library; and feeding back the UI interaction interface and the final code to the user. This invention receives project requirements input by a user, creates a database based on the project requirements, statistically analyzes the input and output corresponding to each requirement, and then matches the UI interaction interface and the executing code, feeding it back to the user to complete the data processing requirements. This process only requires the user to perform input operations, making the operation extremely simple.

Description

Technical Field

[0001] This invention relates to the field of project setup technology, specifically a project setup method and system based on a low-code platform. Background Technology

[0002] Low-code platforms are technical tools that enable rapid application development, improving development efficiency. Most mainstream low-code platforms use visual configuration methods, reducing manual coding and allowing users to quickly build applications through graphical drag-and-drop and parameterized configuration. This is suitable for scenarios such as data management and business logic processing. While this approach is somewhat similar to VB, it still requires users to have some programming skills. With the widespread adoption of smart devices, some users only have the data to process but lack advanced programming abilities. This necessitates a simpler code development platform. The technical problem this invention aims to solve is how to further simplify the code generation process based on existing technologies. Summary of the Invention

[0003] The purpose of this invention is to provide a project building method and system based on a low-code platform to solve the problems mentioned in the background art.

[0004] To achieve the above objectives, the present invention provides the following technical solution: A method for building a project based on a low-code platform, the method comprising: The system receives project requirements input by the user and creates a database based on these requirements to receive and expand the data pairs input by the user. The project requirements are a tree-structured set of tags, with each tag corresponding to a database. For any tag in the project requirements, match UI components based on the data structure of the data pairs in the database, combine the matched UI components, and determine the UI interaction interface; For any tag in the project requirements, the code is matched and executed in a pre-defined code library based on the data in the database. When the match fails, the data pair is virtualized, and the code is obtained based on the virtualized data. The virtualization process is uniquely mapped to the user. All execution code is simplified, and the simplified code is used as the final code. The UI interaction interface, the final code, and the virtualization process are then fed back to the user. When users apply the final code, they build a supplementary database based on the virtualization process; the supplementary database serves as a source for code updates.

[0005] As a further aspect of the present invention: the step of receiving project requirements input by the user, creating a database based on the project requirements, and receiving and expanding the data pairs input by the user includes: Receive project requirements input from the user; The tags are queried sequentially according to the tree structure traversal order, and information retrieval requests are sent to the user. Receive user input of demand inputs and mapping relationships indexed by tags, determine the demand outputs based on the mapping relationships, and create data pairs of demand inputs and outputs; Expand the demand input, determine the demand output of the expanded demand input according to the mapping relationship, create data pairs of demand input and demand output, and randomly rearrange all data pairs.

[0006] As a further aspect of the present invention: the step of matching UI components based on the data structure of data pairs in the database for any tag in the project requirements, and combining the matched UI components to determine the UI interaction interface includes: For any tag in the project requirements, read its corresponding database; Query the database to obtain the required input data structure and the required output data structure; Match UI component pairs from a pre-defined UI component library based on the data structure; The UI components of each label are combined to obtain the UI interactive interface.

[0007] As a further aspect of the present invention: for any tag in the project requirements, matching and executing code in a preset code library based on data pairs in the database; when matching fails, virtualizing the data pairs; and obtaining the executing code based on the virtualized data, the steps include: For any tag in the project requirements, the system iterates through the preset code library based on the data in the database and matches and executes the code. When a match fails, the data pair is read from the database, the user's information is queried, the virtualization model is determined based on the user information, and the data pair is transcoded based on the virtualization model to obtain a virtual data pair. Send virtual data to a third party and receive processing code in response to the third party; The virtualization model is used as a pre-processing process for the code, and the inverse process of the virtualization model is used as a post-processing process for the code, resulting in the executable code.

[0008] As a further aspect of the present invention: the step of simplifying all executable code, using the simplified code as the final code, and feeding back the UI interface, the final code, and the virtualization process to the user includes: Analyze all executed code and locate the calling code and its calling libraries within the executed code; Compare the calling libraries and, based on the comparison results, identify a type of executable code corresponding to each calling library. Calculate the number of executable codes corresponding to each called library. When the number reaches a preset threshold, the called library is treated as a global library. For each global library generated, an update instruction pointing to all executable code is generated; wherein, the update instruction is used to adjust the library address in the calling code; Read the UI interface, final code, and virtualization process, and send them to the user.

[0009] As a further aspect of the present invention, the method further includes: Periodically grant additional database read permissions; The database is accessed based on data read permissions. When the data volume reaches a preset data volume threshold, the database is supplemented based on data read permissions. Send virtual data to a third party, receive processing code from the third party, and then send it back to the user; In this process, after receiving the processing code, the user uses the virtualization model as a pre-processing process and the inverse process of the virtualization model as a post-processing process to obtain the executable code.

[0010] The present invention also provides a project building system based on a low-code platform, the system comprising: The database creation module is used to receive project requirements input by the user, and create a database based on the project requirements to receive and expand the data pairs input by the user; the project requirements are a tree-structured set of tags, with each tag corresponding to a database; The interactive interface creation module is used to match UI components to any tag in the project requirements based on the data structure of the data pairs in the database, and combine the matched UI components to determine the UI interactive interface. The code acquisition module is used to match and execute code in a preset code library for any tag in the project requirements based on data pairs in the database. When a match fails, the data pairs are virtualized, and the code is acquired and executed based on the virtualized data. The virtualization process is uniquely mapped to the user. The code simplification module is used to simplify all executable code, use the simplified code as the final code, and provide the user with the UI interaction interface, the final code, and the virtualization process. When users apply the final code, they build a supplementary database based on the virtualization process; the supplementary database serves as a source for code updates.

[0011] As a further aspect of the present invention: the database creation module includes: The requirement receiving unit is used to receive project requirements input by the user. The request sending unit is used to query the tags sequentially according to the tree structure traversal order and send information retrieval requests to the user. The data pair creation unit is used to receive user input of demand inputs and mapping relationships indexed by tags, determine the demand outputs of the demand inputs based on the mapping relationships, and create data pairs of demand inputs and outputs. The extended rearrangement unit is used to expand the demand input, determine the demand output of the expanded demand input according to the mapping relationship, create data pairs of demand input and demand output, and randomly rearrange all data pairs.

[0012] As a further aspect of the present invention: the interactive interface creation module includes: The database reading unit is used to read the corresponding database for any tag in the project requirements; The data structure query unit is used to query the required input data structure and required output data structure in the database. The component pair matching unit is used to match UI component pairs in a preset UI component library based on the data structure. The component combination unit is used to combine the UI component pairs of various tags to obtain the UI interactive interface.

[0013] As a further aspect of the present invention: the code acquisition module includes: The code matching unit is used to match and execute code based on data in the database by traversing a preset code library for any tag in the project requirements. The data transcoding unit is used to read data pairs from the database, query user information, determine a virtualization model based on the user information, and transcode the data pairs based on the virtualization model to obtain virtual data pairs when matching fails. The interaction unit is used to send virtual data to a third party and receive feedback from the third party. The process addition unit is used to use the virtualization model as a pre-processing process for processing code and the inverse process of the virtualization model as a post-processing process for processing code to obtain the executable code.

[0014] Compared with the prior art, the beneficial effects of the present invention are as follows: The present invention receives project requirements input by the user, creates a database based on the project requirements, counts the inputs and outputs corresponding to each requirement, and then matches the UI interaction interface and execution code, and feeds back to the user to complete the data processing requirements. In this process, the project requirements, inputs and outputs are all non-code content. Only the user needs to perform input operations, and the operation process is extremely simple, further simplifying the code generation process. Attached Figure Description

[0015] To more clearly illustrate the technical solutions in the embodiments of the present invention, the accompanying drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the accompanying drawings described below are only some embodiments of the present invention.

[0016] Figure 1 A flowchart illustrating the method for building a project based on a low-code platform.

[0017] Figure 2 The first sub-flow diagram for the method of building a project based on a low-code platform.

[0018] Figure 3 This is the second sub-flow diagram of the method for building a project based on a low-code platform.

[0019] Figure 4 This is the third sub-flow diagram of the method for building projects based on a low-code platform.

[0020] Figure 5 This is the fourth sub-flow diagram of the project setup method based on a low-code platform.

[0021] Figure 6 A structural diagram of the system components for building a project based on a low-code platform. Detailed Implementation

[0022] To make the technical problems to be solved, the technical solutions, and the beneficial effects of the present invention clearer, the present invention will be further described in detail below with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative of the present invention and are not intended to limit the present invention.

[0023] Figure 1 The flowchart below illustrates a method for building a project based on a low-code platform. In this embodiment of the invention, a method for building a project based on a low-code platform includes: Step S100: Receive project requirements input by the user, and create a database based on the project requirements to receive and expand the data pairs input by the user; the project requirements are a tree-structured set of tags, with each tag corresponding to a database; Project requirements refer to the functions that users need to implement. For example, if the project to be built is an interactive app, then each interface includes several inputs and their corresponding responses. Each input and its corresponding response is a requirement, represented by a tag, such as query, fill, and download. For an app, different tags (requirements) are hierarchically nested, that is, different tags are actually in a tree structure. The project requirements are a tree-structured set of tags, and each tag corresponds to a database. In practical applications, the database of each tag is used to count the data (input) to be processed and the output to be obtained. The input and output are determined by the user and are called a data pair.

[0024] Step S200: For any tag in the project requirements, match UI components according to the data structure of the data pairs in the database, combine the matched UI components, and determine the UI interaction interface; For any tag (any requirement) in the project requirements, query the data structure of all data pairs in the database. The data structure of all data pairs in the same database is the same. The data structure includes the input data structure and the output data structure. Determine the UI interface based on the data structure. This is the interface that users can directly view and operate, such as checkboxes, input boxes, and display images. Combine the UI components corresponding to all tags to obtain a complete UI interaction interface. In layman's terms, the UI interaction interface is actually the display state of the App.

[0025] Step S300: For any tag in the project requirements, match the execution code in the preset code library according to the data pair in the database. When the match fails, virtualize the data pair and obtain the execution code based on the virtualized data. The virtualization process is uniquely mapped to the user. Step S200 is used to determine the display status of each tag, and step S300 is used to determine the actual execution process of each tag. For any tag in the project requirements, the execution code is matched with the data pair in the database in the preset code library. The data pair in the database is actually the input and output. The conversion relationship between the input and output can be determined. The code that can complete the conversion is queried in the code library according to the conversion relationship, which is the execution code. Since the conversion relationship between input and output is very conventional in the project construction process of the low-code platform, it mostly involves only basic operations such as summation or filtering. Therefore, the code library construction process is extremely easy. The execution platform of this method can fully provide it, which is equivalent to building a basic functional code library. When the matching fails, it means that the relationship between input and output is more complex. At this time, special operations are required, which is the core of this invention. The data pair is virtualized, and the data is acquired based on the virtualized data. The execution code is uniquely mapped to the user within the virtualization process. The significance of this process lies in the fact that the execution entity of this method is the provider of the low-code platform. The code tasks within the platform are actually assigned to freelance code writers. If data from the database were directly forwarded to these writers, there would be a risk of information leakage. Therefore, the execution entity (low-code platform) determines a unique virtualization process based on user information to transcode the input and output. The transcoded input and output are then used as tasks and dispatched to the writers. Upon receiving the code from them, the system uses the reverse process of the virtualization process to backtrack the information and obtain the original data. In this process, the transcoding is entirely performed by the user, ensuring extremely high information security. Furthermore, the execution entity can even delete the virtualization process locally after determining it. At this point, only the user knows the actual data, ensuring extremely high security.

[0026] Step S400: Simplify all executable code, use the simplified code as the final code, and feed back the UI interaction interface, the final code, and the virtualization process to the user; After all tags have obtained their corresponding execution code, the code is simplified. The simplification process involves eliminating some repetitive operations. The simplified code is then used as the final code, and the UI interaction interface, the final code, and the virtualization process are fed back to the user.

[0027] It should be noted that, on the user side, when the user applies the final code, a supplementary database is built based on the virtualization process; this supplementary database serves as the source for code updates; the explanation of this process is as follows: When the user application's final code processes data, it is actually a local task processing process on the user's end, which is highly secure. However, some tasks may be unprocessable. These unprocessable tasks can be handled by large models such as AI, or sent to a human end to receive feedback data. At this point, the task and processing result constitute a new data pair. The data pair is transcoded based on the virtualization process, and the transcoded data is sent to the execution body of this method (low-code platform). The execution code is retrieved again and fed back to the user end as supplementary code. This is the update process of the final code on the user's end.

[0028] It is worth mentioning that, in the above content, the user uploads some requirements, and the execution entity of this method provides feedback on the final code and virtualization processing progress. At this time, the execution entity of this method may not even retain the corresponding results. That is, after sending it to the user, the relevant content is deleted, which has a very high level of security. In subsequent application processes, the execution entity of this method provides update services.

[0029] Figure 2 The first sub-flow diagram of the project building method based on a low-code platform includes the steps of receiving project requirements input by the user, creating a database based on the project requirements, and receiving and expanding the data pairs input by the user. Step S101: Receive project requirements input by the user; Step S102: Query the tags sequentially according to the tree structure traversal order and send an information retrieval request to the user; Step S103: Receive user input of demand input and mapping relationship indexed by tags, determine demand output based on the mapping relationship, and create data pairs of demand input and demand output; Step S104: Expand the demand input, determine the demand output of the expanded demand input according to the mapping relationship, create data pairs of demand input and demand output, and randomly rearrange all data pairs.

[0030] The above describes the process of determining the data pairs. It involves receiving user-inputted project requirements, which are essentially the code development process, including the steps and corresponding functions. Each function represents the conversion of inputs into outputs. In the existing app architecture, project requirements form a tree structure. Following the tree traversal order (a pre-defined order: for a given node, query its child nodes sequentially until a leaf node, then backtrack to query the sibling nodes of the leaf node, repeating this process), tags are queried sequentially, and information retrieval requests are sent to the user. The tag query order is pre-defined; it only requires traversing all nodes. The process then receives user-inputted requirements indexed by tags and their mapping relationships. Based on the mapping relationships, the required outputs are determined, creating data pairs of required inputs and outputs. This means that when users submit requirements, they often specify data processing requirements, such as uploading data and specifying a formula for conversion to obtain outputs. In this case, the mapping relationship is directly applied to obtain the required outputs, creating data pairs of required inputs and outputs. Each tag corresponds to a database, and all required inputs and outputs are stored in the same database.

[0031] The user-uploaded input and output requirements are real data. However, once sent to the execution entity of this method, there is a certain possibility of data leakage. To further improve security, the execution entity of this method expands the input requirements. This process can use AI or some random generation algorithms to randomly generate some virtual inputs. Based on the mapping relationship, the output requirements of the expanded input requirements are determined, resulting in data pairs. Finally, all data pairs are shuffled and rearranged to obtain a database whose authenticity is difficult to determine.

[0032] Figure 3 The second sub-flow diagram of the project building method based on a low-code platform includes the following steps: matching UI components for any tag in the project requirements according to the data structure of the data pairs in the database, combining the matched UI components, and determining the UI interaction interface. Step S201: For any tag in the project requirements, read its corresponding database; Step S202: Query the database for the required input data structure and the required output data structure; Step S203: Match UI component pairs in the preset UI component library according to the data structure; Step S204: Combine the UI components of each label to obtain the UI interactive interface.

[0033] The above content explains the process of determining the UI interaction interface. For any tag in the project requirements, the corresponding database is read, and the data structure of the requirement input and the data structure of the requirement output are queried in the database. The input UI component is queried according to the data structure of the requirement input, and the output UI component is queried according to the data structure of the requirement output, so as to obtain the UI component pair. The UI component pairs of each tag are combined to obtain the UI interaction interface.

[0034] It is worth mentioning that there are a large number of UI components in the existing UI component library. The process of matching UI component pairs in the preset UI component library according to the data structure means that each tag can match multiple UI component pairs. There are many ways to combine the UI component library. At this point, an optimization process is involved to select the optimal UI component combination from the multiple combination methods as the final UI interaction interface.

[0035] Figure 4 The third sub-flow diagram of the project building method based on a low-code platform includes the following steps: for any tag in the project requirements, matching the executable code with data pairs in a preset code library based on data pairs in the database; when the matching fails, virtualizing the data pairs; and obtaining the executable code based on the virtualized data. Step S301: For any tag in the project requirements, traverse the preset code library according to the data in the database and match the code to be executed; Step S302: When matching fails, read the data pair from the database, query the user's information, determine the virtualization model based on the user information, and transcode the data pair based on the virtualization model to obtain a virtual data pair; Step S303: Send virtual data to a third party and receive processing code from the third party; Step S304: Use the virtualization model as a pre-processing process for the code and the reverse process of the virtualization model as a post-processing process for the code to obtain the executable code.

[0036] In one example of the technical solution of this invention, the process of obtaining the executable code is described. For any tag in the project requirements, the preset code library is traversed according to the data in the database to match the executable code. This traversal process is based on input and output and does not involve mapping relationships. Mapping relationships are often functions, which are difficult to operate on, while input and output are data with fixed data structures. The traversal process only needs to perform simple comparisons. When the match fails, the data pair in the database is read, the user's user information is queried, and the virtualization model is determined based on the user information. The data pair is transcoded based on the virtualization model to obtain virtual data pairs. The user information is generally used to determine the parameters of the virtualization model. The virtual data is sent to a third party, which is the code writer. The processing code fed back by the third party is received. During this process, the third party has no knowledge of the original data. In addition, the original data in the technical solution of this invention has been expanded and rearranged, and the security is extremely high. After receiving the processing code, the virtualization model is used as the pre-processing process of the processing code, and the reverse process of the virtualization model is used as the post-processing process of the processing code to obtain the executable code.

[0037] Figure 5 The fourth sub-flow diagram of the project building method based on a low-code platform includes the following steps: simplifying all executable code, using the simplified code as the final code, and feeding back the UI interface, the final code, and the virtualization process to the user. Step S401: Analyze all executed code and locate the calling code and its calling library within the executed code; Step S402: Compare the calling libraries and, based on the comparison results, count the type of executable code corresponding to each calling library; Step S403: Calculate the number of executable codes corresponding to each called library. When the number reaches a preset threshold, the called library is treated as a global library. Step S404: For each global library generated, an update instruction pointing to all executable code is generated; wherein, the update instruction is used to adjust the library address in the calling code; Step S405: Read the UI interaction interface, final code and virtualization processing, and send them to the user.

[0038] After obtaining the corresponding execution code for each tag, all execution codes are counted, the calling code and its calling library within the execution code are located, the calling libraries are compared, and the execution codes are clustered based on the calling libraries. Each calling library corresponds to one type of execution code (execution codes calling the same calling library are considered as one type). The number of execution codes corresponding to each calling library is calculated. When the number reaches a preset threshold, the calling library is used as a global library. For each global library generated, an update instruction pointing to all execution codes is generated. The update instruction is used to adjust the calling library address in the calling code. At this point, the code simplification process is achieved.

[0039] It's worth noting that the simplest approach to calculating the number of executable codes corresponding to each calling library is to directly read the number of executable code types as the quantity. However, in practical applications, the proximity between tags, i.e., the difference in requirements corresponding to these two tags, might also need to be considered, and the quantity adjusted accordingly. A feasible approach is to, for each type of executable code, query the node distance between any two tags corresponding to the project requirements. This node distance is calculated using the shortest path length in a tree structure, and the average node distance is used to determine a correction coefficient, which is then used to adjust the quantity. The correction coefficient is inversely proportional to the average. Its practical significance is that if a type of executable code... The larger the average distance between nodes, the greater the difference in their corresponding tags within the project requirements. In this case, when they jointly call the global library, they may need to go through more nesting levels. Therefore, their number should be slightly smaller to make it more difficult to reach the threshold, and the calling library is less likely to become a global library. For example, if a calling library corresponds to three executable codes, and the tags corresponding to these three executable codes are scattered in locations with significant differences in the project requirements, it would be somewhat redundant for them to jointly call the global library (the preset global library file). After optimizing the number, their number may be reduced from three to two, making it more difficult to reach the threshold. This process is actually also about optimizing the number of global libraries to prevent redundancy.

[0040] Finally, the UI interface, final code, and virtualization process are read and sent to the user. One feasible approach is to use a cut-and-paste method for this transmission. Once the user confirms, the execution entity deletes the relevant content to further improve security.

[0041] As a preferred embodiment of the technical solution of the present invention, the method further includes: Periodically grant additional database read permissions; The database is accessed based on data read permissions. When the data volume reaches a preset data volume threshold, the database is supplemented based on data read permissions. Send virtual data to a third party, receive processing code from the third party, and then send it back to the user; In this process, after receiving the processing code, the user uses the virtualization model as a pre-processing process and the inverse process of the virtualization model as a post-processing process to obtain the executable code.

[0042] In one example of the technical solution of this invention, the update process is described. The execution entity of this method periodically sends data read permissions to the user for supplementary databases. Based on the data read permissions, the data volume of the database is obtained. When the data volume reaches a preset data volume threshold, the supplementary database is read based on the data read permissions, and the virtual data is sent to a third party. The processing code fed back by the third party is received and fed back to the user. This process is similar to step S303 and is not complicated. For the user end, after receiving the processing code, the user uses the virtualization model as the pre-processing process of the processing code and the reverse process of the virtualization model as the post-processing process of the processing code to obtain the execution code.

[0043] Figure 6 This invention provides a project building system based on a low-code platform, comprising: a structural block diagram of the system's components. The system 10 includes: The database creation module 11 is used to receive project requirements input by the user and create a database based on the project requirements to receive and expand the data pairs input by the user; the project requirements are a tree-structured set of tags, with each tag corresponding to a database; The interactive interface creation module 12 is used to match UI components to any tag in the project requirements based on the data structure of the data pairs in the database, and to combine the matched UI components to determine the UI interactive interface. The code acquisition module 13 is used to match and execute code in a preset code library based on data pairs in the database for any tag in the project requirements. When the match fails, the data pairs are virtualized, and the code is acquired and executed based on the virtualized data. The virtualization process is uniquely mapped to the user. The code simplification module 14 is used to simplify all executable code, use the simplified code as the final code, and feed back the UI interaction interface, the final code and the virtualization process to the user. When users apply the final code, they build a supplementary database based on the virtualization process; the supplementary database serves as a source for code updates.

[0044] Furthermore, the database creation module 11 includes: The requirement receiving unit is used to receive project requirements input by the user. The request sending unit is used to query the tags sequentially according to the tree structure traversal order and send information retrieval requests to the user. The data pair creation unit is used to receive user input of demand inputs and mapping relationships indexed by tags, determine the demand outputs of the demand inputs based on the mapping relationships, and create data pairs of demand inputs and outputs. The extended rearrangement unit is used to expand the demand input, determine the demand output of the expanded demand input according to the mapping relationship, create data pairs of demand input and demand output, and randomly rearrange all data pairs.

[0045] Specifically, the interactive interface creation module 12 includes: The database reading unit is used to read the corresponding database for any tag in the project requirements; The data structure query unit is used to query the required input data structure and required output data structure in the database. The component pair matching unit is used to match UI component pairs in a preset UI component library based on the data structure. The component combination unit is used to combine the UI component pairs of various tags to obtain the UI interactive interface.

[0046] Furthermore, the code acquisition module 13 includes: The code matching unit is used to match and execute code based on data in the database by traversing a preset code library for any tag in the project requirements. The data transcoding unit is used to read data pairs from the database, query user information, determine a virtualization model based on the user information, and transcode the data pairs based on the virtualization model to obtain virtual data pairs when matching fails. The interaction unit is used to send virtual data to a third party and receive feedback from the third party. The process addition unit is used to use the virtualization model as a pre-processing process for processing code and the inverse process of the virtualization model as a post-processing process for processing code to obtain the executable code.

[0047] The above description is only a preferred embodiment of the present invention and is not intended to limit the present invention. Any modifications, equivalent substitutions, and improvements made within the spirit and principles of the present invention should be included within the protection scope of the present invention.

Claims

1. A project setup method based on a low-code platform, characterized in that, The method includes: The system receives project requirements input by the user and creates a database based on these requirements to receive and expand the data pairs input by the user. The project requirements are a tree-structured set of tags, with each tag corresponding to a database. For any tag in the project requirements, match UI components based on the data structure of the data pairs in the database, combine the matched UI components, and determine the UI interaction interface; For any tag in the project requirements, the code is matched and executed in a pre-defined code library based on the data in the database. When the match fails, the data pair is virtualized, and the code is obtained based on the virtualized data. The virtualization process is uniquely mapped to the user. All execution code is simplified, and the simplified code is used as the final code. The UI interaction interface, the final code, and the virtualization process are then fed back to the user. When users apply the final code, they build a supplementary database based on the virtualization process; the supplementary database serves as a source for code updates. For any tag in the project requirements, the method involves matching the data pair in the database with the execution code in a preset code library. When a match fails, the data pair is virtualized. The steps for obtaining the execution code based on the virtualized data include: For any tag in the project requirements, the system iterates through the preset code library based on the data in the database and matches and executes the code. When a match fails, the data pair is read from the database, the user's information is queried, the virtualization model is determined based on the user information, and the data pair is transcoded based on the virtualization model to obtain a virtual data pair. Send virtual data to a third party and receive processing code in response to the third party; The virtualization model is used as a pre-processing process for the code, and the inverse process of the virtualization model is used as a post-processing process for the code to obtain the executable code. The steps of simplifying all executable code, using the simplified code as the final code, and feeding back the UI interface, the final code, and the virtualization process to the user include: Analyze all executed code and locate the calling code and its calling libraries within the executed code; Compare the calling libraries and, based on the comparison results, identify a type of executable code corresponding to each calling library. Calculate the number of executable codes corresponding to each called library. When the number reaches a preset threshold, the called library is treated as a global library. For each global library generated, an update instruction pointing to all executable code is generated; wherein, the update instruction is used to adjust the library address in the calling code; Read the UI interface, final code, and virtualization process, and send them to the user.

2. The project building method based on a low-code platform according to claim 1, characterized in that, The steps of receiving project requirements input by the user and creating a database based on those requirements to receive and expand the data pairs input by the user include: Receive project requirements input from the user; The tags are queried sequentially according to the tree structure traversal order, and information retrieval requests are sent to the user. Receive user input of demand inputs and mapping relationships indexed by tags, determine the demand outputs based on the mapping relationships, and create data pairs of demand inputs and outputs; Expand the demand input, determine the demand output of the expanded demand input according to the mapping relationship, create data pairs of demand input and demand output, and randomly rearrange all data pairs.

3. The project building method based on a low-code platform according to claim 1, characterized in that, The steps of matching UI components for any tag in the project requirements based on the data structure of the data pairs in the database, and combining the matched UI components to determine the UI interaction interface include: For any tag in the project requirements, read its corresponding database; Query the database to obtain the required input data structure and the required output data structure; Match UI component pairs from a pre-defined UI component library based on the data structure; The UI components of each label are combined to obtain the UI interactive interface.

4. The project building method based on a low-code platform according to claim 1, characterized in that, The method further includes: Periodically grant additional database read permissions; The database is accessed based on data read permissions. When the data volume reaches a preset data volume threshold, the database is supplemented based on data read permissions. Send virtual data to a third party, receive processing code from the third party, and then send it back to the user; In this process, after receiving the processing code, the user uses the virtualization model as a pre-processing process and the inverse process of the virtualization model as a post-processing process to obtain the executable code.

5. A project building system based on a low-code platform, characterized in that, The system includes: The database creation module is used to receive project requirements input by the user, and create a database based on the project requirements to receive and expand the data pairs input by the user; the project requirements are a tree-structured set of tags, with each tag corresponding to a database; The interactive interface creation module is used to match UI components to any tag in the project requirements based on the data structure of the data pairs in the database, and combine the matched UI components to determine the UI interactive interface. The code acquisition module is used to match and execute code in a preset code library for any tag in the project requirements based on data pairs in the database. When a match fails, the data pairs are virtualized, and the code is acquired and executed based on the virtualized data. The virtualization process is uniquely mapped to the user. The code simplification module is used to simplify all executable code, use the simplified code as the final code, and provide the user with the UI interaction interface, the final code, and the virtualization process. When users apply the final code, they build a supplementary database based on the virtualization process; the supplementary database serves as a source for code updates. The code acquisition module includes: The code matching unit is used to match and execute code based on data in the database by traversing a preset code library for any tag in the project requirements. The data transcoding unit is used to read data pairs from the database, query user information, determine a virtualization model based on the user information, and transcode the data pairs based on the virtualization model to obtain virtual data pairs when matching fails. The interaction unit is used to send virtual data to a third party and receive feedback from the third party. The process addition unit is used to use the virtualization model as a pre-processing process for processing code and the inverse process of the virtualization model as a post-processing process for processing code to obtain the executable code; The process of simplifying all executable code and using the simplified code as the final code, along with the UI interaction interface, the final code, and the virtualization processing process fed back to the user, includes: Analyze all executed code and locate the calling code and its calling libraries within the executed code; Compare the calling libraries and, based on the comparison results, identify a type of executable code corresponding to each calling library. Calculate the number of executable codes corresponding to each called library. When the number reaches a preset threshold, the called library is treated as a global library. For each global library generated, an update instruction pointing to all executable code is generated; wherein, the update instruction is used to adjust the library address in the calling code; Read the UI interface, final code, and virtualization process, and send them to the user.

6. The project building system based on a low-code platform according to claim 5, characterized in that, The database creation module includes: The requirement receiving unit is used to receive project requirements input by the user. The request sending unit is used to query the tags sequentially according to the tree structure traversal order and send information retrieval requests to the user. The data pair creation unit is used to receive user input of demand inputs and mapping relationships indexed by tags, determine the demand outputs of the demand inputs based on the mapping relationships, and create data pairs of demand inputs and outputs. The extended rearrangement unit is used to expand the demand input, determine the demand output of the expanded demand input according to the mapping relationship, create data pairs of demand input and demand output, and randomly rearrange all data pairs.

7. The project building system based on a low-code platform according to claim 5, characterized in that, The interactive interface creation module includes: The database reading unit is used to read the corresponding database for any tag in the project requirements; The data structure query unit is used to query the required input data structure and required output data structure in the database. The component pair matching unit is used to match UI component pairs in a preset UI component library based on the data structure. The component combination unit is used to combine the UI component pairs of various tags to obtain the UI interactive interface.

Images