Interface interaction element generation method and device, equipment, medium and program product

Abstract

The embodiment of the invention discloses an interface interaction element generation method and device, equipment, a medium and a program product. The method comprises the steps that corresponding original metadata is generated based on target generation demand information corresponding to a to-be-generated element through a target large model, the to-be-generated element is a target interface interaction element which is specified by a user and needs to be generated, and the target generation demand information carries a target element type corresponding to the target interface interaction element; performing standardization processing on the original metadata by utilizing the metadata model to obtain target metadata; and generating a target interface interaction element based on the target metadata and the target element type.

Description

Technical Field

[0001] This specification relates to the field of computer technology, and in particular to a method, apparatus, device, medium, and program product for generating interface interactive elements. Background Technology

[0002] The current process of building user interface elements (such as forms and tables) requires manually adding and configuring fields one by one, which is particularly inefficient when dealing with complex data sources or a large number of fields. Therefore, there is an urgent need for a fast and low-cost solution to enable users to build user interface elements efficiently and economically. Summary of the Invention

[0003] This specification provides a method, apparatus, device, medium, and program product for generating interface interaction elements. Through the collaboration of a target large model and a metadata model, it achieves end-to-end conversion from natural language to structured metadata. Standardized target metadata efficiently drives the generation of target interface interaction elements. It fully combines the understanding capabilities of the target large model with the standardization advantages of the metadata model. A three-layer processing structure decouples business semantics from interface implementation, significantly reducing the cost of multi-scenario adaptation, improving the system's adaptability to diverse needs and the reliability of the generated results, and enhancing reusability across scenarios and domains. This provides solid support for the rapid construction of complex business systems. The above technical solution is as follows: Firstly, embodiments of this specification provide a method for generating interface interactive elements, including: Using the target large model, the corresponding raw metadata is generated based on the target generation requirement information corresponding to the element to be generated; the aforementioned element to be generated is the target interface interaction element that the user specifies needs to generate; the aforementioned target generation requirement information carries the target element type corresponding to the aforementioned target interface interaction element. The original metadata is standardized using a metadata model to obtain the target metadata; The target interface interaction elements are generated based on the target metadata and the target element types.

[0004] Secondly, embodiments of this specification provide an interface interaction element generation apparatus, the apparatus comprising: The metadata generation module is used to generate corresponding raw metadata based on the target generation requirement information corresponding to the elements to be generated, using the target large model; the elements to be generated are the target interface interaction elements that the user specifies need to generate; the target generation requirement information carries the target element type corresponding to the target interface interaction elements. The processing module is used to standardize the above-mentioned raw metadata using the metadata model to obtain the target metadata. The element generation module is used to generate the target interface interaction elements based on the target metadata and the target element types.

[0005] Thirdly, embodiments of this specification provide an electronic device, including: a processor and a memory; The processor is connected to the memory. The aforementioned memory is used to store executable program code; The processor reads the executable program code stored in the memory to run a program corresponding to the executable program code, so as to execute the method provided in the first aspect of the embodiments of this specification.

[0006] Fourthly, embodiments of this specification provide a computer storage medium storing a plurality of instructions adapted for loading by a processor and executing the method provided in the first aspect of embodiments of this specification.

[0007] Fifthly, embodiments of this specification provide a computer program product containing instructions that, when run on a computer or processor, causes the computer or processor to execute the interface interaction element generation method provided in the first aspect of embodiments of this specification.

[0008] In the embodiments described in this specification, on the one hand, the target large model is used to automatically parse the user's target generation requirement information and generate raw metadata, realizing the automatic conversion from fuzzy requirements to precise metadata. This eliminates the need for users to manually add and configure fields one by one, improving the efficiency of interface interaction element generation, lowering the user's barrier to entry, and automatically completing data generation, allowing users to efficiently generate runnable interface interaction elements. On the other hand, the raw metadata is standardized using a metadata model, ensuring not only a unified target metadata structure and format, laying the foundation for generating accurate target interface interaction elements, improving generation consistency and maintainability, avoiding format chaos or data loss caused by manual configuration, and ensuring generation quality and stability, but also enabling the system to support diverse input sources and output products, improving flexibility and scalability. Compared to the traditional view-driven generation mode, the metadata-driven generation method is better able to handle complex business scenarios, providing comprehensive business semantic expression and ensuring business consistency. Furthermore, through the collaborative generation mechanism of target metadata and target element types, the generation targeting and system intelligence level are improved, flexibly responding to different types of interface interaction element generation requirements, exhibiting strong versatility and scalability. Furthermore, the embodiments in this specification achieve end-to-end conversion from natural language to structured metadata through the collaboration of the target big model and the metadata model. Standardized target metadata drives the generation of target interface interactive elements, fully combining the understanding capabilities of the target big model and the standardization advantages of the metadata model. Through a three-layer processing structure (input adaptation based on the target big model → standardized processing of the metadata model → output adaptation based on the target element type), business semantics and interface implementation are decoupled. Compared with traditional methods, this not only significantly reduces the cost of multi-scenario adaptation and improves the system's adaptability to diverse needs and the reliability of the generated results, but also enhances the reusability across scenarios and domains, providing solid support for the rapid construction of complex business systems. Attached Figure Description

[0009] To more clearly illustrate the technical solutions in the embodiments of this specification, the accompanying drawings used in the embodiments will be briefly introduced below. Obviously, the drawings described below are only some embodiments of this specification. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0010] Figure 1 A schematic diagram of a link for generating interface interaction elements provided in related technologies; Figure 2 A schematic diagram of the architecture of a user interface interaction element generation system provided as an exemplary embodiment of this specification; Figure 3 A flowchart illustrating a method for generating interface interaction elements provided as an exemplary embodiment of this specification; Figure 4A flowchart illustrating another method for generating interface interaction elements provided as an exemplary embodiment of this specification; Figure 5 This is a schematic diagram of a target interactive element configuration interface provided for an exemplary embodiment of this specification; Figure 6 This is a schematic diagram of a link for generating interface interaction elements, provided as an exemplary embodiment of this specification. Figure 7 A schematic diagram of the structure of an interface interaction element generation device provided for an exemplary embodiment of this specification; Figure 8 This is a schematic diagram of the structure of an electronic device provided as an exemplary embodiment of this specification. Detailed Implementation

[0011] The technical solutions in the embodiments of this specification will be clearly and completely described below with reference to the accompanying drawings.

[0012] The terms "first," "second," "third," etc., used in this specification, claims, and the foregoing drawings are used to distinguish different objects, not to describe a specific order. Furthermore, the terms "comprising" and "having," and any variations thereof, are intended to cover non-exclusive inclusion. For example, a process, method, system, product, or apparatus that includes a series of steps or units is not limited to the listed steps or units, but may optionally include steps or units not listed, or may optionally include other steps or units inherent to such processes, methods, products, or apparatus.

[0013] It should be noted that the information (including but not limited to user device information, user personal information, etc.), data (including but not limited to data used for analysis, stored data, displayed data, etc.), and signals involved in the embodiments of this specification are all authorized by the user or fully authorized by all parties, and the collection, use, and processing of related data must comply with the relevant laws, regulations, and standards of the relevant countries and regions. For example, the target generation requirement information and target adjustment requirement information involved in this specification were obtained under full authorization.

[0014] In related UI / UX element generation technologies, taking form generation as an example, according to the form design document, basic components such as form containers, field containers, and input controls already exist. However, if... Figure 1As shown, when building a form, users need to manually add and configure fields one by one based on the structure and data provided by the data source through a guided building engine, and then call components to generate the form on a low-code platform. This is inefficient for scenarios with complex data sources or a large number of fields. Furthermore, it can only complete the initial form building (assuming there is already a submission interface), but not only are the generated forms unusable directly and require users to perform a lot of secondary configuration (such as selecting data sources from dropdowns), but extending to a new generation source is costly, and the generation logic needs to be adapted for each set.

[0015] Based on this, this specification provides a method for generating interface interaction elements. First, using a target large model, corresponding raw metadata is generated based on the target generation requirement information corresponding to the element to be generated. The element to be generated is the target interface interaction element specified by the user, and the target generation requirement information carries the target element type corresponding to the target interface interaction element. Then, the raw metadata is standardized using a metadata model to obtain target metadata. Finally, the target interface interaction element is generated based on the target metadata and the target element type. On the one hand, the target large model automatically parses the user's target generation requirement information and generates raw metadata, achieving automatic conversion from fuzzy requirements to precise metadata. This eliminates the need for users to manually add and configure fields one by one, improving the efficiency of interface interaction element generation, lowering the user's barrier to entry, and automatically completing data generation, allowing users to efficiently generate runnable interface interaction elements. On the other hand, using a metadata model to standardize the raw metadata not only ensures the uniformity of the target metadata structure and format, laying the foundation for generating accurate target interface interaction elements, improving the consistency and maintainability of the generation, avoiding problems such as format chaos or data loss caused by manual configuration, and ensuring generation quality and stability, but also enables the system to support diverse input sources and output products, improving flexibility and scalability. Compared to traditional view-driven generation, metadata-driven generation is better suited to complex business scenarios, providing comprehensive business semantic expression and ensuring business consistency. Furthermore, through a collaborative generation mechanism between target metadata and target element types, it enhances the targeting and intelligence of the generation process, flexibly addressing the generation needs of different types of interface interaction elements, and exhibits strong versatility and scalability. In addition, the embodiments in this specification achieve end-to-end conversion from natural language to structured metadata through the collaboration of the target large model and the metadata model. Standardized target metadata drives the generation of target interface interaction elements, fully combining the understanding capabilities of the target large model with the standardization advantages of the metadata model. A three-layer processing structure (input adaptation based on the target large model → standardized processing of the metadata model → output adaptation based on the target element type) decouples business semantics from interface implementation. Compared to traditional methods, this not only significantly reduces the cost of multi-scenario adaptation and improves the system's adaptability to diverse needs and the reliability of the generated results, but also enhances cross-scenario and cross-domain reusability, providing solid support for the rapid construction of complex business systems.

[0016] Please refer to the following. Figure 2 , Figure 2 This is a schematic diagram of the architecture of a user interface interaction element generation system provided as an exemplary embodiment of this specification. Figure 2 As shown, the interface interaction element generation system may include: a terminal 210 and a server 220. Wherein: Terminal 210 may include one or more user terminals, i.e., terminals used by users who need to create interface interaction elements. One or more user-version applications may be installed on terminal 210. Terminal 210 can establish a data relationship with a network and, through this network, establish a data connection with server 220, such as sending target generation requirement information and receiving target interface interaction elements obtained after the server 220 generates interface interaction elements. Terminal 210 may be, but is not limited to, devices such as mobile phones, tablets, and laptops with user-version applications installed.

[0017] Server 220 can be a server that can generate various interface interaction elements. Server 220 can be, but is not limited to, a hardware server, a virtual server, a cloud server, etc.

[0018] Optionally, after receiving the target generation requirement information corresponding to the element to be generated sent by the terminal 210, the server 220 can first use the target big model to generate the corresponding raw metadata based on the target generation requirement information corresponding to the element to be generated. The element to be generated is the target interface interaction element that the user specifies needs to generate, and the target generation requirement information carries the target element type corresponding to the target interface interaction element. Then, the raw metadata is standardized using the metadata model to obtain the target metadata. Finally, the target interface interaction element is generated based on the target metadata and the target element type.

[0019] It is understood that the above-mentioned process of generating interface interaction elements is not limited to being executed by the server 220, but can also be executed by the terminal 210. This specification does not specifically limit this embodiment. The following embodiments are all described using the server 220 as an example of generating the above-mentioned interface interaction elements.

[0020] The network can be a medium that provides a communication link between server 220 and terminal 210, or it can be the Internet, which includes network devices and transmission media, and is not limited thereto. The transmission media can be a wired link, such as, but not limited to, coaxial cable, fiber optic cable, and digital subscriber line (DSL), or a wireless link, such as, but not limited to, wireless fidelity (WIFI), Bluetooth, and mobile device networks.

[0021] Understandably, Figure 2The number of terminals 210 and servers 220 in the interface interaction element generation system shown is merely an example. In a specific implementation, the interface interaction element generation system can contain any number of terminals 210 and servers. This specification does not specifically limit this. For example, but not limited to, terminal 210 can be a terminal cluster composed of multiple terminals, and server 220 can be a server cluster composed of multiple servers.

[0022] Next, combine Figure 2 This document describes the method for generating interface interaction elements provided in the embodiments of this specification. Please refer to the following for details. Figure 3 This is a flowchart illustrating a method for generating interface interaction elements provided in an exemplary embodiment of this specification. Figure 3 As shown, the method for generating interactive elements in this interface includes the following steps: S302: Using the target large model, generate the corresponding raw metadata based on the target generation requirement information corresponding to the element to be generated. The element to be generated is the target interface interaction element that the user specifies to be generated.

[0023] Specifically, the aforementioned target generation requirement information can be, but is not limited to, the requirement description information corresponding to the element to be generated input by the user, such as "We're having a team building activity, please generate a form for collecting team outing identity information." This target generation requirement information carries the target element type corresponding to the target interface interaction element, such as, but not limited to, forms, tables, lists, pop-ups, etc. The aforementioned raw metadata is structured information describing the data structure and business semantics of the target interface interaction element, such as, but not limited to, element information including field types, data constraints, entity relationships, etc. The target large model can... by However, it is not limited to deep learning-based natural language processing models. This model is trained based on the generation requirements of multiple known metadata sources, possessing powerful semantic understanding and information extraction and generation capabilities. Upon receiving the target generation requirement information, the target large model can analyze and parse it, identifying the key information contained therein, such as the target element type of the target interface interaction elements (e.g., whether a form or table needs to be generated), required fields, data constraints, etc., and generating corresponding raw metadata based on this key information. This ensures semantic integrity and conforms to user intent, outputting an intermediate data format (raw metadata) that can drive front-end rendering, providing a foundation for subsequent standardized processing.

[0024] In the embodiments described in this specification, the target large model is used to automatically parse the target generation requirement information specified by the user and generate the corresponding original metadata. This eliminates the need for the user to manually add and configure fields one by one during the generation process of interface interaction elements. By automatically and accurately understanding the user's generation requirements through the target large model, the automatic conversion from vague requirements to precise metadata is achieved, which greatly improves the generation efficiency of interface interaction elements. Even when facing complex data sources or a large number of fields that need to be configured, it can quickly and accurately generate target interface interaction elements that meet the requirements. It can also lower the user's usage threshold and automatically complete data generation such as enumeration options, allowing users to directly and efficiently generate working interface interaction elements.

[0025] Optionally, the above-mentioned S302, the process of generating corresponding raw metadata based on the target generation requirement information corresponding to the element to be generated using the target large model, may include, but is not limited to, generating corresponding raw metadata based on the target generation requirement information and target prompt words corresponding to the element to be generated using the target large model. The aforementioned target prompt words are used to guide the target large model in generating raw metadata that conforms to the target structure, ensuring that the output format of the raw metadata is consistent with the predefined metadata structure (target structure). Target prompt words may include, but are not limited to, configuration guidance information such as field naming conventions, data type mapping rules, and constraint expression syntax, assisting the target large model in accurately generating structured content that conforms to the subsequent processing flow. This embodiment of the specification enhances the controllability and standardization of the generation process by introducing target prompt words, enabling the raw metadata to simultaneously meet business needs and system parsing requirements at both the semantic and structural levels, thereby improving the overall generation quality and stability. The design of the target prompt words balances flexibility and constraint, guiding the target large model to focus on key semantic information while preventing the generated results from deviating from the expected structure.

[0026] Optionally, the above-mentioned S302, the process of generating corresponding raw metadata based on the target generation requirement information corresponding to the element to be generated using the target large model, may also include, but is not limited to, generating corresponding raw metadata based on the target generation requirement information and business model corresponding to the element to be generated using the target large model. The aforementioned business model describes the business logic and rules, defines the data structure and constraints, and is used to guide the target large model in generating target interface interaction elements that conform to specific business requirements and specifications, thereby improving the practicality and accuracy of the target interface interaction elements.

[0027] S304 uses a metadata model to standardize the original metadata to obtain the target metadata.

[0028] Specifically, a metadata model is a predefined set of rules and standards used to standardize raw metadata. Upon receiving the raw metadata generated by the target large model, the metadata model checks and adjusts it according to established rules to ensure the uniformity of the target metadata's structure and format. For example, for field types, the metadata model standardizes their naming conventions and data formats; for entity relationships, it clarifies their association methods and logic. Through standardization, not only is a foundation laid for generating accurate target interface interactive elements, improving consistency and maintainability, and avoiding formatting issues or data loss that may result from manual configuration, thus ensuring generation quality and stability, but the system also supports diverse input sources and output products, enhancing flexibility and scalability.

[0029] In the embodiments of this specification, the raw metadata is standardized using a metadata model, ensuring that the generated target metadata has a unified structure and format. This lays a solid foundation for the subsequent generation of accurate and effective target interface interaction elements, effectively improves the consistency and maintainability of interface interaction element generation, avoids format chaos or data loss caused by manual configuration, and further guarantees the generation quality and stability of interface interaction elements. Furthermore, the unified metadata model enables the interface interaction element generation system to support diverse input sources and output products (interface interaction elements) during the interface interaction element generation process, significantly improving the flexibility and scalability of the system. Compared to the traditional view-driven generation mode, the metadata-driven generation method in the embodiments of this specification is more effective in handling complex business scenarios, providing a more comprehensive business semantic expression, and ensuring business consistency among different generated products.

[0030] Optionally, the above-mentioned S304, which standardizes the original metadata using the metadata model to obtain the target metadata, may include, but is not limited to, the following steps: verifying the original metadata using the metadata model to obtain the target verification result; if the target verification result indicates verification failure, then executing the above-mentioned S302 again based on the corresponding target verification error information, using the target large model to generate the corresponding original metadata based on the target generation requirement information corresponding to the element to be generated, that is, using the target large model to generate the corresponding original metadata based on the target generation requirement information and target verification error information corresponding to the element to be generated; if the target verification result indicates verification success, then the original metadata is determined as the standardized target metadata.

[0031] Optionally, the metadata model incorporates a rich set of validation rules, covering aspects such as data format, field naming, data type, and constraints. When the raw metadata enters the metadata model, it is validated against these rules. If validation fails, it indicates a non-compliance with specifications. In this case, the metadata model generates detailed target validation error information, which is fed back to the target model. Upon receiving this error information, the target model combines it with existing target generation requirements to regenerate the raw metadata, ensuring it meets the metadata model's validation requirements. If validation succeeds, the raw metadata conforms to specifications, and the metadata model identifies it as standardized target metadata, providing a reliable data foundation for subsequent generation of target interface interaction elements. This validation and feedback mechanism in the embodiments of this specification not only improves the quality of target metadata but also effectively reduces interface generation errors caused by non-standard data. By iteratively optimizing the raw metadata, it can stably output expected interface interaction elements in complex business scenarios, ensuring the reliability and maintainability of the generated results. Meanwhile, this mechanism improves human-machine collaboration efficiency, allowing developers to focus more on defining business logic rather than adjusting data formats, further enhancing development efficiency and system intelligence. The closed-loop design of the verification process ensures that metadata becomes increasingly complete during generation and correction, with each feedback deepening the understanding of business semantics. When the target verification error information is accurately located and returned, the target large model not only corrects the data surface structure but also reconstructs the underlying logical consistency, gradually bringing the generated result closer to the ideal form. This dynamic optimization mechanism is akin to cognitive iteration, establishing a synergistic tension between rule constraints and intelligent generation. This allows technical implementation to move beyond the application of static templates and towards true semantic-driven development, ensuring that the final generated target metadata not only meets business requirements but also possesses a high degree of standardization and consistency.

[0032] Furthermore, the process of validating the original metadata using the metadata model to obtain the target validation result may include, but is not limited to, performing structural and business logic validation on the original metadata using the metadata model to obtain the target validation result. If the structural validation or business logic validation corresponding to the original metadata fails, the target validation result indicates validation failure; in this case, the target validation result may include, but is not limited to, target validation error information. The aforementioned target validation error information may include, but is not limited to, descriptions of the location and / or content of the validation error in the original metadata. If the structural validation and business logic validation corresponding to the original metadata succeed, the metadata model will confirm that the original metadata conforms to the predefined syntax specifications and semantic constraints, and the target validation result indicates validation success.

[0033] The aforementioned structural validation primarily verifies the organizational structure of the original metadata, ensuring that its field definitions, hierarchical relationships, and data types conform to established metadata structure standards. For example, it checks whether form fields contain necessary labels, whether input types are correct, and whether reasonable constraints (such as required fields or length limits) are set. Business logic validation delves further into the business rules level, verifying whether the original metadata meets the logical requirements of specific business scenarios. For instance, in an order processing system, it verifies whether the "total amount" field in the order form is automatically calculated based on the "unit price" and "quantity," and whether it updates in real time when the quantity or unit price of the goods is modified.

[0034] This specification's embodiments employ dual safeguards—structural validation and business logic validation—to ensure that the metadata model can comprehensively and accurately identify potential problems in the original metadata and generate detailed target validation error information. This information not only indicates the specific location of the error (e.g., a field or business rule) but also describes the content of the error (e.g., data type mismatch, business logic conflict), providing a clear direction for the correction of the target large model. Upon receiving the target validation error information, the target large model combines the original target generation requirements with targeted adjustments and optimizations to the original metadata. This process may involve multiple aspects such as adding, deleting, and modifying fields, converting data types, and refactoring business logic, aiming to ensure that the newly generated original metadata simultaneously meets both structural specifications and business logic requirements. Through this closed-loop validation and feedback mechanism, the interface interaction element generation method in this specification's embodiments can continuously improve the quality of the target metadata, thereby generating more accurate and reliable target interface interaction elements.

[0035] S306, Generate target interface interaction elements based on target metadata and target element type.

[0036] Optionally, after obtaining the target metadata, the system will call the corresponding generation logic and template according to the target element type specified by the user, and populate the target metadata into the template to generate the target interface interaction element. For example, if the target element type is a form, the system will generate a complete form interface based on the form template and the field information and data constraints in the target metadata; if the target element type is a table, the system will generate a table interface containing the corresponding data based on the table template and the data structure and entity relationships in the target metadata. Through the collaborative generation mechanism of target metadata and target element type, the system can flexibly respond to the generation needs of different types of interface interaction elements, and has strong versatility and scalability.

[0037] Optionally, the implementation process of generating target interface interaction elements based on target metadata and target element types in S306 above may also include, but is not limited to, calling the target generator corresponding to the target element type and generating the target interface interaction elements based on the target metadata. Different target element types require different target generators; for example, generating a form requires calling a form generator, generating a table requires calling a table generator, etc. The target generator is designed for the interface element structure and interaction characteristics of the target element type and is registered through a plug-in approach to manage the generation logic of different types of interface interaction elements. After receiving the target metadata, the target generator parses its field structure, constraints, and business semantics, and maps the metadata to specific interface components and their behavior configurations according to preset interface rules and interaction logic. For example, text fields are automatically bound to input box controls and validation rules are set, while date type fields are associated with date pickers and configured with corresponding format validation and interaction events. For complex data relationships, the target generator can automatically build advanced interaction functions such as cascading selection and dynamic linkage to ensure that the generated target interface interaction elements are not only structurally compliant but also have interaction logic that meets the actual needs of the business scenario. This mechanism enables the system to efficiently generate high-fidelity interface prototypes, significantly reducing manual coding costs and improving development efficiency and consistency. Simultaneously, the target generator supports extension and customization; developers can register new generator plugins based on specific business scenarios to adapt to evolving interface specifications and interaction patterns. During the generation process, the system records metadata mapping logs in real time, facilitating traceability and debugging, and ensuring the interpretability and stability of the generated results.

[0038] Furthermore, the target generator can dynamically adjust the response rules and data binding logic of interface interaction elements during the rendering process by combining runtime environment parameters, ensuring consistent functional performance and visual presentation across different terminal devices and user operating habits. The generated target interface interaction elements can be, but are not limited to, synchronized in real-time to the development environment or preview platform for users to perform visual verification and interactive testing. The system supports fine-grained adjustments to the generated results, allowing developers to make localized corrections to layout, style, and data mapping relationships through configuration parameters or drag-and-drop operations, and feed these modifications back to the metadata layer to drive iterative updates. Simultaneously, all generation records and changed versions can be automatically archived, facilitating the tracking of generation logic and output differences at different stages. The target interface interaction elements output by the target generator support automatic integration with backend services, completing interface binding and request parameter mapping through the data source configuration defined in the target metadata. The system can recognize user operation behavior and dynamically adjust the interaction logic, improving response accuracy and scene adaptability.

[0039] In the embodiments of this specification, through the collaborative generation mechanism of target metadata and target element type, suitable interface interaction element rendering templates and interaction logic can be intelligently matched to realize the automated layout and dynamic behavior binding of target interface interaction elements. Thus, end-to-end generation from requirements to visualization can be completed without manual intervention, significantly improving the efficiency of interface interaction element generation and the level of system intelligence. It can also flexibly cope with various types of interface interaction element generation requirements, and has strong versatility and scalability. Meanwhile, the embodiments in this specification achieve end-to-end conversion from natural language description to structured metadata through the synergistic effect of the target big model and the metadata model. Standardized target metadata is used as an intermediate product to drive the generation of target interface interaction elements required by users. By fully combining the understanding capabilities of the target big model and the standardization advantages of the metadata model, a three-layer processing structure (input adaptation based on the target big model → standardization processing of the metadata model → output adaptation based on the target element type) is used to decouple business semantics from interface implementation. Compared with the traditional view-driven approach, this not only significantly reduces the cost of multi-scenario adaptation for the generation of interface interaction elements and improves the system's adaptability to diverse needs and the reliability of the generated results, but also enhances the reusability across scenarios and domains, providing solid support for the rapid construction of complex business systems.

[0040] In some possible embodiments, after standardizing the original metadata using a metadata model to obtain the target metadata in step S306 above, the method for generating interface interaction elements may further include, but is not limited to, storing the target metadata using a metadata model. During storage, the metadata model may, but is not limited to, classify and organize the target metadata according to different business scenarios, element types, and other dimensions, so that the target metadata can be quickly retrieved and called subsequently, and it is also convenient to manage and maintain historically generated target metadata. For example, when business rules or interface specifications change, the stored target metadata can be easily updated and adjusted in batches to ensure that the generated interface interaction elements always meet the latest business requirements.

[0041] Please refer to the following. Figure 4 This is a flowchart illustrating another method for generating interface interaction elements provided in an exemplary embodiment of this specification. Figure 4 As shown, the method for generating interactive elements in this interface may include, but is not limited to, the following steps: S402: Using the target large model, generate the corresponding raw metadata based on the target generation requirement information corresponding to the element to be generated. The element to be generated is the target interface interaction element that the user specifies to be generated.

[0042] Specifically, S402 is the same as S302, and will not be repeated here.

[0043] S404 uses a metadata model to standardize the original metadata and obtain the target metadata.

[0044] Specifically, S404 is the same as S304, and will not be repeated here.

[0045] S406, Generate target interface interaction elements based on target metadata and target element type.

[0046] Specifically, S406 is the same as S306, and will not be repeated here.

[0047] S408 displays the corresponding target interactive element configuration interface based on the target interface interactive elements.

[0048] Specifically, after generating the target interface interactive element, the target interface interactive element is also sent to the terminal so that the terminal can display the corresponding target interactive element configuration interface (e.g., but not limited to) according to the type and characteristics of the target interface interactive element. Figure 5 (As shown). This target interactive element configuration interface provides users with an intuitive and convenient operating environment, enabling them to further personalize and adjust the generated target interface interactive elements. For example, for form-type interface interactive elements, the configuration interface may include, but is not limited to, options for adding, deleting, and modifying fields, setting field attributes (such as whether they are required, input type, length limit, etc.), and adjusting the form layout; for table-type interface interactive elements, the configuration interface may provide, but is not limited to, options for adjusting column width, setting sorting and filtering functions, and customizing data display formats. Through these configuration options, users can flexibly adjust the appearance and behavior of the target interface interactive elements according to actual business needs, ensuring that they better meet the requirements of the business scenario. Simultaneously, the configuration interface also supports real-time preview functionality, allowing users to instantly see the changes in the target interface interactive elements when adjusting configuration parameters, thereby more intuitively evaluating the configuration effect and improving configuration efficiency and accuracy. Furthermore, the configuration interface may also provide, but is not limited to, functions for saving and exporting configurations, allowing users to save the adjusted configuration parameters for later reuse or sharing with other developers, further improving development efficiency and collaboration.

[0049] S410: Obtain the user's input of target configuration adjustment requirements based on the target interactive element configuration interface.

[0050] Specifically, the target configuration adjustment information entered by users through the target interactive element configuration interface can cover multiple aspects. For example, but not limited to, users may want to adjust the layout of the target interface interactive elements, changing vertically arranged components to horizontally arranged ones, or changing the spacing and size between components to optimize the overall visual effect and space utilization. Regarding field attribute settings, users can modify the input type of fields according to actual business needs, such as changing text input boxes to drop-down selection boxes, or adjusting attributes such as field length limits and whether a field is required, to ensure data accuracy and completeness. For form-type interface interactive elements, users can make significant adjustments to the form layout, such as combining multiple fields into different blocks, or changing the form's display order to improve the user experience when filling out the form. For table-type interface interactive elements, users can also fine-tune column widths to highlight important data, or set sorting and filtering functions to facilitate users' quick search and browsing of required data, and can also customize the data display format, such as setting the number of digits displayed for numbers, the format of dates, etc. After obtaining this target configuration adjustment requirement information, the system will feed it back to the target large model so that it can make corresponding adjustments and optimizations to the target interface interaction elements based on this information, ensuring that the target interface interaction elements can accurately meet the user's personalized needs, and further improve user satisfaction and system usability.

[0051] S412 utilizes the target big model to update the target metadata based on the target adjustment requirement information.

[0052] Specifically, after receiving the target configuration adjustment request information, the target big data model analyzes and parses it to accurately identify the specific adjustments the user expects to make to the target interface interactive elements. Then, based on these adjustments and the existing target metadata, the target big data model leverages its powerful understanding and processing capabilities to perform targeted updates to the target metadata. For example, if the user wants to adjust the input type of a form field, the target big data model will modify the corresponding field's input type attribute in the target metadata; if the user adjusts the column width or data display format of a table, the target big data model will also update the data information related to the table structure and display in the target metadata accordingly. In this way, it ensures that the target metadata can reflect the user's personalized configuration needs for the target interface interactive elements in real time and accurately, providing a solid data foundation for subsequently generating interface interactive elements that meet the user's expectations. The updated target metadata will then re-enter the subsequent generation process to ensure that the final target interface interactive elements presented to the user are completely consistent with the user's configuration adjustments.

[0053] S414, Update the target interface interaction elements based on the updated target metadata.

[0054] In the embodiments described in this specification, users can adjust the layout structure and interaction rules of the target interface interactive elements in real time through a visual configuration interface. The system automatically updates the metadata and triggers the regeneration of the target interface interactive elements to ensure that the modifications take effect immediately.

[0055] Please refer to the following. Figure 6 This is a schematic diagram illustrating a link for generating interface interaction elements, provided in an exemplary embodiment of this specification. For example... Figure 6 As shown, the generation chain of this interface interaction element includes an external input relationship chain, an internal processing relationship chain, and an output relationship chain. The external input relationship chain includes: Developer → Low-code Platform → Input Source Adaptation Layer, where users provide business requirements (target generation requirement information) through the platform interface, and the platform passes these requirements to the metadata-driven generation engine for processing; LLM (Target Large Model) Service → Input Source Adaptation Layer, where the target large model provides natural language understanding and processing capabilities to the input source adaptation layer; and Business Modeling Tools → Input Source Adaptation Layer, where business modeling tools provide structured business model definitions to the input source adaptation layer. The input source adaptation layer is responsible for connecting to various input sources (natural language / DTO / business model, etc.) and standardizing them, then passing the processed unified format (raw metadata) to the internal processing relationship chain, which then enters the metadata-driven generation engine. This engine, combined with the target large model parsing and generation logic, drives the dynamic reconstruction of metadata. The internal processing chain includes: Input Source Adaptation Layer → Generator Registry Center (requests the corresponding target generator based on the type of the input target element); Generator Registry Center → Generator Instance (calls the specific generator instance (i.e., the target generator) based on the request); Input Source Adaptation Layer → Generator Instance → Metadata Model Layer (calls the target generator to process the specific input (raw metadata), converting it into standardized metadata); Metadata Model Layer → Metadata Storage (persistently stores and retrieves the standardized target metadata); Metadata Model Layer → Generator Instance → Output Adaptation Layer (provides standardized target metadata for the target generator to use, and the output adaptation layer calls the corresponding target generator to convert the standardized metadata into specific target interface interactive elements (final output)). The output chain includes: Output Adaptation Layer → Low-Code Platform (the output adaptation layer returns the final output to the platform for display and execution).

[0056] Please refer to the following. Figure 7 This is a schematic diagram of the structure of an interface interaction element generation device provided in an exemplary embodiment of this specification. Figure 7 As shown, the interface interaction element generation device 700 includes: Metadata generation module 710 is used to generate corresponding raw metadata based on the target generation requirement information corresponding to the element to be generated, using the target large model; the element to be generated is the target interface interaction element that the user specifies needs to generate; the target generation requirement information carries the target element type corresponding to the target interface interaction element.

[0057] The processing module 720 is used to standardize the above-mentioned original metadata using the metadata model to obtain the target metadata.

[0058] The element generation module 730 is used to generate the target interface interaction elements based on the target metadata and the target element type.

[0059] In one possible implementation, the metadata generation module 710 is specifically used for: Using the target big model, the corresponding raw metadata is generated based on the target generation requirement information and target prompt words corresponding to the elements to be generated; the aforementioned target prompt words are used to guide the aforementioned target big model to generate raw metadata that conforms to the target structure.

[0060] In one possible implementation, the processing module 720 includes: The verification unit is used to verify the original metadata using the metadata model to obtain the target verification result; The execution unit is used to, if the above target verification result indicates that the verification failed, execute the above steps of using the target large model to generate the corresponding original metadata based on the target generation requirement information corresponding to the element to be generated again based on the corresponding target verification error information. The determining unit is used to determine the above-mentioned original metadata as standardized target metadata if the above-mentioned target verification result indicates that the verification is successful.

[0061] In one possible implementation, the above verification unit is specifically used for: The original metadata is subjected to structural and business logic validation using the metadata model to obtain the target validation result. If the structural validation or business logic validation corresponding to the original metadata fails, the target validation result indicates validation failure. If the structural validation and business logic validation corresponding to the original metadata succeed, the target validation result indicates validation success.

[0062] In one possible implementation, the element generation module 730 described above is specifically used for: The target generator corresponding to the above target element type is invoked to generate the above target interface interaction element based on the above target metadata; different target element types correspond to different target generators.

[0063] In one possible implementation, the aforementioned interface interaction element generation device 700 further includes: The storage module is used to store the target metadata using the aforementioned metadata model.

[0064] In one possible implementation, the aforementioned interface interaction element generation device 700 further includes: The display module is used to display the corresponding target interactive element configuration interface based on the above-mentioned target interface interactive elements. The acquisition module is used to acquire the user's target configuration adjustment requirements based on the above-mentioned target interactive element configuration interface; The first update module is used to update the target metadata based on the target adjustment requirement information using the aforementioned target big model. The second update module is used to update the target interface interaction elements based on the updated target metadata.

[0065] The division of modules in the above-described interface interaction element generation device is for illustrative purposes only. In other embodiments, the interface interaction element generation device can be divided into different modules as needed to complete all or part of the functions of the above-described interface interaction element generation device. The implementation of each module in the interface interaction element generation device provided in the embodiments of this specification can be in the form of a computer program. This computer program can run on a terminal or server. The program modules constituted by this computer program can be stored in the memory of the terminal or server. When the computer program is executed by a processor, it implements all or part of the steps of the interface interaction element generation method described in the embodiments of this specification.

[0066] Please refer to the following. Figure 8 , Figure 8 This is a schematic diagram of the structure of an electronic device provided as an exemplary embodiment of this specification. For example... Figure 8 As shown, the electronic device 800 may include: at least one processor 810, at least one communication bus 820, a user interface 830, at least one network interface 840, and a memory 850. The communication bus 820 can be used to enable communication between the aforementioned components.

[0067] The user interface 830 may include a display screen and a camera. Optionally, the user interface 830 may also include a standard wired interface and a wireless interface.

[0068] The network interface 840 may optionally include a Bluetooth module, a Near Field Communication (NFC) module, a Wireless Fidelity (Wi-Fi) module, etc.

[0069] The processor 810 may include one or more processing cores. The processor 810 connects to various parts within the electronic device 800 using various interfaces and lines, and performs various functions and processes data by running or executing instructions, programs, code sets, or instruction sets stored in the memory 850, and by calling data stored in the memory 850. Optionally, the processor 810 may be implemented using at least one hardware form of Digital Signal Processing (DSP), Field-Programmable Gate Array (FPGA), or Programmable Logic Array (PLA). The processor 810 may integrate one or a combination of several of the following: a Central Processing Unit (CPU), a Graphics Processing Unit (GPU), and a modem. The CPU primarily handles the operating system, user interface, and applications; the GPU is responsible for rendering and drawing the content required for display; and the modem handles wireless communication. It is understood that the modem may also not be integrated into the processor 810 and may be implemented as a separate chip.

[0070] The memory 850 may include random access memory (RAM) or read-only memory (ROM). Optionally, the memory 850 may include a non-transitory computer-readable medium. The memory 850 may be used to store instructions, programs, code, code sets, or instruction sets. The memory 850 may include a program storage area and a data storage area, wherein the program storage area may store instructions for implementing an operating system, instructions for at least one function (such as interface interaction element generation function, metadata generation function, etc.), instructions for implementing the above-described method embodiments, etc.; the data storage area may store data involved in the above-described method embodiments, etc. Optionally, the memory 850 may also be at least one storage device located remotely from the aforementioned processor 810. Figure 8 As shown, the memory 850, which serves as a computer storage medium, may include an operating system, a network communication module, a user interface module, and application programs.

[0071] Specifically, the processor 810 can be used to call the application stored in the memory 850 and perform the following operations: using the target big model, generating corresponding raw metadata based on the target generation requirement information corresponding to the element to be generated; the element to be generated is the target interface interaction element that the user needs to generate; the target generation requirement information carries the target element type corresponding to the target interface interaction element; using the metadata model to standardize the raw metadata to obtain target metadata; and generating the target interface interaction element based on the target metadata and the target element type.

[0072] In some possible embodiments, when the processor 810 executes the above-described method of generating corresponding raw metadata based on the target generation requirement information corresponding to the element to be generated using the target large model, it specifically performs the following: Using the target big model, the corresponding raw metadata is generated based on the target generation requirement information and target prompt words corresponding to the elements to be generated; the aforementioned target prompt words are used to guide the aforementioned target big model to generate raw metadata that conforms to the target structure.

[0073] In some possible embodiments, when the processor 810 performs the above-described standardization process of the original metadata using the metadata model to obtain the target metadata, it specifically performs the following: The original metadata is validated using the metadata model to obtain the target validation result. If the target validation result indicates that the validation failed, the steps of generating the corresponding original metadata using the target big model and the target generation requirement information corresponding to the element to be generated are executed again based on the corresponding target validation error information. If the target validation result indicates that the validation was successful, the original metadata is determined as the standardized target metadata.

[0074] In some possible embodiments, when the processor 810 performs the above-described verification of the original metadata using the metadata model to obtain the target verification result, it specifically performs the following: The original metadata is subjected to structural and business logic validation using the metadata model to obtain the target validation result. If the structural validation or business logic validation corresponding to the original metadata fails, the target validation result indicates validation failure. If the structural validation and business logic validation corresponding to the original metadata succeed, the target validation result indicates validation success.

[0075] In some possible embodiments, when the processor 810 executes the above-mentioned generation of the target interface interaction element based on the target metadata and the target element type, it is specifically used to perform: The target generator corresponding to the above target element type is invoked to generate the above target interface interaction element based on the above target metadata; different target element types correspond to different target generators.

[0076] In some possible embodiments, after the processor 810 performs the above-described standardization process of the original metadata using the metadata model to obtain the target metadata, it is further used to perform: The aforementioned target metadata is stored using the metadata model described above.

[0077] In some possible embodiments, after the processor 810 executes the above-mentioned generation of the target interface interaction element based on the target metadata and the target element type, it is further configured to execute: Based on the aforementioned target interface interaction elements, display the corresponding target interaction element configuration interface; based on the aforementioned target interaction element configuration interface, obtain the user's input target configuration adjustment requirement information; using the aforementioned target big model, update the aforementioned target metadata based on the aforementioned target adjustment requirement information; update the aforementioned target interface interaction elements based on the updated aforementioned target metadata.

[0078] This specification also provides a computer-readable storage medium storing instructions that, when executed on a computer or processor, cause the computer or processor to perform one or more steps in the above embodiments. If the constituent modules of the above-described interface interaction element generation device are implemented as software functional units and sold or used as independent products, they can be stored in the above-described computer-readable storage medium.

[0079] In the above embodiments, implementation can be achieved, in whole or in part, through software, hardware, firmware, or any combination thereof. When implemented in software, it can be implemented, in whole or in part, as a computer program product. The computer program product includes one or more computer instructions. When these computer program instructions are loaded and executed on a computer, all or part of the processes or functions described in the embodiments of this specification are generated. The computer can be a general-purpose computer, a special-purpose computer, a computer network, or other programmable device. The computer instructions can be stored in or transmitted through a computer-readable storage medium. The computer instructions can be transmitted from one website, computer, server, or data center to another website, computer, server, or data center via wired means, such as coaxial cable, fiber optic cable, Digital Subscriber Line (DSL), or wireless means (e.g., infrared, wireless, microwave, etc.). The computer-readable storage medium can be any available medium accessible to a computer or a data storage device such as a server or data center that integrates one or more available media. The aforementioned available media can be magnetic media (e.g., floppy disks, hard disks, magnetic tapes), optical media (e.g., Digital Versatile Discs, DVDs), or semiconductor media (e.g., Solid State Disks, SSDs).

[0080] Those skilled in the art will understand that all or part of the processes in the methods of the above embodiments can be implemented by a computer program instructing related hardware. This program can be stored in a computer-readable storage medium, and when executed, it can include the processes of the embodiments of the methods described above. The aforementioned storage medium includes various media capable of storing program code, such as ROM, RAM, magnetic disks, or optical disks. Unless otherwise specified, the technical features of this embodiment and its implementation can be combined arbitrarily.

[0081] The embodiments described above are merely preferred embodiments of this specification and are not intended to limit the scope of this specification. Any modifications and improvements made to the technical solutions of this specification by those skilled in the art without departing from the spirit of this specification should fall within the protection scope defined by the claims.

[0082] The foregoing has described specific embodiments of this specification. Other embodiments are within the scope of the appended claims. In some cases, the actions or steps recorded in the claims and specification may be performed in a different order than in the embodiments described in the specification and may still achieve the desired result. Furthermore, the processes depicted in the drawings do not necessarily require the specific or sequential order shown to achieve the desired result. In some embodiments, multitasking and parallel processing are also possible or may be advantageous.

Claims

1. A method for generating interface interactive elements, the method comprising: Using the target large model, the corresponding raw metadata is generated based on the target generation requirement information corresponding to the element to be generated; The element to be generated is the target interface interaction element that the user specifies needs to generate. The target generation requirement information carries the target element type corresponding to the target interface interaction element; The original metadata is standardized using a metadata model to obtain the target metadata; The target interface interaction elements are generated based on the target metadata and the target element type.

2. The method as described in claim 1, wherein generating corresponding raw metadata based on the target generation requirement information corresponding to the element to be generated using the target large model includes: Using the target big model, the corresponding raw metadata is generated based on the target generation requirement information and target prompt words corresponding to the elements to be generated; The target cue words are used to guide the target large model in generating raw metadata that conforms to the target structure.

3. The method as described in claim 1, wherein the standardization process of the original metadata using a metadata model to obtain the target metadata includes: The original metadata is validated using a metadata model to obtain the target validation result; If the target verification result indicates that the verification failed, then the step of using the target large model to generate the corresponding original metadata based on the target generation requirement information corresponding to the element to be generated is executed again based on the corresponding target verification error information. If the target verification result indicates successful verification, then the original metadata is determined as standardized target metadata.

4. The method as described in claim 3, wherein the step of validating the original metadata using a metadata model to obtain a target validation result includes: The original metadata is subjected to structural and business logic validation using the metadata model to obtain the target validation result. If the original metadata structure verification fails or the business logic verification fails, the target verification result indicates that the verification failed. If the original metadata corresponds to a structure verification and a business logic verification, the target verification result indicates successful verification.

5. The method as described in claim 1, wherein generating the target interface interaction element based on the target metadata and the target element type comprises: Invoke the target generator corresponding to the target element type to generate the target interface interaction element based on the target metadata; The target element type is different, and the corresponding target generator is called differently.

6. The method of claim 1, wherein after standardizing the original metadata using a metadata model to obtain the target metadata, the method further includes: The target metadata is stored using the metadata model.

7. The method of claim 1, wherein after generating the target interface interaction element based on the target metadata and the target element type, the method further includes: Based on the target interface interactive elements, the corresponding target interactive element configuration interface is displayed; Based on the target interactive element configuration interface, obtain the user's target configuration adjustment requirements information; Using the target big model, update the target metadata based on the target adjustment requirement information; The target interface interaction elements are updated based on the updated target metadata.

8. A device for generating interface interaction elements, the device comprising: The metadata generation module is used to generate the corresponding raw metadata based on the target generation requirement information corresponding to the element to be generated, using the target large model. The element to be generated is the target interface interaction element that the user specifies needs to generate. The target generation requirement information carries the target element type corresponding to the target interface interaction element; The processing module is used to standardize the original metadata using a metadata model to obtain the target metadata; The element generation module is used to generate the target interface interaction elements based on the target metadata and the target element type.

9. An electronic device, comprising: Processor and memory; The processor is connected to the memory; The memory is used to store executable program code; The processor runs a program corresponding to the executable program code stored in the memory to perform the method as described in any one of claims 1-7.

10. A computer storage medium storing a plurality of instructions adapted for loading by a processor and executing the steps of the method as claimed in any one of claims 1-7.

11. A computer program product containing instructions that, when run on a computer or processor, causes the computer or processor to perform the interface interaction element generation method as described in any one of claims 1-7.

Images