Application program construction method and device based on low-code engine and electronic equipment

Abstract

This application provides a method, apparatus, and electronic device for building applications based on a low-code engine, relating to the field of application development technology. The method includes: building a low-code engine for a low-code platform and importing material components that meet preset conditions into the low-code engine, wherein the material components are basic building blocks in application development. Based on the low-code engine, a visual page for building the application is generated in the low-code platform, and a list of material components is displayed on the visual page. Then, an application prototype designed by a target user based on the component list is obtained on the visual page, and the application prototype is further transformed into a target application based on the low-code engine. Here, the application prototype is the initial model of the target application, and the target application is the final, usable product. The method of this application simplifies the complexity of application development and improves the efficiency of application building.

Description

Technical Field

[0001] This application relates to the field of application development technology, and in particular to an application building method, apparatus and electronic device based on a low-code engine. Background Technology

[0002] With the accelerating pace of digital transformation, enterprises face pressure to quickly adapt to market changes and technological advancements, making the need for rapid and efficient application development increasingly urgent. To meet this demand, many enterprises have begun adopting low-code platforms to build their applications.

[0003] Currently, a common development framework or platform is typically used to ensure that low-code platforms can provide a stable and efficient development environment to support users in visual development and rapid application building. When building applications in a low-code platform, users need to write a certain amount of code to implement the application logic, especially for complex applications that require deep customization.

[0004] However, existing technologies suffer from high application development complexity and low build efficiency. Summary of the Invention

[0005] This application provides an application building method, apparatus, and electronic device based on a low-code engine to solve the technical problems of high application development complexity and low building efficiency in the prior art.

[0006] Firstly, this application provides a method for building applications based on a low-code engine, including:

[0007] A low-code engine is built for the low-code platform, and material components that meet preset conditions are imported into the low-code engine; wherein, the material components represent basic building blocks in application development;

[0008] Based on the low-code engine, a visualization page for building applications is generated in the low-code platform, and a component list of the material components is displayed on the visualization page;

[0009] Obtain the application prototype designed by the target user on the visualization page based on the component list; transform the application prototype into a target application based on the low-code engine; wherein, the application prototype represents the initial model of the target application, and the target application represents the final product that can be put into use.

[0010] Optionally, building a low-code engine for the low-code platform includes:

[0011] Functional analysis is performed on the low-code platform to identify its core functions;

[0012] Based on the core functions, the target resources and engine body of the low-code engine are determined; wherein, the target resources indicate the relevant resources required to build the low-code engine, and the engine body is the core component of the low-code engine;

[0013] Based on the target resources and the engine body, the low-code engine is built for the low-code platform.

[0014] Optionally, the engine body of the low-code engine includes a material component protocol, and importing material components that meet preset conditions into the low-code engine includes:

[0015] Determine the preset fields pre-specified in the material component protocol;

[0016] Import the material component containing the preset fields into the low-code engine.

[0017] Optionally, the engine body of the low-code engine also includes a page skeleton, and the generation of a visual page for building the application in the low-code platform based on the low-code engine includes:

[0018] Based on the page skeleton, a basic framework for building visual pages for applications is constructed.

[0019] Based on the core functions of the low-code platform, target page elements are generated through the low-code engine; the target page elements are added to the basic framework to generate the visualization page; wherein, the target page elements are the basic units that make up the visualization page.

[0020] Optionally, the target page elements include a page rendering area and a component attribute setting area, and obtaining the application prototype designed by the target user based on the component list in the visualization page includes:

[0021] Obtain the application layout designed by the target user in the page rendering area based on the component list, and the component attributes set in the component attribute setting area; wherein, the component attribute setting area is generated based on the component attribute protocol included in the engine body of the low-code engine;

[0022] Based on the application layout and the component properties, construct the application prototype.

[0023] Optionally, the main body of the low-code engine further includes a page rendering component, and the process of transforming the application prototype into a target application based on the low-code engine includes:

[0024] Obtain the application data of the application prototype;

[0025] Based on the page rendering component, the application data is rendered to generate the target application.

[0026] Optionally, the method further includes:

[0027] Determine the preset customization requirements of the target application and obtain a custom plugin designed based on the preset customization requirements;

[0028] Integrate the custom plugin into the visualization page.

[0029] Secondly, this application provides an application building apparatus based on a low-code engine, comprising:

[0030] Build modules are used to build a low-code engine for the low-code platform;

[0031] An import module is used to import material components that meet preset conditions into the low-code engine; wherein, the material components represent basic building blocks in application development;

[0032] A generation module is used to generate a visualization page for building applications in the low-code platform based on the low-code engine, and to display a list of components of the material components in the visualization page;

[0033] The acquisition module is used to acquire the application prototype designed by the target user on the visualization page based on the component list;

[0034] The generation module is further configured to transform the application prototype into a target application based on the low-code engine; wherein the application prototype represents the initial model of the target application, and the target application represents the final product that can be put into use.

[0035] Optionally, the construction module further includes: an analysis module and a determination module.

[0036] The analysis module is used to perform functional analysis on the low-code platform in order to identify the core functions of the low-code platform.

[0037] The determining module is used to determine the target resources and engine body of the low-code engine based on the core functions; wherein, the target resources indicate the relevant resources required to build the low-code engine, and the engine body is the core component of the low-code engine;

[0038] The building module is also used to build the low-code engine for the low-code platform based on the target resources and the engine body.

[0039] Optionally, the engine body of the low-code engine includes a material component protocol.

[0040] The determining module is further configured to determine preset fields pre-specified in the material component protocol;

[0041] The import module is also used to import material components containing the preset fields into the low-code engine.

[0042] Optionally, the core of the low-code engine also includes a page skeleton.

[0043] The building module is also used to build a basic framework for constructing a visual page for the application based on the page skeleton;

[0044] The generation module is also used to generate target page elements through the low-code engine based on the core functions of the low-code platform;

[0045] The generation module further includes an adding module, used to add the target page element to the basic framework to generate the visualization page; wherein the target page element is the basic unit that makes up the visualization page.

[0046] Optionally, the target page element includes a page rendering area and a component attribute setting area.

[0047] The acquisition module is further configured to acquire the application layout designed by the target user in the page rendering area based on the component list, and the component attributes set in the component attribute setting area; wherein, the component attribute setting area is generated based on the component attribute protocol included in the engine body of the low-code engine;

[0048] The building module is also used to build the application prototype based on the application layout and the component attributes.

[0049] Optionally, the core of the low-code engine may also include a page rendering component.

[0050] The acquisition module is also used to acquire application data of the application prototype;

[0051] The generation module further includes a rendering module, used to render the application data based on the page rendering component to generate the target application.

[0052] Optionally, the determining module is further configured to determine the preset customization requirements of the target application;

[0053] The acquisition module is also used to acquire custom plugins designed based on the preset customization requirements;

[0054] The application building apparatus based on the low-code engine further includes an integration module for integrating the custom plugin into the visualization page.

[0055] Thirdly, this application provides an electronic device, comprising:

[0056] Memory and processor;

[0057] The memory stores computer-executed instructions;

[0058] The processor executes computer execution instructions stored in the memory to implement the application building method based on the low-code engine as described in the first aspect above and in various possible implementations.

[0059] Fourthly, this application provides a computer-readable storage medium storing computer-executable instructions, which, when executed by a processor, are used to implement the application building method based on a low-code engine as described in the first aspect and various possible implementations above.

[0060] Fifthly, this application provides a computer program product comprising a computer program that, when executed by a processor, implements the application building method based on a low-code engine as described in the first aspect and various possible implementations above.

[0061] This application provides a method, apparatus, and electronic device for building applications based on a low-code engine. It constructs a low-code engine for a low-code platform, importing material components that meet preset conditions into the engine. These material components are the basic building blocks in application development. The low-code engine integrates the core functions of the low-code platform, forming an organic and complete system. Based on the low-code engine, a visual page for building applications can be quickly generated within the low-code platform, displaying a list of material components for immediate use and saving initial setup costs. Subsequently, an application prototype designed by the target user based on the component list is obtained from the visual page. This prototype is then further transformed into a target application using the low-code engine. The application prototype serves as the initial model of the target application, while the target application is the final, usable product. Therefore, the low-code engine constrains the entire process of material components from creation and operation to interaction, while providing convenient component operation functions and rapid logic adjustment linkages, fully meeting the needs of rapid application development, simplifying application development complexity, and improving application building efficiency. Attached Figure Description

[0062] The accompanying drawings, which are incorporated in and form part of this specification, illustrate embodiments consistent with this application and, together with the description, serve to explain the principles of this application.

[0063] Figure 1 A flowchart illustrating the application building method based on a low-code engine provided in this application embodiment;

[0064] Figure 2 Application scenarios of the application building method based on low-code engine provided in the embodiments of this application Figure 1 ;

[0065] Figure 3 Application scenarios of the application building method based on low-code engine provided in the embodiments of this application Figure 2 ;

[0066] Figure 4 Application scenarios of the application building method based on low-code engine provided in the embodiments of this application Figure 3 ;

[0067] Figure 5 Application scenarios of the application building method based on low-code engine provided in the embodiments of this application Figure 4 ;

[0068] Figure 6 Application scenarios of the application building method based on low-code engine provided in the embodiments of this application Figure 5 ;

[0069] Figure 7 A schematic diagram of the structure of the application building apparatus based on a low-code engine provided in the embodiments of this application;

[0070] Figure 8 A hardware structure diagram of the electronic device provided in this application.

[0071] The accompanying drawings illustrate specific embodiments of this application, which will be described in more detail below. These drawings and descriptions are not intended to limit the scope of the concept in any way, but rather to illustrate the concept of this application to those skilled in the art through reference to particular embodiments. Detailed Implementation

[0072] Exemplary embodiments will now be described in detail, examples of which are illustrated in the accompanying drawings. When the following description relates to the drawings, unless otherwise indicated, the same numbers in different drawings denote the same or similar elements. The embodiments described in the following exemplary embodiments do not represent all embodiments consistent with this application. Rather, they are merely examples of apparatuses and methods consistent with some aspects of this application as detailed in the appended claims.

[0073] The terms "first," "second," "third," "fourth," etc. (if present) in the specification, claims, and accompanying drawings of this invention are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence. It should be understood that such data can be interchanged where appropriate so that embodiments of the invention described herein can be implemented, for example, in orders other than those illustrated or described herein.

[0074] In this application, the terms "exemplary" or "for example" are used to indicate examples, illustrations, or descriptions. Any embodiment or design described as "exemplary" or "for example" in this application should not be construed as being more preferred or advantageous than other embodiments or designs. Specifically, the use of terms such as "exemplary" or "for example" is intended to present the relevant concepts in a specific manner.

[0075] It should be noted that the user information (including but not limited to user device information, user personal information, etc.) and data (including but not limited to data used for analysis, data stored, data displayed, etc.) involved in this application are all information and data authorized by the user or fully authorized by all parties. Furthermore, the collection, use and processing of the relevant data must comply with relevant laws, regulations and standards, and corresponding operation entry points are provided for users to choose to authorize or refuse.

[0076] First, let me explain the terms used in this application:

[0077] Low-code platforms are software development environments designed to accelerate application creation and deployment by minimizing the need for manual coding.

[0078] Low-code engine: A software development tool that allows users to create applications by dragging and dropping components and configuring parameters through a graphical interface and pre-defined modular components.

[0079] As digital transformation accelerates, enterprises need to be able to quickly develop and deploy new applications in order to cope with the pressures brought about by digital transformation and changes in the market and technology.

[0080] Low-code platforms, as tools that simplify the application development process, allow users to create applications with minimal manual coding. By using low-code platforms, businesses can develop and deploy applications faster, thus responding more effectively to market changes and technological advancements.

[0081] Currently, a common development framework or platform is typically used to ensure that low-code platforms can provide a stable and efficient development environment. This common framework or platform provides pre-built tools designed to simplify and accelerate the application development process, making it easier for users to build common functionalities and interfaces.

[0082] However, in some cases, applications may need to implement complex business logic or undergo deep customization, requirements that exceed the capabilities of general-purpose tools. Therefore, to meet these complex or customized needs, a certain amount of code needs to be manually written to implement the specific functionality of the application.

[0083] Therefore, general-purpose development frameworks or platforms are typically designed to adapt to a wide range of application scenarios. While this versatility provides flexibility, it can lead to complex application development when dealing with specific requirements or complex application logic. Consequently, existing technologies suffer from both high application development complexity and low build efficiency.

[0084] To address the aforementioned technical problems, the inventors, considering that low-code platforms using general-purpose development frameworks or platforms cannot meet the development needs of customized target applications, decided to create a low-code engine with higher automation and functional integration for low-code platforms. In addition to providing more advanced automation tools, low-code engines also offer domain-specific functional modules and more powerful visual development capabilities. Furthermore, low-code engines typically include more built-in functions and automated processes, reducing the complexity of manual processing required by users, thereby making low-code platforms more efficient in rapidly developing and deploying applications.

[0085] The technical solution of this application and how the technical solution of this application solves the above-mentioned technical problems are described in detail below with specific embodiments. These specific embodiments can be combined with each other, and the same or similar concepts or processes may not be described again in some embodiments. The embodiments of this application will now be described with reference to the accompanying drawings.

[0086] This application provides a method for building applications based on a low-code engine. Figure 1 A flowchart illustrating the application building method based on a low-code engine provided in this application embodiment is shown below. Figure 1 As shown, this application building method based on a low-code engine includes:

[0087] S101. Build a low-code engine for the low-code platform and import material components that meet the preset conditions into the low-code engine.

[0088] Material components represent the basic building blocks in application development. Each material component may represent a specific function or page element, such as a button, form, data table, chart, etc. Preset conditions refer to certain standards or requirements that material components need to meet in order to be accepted and used by the low-code engine.

[0089] Specifically, a functional analysis is performed on the low-code platform to identify its core functions, such as component input, page design, component settings, page rendering, and data source configuration. Then, based on these core functions, the target resources and engine structure of the low-code engine are determined, and a low-code engine is built for the platform based on these resources and structure.

[0090] Among them, the target resources indicate the relevant resources required to build the low-code engine; the engine body is the core component of the low-code engine, specifically including material component protocols, component attribute protocols, page skeleton, and page rendering components.

[0091] In an interpretive sense, the Material Component Protocol aims to ensure seamless integration of material components created by different developers on a low-code engine by standardizing their definitions, interaction methods, and usage. Therefore, preset conditions that material components must meet can be specified according to the Material Component Protocol.

[0092] In one possible implementation, preset fields pre-defined in the material component protocol are identified, and material components containing these preset fields are imported into the low-code engine. It should be understood that these preset fields are mandatory for the material components. Before importing a material component into the low-code engine, each material component is checked to ensure it conforms to the material component protocol requirements so that it can interact correctly with the low-code engine.

[0093] As can be seen, the Material Component Protocol provides a unified standard for material components (see Table 1). Through the Material Component Protocol, the interfaces, data structures, styles, behaviors, and dependencies of material components are clearly defined and constrained, enabling low-code platforms to support a wider component ecosystem. Both material components contributed by third-party developers and basic components provided by the low-code platform can run within the same framework.

[0094] Table 1

[0095]

[0096]

[0097] Taking an input field as an example, the standard format provided by the material component protocol is as follows: the input field component must contain componentName and schema-related fields, which may include title, type, version, icon, group, category, and RefApiList. As long as the input field component conforms to the above standard format, it can be imported into the low-code engine.

[0098] The material component protocol is one of the core foundations of the low-code engine, and the component attribute protocol is one of the core logics of the material component protocol. The component attribute protocol involves the definition and management of material component attributes, helping users define the appearance, behavior, and interaction methods of material components. Specifically, Table 1 provides the material component protocol, and the fields related to schema in Table 1 are the component attribute protocols.

[0099] S102. Based on the low-code engine, generate a visualization page for building applications in the low-code platform, and display a list of material components in the visualization page.

[0100] It's worth noting that in the process of generating visual pages based on the low-code engine, another core component of the low-code engine—the page skeleton—was used. The page skeleton has rich extensibility capabilities and is used to display all content panels in the page's design state.

[0101] Figure 2 Application scenarios of the application building method based on low-code engine provided in the embodiments of this application Figure 1 ,like Figure 2 As shown, the page skeleton consists of six areas: topArea, toolbarArea, leftArea, mainArea, rightArea, and bottomArea. Each area can be expanded.

[0102] The top area typically features designer icons, such as back or reverse buttons for the designer's operations, and global save and preview buttons. The toolbar area is similar to the top area, often used to place utility plugins that aid in layout and operation. The content area primarily displays the canvas, with fewer extension types; common extensions include canvas size adjusters and component selection area modification. The right-hand area is often used for component property configuration; extension functions are rarely used unless there are specific needs. The bottom area usually contains operation icons.

[0103] The left-hand area is mostly displayed as icons and corresponding panels. Clicking an icon will display the corresponding panel. The main plugins in the left-hand area are: (1) Outline Tree, which displays the component hierarchy of the current visualization page; (2) Material Panel, which displays the material components supported by the current visualization page. Material components can be added to the design canvas of the visualization page by double-clicking or dragging; (3) Data Source Panel, which displays the data source information configured for the current visualization page; (4) Action Panel, which displays the action scripts configured for the current visualization page and some built-in functions, lifecycles, etc.

[0104] Furthermore, to address complex business scenarios and better support custom extension capabilities, the page skeleton also supports extensions, allowing users to register custom plugins for different business scenarios. Specifically, it identifies the target application's preset customization requirements, obtains custom plugins designed based on these requirements, and integrates these custom plugins into the visual page, such as adding a custom extension bar to the left side of the page skeleton.

[0105] Before integrating a custom plugin into the visualization page, it needs to be registered. This involves defining the plugin's name, area, type, alignment, icon, description, and content. In a specific example, the code for registering a custom plugin is as follows:

[0106] skeleton.add({

[0107] name: SkeletonExtendTest; / / The name of the extension must be unique; duplicate names will result in it being overwritten.

[0108] area:'leftArea'; / / Specifies the location to add.

[0109] type:'PanelDock'; / / Specify the type to add

[0110] props:{

[0111] align:'top'; / / align top

[0112] icon:Icon; / / Icon for the menu bar

[0113] description:'Test'; / / Description information

[0114] }

[0115] content: Hello, I am a newly added panel. ; / / Specific content

[0116] })

[0117] In one possible implementation, a basic framework for building the application's visual pages is constructed based on a page skeleton. Then, target page elements are generated using a low-code engine according to the core functionalities of the low-code platform. These target page elements are added to the basic framework to generate the visual pages. Here, the target page elements are the basic units that make up the visual pages.

[0118] The page skeleton only provides a general framework, and the internal functions or content can be customized according to needs. At the same time, the low-code engine also provides some built-in functions, such as menu content area, page rendering area, component attribute setting area, etc.

[0119] In a specific example, Figure 3 Application scenarios of the application building method based on low-code engine provided in the embodiments of this application Figure 2 , Figure 3 The visualization page shown is built using built-in features. Both the page rendering area and the component attribute setting area belong to the target page elements. In addition, the visualization page includes a menu list area and a menu content area, where the menu content area displays a list of material components.

[0120] It's important to note that the component attribute setting area relies on the component attribute setter. Specifically, the component attribute protocol provides a standardized method for describing the attributes of material components, and corresponding component attribute setters can be generated based on the component attribute protocol. The component attribute setter can be considered as an underlying logical component; by rendering the component attribute setter, the component attribute setting area in the visualization page can be obtained.

[0121] Explain that the low-code engine includes several commonly used component property setters to simplify configuration requirements for common fields. These built-in setters typically include text setters, numeric setters, and option setters. Furthermore, the low-code engine provides extension functionality; a setter management module allows for the registration and management of custom component property setters. When the built-in setters cannot fully meet specific needs, the setter management module can be used to extend and add new custom component property setters, demonstrating the low-code engine's flexibility and scalability.

[0122] For example, Figure 4 Application scenarios of the application building method based on low-code engine provided in the embodiments of this application Figure 3 ,like Figure 4 As shown, the component attribute setting area on the visualization page is the attribute panel, and the attribute panel corresponding to each material component is usually different. Figure 4 The displayed attribute panel specifically includes configuration options for the material component's title, description, placeholder information, clear button, display counter, character limit, default value, and whether barcode scanning is allowed via mobile device. The title, description, placeholder information, and default value can be configured using the text setter; the clear button, display counter, and barcode scanning can be configured using the option setter; and the character limit can be configured using a combination of the text setter and the number setter.

[0123] Furthermore, you can register a new component property setter belonging to a specific company. Set the component property setter's name (title) to "Company", the required field to "true", and the default value to "None". In a specific example, the code for registering a component property setter belonging to a specific company is as follows:

[0124] setters.registerSetter('CompanySetter',({value,onChange})=> The currently selected company is: {value} / / You can specify this directly when using it.

[0125] company:{

[0126] title:'Company Affiliation'; / / Display tag

[0127] required: true; / / Whether it is required

[0128] default:'None'; / / Default value

[0129] setter:{

[0130] name:'CompanySetter'; / / Specifies that the newly registered component property setter should be used.

[0131] }

[0132] }

[0133] It should be understood that for material components, it is only necessary to declare the field names and the names of the matching component property setters in their own metadata files. Figure 4 Taking the title of the configured material component as an example, the specific code is as follows:

[0134] label:{

[0135] title:'Title'; / / Displays the label

[0136] required: true; / / Whether it is required

[0137] default: 'Single-line text input box'; / / Default value

[0138] setter:{

[0139] name:'StringSetter'; / / The name of the component property setter, here indicating the use of a text setter.

[0140] }

[0141] }

[0142] Therefore, in the above example, configuring the title of the material component relies on the text setter, that is, the corresponding title text can be entered in the single-line text input box.

[0143] In addition, it allows for the extension of custom properties to the component property setter, such as the maximum and minimum supported values ​​for the number setter. In a specific example, the text setter and number setter can be combined to set the maximum character count for a material component, thus limiting the number of characters that can be entered. Assume the default value for the maximum character count in the number setter is set to 50, and the minimum supported character count is set to 1, with a maximum supported character count of 255. This means that by default, the maximum character count is 50, meaning the maximum number of characters that can be entered into the material component is 50. The maximum character count can be set to any number between 1 and 255. For example, when the maximum character count is 255, the maximum number of characters that can be entered into the material component is 255; when the maximum character count is 10, the maximum number of characters that can be entered into the material component is 10. The specific code is as follows:

[0144] maxLength:{

[0145] title:'Maximum word count';

[0146] default: 50; / / Default value of the field

[0147] setter:{

[0148] name:'NumberSetter';

[0149] props:{

[0150] min:1; / / Minimum number of characters supported

[0151] man: 255; / / Maximum number of characters supported

[0152] }

[0153] }

[0154] }

[0155] It should be explained that component property setters use the setter name as a unique identifier. The mapping relationship between properties and component property setters can be completed by declaring the title field of the component property setter in the schema.

[0156] In practical use, since multiple component property setters may be used simultaneously, the required component property setter is located in the setter management module by using the setter name as a unique identifier through the declaration of fields in the schema. Then, a deep recursive approach is used to render the required component property setter, thus completing the nesting, layout, and hierarchy functions of the component property setter.

[0157] Within a component property setter, only the current value of the corresponding field needs to be considered; the overall properties of the material component are not required. For example, for the title of a material component, the component property setter only needs to focus on the `title` field. However, the material component may also include multiple other fields, which can be configured by combining or nesting component property setters to complete the configuration of all the property fields of the entire material component.

[0158] S103. Obtain the application prototype designed by the target user based on the component list in the visualization page; transform the application prototype into the target application based on the low-code engine.

[0159] This step obtains the application layout designed by the target user in the page rendering area based on the component list, as well as the component properties set in the component property settings area. Based on the application layout and component properties, an application prototype is built. The application layout refers to the structure and organization of the application interface, including how material components are arranged and displayed. The application prototype is an early version (initial model) of the target application, used to test and validate design concepts.

[0160] Next, the application prototype needs to be transformed into a usable final product (the target application) using a low-code engine. The process of transforming the application prototype into the target application utilizes the page rendering components of the low-code engine's core.

[0161] It needs to be explained that, Figure 5 Application scenarios of the application building method based on low-code engine provided in the embodiments of this application Figure 4 .like Figure 5As shown, the core process of the page rendering component is as follows: First, it obtains the application data from the application prototype, such as schema JSON data, which is in a tree structure. The tree hierarchy corresponds to the material component hierarchy; each node in the tree represents a material component and has an identifier (componentName). The page rendering component uses this identifier to accurately locate the corresponding material component among the material components imported into the low-code engine for page rendering. Then, it passes the corresponding component properties as parameters into the material component, starting the next iteration of the loop. This process is repeated until the entire tree data (i.e., the application data) is completely traversed, thus successfully rendering the final page and generating the target application.

[0162] It is worth noting that, Figure 6 Application scenarios of the application building method based on low-code engine provided in the embodiments of this application Figure 5 ,like Figure 6 As shown, the rendered view in the page rendering component in design mode is interactive. The page rendering component is the core of the low-code engine's page orchestration, integrating page rendering with features such as dragging, selecting, and quickly configuring material components.

[0163] This application provides a method for building applications based on a low-code engine. It performs functional analysis on the low-code platform to identify its core functions and, based on these functions, determines the target resources and engine body of the low-code engine. Further, based on the target resources and engine body, a low-code engine is built for the low-code platform, integrating its core functions to form an organic and complete system. Based on the material component protocols included in the engine body and the pre-specified fields of these protocols, material components containing the pre-specified fields are imported into the low-code engine. Then, based on the page skeleton included in the engine body, a basic framework for building a visual page for the application is quickly constructed within the low-code platform, achieving a ready-to-use experience and saving initial setup costs. Target page elements are generated based on the core functions of the low-code platform and added to the basic framework of the visual page to generate the visual page, which also displays a list of material components. Next, the application prototype designed by the target user based on the component list in the visual page, along with corresponding application data, is obtained. Based on the page rendering components included in the engine body, the application data is rendered, ultimately generating the target application. This demonstrates that low-code engines constrain the entire process of material components from creation and operation to interaction, while providing convenient component operation functions and rapid logic adjustment linkage, fully meeting the needs of rapid application development, simplifying application development complexity, and improving application building efficiency.

[0164] Figure 7 A schematic diagram of the structure of the application building apparatus based on a low-code engine provided in the embodiments of this application is shown below. Figure 7 As shown, the application building apparatus 700 based on the low-code engine includes: a building module 701, an import module 702, a generation module 703, and an acquisition module 704.

[0165] Among them, Module 701 is used to build a low-code engine for the low-code platform;

[0166] Import module 702 is used to import material components that meet preset conditions into the low-code engine; wherein, material components represent basic building blocks in application development;

[0167] The generation module 703 is used to generate a visual page for building applications in a low-code platform based on a low-code engine, and to display a list of material components in the visual page;

[0168] Module 704 is used to obtain the application prototype designed by the target user in the visualization page based on the component list.

[0169] The generation module 703 is also used to transform the application prototype into a target application based on a low-code engine; wherein the application prototype represents the initial model of the target application, and the target application represents the final product that can be put into use.

[0170] Optionally, the construction module 701 may also include: an analysis module 705 and a determination module 706.

[0171] Analysis module 705 is used to perform functional analysis on the low-code platform in order to identify the core functions of the low-code platform;

[0172] The determination module 706 is used to determine the target resources and engine body of the low-code engine based on the core functions; wherein, the target resources indicate the relevant resources required to build the low-code engine, and the engine body is the core component of the low-code engine;

[0173] Module 701 is also used to build a low-code engine for a low-code platform based on target resources and the engine body.

[0174] Optionally, the core of the low-code engine includes material component protocols.

[0175] The determination module 706 is also used to determine preset fields pre-specified in the material component protocol;

[0176] Import module 702 is also used to import material components containing preset fields into the low-code engine.

[0177] Optionally, the core of a low-code engine may also include a page skeleton.

[0178] Module 701 is also used to build a basic framework for visual pages used to build applications, based on the page skeleton.

[0179] The generation module 703 is also used to generate target page elements through the low-code engine based on the core functions of the low-code platform;

[0180] The generation module 703 also includes an addition module 707, which is used to add target page elements to the basic framework to generate a visual page; wherein the target page elements are the basic units that make up the visual page.

[0181] Optionally, the target page elements include the page rendering area and the component attribute setting area.

[0182] The module 704 is also used to obtain the application layout designed by the target user in the page rendering area based on the component list, and the component properties set in the component property setting area; wherein, the component property setting area is generated based on the component property protocol included in the engine body of the low-code engine;

[0183] Module 701 is also used to build application prototypes based on application layout and component properties.

[0184] Optionally, the core of a low-code engine may also include page rendering components.

[0185] The acquisition module 704 is also used to acquire application data from the application prototype;

[0186] The generation module 703 also includes a rendering module 708, which is used to render application data based on the page rendering component to generate the target application.

[0187] Optionally, the determination module 706 is also used to determine the preset customization requirements of the target application;

[0188] The module 704 is also used to obtain custom plugins designed based on preset customization requirements;

[0189] The low-code engine-based application building apparatus 700 also includes an integration module 709 for integrating custom plugins into a visual page.

[0190] The application building apparatus based on a low-code engine provided in this application embodiment can be used to execute the application building method based on a low-code engine in any of the above embodiments. Its implementation principle and technical effect are similar, and will not be described again here.

[0191] It should be noted that the division of the various modules in the above device is merely a logical functional division. In actual implementation, they can be fully or partially integrated into a single physical entity, or they can be physically separated. Furthermore, these modules can be implemented entirely in software via processing element calls; they can be fully implemented in hardware; or some modules can be implemented via processing element calls in software, while others are implemented in hardware. Additionally, these modules can be fully or partially integrated together, or implemented independently. The processing element mentioned here can be an integrated circuit with signal processing capabilities. During implementation, each step of the above method or each of the above modules can be completed through integrated logic circuits in the hardware of the processor element or through software instructions.

[0192] Figure 8 A hardware structure diagram of the electronic device provided in this application. For example... Figure 8 As shown, the electronic device 800 includes:

[0193] Processor 801 and memory 802;

[0194] The memory stores instructions that the computer executes;

[0195] The processor executes computer execution instructions stored in memory 802, causing the electronic device to perform the application building method based on the low-code engine described above.

[0196] It should be understood that the processor 801 described above can be a Central Processing Unit (CPU), or other general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), etc. A general-purpose processor can be a microprocessor or any conventional processor. The steps of the method disclosed in this invention can be directly implemented by a hardware processor, or implemented by a combination of hardware and software modules within the processor. The memory 802 may include high-speed random access memory (RAM), and may also include non-volatile memory (NVM), such as at least one disk storage device, and may also be a USB flash drive, external hard drive, read-only memory, disk, or optical disc, etc.

[0197] The electronic device provided in this application embodiment can be used to execute the application building method based on the low-code engine provided in any of the above method embodiments. Its implementation principle and technical effect are similar, and will not be described again here.

[0198] This application also provides a computer-readable storage medium storing computer-executable instructions, which, when executed by a processor, are used to implement the application building method based on a low-code engine as described above.

[0199] This application also provides a computer program product, which includes a computer program that, when executed by a processor, is used to implement the application building method based on a low-code engine as described above.

[0200] It should be noted that, for the sake of simplicity, the foregoing method embodiments are all described as a series of actions. However, those skilled in the art should understand that this application is not limited to the described order of actions, as some steps may be performed in other orders or simultaneously according to this application. Furthermore, those skilled in the art should also understand that the embodiments described in the specification are all optional embodiments, and the actions and modules involved are not necessarily essential to this application.

[0201] It should be further noted that although the steps in the flowchart are shown sequentially according to the arrows, these steps are not necessarily executed in the order indicated by the arrows. Unless explicitly stated herein, there is no strict order restriction on the execution of these steps, and they can be executed in other orders. Moreover, at least some steps in the flowchart may include multiple sub-steps or multiple stages. These sub-steps or stages are not necessarily completed at the same time, but can be executed at different times. The execution order of these sub-steps or stages is not necessarily sequential, but can be performed alternately or in turn with other steps or at least some of the sub-steps or stages of other steps.

[0202] It should be understood that the above-described device embodiments are merely illustrative, and the device of this application can also be implemented in other ways. For example, the division of units / modules in the above embodiments is only a logical functional division, and there may be other division methods in actual implementation. For example, multiple units, modules, or components may be combined, or integrated into another system, or some features may be ignored or not executed.

[0203] Furthermore, unless otherwise specified, the functional units / modules in the various embodiments of this application can be integrated into one unit / module, or each unit / module can exist physically separately, or two or more units / modules can be integrated together. The integrated units / modules described above can be implemented in hardware or as software program modules.

[0204] When integrated units / modules are implemented in hardware, the hardware can be digital circuits, analog circuits, etc. The physical implementation of the hardware structure includes, but is not limited to, transistors, memristors, etc. Unless otherwise specified, the processor can be any suitable hardware processor, such as a CPU, GPU, FPGA, DSP, and ASIC, etc. Unless otherwise specified, the storage unit can be any suitable magnetic or magneto-optical storage medium, such as Resistive Random Access Memory (RRAM), Dynamic Random Access Memory (DRAM), Static Random Access Memory (SRAM), Enhanced Dynamic Random Access Memory (EDRAM), High-Bandwidth Memory (HBM), Hybrid Memory Cube (HMC), etc.

[0205] If the integrated unit / module is implemented as a software program module and sold or used as an independent product, it can be stored in a computer-readable storage device (CMD). Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, or all or part of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a memory and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods of the various embodiments of this application. The aforementioned memory includes various media capable of storing program code, such as a USB flash drive, read-only memory (ROM), random access memory (RAM), portable hard drive, magnetic disk, or optical disk.

[0206] In the above embodiments, the descriptions of each embodiment have their own emphasis. For parts not described in detail in a certain embodiment, please refer to the relevant descriptions of other embodiments. The technical features of the above embodiments can be combined arbitrarily. For the sake of brevity, not all possible combinations of the technical features in the above embodiments are described. However, as long as the combination of these technical features does not contradict each other, it should be considered within the scope of this specification.

[0207] Other embodiments of this application will readily occur to those skilled in the art upon consideration of the specification and practice of the invention disclosed herein. This application is intended to cover any variations, uses, or adaptations of this application that follow the general principles of this application and include common knowledge or customary techniques in the art not disclosed herein. The specification and examples are to be considered exemplary only, and the true scope and spirit of this application are indicated by the following claims.

[0208] It should be understood that this application is not limited to the precise structure described above and shown in the accompanying drawings, and various modifications and changes can be made without departing from its scope. The scope of this application is limited only by the appended claims.

Claims

1. A method for building applications based on a low-code engine, characterized in that, Applied to low-code platforms, the method includes: A low-code engine is built for the low-code platform, and material components that meet preset conditions are imported into the low-code engine; wherein, the material components represent the basic building blocks in application development; Based on the low-code engine, a visualization page for building applications is generated in the low-code platform, and a component list of the material components is displayed on the visualization page; Obtain the application prototype designed by the target user on the visualization page based on the component list; transform the application prototype into a target application based on the low-code engine; wherein, the application prototype represents the initial model of the target application, and the target application represents the final product that can be put into use.

2. The method according to claim 1, characterized in that, The step of building a low-code engine for the low-code platform includes: Functional analysis is performed on the low-code platform to identify its core functions; Based on the core functions, the target resources and engine body of the low-code engine are determined; wherein, the target resources indicate the relevant resources required to build the low-code engine, and the engine body is the core component of the low-code engine; Based on the target resources and the engine body, the low-code engine is built for the low-code platform.

3. The method according to claim 1, characterized in that, The engine core of the low-code engine includes a material component protocol. Importing material components that meet preset conditions into the low-code engine includes: Determine the preset fields pre-specified in the material component protocol; Import the material component containing the preset fields into the low-code engine.

4. The method according to claim 2, characterized in that, The core of the low-code engine also includes a page skeleton. The process of generating a visual page for building applications within the low-code platform based on the low-code engine includes: Based on the page skeleton, a basic framework for building visual pages for applications is constructed. Based on the core functionality of the low-code platform, target page elements are generated through the low-code engine. The target page element is added to the basic framework to generate the visualization page; wherein the target page element is the basic unit that makes up the visualization page.

5. The method according to claim 4, characterized in that, The target page elements include a page rendering area and a component attribute setting area. Obtaining the application prototype designed by the target user on the visualization page based on the component list includes: Obtain the application layout designed by the target user in the page rendering area based on the component list, and the component attributes set in the component attribute setting area; wherein, the component attribute setting area is generated based on the component attribute protocol included in the engine body of the low-code engine; Based on the application layout and the component properties, construct the application prototype.

6. The method according to claim 1, characterized in that, The core of the low-code engine also includes a page rendering component. The process of transforming the application prototype into a target application based on the low-code engine includes: Obtain the application data of the application prototype; Based on the page rendering component, the application data is rendered to generate the target application.

7. The method according to any one of claims 1 to 6, characterized in that, The method further includes: Determine the preset customization requirements of the target application and obtain a custom plugin designed based on the preset customization requirements; Integrate the custom plugin into the visualization page.

8. An application building apparatus based on a low-code engine, characterized in that, The device, applied to a low-code platform, includes: Build modules are used to build a low-code engine for the low-code platform; An import module is used to import material components that meet preset conditions into the low-code engine; wherein, the material components represent basic building blocks in application development; A generation module is used to generate a visualization page for building applications in the low-code platform based on the low-code engine, and to display a list of components of the material components in the visualization page; The acquisition module is used to acquire the application prototype designed by the target user on the visualization page based on the component list; The generation module is further configured to transform the application prototype into a target application based on the low-code engine; wherein the application prototype represents the initial model of the target application, and the target application represents the final product that can be put into use.

9. An electronic device, characterized in that, include: A processor, and a memory communicatively connected to the processor; The memory stores computer-executed instructions; The processor executes computer execution instructions stored in the memory to implement the application building method based on a low-code engine as described in any one of claims 1 to 7.

10. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores computer-executable instructions, which, when executed by a processor, are used to implement the application building method based on a low-code engine as described in any one of claims 1 to 7.

Images