Low-code platform component intelligent generation method, system and device and storage medium
By constructing a component gene map and semantic parsing, the instability and high cost of generating components on low-code platforms are solved, achieving deterministic and controllable component generation and supporting efficient iterative optimization.
Patent Information
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- SHANDONG INSPUR SCI RES INST CO LTD
- Filing Date
- 2025-12-11
- Publication Date
- 2026-05-12
AI Technical Summary
Existing low-code platform component generation methods rely on large models, resulting in an unstable and untraceable generation process, high costs, and difficulty in precise modification, hindering efficient iterative optimization.
By constructing a component gene map, including an atomic capability library and a component template library, and using semantic parsing and predefined rules to generate component code, determinism and controllability are achieved, reducing dependence on large models.
The generated results are stable and reliable, conform to platform specifications, are logically transparent, reduce implementation costs, and support precise and efficient component iteration and optimization.
Smart Images
Figure CN122018910A_ABST
Abstract
Description
Technical Field
[0001] This invention belongs to the field of low-code platform technology, specifically relating to a method, system, device, and storage medium for intelligent generation of low-code platform components. Background Technology
[0002] Currently, low-code platforms commonly employ large language models to implement "natural language generation components." This method directly inputs the requirement description into a large model, which then generates code end-to-end. However, this approach has significant drawbacks: the generation process of large models is inherently random, leading to instability in the quality, style, and platform compliance of the output code; its operation is like a "black box," making the generation logic difficult to trace and intervene in; and it heavily relies on large-scale, high-quality training data and massive computing power, resulting in high implementation costs. Furthermore, the generated components are difficult to modify in a controllable and precise manner, often requiring regeneration and hindering efficient iterative optimization. Therefore, the industry urgently needs a low-code component construction method that offers high determinism, strong controllability, and independence from large model generation. Summary of the Invention
[0003] In view of the above-mentioned shortcomings of the prior art, the present invention provides a method, system, device and storage medium for intelligent generation of low-code platform components to solve the above-mentioned technical problems.
[0004] In a first aspect, the present invention provides a method for intelligent generation of low-code platform components, comprising: Components that receive user input generate requirement information; The requirement information is semantically parsed, and by matching it with a pre-constructed component gene map, the corresponding component template type and one or more atomic capabilities are determined; the component gene map includes an atomic capability library storing the smallest functional unit and a component template library storing parameterized component templates; Based on the matched component templates and atomic capabilities, the component template library is retrieved and combined to generate a component code skeleton, and the parameters in the requirement information are filled into the code skeleton to generate the target component code. Output the generated target component code.
[0005] In one optional implementation, receiving user-inputted component generation requirement information includes: Receive natural language descriptions from user input; Furthermore, through a guided interactive interface, structured input items are provided based on the natural language description to guide users to select or fill in at least one parameter among component type, data source, and operation function to form structured requirement information.
[0006] In one optional implementation, the method for constructing the component gene map includes: During the data collection and parsing phase, raw data is collected from the platform's built-in component library, historical custom component library, and development specification documents. The corresponding parsing tools are then used to extract the structured metadata and unstructured description information of the components from the raw data. In the atomization and structuring stage, based on the extracted information, the functional logic of multiple components is summarized and analyzed, and multiple atomic capability units are defined. Each atomic capability unit includes at least: a unique capability identifier, a functional category, a description, input and output parameter definitions, and platform-related default code snippets. The atomic capability units are stored in the atomic capability library. A component template library is constructed, which is used to store parameterized component code skeletons. The following information is defined for each component template: semantic tags to describe the applicable scenarios of the component; a list of required atomic capability identifiers; component interface specifications, including attribute definitions and event definitions; and a code skeleton file containing placeholders. In the graph storage and indexing stage, the atomic capability library and component template library are stored in a document-based database or search engine; indexes are created for the capability identifiers, function categories, and descriptions of the atomic capability library; and indexes are created for the template identifiers, semantic tags, and descriptions of the component template library.
[0007] In one optional implementation, the requirement information is semantically parsed, and by matching it with a pre-constructed component gene map, the corresponding component template type and one or more atomic capabilities are determined, including: Natural language processing technology is used to extract keywords from the demand information and normalize the keywords to form standardized key semantic elements. Matching the key semantic elements with the component gene map includes: calculating the similarity between the key semantic elements and the semantic tags of the component template to determine the component template type; and matching the key semantic elements with the descriptions of atomic capability units to identify one or more atomic capabilities. The similarity calculation and matching are achieved by calling a pre-trained natural language processing model.
[0008] In an optional implementation, based on the matched component templates and atomic capabilities, a component code skeleton is generated by retrieving and combining components from the component template library, and the parameters from the requirement information are filled into the code skeleton to generate the target component code, including: Based on the determined component template type, retrieve the corresponding basic template from the component template library; If the atomic capabilities associated with the basic template cannot cover all identified atomic capabilities, then according to the predefined combination rules, the basic template is combined with one or more other templates to generate a component code skeleton that satisfies all atomic capabilities. If the atomic capabilities associated with the basic template can cover all the identified atomic capabilities, then the basic template is directly used as the component code skeleton; The specific parameter values contained in the requirement information are filled into the corresponding placeholders in the component code skeleton to generate the target component code.
[0009] In an optional implementation, the combination according to predefined combination rules includes: Based on the uncovered atomic capabilities, retrieve one or more other component templates associated with the corresponding atomic capabilities from the component template library; According to the code structure and interface correspondence defined by the combination rules, the code skeleton of the basic template is merged with the code skeleton of other templates to generate a unified component code skeleton.
[0010] In one optional implementation, the predefined combination rules include at least one of the following: Container-content rules are used to insert the first component template as content into a specified slot position in the second component template; The sibling rule is used to treat the template nodes of multiple component templates as sibling nodes and wrap them in the same layout container. The controller-controlled entity rule is used to establish the control relationship between the first component template and the second component template, so that the events of the first component template can update the state that the second component template depends on. The data provider-consumer rule is used to establish the data supply relationship between the first component template and the second component template, so that the data obtained by the first component template can be passed to the second component template for use; Conditional wrapping rules are used to control the rendering state or properties of a target component template based on preset conditions.
[0011] Secondly, this invention provides a low-code platform component intelligent generation system, comprising: The requirement receiving module is used to receive user input of component generation requirement information; The gene retrieval module is used to perform semantic parsing on the requirement information, and to determine the corresponding component template type and one or more atomic capabilities by matching it with a pre-constructed component gene map; the component gene map includes an atomic capability library storing the smallest functional unit and a component template library storing parameterized component templates; The code generation module is used to retrieve and combine components from the component template library to generate a component code skeleton based on the matched and determined component templates and atomic capabilities, and to fill the parameters in the requirement information into the code skeleton to generate the target component code. The code output module is used to output the generated target component code.
[0012] Thirdly, a device is provided, comprising: Memory, used to store intelligent generation programs for low-code platform components; A processor is configured to implement the steps of the low-code platform component intelligent generation method as provided in the first aspect when executing the low-code platform component intelligent generation program.
[0013] Fourthly, a computer-readable storage medium is provided, on which a low-code platform component intelligent generation program is stored, wherein when the low-code platform component intelligent generation program is executed by a processor, the low-code platform component intelligent generation method as provided in the first aspect is implemented.
[0014] The beneficial effects of this invention are as follows: The low-code platform component intelligent generation method, system, device, and storage medium provided by this invention, based on a structured component gene map and semantic workflow, transforms user requirements into component code through deterministic parsing, matching, and combination, effectively overcoming the "black box" uncertainty of large model generation methods. Its beneficial effects include: 1. Stable and reliable generation results, strictly conforming to platform specifications, and controllable code quality; 2. Combination through predefined atomic capabilities and template rules, resulting in transparent logic and strong interpretability; 3. Reduced dependence on large-scale training data and massive computing power, significantly reducing implementation costs; 4. Support for interactive code optimization based on precise instructions, achieving accurate and efficient component iteration. Attached Figure Description
[0015] 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, for those skilled in the art, other drawings can be obtained based on these drawings without creative effort.
[0016] Figure 1 This is a schematic flowchart of a method according to an embodiment of the present invention.
[0017] Figure 2 This is a schematic block diagram of a system according to an embodiment of the present invention.
[0018] Figure 3 This is a schematic diagram of the structure of a device provided in an embodiment of the present invention. Detailed Implementation
[0019] To enable those skilled in the art to better understand the technical solutions of this invention, the technical solutions of the embodiments of this invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only 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.
[0020] Unless otherwise defined, all technical and scientific terms used herein have the same meaning as commonly understood by one of ordinary skill in the art to which this invention pertains. The terminology used herein in the description of the invention is for the purpose of describing particular embodiments only and is not intended to be limiting of the invention.
[0021] The low-code platform component intelligent generation method provided in this embodiment of the invention is executed by a computer device, and correspondingly, the low-code platform component intelligent generation system runs on the computer device.
[0022] Figure 1 This is a schematic flowchart illustrating a method according to an embodiment of the present invention. Wherein, Figure 1 The executing entity can be a low-code platform component intelligent generation system. Depending on different requirements, the order of steps in this flowchart can be changed, and some can be omitted.
[0023] like Figure 1 As shown, the method includes: S1. Receive user input for component generation requirements; S2. Perform semantic parsing on the requirement information, and determine the corresponding component template type and one or more atomic capabilities by matching it with the pre-constructed component gene map; the component gene map includes an atomic capability library storing the smallest functional unit and a component template library storing parameterized component templates; S3. Based on the matched component templates and atomic capabilities, retrieve and combine them from the component template library to generate a component code skeleton, and fill the parameters in the requirement information into the code skeleton to generate the target component code; S4. Output the generated target component code.
[0024] The methods for constructing component gene maps include: 1. Data Acquisition and Analysis Stage: The purpose of this stage is to extract the original information used to build the knowledge base from multi-source heterogeneous data.
[0025] First, the system collects raw data from three main data sources: (a) Platform built-in component library: By writing scripts to scan the platform SDK or node_modules directory, the system obtains component description files (such as asset.json), source code (.vue, .jsx files), and configuration files (package.json); (b) Historical custom component library: The system obtains high-quality custom components that have been released from the component marketplace or project repository, and the content collected is the same as (a); (c) Development specification documents: The system uses web crawlers or document parsing tools to process official development guides, API documents, and other Markdown or PDF format text.
[0026] Subsequently, the collected data is parsed and information is extracted. For structured description files (JSON / XML), standard parsing libraries (such as Python's json.loads) are used to directly extract metadata fields such as props, events, and slots. For unstructured document text, natural language processing tools (such as spaCy) are used for entity recognition and rule extraction to obtain descriptive information such as component names and attribute constraints. For component source code, abstract syntax tree (AST) parsers (such as Babel, @vue / compiler-sfc) are used to analyze its template structure, logical methods, and dependencies.
[0027] 2. Atomization and Structuring Stage: The goal of this stage is to reconstruct the resolved "coarse-grained" component information into computable and reusable "gene" units.
[0028] First, an atomic capability library is constructed. The system summarizes and analyzes the functional logic of hundreds or thousands of components extracted in the previous stage, abstracting the smallest reusable functional unit, namely, the "atomic capability." Each atomic capability is precisely defined as a structured object, which contains at least the following fields: a unique capability identifier (such as HTTP_GET), a functional category (such as "data manipulation"), a text description, definitions of input / output parameters, and default code snippets for different platforms. For example, the definition of the HTTP_GET capability includes its required URL parameters and the returned data.
[0029] Next, a component template library is built. The system "parameterizes" the original components, creating code skeleton templates that do not contain specific business values. Each component template is also defined as a structured object, with key fields including: semantic tags describing the applicable scenario (such as ["data display", "table"]), a list of atomic capability identifiers necessary to implement the template, specifications for the component's external interfaces (props) and events, and a code skeleton file (such as the contents of src / index.vue) containing placeholders (such as {{apiUrl}}). A "table with search" template might have a requiredAbilities field containing ["TABLE_RENDER", "SEARCH_INPUT"].
[0030] 3. Knowledge Base Storage and Indexing Stage: The goal of this stage is to persistently store the structured knowledge base and provide efficient retrieval capabilities.
[0031] The system prefers document-oriented databases (such as MongoDB) or search engines (such as Elasticsearch) to store the aforementioned structured atomic capability libraries and component template libraries, because they natively support nested data in JSON format.
[0032] To enable fast queries, the system creates inverted indexes for both databases. For the atomic capability database, indexes are primarily created on the `abilityId` (primary key), `category`, and `description` (full text) fields. For the component template database, indexes are created on the `templateId` (primary key), `semanticTags` (multi-value tags), and `description` (full text) fields. For example, when a user's query includes the keyword "search," the system can quickly retrieve all relevant templates using the full-text index of either `semanticTags` or `description`.
[0033] At this point, a structured component gene map that can be used for subsequent semantic parsing and template matching is complete.
[0034] In one embodiment of the present invention, based on step S1, the following will provide a possible embodiment and describe its specific implementation in a non-limiting manner.
[0035] When a user submits an initial description (e.g., "I want to create a table that displays a list of users and allows searching and deleting") through the platform's natural language input box, the system does not directly attempt to generate code. Instead, it launches a guided interactive interface to transform the vague natural language intent into precise, computable, structured requirements.
[0036] This guided interface is typically presented in the form of a dynamic form or a multi-step wizard. The system first performs a shallow analysis of the natural language description entered by the user in real time (e.g., through keyword matching or a lightweight intent recognition model), and based on the analysis results, intelligently pre-fills or highlights relevant options, thereby proactively guiding the user to confirm or supplement information.
[0037] The core of the structured input items includes: Component type selection: The system provides a drop-down menu or card selector listing major component types such as "data table," "form," "chart," and "navigation menu." Based on the recognition of the word "table" in the user's description, the interface can automatically pre-select or recommend the "data table" type.
[0038] Data source configuration: The system provides radio buttons or drop-down menus to allow users to specify the data source. Options typically include "Internal platform API", "Static JSON data", "External HTTP interface", "Database query", etc. For example, based on the above description, the interface can guide the user to select a specific data interface.
[0039] Operation Function Selection: The system provides a checkbox list listing common interactive functions for this type of component, such as "Add Record," "Edit Row," "Delete Row," "Query / Search," "Batch Operation," and "Export Data." Based on the description "Search and Delete," the interface will automatically select the "Query / Search" and "Delete Row" options and prompt the user for confirmation or to add other functions.
[0040] Key parameter input: For the selected configuration, the interface will dynamically expand the corresponding required or optional parameter input boxes. For example, if the user selects "Platform Internal API" as the data source, the specific "API path" must be filled in; if the "Search" function is selected, the "Search Field" can be further configured, etc.
[0041] After the user completes their interaction with the guided interface, the system integrates the natural language description submitted by the user with all structured options and parameters, encapsulating them into a unified, machine-readable, structured requirement information object (usually in JSON format). This object serves as direct input for subsequent semantic analysis and template matching. This process significantly reduces ambiguity in the conversion from vague requirements to precise specifications, laying a reliable foundation for subsequent deterministic code generation.
[0042] In one embodiment of the present invention, based on step S2, the following will provide a possible embodiment and describe its specific implementation in a non-limiting manner.
[0043] S201. Semantic Element Extraction and Normalization The goal of this step is to extract standardized, machine-understandable semantic elements from the user-input component-generated requirement information (especially the natural language description portion).
[0044] First, the system preprocesses the text using natural language processing technology. For example, given the input "I need an employee information table that can be searched by department and displayed in pages", the system uses a word segmentation tool (such as jieba) to segment it into a word sequence and removes stop words such as "I" and "need", resulting in a preliminary word list, such as ["department", "search", "page", "employee information", "table"].
[0045] The system then normalizes the word list to form standardized key semantic elements. This is mainly achieved in two ways: Based on keyword extraction and synonym mapping: The system uses algorithms such as TF-IDF and TextRank to extract high-importance keywords from a word list. Then, by querying a pre-built thesaurus containing platform-domain terminology, the extracted keywords are mapped to unified, standardized terms. For example, the dictionary might define "search": ["find", "query"], thus ensuring that different expressions are normalized to "search".
[0046] Semantic encoding based on pre-trained models: The system directly calls a pre-trained natural language processing model, such as a lightweight sentence encoding model (e.g., all-MiniLM-L6-v2). This model directly encodes the entire sentence or pre-processed text into a fixed-dimensional sentence vector. This sentence vector itself is a highly abstract and standardized representation of the input semantics, eliminating the need for explicit keyword extraction and synonym replacement steps, simplifying the process and improving the depth of semantic understanding.
[0047] S202. Determining the Component Template Type The goal of this step is to determine the type of component the user intends to create based on the key semantic elements obtained in the previous step.
[0048] The system matches the key semantic elements (whether it's a normalized list of keywords or sentence vectors) with the semantic tags of each template in the component template library of the "component gene map". This is specifically achieved by calculating semantic similarity.
[0049] When the key semantic element is a sentence vector, the system calculates the cosine similarity between the sentence vector and the corresponding vectors of each semantic label (which can be obtained through the same pre-trained model).
[0050] When the key semantic elements are a list of keywords, the overlap can be calculated using the bag-of-words model, or similarity can be calculated after converting them into vectors.
[0051] The system selects the category corresponding to the semantic tag with the highest similarity and determines it as the component template type (e.g., "data table").
[0052] S203. Identification of Atomic Capabilities The goal of this step is to identify the specific functionalities required to fulfill this requirement, namely atomic capabilities.
[0053] The system matches the key semantic elements with the descriptive text of each atomic capability unit in the atomic capability library of the "component gene map". This process also relies on calling a pre-trained natural language processing model to calculate semantic similarity.
[0054] For example, the similarity between the user description (or its sentence vector) and the description text of "provide search input box functionality" (corresponding to the SEARCH_INPUT capability) is calculated. The system calculates a similarity score for all atomic capabilities and typically sets a threshold (e.g., 0.6). Atomic capabilities with scores exceeding the threshold are identified as the capabilities the user needs, forming a list of atomic capabilities (e.g., ["HTTP_GET", "TABLE_RENDER", "SEARCH_INPUT", "PAGINATION"]).
[0055] S204. Formation of Structured Output Finally, the system integrates the matching and recognition results to form a structured intermediate representation. This representation includes at least: the determined component template type, the list of identified atomic capabilities, and specific parameters extracted from the original description through simple rules or named entity recognition (such as dataSource: "employee information"). This structured output is passed as an explicit instruction to the subsequent template retrieval and code generation modules.
[0056] In one embodiment of the present invention, based on step S3, the following will provide a possible embodiment and describe its specific implementation in a non-limiting manner.
[0057] S301. Basic Template Retrieval The system retrieves components from the pre-built "Component Gene Map" component template library based on the component template type (such as "data table") determined in the component specification object. For example, based on the type "data table", the system may retrieve the corresponding basic template with templateId as basic_table. This basic template contains the core code skeleton of this type of component and a set of associated atomic capabilities (such as ["TABLE_RENDER"]).
[0058] S302. Component Code Skeleton Generation The system compares the list of atomic capabilities associated with the retrieved basic template with the list of required atomic capabilities identified in the component specification object, and generates the final component code skeleton by adopting different strategies based on the comparison results.
[0059] Scenario 1: Directly use the basic template If the list of atomic capabilities associated with the basic template completely covers (i.e. includes) all identified required atomic capabilities, then the basic template meets all functional requirements. In this case, the system directly uses the code skeleton of the basic template as the final component code skeleton. For example, if the requirement is only a basic table, the skeleton of the basic_table template can be used directly.
[0060] Scenario 2: Template combination based on rules If the basic template's capability list contains uncovered atomic capabilities (for example, a requirement includes the SEARCH_INPUT and PAGINATION capabilities, while the basic_table template only associates with the TABLE_RENDER capability), the system initiates the template composition process.
[0061] Retrieve supplementary templates: Based on the uncovered atomic capabilities, the system retrieves other templates associated with the corresponding capabilities from the component template library. For example, it retrieves the search_bar template associated with the SEARCH_INPUT capability and the pagination template associated with the PAGINATION capability.
[0062] Merging is performed using combination rules: The system intelligently merges the base template with the retrieved supplementary templates according to predefined combination rules. These rules define the integration logic for code and interfaces between different templates, mainly including the following: Container-Content Rules: These are specified slots used to embed one template (content) into another template (container). For example, embedding the search_bar and pagination templates as content into the body and footer slots of a card container creates a card-style table layout.
[0063] Sibling rule: Used to arrange multiple templates side by side horizontally or vertically. For example, placing the search_bar template and the basic_table template as sibling nodes together within a div layout container forms the common layout of "search bar + table".
[0064] Controller-Controlled Rule: Used to establish control relationships between templates. For example, binding the search keywords of the search_bar template to the data filtering function of the basic_table template allows the search box to control the data displayed in the table.
[0065] Data provider-consumer rules: used to establish data flow between templates. For example, after a dictionary lookup template retrieves data, it passes it to a form selector template via Props for rendering options.
[0066] Conditional wrapping rules: Used to control template rendering based on conditions. For example, wrapping a delete button template with a permission verification template can achieve permission-based button visibility control.
[0067] The system merges, splices, and integrates the code skeletons of multiple templates according to the code structure and interface correspondence defined by the selected rules, and finally generates a unified component code skeleton that satisfies all atomic capabilities.
[0068] S303. Parameter Filling and Code Generation After obtaining the final component code skeleton, the system populates the parameters. The component code skeleton contains placeholders (such as {{apiUrl}}, {{columns}}) for receiving specific business values. The system retrieves the specific parameter values from the component specification object's slotFillingParameters (or an equivalent parameter object) and populates them into the corresponding placeholders in the code skeleton. For example, the value of the dataSource parameter is populated into the URL placeholder for initiating the HTTP request in the skeleton. After population, a complete and runnable target component source code file (such as a Vue single-file component) is generated.
[0069] In one embodiment of the present invention, based on step S4, the following will provide a possible embodiment and describe its specific implementation in a non-limiting manner.
[0070] The Node.js service is invoked to compile the automatically generated component code into JS files in real time, and then the low-code platform's dynamic referencing feature is used to embed the files into the component tree for real-time preview.
[0071] Users can continue to optimize and adjust the instruction model through natural language, realizing a closed loop of "generation-preview-optimization". Before release, the component also needs to be checked and verified by the platform, including code syntax verification and platform compliance checks, to ensure the component's instructions and platform compatibility.
[0072] The compiled component files can be published to the platform's component marketplace with one click for unified management, allowing users to retrieve and reuse them.
[0073] In some embodiments, the low-code platform component intelligent generation system may include multiple functional modules composed of computer program segments. The computer programs of each program segment in the low-code platform component intelligent generation system may be stored in the memory of a computer device and executed by at least one processor to perform (see details). Figure 1 (Description) The functionality of intelligent generation of low-code platform components.
[0074] In this embodiment, the low-code platform component intelligent generation system can be divided into multiple functional modules based on its functions, such as... Figure 2 As shown. The module referred to in this invention is a series of computer program segments that can be executed by at least one processor and perform a fixed function, and is stored in memory. In this embodiment, the functions of each module will be described in detail in subsequent embodiments.
[0075] The requirement receiving module is used to receive user input of component generation requirement information; The gene retrieval module is used to perform semantic parsing on the requirement information, and to determine the corresponding component template type and one or more atomic capabilities by matching it with a pre-constructed component gene map; the component gene map includes an atomic capability library storing the smallest functional unit and a component template library storing parameterized component templates; The code generation module is used to retrieve and combine components from the component template library to generate a component code skeleton based on the matched and determined component templates and atomic capabilities, and to fill the parameters in the requirement information into the code skeleton to generate the target component code. The code output module is used to output the generated target component code.
[0076] Figure 3 The low-code platform component intelligent generation method provided in the embodiments of this application can be applied to devices. Those skilled in the art will understand that the device structures involved in the embodiments of this invention do not constitute a limitation on the device. A device may include more or fewer components than illustrated, or combine certain components, or have different component arrangements. In the embodiments of this invention, the device includes, but is not limited to, laptop computers, desktop computers, workstations, personal digital assistants, servers, blade servers, mainframe computers, and other suitable computers. The device may also represent various forms of mobile devices, such as personal digital processors, cellular phones, smartphones, wearable devices, and other similar computing devices. The components shown herein, their connections and relationships, and their functions are merely examples and are not intended to limit the implementation of the embodiments of this application described and / or claimed herein.
[0077] The device 300 may include a processor 310, a memory 320, and a communication unit 330. These components communicate via one or more buses. Those skilled in the art will understand that the server structure shown in the figure does not constitute a limitation of the present invention. It may be a bus topology or a star topology, and may include more or fewer components than shown, or combine certain components, or have different component arrangements.
[0078] The memory 320 can be used to store execution instructions of the processor 310. The memory 320 can be implemented by any type of volatile or non-volatile storage device or a combination thereof, such as static random access memory (SRAM), electrically erasable programmable read-only memory (EEPROM), erasable programmable read-only memory (EPROM), programmable read-only memory (PROM), read-only memory (ROM), magnetic storage, flash memory, magnetic disk, or optical disk. When the execution instructions in the memory 320 are executed by the processor 310, the device 300 is able to perform some or all of the steps in the above method embodiments.
[0079] The processor 310 serves as the control center of the storage device, connecting various parts of the electronic device via various interfaces and lines. It executes software programs and / or modules stored in the memory 320, and calls data stored in the memory to perform various functions of the electronic device and / or process data. The processor can be composed of integrated circuits (ICs), such as a single packaged IC or multiple packaged ICs with the same or different functions connected together. For example, the processor 310 may consist only of a central processing unit (CPU). In this embodiment of the invention, the CPU may have a single processing core or include multiple processing cores.
[0080] The communication unit 330 is used to establish a communication channel, enabling the storage device to communicate with other devices. It can receive user data sent by other devices or send user data to other devices.
[0081] The present invention also provides a computer storage medium, wherein the computer storage medium may store a program, which, when executed, may include some or all of the steps provided in the embodiments of the present invention. The storage medium may be a magnetic disk, an optical disk, read-only memory (ROM), or random access memory (RAM), etc.
[0082] Those skilled in the art will clearly understand that the techniques in the embodiments of the present invention can be implemented using software plus necessary general-purpose hardware platforms. Based on this understanding, the technical solutions in the embodiments of the present invention, or the parts that contribute to the prior art, can be embodied in the form of a software product. This computer software product is stored in a storage medium such as a USB flash drive, a portable hard drive, a read-only memory (ROM), a random access memory (RAM), a magnetic disk, or an optical disk, or any other medium capable of storing program code. It includes several instructions to cause a computer device (which may be a personal computer, a server, or a second device, network device, etc.) to execute all or part of the steps of the methods described in the various embodiments of the present invention.
[0083] The same or similar parts between the various embodiments in this specification can be referred to mutually. In particular, the device embodiments are basically similar to the method embodiments, so the description is relatively simple, and the relevant parts can be referred to the description in the method embodiments.
[0084] In the embodiments provided by this invention, it should be understood that the disclosed systems and methods can be implemented in other ways. For example, the system embodiments described above are merely illustrative. For instance, the division of modules is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple modules or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the coupling or direct coupling or communication connection shown or discussed may be through some interfaces; the indirect coupling or communication connection between systems or modules may be electrical, mechanical, or other forms.
[0085] The modules described as separate components may or may not be physically separate. The components shown as modules may or may not be physical modules; that is, they may be located in one place or distributed across multiple network modules. Some or all of the modules can be selected to achieve the purpose of this embodiment according to actual needs.
[0086] In addition, the functional modules in the various embodiments of the present invention can be integrated into one processing module, or each module can exist physically separately, or two or more modules can be integrated into one module.
[0087] Although the present invention has been described in detail with reference to the accompanying drawings and preferred embodiments, the present invention is not limited thereto. Various equivalent modifications or substitutions can be made to the embodiments of the present invention by those skilled in the art without departing from the spirit and essence of the invention, and such modifications or substitutions should all be within the scope of the present invention. Any variations or substitutions that can be easily conceived by those skilled in the art within the technical scope disclosed in the present invention should also be covered within the protection scope of the present invention.
Claims
1. A method for intelligent generation of low-code platform components, characterized in that, include: Components that receive user input generate requirement information; The requirement information is semantically parsed and matched with a pre-constructed component gene map to determine the corresponding component template type and one or more atomic capabilities; the component gene map includes an atomic capability library storing the smallest functional unit and a component template library storing parameterized component templates; Based on the matched component templates and atomic capabilities, the component template library is retrieved and combined to generate a component code skeleton, and the parameters in the requirement information are filled into the code skeleton to generate the target component code. Output the generated target component code.
2. The method according to claim 1, characterized in that, Receive user-inputted component generation requirements information, including: Receive natural language descriptions from user input; Furthermore, through a guided interactive interface, structured input items are provided based on the natural language description to guide users to select or fill in at least one parameter among component type, data source, and operation function to form structured requirement information.
3. The method according to claim 1, characterized in that, Methods for constructing component gene maps include: During the data collection and parsing phase, raw data is collected from the platform's built-in component library, historical custom component library, and development specification documents. The corresponding parsing tools are then used to extract the structured metadata and unstructured description information of the components from the raw data. In the atomization and structuring stage, based on the extracted information, the functional logic of multiple components is summarized and analyzed, and multiple atomic capability units are defined. Each atomic capability unit includes at least: a unique capability identifier, a functional category, a description, input and output parameter definitions, and platform-related default code snippets. The atomic capability units are stored in the atomic capability library. A component template library is constructed, which is used to store parameterized component code skeletons. The following information is defined for each component template: semantic tags to describe the applicable scenarios of the component; a list of required atomic capability identifiers; component interface specifications, including attribute definitions and event definitions; and a code skeleton file containing placeholders. In the graph storage and indexing stage, the atomic capability library and component template library are stored in a document-based database or search engine; indexes are created for the capability identifiers, function categories, and descriptions of the atomic capability library; and indexes are created for the template identifiers, semantic tags, and descriptions of the component template library.
4. The method according to claim 1, characterized in that, The required information is semantically parsed, and by matching it with a pre-constructed component gene map, the corresponding component template type and one or more atomic capabilities are determined, including: Natural language processing technology is used to extract keywords from the demand information and normalize the keywords to form standardized key semantic elements. Matching the key semantic elements with the component gene map includes: calculating the similarity between the key semantic elements and the semantic tags of the component template to determine the component template type; and matching the key semantic elements with the descriptions of atomic capability units to identify one or more atomic capabilities. The similarity calculation and matching are achieved by calling a pre-trained natural language processing model.
5. The method according to claim 1, characterized in that, Based on the matched component templates and atomic capabilities, a component code skeleton is generated by retrieving and combining components from the component template library, and the parameters in the requirement information are filled into the code skeleton to generate the target component code, including: Based on the determined component template type, retrieve the corresponding basic template from the component template library; If the atomic capabilities associated with the basic template cannot cover all identified atomic capabilities, then according to the predefined combination rules, the basic template is combined with one or more other templates to generate a component code skeleton that satisfies all atomic capabilities. If the atomic capabilities associated with the basic template can cover all the identified atomic capabilities, then the basic template is directly used as the component code skeleton; The specific parameter values contained in the requirement information are filled into the corresponding placeholders in the component code skeleton to generate the target component code.
6. The method according to claim 5, characterized in that, The combination according to predefined combination rules includes: Based on the uncovered atomic capabilities, retrieve one or more other component templates associated with the corresponding atomic capabilities from the component template library; According to the code structure and interface correspondence defined by the combination rules, the code skeleton of the basic template is merged with the code skeleton of other templates to generate a unified component code skeleton.
7. The method according to claim 6, characterized in that, The predefined combination rules include at least one of the following: Container-content rules are used to insert the first component template as content into a specified slot position in the second component template; The sibling rule is used to treat the template nodes of multiple component templates as sibling nodes and wrap them in the same layout container. The controller-controlled entity rule is used to establish the control relationship between the first component template and the second component template, so that the events of the first component template can update the state that the second component template depends on. The data provider-consumer rule is used to establish a data supply relationship between the first component template and the second component template, so that the data acquired by the first component template can be passed to the second component template for use; Conditional wrapping rules are used to control the rendering state or properties of a target component template based on preset conditions.
8. A low-code platform component intelligent generation system, characterized in that, include: The requirement receiving module is used to receive user input of component generation requirement information; The gene retrieval module is used to perform semantic parsing on the requirement information, and to determine the corresponding component template type and one or more atomic capabilities by matching it with a pre-constructed component gene map; the component gene map includes an atomic capability library storing the smallest functional unit and a component template library storing parameterized component templates; The code generation module is used to retrieve and combine components from the component template library to generate a component code skeleton based on the matched and determined component templates and atomic capabilities, and to fill the parameters in the requirement information into the code skeleton to generate the target component code. The code output module is used to output the generated target component code.
9. A low-code platform component intelligent generation device, characterized in that, include: Memory, used to store intelligent generation programs for low-code platform components; A processor, configured to implement the steps of the low-code platform component intelligent generation method as described in any one of claims 1-7 when executing the low-code platform component intelligent generation program.
10. A computer-readable storage medium storing a computer program, characterized in that, The readable storage medium stores a low-code platform component intelligent generation program, which, when executed by a processor, implements the steps of the low-code platform component intelligent generation method as described in any one of claims 1-7.