CN113268420A

CN113268420A - Development method, device and system of data interface and computer storage medium

Info

Publication number: CN113268420A
Application number: CN202110558223.XA
Authority: CN
Inventors: 方朋; 马越
Original assignee: Beijing Dami Technology Co Ltd
Current assignee: Beijing Dami Technology Co Ltd
Priority date: 2021-05-21
Filing date: 2021-05-21
Publication date: 2021-08-17

Abstract

The application discloses a development method, a device and a system of a data interface and a computer storage medium, wherein the method comprises the steps that a client terminal sends definition data and an editing code corresponding to a target data interface to a first server, the first server carries out script compiling according to the definition data and the editing code, and interface logic is generated based on the script compiling; receiving preset access parameter data by the first server, and obtaining access parameter data corresponding to the preset access parameter data based on interface logic; the client terminal can verify whether the interface logic is correct according to the output parameter, and carry out issuing operation under the condition that the interface logic is correct to generate the interface address of the target data interface. The method and the system have the advantages that the developer can input the definition data and the editing codes corresponding to the target data interface at the client terminal, so that the first server can conveniently complete the development of the target data interface under the development environment configured by the second server, the flexible development of the developer on the data interface is realized, and the development efficiency is further improved.

Description

Development method, device and system of data interface and computer storage medium

Technical Field

The present application relates to the field of application development technologies, and in particular, to a method, an apparatus, a system, and a computer storage medium for developing a data interface.

Background

The JAVA conventional interface development comprises the steps of interface definition, interface development, interface debugging, interface release and the like, and if the interface test is successful in the interface debugging process, the developed interface can be released on line; if the interface test fails, returning to the interface development step to edit the interface codes again.

For conventional interface development, the whole development step needs to be executed in a specified development scene strictly according to an operation flow, which is inconvenient for developers to operate flexibly, and further influences development experience.

Disclosure of Invention

The embodiment of the application provides a method, a device and a system for developing a data interface and a computer storage medium, which can enable developers to complete the development of the data interface on a client terminal page, and have flexible and efficient operation.

In a first aspect, an embodiment of the present application provides a method for developing a data interface, where the method is applied to a first server, and includes:

receiving definition data and an editing code which are sent by a client terminal and correspond to a target data interface;

compiling scripts according to definition data corresponding to the target data interface and editing codes corresponding to the target data interface in a development environment configured by the second server, and generating interface logic based on the compiling scripts; the development environment is determined by the second server according to definition data which is sent by the client terminal and corresponds to the target data interface;

receiving preset parameter input data sent by a client terminal, and obtaining parameter output data corresponding to the preset parameter input data based on interface logic;

returning the parameter data to the client terminal so that the client terminal can verify whether the interface logic is correct or not according to the parameter data;

and carrying out issuing operation under the condition that the interface logic is correct, and generating an interface address of the target data interface.

In an alternative of the first aspect, the issuing operation is performed with the interface logic correct, and includes:

under the condition that the interface logic is correct, carrying out smoking test on the interface logic;

and issuing operation is carried out under the condition that the smoking test result is successful.

In yet another alternative of the first aspect, after returning the outbound parameter data to the client terminal so that the client terminal verifies whether the interface logic is correct according to the outbound parameter data, the method further includes:

and under the condition that the interface logic is verified to be incorrect by the client terminal, receiving the modified editing code corresponding to the target data interface sent by the client terminal, and compiling the script according to the definition data corresponding to the target data interface and the modified editing code corresponding to the target data interface.

In yet another alternative of the first aspect, after performing the issuing operation when the interface logic is correct and generating the interface address of the target data interface, the method further includes:

and sending the interface address of the target data interface to the client terminal, and sending prompt information for representing the target data interface to be released to the client terminal so that the client terminal completes the on-line release of the target data interface.

determining an interface address corresponding to a previous version of the target data interface according to the version information of the target data interface;

and sending an interface address corresponding to the last version of the target data interface to the client terminal so that the client terminal acquires the modified definition data corresponding to the last version of the target data interface and the editing code.

In a second aspect, an embodiment of the present application further provides a method for developing a data interface, where the method is applied to a client terminal, and includes:

acquiring definition data corresponding to the target data interface, and sending the definition data corresponding to the target data interface to a second server so that the second server configures a development environment according to the definition data corresponding to the target data interface;

acquiring an editing code corresponding to the target data interface, and sending definition data corresponding to the target data interface and the editing code corresponding to the target data interface to the first server, so that the first server performs script compiling according to the definition data corresponding to the target data interface and the editing code corresponding to the target data interface under a development environment configured by the second server, and generates an interface logic based on the script compiling;

acquiring preset input parameter data, and sending the preset input parameter data to a first server so that the first server obtains output parameter data corresponding to the preset input parameter data based on interface logic;

and receiving the output parameter data sent by the first server, and verifying whether the interface logic is correct or not based on the output parameter data, so that the first server performs issuing operation under the condition that the interface logic is correct, and generates an interface address of a target data interface.

In an alternative of the second aspect, after receiving the outbound parameter data sent by the first server and verifying whether the interface logic is correct based on the outbound parameter data, the method further includes:

under the condition that the interface logic is determined to be incorrect, acquiring a modified editing code corresponding to the target data interface;

and sending the modified editing code corresponding to the target data interface to the first server so that the first server carries out script compiling according to the definition data corresponding to the target data interface and the modified editing code corresponding to the target data interface.

In yet another alternative of the second aspect, before acquiring the definition data corresponding to the target data interface, the method further includes:

and acquiring the identity information of the login user, and sending the identity information of the login user to the second server so that the second server verifies the identity information of the login user.

In a third aspect, an embodiment of the present application further provides a method for developing a data interface, where the method is applied to a second server, and includes:

receiving definition data which is sent by a client terminal and corresponds to a target data interface;

configuring a development environment according to definition data corresponding to a target data interface, so that a first server carries out script compiling according to the definition data corresponding to the target data interface and an editing code corresponding to the target data interface under the development environment, generates interface logic based on the script compiling, and carries out issuing operation under the condition that the interface logic is correct to generate an interface address of the target data interface; wherein the editing code is sent to the first server by the client terminal.

In an alternative of the third aspect, before receiving the definition data corresponding to the target data interface sent by the client terminal, the method further includes:

receiving identity information of a login user sent by a client terminal, and determining a verification result of the identity information of the login user;

and sending the verification result to the client terminal.

In a fourth aspect, an embodiment of the present application provides a first server, including:

the first receiving module is used for receiving definition data and editing codes which are sent by a client terminal and correspond to the target data interface;

the first processing module is used for compiling scripts according to definition data corresponding to the target data interface and editing codes corresponding to the target data interface under the development environment configured by the second server and generating interface logic based on the script compiling; the development environment is determined by the second server according to definition data which is sent by the client terminal and corresponds to the target data interface;

the second processing module is used for receiving preset parameter input data sent by the client terminal and obtaining parameter output data corresponding to the preset parameter input data based on interface logic;

the first sending module is used for returning the parameter data to the client terminal so that the client terminal can verify whether the interface logic is correct or not according to the parameter data;

and the third processing module is used for performing issuing operation under the condition that the interface logic is correct and generating an interface address of the target data interface.

In an alternative of the fourth aspect, the third processing module comprises:

the first processing unit is used for carrying out smoking test on the interface logic under the condition that the interface logic is correct;

and the second processing unit is used for issuing operation under the condition that the smoking test result is successful.

In yet another alternative of the fourth aspect, the first server further comprises:

and the sixth processing module is used for returning the output parameter data to the client terminal at the first sending module so that the client terminal receives the modified editing code corresponding to the target data interface sent by the client terminal under the condition that the client terminal verifies whether the interface logic is correct or not according to the output parameter data, and compiling the script according to the definition data corresponding to the target data interface and the modified editing code corresponding to the target data interface.

and the fourth sending module is used for sending the interface address of the target data interface to the client terminal after the third processing module carries out publishing operation under the condition that the interface logic is correct and generates the interface address of the target data interface, and sending prompt information for representing the target data interface to be published to the client terminal so that the client terminal completes online publishing of the target data interface.

the seventh processing module is used for determining an interface address corresponding to a previous version of the target data interface according to the version information of the target data interface after the third processing module performs the publishing operation under the condition that the interface logic is correct and generates the interface address of the target data interface;

and the fifth sending module is used for sending the interface address corresponding to the last version of the target data interface to the client terminal so that the client terminal can obtain the modified definition data and the modified editing code corresponding to the last version of the target data interface.

In a fifth aspect, an embodiment of the present application provides a client terminal, including:

the first acquisition module is used for acquiring definition data corresponding to the target data interface and sending the definition data corresponding to the target data interface to the second server so that the second server configures a development environment according to the definition data corresponding to the target data interface;

the second sending module is used for acquiring the editing code corresponding to the target data interface, sending the definition data corresponding to the target data interface and the editing code corresponding to the target data interface to the first server, so that the first server carries out script compiling according to the definition data corresponding to the target data interface and the editing code corresponding to the target data interface under the development environment configured by the second server, and generates interface logic based on the script compiling;

the third sending module is used for acquiring preset entry parameter data and sending the preset entry parameter data to the first server so that the first server can obtain exit parameter data corresponding to the preset entry parameter data based on the interface logic;

and the fourth processing module is used for receiving the output parameter data sent by the first server, verifying whether the interface logic is correct based on the output parameter data, so that the first server performs issuing operation under the condition that the interface logic is correct, and generating an interface address of the target data interface.

In an alternative of the fifth aspect, the client terminal further comprises:

the second acquisition module is used for receiving the parameter data sent by the first server through the fourth processing module, verifying whether the interface logic is correct based on the parameter data, and acquiring the modified editing code corresponding to the target data interface under the condition that the interface logic is determined to be incorrect;

and the sixth sending module is used for sending the modified editing code corresponding to the target data interface to the first server so that the first server carries out script compiling according to the definition data corresponding to the target data interface and the modified editing code corresponding to the target data interface.

In yet another alternative of the fifth aspect, the client terminal further comprises:

and the third acquisition module is used for acquiring the identity information of the login user before the first acquisition module acquires the definition data corresponding to the target data interface and sends the definition data corresponding to the target data interface to the second server, and sending the identity information of the login user to the second server so that the second server can verify the identity information of the login user.

In a sixth aspect, an embodiment of the present application provides a second server, including:

the second receiving module is used for receiving definition data which is sent by the client terminal and corresponds to the target data interface;

and the fifth processing module is used for configuring a development environment according to the definition data corresponding to the target data interface, so that the first server performs script compiling according to the definition data corresponding to the target data interface and the editing code corresponding to the target data interface under the development environment, generates interface logic based on the script compiling, and performs issuing operation under the condition that the interface logic is correct to generate an interface address of the target data interface.

In an alternative of the sixth aspect, the second server further comprises:

the eighth processing module is used for receiving the identity information of the login user sent by the client terminal and determining the verification result of the identity information of the login user before the second receiving module receives the definition data corresponding to the target data interface sent by the client terminal;

and the sixth sending module is used for sending the verification result to the client terminal.

In a seventh aspect, an embodiment of the present application further provides a first server, including a processor and a memory;

the processor is connected with the memory;

a memory for storing executable program code;

the processor reads the executable program code stored in the memory to run a program corresponding to the executable program code, so as to execute the method for developing the data interface provided by the first aspect of the embodiments of the present application or any implementation manner of the first aspect.

In an eighth aspect, an embodiment of the present application further provides a client terminal, including a processor and a memory;

the processor is connected with the memory;

a memory for storing executable program code;

the processor executes a program corresponding to the executable program code by reading the executable program code stored in the memory, so as to execute the method for developing the data interface provided by the second aspect of the embodiments of the present application or any implementation manner of the second aspect.

In a ninth aspect, an embodiment of the present application further provides a second server, including a processor and a memory;

the processor is connected with the memory;

a memory for storing executable program code;

the processor reads the executable program code stored in the memory to run a program corresponding to the executable program code, so as to execute the development method of the data interface provided by the third aspect or any implementation manner of the third aspect of the embodiment of the present application.

In a tenth aspect, an embodiment of the present application provides a development system of a data interface, including the first server as mentioned in the seventh aspect, the client terminal as mentioned in the eighth aspect, and the second server as mentioned in the ninth aspect.

In an eleventh aspect, an embodiment of the present application provides a computer storage medium, where a computer program is stored in the computer storage medium, where the computer program includes program instructions, and when the program instructions are executed by a processor, the method for developing a data interface provided in the first aspect of the present application or any implementation manner of the first aspect may be implemented.

In a twelfth aspect, an embodiment of the present application further provides a computer storage medium, where a computer program is stored in the computer storage medium, where the computer program includes program instructions, and when the program instructions are executed by a processor, the method for developing a data interface provided in any one of the second aspect and the second implementation manner of the embodiment of the present application can be implemented.

In a thirteenth aspect, an embodiment of the present application further provides a computer storage medium, where a computer program is stored in the computer storage medium, where the computer program includes program instructions, and when the program instructions are executed by a processor, the method for developing a data interface provided in any one of the third aspect and the implementation manner of the third aspect of the embodiment of the present application can be implemented.

In the embodiment of the application, the client terminal can send definition data and an editing code corresponding to the target data interface to the first server, and the first server performs script compiling according to the definition data and the editing code corresponding to the target data interface under the development environment configured by the second server, and generates interface logic based on the script compiling; receiving preset access parameter data sent by a client terminal by a first server, and obtaining access parameter data corresponding to the preset access parameter data based on interface logic; the client terminal can verify whether the interface logic is correct according to the output parameter, and the first server performs issuing operation under the condition that the interface logic is correct to generate the interface address of the target data interface. The method and the system have the advantages that the developer can input the definition data and the editing codes corresponding to the target data interface at the client terminal, so that the first server can conveniently complete the development of the target data interface under the development environment configured by the second server, the flexible development of the developer on the data interface is realized, and the development efficiency is further improved.

Drawings

In order to more clearly illustrate the technical solutions in the embodiments of the present application, the drawings needed to be used in the embodiments will be briefly described below, and it is obvious that the drawings in the following description are only some embodiments of the present application, and it is obvious for those skilled in the art to obtain other drawings without creative efforts.

Fig. 1 is a schematic diagram of a development system architecture of a data interface according to an embodiment of the present disclosure;

fig. 2 is a schematic flowchart of a development system of a data interface according to an embodiment of the present disclosure;

fig. 3 is a schematic view of an interactive display interface of a client terminal according to an embodiment of the present disclosure;

fig. 4 is a schematic flowchart of a method for developing a data interface according to an embodiment of the present disclosure;

fig. 5 is a schematic flowchart of a method for developing a data interface according to an embodiment of the present application;

fig. 6 is a schematic flowchart of a method for developing a data interface according to an embodiment of the present application;

fig. 7 is a schematic overall flowchart of development of a data interface according to an embodiment of the present application;

fig. 8 is a schematic structural diagram of a first server according to an embodiment of the present disclosure;

fig. 9 is a schematic structural diagram of a client terminal according to an embodiment of the present application;

fig. 10 is a schematic structural diagram of a second server according to an embodiment of the present application;

fig. 11 is a schematic structural diagram of another first server according to an embodiment of the present application;

fig. 12 is a schematic structural diagram of another client terminal according to an embodiment of the present application;

fig. 13 is a schematic structural diagram of another second server according to an embodiment of the present application.

Detailed Description

The technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the drawings in the embodiments of the present application.

The terms "first," "second," "third," and the like in the description and claims of this application and in the above-described drawings are used for distinguishing between different objects and not for describing a particular order. Furthermore, the terms "include" and "have," as well as any variations thereof, are intended to cover non-exclusive inclusions. For example, a process, method, system, article, or apparatus that comprises a list of steps or elements is not limited to only those steps or elements listed, but may alternatively include other steps or elements not listed, or inherent to such process, method, article, or apparatus.

Referring to fig. 1, fig. 1 is a schematic diagram illustrating a development system architecture of a data interface according to an embodiment of the present disclosure.

As shown in fig. 1, the development system of the data interface may include a first server 101, a client terminal 102, and a second server 103, wherein:

the first server 101 may be configured to obtain definition information of a data interface and code information edited by a developer, which are sent by the client terminal 102 via a transmission protocol, and perform script compiling according to the definition information and the code information to obtain a corresponding interface logic. Before the script compiling, the first server 101 may obtain a development environment configured by the second server 103 for the definition information of the data interface, and complete the script compiling in the development environment. Further, the first server 101 may determine whether the interface logic is correct through the client terminal 102 after obtaining the interface logic. Specifically, the first server 101 may bring the generated interface logic into the generated interface logic according to the preset input data sent by the client terminal 102 to obtain the output data, and return the output data to the client terminal 102, so that the client terminal 102 determines whether the interface logic is correct according to the output data and the preset output data.

Under the condition that the interface logic fed back by the client terminal 102 to the first server 101 is correct, the first server 101 can perform interface issuing operation and generate an interface address corresponding to the data interface, thereby completing the development of the data interface. The first server 101 is configured with a test environment for testing interface logic and a publishing environment for executing interface publishing operation, where the test environment and the publishing environment may be the test environment and the publishing environment configured for interface development in the prior art, and are not described in detail in this embodiment of the present application.

It should be noted that, in the prior art, conventional interface development based on Java is usually based on a SpringBoot framework, and specifically, after a service requirement of a data interface is clarified, definition information and code information of the data interface can be acquired in a Java development environment, and a generated interface logic is packed to a test environment to complete an interface test, and if the interface test is successful, the interface logic is packed to an on-line release environment to complete the release of the interface. The interface logic generated by the Java development environment needs to be packaged to different environments for operation according to different requirements, if the interface logic has errors, definition information and code information of a data interface need to be acquired again in the Java development environment, so that the development cycle of the whole data interface is too long, and the development process needs to be strictly based on a well-agreed framework protocol and a well-agreed layered structure, for example, a SpringBoot related syntax, a Mapper layer, a Service layer, a DTO layer and the like, so that the flexibility of data interface development is greatly reduced.

The client terminal 102 may be configured to present a human-computer interaction interface between the development system of the data interface and the developer, acquire data information corresponding to the data interface and input by the developer, and display an operation result of the first server 101 to the developer, so that the developer can know a development progress and a development effect of the data interface in real time. Specifically, the client terminal 102 may obtain, on the interactive interface, definition information and edited code information that are input by a developer according to a service requirement of the data interface, send the definition information to the second server 103 via a transmission protocol by selecting a confirmation control or another control for representing completion of data input, and send the definition information and the edited code information to the first server 101 via the transmission protocol.

Further, after the client terminal 102 confirms that the first server 101 generates the corresponding interface logic, the preset input data for verifying the interface logic may be continuously sent to the first server 101, and whether the interface logic is correct is determined by receiving the output data obtained by the first server 101 through the interface logic. Specifically, after the first server 101 produces the interface logic, prompt information for verifying the interface logic may be sent to the client terminal 102, a developer may check the development progress of the data interface on the interactive interface of the client terminal 102, if the prompt information for verifying the interface logic is checked, set input data may be input to the client terminal 102, and the client terminal 102 sends the input data to the first server 101 and obtains output data obtained based on the interface logic. The developer may combine the output data with the preset output result corresponding to the input data, and if the expected effect is satisfied, the interface logic verification may be determined to be correct on the interactive interface of the client terminal 102, so that the first server 101 performs the subsequent development operation. It can be understood that, the present application is not limited to the client terminal obtaining the preset input data input by the developer, and a corresponding list containing a plurality of preset input data and corresponding output results may also be stored in advance in the client terminal, when the client terminal receives the prompt information for characterizing the logic of the verification interface, the preset input data may be automatically randomly extracted from the corresponding list and sent to the first server 101, after receiving the fed back output data, the output result corresponding to the preset input data may be searched in the corresponding list and compared with the output data, and if the similarity is greater than the preset threshold, it may be indicated that the output data meets the expected result, so as to accelerate the development progress of the data interface.

It can also be understood that, in the present application, the manner in which the client terminal 102 determines whether the interface logic is correct may not be limited to sending the preset input data to the first server 101 at a single time, but may also send different preset input data to the first server 101 multiple times, and determine whether the interface logic is correct according to the comparison results of multiple times, so as to improve the accuracy of the determination.

After the first server 101 generates the interface address of the data interface, the client terminal 102 may further obtain the interface address from the first server 101, and display the interface address to the developer in the interactive interface, so that the developer can quickly call the interface address.

The client terminal 102 according to the embodiment of the present application may be a tablet Computer, a desktop Computer, a laptop Computer, a notebook Computer, an Ultra-mobile Personal Computer (UMPC), a handheld Computer, a netbook, a Personal Digital Assistant (PDA), a routing device, a virtual reality device, and the like.

The second server 103 may be configured to configure a corresponding interface development environment according to the definition information of the data interface acquired by the client terminal 102, so that the first server 101 completes generation of the interface logic according to the interface development environment. Specifically, after the client terminal 102 acquires the definition information input by the developer according to the service requirement of the data interface and the edited code information, the definition information of the data interface may be sent to the second server 103. After receiving the definition information of the data interface, the second server 103 may configure corresponding editors, compilers, debuggers, interface tools, and the like, so that the first server 101 completes generation of interface logic according to the configured development environment. The second server 103 may store a database including a plurality of editors, a plurality of compilers, a plurality of debuggers, a plurality of interface tools, and the like, so as to rapidly configure corresponding development environments for different data interfaces.

In the embodiment of the present application, the data transmission manner between the first server 101, the client terminal 102, and the second server 103 may be, but is not limited to, an HTTP protocol.

Referring to fig. 2, fig. 2 is a schematic flowchart illustrating a development system of a data interface according to an embodiment of the present application.

As shown in fig. 2, the development system of the data interface includes a first server, a client terminal, and a second server, and specifically includes the following steps:

step 201, the client terminal acquires definition data corresponding to the target data interface.

Specifically, the client terminal may obtain, at the interactive interface, definition data determined by the developer according to the service requirement of the target data interface.

Specifically, the developer can input the website for data interface development on the browsing interface of the client terminal, so that the browsing interface of the client terminal jumps to the interactive interface for data interface development. An input box for inputting definition data corresponding to the target data interface and a control for determining the input definition data can be displayed in the interactive interface, and after a developer inputs the definition data in the interactive interface of the client terminal and selects the determination control, the client terminal can finish the transfer of the definition data. The definition data corresponding to the target data interface may include, but is not limited to, an interface protocol type, an interface address name, a method, and entry data.

And 202, receiving definition data which is sent by the client terminal and corresponds to the target data interface to the second server by the second server.

Specifically, the client terminal may transmit the definition data to the second server via the HTTP protocol after the developer determines the inputted definition data. The client terminal can store the definition data after the definition data is input by a developer, so that the definition data can be rapidly displayed on the interactive interface when the developer needs to edit the definition data again, and the development flexibility of the data interface is improved.

The second server can receive definition data corresponding to the target data interface and sent by the client terminal through an HTTP protocol, and can store the definition data so as to facilitate subsequent quick calling. It can be understood that the second server may obtain the definition data sent by the client terminal according to a preset time interval, or may obtain the definition data sent by the client terminal in real time, which may be determined according to the requirements of the developer.

The second server may be provided with a database for storing the definition data, and may distinguish different definition data in a labeling manner, for example, label the definition data acquired at different times in a time labeling manner, so as to distinguish different definition data.

And step 203, configuring the development environment by the second server according to the definition data corresponding to the target data interface.

In particular, the second server may select a corresponding executor according to the definition data to configure a development environment for the target data interface.

Specifically, the second server may select a corresponding editor, compiler, debugger, interface tool, and the like according to data such as an interface protocol type, an interface address name, a method, and an input parameter data in the definition data, and may send the configured development environment to the first server, where the first server completes generation of the interface logic in the development environment.

The second server can store a database comprising a plurality of editors, a plurality of compilers, a plurality of debuggers, a plurality of interface tools and the like, so that corresponding development environments can be rapidly configured for different data interfaces.

And step 204, the client terminal acquires an editing code corresponding to the target data interface.

Specifically, the client terminal may further obtain a code edited by the developer according to the business requirement of the target data interface, where the developer may preferentially select a code language to be edited, such as but not limited to DataQL or SQL dialect, on the interactive interface of the client terminal, and complete the input of the code at a specified position of the code editing in the interactive interface.

In this embodiment, the editing code input by the developer may use various databases stored in the development system of the data interface, such as but not limited to, various databases including vipsid enlightenment and backend services, so as to implement the data call of the target data interface to the vipsid enlightenment database, and provide sufficient support for the development of the target data interface. In addition, in the process of inputting the editing code by a developer, a user-defined function code can be imported according to the service requirement of the target data interface (for example, the edited code can realize the calling of data stored in other databases) so as to enrich the function of the target data interface.

It is understood that the client terminal may not be limited to the order of acquiring the definition data and the editing code input by the developer, for example, the editing code may be acquired first and then the definition data may be acquired, or the definition data and the editing code may be acquired at the same time in the interactive interface.

Specifically, taking an example that the client terminal obtains the definition data and the editing code at the same time on the interactive interface, reference may be made to an interactive display interface schematic diagram of the client terminal provided in the embodiment of the present application shown in fig. 3. As shown in fig. 3, the interactive display interface 300 may be configured on a browsing interface of the client terminal, and specifically includes a protocol type input box 301, an interface address input box 302, a method selection box 303, an input parameter data input box 304, a language type selection box 305, and an editing language input box 306. The protocol type input box 301 may be configured to input a protocol applicable to the target data interface, where the protocol type may be applied to an address corresponding to the target data interface; the interface address input box 302 may be used to input a definition name of the developer for the target data interface, where the name may be applied to an address corresponding to the target data interface; the method selection box 303 may select an application method corresponding to the target data interface among the stored method types by the developer; the input parameter data input box 304 can be used for a developer to input the selected input parameter type; the language type selection box 305 may be used for a developer to determine a language type corresponding to the code before performing code editing, so as to present an editing language input box corresponding to the language type; the editing language input box 306 may be used to determine a corresponding language input box mode according to the selected language type and obtain the editing language input by the developer.

It is to be understood that the above-mentioned protocol type input box 301, interface address input box 302, method selection box 303 and parameter data input box 304 can obtain the definition data input by the developer for the client terminal, and the language type selection box 305 and editing language input box 306 can obtain the editing code input by the developer for the client terminal.

Further, when the developer completes inputting the protocol type input box 301, the interface address input box 302, the method selection box 303, the input parameter data input box 304, the language type selection box 305, and the editing language input box 306, a confirmation control arranged below the editing language input box 306 may be selected to confirm the inputted definition data and the editing code, and the client terminal may transmit the definition data determined to be inputted to the second server after receiving an instruction of the confirmation control.

Possibly, if the developer finds that the inputted definition data and/or the editing code has an error, a modification control arranged below the editing language input box 306 can be selected, and the client terminal can define the protocol type input box 301, the interface address input box 302, the method selection box 303, the input parameter data input box 304, the language type selection box 305 and the editing language input box 306 as reselected after receiving an instruction of the modification control, so that the developer can modify the definition data in time and send the inputted definition data to the second server after the developer selects the confirmation control again.

And step 205, receiving definition data and editing codes corresponding to the target data interface, which are sent by the client terminal, by the first server.

Specifically, after receiving the editing code input by the developer, the client terminal may send the already input definition data and the editing code to the first server, so that the first server completes subsequent development of the target data interface.

In the above-mentioned interactive display interface 300 as an example, after the developer completes inputting the protocol type input box 301, the interface address input box 302, the method selection box 303, the input parameter data input box 304, the language type selection box 305, and the editing language input box 306, the developer may select a confirmation control arranged below the editing language input box 306 to confirm the inputted definition data and editing codes, and the client terminal may send the definition data and the editing codes that are determined to be inputted to the first server after receiving the instruction of the confirmation control.

The first server can receive definition data and an editing code which are sent by the client terminal and correspond to the target data interface through an HTTP protocol, and store the definition data and the editing code. It can be understood that the first server may obtain the definition data and the editing code sent by the client terminal according to a preset time interval, and may also obtain the definition data and the editing code sent by the client terminal in real time, which may be determined according to the requirements of developers.

And step 206, performing script compiling by the first server according to the definition data corresponding to the target data interface and the editing code under the development environment configured by the second server, and generating interface logic based on the script compiling.

Specifically, the first server may obtain a development environment configured by the second server according to definition data sent by the client terminal, and perform script compilation according to the definition data and an editing code based on the development environment to generate an interface logic corresponding to the target data interface.

It should be noted that after the first server receives the editing code sent by the client terminal, prompt information defining the parameter data may be sent to the client terminal, so that the client terminal obtains the parameter data corresponding to the input parameter data input by the developer, and the client terminal sends the confirmed parameter data to the first server, so as to complete generation of the interface logic corresponding to the target data interface. The first server can store definition data, editing codes and parameter data sent by the client terminal, and the modification position can be conveniently and rapidly found out when the generated interface logic needs to be modified.

In this embodiment, the input of the parameter data is set after the developer completes the editing of the code, and compared with the prior art in which the parameter data is defined and the parameter data is output before the code editing is completed, the flexible definition of the parameter data can be realized, and the flexibility of the development of the target data interface is improved.

And step 207, acquiring preset access data by the client terminal.

Specifically, after the first server generates the interface logic according to the definition data and the editing code, the first server may send a prompt message for generating the interface logic to the client terminal, and the client terminal may obtain preset parameter data for verifying whether the interface logic is correct, which is input by the developer, when receiving the prompt message for generating the interface logic.

Specifically, when the client terminal receives the prompt information for generating the interface logic, the prompt information may be displayed to the developer on the interactive display interface of the client terminal, for example, but not limited to, a prompt box labeled with the generated interface logic pops up on the interactive display interface, and the developer may select to input the preset entry data according to the content of the prompt box. The preset parameter data can be stored in the client terminal in advance, and a developer selects any one of the names of the parameter data as the input preset parameter data on the interactive display interface. It is to be understood that the preset input parameter may also be manually input by a developer, and the embodiment of the present application is not limited thereto.

And step 208, receiving preset access parameter data sent by the client terminal by the first server, and obtaining access parameter data corresponding to the preset access parameter data based on the interface logic.

Specifically, after the client terminal selects or inputs the preset access parameter data, the developer may select the confirmation control to confirm the preset access parameter data, and the client terminal may send the preset access parameter data to the first server after receiving an instruction to confirm the preset access parameter data.

Further, after receiving the preset parameter data, the first server may substitute the preset parameter data into the interface logic to obtain the corresponding parameter data. The type and number of the preset parameter data sent by the client terminal can be any number, and the corresponding parameter data can be obtained through interface logic according to the received different types of the preset parameter data.

Specifically, taking the preset entry parameter data sent by the client terminal including a and B as an example, when the preset entry parameter data received by the first server is a, the corresponding exit parameter data can be obtained as a according to the interface logic. And when the preset access parameter data received by the first server is B, obtaining corresponding access parameter data B according to the interface logic.

And step 209, receiving the parameter output data sent by the first server by the client terminal, and verifying whether the interface logic is correct or not based on the parameter output data.

Specifically, after obtaining the parameter output data corresponding to the preset parameter input data according to the interface logic, the first server may send the parameter output data to the client terminal, and the client terminal and the developer determine whether the interface logic is correct.

Furthermore, after receiving the parameter output data corresponding to the preset parameter input data, the client terminal can display the parameter output data on an interactive display interface, so that developers can compare the parameter output data with the preset parameter output data in combination.

Possibly, the developer can compare the preset parameter output result corresponding to the preset parameter input data input to the client terminal with the parameter output data corresponding to the preset parameter input data sent to the client terminal by the first server according to the corresponding relation between the preset parameter input data and the preset parameter output result, if the similarity meets a preset threshold value, the interface logic is in line with expectation, and the next process of target data interface development can be entered.

Possibly, the client terminal may store a corresponding relationship list of preset parameter input data and preset parameter output results, and after receiving the prompt message for generating the interface logic sent by the first server, the client terminal may randomly select the preset parameter input data from the corresponding relationship list and send the preset parameter input data to the first server. Further, the client terminal can find out that the preset parameter output result corresponding to the selected preset parameter input data is compared with the similarity of the parameter output data sent by the first server, if the similarity meets a preset threshold value, the interface logic is in accordance with the expectation, and the next process of target data interface development can be entered.

It will be appreciated that the manner of determination of the interface logic may not be limited to the above-mentioned similarity comparison, for example but not limited to comparison by a natural language processing model.

And step 210, the first server performs issuing operation under the condition that the interface logic is correct, and generates an interface address of the target data interface.

Specifically, in the case where the client terminal confirms that the interface logic is correct, an instruction to perform the issuing operation may be sent by the client terminal to the first server, so that the first server performs the issuing operation and generates the interface address of the target data interface.

Specifically, the client terminal may be configured to select a control for executing the issuing operation instruction by the developer when the developer confirms that the interface logic is correct, and may send operation information of the issuing operation to the first server when the client terminal receives the instruction for executing the issuing operation. Further, the first server executes the publishing operation after receiving the operation information of the publishing operation, generates an interface address of the target data interface, returns the generated interface address to the client terminal, and displays the generated interface address to the developer through the client terminal.

After obtaining the interface address of the target data interface, the developer may continue to perform script compiling to convert the target data interface into an Intermediate Query Language (QIL), so that when receiving the interface request of the target data interface, the developer may parse and execute the interface request through the converted Intermediate Query Language execution engine, and return a final result.

As an embodiment of the present application, the issuing operation performed by the first server in the case that the interface logic is correct includes:

Specifically, the first server can perform the issuing operation only when receiving the operation information of the issuing operation sent by the client terminal, and can perform the smoking test before the issuing operation to quickly verify whether the interface logic has defects, and perform the issuing operation again when the smoking test result is successful, so as to ensure the stability and the performability of the target data interface, and improve the development efficiency and the development quality.

As another embodiment of the present application, refer to fig. 4, which is a schematic flowchart of a method for developing a data interface provided in the embodiment of the present application, where the method is applied to a first server, and specifically includes the following steps:

step 401, receiving definition data and editing code corresponding to the target data interface sent by the client terminal.

Specifically, step 401 is identical to step 205, and is not described herein again.

And 402, performing script compiling according to definition data corresponding to the target data interface and editing codes corresponding to the target data interface in the development environment configured by the second server, and generating interface logic based on the script compiling.

Specifically, step 402 is identical to step 206, and is not described herein again.

And 403, receiving preset parameter input data sent by the client terminal, and obtaining parameter output data corresponding to the preset parameter input data based on the interface logic.

Specifically, step 403 is identical to step 208, and is not described herein again.

Step 404, returning the parameter data to the client terminal, so that the client terminal verifies whether the interface logic is correct according to the parameter data.

Specifically, step 404 is identical to step 209, and is not described herein again.

And 405, under the condition that the interface logic is verified to be incorrect by the client terminal, receiving the modified editing code corresponding to the target data interface sent by the client terminal, and compiling the script according to the definition data corresponding to the target data interface and the modified editing code corresponding to the target data interface.

Specifically, after receiving the parameter output data corresponding to the preset parameter input data, the client terminal can display the parameter output data on an interactive display interface, so that developers can compare the parameter output data with the preset parameter output data in combination.

Possibly, the developer can compare the preset parameter output result corresponding to the preset parameter input data input to the client terminal with the parameter output data corresponding to the preset parameter input data sent to the client terminal by the first server according to the corresponding relation between the preset parameter input data and the preset parameter output result, if the similarity does not meet the preset threshold, the interface logic is not in accordance with the expectation, and the editing code needs to be modified.

Possibly, the client terminal may store a corresponding relationship list of preset parameter input data and preset parameter output results, and after receiving the prompt message for generating the interface logic sent by the first server, the client terminal may randomly select the preset parameter input data from the corresponding relationship list and send the preset parameter input data to the first server. Further, the client terminal can find out that the preset parameter output result corresponding to the selected preset parameter input data is compared with the similarity of the parameter output data sent by the first server, and if the similarity does not meet a preset threshold value, the interface logic is not expected to meet the requirement, and the editing code needs to be modified.

Further, under the condition that the client terminal verifies that the interface logic is incorrect, the client terminal can display a modification prompt box with incorrect interface logic on the interactive display interface to remind a developer of modifying the edited code in time, and after the developer determines the input modified edited code, the modified edited code is sent to the first server, so that the first server carries out script editing again according to the modified edited code and the stored definition data, and the interface logic is regenerated.

Furthermore, after the first server regenerates the interface logic, the first server may receive the preset access parameter data sent by the client terminal again, obtain the parameter data according to the preset access parameter data and the regenerated interface logic, send the parameter data to the client terminal, and verify the interface logic again by the client terminal until the verification result of the generated interface logic is correct.

In the embodiment of the application, under the condition that the interface logic is incorrect, a developer can modify the editing code at the client terminal, so that repeated and complicated development links are avoided, and the development efficiency of the data interface can be effectively improved.

As another embodiment of the present application, after the first server performs the issuing operation when the interface logic is correct and generates the interface address of the target data interface, the method further includes:

Specifically, the first server may send the generated interface address to the client terminal under the condition that the interface logic verification is correct, so as to display the interface address to the developer through the interactive display interface of the client terminal, and send the prompt information for issuing the interface address to the client terminal, so that the developer performs an operation of issuing a target data interface on the interactive display interface of the client terminal, for example but not limited to selecting an issuing control set on the interactive display interface of the client terminal, and the client terminal may cooperate with the first server to complete online issuing of the target data interface when receiving an instruction of the issuing control.

It can be understood that, after the target data interface completes the online publishing, the first server may also send the information that the target data interface completes the online publishing to the client terminal, so that the developer can know the development progress of the target data interface through the client terminal at any time, thereby providing more convenience for the developer.

As another embodiment of the present application, refer to fig. 5, which shows a flowchart of a method for developing a data interface provided in the embodiment of the present application, where the method for developing a data interface is applied to a first server, and specifically includes the following steps:

step 501, receiving definition data and editing code corresponding to the target data interface sent by the client terminal.

Specifically, step 501 is identical to step 401 and step 205, and is not described herein again.

And 502, performing script compiling according to definition data corresponding to the target data interface and editing codes corresponding to the target data interface under the development environment configured by the second server, and generating interface logic based on the script compiling.

Specifically, step 502 is the same as step 402 and step 206, and is not described here again.

Step 503, receiving preset parameter entering data sent by the client terminal, and obtaining parameter exiting data corresponding to the preset parameter entering data based on the interface logic.

Specifically, step 503 is identical to step 403 and step 208, and is not described here again.

Step 504, the parameter data is returned to the client terminal, so that the client terminal can verify whether the interface logic is correct according to the parameter data.

Specifically, step 504 is identical to step 404 and step 209, and is not described here again.

And 505, performing issuing operation under the condition that the interface logic is correct, and generating an interface address of the target data interface.

Specifically, step 505 is identical to step 210, and is not described herein again.

Step 506, determining an interface address corresponding to a previous version of the target data interface according to the version information of the target data interface.

Specifically, the interface address of the target data interface generated by the first server may include version information, for example, different versions of interface addresses may be developed for the same target data interface in a process of being continuously adjusted according to different requirements, and the interface addresses between two adjacent versions may have a certain association. In the case where the interface address of the target data interface is at risk, version information of the current interface address may be determined by the first server, and an interface address corresponding to a previous version of the version may be determined based on the version information. It should be noted that, in the process of developing the data interfaces of different versions, the first server may store the generated data interfaces of each version, and the data interfaces of different versions may be stored in the same path, which facilitates fast query.

Step 507, sending an interface address corresponding to a previous version of the target data interface to the client terminal.

Specifically, the first server, in a case that a data interface corresponding to a previous version of the current version of the target data interface is determined, may send the data interface of the previous version to the client terminal, so that the interactive display interface of the client terminal displays the definition data and the editing code corresponding to the data interface of the previous version.

Specifically, the first server may, in a case where the data interface of the previous version is determined, call the definition data and the editing code corresponding to the data interface of the previous version, and send the definition data and the editing code to the client terminal, so that the client terminal displays the definition data and the editing code, which is convenient for a developer to re-input or modify part of the data according to the definition data and the editing code.

Further, after the developer modifies and redetermines the definition data and the editing code corresponding to the data interface of the previous version, the client terminal may further send the redetermined definition data to the second server, so that the second server reconfigures the development environment according to the definition data, and the client terminal sends the redetermined definition data and the editing code to the first server, so that the first server performs script compilation on the redetermined definition data and the editing code according to the redeployed development environment of the second server, regenerates the interface logic, and executes the aforementioned development steps, which is not described herein again.

In the embodiment of the application, when the target data interface is in risk, the definition data and the editing code corresponding to the data interface can be determined through the version information of the target data interface, so that developers can quickly modify the definition data and the editing code and regenerate the interface logic of the target data interface, the risk coping capability and the modification efficiency of the target data interface are improved, and more flexibility is brought to the development of the data interface.

As another embodiment of the present application, refer to fig. 6 showing a flowchart of a method for developing a data interface provided in the embodiment of the present application, where the method for developing a data interface is applied to a client terminal, and specifically includes the following steps:

step 601, obtaining the identity information of the login user, and sending the identity information of the login user to the second server.

Specifically, before entering the interactive display interface, the client terminal can also input a specified development interface website by the developer on a browser page to enter an information interface for verifying the identity of the developer. The developer needs to input authorized user identity information at the client terminal, the second server receives the identity information sent by the client terminal and verifies the identity information, and the second server can send the verification result to the client terminal after the verification result is obtained.

Specifically, after the developer inputs the specified development interface website at the client terminal, the interactive display interface of the client terminal displays a verification interface for prompting the developer to input the identity information. The developer may enter an account name, such as but not limited to a designated work number or a mobile phone number, in an account entry box of the verification interface and enter a password corresponding to the account name in a corresponding password entry box. It can be understood that the account name input by the developer is a registered account, and the password can be retrieved or reset through the bound mobile phone number or mailbox number when the developer forgets the password.

Further, after the developer inputs the account name and the corresponding password, the developer can select a login control on an interactive display interface of the client terminal, and the client terminal uploads the account name and the corresponding password to the second server when receiving a login instruction determined by the developer. The second server stores a database of a plurality of authorized account names and corresponding set passwords, and can query in the database according to the received account names and the corresponding passwords, determine that the verification result is authorized when the same account name and the corresponding password are queried, determine that the verification result is unauthorized when the same account name is not queried, and determine that the verification result is a password error when the password identical to the account name is not queried.

Possibly, when the verification result sent by the second server to the client terminal is authorized, the client terminal may jump to an interface for acquiring definition data corresponding to the target data interface, and the developer inputs the definition data at a specified position.

Possibly, when the verification result sent by the second server to the client terminal is unauthorized, the client terminal may pop up a prompt box for indicating that the user identity is unauthorized, so as to prompt the developer to re-input the authorized account name.

Possibly, when the verification result sent by the second server to the client terminal is that the password is wrong, the client terminal may pop up a prompt box for representing that the password is wrong, so as to prompt the developer to re-input the password or select to retrieve the password.

Step 602, obtaining definition data corresponding to the target data interface, and sending the definition data corresponding to the target data interface to the second server.

Specifically, step 602 is identical to step 202, and is not described herein again.

Step 603, acquiring the editing code corresponding to the target data interface, and sending the definition data corresponding to the target data interface and the editing code corresponding to the target data interface to the first server.

Specifically, step 603 is the same as step 205, and is not described herein again.

And step 604, acquiring preset parameter data, and sending the preset parameter data to the first server.

Specifically, step 604 is identical to step 208, and is not described herein again.

Step 605, receiving the parameter output data sent by the first server, and verifying whether the interface logic is correct based on the parameter output data.

Specifically, step 605 is identical to step 209, and is not described herein again.

In the embodiment of the application, the identity information of the login user can be verified before the target data interface is developed, so that the safety and operability of the data interface are improved, meanwhile, the login user can finish the development of the data interface by logging in different client terminals, and the flexibility of interface development is further improved.

As another embodiment of the present application, reference may be made to fig. 7, which is a schematic overall flowchart of a development system of a data interface provided in an embodiment of the present application.

As shown in fig. 7, the development system of the data interface includes the following steps:

step 701, the user logs in.

Step 702, verifying whether the user is authorized, if so, entering step 703, otherwise, entering step 711.

And step 703, acquiring definition data corresponding to the target data interface.

And step 704, acquiring an editing code corresponding to the target data interface.

Step 705, obtaining definition parameter data corresponding to the target data interface, and generating an interface logic according to the definition data, the editing code and the definition parameter data.

And step 706, acquiring preset parameter data.

Step 707, verifying whether the interface logic is successful, if so, entering step 709, otherwise, entering step 708, and returning to step 704.

Step 708, obtain the modified editing code corresponding to the target data interface.

Step 709, performing a publishing operation, and generating an interface address of the target data interface.

Step 710, publish the target data interface.

And step 711, logging out.

Specifically, the development system of the data interface may include a first server, a client terminal, and a second server, where a developer may input a user account on an interactive display interface of the client terminal, and the client terminal sends the user account to the second server, so that the second server determines whether the user account is authorized, and continues to obtain, by the client terminal, an edit code corresponding to the target data interface, which is input by the developer, under the authorized condition. If the second server judges that the user account cannot be authorized, the login is stopped, and the user account input by the developer is obtained again by the client terminal. Furthermore, the client terminal can send the definition data input by the developer to a second server, the second server configures the environment according to the definition data, and can send the definition data, the editing codes and the definition parameter data input by the developer to a first server, and the first server performs script compiling according to the definition data, the editing codes and the definition parameter data in the development environment configured by the second server to generate the interface logic. The definition data can be a protocol type, an interface address, a method and entry parameter data of the target data interface. Further, the client terminal can obtain preset input parameter data input by a developer under the condition that the first server generates the interface logic, the preset input parameter data are sent to the first server, the first server generates the input parameter data according to the preset input parameter data, and the developer can judge whether the interface logic is successful according to the similarity between the preset input parameter data and the input parameter data generated by the first server. It can be understood that the preset parameter data and the corresponding parameter output result can be stored in the client terminal, and the client terminal can determine whether the interface logic is successful. Further, under the condition that the interface logic is successful, the first server can perform smoking test, and perform issuing operation after the test is successful, so as to generate an interface address of the target data interface and complete the on-line issuing of the target data interface. And under the condition that the interface logic fails, a developer can input the modified editing code corresponding to the target data interface at the client terminal and send the modified editing code to the first server so as to regenerate a new interface logic and verify the new interface logic until the verification is successful.

It is understood that the development system of the data interface may also perform data statistics on the published data interfaces, for example, but not limited to, including distribution of the statistical data interfaces, database contents corresponding to the data interfaces, the number of the data interfaces, and applications of the data interfaces, and may feed back the statistical data to the developer in the form of a table.

Referring to fig. 8, fig. 8 is a schematic structural diagram illustrating a first server according to an embodiment of the present disclosure.

As shown in fig. 8, the first server 800 may include at least a first receiving module 801, a first processing module 802, a second processing module 803, a first sending module 804, and a third processing module 805, wherein:

a first receiving module 801, configured to receive definition data and an editing code, which are sent by a client terminal and correspond to a target data interface;

a first processing module 802, configured to perform script compiling according to definition data corresponding to the target data interface and an editing code corresponding to the target data interface in a development environment configured by the second server, and generate an interface logic based on the script compiling; the development environment is determined by the second server according to definition data which is sent by the client terminal and corresponds to the target data interface;

a second processing module 803, configured to receive preset access parameter data sent by a client terminal, and obtain, based on an interface logic, access parameter data corresponding to the preset access parameter data;

a first sending module 804, configured to return the outgoing parameter data to the client terminal, so that the client terminal verifies whether the interface logic is correct according to the outgoing parameter data;

and a third processing module 805, configured to perform a publishing operation if the interface logic is correct, and generate an interface address of the target data interface.

In some possible embodiments, the third processing module 805 comprises:

In some possible embodiments, the first server further comprises:

and a sixth processing module, configured to, after the first sending module 804 returns the output parameter data to the client terminal, so that the client terminal verifies whether the interface logic is correct according to the output parameter data, and when the client terminal verifies that the interface logic is incorrect, receive a modified editing code corresponding to the target data interface sent by the client terminal, and perform script compiling according to definition data corresponding to the target data interface and the modified editing code corresponding to the target data interface.

In some possible embodiments, the first server further comprises:

and a fourth sending module, configured to send the interface address of the target data interface to the client terminal after the third processing module 805 performs the publishing operation and generates the interface address of the target data interface under the condition that the interface logic is correct, and send the prompt information for representing the publishing target data interface to the client terminal, so that the client terminal completes online publishing of the target data interface.

In some possible embodiments, the first server further comprises:

a seventh processing module, configured to determine, according to the version information of the target data interface, an interface address corresponding to a previous version of the target data interface after the third processing module 805 performs a publishing operation when the interface logic is correct and generates an interface address of the target data interface;

Referring to fig. 9, fig. 9 is a schematic structural diagram of a client terminal according to an embodiment of the present disclosure.

As shown in fig. 9, the client terminal 900 may include at least a first obtaining module 901, a second sending module 902, a third sending module 903, and a fourth processing module 904, where:

a first obtaining module 901, configured to obtain definition data corresponding to the target data interface, and send the definition data corresponding to the target data interface to a second server, so that the second server configures a development environment according to the definition data corresponding to the target data interface;

a second sending module 902, configured to obtain an edit code corresponding to the target data interface, and send the definition data corresponding to the target data interface and the edit code corresponding to the target data interface to the first server, so that the first server performs script compiling according to the definition data corresponding to the target data interface and the edit code corresponding to the target data interface in a development environment configured by the second server, and generates an interface logic based on the script compiling;

a third sending module 903, configured to obtain preset entry parameter data, and send the preset entry parameter data to the first server, so that the first server obtains, based on the interface logic, entry parameter data corresponding to the preset entry parameter data;

the fourth processing module 904 is configured to receive the egress parameter sent by the first server, and verify whether the interface logic is correct based on the egress parameter, so that the first server performs an issue operation when the interface logic is correct, and generates an interface address of the target data interface.

In some possible embodiments, the client terminal further comprises:

a second obtaining module, configured to receive the export parameter data sent by the first server by the fourth processing module 904, and obtain, after verifying whether the interface logic is correct based on the export parameter data, a modified editing code corresponding to the target data interface when the interface logic is determined to be incorrect;

In some possible embodiments, the client terminal further comprises:

a third obtaining module, configured to obtain the identity information of the login user before the first obtaining module 901 obtains the definition data corresponding to the target data interface and sends the definition data corresponding to the target data interface to the second server, and send the identity information of the login user to the second server, so that the second server verifies the identity information of the login user.

Referring to fig. 10, fig. 10 is a schematic structural diagram illustrating a second server according to an embodiment of the present disclosure.

As shown in fig. 10, the second server 1000 may include at least a second receiving module 1001 and a fifth processing module 1002, wherein:

a second receiving module 1001, configured to receive definition data corresponding to a target data interface sent by a client terminal;

the fifth processing module 1002 is configured to configure a development environment according to the definition data corresponding to the target data interface, so that the first server performs script compilation according to the definition data corresponding to the target data interface and the editing code corresponding to the target data interface in the development environment, generates an interface logic based on the script compilation, and performs an issuing operation when the interface logic is correct, thereby generating an interface address of the target data interface.

In some possible embodiments, the second server further comprises:

an eighth processing module, configured to receive, before the second receiving module 1001 receives the definition data corresponding to the target data interface and sent by the client terminal, identity information of the login user sent by the client terminal, and determine a verification result of the identity information of the login user;

Referring to fig. 11, fig. 11 is a schematic structural diagram illustrating another first server according to an embodiment of the present disclosure.

As shown in fig. 11, the first server 1100 may include: at least one processor 1101, at least one network interface 1104, a user interface 1103, a memory 1105, and at least one communication bus 1102.

The communication bus 1102 may be used to implement the connection communication of the above components.

The user interface 1103 may include keys, and the optional user interface may include a standard wired interface or a wireless interface.

The network interface 1104 may optionally include a bluetooth module, an NFC module, a Wi-Fi module, or the like.

Processor 1101 may include one or more processing cores, among other things. The processor 1101 connects various portions throughout the electronic device 1100 using various interfaces and lines to perform various functions of the routing device 1100 and process data by executing or executing instructions, programs, code sets, or instruction sets stored in the memory 1105 and invoking data stored in the memory 1105. Optionally, the processor 1101 may be implemented in at least one hardware form of DSP, FPGA, or PLA. The processor 1101 may integrate one or a combination of CPUs, GPUs, modems, etc. Wherein, the CPU mainly processes an operating system, a user interface, an application program and the like; the GPU is used for rendering and drawing the content required to be displayed by the display screen; the modem is used to handle wireless communications. It is understood that the modem may not be integrated into the processor 1101, but may be implemented by a single chip.

The memory 1105 may include a RAM or a ROM. Optionally, the memory 1105 includes non-transitory computer readable media. The memory 1105 may be used to store instructions, programs, code, sets of codes, or sets of instructions. The memory 1105 may include a stored program area and a stored data area, wherein the stored program area may store instructions for implementing an operating system, instructions for at least one function (such as a touch function, a sound playing function, an image playing function, etc.), instructions for implementing the various method embodiments described above, and the like; the storage data area may store data and the like referred to in the above respective method embodiments. The memory 1105 may alternatively be at least one storage device located remotely from the processor 1101. As shown in fig. 11, the memory 1105, which is a type of computer storage medium, may include an operating system, a network communication module, a user interface module, and a development application of a data interface.

In particular, the processor 1101 may be configured to invoke a development application of the data interface stored in the memory 1105, and specifically perform the following operations:

In some possible embodiments, the issue operation is performed with the correct interface logic, and the processor 1101 is configured to:

In some possible embodiments, after returning the parameter data to the client terminal, so that the client terminal verifies whether the interface logic is correct according to the parameter data, the processor 1101 is further configured to:

In some possible embodiments, after performing the issue operation with the correct interface logic and generating the interface address of the target data interface, the processor 1101 is further configured to perform:

Referring to fig. 12, fig. 12 is a schematic structural diagram of another client terminal according to an embodiment of the present application.

As shown in fig. 12, the first server 1200 may include: at least one processor 1201, at least one network interface 1204, a user interface 1203, memory 1205, a touch screen 1206, and at least one communication bus 1202.

The communication bus 1202 may be used for implementing the connection communication of the above components.

The user interface 1203 may include keys, and the optional user interface may include a standard wired interface or a wireless interface.

The network interface 1204 may optionally include a bluetooth module, an NFC module, a Wi-Fi module, or the like.

Processor 1201 may include one or more processing cores, among others. The processor 1201 interfaces with various interfaces and circuitry throughout the electronic device 1200 to perform various functions of the routing device 1200 and to process data by executing or executing instructions, programs, code sets, or instruction sets stored in the memory 1205, as well as invoking data stored in the memory 1205. Optionally, the processor 1201 may be implemented in at least one hardware form of DSP, FPGA, or PLA. The processor 1201 may integrate one or a combination of several of a CPU, GPU, modem, and the like. Wherein, the CPU mainly processes an operating system, a user interface, an application program and the like; the GPU is used for rendering and drawing the content required to be displayed by the display screen; the modem is used to handle wireless communications. It is understood that the modem may not be integrated into the processor 1201, and may be implemented by a single chip.

The memory 1205 may include RAM and ROM. Optionally, the memory 1205 includes a non-transitory computer-readable medium. The memory 1205 may be used to store an instruction, a program, code, a set of codes, or a set of instructions. The memory 1205 may include a stored program area and a stored data area, wherein the stored program area may store instructions for implementing an operating system, instructions for at least one function (such as a touch function, a sound playing function, an image playing function, etc.), instructions for implementing the various method embodiments described above, and the like; the storage data area may store data and the like referred to in the above respective method embodiments. The memory 1205 may also optionally be at least one storage device located remotely from the processor 1201 described previously. As shown in fig. 12, the memory 1205 as a computer storage medium may include an operating system, a network communication module, a user interface module, and a development application for data interfaces.

In particular, the processor 1201 may be configured to invoke a development application of the data interface stored in the memory 1205, and specifically perform the following operations:

In some possible embodiments, after receiving the parameter data sent by the first server and verifying whether the interface logic is correct based on the parameter data, the processor 1201 is further configured to:

In some possible embodiments, before obtaining the definition data corresponding to the target data interface, the processor 1201 is further configured to:

Referring to fig. 13, fig. 13 is a schematic structural diagram illustrating another second server according to an embodiment of the present disclosure.

As shown in fig. 13, the first server 1300 may include: at least one processor 1301, at least one network interface 1304, a user interface 1303, memory 1305, and at least one communication bus 1302.

The communication bus 1302 may be used for implementing the connection communication of the above components.

The user interface 1303 may include keys, and the selectable user interfaces may also include standard wired interfaces and wireless interfaces.

The network interface 1304 may optionally include a bluetooth module, an NFC module, a Wi-Fi module, or the like.

Processor 1301 may include one or more processing cores, among other things. The processor 1301, which connects various parts throughout the electronic device 1300 using various interfaces and lines, performs various functions of the routing device 1300 and processes data by executing or executing instructions, programs, code sets, or instruction sets stored in the memory 1305 and invoking data stored in the memory 1305. Optionally, the processor 1301 may be implemented in at least one hardware form of DSP, FPGA, or PLA. The processor 1301 may integrate one or a combination of CPU, GPU, modem, etc. Wherein, the CPU mainly processes an operating system, a user interface, an application program and the like; the GPU is used for rendering and drawing the content required to be displayed by the display screen; the modem is used to handle wireless communications. It is to be understood that the modem may not be integrated into the processor 1301, but may be implemented by a single chip.

The memory 1305 may include a RAM or a ROM. Optionally, the memory 1305 includes a non-transitory computer-readable medium. The memory 1305 may be used to store an instruction, a program, code, a set of codes, or a set of instructions. The memory 1305 may include a program storage area and a data storage area, wherein the program storage area may store instructions for implementing an operating system, instructions for at least one function (such as a touch function, a sound playing function, an image playing function, etc.), instructions for implementing the various method embodiments described above, and the like; the storage data area may store data and the like referred to in the above respective method embodiments. The memory 1305 may optionally be at least one memory device located remotely from the processor 1301. As shown in fig. 13, the memory 1305, which is a kind of computer storage medium, may include therein an operating system, a network communication module, a user interface module, and a development application program of a data interface.

In particular, the processor 1301 may be configured to invoke a development application of the data interface stored in the memory 1305, and specifically perform the following operations:

In some possible embodiments, before receiving the definition data corresponding to the target data interface sent by the client terminal, the processor 1301 is further configured to:

and sending the verification result to the client terminal.

Embodiments of the present application also provide a computer-readable storage medium, which stores instructions that, when executed on a computer or a processor, cause the computer or the processor to perform one or more steps in the embodiments shown in fig. 2 or fig. 4 or fig. 5 or fig. 6. The above-mentioned respective constituent modules of the mobile terminal, if implemented in the form of software functional units and sold or used as independent products, may be stored in the computer-readable storage medium.

In the above embodiments, the implementation may be wholly or partially realized by software, hardware, firmware, or any combination thereof. When implemented in software, may be implemented in whole or in part in the form of a computer program product. The computer program product includes one or more computer instructions. When loaded and executed on a computer, cause the processes or functions described in accordance with the embodiments of the application to occur, in whole or in part. The computer may be a general purpose computer, a special purpose computer, a network of computers, or other programmable device. The computer instructions may be stored in or transmitted over a computer-readable storage medium. The computer instructions may be transmitted from one website, computer, server, or data center to another website, computer, server, or data center by wire (e.g., coaxial cable, fiber optic, Digital Subscriber Line (DSL)), or wirelessly (e.g., infrared, wireless, microwave, etc.). The computer-readable storage medium can be any available medium that can be accessed by a computer or a data storage device, such as a server, a data center, etc., that incorporates one or more of the available media. The usable medium may be a magnetic medium (e.g., floppy Disk, hard Disk, magnetic tape), an optical medium (e.g., Digital Versatile Disk (DVD)), or a semiconductor medium (e.g., Solid State Disk (SSD)), among others.

It will be understood by those skilled in the art that all or part of the processes of the methods of the embodiments described above can be implemented by a computer program, which can be stored in a computer-readable storage medium, and can include the processes of the embodiments of the methods described above when the program is executed. And the aforementioned storage medium includes: various media that can store program codes, such as ROM, RAM, magnetic or optical disks. The technical features in the present examples and embodiments may be arbitrarily combined without conflict.

The above-described embodiments are merely preferred embodiments of the present application, and are not intended to limit the scope of the present application, and various modifications and improvements made to the technical solutions of the present application by those skilled in the art without departing from the design spirit of the present application should fall within the protection scope defined by the claims of the present application.

Claims

1. A method for developing a data interface, the method being applied to a first server and comprising:

performing script compiling according to the definition data corresponding to the target data interface and the editing code corresponding to the target data interface in a development environment configured by a second server, and generating interface logic based on the script compiling; the development environment is determined by the second server according to definition data which is sent by the client terminal and corresponds to the target data interface;

receiving preset parameter entering data sent by the client terminal, and obtaining parameter exiting data corresponding to the preset parameter entering data based on the interface logic;

returning the parameter data to the client terminal so that the client terminal can verify whether the interface logic is correct according to the parameter data;

2. The method of claim 1, wherein performing the issue operation if the interface logic is correct comprises:

3. The method of claim 1, wherein after returning the outbound parameter data to the client terminal to enable the client terminal to verify whether the interface logic is correct according to the outbound parameter data, further comprising:

and under the condition that the client terminal verifies that the interface logic is incorrect, receiving a modified editing code corresponding to the target data interface and sent by the client terminal, and compiling a script according to the definition data corresponding to the target data interface and the modified editing code corresponding to the target data interface.

4. The method of claim 1, wherein after performing the issue operation if the interface logic is correct and generating the interface address of the target data interface, further comprising:

and sending the interface address of the target data interface to the client terminal, and sending prompt information for representing and issuing the target data interface to the client terminal so that the client terminal completes on-line issuing of the target data interface.

5. The method of claim 1, wherein after performing the issue operation if the interface logic is correct and generating the interface address of the target data interface, further comprising:

determining an interface address corresponding to a last version of the target data interface according to the version information of the target data interface;

and sending the interface address corresponding to the last version of the target data interface to the client terminal so that the client terminal acquires the modified definition data corresponding to the last version of the target data interface and the editing code.

6. A method for developing a data interface is applied to a client terminal and comprises the following steps:

acquiring definition data corresponding to a target data interface, and sending the definition data corresponding to the target data interface to a second server so that the second server configures a development environment according to the definition data corresponding to the target data interface;

acquiring an editing code corresponding to the target data interface, and sending the definition data corresponding to the target data interface and the editing code corresponding to the target data interface to a first server, so that the first server performs script compiling according to the definition data corresponding to the target data interface and the editing code corresponding to the target data interface under a development environment configured by a second server, and generates an interface logic based on the script compiling;

acquiring preset entry parameter data, and sending the preset entry parameter data to the first server so that the first server obtains exit parameter data corresponding to the preset entry parameter data based on the interface logic;

and receiving the export parameter data sent by the first server, verifying whether the interface logic is correct or not based on the export parameter data, so that the first server performs issuing operation under the condition that the interface logic is correct, and generating an interface address of the target data interface.

7. The method of claim 6, wherein after receiving the egress parameter data sent by the first server and verifying whether the interface logic is correct based on the egress parameter data, the method further comprises:

8. The method of claim 6, wherein prior to obtaining the definition data corresponding to the target data interface, further comprising:

9. A method for developing a data interface, the method being applied to a second server and comprising:

configuring a development environment according to the definition data corresponding to the target data interface, so that the first server performs script compilation according to the definition data corresponding to the target data interface and the editing code corresponding to the target data interface in the development environment, generates an interface logic based on the script compilation, and performs issuing operation under the condition that the interface logic is correct to generate an interface address of the target data interface; wherein the editing code is sent to the first server by the client terminal.

10. The method of claim 9, wherein before receiving the definition data corresponding to the target data interface sent by the client terminal, the method further comprises:

receiving identity information of a login user sent by the client terminal, and determining a verification result of the identity information of the login user;

and sending the verification result to the client terminal.

11. A first server, comprising:

the first processing module is used for performing script compiling according to the definition data corresponding to the target data interface and the editing code corresponding to the target data interface under the development environment configured by the second server, and generating interface logic based on the script compiling; the development environment is determined by the second server according to definition data which is sent by the client terminal and corresponds to the target data interface;

the second processing module is used for receiving preset parameter input data sent by the client terminal and obtaining parameter output data corresponding to the preset parameter input data based on the interface logic;

the first sending module is used for returning the output parameter data to the client terminal so that the client terminal can verify whether the interface logic is correct according to the output parameter data;

12. A client terminal, comprising:

the first acquisition module is used for acquiring definition data corresponding to a target data interface and sending the definition data corresponding to the target data interface to a second server so that the second server configures a development environment according to the definition data corresponding to the target data interface;

the second sending module is used for acquiring the editing code corresponding to the target data interface, sending the definition data corresponding to the target data interface and the editing code corresponding to the target data interface to a first server, so that the first server carries out script compiling according to the definition data corresponding to the target data interface and the editing code corresponding to the target data interface under the development environment configured by the second server, and generates interface logic based on the script compiling;

the third sending module is used for obtaining preset parameter entering data and sending the preset parameter entering data to the first server so that the first server obtains parameter exiting data corresponding to the preset parameter entering data based on the interface logic;

and the fourth processing module is used for receiving the export parameter data sent by the first server, verifying whether the interface logic is correct based on the export parameter data, so that the first server performs issuing operation under the condition that the interface logic is correct, and generating an interface address of the target data interface.

13. A second server, comprising:

and the fifth processing module is used for configuring a development environment according to the definition data corresponding to the target data interface, so that the first server performs script compilation according to the definition data corresponding to the target data interface and the editing code corresponding to the target data interface in the development environment, generates interface logic based on the script compilation, performs issuing operation under the condition that the interface logic is correct, and generates an interface address of the target data interface.

14. A first server comprising a processor and a memory;

the processor is connected with the memory;

the memory for storing executable program code;

the processor runs a program corresponding to the executable program code by reading the executable program code stored in the memory for performing the method of any one of claims 1-5.

15. A client terminal comprising a processor and a memory;

the processor is connected with the memory;

the memory for storing executable program code;

the processor runs a program corresponding to the executable program code by reading the executable program code stored in the memory for performing the method of any one of claims 6-8.

16. A second server comprising a processor and a memory;

the processor is connected with the memory;

the memory for storing executable program code;

the processor runs a program corresponding to the executable program code by reading the executable program code stored in the memory for performing the method of any one of claims 9-10.

17. A development system for a data interface, comprising a first server according to claim 11, a client terminal according to claim 12, and a second server according to claim 13.

18. A computer-readable storage medium, on which a computer program is stored, which, when being executed by a processor, carries out the method according to any one of claims 1-5 or 6-8 or 9-10.