CN117289906A - Low-code application development method, equipment and medium - Google Patents
Low-code application development method, equipment and medium Download PDFInfo
- Publication number
- CN117289906A CN117289906A CN202311019364.XA CN202311019364A CN117289906A CN 117289906 A CN117289906 A CN 117289906A CN 202311019364 A CN202311019364 A CN 202311019364A CN 117289906 A CN117289906 A CN 117289906A
- Authority
- CN
- China
- Prior art keywords
- service component
- low
- service
- component
- code
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
- 238000011161 development Methods 0.000 title claims abstract description 114
- 238000000034 method Methods 0.000 title claims abstract description 55
- 230000006870 function Effects 0.000 claims description 22
- 230000004044 response Effects 0.000 claims description 6
- 230000001419 dependent effect Effects 0.000 claims description 5
- 238000004806 packaging method and process Methods 0.000 claims description 4
- 238000005469 granulation Methods 0.000 abstract description 5
- 230000003179 granulation Effects 0.000 abstract description 5
- 238000010586 diagram Methods 0.000 description 15
- 239000008186 active pharmaceutical agent Substances 0.000 description 9
- 238000012423 maintenance Methods 0.000 description 6
- 230000008569 process Effects 0.000 description 5
- 238000004891 communication Methods 0.000 description 4
- 238000012545 processing Methods 0.000 description 4
- 230000008878 coupling Effects 0.000 description 3
- 238000010168 coupling process Methods 0.000 description 3
- 238000005859 coupling reaction Methods 0.000 description 3
- 230000008447 perception Effects 0.000 description 3
- 238000005516 engineering process Methods 0.000 description 2
- 230000000712 assembly Effects 0.000 description 1
- 238000000429 assembly Methods 0.000 description 1
- 238000010276 construction Methods 0.000 description 1
- 230000007547 defect Effects 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 230000001360 synchronised effect Effects 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
Landscapes
- Engineering & Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Software Systems (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Stored Programmes (AREA)
Abstract
The application discloses a low-code application development method, equipment and medium, wherein the low-code application development method is applied to a low-code development platform, the low-code development platform comprises a service component and an interface access resource, the interface access resource is used for realizing the access of a designated interface, the service component is associated with at least one interface access resource to realize the designated service function, and the low-code application development method comprises the following steps: responding to the service component binding request, and selecting a target component from the service components; the target component is bound to the low code application such that the low code application accesses the resource by invoking an interface associated with the target component through the target component. The method realizes the componentization and granulation of the interface access service in the low-code development platform, can realize more flexible application development through the mutual calling and combination among service components, improves the awareness of the low-code development platform on the interface access resource, and is convenient for maintaining and managing the interface access resource.
Description
Technical Field
The present invention relates to the field of computer software technologies, and in particular, to a method, an apparatus, and a medium for developing a low-code application.
Background
In low code development techniques, the front-end component may access a network interface (Application Programming Interface, API) through a set of code generated online to obtain the required data. These online generation codes for accessing web APIs based on automation construction are called interface access resources, which is a resource concept under low code development technology.
At present, most of low-code development technologies in the industry mainly adopt a platform scheme, an interface accesses an API disclosed by a resource calling network, and the platform is only used as a calling party and does not participate in maintenance of an API service, so that the effect of low-code development is not ideal.
Disclosure of Invention
The application provides at least a low-code application development method, equipment and a storage medium.
The first aspect of the present application provides a low-code application development method applied to a low-code development platform, where the low-code development platform contains a service component and an interface access resource, the interface access resource is used to implement access of a specified interface, and the service component is associated with at least one interface access resource to implement a specified service function, and the method includes: acquiring a service component binding request for a low-code application; responding to the service component binding request, and selecting a target component from the service components; the target component is bound to the low code application such that the low code application accesses the resource by invoking an interface associated with the target component through the target component.
In an embodiment, before obtaining the service component binding request for the low code application, the method further comprises: receiving service component description information sent by a component development terminal; analyzing the service component description information to obtain interface access resources corresponding to the service component description information; and associating the interface access resource with the service component corresponding to the service component description information.
In an embodiment, associating the interface access resource with the service component corresponding to the service component description information includes: acquiring version information of a service component corresponding to the service component description information; and associating the service component corresponding to the service component description information with the interface access resource based on the version information.
In an embodiment, obtaining a service component binding request for a low code application includes: receiving a service component query request, and displaying a service component contained in the low-code development platform on a service component selection page; responding to a service component selection instruction aiming at low-code application in a service component selection page, and taking the selected service component as a 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.
In an embodiment, generating a service component binding request for a low code application based on a service component to be bound includes: the method comprises the steps of obtaining version information corresponding to a 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 aiming at version information in a service component selection page, and determining the version information corresponding to the service component to be bound; and generating a service component binding request aiming at the low-code application based on the service component to be bound and version information corresponding to the service component to be bound.
In one embodiment, in response to a service component binding request, selecting a target component from service components includes: and selecting a target component from the service components based on the service components to be bound and version information corresponding to the service components to be bound.
In an embodiment, the method further comprises: acquiring an offline deployment request for a low-code application; responding to the offline deployment request, and inquiring a target component bound by the low-code application; an executable code file is generated based on the target component to which the low code application is bound.
In one embodiment, generating an executable code file based on a target component of a low code application binding includes: acquiring a preset standard component template; assembling the target component bound by the low-code application based on the standard component template, and acquiring the dependent data of the target component bound by the low-code application; and compiling and packaging the assembled service component information and the dependency data to obtain an executable code file.
The second aspect of the present application provides a low-code application development device, where the low-code application development device is deployed on 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 to implement access of a specified interface, and the service component is associated with at least one interface access resource to implement a specified service function, and the device includes: the request acquisition module is used for acquiring a service component binding request aiming at the low-code application; the component selecting module is used for responding to the service component binding request and selecting a target component from the service components; and the component binding module is used for binding the target component to the low-code application so that the low-code application can access the resource through the interface which is called by the target component and is associated with the target component.
A third aspect of the present application provides an electronic device, including a memory and a processor, where the processor is configured to execute program instructions stored in the memory, to implement the low-code application development method described above.
A fourth aspect of the present application provides a computer-readable storage medium having stored thereon program instructions that, when executed by a processor, implement the above-described low-code application development method.
According to the scheme, the service component and the interface access resource are deployed in the low-code development platform, the interface access resource is used for realizing the access of the appointed interface, the service component is associated with at least one interface access resource to realize the appointed service function, and then the service component binding request aiming at the low-code application is acquired; responding to the service component binding request, and selecting a target component from the service components; the target component is bound to the low code application such that the low code application accesses the resource by invoking an interface associated with the target component through the target component. The method realizes the componentization and granulation of the interface access service in the low-code development platform, can realize more flexible application development through the mutual calling and combination among service components, is convenient for the expansion of the subsequent interface access resource, improves the perception of the interface access resource of the low-code development platform, and is convenient for the maintenance and management of the interface access resource.
It is to be understood that both the foregoing general description and the following detailed description are exemplary and explanatory only and are not restrictive of the application.
Drawings
The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate embodiments consistent with the application and, together with the description, serve to explain the technical aspects of the application.
FIG. 1 is a flow chart of a low code application development method shown in an exemplary embodiment of the present application;
FIG. 2 is a schematic diagram of development service components shown in an exemplary embodiment of the present application;
FIG. 3 is a block diagram of service components shown in an exemplary embodiment of the present application;
FIG. 4 is a diagram illustrating binding between service components and interface access resources according to an exemplary embodiment of the present application;
FIG. 5 is a schematic diagram of a service component binding low code application shown in an exemplary embodiment of the present application;
FIG. 6 is a schematic diagram illustrating offline deployment of a low-code application according to an exemplary embodiment of the present application;
FIG. 7 is a block diagram of a low code application development device shown in an exemplary embodiment of the present application;
FIG. 8 is a schematic diagram of an electronic device shown in an exemplary embodiment of the present application;
fig. 9 is a schematic structural view of a computer-readable storage medium shown in an exemplary embodiment of the present application.
Detailed Description
The following describes the embodiments of the present application in detail with reference to the drawings.
In the following description, for purposes of explanation and not limitation, specific details are set forth such as the particular system architecture, interfaces, techniques, etc., in order to provide a thorough understanding of the present application.
The term "and/or" is herein merely an association information describing an associated object, meaning that three relationships may exist, e.g., a and/or B may represent: a exists alone, A and B exist together, and B exists alone. In addition, the character "/" herein generally indicates that the front and rear associated objects are an "or" relationship. Further, "a plurality" herein means two or more than two. In addition, the term "at least one" herein means any one of a plurality or any combination of at least two of a plurality, for example, including at least one of A, B, C, and may mean including any one or more elements selected from the group consisting of A, B and C.
At present, most of low-code development in the industry is mainly based on a platform scheme, an interface accesses an API disclosed by a resource calling network, and the low-code development platform only serves as a calling party and does not participate in maintenance of an API calling service, so that certain defects exist: firstly, offline deployment of low-code applications is inconvenient, for example, a deployment scheme of security protection in an offline environment based on security and field actual conditions is not supported; secondly, the low-code development platform is used as a passive calling party of the interface access resource, the interface access resource cannot be perceived correctly, the version of the interface access resource cannot be controlled, and the interface access resource cannot be maintained conveniently.
Based on this, the present application provides a low-code application development method, an electronic device, and a computer-readable storage medium.
Referring to fig. 1, fig. 1 is a flowchart illustrating a low code application development method according to an exemplary embodiment of the present application. The low code is applied to a low code development platform.
As shown in fig. 1, the low-code application development method at least includes steps S110 to S130, and is described in detail as follows:
step S110: a service component binding request for a low code application is obtained.
The low code development platform receives a service component binding request for a low code application, the service component binding request requesting binding of a specified service component with the low code application.
In the application, the low-code development platform can realize the development of the low-code application and provide calling service of the interface access resource for the low-code application to be developed.
The low-code development platform comprises a service component and an interface access resource.
The interface access resource is used to enable access to a specified interface, which is a set of online generated code that can access the specified interface to obtain the desired data.
The service component accesses the resource to implement the specified business function by associating with at least one interface. For example, service components may be developed based on the Java programming language, e.g., the service components are based on the Java Web framework, equipped with a set of code that correlates configuration code to achieve specified business functions.
Step S120: in response to the service component binding request, a target component is selected from the service components.
And after receiving the service component binding request for the low-code application, the low-code development platform takes the service component corresponding to the service component binding request as a target component.
For example, the service components stored in the low-code development platform are respectively corresponding to component identifiers, so that the service components are distinguished through the component identifiers, the service component binding request carries the component identifier of the service component requested to be bound, and the target component is selected from the service components stored in the low-code development platform through the component identifier carried in the service component binding request.
Step S130: the target component is bound to the low code application such that the low code application accesses the resource by invoking an interface associated with the target component through the target component.
Binding the target component with the low code application, then a subsequent low code application may access the resource by invoking an interface associated with the target component through the target component having the binding relationship.
The method has the advantages that the interface access resources and the service components are associated, the assembly and granulation of the API access service in the low-code development platform are realized, more flexible application development can be realized through the mutual calling and combination among the service components, the subsequent expansion of the interface access resources is facilitated, the perception of the interface access resources by the low-code development platform is improved, and the maintenance and the management of the interface access resources are facilitated.
The steps of the present application are described in further detail below:
in some embodiments, prior to obtaining the service component binding request for the low code application, the method further comprises: receiving service component description information sent by a component development terminal; analyzing the service component description information to obtain interface access resources corresponding to the service component description information; and associating the interface access resource with the service component corresponding to the service component description information.
The service component description information is related information obtained by developing the service component.
Illustratively, taking the example that the service component is developed based on the Java programming language, the development process of the service component is schematically illustrated:
referring to fig. 2, fig. 2 is a schematic diagram of a development service component according to an exemplary embodiment of the present application. As shown in fig. 2, the service component is developed based on a Java component development framework, so as to obtain a plurality of service components, and each service component may contain a plurality of interface access resources.
Optionally, the service components include service components with stable functions and less code updating times, such as a cache component for realizing a data cache function, a communication component for realizing a communication function in fig. 2, and the like, and these service components can be used as basic components; the service components have unstable functions, the code updating times are more, and the continuous development iteration is required, so that the service component A realizing the function A, the service component B realizing the function B and the service component C realizing the function C are realized, and the continuous iterative development is required.
For example, taking service component a as an example, please refer to fig. 3, fig. 3 is a block diagram of service component shown in an exemplary embodiment of the present application. As shown in fig. 3, the Java Web framework includes a plurality of service libraries, where the service libraries refer to code sets including relevant configuration codes to implement specified service functions, and the service component a depends on the service library a in the Java Web framework, where the service library a includes data such as assembly configuration information, java service, API configuration information, and so on, so as to add interface access resources to the service component, where the Java service may include terminal services facing end users, basic services, and public capabilities corresponding to the Java Web framework. The service component may contain API description documents and other configuration data in addition to the above-described dependent service libraries.
The developer of the component development end can develop the service component based on the embodiment to obtain the service component shown in fig. 3, package the developed service component according to the standard agreed with the low-code development platform to obtain the service component description information, and send the service component description information to the low-code development platform from the component development end of the developer.
After the code development platform obtains the service component description information, the service component description information is analyzed according to the agreed standard to obtain the service component corresponding to the service component description information and the corresponding interface access resource thereof, and the service component and the interface access resource are associated in the low-code development platform.
Optionally, with continued reference to fig. 2, the service components correspondingly tag different iteration versions of the service components with version information during the development process, e.g., performing development iteration by version ver1.0 to obtain version ver2.0, and tagging each service component with corresponding version information.
In addition, service components can be grouped according to the association information among each service component, the service components in the same group are components with service functions associated with each other, synchronous development and iteration are carried out on the service components in the same group, and the same version information is used in the same iteration period. In fig. 2, if the service components a, B and B belong to the same group, the same version information is used for each development iteration, so that service components in the same group can mutually depend, and version conflicts do not need to be considered.
On the premise that version information of service components in different iteration periods is considered in the service component development process, service components corresponding to service component description information and interface access resources are associated, and the method comprises the following steps: acquiring version information of a service component corresponding to the service component description information; and associating the service component corresponding to the service component description information with the interface access resource based on the version information.
The low-code development platform associates the service component with the interface access resource according to the version information, so that the low-code development platform is convenient for version management of the interface access resource.
Referring to fig. 4, fig. 4 is a schematic diagram illustrating binding between a service component and an interface access resource according to an exemplary embodiment of the present application. As shown in fig. 4, the component development end sends the service component description information to the low-code development platform, the low-code development platform analyzes the service component description information to obtain the service component and the interface access resource corresponding to the service component, adds the interface access resource to the resource library, adds the service component to the component library, and binds the interface access resource and the service component by marking version information to the interface access resource and the service component.
In some embodiments, obtaining a service component binding request for a low code application in step S110 includes: receiving a service component query request, and displaying a service component contained in the low-code development platform on a service component selection page; responding to a service component selection instruction aiming at low-code application in a service component selection page, and taking the selected service component as a 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.
The low-code development platform supports development of low-code application, and service components can be selected for binding in the development process of the low-code application.
For example, the method is used for developing a low-code application on a code development platform and requesting to access resources by using an interface, a service component query request is generated, and the code development platform displays a service component selection page for displaying service components contained in the low-code development platform to a user according to the service component query request.
The service component displayed in the service component selection page may be a component identifier of the service component, such as a component name of the service component, or may display component information of the service component, such as a service function supported by the service component. And the service components displayed in the service component selection page can be all service components of the code development platform, or can be part of the service components, for example, the service component inquiry request carries the currently developed function type of the low-code application, the code development platform screens the service components according to the function type and the service function realized by the service components, and the screened service components are displayed in the service component selection page.
Then, responding to service component selection operation executed by a user for the low-code application in the service component selection page, generating a corresponding service component selection instruction, and determining the service component selected by the user by the low-code development platform according to the service component selection instruction, so that the selected service component is used as the service component to be bound, and further generating a service component binding request for the low-code application according to the service component to be bound.
Illustratively, in combination with the above embodiment, the service component corresponds to version information, and generating, based on the service component to be bound, a service component binding request for the low code application includes: the method comprises the steps of obtaining version information corresponding to a 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 aiming at version information in a service component selection page, and determining the version information corresponding to the service component to be bound; and generating a service component binding request aiming at the low-code application based on the service component to be bound and version information corresponding to the service component to be bound.
And after determining the service component to be bound selected by the user, acquiring version information corresponding to the service component to be bound, so as to display the version information of the service component to be bound on a service component selection page.
Then, responding to version information selection operation executed by a user on version information of the service component to be bound in a service component selection page, generating a corresponding version selection instruction, and determining version information corresponding to the service component to be bound according to the version selection instruction by the low-code development platform so as to generate a service component binding request for low-code application according to the service component to be bound and the version information corresponding to the service component to be bound.
Further, in response to the service component binding request, selecting a target component from the service components, including: and selecting a target component from the service components based on the service components to be bound and version information corresponding to the service components to be bound.
And determining a specific target component according to the service component to be bound and version information corresponding to the service component to be bound.
Referring to fig. 5, fig. 5 is a schematic diagram of a service component binding low code application according to an exemplary embodiment of the present application. As shown in fig. 5, the low-code application sends a service component query request to the low-code development platform to query all available service components, and displays the component names of these service components on the component selection page. The service component to be bound selected by the low-code application is a service component A, and the version information of the service component A is acquired by the low-code development platform and comprises Ver1.0 and Ver2.0. The version information of the service component A selected by the low-code application is Ver1.0, and the low-code development platform binds the service component A with the version information of Ver1.0 into the low-code application, so that the low-code application can call interfaces in an associated resource library to access resources.
By selecting version information, a user flexibly selects or switches the version of the service component in the development process of the low-code application, namely flexibly selects or switches the version of the interface access resource, and version control of the interface access resource is realized.
The low code development platform of the present application also supports offline deployment of low code applications, which may include the steps of: acquiring an offline deployment request for a low-code application; responding to the offline deployment request, and inquiring a target component bound by the low-code application; an executable code file is generated based on the target component to which the low code application is bound.
Because the interface access resource is componentized, the target component bound by the low-code application can be compiled and packaged to obtain an executable code file which can be run offline.
Specifically, the low code development platform queries all target components bound by the low code application in response to an offline deployment request of the low code application to package and compile the target components to generate an executable code file.
Illustratively, generating the executable code file based on the target component of the low code application binding includes: acquiring a preset standard component template; assembling the target component bound by the low-code application based on the standard component template, and acquiring the dependent data of the target component bound by the low-code application; and compiling and packaging the assembled service component information and the dependency data to obtain an executable code file.
For example, referring to fig. 6, fig. 6 is a schematic diagram illustrating offline deployment of a low-code application according to an exemplary embodiment of the present application. As shown in fig. 6, querying all target components bound by the low-code application to obtain a service component a, a service component B and a service component C with version information of ver1.0, and then generating an executable code file according to the information of the bound target components, wherein the specific steps include: and acquiring all relevant data of each target component, then assembling all relevant data of each target component according to a standard component template, and pulling dependent data of each target component so as to support normal operation of each target component. And compiling and packaging the service component information obtained after assembly to obtain an executable code file corresponding to the low-code application, and storing the executable code file for downloading by a user. For example, a download link of the executable code file is generated, and the user side can download the executable code file through the download link, so that offline deployment of the low-code application is realized.
The low-code application development method is applied to a low-code development platform, the low-code development platform comprises a service component and interface access resources, the interface access resources are used for realizing the access of a specified interface, the service component is associated with at least one interface access resource to realize a specified service function, and the method is used for obtaining a service component binding request aiming at low-code application; responding to the service component binding request, and selecting a target component from the service components; the target component is bound to the low code application such that the low code application accesses the resource by invoking an interface associated with the target component through the target component. The method realizes the componentization and granulation of the interface access service in the low-code development platform, can realize more flexible application development through the mutual calling and combination among service components, is convenient for the expansion of the subsequent interface access resource, improves the perception of the interface access resource of the low-code development platform, and is convenient for the maintenance and management of the interface access resource.
Fig. 7 is a block diagram of a low-code application development device according to an exemplary embodiment of the present application, where the low-code application development device is deployed on a low-code development platform, and the low-code development platform includes a service component and an interface access resource, where the interface access resource is used to implement access of a specified interface, and the service component is associated with at least one interface access resource to implement a specified service function. As shown in fig. 7, 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:
a request acquisition module 710 for acquiring a service component binding request for a low code application;
a component selecting module 720, configured to respond to the service component binding request, and select a target component from the service components;
a component binding module 730 for binding the target component to the low code application such that the low code application accesses the resource by invoking an interface associated with the target component through the target component.
In the low-code application development device, the assembly and granulation of the interface access service in the low-code development platform are realized, more flexible application development can be realized through the mutual calling and combination among service assemblies, the subsequent expansion of the interface access resource is convenient, the awareness of the interface access resource of the low-code development platform is improved, and the maintenance and management of the interface access resource are convenient.
Referring to fig. 8, fig. 8 is a schematic structural diagram of an embodiment of an electronic device of the present application. The electronic device 800 comprises a memory 801 and a processor 802, the processor 802 being arranged to execute program instructions stored in the memory 801 to implement the steps of any of the low code application development method embodiments described above. In one particular implementation scenario, electronic device 800 may include, but is not limited to: the electronic device 800 may also include mobile devices such as a notebook computer and a tablet computer, and is not limited herein.
In particular, the processor 802 is operative to control itself as well as the memory 801 to implement the steps in any of the low code application development method embodiments described above. The processor 802 may also be referred to as a central processing unit (Central Processing Unit, CPU). The processor 802 may be an integrated circuit chip with signal processing capabilities. The processor 802 may also be a general-purpose processor, a digital signal processor (Digital Signal Processor, DSP), an application specific integrated circuit (Application Specific Integrated Circuit, ASIC), a Field-programmable gate array (Field-Programmable Gate Array, FPGA) or other programmable logic device, discrete gate or transistor logic device, discrete hardware components. A general purpose processor may be a microprocessor or the processor may be any conventional processor or the like. In addition, the processor 802 may be commonly implemented by an integrated circuit chip.
Referring to fig. 9, fig. 9 is a schematic structural diagram of an embodiment of a computer readable storage medium of the present application. The computer readable storage medium 900 stores program instructions 910 that can be executed by a processor, where the program instructions 910 are configured to implement the steps in any of the low code application development method embodiments described above.
In some embodiments, functions or modules included in an apparatus provided by the embodiments of the present disclosure may be used to perform a method described in the foregoing method embodiments, and specific implementations thereof may refer to descriptions of the foregoing method embodiments, which are not repeated herein for brevity.
The foregoing description of various embodiments is intended to highlight differences between the various embodiments, which may be the same or similar to each other by reference, and is not repeated herein for the sake of brevity.
In the several embodiments provided in the present application, it should be understood that the disclosed methods and apparatus may be implemented in other manners. For example, the apparatus embodiments described above are merely illustrative, e.g., the division of modules or units is merely a logical functional division, and there may be additional divisions of actual implementation, e.g., units or components may be combined or integrated into another system, or some features may be omitted, or not performed. Alternatively, the coupling or direct coupling or communication connection shown or discussed with each other may be an indirect coupling or communication connection via some interfaces, devices or units, which may be in electrical, mechanical, or other forms.
In addition, each functional unit in each embodiment of the present application may be integrated in one processing unit, or each unit may exist alone physically, or two or more units may be integrated in one unit. The integrated units may be implemented in hardware or in software functional units. The integrated units, if implemented in the form of software functional units and sold or used as stand-alone products, may be stored in a computer readable storage medium. Based on such understanding, the technical solution of the present application may be embodied essentially or in part or all or part of the technical solution contributing to the prior art or in the form of a software product stored in a storage medium, including several instructions to cause a computer device (which may be a personal computer, a server, or a network device, etc.) or a processor (processor) to perform all or part of the steps of the methods of the embodiments of the present application. And the aforementioned storage medium includes: a U-disk, a removable hard disk, a Read-Only Memory (ROM), a random access Memory (Random Access Memory, RAM), a magnetic disk, or an optical disk, or other various media capable of storing program codes.
Claims (10)
1. A low code application development method, characterized by being applied to a low code development platform, the low code development platform containing a service component and an interface access resource, the interface access resource being used to implement access of a specified interface, the service component being associated with at least one interface access resource to implement specified business functions, the method comprising:
acquiring a service component binding request for a low-code application;
responding to the service component binding request, and selecting a target component from the service components;
binding the target component to the low code application such that the low code application accesses resources through the target component invoking an interface associated with the target component.
2. The method of claim 1, wherein prior to the obtaining a service component binding request for a low code application, the method further comprises:
receiving service component description information sent by a component development terminal;
analyzing the service component description information to obtain interface access resources corresponding to the service component description information;
and associating the interface access resource with the service component corresponding to the service component description information.
3. The method according to claim 2, wherein associating the interface access resource with the service component corresponding to the service component description information comprises:
acquiring 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 with the interface access resource based on the version information.
4. The method of claim 1, wherein the obtaining a service component binding request for a low code application comprises:
receiving a service component query request, and displaying a service component contained in the low-code development platform on a service component selection page;
responding to a service component selection instruction aiming at the low-code application in the service component selection page, and taking 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.
5. The method of claim 4, wherein the generating a service component binding request for the low code application based on the service component to be bound comprises:
the version information corresponding to the service component to be bound is obtained, and the version information of the service component to be bound is displayed on the service component selection page;
responding to a version selection instruction aiming at the version information in the service component selection page, and determining the version information corresponding to the service component to be bound;
and generating a service component binding request aiming at the low-code application based on the service component to be bound and version information corresponding to the service component to be bound.
6. The method of claim 5, wherein the selecting a target component from the service components in response to the service component binding request comprises:
and selecting a target component from the service components based on the service components to be bound and version information corresponding to the service components to be bound.
7. The method according to any one of claims 1-6, further comprising:
acquiring an offline deployment request for the low-code application;
querying a target component bound by the low-code application in response to the offline deployment request;
and generating an executable code file based on the target component bound by the low-code application.
8. The method of claim 7, wherein the generating an executable code file based on the target component to which the low code application is bound comprises:
acquiring a preset standard component template;
assembling the target component bound by the low-code application based on the standard component template, and acquiring the dependent data of the target component bound by the low-code application;
and compiling and packaging the assembled service component information and the dependency data to obtain an executable code file.
9. An electronic device comprising a memory and a processor for executing program instructions stored in the memory to implement the low code application development method of any one of claims 1 to 8.
10. A computer readable storage medium having stored thereon program instructions, which when executed by a processor implement the low code application development method of any one of claims 1 to 8.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311019364.XA CN117289906A (en) | 2023-08-14 | 2023-08-14 | Low-code application development method, equipment and medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311019364.XA CN117289906A (en) | 2023-08-14 | 2023-08-14 | Low-code application development method, equipment and medium |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN117289906A true CN117289906A (en) | 2023-12-26 |
Family
ID=89252514
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202311019364.XA Pending CN117289906A (en) | 2023-08-14 | 2023-08-14 | Low-code application development method, equipment and medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN117289906A (en) |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN119536703A (en) * | 2025-01-16 | 2025-02-28 | 太极计算机股份有限公司 | Offline deployment method of low-code development platform |
| CN119536703B (en) * | 2025-01-16 | 2025-04-15 | 太极计算机股份有限公司 | An offline deployment method for a low-code development platform |
-
2023
- 2023-08-14 CN CN202311019364.XA patent/CN117289906A/en active Pending
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN119536703A (en) * | 2025-01-16 | 2025-02-28 | 太极计算机股份有限公司 | Offline deployment method of low-code development platform |
| CN119536703B (en) * | 2025-01-16 | 2025-04-15 | 太极计算机股份有限公司 | An offline deployment method for a low-code development platform |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN109840429B (en) | Intelligent contract deployment and calling method and device | |
| CN110688232B (en) | Application program calling method, terminal equipment and computer readable storage medium | |
| US9038082B2 (en) | Resource abstraction via enabler and metadata | |
| US7779408B1 (en) | Method and system for downloading and managing portable applications on a mobile device | |
| US20090300578A1 (en) | System and Method For Developing An Application For Extending Access to Local Software Of A Wireless Device | |
| US20060047665A1 (en) | System and method for simulating an application for subsequent deployment to a device in communication with a transaction server | |
| US20050198646A1 (en) | Method, data processing device, computer program product and arrangement for processing electronic data | |
| CN110716783A (en) | Front-end page generation and deployment method and device, storage medium and equipment | |
| US9477497B2 (en) | Methods for determining resource dependency and systems thereof | |
| CN109492181B (en) | Page jump method, device, computer equipment and storage medium | |
| CN112363845A (en) | Data synchronization method of system integration middling station and integration middling station system | |
| CN107273126B (en) | Application development method and device | |
| US7533383B2 (en) | Method, system, and apparatus for scheduling pattern based web services | |
| CN113961463A (en) | Application environment switching method and system, storage medium and electronic equipment | |
| CN115658187A (en) | Class implementation method, device, equipment and medium based on tangent plane-oriented programming | |
| CN116523457A (en) | Workflow processing method, device, equipment and storage medium based on business process | |
| CN116755788A (en) | On-line rule modification method, device, equipment and storage medium | |
| CN112769706A (en) | Componentized routing method and system | |
| JP2005228183A (en) | Program execution method and computer system for program execution | |
| CN114443905A (en) | Interface document updating method and device, electronic equipment and readable storage medium | |
| CN111026466A (en) | File processing method and device, computer readable storage medium and electronic equipment | |
| CN111488286A (en) | Method and device for independently developing Android module | |
| CN111309319A (en) | Inheritable office data dynamic page configuration method and device | |
| CN115604344B (en) | Micro-service current limiting method and device | |
| CN117289906A (en) | Low-code application development method, equipment and medium |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |