Low-code application development method, device, and medium

Abstract

The application discloses a low-code application development method, device and medium. The low-code application development method is applied to a low-code development platform. The low-code development platform contains a service component and an interface access resource. The interface access resource is used for realizing access of a specified interface. The service component is associated with at least one interface access resource to realize a specified business function. The low-code application development method comprises the following steps: in response to a service component binding request, a target component is selected from the service component; and the target component is bound to a low-code application, so that the low-code application calls the interface access resource associated with the target component through the target component. The componentization and granulation of the interface access service in the low-code development platform are realized. The interface access resource can be called and combined between the service components, so that more flexible application development can be realized. The perception of the low-code development platform to the interface access resource is improved, and the interface access resource is convenient to maintain and manage.

Description

Technical Field

[0001] This application relates to the field of computer software technology, and in particular to a low-code application development method, device and medium. Background Technology

[0002] In low-code development, front-end components can access web interfaces (APIs) to obtain the data they need through a set of online-generated code. This automatically generated online code for accessing web APIs is called an API access resource, a resource concept within low-code development.

[0003] Currently, most low-code development technologies in the industry are based on platform-based solutions. They access resources through publicly available APIs on the network, but the platform only acts as the caller and does not participate in the maintenance of the API service itself, resulting in less than ideal low-code development results. Summary of the Invention

[0004] This application provides at least one low-code application development method, device, and storage medium.

[0005] The first aspect of this application provides a low-code application development method applied to a low-code development platform. The low-code development platform contains service components and interface access resources. The interface access resources are used to implement access to specified interfaces. The service components implement specified business functions by associating with at least one interface access resource. The method includes: obtaining a service component binding request for the low-code application; in response to the service component binding request, selecting a target component from the service components; and binding the target component to the low-code application so that the low-code application calls the interface access resource associated with the target component through the target component.

[0006] In one embodiment, before obtaining the service component binding request for the low-code application, the method further includes: receiving service component description information sent by the component development end; parsing the service component description information to obtain the interface access resource corresponding to the service component description information; and associating the interface access resource with the service component corresponding to the service component description information.

[0007] In one embodiment, associating the service component corresponding to the interface access resource and the service component description information includes: obtaining the version information of the service component corresponding to the service component description information; and associating the service component corresponding to the service component description information and the interface access resource based on the version information.

[0008] In one embodiment, obtaining a service component binding request for a low-code application includes: receiving a service component query request and displaying the service components contained in the low-code development platform on a service component selection page; responding to the service component selection instruction for the low-code application on the service component selection page, selecting the selected service component as a service component to be bound; and generating a service component binding request for the low-code application based on the service component to be bound.

[0009] In one embodiment, generating a service component binding request for a low-code application based on the service component to be bound includes: obtaining version information corresponding to the service component to be bound, and displaying the version information of the service component to be bound on a service component selection page; responding to a version selection instruction for the version information on the service component selection page, determining the version information corresponding to the service component to be bound; and generating a service component binding request for a low-code application based on the service component to be bound and the version information corresponding to the service component to be bound.

[0010] In one embodiment, in response to a service component binding request, selecting a target component from the service components includes: selecting the target component from the service components based on the service component to be bound and the version information corresponding to the service component to be bound.

[0011] In one embodiment, the method further includes: obtaining an offline deployment request for the low-code application; in response to the offline deployment request, querying the target component bound to the low-code application; and generating an executable code file based on the target component bound to the low-code application.

[0012] In one embodiment, generating an executable code file based on the target component bound to the low-code application includes: obtaining a preset standard component template; assembling the target component bound to the low-code application based on the standard component template and obtaining the dependency data of the target component bound to the low-code application; compiling and packaging the assembled service component information and dependency data to obtain the executable code file.

[0013] A second aspect of this application provides a low-code application development apparatus deployed on a low-code development platform. The low-code development platform includes service components and interface access resources. The interface access resources are used to access specified interfaces. The service components implement specified business functions by associating with at least one interface access resource. The apparatus includes: a request acquisition module for acquiring a service component binding request for the low-code application; a component selection module for selecting a target component from the service components in response to the service component binding request; and a component binding module for binding the target component to the low-code application so that the low-code application can call the interface access resource associated with the target component through the target component.

[0014] A third aspect of this application provides an electronic device, including a memory and a processor, wherein the processor is used to execute program instructions stored in the memory to implement the aforementioned low-code application development method.

[0015] The fourth aspect of this application provides a computer-readable storage medium having program instructions stored thereon, which, when executed by a processor, implement the aforementioned low-code application development method.

[0016] The above solution deploys service components and interface access resources within a low-code development platform. Interface access resources enable access to specified interfaces, and service components associate with at least one interface access resource to implement specific business functions. Then, it obtains a service component binding request for the low-code application; responds to the binding request, selects a target component from the service components, and binds the target component to the low-code application, enabling the low-code application to call the interface access resource associated with the target component. This achieves componentization and granularity of interface access services within the low-code development platform. Furthermore, it allows for more flexible application development through mutual calls and combinations between service components, facilitates subsequent expansion of interface access resources, improves the low-code development platform's awareness of interface access resources, and simplifies the maintenance and management of these resources.

[0017] It should be understood that the above general description and the following detailed description are exemplary and explanatory only, and are not intended to limit this application. Attached Figure Description

[0018] The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate embodiments consistent with this application and, together with the specification, serve to explain the technical solutions of this application.

[0019] Figure 1 This is a flowchart illustrating a low-code application development method in an exemplary embodiment of this application;

[0020] Figure 2 This is a schematic diagram illustrating a development service component as shown in an exemplary embodiment of this application;

[0021] Figure 3 This is a structural diagram of a service component shown in an exemplary embodiment of this application;

[0022] Figure 4 This is a schematic diagram illustrating the binding between service components and interface access resources, as shown in an exemplary embodiment of this application;

[0023] Figure 5 This is a schematic diagram illustrating the binding of a service component to a low-code application, as shown in an exemplary embodiment of this application;

[0024] Figure 6 This is a schematic diagram illustrating offline deployment of a low-code application, as shown in an exemplary embodiment of this application.

[0025] Figure 7 This is a block diagram illustrating a low-code application development apparatus according to an exemplary embodiment of this application;

[0026] Figure 8 This is a schematic diagram of the structure of an electronic device shown in an exemplary embodiment of this application;

[0027] Figure 9 This is a schematic diagram illustrating the structure of a computer-readable storage medium, as shown in an exemplary embodiment of this application. Detailed Implementation

[0028] The embodiments of this application will now be described in detail with reference to the accompanying drawings.

[0029] In the following description, specific details such as particular system architectures, interfaces, and technologies are presented for illustrative purposes rather than for limiting purposes, in order to provide a thorough understanding of this application.

[0030] In this document, the term "and / or" is merely a description of the association information of related objects, indicating that three relationships can exist. For example, A and / or B can represent: A existing alone, A and B existing simultaneously, and B existing alone. Additionally, the character " / " in this document generally indicates that the preceding and following related objects have an "or" relationship. Furthermore, "many" in this document means two or more. Moreover, the term "at least one" in this document means any combination of at least two of any one or more of a plurality of elements. For example, including at least one of A, B, and C can mean including any one or more elements selected from the set consisting of A, B, and C.

[0031] Currently, most low-code development in the industry adopts a platform-based approach, where interfaces access resources by calling publicly available APIs. The low-code development platform acts only as the caller and does not participate in the maintenance of the API call service itself. This has certain drawbacks: First, it is not convenient for offline deployment of low-code applications. For example, it does not support security deployment schemes that require an offline environment based on security and actual on-site conditions. Second, as a passive caller of interface access resources, the low-code development platform cannot correctly perceive the interface access resources, nor can it control the version of the interface access resources, making it inconvenient to maintain the interface access resources.

[0032] Based on this, this application provides a low-code application development method, an electronic device, and a computer-readable storage medium.

[0033] Please see Figure 1 , Figure 1This is a flowchart illustrating a low-code application development method in an exemplary embodiment of this application. The low-code is applied to a low-code development platform.

[0034] like Figure 1 As shown, the low-code application development method includes at least steps S110 to S130, which are described in detail below:

[0035] Step S110: Obtain the service component binding request for the low-code application.

[0036] The low-code development platform receives service component binding requests for low-code applications. These service component binding requests are used to request the binding of specified service components to the low-code application.

[0037] In this application, the low-code development platform can realize the development of low-code applications and provide interface access resource calling services to the low-code applications to be developed.

[0038] The low-code development platform includes service components and interface access resources.

[0039] Interface access resources are used to implement access to a specified interface. They are a set of online-generated code that can access the specified interface to obtain the required data.

[0040] A service component accesses resources through at least one interface to implement a specified business function. For example, a service component can be developed based on the Java programming language; for instance, it can be a collection of code based on a Java Web framework, equipped with relevant configuration code to implement the specified business function.

[0041] Step S120: In response to the service component binding request, select the target component from the service components.

[0042] After receiving a service component binding request for a low-code application, the low-code development platform will use the service component corresponding to the service component binding request as the target component.

[0043] For example, each service component stored in the low-code development platform has a corresponding component identifier, which is used to distinguish the service components. The service component binding request carries the component identifier of the service component to be bound. The target component is selected from the service components stored in the low-code development platform by using the component identifier carried in the service component binding request.

[0044] Step S130: Bind the target component to the low-code application so that the low-code application can access resources by calling the interface associated with the target component through the target component.

[0045] By binding a target component to a low-code application, the low-code application can access resources by calling the interfaces associated with the target component through the bound target component.

[0046] By associating API access resources with service components, the API access services in the low-code development platform are modularized and granularized. Through mutual calls and combinations between service components, more flexible application development can be achieved, and it is easier to expand the API access resources in the future. This improves the low-code development platform's awareness of API access resources and facilitates the maintenance and management of these resources.

[0047] The steps of this application will now be described in further detail:

[0048] In some implementations, before obtaining the service component binding request for the low-code application, the method further includes: receiving service component description information sent by the component development end; parsing the service component description information to obtain the interface access resource corresponding to the service component description information; and associating the interface access resource with the service component corresponding to the service component description information.

[0049] Among them, the service component description information is the relevant information obtained from the development of the service component.

[0050] For example, taking a service component developed using the Java programming language as an example, the development process of a service component is illustrated below:

[0051] Please see Figure 2 , Figure 2 This is a schematic diagram illustrating a development service component as shown in an exemplary embodiment of this application. Figure 2 As shown, service components are developed based on a Java component development framework, resulting in multiple service components, each of which can contain multiple interfaces for accessing resources.

[0052] Optionally, the service components may include service components that are functionally stable and require infrequent code updates, such as... Figure 2 The service components include caching components that implement data caching functions, communication components that implement communication functions, and so on. These service components can serve as basic components. There are also service components that contain unstable functions, have a high number of code updates, and require continuous development and iteration, such as service component A that implements function A, service component B that implements function B, and service component C that implements function C. These components require continuous iterative development.

[0053] For example, let's take service component A as an example for illustration. Please refer to [link / reference]. Figure 3 , Figure 3 This is a structural diagram of a service component illustrated in an exemplary embodiment of this application. Figure 3As shown, the Java Web framework contains multiple business libraries. A business library is a collection of code containing relevant configuration code to implement a specified business function. Service component A depends on business library A in the Java Web framework. Business library A contains configuration information, Java business services, API configuration information, and other data to add interface access resources to the service component. The Java business services can contain end-user-facing terminal business functions, basic business functions, and common capabilities corresponding to the Java Web framework. In addition to the aforementioned dependent business libraries, service components can also contain API description documents and other configuration data.

[0054] Developers on the component development side can develop service components based on the above embodiments to obtain... Figure 3 The service components shown are packaged according to the standards agreed upon with the low-code development platform to obtain service component description information, which is then sent to the low-code development platform by the developer's component development end.

[0055] After obtaining the service component description information, the code development platform parses the service component description information according to the aforementioned standards to obtain the service component corresponding to the service component description information and its corresponding interface access resource, and then associates the service component and interface access resource in the low-code development platform.

[0056] Optionally, see [link to relevant documentation] Figure 2 During the development process, service components are marked with version information for different iterations. For example, version Ver1.0 is developed and iterated to obtain version Ver2.0, and each service component is marked with the corresponding version information.

[0057] Additionally, service components can be grouped based on their interrelationships. Components within the same group are those with interconnected business functions. These components are then developed and iterated synchronously, using the same version information within the same iteration cycle. For example... Figure 2 If service component A, service component B, and service component B belong to the same group, then the same version information is used in each development iteration, so that service components within the same group can depend on each other without considering version conflicts.

[0058] During the development of service components, taking into account the version information of service components in different iteration cycles, the service components and interface access resources corresponding to the service component description information are associated. This includes: obtaining the version information of the service component corresponding to the service component description information; and associating the service component and interface access resources corresponding to the service component description information based on the version information.

[0059] The low-code development platform associates service components and interface access resources based on version information, making it easier for the low-code development platform to manage the version of interface access resources.

[0060] For example, please refer to Figure 4 , Figure 4 This is a schematic diagram illustrating the binding between service components and interface access resources, as shown in an exemplary embodiment of this application. Figure 4 As shown, the component development end sends the service component description information to the low-code development platform. The low-code development platform parses the service component description information to obtain the service component and the corresponding interface access resource. It adds the interface access resource to the resource library, adds the service component to the component library, and binds the interface access resource and service component by marking version information on the interface access resource and service component.

[0061] In some implementations, obtaining the service component binding request for the low-code application in step S110 includes: receiving a service component query request and displaying the service components contained in the low-code development platform on the service component selection page; responding to the service component selection instruction for the low-code application on the service component selection page, selecting the selected service component as the service component to be bound; and generating a service component binding request for the low-code application based on the service component to be bound.

[0062] The low-code development platform supports the development of low-code applications, and during the development process, service components can be selected and bound.

[0063] For example, when developing low-code applications on a code development platform and requesting access to resources via an interface, a service component query request is generated. The code development platform then displays a service component selection page to the user based on the service component query request. This service component selection page displays the service components contained in the low-code development platform.

[0064] The service components displayed on the service component selection page can be component identifiers, such as the component name, or component information, such as the business functions supported by the component. Furthermore, the service components displayed on the service component selection page can be all service components of the code development platform, or only a portion of them. For example, if the service component query request carries the currently developed function type of the low-code application, the code development platform can filter the service components based on the function type and the business functions implemented by the service components, and then display the filtered service components on the service component selection page.

[0065] Then, in response to the user's service component selection operation for the low-code application on the service component selection page, a corresponding service component selection instruction is generated. The low-code development platform determines the service component selected by the user based on the service component selection instruction, uses the selected service component as the service component to be bound, and then generates a service component binding request for the low-code application based on the service component to be bound.

[0066] For example, in conjunction with the above embodiments, the service component corresponds to version information. Generating a service component binding request for the low-code application based on the service component to be bound includes: obtaining the version information corresponding to the service component to be bound; displaying the version information of the service component to be bound on the service component selection page; responding to the version selection instruction for the version information on the service component selection page; determining the version information corresponding to the service component to be bound; and generating a service component binding request for the low-code application based on the service component to be bound and the version information corresponding to the service component to be bound.

[0067] After identifying the service component to be bound by the user, obtain the version information of the service component to be bound so as to display the version information of the service component to be bound on the service component selection page.

[0068] Then, in response to the user's version information selection operation on the service component selection page, a corresponding version selection instruction is generated. The low-code development platform determines the version information of the service component to be bound based on the version selection instruction, and generates a service component binding request for the low-code application based on the service component to be bound and its corresponding version information.

[0069] Furthermore, in response to a service component binding request, a target component is selected from the service components, including: selecting the target component from the service components based on the service component to be bound and the version information corresponding to the service component to be bound.

[0070] The specific target component is determined based on the service component to be bound and its corresponding version information.

[0071] For example, please refer to Figure 5 , Figure 5 This is a schematic diagram illustrating the binding of a service component to a low-code application, as shown in an exemplary embodiment of this application. Figure 5As shown, the low-code application sends a service component query request to the low-code development platform to query all available service components. The component names of these service components are displayed on the component selection page. The low-code application selects service component A to be bound. The low-code development platform obtains the version information of service component A, including Ver1.0 and Ver2.0. The low-code application selects service component A with version information of Ver1.0. The low-code development platform binds service component A with version information of Ver1.0 to the low-code application, enabling the low-code application to access resources by calling the interfaces in its associated resource library.

[0072] By selecting version information, users can flexibly choose or switch the version of service components during low-code application development, that is, flexibly choose or switch the version of interface access resources, thereby achieving version control over interface access resources.

[0073] The low-code development platform of this application also supports offline deployment of low-code applications. The offline deployment steps may include: obtaining an offline deployment request for the low-code application; responding to the offline deployment request and querying the target components bound to the low-code application; and generating an executable code file based on the target components bound to the low-code application.

[0074] By componentizing the interface access resources, the target components bound to the low-code application can be compiled and packaged to obtain an executable code file that can run offline.

[0075] Specifically, in response to an offline deployment request for a low-code application, the low-code development platform queries all target components bound to the low-code application to package and compile these target components and generate executable code files.

[0076] For example, generating an executable code file based on the target component bound to the low-code application includes: obtaining a preset standard component template; assembling the target component bound to the low-code application based on the standard component template and obtaining the dependency data of the target component bound to the low-code application; compiling and packaging the assembled service component information and dependency data to obtain the executable code file.

[0077] For example, please see Figure 6 , Figure 6 This is a schematic diagram illustrating offline deployment of a low-code application, as shown in an exemplary embodiment of this application. Figure 6As shown, the process involves querying all target components bound to the low-code application, obtaining service components A, B, and C with version information Ver1.0. Then, based on the information of the bound target components, an executable code file is generated. The specific steps include: obtaining all relevant data for each target component; assembling all relevant data for each target component according to a standard component template; and pulling the dependency data for each target component to support its normal operation. Next, the assembled service component information is compiled and packaged to obtain the executable code file corresponding to the low-code application. This executable code file is then stored for users to download. For example, a download link for the executable code file can be generated, allowing users to download the executable code file and achieve offline deployment of the low-code application.

[0078] The low-code application development method provided in this application is applied to a low-code development platform. The low-code development platform contains service components and interface access resources. Interface access resources are used to access specified interfaces. Service components implement specified business functions by associating with at least one interface access resource. The method involves: obtaining a service component binding request for the low-code application; responding to the service component binding request; selecting a target component from the service components; and binding the target component to the low-code application, so that the low-code application can call the interface access resource associated with the target component through the target component. This achieves componentization and granularity of interface access services in the low-code development platform, and allows for more flexible application development through mutual calls and combinations between service components. It also facilitates subsequent expansion of interface access resources, improves the low-code development platform's awareness of interface access resources, and facilitates the maintenance and management of these resources.

[0079] Figure 7 This is a block diagram illustrating a low-code application development apparatus in an exemplary embodiment of this application. The low-code application development apparatus is deployed on a low-code development platform. The low-code development platform contains service components and interface access resources. The interface access resources are used to implement access to specified interfaces. The service components implement specified business functions by associating with at least one interface access resource. Figure 7 As shown, the exemplary low-code application development apparatus 700 includes: a request acquisition module 710, a component selection module 720, and a component binding module 730. Specifically:

[0080] Request Module 710 is used to obtain service component binding requests for low-code applications;

[0081] The component selection module 720 is used to select the target component from the service components in response to the service component binding request;

[0082] The component binding module 730 is used to bind a target component to a low-code application, so that the low-code application can access resources by calling the interface associated with the target component through the target component.

[0083] In the above-described exemplary low-code application development device, the componentization and granularization of interface access services in the low-code development platform are realized. Through mutual calls and combinations between service components, more flexible application development can be achieved, and it is convenient to expand the interface access resources in the future. This improves the low-code development platform's awareness of interface access resources and facilitates the maintenance and management of interface access resources.

[0084] Please see Figure 8 , Figure 8 This is a schematic diagram of the structure of an embodiment of the electronic device of this application. The electronic device 800 includes a memory 801 and a processor 802. The processor 802 is used to execute program instructions stored in the memory 801 to implement the steps in any of the above-described low-code application development method embodiments. In a specific implementation scenario, the electronic device 800 may include, but is not limited to, a microcomputer or a server. In addition, the electronic device 800 may also include mobile devices such as laptops and tablets, which are not limited here.

[0085] Specifically, processor 802 controls itself and memory 801 to implement the steps in any of the low-code application development method embodiments described above. Processor 802 can also be referred to as a Central Processing Unit (CPU). Processor 802 may be an integrated circuit chip with signal processing capabilities. Processor 802 can also be a general-purpose processor, a digital signal processor (DSP), an application-specific integrated circuit (ASIC), a field-programmable gate array (FPGA), or other programmable logic devices, discrete gate or transistor logic devices, or discrete hardware components. A general-purpose processor can be a microprocessor or any conventional processor. Furthermore, processor 802 can be implemented using integrated circuit chips.

[0086] Please see Figure 9 , Figure 9 This is a schematic diagram of a computer-readable storage medium according to an embodiment of the present application. The computer-readable storage medium 900 stores program instructions 910 that can be executed by a processor. The program instructions 910 are used to implement the steps in any of the above-described low-code application development method embodiments.

[0087] In some embodiments, the functions or modules of the apparatus provided in this disclosure can be used to perform the methods described in the above method embodiments. The specific implementation can be referred to the description of the above method embodiments, and for the sake of brevity, it will not be repeated here.

[0088] The description of the various embodiments above tends to emphasize the differences between the various embodiments. The similarities or similarities between them can be referred to, and for the sake of brevity, they will not be repeated here.

[0089] In the several embodiments provided in this application, it should be understood that the disclosed methods and apparatus can be implemented in other ways. For example, the apparatus implementations described above are merely illustrative. For instance, the division of modules or units is only a logical functional division, and in actual implementation, there may be other division methods. For example, units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the mutual coupling or direct coupling or communication connection shown or discussed may be through some interfaces; the indirect coupling or communication connection of devices or units may be electrical, mechanical, or other forms.

[0090] Furthermore, the functional units in the various embodiments of this application can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The integrated unit can be implemented in hardware or as a software functional unit. If the integrated unit is implemented as a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. 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 storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) or processor to execute all or part of the steps of the methods in the various embodiments of this application. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

Claims

1. A low-code application development method, characterized in that, The method, applied to a low-code development platform containing service components and interface access resources, wherein the interface access resources are used to access a specified interface, and the service components are associated with at least one interface access resource to implement a specified business function, includes: Receive service component description information sent by the component development team; The service component description information is parsed to obtain the interface access resources corresponding to the service component description information; Obtain the version information of the service component corresponding to the service component description information; Add the interface access resource to the resource library, add the service component to the component library, and mark the interface access resource and the service component with version information to bind the interface access resource and the service component; Retrieve service component binding requests for low-code applications; In response to the service component binding request, a target component is selected from the service components; The target component is bound to the low-code application so that the low-code application can access resources by calling the interface associated with the target component through the target component.

2. The method according to claim 1, characterized in that, The process of obtaining the service component binding request for the low-code application includes: Receive service component query requests and display the service components contained in the low-code development platform on the service component selection page; In response to the service component selection instruction for the low-code application on the service component selection page, the selected service component is used as the service component to be bound. A service component binding request for the low-code application is generated based on the service component to be bound.

3. The method according to claim 2, characterized in that, The step of generating a service component binding request for the low-code application based on the service component to be bound includes: Obtain the version information corresponding to the service component to be bound, and display the version information of the service component to be bound on the service component selection page; In response to the version selection instruction for the version information on the service component selection page, determine the version information corresponding to the service component to be bound; Based on the service component to be bound and its corresponding version information, a service component binding request is generated for the low-code application.

4. The method according to claim 3, characterized in that, The step of selecting a target component from the service components in response to the service component binding request includes: Based on the service component to be bound and the version information corresponding to the service component to be bound, the target component is selected from the service components.

5. The method according to any one of claims 1-4, characterized in that, The method further includes: Obtain the offline deployment request for the low-code application; In response to the offline deployment request, query the target components bound to the low-code application; An executable code file is generated based on the target component bound to the low-code application.

6. The method according to claim 5, characterized in that, The process of generating an executable code file based on the target component bound to the low-code application includes: Get the preset standard component template; The target components bound to the low-code application are assembled based on the standard component template, and the dependency data of the target components bound to the low-code application is obtained. The assembled service component information and the dependency data are compiled and packaged to obtain an executable code file.

7. An electronic device, characterized in that, It includes a memory and a processor, the processor being configured to execute program instructions stored in the memory to implement the low-code application development method according to any one of claims 1 to 6.

8. A computer-readable storage medium having program instructions stored thereon, characterized in that, When the program instructions are executed by the processor, they implement the low-code application development method as described in any one of claims 1 to 6.

Images