Low-code platform-oriented application front-end export method and device, and electronic equipment

Abstract

This application provides a method, apparatus, and electronic device for exporting application front-ends to low-code platforms, relating to the field of application development technology. The method includes: parsing an application in a low-code platform to identify the application front-end; then, determining the user interface and user interaction logic included in the application front-end, reconstructing the user interface and user interaction logic to obtain a reconstructed application front-end; further, obtaining the front-end code of the reconstructed application front-end, and exporting the front-end code from the low-code platform. The method of this application enables independent management and deployment of applications outside of a low-code platform, improving the scalability of applications.

Description

Technical Field

[0001] This application relates to the field of application development technology, and in particular to an application front-end export method, apparatus and electronic device for low-code platforms. Background Technology

[0002] As digitalization accelerates, businesses and developers are increasingly demanding higher efficiency and flexibility in application development. Low-code platforms have emerged to address this need, enabling rapid application building through a visual approach and minimal manual coding.

[0003] Low-code platforms typically provide a standardized set of tools and components suitable for rapid development and common needs. Different enterprises and developers accumulate a large number of applications built on low-code platforms during the application development process. As businesses grow and change, there is a need to manage the versions of these applications, extend their functionality, and deploy them within low-code platforms or their managed environments.

[0004] However, existing technologies struggle to achieve independent management and deployment of applications outside of low-code platforms, resulting in limitations on application expansion. Summary of the Invention

[0005] This application provides a method, apparatus, and electronic device for exporting application front-ends to low-code platforms, in order to solve the technical problem in the prior art that it is difficult to achieve independent management and deployment of applications without a low-code platform, resulting in certain limitations on the expansion of applications.

[0006] Firstly, this application provides a method for exporting application front-ends for low-code platforms, including:

[0007] The application in the low-code platform is parsed to identify the application's front-end;

[0008] The user interface and user interaction logic included in the application front end are determined, and the user interface and user interaction logic are reconstructed to obtain the reconstructed application front end;

[0009] Obtain the front-end code of the refactored application front-end, and export the front-end code from the low-code platform.

[0010] Optionally, the step of reconstructing the user interface and the user interaction logic to obtain the reconstructed application front end includes:

[0011] The interface type of the user interface is determined, and a corresponding interface template library is determined based on the interface type; the user interface is reconstructed based on the interface template library to obtain a reconstructed user interface; wherein, the interface template library includes basic configurations suitable for the corresponding user interface;

[0012] Obtain the target user's preset needs, and based on the preset needs and the reconstructed user interface, reconstruct the user interaction logic to obtain the reconstructed user interaction logic;

[0013] Based on the reconstructed user interface and the reconstructed user interaction logic, the reconstructed application front end is determined.

[0014] Optionally, the step of reconstructing the user interface based on the interface template library to obtain a reconstructed user interface includes:

[0015] Based on the basic configuration contained in the interface template library, determine the construction resources required for the user interface;

[0016] Based on the aforementioned resources, a basic framework for reconstructing the user interface is built; based on the basic framework, the reconstructed user interface is generated.

[0017] Optionally, generating the reconstructed user interface based on the basic framework includes:

[0018] The user interface is parsed to determine its core configuration; based on the core configuration, the user interface is modularized to obtain corresponding code modules.

[0019] Based on the user interaction logic, the code module is integrated into the basic framework of the corresponding reconstructed user interface to generate the reconstructed user interface.

[0020] Optionally, the step of reconstructing the user interaction logic to obtain reconstructed user interaction logic further includes:

[0021] Based on the reconstructed user interaction logic, the reconstructed user interface is optimized and adjusted.

[0022] Perform a correctness test on the optimized and reconstructed user interface, and determine the reconstructed user interface that passes the correctness test.

[0023] Optionally, parsing the application in the low-code platform includes:

[0024] Determine the global code and global configuration of the application in the low-code platform; wherein, the global configuration represents configuration files or parameters that affect the overall behavior and settings of the application;

[0025] The global code and global configuration are parsed to obtain the front-end code library of the application.

[0026] Optionally, the method further includes:

[0027] Identify the secondary developments performed by the target users on the front-end code and obtain the corresponding secondary development files;

[0028] The secondary development files are deployed to the target platform; wherein, the target platform represents a platform other than the low-code platform.

[0029] Secondly, this application provides an application front-end export device for low-code platforms, comprising:

[0030] The parsing module is used to parse the applications in the low-code platform to identify the application front-end of the applications;

[0031] The reconstruction module is used to determine the user interface and user interaction logic included in the application front end, and to reconstruct the user interface and user interaction logic to obtain the reconstructed application front end.

[0032] The export module is used to obtain the front-end code of the refactored application front-end and export the front-end code from the low-code platform.

[0033] Optionally, the reconstruction module further includes: a determining module and an obtaining module.

[0034] The determining module is used to determine the interface type of the user interface and determine the corresponding interface template library based on the interface type.

[0035] The reconstruction module is further configured to reconstruct the user interface based on the interface template library to obtain a reconstructed user interface; wherein, the interface template library includes basic configurations suitable for the corresponding user interface;

[0036] The acquisition module is used to acquire the preset requirements of the target user;

[0037] The reconstruction module is also used to reconstruct the user interaction logic based on the preset requirements and the reconstructed user interface to obtain the reconstructed user interaction logic.

[0038] The determining module is further configured to determine the reconstructed application front-end based on the reconstructed user interface and the reconstructed user interaction logic.

[0039] Optionally, the determining module is further configured to determine the building resources required for the user interface based on the basic configuration contained in the interface template library;

[0040] The reconstruction module also includes: a construction module and a generation module.

[0041] The building module is used to build a basic framework for reconstructing the user interface based on the building resources;

[0042] The generation module is used to generate the reconstructed user interface based on the basic framework.

[0043] Optionally, the determining module is further configured to parse the user interface, determine the core configuration of the user interface, and perform modular processing on the user interface based on the core configuration to obtain corresponding code modules;

[0044] The generation module further includes an integration module, used to integrate the code module into the basic framework of the corresponding reconstructed user interface based on the user interaction logic, so as to generate the reconstructed user interface.

[0045] Optionally, the reconstruction module further includes: a processing module, used for:

[0046] Based on the reconstructed user interaction logic, the reconstructed user interface is optimized and adjusted.

[0047] Perform a correctness test on the optimized and reconstructed user interface, and determine the reconstructed user interface that passes the correctness test.

[0048] Optionally, the determining module is further configured to determine the global code and global configuration of the application in the low-code platform; wherein the global configuration represents configuration files or parameters that affect the overall behavior and settings of the application;

[0049] The parsing module is also used to parse the global code and the global configuration to obtain the front-end code library of the application.

[0050] Optionally, the determining module is further configured to determine the secondary development performed by the target user on the front-end code;

[0051] The acquisition module is also used to acquire corresponding secondary development files;

[0052] The application front-end export device for low-code platforms further includes: a deployment module for deploying the secondary development files to the target platform; wherein the target platform represents a platform other than the low-code platform.

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

[0054] Memory and processor;

[0055] The memory stores computer-executed instructions;

[0056] The processor executes computer execution instructions stored in the memory to implement the application front-end export method for low-code platforms as described in the first aspect above and in various possible implementations.

[0057] 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 front-end export method for low-code platforms as described in the first aspect and various possible implementations above.

[0058] Fifthly, this application provides a computer program product comprising a computer program that, when executed by a processor, implements the application front-end export method for low-code platforms as described in the first aspect and various possible implementations above.

[0059] This application provides a method, apparatus, and electronic device for exporting application front-ends to low-code platforms. It parses applications within a low-code platform to identify the application's front-end. Then, it determines the user interface and user interaction logic included in the application front-end, and reconstructs these elements to obtain a reconstructed application front-end. The reconstructed application front-end removes all low-code platform-specific services, meaning it no longer depends on the back-end services provided by the low-code platform. Next, it obtains the front-end code of the reconstructed application front-end and exports it from the low-code platform. The front-end code exported from the low-code platform can be independently managed and deployed, giving users complete control over it. Users can modify and optimize the front-end code as needed, thereby improving the application's scalability. Attached Figure Description

[0060] 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.

[0061] Figure 1 A flowchart illustrating the application front-end export method for low-code platforms provided in this application embodiment. Figure 1 ;

[0062] Figure 2 An application scenario diagram for the application front-end export method for low-code platforms provided in the embodiments of this application;

[0063] Figure 3 A flowchart illustrating the application front-end export method for low-code platforms provided in this application embodiment. Figure 2 ;

[0064] Figure 4 A flowchart illustrating the application front-end export method for low-code platforms provided in this application embodiment. Figure 3 ;

[0065] Figure 5 A schematic diagram of the structure of an application front-end export device for low-code platforms provided in an embodiment of this application;

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

[0067] 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

[0068] 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.

[0069] 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.

[0070] 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.

[0071] 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.

[0072] Modern enterprises are undergoing rapid digital transformation, with more and more business processes and user interactions moving towards digitalization. In this rapidly changing environment, businesses and developers need more efficient development tools to quickly create and deploy applications in order to respond promptly to business changes and user needs.

[0073] Therefore, low-code platforms were developed. These platforms typically provide a visual development environment that allows users to create applications by dragging and dropping components and configuring pre-built modules. Low-code platforms offer a set of pre-designed, standardized tools and components suitable for rapidly developing common application needs.

[0074] Different companies and developers have accumulated a large number of applications built on low-code platforms during the application development process. As business needs change, it is necessary to manage the versions of existing applications, add new features, or deploy applications.

[0075] Because applications are built on low-code platforms and require operation within those platforms or their hosting environments, these management and deployment operations are difficult to separate from the low-code platform itself. This means that enterprises may be limited by the low-code platform when extending application functionality, and cannot develop with complete freedom. This may include features not supported by the low-code platform, performance limitations, or other technical obstacles.

[0076] Therefore, existing technologies have the technical problem of making it difficult to achieve independent management and deployment of applications outside of low-code platforms, resulting in certain limitations on the expansion of applications.

[0077] To address the aforementioned technical problems, the inventors, during their research on managing and deploying applications developed on low-code platforms, discovered that the reason applications are difficult to separate from low-code platforms is their reliance on the backend services provided by those platforms. Based on this, the inventors conceived of separating the application's frontend from its backend services, and only refactoring the frontend. The purpose of this refactoring is to ensure that the frontend no longer depends on the backend services provided by the low-code platform, making it more independent. The refactored frontend is then exported from the low-code platform; at this point, the frontend is no longer limited by the low-code platform and can be arbitrarily expanded according to actual needs.

[0078] 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.

[0079] This application provides a method for exporting application front-ends for low-code platforms. Figure 1 A flowchart illustrating the application front-end export method for low-code platforms provided in this application embodiment. Figure 1 ,like Figure 1 As shown, this application front-end export method for low-code platforms includes:

[0080] S101. Parse the application in the low-code platform to identify the application's front end.

[0081] Specifically, the global code and global configuration of the application in the low-code platform are determined, and the global code and global configuration are parsed to obtain the application's front-end code library. Then, the application front-end of the application is identified based on the front-end code library.

[0082] Global code typically refers to code snippets or scripts that are common throughout the application. These snippets or scripts may be used to handle common logic, data processing, and Application Programming Interface (API) calls. Global configuration refers to configuration files or parameters that affect the overall behavior and settings of the application, such as global variables, global parameters, and global data sources. It should be understood that global configurations are shared within the application.

[0083] The identified application frontend needs to be separated from the application. In a specific example, Figure 2 This application scenario diagram illustrates the method for exporting the application front-end to a low-code platform as provided in the embodiments of this application. Figure 2 As shown, the "Export Source Code" button is located in the operation list for applications in the "Completed Development" state. Source code export is allowed when the application front-end is in the "Completed Development" state; it is not allowed when the application front-end is in the "Incomplete Development" state. Clicking the "Export Source Code" button will take you to the source code export information configuration page. On this page, users can select the version of the application front-end to be exported, the export title, and remarks. After configuration, clicking "Confirm" will trigger the application front-end source code export process.

[0084] S102. Determine the user interface and user interaction logic included in the application front end, reconstruct the user interface and user interaction logic, and obtain the reconstructed application front end.

[0085] In an explanatory sense, the application front-end mainly involves the user interface and user interaction logic. By designing the user interface and user interaction logic, an intuitive, easy-to-use, and efficient user front-end can be built. The user interface specifically includes visual design, components and elements, and responsive design, while the user interaction logic specifically includes event handling, dynamic updates, navigation, and workflow.

[0086] Visual design encompasses the application's appearance, including layout, colors, fonts, icons, and other visual elements. The goal of visual design is to create an intuitive and engaging interface. Components and elements such as buttons, forms, menus, and charts are the basic units for user interaction with the application. Responsive design ensures that the application displays and functions correctly on different devices and screen sizes.

[0087] Event handling defines the events triggered by user actions (such as clicks, input, swipes, etc.) and their response behaviors. Dynamic updates manage dynamic changes to the user interface, such as asynchronous content loading, animation effects, and real-time data updates. Navigation and flow concern the user's navigation paths and interaction flows within the application to ensure a smooth and consistent user experience.

[0088] It should be understood that application front-ends rely on low-code platform-specific APIs, services, or components. Therefore, a certain degree of refactoring is required to replace or simulate these dependencies and remove all low-code platform-specific services. After refactoring, the application front-end can then become an independent front-end, separate from the low-code platform.

[0089] Therefore, the user interface and user interaction logic need to be refactored separately to obtain the refactored application front-end. In one possible implementation, the interface type is first determined, which involves identifying the application scenario or functional module to which the user interface belongs, such as a dashboard, form, or list view. Secondly, because different types of user interfaces may have different design requirements, and the basic configuration of the same type of user interface is consistent, a corresponding interface template library can be determined based on the interface type. This interface template library includes basic configurations suitable for the corresponding user interface. The user interface is then refactored based on the interface template library to obtain the refactored user interface. This means replacing or improving the current user interface implementation with the basic configurations (such as components and layouts) from the interface template library.

[0090] Specifically, based on the basic configuration contained in the interface template library, the build resources required for the user interface are determined, that is, which resources (such as components, style files, icon libraries, etc.) are necessary for building the user interface. Based on the build resources, a basic framework for reconstructing the user interface is built, and the reconstructed user interface is generated based on the basic framework.

[0091] In a specific example, the build resources required for the user interface include relevant resource configurations, dependencies, and control-related configuration files. In addition, some components in the existing user interface may request data from remote sources. To ensure that the application front-end exported from the low-code platform can run independently of the low-code platform, mock services are automatically generated to handle component data requests. Users can also develop custom server-side data based on the mock service's data structure; subsequently, they only need to replace the actual data request address with the server address.

[0092] Furthermore, the interface list data of the user interface can be parsed, and a routing structure for the user interface can be generated based on information such as the user interface identifier, name, and type. Combined with the routing structure, the basic framework for reconstructing the user interface can be built using construction resources.

[0093] Next, we obtain the target users' pre-defined needs, which may include how users want to interact with the application, what functions they need, and their expectations for the user experience. Based on these pre-defined needs and the refactored user interface, we refactor the user interaction logic to obtain the refactored user interaction logic. User interaction logic involves the flow and methods by which users perform actions within the application, such as clicking buttons, filling out forms, and navigation menus. Refactoring the user interaction logic means redesigning these interaction flows to better meet user needs. Based on the refactored user interface and the refactored user interaction logic, we can then determine the refactored application front-end.

[0094] It's important to note that the basic framework for refactoring the user interface is a preliminary, simplified structure, including only basic elements such as layout, placeholder content, styles, and the main body, without populating specific content like dynamic data and interaction logic. Therefore, specific content needs to be added to this basic framework to obtain a complete refactored user interface. The specific content to add can be determined based on the existing user interface in the application's front end.

[0095] In one possible implementation, the user interface data is obtained, the user interface is parsed based on the user interface data, the core configuration of the user interface is determined, and the user interface is modularized according to the core configuration of the user interface to obtain the corresponding code modules.

[0096] Understandably, an application front-end comprises multiple user interfaces, and the logic of a single user interface can be divided into many parts, such as importing global configurations, lifecycle logic, and associated data sources. When modularizing the user interface, each logical part corresponds to a code module; therefore, multiple code modules can be obtained.

[0097] In a specific example, the parsing of each user interface is independent of each other. Starting with the configuration of the user interface (such as the schema), the parsing process analyzes the component composition and hierarchical structure of the entire user interface, as well as key configuration items such as lifecycle, data source, and style interface.

[0098] Each user interface corresponds to a module code processor. For example, the module code processor corresponding to the lifecycle handles the user page's lifecycle logic, splitting the corresponding lifecycle functions and generating them during the user interface refactoring. The main lifecycle nodes are: when the user page finishes loading and when the user interface is closed. The module code processor corresponding to the style interface handles the user interface's styles, splitting and reorganizing the style data configured on component properties into Cascading Style Sheets (CSS) files, and converting the style setting logic that originally depended on the low-code platform into style files, allowing the user interface styles to take effect independently of the low-code platform. The module code processor corresponding to the data source handles the user interface's data source data, processing the original data source data separately into a JSON format data source. In addition, there is a module code processor for handling the main structure of the user page, splitting it according to the component hierarchy in the user interface configuration, converting the original JSON data into relevant code (such as JSX code), which is the main content of the refactored user interface.

[0099] It's important to explain that if the low-code platform is designed to drive UI generation and modular processing via JSON configuration, then parsing the module code processor into JSON data is necessary. Specifically, based on the application identifier, some global configurations related to building the basic framework for refactoring the user interface can be obtained, such as application variables, application option sets, and application attachment sets. These global configurations will be parsed into corresponding JSON data by the module code processor and stored in a preset file.

[0100] Modular code generation is achieved by processing the corresponding user interface through a module code processor. It's important to note that each module code processor dynamically generates code modules with specific tags, which clearly identify the user interface and logical type to which the code module belongs. After all the module code processors have returned code modules, a dedicated code assembler processes these modules. This assembler categorizes and sorts the code modules according to their various identifiers, piecing them together into a complete codebase.

[0101] Furthermore, based on user interaction logic, the code modules are integrated into the corresponding basic framework of the refactored user interface to generate the refactored user interface. It should be noted that, to optimize code readability and standardization, the code modules can be uniformly formatted before integrating them into the basic framework of the refactored user interface to eliminate whitespace characters and line breaks caused by concatenation.

[0102] During integration, user interaction logic guides how to associate code modules with UI elements to ensure that events correctly trigger the corresponding module functions. For example, a button click event might need to be bound to a specific code module to execute its function.

[0103] It's important to note that during the initial integration phase, the existing user interaction logic of the application's front-end will be used to guide the integration of code modules, quickly establishing a functional interface for easy testing and verification of basic functionality. Once the refactored user interaction logic is defined and implemented, the refactored user interface will be optimized and adjusted. This involves modifying code modules, adding new code modules, or adjusting the interface layout to ensure that the final refactored user interface fully utilizes these improved user interaction logics. Simultaneously, the optimized and adjusted refactored user interface undergoes correctness testing. If the refactored user interface fails the correctness test, optimization and adjustments will continue until it passes the correctness test, ultimately determining the refactored user interface that passes the correctness test.

[0104] S103. Obtain the front-end code of the refactored application front-end and export the front-end code from the low-code platform.

[0105] It should be explained that when exporting front-end code from a low-code platform, exporting it in the form of a directory structure is a common practice. This format helps maintain the organization and maintainability of the code, making it easier for users to understand and navigate the code library.

[0106] In a specific example, based on the code module descriptions, such as module name, function, dependencies, and location, a file structure tree is generated for all code modules and the refactored application front-end framework, with each file's path corresponding precisely to the application front-end's directory structure. This directory structure is then converted into a file object, and this file object, along with related files, is exported from the low-code platform as a compressed package and provided to the user.

[0107] In summary, Figure 3 A flowchart illustrating the application front-end export method for low-code platforms provided in this application embodiment. Figure 2 .like Figure 3As shown in a specific example, exporting the application front-end from a low-code platform includes the following steps:

[0108] S301. Separate the application front-end from the application application;

[0109] S302. Determine the user interface and user interaction logic of the application front end;

[0110] S303. Determine the corresponding interface template library according to the interface type of the user interface, and build the basic framework for reconstructing the user interface based on the interface template library.

[0111] S304. Modularize the user interface using a module code processor to obtain corresponding code modules;

[0112] S305. Based on user interaction logic, integrate the code modules into the basic framework of the corresponding refactored user interface to generate the refactored user interface;

[0113] S306. Obtain the target user's preset needs, and reconstruct the user interaction logic based on the preset needs and the reconstructed user interface to obtain the reconstructed user interaction logic.

[0114] S307. Based on the reconstruction of the user interface and the reconstruction of the user interaction logic, determine the reconstructed application front end;

[0115] S308. Package the front-end code of the application front-end and export it from the low-code platform.

[0116] It should be noted that by exporting the application's front-end code from the low-code platform and providing it to users, users can then perform secondary development on the application's front-end. In one possible implementation, the secondary development work performed by the target users on the front-end code is identified, and the corresponding secondary development files are obtained. These files are then deployed to platforms other than the low-code platform.

[0117] in, Figure 4 A flowchart illustrating the application front-end export method for low-code platforms provided in this application embodiment. Figure 3 .like Figure 4 As shown, after the target user receives the packaged front-end code, the steps for secondary development are as follows:

[0118] S401. Unzip the packaged front-end code file and obtain the front-end code from it;

[0119] S402. Install the dependencies required for the front-end code and execute the development commands;

[0120] S403. Set up the development environment and enter development mode;

[0121] S404. The target user performs secondary development on the front-end code in the development environment;

[0122] S405. After the secondary development is completed, execute the packaging command to integrate and package the secondary development results.

[0123] S406. Deploy the secondary development packaged files to platforms other than the low-code platform.

[0124] This application provides a method for exporting application front-ends for low-code platforms. It parses the application within the low-code platform to identify the application's front-end. Next, it determines the user interface and user interaction logic included in the front-end. Based on the interface type, it identifies the corresponding interface template library and, based on the basic configuration contained in the interface template library, determines the build resources required for the user interface. Further, based on these build resources, it builds a basic framework for reconstructing the user interface. Simultaneously, it parses the user interface to determine its core configuration and modularizes it based on this core configuration to obtain corresponding code modules. Next, based on the user interaction logic, it integrates the code modules into the corresponding basic framework of the reconstructed user interface to generate the reconstructed user interface. After obtaining the reconstructed user interface, it acquires the target user's preset requirements. Based on these requirements and the reconstructed user interface, it reconstructs the user interaction logic to obtain reconstructed user interaction logic. Then, based on the reconstructed user interface and the reconstructed user interaction logic, it determines the reconstructed application front-end. The reconstructed application front-end removes all low-code platform-specific services, meaning it no longer depends on the back-end services provided by the low-code platform. Finally, it obtains the front-end code of the reconstructed application front-end and exports it from the low-code platform. The front-end code exported from the low-code platform can be independently managed and deployed. Users have complete control over the front-end code and can make any modifications and optimizations as needed to achieve secondary development of the application. The entire secondary development process is no longer limited by the functionality of the low-code platform, thereby improving the scalability of the application.

[0125] Figure 5 This is a schematic diagram of the structure of the application front-end export device for low-code platforms provided in the embodiments of this application, as shown below. Figure 5 As shown, the application front-end export device 500 for low-code platforms includes: a parsing module 501, a refactoring module 502, and an export module 503.

[0126] The parsing module 501 is used to parse the application in the low-code platform to identify the application's front end.

[0127] The refactoring module 502 is used to determine the user interface and user interaction logic included in the application front end, and to refactor the user interface and user interaction logic to obtain the refactored application front end.

[0128] Export module 503 is used to obtain the front-end code of the refactored application front-end and export the front-end code from the low-code platform.

[0129] Optionally, the reconstruction module 502 may also include: a determination module 504 and an acquisition module 505.

[0130] Module 504 is used to determine the interface type of the user interface and determine the corresponding interface template library based on the interface type.

[0131] The reconstruction module 502 is also used to reconstruct the user interface based on the interface template library to obtain the reconstructed user interface; wherein, the interface template library includes basic configurations applicable to the corresponding user interface;

[0132] Module 505 is used to obtain the preset requirements of the target user;

[0133] The refactoring module 502 is also used to refactor the user interaction logic based on preset requirements and the refactored user interface to obtain the refactored user interaction logic.

[0134] The determination module 504 is also used to determine the reconstructed application front end based on the reconstructed user interface and reconstructed user interaction logic.

[0135] Optionally, module 504 is also used to determine the build resources required for the user interface based on the basic configuration contained in the interface template library;

[0136] Reconstruction module 502 also includes: construction module 506 and generation module 507.

[0137] Module 506 is used to build the basic framework for reconstructing the user interface based on build resources;

[0138] Module 507 is used to generate a refactored user interface based on the basic framework.

[0139] Optionally, module 504 is also used to parse the user interface and determine its core configuration; based on the core configuration, the user interface is modularized to obtain the corresponding code modules;

[0140] The generation module 507 also includes an integration module 508, which integrates the code module into the basic framework of the corresponding refactored user interface based on the user interaction logic to generate the refactored user interface.

[0141] Optionally, the refactoring module 502 further includes: a processing module 509, used for:

[0142] Based on the reconstructed user interaction logic, the reconstructed user interface was optimized and adjusted;

[0143] Perform correctness testing on the optimized and reconstructed user interface to determine which user interface passes the correctness test.

[0144] Optionally, the determination module 504 is also used to determine the global code and global configuration of the application in the low-code platform; wherein, the global configuration represents the configuration files or parameters that affect the overall behavior and settings of the application;

[0145] The parsing module 501 is also used to parse global code and global configuration to obtain the application's front-end code library.

[0146] Optionally, module 504 can also be used to determine the secondary development of the front-end code by the target user;

[0147] The module 505 is also used to obtain the corresponding secondary development files;

[0148] The application front-end export device 500 for low-code platforms also includes: a deployment module 510 for deploying secondary development files to the target platform; wherein, the target platform represents a platform other than the low-code platform.

[0149] The application front-end export device for low-code platforms provided in this application embodiment can be used to execute the application front-end export method for low-code platforms in any of the above embodiments. Its implementation principle and technical effect are similar, and will not be described again here.

[0150] 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.

[0151] Figure 6 A hardware structure diagram of the electronic device provided in this application. For example... Figure 6 As shown, the electronic device 600 includes:

[0152] Processor 601 and memory 602;

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

[0154] The processor executes computer execution instructions stored in memory 602, causing the electronic device to execute the application front-end export method for low-code platforms as described above.

[0155] It should be understood that the processor 601 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 602 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.

[0156] The electronic device provided in this application embodiment can be used to execute the application front-end export method for low-code platforms provided in any of the above method embodiments. Its implementation principle and technical effect are similar, and will not be described again here.

[0157] 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 front-end export method for low-code platforms as described above.

[0158] 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 front-end export method for low-code platforms as described above.

[0159] 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.

[0160] 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.

[0161] 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.

[0162] 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.

[0163] 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.

[0164] 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.

[0165] 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.

[0166] 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.

[0167] 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 exporting application front-ends for low-code platforms, characterized in that, include: The application in the low-code platform is parsed to identify the application's front-end; The user interface and user interaction logic included in the application front end are determined, and the user interface and user interaction logic are reconstructed to obtain the reconstructed application front end; Obtain the front-end code of the refactored application front-end, and export the front-end code from the low-code platform.

2. The method according to claim 1, characterized in that, The process of reconstructing the user interface and the user interaction logic to obtain the reconstructed application front-end includes: The interface type of the user interface is determined, and a corresponding interface template library is determined based on the interface type; the user interface is reconstructed based on the interface template library to obtain a reconstructed user interface; wherein, the interface template library includes basic configurations suitable for the corresponding user interface; Obtain the target user's preset needs, and based on the preset needs and the reconstructed user interface, reconstruct the user interaction logic to obtain the reconstructed user interaction logic; Based on the reconstructed user interface and the reconstructed user interaction logic, the reconstructed application front end is determined.

3. The method according to claim 2, characterized in that, The process of reconstructing the user interface based on the interface template library to obtain a reconstructed user interface includes: Based on the basic configuration contained in the interface template library, determine the construction resources required for the user interface; Based on the aforementioned resources, a basic framework for reconstructing the user interface is built; based on the basic framework, the reconstructed user interface is generated.

4. The method according to claim 3, characterized in that, The process of generating the reconstructed user interface based on the basic framework includes: The user interface is parsed to determine its core configuration; based on the core configuration, the user interface is modularized to obtain corresponding code modules. Based on the user interaction logic, the code module is integrated into the basic framework of the corresponding reconstructed user interface to generate the reconstructed user interface.

5. The method according to claim 2, characterized in that, The step of reconstructing the user interaction logic to obtain the reconstructed user interaction logic further includes: Based on the reconstructed user interaction logic, the reconstructed user interface is optimized and adjusted. Perform a correctness test on the optimized and reconstructed user interface, and determine the reconstructed user interface that passes the correctness test.

6. The method according to claim 1, characterized in that, The parsing of the application in the low-code platform includes: Determine the global code and global configuration of the application in the low-code platform; wherein, the global configuration represents configuration files or parameters that affect the overall behavior and settings of the application; The global code and global configuration are parsed to obtain the front-end code library of the application.

7. The method according to any one of claims 1 to 6, characterized in that, The method further includes: Identify the secondary developments performed by the target users on the front-end code and obtain the corresponding secondary development files; The secondary development files are deployed to the target platform; wherein, the target platform represents a platform other than the low-code platform.

8. An application front-end export device for low-code platforms, characterized in that, include: The parsing module is used to parse the applications in the low-code platform to identify the application front-end; The reconstruction module is used to determine the user interface and user interaction logic included in the application front end, and to reconstruct the user interface and user interaction logic to obtain the reconstructed application front end. The export module is used to obtain the front-end code of the refactored application front-end and export the front-end code from the low-code platform.

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 the computer execution instructions stored in the memory to implement the application front-end export method for low-code platforms 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 front-end export method for low-code platforms as described in any one of claims 1 to 7.

Images