CN115509522A

CN115509522A - Interface arranging method and system for low-code scene and electronic equipment

Info

Publication number: CN115509522A
Application number: CN202211352444.2A
Authority: CN
Inventors: 张艺坤
Original assignee: Beijing Baidu Netcom Science and Technology Co Ltd
Current assignee: Beijing Baidu Netcom Science and Technology Co Ltd
Priority date: 2022-10-31
Filing date: 2022-10-31
Publication date: 2022-12-23

Abstract

The disclosure provides an interface arranging method, system, electronic equipment, storage medium and program product for a low-code scene, relates to the field of artificial intelligence, in particular to cloud computing, low-code and enterprise application technologies, and can be applied to a software development scene. The specific implementation scheme is as follows: determining a target task node matched with an interface to be arranged from the candidate task nodes; the target task node is used for enabling the interface to be programmed to realize a target additional function; and performing interface arrangement on the interface to be arranged according to the target task node. According to the method and the device, any target additional function can be configured for the interface to be arranged through the target task node, the interface arrangement of any business logic can be realized without changing the API interface, and the multiplexing rate, flexibility and compatibility of the interface arrangement are improved. The method is particularly suitable for API arrangement of a low-code platform.

Description

Interface arranging method and system for low-code scene and electronic equipment

Technical Field

The disclosure relates to the field of artificial intelligence, in particular to a cloud computing, low-code and enterprise application technology, which can be applied in a software development scene.

Background

The Interface arrangement refers to a process of performing visual arrangement on a developed API (Application Programming Interface) Interface according to a certain flow according to service logic. The API can be reconstructed and recombined without any code through interface arrangement, so that new service logic is realized, the reuse rate of the API can be improved on one hand, and the efficiency of developing the new service logic by developers can be improved on the other hand. However, the current interface layout is difficult to adapt to all service logics, and has certain limitations.

Disclosure of Invention

The present disclosure provides a low-code scene oriented interface arrangement method, system, electronic device, storage medium, and program product.

According to a first aspect of the present disclosure, there is provided a low-code scene oriented interface orchestration method, including:

determining a target task node matched with an interface to be programmed from the candidate task nodes; the target task node is used for enabling the interface to be programmed to realize a target additional function;

and performing interface arrangement on the interface to be arranged according to the target task node.

According to a second aspect of the present disclosure, there is provided a low-code scene oriented interface orchestration system, comprising:

the determining module is used for determining a target task node matched with the interface to be arranged from the candidate task nodes; the target task node is used for enabling the interface to be programmed to realize a target additional function;

and the arranging module is used for carrying out interface arrangement on the interface to be arranged according to the target task node.

According to a third aspect of the present disclosure, there is provided an electronic device comprising:

at least one processor; and

a memory communicatively coupled to the at least one processor; wherein, the first and the second end of the pipe are connected with each other,

the memory stores instructions executable by the at least one processor to enable the at least one processor to perform any of the low code scenario oriented interface orchestration methods described above.

According to a fourth aspect of the present disclosure, there is provided a non-transitory computer readable storage medium having stored thereon computer instructions for causing the computer to perform the low-code scene oriented interface orchestration method according to the first aspect.

According to a fifth aspect of the present disclosure, a computer program product is provided, comprising a computer program which, when executed by a processor, implements the low-code scene oriented interface orchestration method according to the first aspect.

It should be understood that the statements in this section do not necessarily identify key or critical features of the embodiments of the present disclosure, nor do they limit the scope of the present disclosure. Other features of the present disclosure will become apparent from the following description.

Drawings

The drawings are included to provide a better understanding of the present solution and are not to be construed as limiting the present disclosure. Wherein:

fig. 1 is a flowchart of a low-code scene oriented interface orchestration method according to an exemplary embodiment of the present disclosure;

FIG. 2 is a detailed flowchart of step 102 of FIG. 1;

FIG. 3 is a block diagram of an interface orchestration system according to an exemplary embodiment of the present disclosure;

fig. 4 is a block diagram of an electronic device for implementing a low-code scene oriented interface orchestration method according to an embodiment of the present disclosure.

Detailed Description

Exemplary embodiments of the present disclosure are described below with reference to the accompanying drawings, in which various details of embodiments of the present disclosure are included to assist understanding, and which are to be considered as merely exemplary. Accordingly, those of ordinary skill in the art will recognize that various changes and modifications of the embodiments described herein can be made without departing from the scope and spirit of the disclosure. Also, descriptions of well-known functions and constructions are omitted in the following description for clarity and conciseness.

Fig. 1 is a flowchart of an interface orchestration method for a low-code scene according to an exemplary embodiment of the present disclosure, where the interface orchestration method for a low-code scene includes:

step 101, determining a target task node matched with an interface to be scheduled from the candidate task nodes.

The target task node is used for enabling the interface to be programmed to achieve a target additional function. The target accessory function can be defined according to actual requirements, for example, the data format of the interface parameters of the API interface is specified, data processing is performed according to the parameter values of the interface parameters, and a target event is executed. The interface parameters include an out-reference and/or an in-reference. Data processing may include, but is not limited to, processing data aggregation, data checking, and the like.

The interface to be arranged is an interface which is selected by a user and needs to be arranged. The number of the interfaces to be programmed can be 1 or more. When the number of the interfaces to be programmed is multiple, the source of each interface to be programmed may be a local interface, or may be an interface of another application platform. When the number of the interfaces to be programmed is multiple, the sources of the interfaces to be programmed may be the same or different. The type of interface to be programmed may include, but is not limited to, restful interface, webService interface, dubbo interface, gRPC interface, and the like. The embodiments of the present disclosure are not particularly limited thereto.

In one embodiment, a user may select a target task node according to a requirement, specifically: displaying candidate task nodes; and in response to the selection operation for the candidate task node, determining the selected candidate task node as the target task node.

In practical application, the candidate task nodes can be displayed through the user interface, and a user can perform selection operation on the candidate task nodes displayed on the user interface to realize selection of the target task nodes.

In the embodiment of the disclosure, the user can select the target task node individually, so that the node to be arranged realizes the corresponding target additional function, and the node to be arranged is suitable for any service logic.

In one implementation, the candidate task node is displayed in a provided user interface, and the user may perform a selection operation by, but not limited to, clicking, dragging, voice, etc. to select a desired target task node.

The candidate task nodes are obtained by encapsulating the self-defined function codes. The candidate task node may be displayed on the user interface by, but is not limited to, at least one of: icon controls, textual description controls, scripts, and the like.

And displaying the candidate task nodes in a visual manner in a user interface, so that a user can conveniently select the required target task node.

In one implementation, user requirement information (corresponding to business logic) is obtained, and candidate task nodes with functions matched with the user requirement information are determined as target task nodes.

The target task node is determined based on the user requirement information provided by the user, and the target task node can be quickly and accurately matched from a plurality of candidate task nodes, so that the matching efficiency of the target task node is improved. When the number of the matched target task nodes is multiple, the user can select the required target task node from the multiple target task nodes.

In one embodiment, automatic matching of target task nodes is supported. Specifically, the method comprises the following steps: and determining the attribute of the interface to be programmed, and determining the candidate task node matched with the attribute as a target task node.

Wherein the attribute of the interface to be programmed comprises at least one of the following: the function of the interface, the dependency relationship of the interface, the exit of the interface and the entrance of the interface. The target task nodes are matched through various attributes, and the matching accuracy of the target nodes can be improved.

For example, if the number of the interfaces to be programmed is at least two, and there is a mismatch between the parameter access rule of at least one interface to be programmed and the parameter access rule of other interfaces to be programmed, for example, the parameter access format of the interface a to be programmed is format a, and the parameter access formats of other interfaces to be programmed are format b, and the interface a to be programmed and other interfaces to be programmed cannot be programmed, a candidate task node of a data format in which a target additional function is an interface parameter of a canonical API interface is automatically determined as a target task node from the candidate task nodes, so as to convert the parameter access format of the interface a to be programmed through the target task node or convert the parameter access formats of other interfaces to be programmed through the target task node, so that the interface a to be programmed is matched with the parameter access rule of at least one other interface to be programmed.

The mode of automatically matching the target task node can quickly and accurately match the target task node from a plurality of candidate task nodes, and obviously unsuitable candidate task nodes are eliminated. When the number of the matched target task nodes is multiple, the user can select the required target task node from the multiple target task nodes.

In one implementation, the corresponding relationship between the attributes and the candidate task nodes may be preset, and when the target task nodes are automatically matched, the target task nodes matched with the attributes of the interface to be arranged are determined according to the corresponding relationship.

And 102, performing interface layout on the interface to be laid according to the target task node.

In one embodiment, referring to fig. 2, step 102 specifically includes:

and 102-1, splicing the target task node and the interface to be programmed so that the target task node converts the interface parameter of the interface to be programmed into a conversion parameter corresponding to the target additional function.

The interface parameters comprise an exit parameter and/or an entry parameter.

In practical application, the target task node and the interface to be arranged can be spliced through the user interface, a user can drag the target task node and/or the interface to be arranged in the user interface and connect the target task node and the interface to be arranged through a connecting line, and splicing of the target task node and the interface to be arranged is achieved. And taking the conversion parameter of the target task node as a new external interface parameter of the interface to be programmed.

And 102-2, performing interface layout on the interface to be laid out spliced with the target task node.

In the embodiment of the disclosure, the interface arrangement implementation mode is simple, the operation is convenient, and the operation threshold of the operator for arranging the interface is reduced.

It should be noted that, when the number of the interfaces to be arranged is multiple, the user may set target task nodes for all the interfaces to be arranged according to the service requirement, or may set target task nodes for part of the interfaces to be arranged.

The number of the target task nodes of each interface to be programmed can be 1 or more, and the interface to be programmed configured with a plurality of target task nodes can realize a plurality of corresponding target additional functions.

In the embodiment of the disclosure, any target additional function can be configured for the interface to be arranged through the target task node, and interface arrangement of any service logic can be realized without changing the API interface, so that the multiplexing rate, flexibility and compatibility of the interface arrangement are improved. The method is particularly suitable for API arrangement of a low-code platform.

In one embodiment, the method further comprises: and acquiring a task code function, and packaging the task code into a candidate task node.

In the embodiment of the disclosure, a user can customize and write the task code function according to requirements so as to expand candidate task nodes. The candidate task nodes may be characterized, but are not limited to being, by a form of script.

In one embodiment, task configuration information is obtained, a code template matched with the task configuration information is determined, and candidate task nodes are generated according to the code template and the task configuration information.

The task configuration information includes: parameters, functional descriptions, etc. required by the candidate task nodes. When the candidate task nodes are generated, the code templates matched with the task configuration information can be determined according to the function description, parameters required by the candidate task nodes are filled into the code templates to generate task codes, and then the candidate task nodes can be automatically generated.

The parameters required by the candidate task nodes comprise at least one of the following parameters: conversion parameters, interface parameters, intermediate temporary parameters, and the like.

The development voice of task code is not particularly limited in the embodiments of the present disclosure, and may include, but is not limited to, at least one of the following: c voice, python, javascript, java, etc.

In the embodiment of the disclosure, the user can customize and expand the candidate task nodes according to the requirement, and the candidate task nodes are generated through the code template, so that the threshold of the user for developing the candidate task nodes is reduced, and the user operation is facilitated.

One implementation of the task code of the target task node being executed in the API arrangement is described as follows:

and performing semantic analysis and syntactic analysis on the newly generated task code of the target task node to ensure that the task code has no syntactic problem, compiling and loading the task code without the syntactic problem to an execution engine, starting a main function by the execution engine, and executing the task code of the target task node so that the target task node converts the interface parameters of the interface to be arranged connected with the target task node into conversion parameters corresponding to the target additional function, wherein the conversion parameters are used as new external interface parameters of the interface to be arranged. The entry of the task code is context information, specifically a set of variables defined in the task code and related to business logic, which is a set of dynamic variables including at least one of: interface parameters of the interface to be programmed, conversion parameters in the task code, intermediate temporary parameters in the process of converting the interface parameters into the conversion parameters, and the like. The user can customize the parameters of the task codes to be null, and can also modify the dynamic variables by modifying the task codes in the execution process of the target task nodes so as to realize parameter adaptation, data processing and the like of the target task nodes. When the API arranges and executes the target task node, the values of the group of dynamic variables are required to be fetched, and the values of the group of dynamic variables arranged in the API are transmitted to the target task node in a parameter entering mode. And after the task code of the target task node is executed, generating new context information and outputting the new context information. The context variable included in the new context information may be the same as or different from the input context variable.

In one implementation, the main function is started by a GraalVM (a new generation of high performance cross-language virtual machine) engine, and the task code of the target task node is executed. The GraalVM engine is described below: the GraalVM engine is an open source engine framework of Oracle (a relational database management system), can support the execution of various programming languages, such as Java/R/JavaScript/Python/Scale/C/Ruby (all programming languages), and the like, and has the following specific principle:

the GraalVM converts various programming languages into Truffle languages realized by the GraalVM through a multi-language interpreter of the GraalVM, wherein the conversion process also relates to semantic and syntax analysis of the GraalVM; compiling the Truffle language through GraalVM; after compilation, the specific execution logic is performed using the underlying substrettevm (a kind of executor).

It should be noted that the execution engine is not limited to the GraalVM engine, and other execution engines may also be used, and the present disclosure is not limited thereto.

Corresponding to the embodiment of the interface arrangement method for the low-code scene, the disclosure also provides an embodiment of an interface arrangement system for the low-code scene.

Fig. 3 is a schematic block diagram of an interface orchestration system for low-code scenes according to an exemplary embodiment of the present disclosure, where the interface orchestration system includes:

the determining module 31 is configured to determine a target task node matched with the interface to be scheduled from the candidate task nodes; the target task node is used for enabling the interface to be programmed to realize a target additional function;

and the arranging module 32 is used for performing interface arrangement on the interface to be arranged according to the target task node.

Optionally, wherein the determining module includes:

the display unit is used for displaying the candidate task nodes;

and the determining unit is used for responding to the selection operation aiming at the candidate task node and determining the selected candidate task node as the target task node.

Optionally, wherein the determining module includes:

the first determining unit is used for determining the attribute of the interface to be programmed;

and the second determining unit is used for determining the candidate task node matched with the attribute as the target task node.

Optionally, wherein the attribute comprises at least one of: the functions of the interfaces, the dependency relationship of the interfaces, the exit participation of the interfaces and the entrance participation of the interfaces.

Optionally, wherein the orchestration module comprises:

the splicing unit is used for splicing the target task node and the interface to be programmed so that the target task node converts the interface parameter of the interface to be programmed into a conversion parameter corresponding to the target additional function; the interface parameters comprise an exit parameter and/or an entry parameter;

and the arranging unit is used for carrying out interface arrangement on the interface to be arranged spliced with the target task node.

Optionally, the method further comprises:

the encapsulation module is used for acquiring task codes and encapsulating the task codes into the candidate task nodes;

and/or the generating module is used for acquiring task configuration information, determining a code template matched with the task configuration information, and generating the candidate task node according to the code template and the task configuration information.

For the system embodiment, since it basically corresponds to the method embodiment, reference may be made to the partial description of the method embodiment for relevant points. The above-described system embodiments are merely illustrative, and the units described as separate parts may or may not be physically separate, and parts displayed as units may or may not be physical units, may be located in one place, or may be distributed on multiple network units. Some or all of the modules can be selected according to actual needs to achieve the purpose of the disclosed solution. One of ordinary skill in the art can understand and implement it without inventive effort.

The present disclosure also provides an electronic device, a readable storage medium, and a computer program product according to embodiments of the present disclosure.

Fig. 4 shows a schematic block diagram of an example electronic device 800 that may be used to implement embodiments of the present disclosure. Electronic devices are intended to represent various forms of digital computers, such as laptops, desktops, workstations, personal digital assistants, servers, blade servers, mainframes, and other appropriate computers. Electronic devices may also represent various forms of mobile devices, such as personal digital processors, cellular telephones, smart phones, wearable devices, and other similar computing devices. The components shown herein, their connections and relationships, and their functions, are meant to be examples only, and are not meant to limit implementations of the disclosure described and/or claimed herein.

As shown in fig. 4, the apparatus 800 includes a computing unit 801 which can perform various appropriate actions and processes according to a computer program stored in a Read Only Memory (ROM) 802 or a computer program loaded from a storage unit 808 into a Random Access Memory (RAM) 803. In the RAM803, various programs and data necessary for the operation of the device 800 can also be stored. The calculation unit 801, the ROM 802, and the RAM803 are connected to each other by a bus 804. An input/output (I/O) interface 805 is also connected to bus 804.

A number of components in the device 800 are connected to the I/O interface 805, including: an input unit 806, such as a keyboard, a mouse, or the like; an output unit 807 such as various types of displays, speakers, and the like; a storage unit 808, such as a magnetic disk, optical disk, or the like; and a communication unit 809 such as a network card, modem, wireless communication transceiver, etc. The communication unit 809 allows the device 800 to exchange information/data with other devices via a computer network such as the internet and/or various telecommunication networks.

Computing unit 801 may be a variety of general and/or special purpose processing components with processing and computing capabilities. Some examples of the computing unit 801 include, but are not limited to, a Central Processing Unit (CPU), a Graphics Processing Unit (GPU), various dedicated Artificial Intelligence (AI) computing chips, various computing units running machine learning model algorithms, a Digital Signal Processor (DSP), and any suitable processor, controller, microcontroller, and so forth. The computing unit 801 performs the low code scenario oriented interface orchestration methods and processes described above. For example, in some embodiments, the low code scenario-oriented interface orchestration method may be implemented as a computer software program tangibly embodied in a machine-readable medium, such as storage unit 808. In some embodiments, part or all of the computer program can be loaded and/or installed onto device 800 via ROM 802 and/or communications unit 809. When the computer program is loaded into RAM803 and executed by the computing unit 801, one or more steps of the low code scenario oriented interface orchestration method described above may be performed. Alternatively, in other embodiments, the computing unit 801 may be configured to perform the low-code scenario-oriented interface orchestration method by any other suitable means (e.g., by means of firmware).

Various implementations of the systems and techniques described here above may be implemented in digital electronic circuitry, integrated circuitry, field Programmable Gate Arrays (FPGAs), application Specific Integrated Circuits (ASICs), application Specific Standard Products (ASSPs), system on a chip (SOCs), complex Programmable Logic Devices (CPLDs), computer hardware, firmware, software, and/or combinations thereof. These various embodiments may include: implemented in one or more computer programs that are executable and/or interpretable on a programmable system including at least one programmable processor, which may be special or general purpose, receiving data and instructions from, and transmitting data and instructions to, a storage system, at least one input device, and at least one output device.

Program code for implementing the methods of the present disclosure may be written in any combination of one or more programming languages. These program codes may be provided to a processor or controller of a general purpose computer, special purpose computer, or other programmable data processing apparatus, such that the program codes, when executed by the processor or controller, cause the functions/operations specified in the flowchart and/or block diagram to be performed. The program code may execute entirely on the machine, partly on the machine, as a stand-alone software package, partly on the machine and partly on a remote machine or entirely on the remote machine or server.

In the context of this disclosure, a machine-readable medium may be a tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device. The machine-readable medium may be a machine-readable signal medium or a machine-readable storage medium. A machine-readable medium may include, but is not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any suitable combination of the foregoing. More specific examples of a machine-readable storage medium would include an electrical connection based on one or more wires, a portable computer diskette, a hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing.

To provide for interaction with a user, the systems and techniques described here can be implemented on a computer having: a display device (e.g., a CRT (cathode ray tube) or LCD (liquid crystal display) monitor) for displaying information to a user; and a keyboard and a pointing device (e.g., a mouse or a trackball) by which a user can provide input to the computer. Other kinds of devices may also be used to provide for interaction with a user; for example, feedback provided to the user can be any form of sensory feedback (e.g., visual feedback, auditory feedback, or tactile feedback); and input from the user may be received in any form, including acoustic, speech, or tactile input.

The systems and techniques described here can be implemented in a computing system that includes a back-end component (e.g., as a data server), or that includes a middleware component (e.g., an application server), or that includes a front-end component (e.g., a user computer having a graphical user interface or a web browser through which a user can interact with an implementation of the systems and techniques described here), or any combination of such back-end, middleware, or front-end components. The components of the system can be interconnected by any form or medium of digital data communication (e.g., a communication network). Examples of communication networks include: local Area Networks (LANs), wide Area Networks (WANs), and the Internet.

The computer system may include clients and servers. A client and server are generally remote from each other and typically interact through a communication network. The relationship of client and server arises by virtue of computer programs running on the respective computers and having a client-server relationship to each other. The server may be a cloud server, a server of a distributed system, or a server with a combined blockchain.

The disclosed embodiments also provide a non-transitory computer readable storage medium storing computer instructions for causing the computer to execute any one of the above interface orchestration methods for low code scenes.

Embodiments of the present disclosure further provide a computer program product, which includes a computer program, and when the computer program is executed by a processor, the computer program implements the low-code scene oriented interface orchestration method according to any one of the above.

It should be understood that various forms of the flows shown above, reordering, adding or deleting steps, may be used. For example, the steps described in the present disclosure may be executed in parallel, sequentially, or in different orders, as long as the desired results of the technical solutions disclosed in the present disclosure can be achieved, and the present disclosure is not limited herein.

The above detailed description should not be construed as limiting the scope of the disclosure. It should be understood by those skilled in the art that various modifications, combinations, sub-combinations and substitutions may be made, depending on design requirements and other factors. Any modification, equivalent replacement, and improvement made within the spirit and principle of the present disclosure should be included in the scope of protection of the present disclosure.

Claims

1. A low-code scene oriented interface arrangement method comprises the following steps:

determining a target task node matched with an interface to be arranged from the candidate task nodes; the target task node is used for enabling the interface to be programmed to realize a target additional function;

and interface arrangement is carried out on the interface to be arranged according to the target task node.

2. The interface orchestration method according to claim 1, wherein the determining a target task node from the candidate task nodes that matches the interface to be orchestrated comprises:

displaying candidate task nodes;

and in response to the selection operation aiming at the candidate task node, determining the selected candidate task node as the target task node.

3. The interface orchestration method according to claim 1, wherein the determining a target task node from the candidate task nodes that matches the interface to be orchestrated comprises:

determining the attribute of the interface to be programmed;

and determining the candidate task node matched with the attribute as the target task node.

4. The interface orchestration method according to claim 3, wherein the attribute comprises at least one of: the function of the interface, the dependency relationship of the interface, the exit of the interface, the entrance of the interface and the type of the interface.

5. The interface orchestration method according to any one of claims 1-4, wherein the interfacing the interface to be orchestrated according to the target task node comprises:

splicing the target task node and the interface to be programmed to enable the target task node to convert the interface parameter of the interface to be programmed into a conversion parameter corresponding to the target additional function; the interface parameters comprise an exit parameter and/or an entry parameter;

and performing interface arrangement on the interface to be arranged spliced with the target task node.

6. The interface orchestration method according to claim 1, further comprising:

acquiring a task code, and packaging the task code into the candidate task node;

and/or acquiring task configuration information, determining a code template matched with the task configuration information, and generating the candidate task node according to the code template and the task configuration information.

7. A low-code scene oriented interface orchestration system, comprising:

8. The interface orchestration system according to claim 7, wherein the determination module comprises:

the display unit is used for displaying the candidate task nodes;

9. The interface orchestration system according to claim 7, wherein the determination module comprises:

10. The interface orchestration system according to claim 9, wherein the attributes comprise at least one of: the function of the interface, the dependency relationship of the interface, the exit of the interface and the entrance of the interface.

11. The interface orchestration system according to any one of claims 7-10, wherein the orchestration module comprises:

12. The interface orchestration system according to claim 7, further comprising:

13. An electronic device, comprising:

at least one processor; and

a memory communicatively coupled to the at least one processor; wherein the content of the first and second substances,

the memory stores instructions executable by the at least one processor to enable the at least one processor to perform the low-code scene oriented interface orchestration method according to any one of claims 1-6.

14. A non-transitory computer readable storage medium storing computer instructions for causing the computer to perform the low code scene oriented interface orchestration method according to any one of claims 1-6.

15. A computer program product comprising a computer program which, when executed by a processor, implements a low-code scene oriented interface orchestration method according to any one of claims 1-6.