Data flow interface dynamic arrangement method and device, equipment, medium and program product

Abstract

This application provides a method, apparatus, device, medium, and program product for dynamic orchestration of data flow interfaces. The method involves copying individual business atomic modules from a graphical module library to a module assembly interface in response to drag-and-drop commands at the front end. Then, in response to logic assembly commands, the individual business atomic modules are assembled into a target business module. The parsing request for the data flow interface is determined based on the target business module and preset interface parameters and sent to the back end. At the back end, the interface source file is determined based on the received parsing request and a preset dynamic template. The interface source file is then dynamically compiled according to the application environment of the interface. Finally, an interface encapsulator encapsulates the compilation result to determine the target data flow interface. This method achieves the goal of using a graphical front-end system to construct the core logic of the interface and then using a back-end service system to automatically and dynamically orchestrate the interface code encapsulation, thus solving the technical problem of low development efficiency caused by the reliance on direct code customization in existing technologies for interface development.

Description

Technical Field

[0001] This application relates to the field of computer data processing, and in particular to a method, apparatus, device, medium and program product for dynamic arrangement of data flow interfaces. Background Technology

[0002] With the continuous development of Internet technology, the demand for new, updated, and maintained applications is accelerating, resulting in an increasing workload for developers. In particular, the development of interfaces between front-end and back-end service systems is a particularly arduous and repetitive task for developers.

[0003] Currently, API (Application Programming Interface) development involves developers directly writing the relevant code based on their understanding of the application's requirements specification. This means that interfaces are built through customized development for specific front-end applications and back-end service systems.

[0004] However, due to the large amount of repetitive code editing work involved in the customized code development approach, developers are unable to separate the core logic of the interface from the code editing, resulting in the technical problem of low interface development efficiency. Summary of the Invention

[0005] This application provides a method, apparatus, device, medium, and program product for dynamic orchestration of data flow interfaces. By using a graphical front-end system to construct the core logic of the interface, and then using a back-end service system to automatically and dynamically orchestrate the code program encapsulation corresponding to the interface based on the core logic of the interface, it solves the technical problem of low development efficiency caused by relying on direct code customization to develop interfaces in the existing technology.

[0006] Firstly, this application provides a dynamic orchestration method for data stream interfaces, applied to a backend service system, including:

[0007] Receive parsing requests sent by the front-end system;

[0008] The original interface file is determined based on the parsing request and the preset dynamic template;

[0009] The original interface file is dynamically compiled according to the application environment indicated in the parsing request in order to determine the compilation result. The application environment is the platform environment used by the target data stream interface. The target data stream is used for data interaction between the front-end system and the back-end service system.

[0010] Using the interface wrapper, the target data stream interface is determined based on the compilation results.

[0011] In one possible design, determining the interface source file based on the parsing request and a preset dynamic template includes:

[0012] Determine the mapping protocol string and preset interface parameters based on the parsing request;

[0013] Based on the preset interface parameters and preset data protocol parsing mapping protocol strings, each interface unit is determined;

[0014] Pre-read the preset dynamic template and add the interface method units in the preset dynamic template to the interface unit to determine the original interface file. The method unit includes: interface request method, access path specification and method declaration.

[0015] In one possible design, the step of dynamically compiling the interface source file according to the application environment indicated in the parsing request to determine the compilation result includes:

[0016] Determine the appropriate compiler based on the application environment;

[0017] The compiler dynamically compiles the interface source file and loads environment units related to the application environment into the interface source file to determine the compilation result.

[0018] In one possible design, the step of dynamically compiling the interface source file using a compiler, while simultaneously loading application-environment-related environment units into the interface source file to determine the compilation result, includes:

[0019] The file management instance is determined by the compiler;

[0020] The environment unit is loaded into the file management instance, and the compilation task instance is built using the file management instance;

[0021] Compile the task instance to determine the compilation result.

[0022] In one possible design, prior to loading the environment unit into the file management instance, the following is also included:

[0023] Create an interface unit loader based on the context module of the current thread;

[0024] Construct a source file instance based on the compilation unit name of the original interface file;

[0025] Use the interface unit loader to add the source file instance to the file management instance;

[0026] Correspondingly, the environment unit is loaded into the file management instance, including:

[0027] Use the interface unit loader to load the environment unit into the file management instance.

[0028] In one possible design, the step of utilizing an interface wrapper to determine the target data stream interface based on the compilation results includes:

[0029] The request-processor mapper is determined based on the application context module of the interface wrapper.

[0030] Determine the corresponding interface method units based on the compilation results;

[0031] Based on the request-processing mapper, the target method unit annotated with the request mapper is selected from each interface method unit;

[0032] Using the dynamic proxy module, the target data stream interface is registered based on the compilation results and the target method unit.

[0033] Optionally, after determining the corresponding interface method units based on the compilation results, the method further includes:

[0034] Set the private properties of the interface method unit to visible properties.

[0035] In one possible design, the dynamic orchestration method for the data flow interface also includes:

[0036] Return the target data stream interface to the front-end system.

[0037] Secondly, this application provides a dynamic orchestration method for data flow interfaces, applied to a front-end system, including:

[0038] In response to the user's drag-and-drop command, each business atomic module is copied from the graphical module library to the module assembly interface. The business atomic module is a graphical module that organizes business logic according to a preset format.

[0039] In response to the user's logical assembly command, the various business atomic modules are assembled into the target business module;

[0040] The parsing request for the data flow interface is determined based on the target business module and preset interface parameters;

[0041] Send a parsing request to the backend service system so that the backend service system can dynamically parse the data based on the parsing request and determine the target data stream interface.

[0042] In one possible design, determining the parsing request of the data flow interface based on the target business module and preset interface parameters includes:

[0043] The mapping protocol string is determined based on the target business module and the preset data protocol. The mapping protocol string is used to represent each business atomic module and the business logic relationship between each business atomic module.

[0044] The parsing request is determined based on the mapping protocol string and preset interface parameters.

[0045] In one possible design, determining the mapping protocol string based on the target business module and a preset data protocol includes:

[0046] Establish a mapping relationship between each business atomic module and its corresponding business logic in the target business module according to the format of the preset data protocol to determine the mapping protocol string.

[0047] Optionally, the preset data protocol is the JSON protocol, and the step of establishing a mapping relationship between each business atomic module and its corresponding business logic in the target business module according to the format of the preset data protocol to determine the mapping protocol string includes:

[0048] Pass the target business module to the backend service system;

[0049] The backend service system maps each business atomic module and its corresponding business logic to JSON text according to the JSON protocol.

[0050] Determine the mapping protocol string based on the JSON text.

[0051] Thirdly, this application provides a dynamic orchestration apparatus for a data stream interface, comprising:

[0052] The receiving module is used to receive parsing requests sent by the front-end system;

[0053] The request processing module is used to determine the original interface file based on the parsing request and the preset dynamic template;

[0054] The compilation module is used to dynamically compile the interface source file according to the application environment indicated in the parsing request, so as to determine the compilation result. The application environment is the platform environment used by the target data stream interface, and the target data stream is used for data interaction between the front-end system and the back-end service system.

[0055] The encapsulation module is used to determine the target data stream interface based on the compilation results using an interface encapsulator.

[0056] In one possible design, the request processing module is used to determine the interface source file based on the parsed request and a preset dynamic template, including:

[0057] The request processing module is used to determine the mapping protocol string and preset interface parameters based on the parsed request;

[0058] The request processing module is also used to parse the mapping protocol string according to the preset interface parameters and the preset data protocol to determine each interface unit;

[0059] The request processing module is also used to pre-read the preset dynamic template and add the interface method units in the preset dynamic template to the interface unit to determine the interface source file. The method unit includes: interface request method, access path specification and method declaration.

[0060] In one possible design, the compilation module is used to dynamically compile the interface source file according to the application environment indicated in the parsing request, in order to determine the compilation result, including:

[0061] The compiler module is used to determine the appropriate compiler based on the application environment.

[0062] The compilation module is also used to dynamically compile interface source files using the compiler, and to load environment units related to the application environment into the interface source files to determine the compilation result.

[0063] In one possible design, the compilation module is further configured to dynamically compile the interface source file using a compiler, and simultaneously load application-environment-related environment units into the interface source file to determine the compilation result, including:

[0064] The compilation module is also used to determine the file management instance based on the compiler;

[0065] The compilation module is also used to load environment units into the file management instance and construct compilation task instances through the file management instance; and to perform compilation on the task instances to determine the compilation results.

[0066] In one possible design, the compilation module further includes, before loading the environment unit into the file management instance:

[0067] The compilation module is also used to create an interface unit loader based on the context module of the current thread; construct a source file instance based on the compilation unit name of the interface source file; and add the source file instance to the file management instance using the interface unit loader.

[0068] Correspondingly, the compilation module is also used to load the environment unit into the file management instance, including:

[0069] The compilation module is also used to load environment units into the file management instance using the interface unit loader.

[0070] In one possible design, the encapsulation module is used to determine the target data stream interface based on the compilation results using an interface encapsulator, including:

[0071] The encapsulation module is used to determine the request-processor mapper based on the application context module of the interface encapsulator;

[0072] The encapsulation module is also used to determine the corresponding interface method units based on the compilation results;

[0073] The encapsulation module is also used to filter out target method units annotated with request mappers from each interface method unit based on the request-processing mapper;

[0074] The encapsulation module is also used to register the target data stream interface based on the compilation results and the target method unit, utilizing the dynamic proxy module.

[0075] Optionally, the encapsulation module, after determining the corresponding interface method units based on the compilation results, further includes:

[0076] The encapsulation module is also used to set the private properties of interface method units to visible properties.

[0077] In one possible design, the data stream interface dynamic orchestration device further includes:

[0078] The sending module is used to return the target data stream interface to the front-end system.

[0079] Fourthly, this application provides a data stream interface dynamic orchestration apparatus, comprising:

[0080] The acquisition module is used to acquire the user's drag and drop commands;

[0081] The graphical library module is used to respond to drag and drop commands to copy various business atomic modules to the module assembly interface. The business atomic module is a graphical module that organizes business logic according to a preset format.

[0082] The acquisition module is also used to acquire the user's logical assembly instructions;

[0083] The assembly module is used to assemble various business atomic modules into a target business module in response to logical assembly instructions;

[0084] The processing module is used to determine the parsing request of the data stream interface based on the target business module and preset interface parameters;

[0085] The processing module is also used to send parsing requests to the backend service system, so that the backend service system can dynamically parse according to the parsing requests and determine the target data stream interface.

[0086] In one possible design, the processing module is used to determine the parsing request of the data stream interface based on the target business module and preset interface parameters, including:

[0087] The processing module is used to determine a mapping protocol string based on the target business module and a preset data protocol. The mapping protocol string is used to represent each of the business atomic modules and the business logic relationship between each of the business atomic modules.

[0088] The processing module is also used to determine the parsing request based on the mapping protocol string and preset interface parameters.

[0089] In one possible design, the processing module is configured to determine a mapping protocol string based on the target business module and a preset data protocol, including:

[0090] The processing module is used to establish a mapping relationship between each business atomic module and its corresponding business logic in the target business module according to the format of a preset data protocol, so as to determine the mapping protocol string.

[0091] Optionally, the preset data protocol is the JSON protocol, and the processing module is used to establish a mapping relationship between each business atomic module and its corresponding business logic in the target business module according to the format of the preset data protocol, so as to determine the mapping protocol string, including:

[0092] The processing module is used to pass the target business module to the backend service system; the backend service system maps each business atomic module and its corresponding business logic into JSON text according to the JSON protocol; and determines the mapping protocol string based on the JSON text.

[0093] Fifthly, this application provides an electronic device, comprising:

[0094] Memory, used to store program instructions;

[0095] The processor is used to call and execute program instructions in the memory, and to execute any possible data flow interface dynamic orchestration method provided in the first aspect.

[0096] In a sixth aspect, this application provides an electronic device, comprising:

[0097] Memory, used to store program instructions;

[0098] The processor is used to call and execute program instructions in the memory, and to execute any possible data flow interface dynamic orchestration method provided in the second aspect.

[0099] In a seventh aspect, this application provides a storage medium storing a computer program for executing any of the possible data stream interface dynamic orchestration methods provided in the first aspect.

[0100] In an eighth aspect, this application provides a storage medium storing a computer program for executing any of the possible data stream interface dynamic orchestration methods provided in the second aspect.

[0101] Ninthly, this application also provides a computer program product, including a computer program that, when executed by a processor, implements any of the possible data flow interface dynamic orchestration methods provided in the first aspect.

[0102] On page ten, this application also provides a computer program product, including a computer program that, when executed by a processor, implements any of the possible data flow interface dynamic orchestration methods provided in the second aspect.

[0103] This application provides a method, apparatus, device, medium, and program product for dynamic orchestration of data flow interfaces. The method involves copying individual business atomic modules from a graphical module library to a module assembly interface in response to drag-and-drop commands at the front end. Then, in response to logic assembly commands, the individual business atomic modules are assembled into a target business module. The parsing request for the data flow interface is determined based on the target business module and preset interface parameters and sent to the back end. At the back end, the interface source file is determined based on the received parsing request and a preset dynamic template. The interface source file is then dynamically compiled according to the application environment of the interface. Finally, an interface encapsulator encapsulates the compilation result to determine the target data flow interface. This method achieves the goal of using a graphical front-end system to construct the core logic of the interface and then using a back-end service system to automatically and dynamically orchestrate the interface code encapsulation, thus solving the technical problem of low development efficiency caused by the reliance on direct code customization in existing technologies for interface development. Attached Figure Description

[0104] To more clearly illustrate the technical solutions in this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0105] Figure 1 A schematic diagram illustrating the principle of the interface provided in this application;

[0106] Figure 2 A schematic diagram of a front-end graphical interface logic editing interface provided in this application;

[0107] Figure 3 A flowchart illustrating a dynamic orchestration method for a data flow interface provided in this application;

[0108] Figure 4 A flowchart illustrating another dynamic orchestration method for data flow interfaces provided in this application;

[0109] Figure 5 A schematic diagram of a data stream interface dynamic orchestration device provided in this application;

[0110] Figure 6 A schematic diagram of a data stream interface dynamic orchestration device provided in this application;

[0111] Figure 7 A schematic diagram of the structure of an electronic device provided in this application;

[0112] Figure 8 This is a schematic diagram of the structure of an electronic device provided in this application. Detailed Implementation

[0113] To make the objectives, technical solutions, and advantages of the embodiments of this application clearer, the technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, and not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort, including but not limited to combinations of multiple embodiments, are within the scope of protection of this application.

[0114] The terms “first,” “second,” “third,” “fourth,” etc. (if present) in the specification, claims, and accompanying drawings of this application are used to distinguish similar objects and are not necessarily used to describe a particular order or sequence. It should be understood that such data can be interchanged where appropriate so that the embodiments of this application described herein can be implemented, for example, in orders other than those illustrated or described herein. Furthermore, the terms “comprising” and “having,” and any variations thereof, are intended to cover a non-exclusive inclusion; for example, a process, method, system, product, or apparatus that comprises a series of steps or units is not necessarily limited to those steps or units explicitly listed, but may include other steps or units not explicitly listed or inherent to such processes, methods, products, or apparatus.

[0115] Current API development relies on developers directly writing code to carry the interface logic based on the requirements in the specifications document and their own understanding—a customized development approach. However, this approach prevents developers from decoupling the interface implementation logic from the code syntax. Developers are overwhelmed by repetitive coding, resulting in low development efficiency. Furthermore, interfaces with the same functionality cannot be directly used in different platform environments, requiring repeated development across different platforms, leading to a significant waste of human and material resources.

[0116] Since the above problems have not been solved, the inventive concept of this application aims to:

[0117] By utilizing a graphical front-end system to construct the core logic of the interface, and then using a back-end service system to automatically and dynamically orchestrate the corresponding code program encapsulation based on the core logic of the interface, users can directly assemble the interface logic through the graphical interface in the front-end system, and then the back-end system will automatically compile and encapsulate it into the required target data stream interface according to the application environment.

[0118] For ease of understanding, the terms used in this application are introduced below.

[0119] An interface is a channel for data exchange between users and the system, between modules, and between the front-end and back-end systems. Both parties use interfaces to receive and send data. For example, an interface receives a request from one system, converts it into a request format that the other system can recognize, and then sends it to the other system for processing.

[0120] Figure 1 A schematic diagram illustrating the principle of the interface provided in this application. (For example...) Figure 1 As shown, the front-end system 11 needs to pass data or requests to the back-end system 12. For different data or requests, or for the same back-end system to correspond to different front-end systems, or for the same front-end system to correspond to multiple back-end systems, each needs its own corresponding data transmission channel, i.e., interface 13, to transmit data and form a data stream.

[0121] The following section, with reference to the accompanying drawings, provides a detailed description of the method for dynamically orchestrating pages using the data flow interface provided in this application.

[0122] Figure 2 This is a schematic diagram of a front-end graphical interface logic editing interface provided in this application. (See diagram below.) Figure 2 As shown, the graphical interface logic editing interface includes a graphical module library 21, a module assembly interface 22, a preset interface parameter input area 23, control command buttons (such as a run button, a basic module library button, a reset button, etc.), and an output result display area. The graphical module library 21 includes at least one user-defined business atomic module 211 based on business logic. Users drag and drop the required business atomic modules into the module assembly interface 22, and then assemble them using basic modules from the basic module library. These basic modules include: Logic modules, Loops modules, Math modules, Text modules, Lists modules, Color modules, Variables modules, and Functions modules, etc. The Logic module includes various logical operation modules, such as arithmetic operations, summation operations, differentiation / integration operations, etc.

[0123] The following explains how users can... Figure 2The interface shown uses the data flow interface dynamic orchestration method provided in this application to automatically generate the target data flow interface, which will be described in detail below.

[0124] Figure 3 This is a flowchart illustrating a dynamic orchestration method for a data flow interface provided in this application. Figure 3 As shown, the specific steps of this dynamic orchestration method for the data stream interface include:

[0125] S301: In response to the user's drag-and-drop command, copy each business atomic module from the graphical module library to the module assembly interface.

[0126] In this step, the business atomic module is a graphical module that organizes business logic according to a preset format.

[0127] Specifically, users, i.e., developers, first need to customize the business atomic modules based on the business logic involved in the target data flow interface. Developers break down the business logic into the smallest business unit capable of implementing the basic logic—the atomic business. Then, developers graphically encapsulate the atomic business using the graphical module customization interface provided by the front-end system, forming the business atomic module. Because atomic businesses have high versatility and can be called by various complex businesses, the number of custom business atomic modules included in the graphical module library will become increasingly rich as developers continue to improve it. Furthermore, developers can add assembled complex modules to the graphical module library to form new business atomic modules, thus achieving nested reuse of business atomic modules.

[0128] When developers need to develop a new interface, i.e., a target data flow interface, they can drag or copy the business atomic module from the graphical module library to the module assembly interface.

[0129] S302. In response to the user's logical assembly command, assemble the various business atomic modules into the target business module.

[0130] In this step, the user uses a combination of business atomic modules and basic modules to implement the business logic of the target data flow interface. This multi-module assembly is the target business module.

[0131] For example: Figure 2 As shown, the target business module 221 in the module assembly interface 22 is obtained by splicing together the business atomic modules 1 to 3, the variable module (setting identification identifier and setting inventory identifier), the logic module (summation), and the list module (creating a collection).

[0132] S303. Determine the parsing request of the data flow interface based on the target business module and preset interface parameters.

[0133] In this step, the user, i.e. the developer, enters some basic parameters of the target data flow interface, i.e., the preset interface parameters, such as: name, type, application environment, calling method and path, input parameters, output parameters, declaration, etc., into the preset interface parameter input area. After clicking the run button, the front-end system generates a parsing request together with the objects and business logic involved in the target business module 221 and the preset interface parameters.

[0134] In one possible implementation, this step specifically includes:

[0135] The mapping protocol string is determined based on the target business module and the preset data protocol. The mapping protocol string is used to represent each business atomic module and the business logic relationship between each business atomic module.

[0136] The parsing request is determined based on the mapping protocol string and preset interface parameters.

[0137] S304. Send a parsing request to the backend service system.

[0138] It should be noted that steps S301 through S304 are all completed in the front-end system. Optionally, for the front-end system, such as... Figure 2 The management system corresponding to the graphical management interface shown can be built using the Blockly graphical solution.

[0139] S305: Receive the parsing request sent by the front-end system, and determine the original interface file based on the parsing request and the preset dynamic template.

[0140] In this step, the backend service system receives the parsing request sent by the frontend system, and then determines the mapping protocol string and preset interface parameters based on the parsing request; next, it parses the mapping protocol string based on the preset interface parameters and preset data protocol to determine each interface unit; then, it pre-reads the preset dynamic template and adds the interface method units from the preset dynamic template to the interface units to determine the interface source file. The method units include: interface request method, access path specification, and method declaration.

[0141] Specifically, based on the parsing request, interface units corresponding to each business atomic module and interface method units corresponding to the business logic relationships between each business atomic module are created. Then, preset dynamic templates are used to implement the data request and / or processing methods and implementation paths corresponding to the business logic relationships in the application environment of the target data flow interface.

[0142] It should be noted that, in this embodiment, one implementation of the interface unit is a Java class object, and another implementation of the interface method unit is a Java method / functionality class, or function object, or simply a function. It is understandable that a method class is essentially a type of Java class.

[0143] S306. Dynamically compile the interface source code according to the application environment indicated in the parsing request.

[0144] In this step, the application environment refers to the platform environment used by the target data stream interface. For example, the target data stream interface is the interactive data transmission interface between the web page front-end and the back-end system. The web page front-end system can be developed based on the JavaScript protocol framework, while the back-end system can include a CMS (content management system) and an SQL (Structured Query Language) database. The back-end system is generally developed based on the JAVA language platform and SQL. These factors determine the application environment of the target data stream interface.

[0145] It should be noted that the target data stream is used for data interaction between the front-end system and the back-end service system.

[0146] In this embodiment, this step specifically includes:

[0147] Determine the corresponding compiler based on the application environment;

[0148] The compiler dynamically compiles the interface source file and loads environment units related to the application environment into the interface source file to determine the compilation result.

[0149] It should be noted that the interface method unit is the interface method class, which is used to implement the access request method or function required by the interface class instance object.

[0150] S307. Using the interface wrapper, determine the target data stream interface based on the compilation results.

[0151] In this step, an interface wrapper is used to decompile the compiled result file, so that the target data stream interface can be recognized by the front-end graphical system, or it can be encapsulated into a general language protocol structure, such as the Spring framework, so that the target data stream interface can be reused efficiently.

[0152] S308, Return the target data stream interface to the front-end system.

[0153] In this step, the backend service system returns the automatically generated target data stream interface to the frontend graphical management interface so that users can check whether there are any logical errors in the target business modules they have built.

[0154] This embodiment provides a method for dynamically orchestrating data flow interfaces. On the front end, in response to drag-and-drop commands, individual business atomic modules are copied from a graphical module library to a module assembly interface. Then, in response to logic assembly commands, these atomic modules are assembled into a target business module. The parsing request for the data flow interface is determined based on the target business module and preset interface parameters and sent to the back end. On the back end, the interface source file is determined based on the received parsing request and a preset dynamic template. The source file is then dynamically compiled according to the application environment of the interface. Finally, an interface encapsulator is used to encapsulate the compilation result, thus determining the target data flow interface. This method utilizes a graphical front-end system to construct the core logic of the interface and then uses a back-end service system to automatically and dynamically orchestrate the interface code encapsulation, thus solving the technical problem of low development efficiency caused by the reliance on direct code customization in existing technologies.

[0155] Figure 4 A flowchart illustrating another dynamic orchestration method for data flow interfaces provided in this application. (For example...) Figure 4 As shown, the specific steps of this dynamic orchestration method for data stream interfaces include:

[0156] S401: In response to the user's drag-and-drop command, copy each business atomic module from the graphical module library to the module assembly interface.

[0157] In this embodiment, the dynamic orchestration method of the data flow interface of this application embodiment is described using the target data flow interface for calculating safety stock as an example. The safety stock calculation process requires three atomic business modules: the prepared inventory atomic module, the available inventory atomic module, and the in-transit inventory atomic module. Users copy or drag and drop these three atomic business modules from the graphical module library onto the module assembly interface.

[0158] S402. In response to the user's logical assembly command, assemble the various business atomic modules into the target business module.

[0159] In this step, the user assembles the basic module and the three business sub-modules mentioned above on the module assembly interface according to the business logic of calculating safety stock, and obtains the target business module, namely the safety stock module, and forms a logical relationship in the graphical management system.

[0160] S403. Determine the mapping protocol string based on the target business module and the preset data protocol.

[0161] In this step, the mapping protocol string is used to represent each business atomic module and the business logic relationships between them.

[0162] In one possible implementation, a mapping relationship is established between each business atomic module and its corresponding business logic in the target business module according to a preset data protocol format to determine the mapping protocol string.

[0163] Specifically, in this embodiment, the preset data protocol is JSON (JavaScript Object Notation). This step specifically includes:

[0164] Pass the target business module to the backend service system;

[0165] The backend service system maps each business atomic module and its corresponding business logic to JSON text according to the JSON protocol.

[0166] Determine the mapping protocol string based on the JSON text.

[0167] For example, in the aforementioned safety stock module, the front-end system sends the safety stock module to the back-end service system, where the back-end service system's JSON generation tool maps it into JSON text according to the JSON protocol, and then arranges the corresponding JSON texts into a certain series to form a mapping protocol string.

[0168] S404. Determine the parsing request based on the mapping protocol string and preset interface parameters.

[0169] In this embodiment, the user is Figure 2 After entering the API interface basic information parameters of the target data flow interface corresponding to the safety stock module, i.e. the target business module, in the preset interface parameter input area 23 shown, and clicking the run button, the front-end system will generate a parsing request together with the mapping protocol string obtained in S403 and the API interface basic information parameters.

[0170] S405, Send a parsing request to the backend service system.

[0171] In this step, the front-end system sends the parsing request generated in the previous step to the back-end service system. It should be noted that the parsing request includes the platform environment, i.e., the application environment, required by the target data stream interface.

[0172] S406. Receive the parsing request sent by the front-end system, and determine the mapping protocol string and preset interface parameters according to the parsing request.

[0173] In this embodiment, the backend service system receives the parsing request and then reads the mapping protocol string and preset interface parameters, namely the PI interface basic information parameters, from the parsing request.

[0174] S407. Determine each interface unit based on the preset interface parameters and the preset data parsing mapping protocol string.

[0175] In this embodiment, the interface unit is an interface Java class. First, a parsing tool is used to parse the JSON text in the mapping protocol string according to the JSON protocol to determine the creation of a blank interface Java class file. Then, the interface Java class name is adjusted according to the API convention specification corresponding to the application environment to make it consistent with the class name in the preset interface parameters.

[0176] S408. Pre-read the preset dynamic template and add the interface method unit in the preset dynamic template to the interface unit to determine the interface source file.

[0177] In this step, the interface method unit includes: interface request method, access path specification, and method declaration. Multiple preset dynamic templates can be available, each corresponding to a different request method and / or access path specification.

[0178] Specifically, a preset dynamic template is pre-read to form a file stream. Then, the corresponding content in the file stream is replaced according to the preset interface parameters, i.e., the API interface basic information parameters. The corresponding interface method JAVA class, i.e., the interface method unit, from the preset dynamic template is added to the blank interface JAVA class file created in the previous step. This forms a complete JAVA class file, i.e., the interface source file.

[0179] S409. Use the compiler to dynamically compile the interface source file, and load environment units related to the application environment into the interface source file to determine the compilation result.

[0180] In this embodiment, this step specifically includes:

[0181] The corresponding compiler is determined based on the application environment indicated in the parsing request, and the file management instance is determined based on the compiler;

[0182] The environment unit is loaded into the file management instance, and the compilation task instance is built using the file management instance;

[0183] Compile the task instance to determine the compilation result.

[0184] It should be noted that in this embodiment, the compilation result is a file in class format in the JAVA framework, and the environment unit is the relevant class instance in the JAVA compilation environment.

[0185] In one possible design, prior to loading the environment unit into the file management instance, the following is also included:

[0186] Create an interface unit loader based on the context module of the current thread;

[0187] Construct a source file instance based on the compilation unit name of the original interface file;

[0188] Use the interface unit loader to add the source file instance to the file management instance;

[0189] Correspondingly, the environment unit is loaded into the file management instance, including:

[0190] Use the interface unit loader to load the environment unit into the file management instance.

[0191] For example, continuing the previous example, the calculation of safety stock needs to be based on the inventory in stock, available inventory, and inventory in transit, i.e., safety stock = inventory in stock - available inventory - inventory in transit. When generating safety stock service code, the atomic components of inventory in stock, available inventory, and inventory in transit, i.e., the atomic modules of inventory in stock, available inventory, and inventory in transit, need to be converted into their original Java code. Based on the logical relationship returned from the front end, i.e., the logical relationship of each business atomic module in the parsed request (inventory in stock - available inventory - inventory in transit), new code is formed, which is constructed into a new method (interface method unit) and its corresponding return value, forming the method content (the specific content of the interface method unit) in the original file (interface original file). The original file is then instantiated by inheriting SimpleJavaFileObject. By implementing DiagnosticListener to specify the compiler diagnostic collector (compiler), a standard file manager instance is constructed. Then, by inheriting ClassLoader to implement a custom class loader, the original file instance is injected into the custom class loader to complete dynamic compilation.

[0192] S410. Using the interface wrapper, determine the target data stream interface based on the compilation results.

[0193] In this embodiment, it specifically includes:

[0194] The request-processing mapper is determined based on the application context module of the interface wrapper. For example, the Spring architecture protocol is used as the specific implementation of the interface wrapper. The application context module is the Spring application context, and the request-processing mapper corresponds to RequestMappingHandlerMapping in the Spring framework.

[0195] The corresponding interface method units, i.e., interface method classes, are determined based on the compilation results.

[0196] Setting the private properties of the interface method unit to visible properties is a step to enable subsequent interface method classes to be called and set.

[0197] The request-processing mapper filters out the target method units annotated with the request mapper from each interface method unit. One implementation of the request mapper is RequestMapping in the Spring framework.

[0198] Using the dynamic proxy module, the target data stream interface is registered based on the compilation results and the target method unit.

[0199] For example, based on the ApplicationContext, all methods of RequestMappingHandlerMapping in the context environment are obtained, i.e., interface method classes, and the method properties are set to visible. The methods that can provide services to the outside world in the target file, i.e. the compiled result, i.e. the target method unit, are dynamically proxied and registered, so that the container environment, i.e. the application environment corresponding to the target data flow interface, can recognize the existence of the new service interface, i.e. the target data flow interface.

[0200] S411, Return the target data stream interface to the front-end system.

[0201] In this step, the backend service system returns the automatically generated target data stream interface to the frontend graphical management interface so that users can check whether there are any logical errors in the target business modules they have built.

[0202] This embodiment provides a method for dynamically orchestrating data flow interfaces. On the front end, in response to drag-and-drop commands, individual business atomic modules are copied from a graphical module library to a module assembly interface. Then, in response to logic assembly commands, these atomic modules are assembled into a target business module. The parsing request for the data flow interface is determined based on the target business module and preset interface parameters and sent to the back end. On the back end, the interface source file is determined based on the received parsing request and a preset dynamic template. The source file is then dynamically compiled according to the application environment of the interface. Finally, an interface encapsulator is used to encapsulate the compilation result, thus determining the target data flow interface. This method utilizes a graphical front-end system to construct the core logic of the interface and then uses a back-end service system to automatically and dynamically orchestrate the interface code encapsulation, thus solving the technical problem of low development efficiency caused by the reliance on direct code customization in existing technologies.

[0203] Figure 5This application provides a schematic diagram of a dynamic orchestration device for a data stream interface. The dynamic orchestration device 500 can be implemented through software, hardware, or a combination of both.

[0204] like Figure 5 As shown, the data stream interface dynamic orchestration device 500 includes:

[0205] The receiving module 501 is used to receive parsing requests sent by the front-end system;

[0206] Request processing module 502 is used to determine the interface source file based on the parsing request and the preset dynamic template;

[0207] The compilation module 503 is used to dynamically compile the interface source file according to the application environment indicated in the parsing request, so as to determine the compilation result. The application environment is the platform environment used by the target data stream interface, and the target data stream is used for data interaction between the front-end system and the back-end service system.

[0208] The encapsulation module 504 is used to determine the target data stream interface based on the compilation result using the interface encapsulator.

[0209] In one possible design, the request processing module 502 is used to determine the interface source file based on the parsed request and a preset dynamic template, including:

[0210] Request processing module 502 is used to determine the mapping protocol string and preset interface parameters based on the parsing request;

[0211] The request processing module 502 is also used to parse the mapping protocol string according to the preset interface parameters and the preset data protocol to determine each interface unit;

[0212] The request processing module 502 is also used to pre-read the preset dynamic template and add the interface method unit in the preset dynamic template to the interface unit to determine the interface source file. The method unit includes: interface request method, access path specification and method declaration.

[0213] In one possible design, the compilation module 503 is used to dynamically compile the interface source file according to the application environment indicated in the parsing request, in order to determine the compilation result, including:

[0214] Compiler module 503 is used to determine the appropriate compiler based on the application environment;

[0215] Compiler module 503 is also used to dynamically compile interface source files using a compiler, and load environment units related to the application environment into the interface source files to determine the compilation result.

[0216] In one possible design, the compilation module 503 is further configured to dynamically compile the interface source file using a compiler, and simultaneously load application-environment-related environment units into the interface source file to determine the compilation result, including:

[0217] Compiler module 503 is also used to determine the file management instance based on the compiler;

[0218] The compiler module 503 is also used to load environment units into a file management instance and construct a compilation task instance through the file management instance; and to perform compilation on the task instance to determine the compilation result.

[0219] In one possible design, the compilation module 503 is further configured to include, before loading the environment unit into the file management instance:

[0220] Compiler module 503 is also used to create an interface unit loader based on the context module of the current thread; construct a source file instance based on the compilation unit name of the interface source file; and add the source file instance to the file management instance using the interface unit loader.

[0221] Correspondingly, compiler module 503 is also used to load the environment unit into the file management instance, including:

[0222] Compiler module 503 is also used to load environment units into file management instances using the interface unit loader.

[0223] In one possible design, the encapsulation module 504 is used to determine the target data stream interface based on the compilation results using an interface encapsulator, including:

[0224] Encapsulation module 504 is used to determine the request-processing mapper based on the application context module of the interface encapsulator;

[0225] The encapsulation module 504 is also used to determine the corresponding interface method units based on the compilation results;

[0226] The encapsulation module 504 is also used to filter out the target method unit annotated with the request mapper from each interface method unit according to the request-processing mapper;

[0227] Encapsulation module 504 is also used to register the target data stream interface based on the compilation results and the target method unit using the dynamic proxy module.

[0228] Optionally, the encapsulation module 504, after determining the corresponding interface method units based on the compilation results, further includes:

[0229] Encapsulation module 504 is also used to set the private properties of the interface method unit to visible properties.

[0230] In one possible design, the data stream interface dynamic orchestration device further includes:

[0231] The sending module is used to return the target data stream interface to the front-end system.

[0232] It is worth noting that, Figure 5 The data stream interface dynamic orchestration device provided in the illustrated embodiment can execute the methods corresponding to the backend service system provided in any of the above method embodiments. Its specific implementation principle, technical features, explanation of professional terms and technical effects are similar, and will not be repeated here.

[0233] Figure 6 This is a schematic diagram of a dynamic orchestration device for a data stream interface provided in this application. The dynamic orchestration device 600 for the data stream interface can be implemented through software, hardware, or a combination of both.

[0234] like Figure 6 As shown, the data stream interface dynamic orchestration device 600 includes:

[0235] Module 601 is used to obtain the user's drag-and-drop commands;

[0236] The graphics library module 602 is used to copy each business atom module to the module assembly interface in response to drag and drop commands. The business atom module is a graphical module that organizes business logic according to a preset format.

[0237] The acquisition module 601 is also used to acquire the user's logical assembly instructions;

[0238] Assembly module 603 is used to assemble various business atomic modules into a target business module in response to a logical assembly instruction;

[0239] Processing module 604 is used to determine the parsing request of the data flow interface based on the target business module and preset interface parameters;

[0240] The processing module 604 is also used to send a parsing request to the backend service system so that the backend service system can perform dynamic parsing based on the parsing request and determine the target data stream interface.

[0241] In one possible design, the processing module 604 is used to determine the parsing request of the data stream interface based on the target business module and preset interface parameters, including:

[0242] Processing module 604 is used to determine a mapping protocol string based on the target business module and a preset data protocol. The mapping protocol string is used to represent each of the business atomic modules and the business logic relationship between each of the business atomic modules.

[0243] The processing module 604 is also used to determine the parsing request based on the mapping protocol string and preset interface parameters.

[0244] In one possible design, the processing module 604 is used to determine a mapping protocol string based on the target business module and a preset data protocol, including:

[0245] Processing module 604 is used to establish a mapping relationship between each business atomic module and its corresponding business logic in the target business module according to the format of a preset data protocol, so as to determine the mapping protocol string.

[0246] Optionally, the preset data protocol is the JSON protocol, and the processing module 604 is used to establish a mapping relationship between each business atomic module and its corresponding business logic in the target business module according to the format of the preset data protocol, so as to determine the mapping protocol string, including:

[0247] Processing module 604 is used to pass the target business module to the backend service system; the backend service system maps each business atomic module and its corresponding business logic to JSON text according to the JSON protocol; and determines the mapping protocol string based on the JSON text.

[0248] It is worth noting that, Figure 6 The data stream interface dynamic orchestration device provided in the illustrated embodiment can execute the methods corresponding to the front-end system provided in any of the above method embodiments. Its specific implementation principles, technical features, explanations of technical terms, and technical effects are similar and will not be repeated here.

[0249] Figure 7 This is a schematic diagram of the structure of an electronic device provided in this application. Figure 7 As shown, the electronic device 700 is used in a back-end service system and may include at least one processor 701 and a memory 702. Figure 7 The example shown is an electronic device using a processor.

[0250] The memory 702 is used to store programs. Specifically, the program may include program code, which includes computer operation instructions.

[0251] The memory 702 may include high-speed RAM memory, and may also include non-volatile memory, such as at least one disk storage device.

[0252] The processor 701 is used to execute computer execution instructions stored in the memory 702 to implement the methods described in the above embodiments.

[0253] The processor 701 may be a central processing unit (CPU), an application-specific integrated circuit (ASIC), or one or more integrated circuits configured to implement the embodiments of this application.

[0254] Optionally, the memory 702 can be either standalone or integrated with the processor 701. When the memory 702 is a device independent of the processor 701, the electronic device 700 may further include:

[0255] Bus 703 is used to connect the processor 701 and the memory 702. The bus can be an industry standard architecture (ISA) bus, a peripheral component (PCI) bus, or an extended industry standard architecture (EISA) bus, etc. Buses can be categorized as address buses, data buses, control buses, etc., but this does not mean there is only one bus or one type of bus.

[0256] Optionally, in a specific implementation, if the memory 702 and the processor 701 are integrated on a single chip, the memory 702 and the processor 701 can communicate through an internal interface.

[0257] Figure 8 This is a schematic diagram of the structure of an electronic device provided in this application. Figure 8 As shown, the electronic device 800 is applied to a front-end system and may include at least one processor 801 and a memory 802. Figure 8 The example shown is an electronic device using a processor.

[0258] The memory 802 is used to store programs. Specifically, the program may include program code, which includes computer operation instructions.

[0259] The memory 802 may include high-speed RAM memory, and may also include non-volatile memory, such as at least one disk storage device.

[0260] The processor 801 is used to execute computer execution instructions stored in the memory 802 to implement the methods described in the above embodiments.

[0261] The processor 801 may be a central processing unit (CPU), an application-specific integrated circuit (ASIC), or one or more integrated circuits configured to implement the embodiments of this application.

[0262] Optionally, the memory 802 can be either standalone or integrated with the processor 801. When the memory 802 is a device independent of the processor 801, the electronic device 800 may further include:

[0263] Bus 803 is used to connect the processor 801 and the memory 802. The bus can be an industry standard architecture (ISA) bus, a peripheral component (PCI) bus, or an extended industry standard architecture (EISA) bus, etc. Buses can be categorized as address buses, data buses, control buses, etc., but this does not mean there is only one bus or one type of bus.

[0264] Optionally, in a specific implementation, if the memory 802 and the processor 801 are integrated on a single chip, the memory 802 and the processor 801 can communicate through an internal interface.

[0265] This application also provides a computer-readable storage medium, which may include various media capable of storing program code, such as a USB flash drive, a portable hard drive, a read-only memory (ROM), a random access memory (RAM), a disk, or an optical disk. Specifically, the computer-readable storage medium stores program instructions, which are used in the methods corresponding to the backend service system in the above method embodiments.

[0266] This application also provides a computer-readable storage medium, which may include various media capable of storing program code, such as a USB flash drive, a portable hard drive, a read-only memory (ROM), a random access memory (RAM), a disk, or an optical disk. Specifically, the computer-readable storage medium stores program instructions, which are used in the methods corresponding to the front-end system in the above method embodiments.

[0267] This application also provides a computer program product, including a computer program that, when executed by a processor, implements the methods corresponding to the backend service system in the above method embodiments.

[0268] This application also provides a computer program product, including a computer program that, when executed by a processor, implements the methods corresponding to the front-end system in the above-described method embodiments.

[0269] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of this application, and are not intended to limit them. Although this application has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some or all of the technical features therein. Such modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the scope of the technical solutions of the embodiments of this application.

Claims

1. A data flow interface dynamic orchestration method, characterized in that, The application is applied to a backend service system, and comprises: receiving an analysis request sent by a front-end system; wherein, the analysis request is that the front-end system, in response to a user's drag instruction, copies each business atomic module from a graphical module library to a module assembly interface, the business atomic module being a graphical module formed by organizing business logic according to a preset format; in response to a user's logic assembly instruction, each business atomic module is assembled into a target business module; and a data flow interface is determined according to the target business module and a preset interface parameter; determining an interface original file according to the analysis request and a preset dynamic template; performing dynamic compilation on the interface original file according to an application environment indicated in the analysis request to determine a compilation result, the application environment being a platform environment used by a target data flow interface, and the target data flow being used for data interaction between the front-end system and the backend service system; determining the target data flow interface according to the compilation result by using an interface encapsulator; the method of determining the interface original file according to the analysis request and the preset dynamic template comprises: determining a mapping protocol string and a preset interface parameter according to the analysis request; wherein, the preset interface parameter comprises: a name, a type, an application environment, a calling method and a path, an input parameter, an output parameter, and a declaration; parsing the mapping protocol string according to the preset interface parameter and a preset data protocol to determine each interface unit; pre-reading a preset dynamic template, and adding an interface method unit in the preset dynamic template to the interface unit to determine the interface original file, the method unit comprising: an interface request mode, an access path specification, and a method declaration.

2. The data flow interface dynamic orchestration method of claim 1, wherein, the method of performing dynamic compilation on the interface original file according to an application environment indicated in the analysis request to determine a compilation result comprises: determining a corresponding compiler according to the application environment; dynamically compiling the interface original file by using the compiler, and loading an environment unit related to the application environment to the interface original file to determine the compilation result.

3. The data flow interface dynamic orchestration method of claim 2, wherein, the method of dynamically compiling the interface original file by using the compiler, and loading an environment unit related to the application environment to the interface original file to determine the compilation result comprises: determining a file management instance according to the compiler; loading the environment unit into the file management instance, and constructing a compilation task instance through the file management instance; performing compilation on the task instance to determine the compilation result.

4. The data flow interface dynamic orchestration method of claim 3, wherein, before the environment unit is loaded into the file management instance, the method further comprises: creating an interface unit loader according to a context module of a current thread; constructing a source file instance according to a compilation unit name of the interface original file; adding the source file instance to the file management instance by using the interface unit loader; correspondingly, the method of loading the environment unit into the file management instance comprises: loading the environment unit into the file management instance by using the interface unit loader.

5. The method of claim 1, wherein, the method of determining the target data flow interface according to the compilation result by using the interface encapsulator comprises: determining a request-processing mapper according to an application context module of the interface wrapper; determining corresponding individual interface method units according to the compilation result; screening a target method unit annotated as a request mapper from the individual interface method units according to the request-processing mapper; registering the target data stream interface according to the compilation result and the target method unit by using a dynamic proxy module.

6. The data flow interface dynamic orchestration method of claim 5, wherein, After the step of determining corresponding individual interface method units according to the compilation result, the method further comprises: setting a private attribute of the interface method unit as a visible attribute.

7. The data flow interface dynamic orchestration method of claim 1, wherein, The method further comprises: returning the target data stream interface to the front-end system.

8. A data flow interface dynamic orchestration method, characterized in that, The method applied to a front-end system comprises: copying individual business atomic modules to a module assembly interface from a graphical module library in response to a user's drag instruction, the business atomic modules being graphical modules in which business logic is organized in a preset format; assembling the individual business atomic modules into a target business module in response to a user's logic assembly instruction; determining an analysis request of a data stream interface according to the target business module and preset interface parameters; sending the analysis request to a back-end service system, so that the back-end service system determines a mapping protocol string and preset interface parameters according to the analysis request; wherein the preset interface parameters include name, type, application environment, calling method and path, input parameter, output parameter, and declaration; the mapping protocol string is analyzed according to the preset interface parameters and a preset data protocol, so as to determine individual interface units; a preset dynamic template is pre-read, and interface method units in the preset dynamic template are added to the interface units, so as to determine an interface original file, the method units including interface request mode, access path specification, and method declaration; the interface original file is dynamically compiled according to an application environment indicated in the analysis request, so as to determine a compilation result, the application environment being a platform environment used by a target data stream interface, the target data stream being used for data interaction between the front-end system and the back-end service system; and an interface wrapper is used to determine the target data stream interface according to the compilation result.

9. The data flow interface dynamic orchestration method of claim 8, wherein, The step of determining an analysis request of a data stream interface according to the target business module and preset interface parameters comprises: determining a mapping protocol string according to the target business module and a preset data protocol, the mapping protocol string being used to represent individual business atomic modules and business logic relationships between the individual business atomic modules; determining the analysis request according to the mapping protocol string and preset interface parameters.

10. The data flow interface dynamic orchestration method of claim 9, wherein, The step of determining a mapping protocol string according to the target business module and a preset data protocol comprises: establishing a mapping relationship of individual business atomic modules in the target business module and corresponding business logic according to a format of the preset data protocol, so as to determine the mapping protocol string.

11. The data flow interface dynamic orchestration method of claim 10, wherein, The preset data protocol is a JSON protocol, and the step of establishing a mapping relationship of individual business atomic modules in the target business module and corresponding business logic according to a format of the preset data protocol, so as to determine the mapping protocol string, comprises: passing the target service module to a backend service system; the backend service system mapping each of the service atomic modules and corresponding service logic into a JSON text according to a JSON protocol; determining the mapping protocol string according to the JSON text.

12. A data flow interface dynamic orchestration apparatus, comprising: comprising: a receiving module configured to receive an analysis request sent by a front-end system; wherein the analysis request is a response of the front-end system to a user's drag instruction, and each service atomic module is copied from a graphical module library to a module assembly interface, the service atomic module being a graphical module formed by organizing service logic according to a preset format; each of the service atomic modules is assembled into a target service module in response to a user's logic assembly instruction; and a data stream interface is determined according to the target service module and a preset interface parameter; a request processing module configured to determine an interface original file according to the analysis request and a preset dynamic template; a compiling module configured to dynamically compile the interface original file according to an application environment indicated in the analysis request, so as to determine a compiling result, the application environment being a platform environment used by a target data stream interface, and the target data stream being used for data interaction between the front-end system and the backend service system; an encapsulating module configured to determine the target data stream interface according to the compiling result by using an interface encapsulator; the request processing module is specifically configured to determine a mapping protocol string and a preset interface parameter according to the analysis request; wherein the preset interface parameter comprises a name, a type, an application environment, a calling method and a path, an input parameter, an output parameter, and a declaration; the mapping protocol string is analyzed according to the preset interface parameter and a preset data protocol, so as to determine each interface unit; a preset dynamic template is pre-read, and an interface method unit in the preset dynamic template is added to the interface unit, so as to determine the interface original file, the method unit comprising an interface request mode, an access path specification, and a method declaration.

13. A data flow interface dynamic orchestration apparatus, comprising: comprising: an obtaining module configured to obtain a user's drag instruction; a graphical library module configured to copy each service atomic module to a module assembly interface in response to the drag instruction, the service atomic module being a graphical module formed by organizing service logic according to a preset format; the obtaining module is further configured to obtain a user's logic assembly instruction; an assembling module configured to assemble each of the service atomic modules into a target service module in response to the logic assembly instruction; a processing module configured to determine an analysis request of a data stream interface according to the target service module and a preset API interface parameter; sending the resolution request to a backend service system, so that the backend service system determines a mapping protocol string and preset interface parameters according to the resolution request; wherein the preset interface parameters include name, type, application environment, calling method and path, input parameter, output parameter, and declaration; resolving the mapping protocol string according to the preset interface parameters and a preset data protocol to determine each interface unit; pre-reading a preset dynamic template and adding an interface method unit in the preset dynamic template to the interface unit to determine an interface original file, the method unit including interface request mode, access path specification, and method declaration; dynamically compiling the interface original file according to an application environment indicated in the resolution request to determine a compilation result, the application environment being a platform environment used by a target data stream interface, the target data stream being used for data interaction between a front-end system and the backend service system; and determining the target data stream interface according to the compilation result by using an interface encapsulator.

14. An electronic device, comprising: comprising: a processor; and a memory for storing a computer program of the processor; wherein the processor is configured to execute the data stream interface dynamic arrangement method of any one of claims 1 to 7 via execution of the computer program.

15. An electronic device, comprising: comprising: a processor; and a memory for storing a computer program of the processor; wherein the processor is configured to execute the data stream interface dynamic arrangement method of any one of claims 8 to 11 via execution of the computer program.

16. A computer readable storage medium having stored thereon a computer program, characterized in that, The computer program is executed by the processor to implement the data stream interface dynamic arrangement method of any one of claims 1 to 7.

17. A computer readable storage medium having stored thereon a computer program, characterized in that, The computer program is executed by the processor to implement the data stream interface dynamic arrangement method of any one of claims 8 to 11.

18. A computer program product comprising a computer program, characterized in that, The computer program is executed by the processor to implement the method of any one of claims 1 to 7.

19. A computer program product comprising a computer program, characterized in that, The computer program is executed by the processor to implement the method of any one of claims 8 to 11.

Images