CN112988409B - Interface calling method and device, computer equipment and storage medium - Google Patents
Interface calling method and device, computer equipment and storage medium Download PDFInfo
- Publication number
- CN112988409B CN112988409B CN201911307130.9A CN201911307130A CN112988409B CN 112988409 B CN112988409 B CN 112988409B CN 201911307130 A CN201911307130 A CN 201911307130A CN 112988409 B CN112988409 B CN 112988409B
- Authority
- CN
- China
- Prior art keywords
- service
- calling
- request information
- interface
- call request
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
- 238000000034 method Methods 0.000 title claims abstract description 72
- 238000012545 processing Methods 0.000 claims description 42
- 230000004044 response Effects 0.000 claims description 41
- 238000012795 verification Methods 0.000 claims description 12
- 238000011161 development Methods 0.000 abstract description 15
- 230000006870 function Effects 0.000 description 66
- 238000013461 design Methods 0.000 description 18
- 238000004891 communication Methods 0.000 description 17
- 238000010586 diagram Methods 0.000 description 16
- 230000008569 process Effects 0.000 description 12
- 239000003795 chemical substances by application Substances 0.000 description 7
- 230000008878 coupling Effects 0.000 description 6
- 238000010168 coupling process Methods 0.000 description 6
- 238000005859 coupling reaction Methods 0.000 description 6
- 230000001960 triggered effect Effects 0.000 description 6
- 230000007246 mechanism Effects 0.000 description 5
- 238000013459 approach Methods 0.000 description 4
- 238000004590 computer program Methods 0.000 description 4
- 230000006399 behavior Effects 0.000 description 3
- 230000005540 biological transmission Effects 0.000 description 3
- 238000005538 encapsulation Methods 0.000 description 3
- 238000012423 maintenance Methods 0.000 description 3
- 230000009471 action Effects 0.000 description 2
- 238000012217 deletion Methods 0.000 description 2
- 230000037430 deletion Effects 0.000 description 2
- 230000000977 initiatory effect Effects 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 238000004806 packaging method and process Methods 0.000 description 2
- 238000000638 solvent extraction Methods 0.000 description 2
- 238000007792 addition Methods 0.000 description 1
- 229910002056 binary alloy Inorganic materials 0.000 description 1
- 230000008859 change Effects 0.000 description 1
- 238000013500 data storage Methods 0.000 description 1
- 239000000284 extract Substances 0.000 description 1
- 239000000835 fiber Substances 0.000 description 1
- 239000003205 fragrance Substances 0.000 description 1
- 230000006872 improvement Effects 0.000 description 1
- 230000010354 integration Effects 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 230000002085 persistent effect Effects 0.000 description 1
- 238000011160 research Methods 0.000 description 1
- 239000004065 semiconductor Substances 0.000 description 1
- 239000007787 solid Substances 0.000 description 1
- 230000001052 transient effect Effects 0.000 description 1
- 238000013519 translation Methods 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/54—Interprogram communication
- G06F9/547—Remote procedure calls [RPC]; Web services
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F2209/00—Indexing scheme relating to G06F9/00
- G06F2209/54—Indexing scheme relating to G06F9/54
- G06F2209/544—Remote
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Stored Programmes (AREA)
Abstract
The embodiment of the application discloses an interface calling method, an interface calling device, computer equipment and a storage medium. The method and the device can check the validity of the call request information at the service layer when the call request information of the user is received, and send the call request information to the proxy layer. And configuring a data object according to the call request information at the proxy layer, calling a preset package plug-in according to the data object, acquiring an execution result of the preset package plug-in, and finally transmitting the execution result to a service layer and outputting the execution result. According to the scheme, the interface calling code is packaged into the plug-in which can be repeatedly used, so that the plug-in can be repeatedly used to adapt to different development environments, and the development efficiency can be improved.
Description
Technical Field
The embodiment of the application relates to the field of software development, in particular to an interface calling method, an interface calling device, computer equipment and a storage medium.
Background
Remote procedure calls (Remote Producer Call, RPC) are based on specific computer communication protocols, transparently translating local approach calls into cross-machine calls, which are the basic functions of distributed services. The remote procedure call always makes a request to the server from the client, and the server executes the result according to the request and returns the result to the client, which may be referred to as remote call hereinafter.
Remote calls typically implement a transparent translation cross-machine call local approach through calls to the interface. However, the existing interface calling method generally comprises the following steps: acquiring a proxy object requesting background service; assembling a request structure object corresponding to the binary protocol; initiating an asynchronous request; and processing call exception and converting the call exception into json objects. In the research and practice process of the prior art, the inventor of the embodiment of the application finds that the existing method exposes excessive calling details, meanwhile, the codes are not separated from interface logic and general logic, so that a large number of codes are repeatedly written in the calling process, the reusability of the calling codes is poor, and the development efficiency is low.
Disclosure of Invention
The embodiment of the application provides an interface calling method, an interface calling device, computer equipment and a storage medium, which enable calling background interface codes to be repeatedly used by packaging the calling background interface codes into plug-ins, so that development efficiency is improved, code redundancy is reduced, and project code maintainability is improved.
In a first aspect, an embodiment of the present application provides an interface calling method, including:
receiving call request information of a user;
verifying the validity of the call request information at a service layer;
Sending the call request information to the proxy layer
At the proxy layer, configuring a data object according to the call request information;
invoking a preset package plug-in according to the data object;
acquiring an execution result of a preset package plug-in;
and sending the execution result to a service layer and outputting the result.
In one possible design, before the calling of the preset package plug-in according to the data object, the method further includes:
determining the service type of the service to be processed according to the data object;
determining an interface to be called according to the service type;
acquiring a plurality of calling component templates according to the interface to be called;
and generating the preset package plug-in according to the plurality of calling component templates.
In one possible design, before the obtaining a plurality of calling component templates according to the interface to be called, the method further includes:
and constructing a calling component template according to the service type.
In one possible design, after the determining the service type of the service to be processed according to the data object, the method further includes:
judging whether the service type changes or not;
when the service type changes, determining the changed service type;
Determining a calling component to be updated according to the changed service type;
and updating the calling component to be updated to a preset package plug-in.
In one possible design, the pre-packaged plugin is provided at the proxy layer.
In one possible design, the configuring, at the proxy layer, a data object according to the call request information includes:
at the proxy layer, configuring a service name, a request structure body and a response structure body according to the calling request information;
and generating the data object according to the service name, the request structure body and the response structure body, wherein the data object is used for bearing data when requesting or responding to the call request information.
In one possible design, the calling a preset package plug-in according to the data object, and obtaining an execution result of the preset package plug-in includes:
assembling the encapsulated call request information into a request structure body according to the data object and the preset encapsulation plugin;
transmitting the request structure to a server according to the preset package plug-in;
calling an interface protocol service proxy to the telecommunication terminal service according to the association relation between the service name and the telecommunication terminal service at the proxy layer;
Acquiring a response structure body generated by the server based on the request structure body according to the preset package plug-in;
analyzing the response structure body according to the preset package plug-in, disassembling the response structure body into a script object, and taking the script object as the execution result.
In one possible design, the method further comprises:
and setting service logic of each calling interface according to the service type at the service layer.
In one possible design, the results of execution of the interface call are maintained on the blockchain node.
In a second aspect, an embodiment of the present application further provides an interface calling device, which has a function of implementing a method corresponding to the interface calling method. The functions may be implemented by hardware, or may be implemented by hardware executing corresponding software. The hardware or software includes one or more modules corresponding to the functions described above, which may be software and/or hardware.
In one possible design, the interface calling device includes:
the input/output module is used for receiving call request information of a user;
the verification module is used for verifying the validity of the call request information received by the input/output module at a service layer;
The input/output module is also used for sending the call request information to the proxy layer;
the processing module is used for configuring a data object according to the calling request information at the proxy layer; invoking a preset package plug-in according to the data object; acquiring an execution result of a preset package plug-in through the input/output module; the execution result is sent to a service layer through the input and output module and is output;
in one possible design, the processing module is further configured to, before the calling of the preset package plug-in according to the data object:
determining the service type of the service to be processed according to the data object; determining an interface to be called according to the service type of the service to be processed;
acquiring a plurality of calling component templates according to the interface to be called;
and generating the preset package plug-in according to the plurality of calling component templates.
In one possible design, before the processing module obtains a plurality of calling component templates according to the interface to be called, the processing module is further configured to:
and constructing a calling component template according to the service type.
In a possible design, the processing module is further configured to, after the determining, according to the data object, a service type of the service to be processed:
Judging whether the service type changes or not;
when the service type changes, determining the changed service type;
determining a calling component to be updated according to the changed service type;
and updating the calling component to be updated to a preset package plug-in.
In one possible design, the pre-packaged plugin is provided at the proxy layer.
In one possible design, the processing module is specifically configured to:
at the agent layer, configuring a service name, a request structure body and a response structure body according to legal calling request information checked by the checking module;
and generating the data object according to the configured service name, the request structure body and the response structure body, wherein the data object is used for bearing data when requesting or responding to the call request information.
In one possible design, the processing module is further configured to, before the calling of the preset package plug-in according to the data object:
and generating a preset package plug-in according to the data object.
In one possible design, the processing module is specifically configured to:
assembling the encapsulated call request information into a request structure body according to the data object and the preset encapsulation plugin;
Transmitting the request structure to a server according to the preset package plug-in;
calling an interface protocol service proxy to the telecommunication terminal service according to the association relation between the service name and the telecommunication terminal service at the proxy layer;
acquiring a response structure body generated by the server based on the request structure body according to the preset package plug-in;
analyzing the response structure body according to the preset package plug-in, disassembling the response structure body into a script object, and taking the script object as the execution result.
In one possible design, the processing module is further configured to:
and setting service logic of each calling interface according to the service type at the service layer.
In one possible design, the results of execution of the interface call are maintained on the blockchain node.
In a third aspect, embodiments of the present application provide a computer device, including at least one connected transceiver, a memory, and a processor, where the memory stores an application program, and the processor is configured to run the application program in the memory to perform the method described in the first aspect.
In a fourth aspect, embodiments of the present application provide a computer readable storage medium storing a plurality of instructions adapted to be loaded by a processor to perform the interface calling method described in the above aspects.
Compared with the existing mechanism, when call request information of a user is received, the method and the device check the validity of the call request information at the service layer and send the call request information to the proxy layer. And configuring a data object according to the calling request information at the proxy layer, calling a preset package plug-in according to the data object, acquiring an execution result of the preset package plug-in, and finally transmitting the execution result to a service layer and outputting. According to the scheme, the interface calling code is packaged into the plug-in capable of being utilized for many times, so that calling details are packaged, decoupling of general logic and interface logic is achieved, code redundancy is reduced, meanwhile, the plug-in can be reused to adapt to different development environments, and development efficiency and project code maintainability can be improved.
Drawings
In order to more clearly illustrate the technical solutions of the embodiments of the present application, the drawings that are needed in the description of the embodiments will be briefly introduced below, it being obvious that the drawings in the following description are only some embodiments of the present application, and that other drawings may be obtained according to these drawings without inventive effort for a person skilled in the art.
FIG. 1a is a schematic diagram of a hierarchical model in an interface invocation method according to an embodiment of the present application;
FIG. 1b is a diagram of a directory structure of a call interface according to an embodiment of the present application;
FIG. 2 is a flowchart of an interface calling method provided in an embodiment of the present application;
fig. 3 is a schematic diagram of generating preset package plugins according to different service types in the interface calling method provided in the embodiment of the present application;
fig. 4 is a schematic diagram of generating a preset package plug-in when a service type is changed in the interface calling method provided in the embodiment of the present application;
fig. 5 is a schematic diagram of generating a preset package plug-in when a service function is increased in the interface calling method provided in the embodiment of the present application;
fig. 6 is a schematic diagram of generating a preset package plug-in when a service function is deleted in the interface calling method provided in the embodiment of the present application;
fig. 7 is a schematic diagram of generating a preset package plug-in when a service function is replaced in the interface calling method provided in the embodiment of the present application;
FIG. 8 is a schematic diagram of a distributed system applied to a blockchain system in the interface invocation method according to the embodiment of the present application
FIG. 9 is a block chain structure of an interface calling method according to an embodiment of the present application
Fig. 10 is a schematic structural diagram of an interface calling device according to an embodiment of the present application;
fig. 11 is a schematic structural diagram of a computer device according to an embodiment of the present application.
Detailed Description
The terms first, second and the like in the description and in the claims of the embodiments and in the above-described figures are used for distinguishing between similar objects and not necessarily for describing a particular sequential or chronological order. It is to be understood that the data so used may be interchanged where appropriate such that the embodiments described herein may be implemented in other sequences than those illustrated or otherwise described herein. Furthermore, the terms "comprises," "comprising," and any variations thereof, are intended to cover a non-exclusive inclusion, such that a process, method, system, article, or apparatus that comprises a list of steps or modules is not necessarily limited to those explicitly listed but may include other steps or modules not expressly listed or inherent to such process, method, article, or apparatus, such that the partitioning of modules by embodiments of the application is only one logical partitioning, such that a plurality of modules may be combined or integrated in another system, or some features may be omitted, or not implemented, and further that the coupling or direct coupling or communication connection between modules may be via some interfaces, such that indirect coupling or communication connection between modules may be electrical or other like, none of the embodiments of the application are limited. The modules or sub-modules described as separate components may or may not be physically separate, may or may not be physical modules, or may be distributed in a plurality of circuit modules, and some or all of the modules may be selected according to actual needs to achieve the purposes of the embodiments of the present application.
The embodiment of the application provides an interface calling method, an interface calling device, computer equipment and a storage medium. The scheme can be used in terminals such as smart phones and personal computers for calling background service interfaces, and the terminals in the embodiment of the application can be nodes of a block chain system. The following will describe in detail.
Fig. 1a is a schematic structural diagram of a hierarchical model when a background service interface is called to obtain data in an embodiment of the present application. The hierarchical model includes a call interface, a service layer, a proxy layer, and a proxy service. Wherein the call interface refers to a communication interface between the front-end platform and the background server, and the call interface is used for receiving call request information, and the action is usually triggered by a user interface component. The service layer mainly checks the validity of the parameters, and transmits legal common format parameters to the proxy layer to obtain a result. The agent layer defines interface forms (objects such as a designated interface name, a request structure body/a response structure body of the interface and the like), and finishes interface parameter coding, response parameter decoding and exception handling through a preset package plug-in. The proxy service refers to a service that a server receives call request information sent by a preset package plug-in, and executes related service call according to the call request information. Taking the example of a user accessing a third party novel website, the hierarchical model shown in FIG. 1a is applied to a transcoding reader to convert the third party website to access novel services. The transcoding reader can be constructed based on a hippy platform, and can communicate with a background server through the transcoding reader when the transcoding reader is used for accessing the novel service. FIG. 1b is a directory structure of a call interface used by a transcoding reader.
In existing mechanisms, the interface calling method generally includes the following steps: acquiring a proxy object requesting background service; assembling a request structure object corresponding to the binary protocol; initiating an asynchronous request; and processing call exception and converting the call exception into json objects. This approach exposes excessive call details and does not encapsulate the call method well. Meanwhile, in the current technical side, the general business logic of the foreground and background communication interfaces is to realize the addition, deletion, modification and inquiry of data, and the general logic is to open the underlying communication link, assemble the request structure of the interface, disassemble the response structure of the interface into common objects, perform exception handling and the like. The existing mechanism does not separate interface logic and general logic, so that a large number of codes of the general logic are repeatedly written in the calling process, redundant codes are generated, and the maintenance performance is poor.
In order to solve the technical problems, the following scheme is adopted in the embodiment of the application:
and isolating the general logic from the service logic in a layering mode, setting the service logic of each calling interface according to the service type in the service layer, and focusing on the service logic of the service layer. The general logic is extracted from the service layer and placed in the proxy layer, so that repeated writing of the general logic can be avoided, and meanwhile, the general logic can be reused, and convenience is provided for service logic. Specifically, when call request information of a user is received, the validity of the call request information is checked at a service layer, and the call request information is sent to a proxy layer. And configuring a data object according to the call request information at the proxy layer, calling a preset package plug-in according to the data object, acquiring an execution result of the preset package plug-in, and finally transmitting the execution result to a service layer and outputting the execution result. According to the scheme, the interface calling code is packaged into the plug-in capable of being used for multiple times, so that calling details are packaged, and meanwhile, the plug-in can be reused to adapt to different development environments, and development efficiency can be improved.
The embodiments of the present application do not limit the implementation and deployment of multiple hierarchical models.
In some embodiments, the relevant code for the call interface, service layer, proxy layer, and proxy service may be developed first and then configured into a relatively independent hierarchy. In the process of calling the method by the interface, the calling interface is used for receiving calling request information, the service layer is used for checking the validity of the calling request information, the proxy layer is used for defining the interface form and obtaining the execution result, and the proxy service is used for executing the calling service contained in the calling request information.
As shown in fig. 2, after the deployment of the hierarchical model is completed, a specific flow of the interface calling method in the embodiment of the present application may be as follows:
201. and receiving call request information of the user.
Wherein, the call request information is generally triggered by a User through a User Interface (UI) component. In some embodiments, when the user is in a particular state, the user may trigger a call request behavior at the user interface component, which is used to generate call request information.
For example, a user accesses a novice reading webpage such as red-sleeve perfuming at a user interface of a mobile terminal. When the user clicks the collection button, the mobile terminal receives the calling request information through clicking action. The received call request information comprises transcoding service, the server executes the transcoding service after receiving the call request information, converts the red sleeve fragrance adding page into a mobile terminal mode, and sends the mobile terminal mode to a service layer of the mobile terminal for output.
In some implementations, the call request information can include an identification of the communication protocol, an application version number, a serialization manner, reserved bytes, a request identification (Identity Document, ID), and the like.
In some embodiments, in order to reduce the impact of the server on the application terminal and the cost of modification, a self-describing serialization approach is selected for the processing of the data. For example, in the processing of the call request information, the service name, the method name and the parameter type are used as the attribute values of the java object, and then are serialized through the Hessian (a binary serialization manner). For data related to an attribute, for example, an attribute value as a java object: and serializing data such as service names, method names, parameter types and the like. Thus, the attribute values of the java objects are converted into binary streams in such a self-descriptive serialization manner.
For example, when a user browser clicks a microblog link, a request for calling a microblog application is triggered at the moment, the identification of a communication protocol is 0xJ, the communication protocol at the moment is represented as a data code (Java Cryptography Extension, JCE) protocol, and the JCE protocol is a binary and custom protocol; the application version number is 01, and represents that the application version called by the current request is 01 version; the request identifier is fixed to be 01, and response information after the request identifier corresponds to the request identifier; the 02 field in the request message is called, and represents the serialization mode of the current request message as Hessian02.
202. And checking the validity of the call request information at a service layer.
After receiving the call request information, the terminal checks the information at a service layer to ensure that the received call request information is legal information, thereby avoiding execution errors in the subsequent call flow. And when the verification result shows that the call request information is illegal, the service layer generates call error information on the user interface and re-receives the call request information. For example, the request ID in the call request information must include only numbers, and the request ID length must conform to the protocol specification corresponding to the request ID. When the service layer checks that the request ID contains characters other than numbers, such as upper/lower letters, the check result indicates that the call request information is illegal call request information, and the service layer generates call error information to the user interface.
In some embodiments, the method further comprises:
and setting service logic of each calling interface according to the service type at the service layer.
By layering and isolating the business logic and the general logic of the calling interface, only the business logic is concerned when the software is developed, and the maintenance of projects and the development of interfaces are facilitated.
203. And sending the call request information to a proxy layer.
Specifically, after the service layer verifies the validity of the call request information, the call request information is sent to the proxy layer, so that the proxy layer can execute subsequent operations according to the call request information.
For example, when the user clicks on a music link on the microblog interface, a call request for starting the music application is triggered at this time. The call request information will pass the service layer check. When the verification result shows that the call request information is legal, the call request information is sent to a proxy layer.
204. And at the proxy layer, configuring a data object according to the call request information.
The data object is used for bearing data when requesting or responding to the call request information. The request structure is used for carrying data when requested, and the response structure is used for carrying data when responding. For example, when the access request is a request to acquire the south mountain map, the server is triggered to call the corresponding service interface, and call request information corresponding to the service interface is generated again, and parameters requested by the user to acquire the south mountain map and data of the south mountain map to be returned to the user are carried in the response structure body, so that data such as network addresses, path fields, structures and the like required by the south mountain map are displayed.
In some embodiments, the data object is a json format data object generated by the proxy layer, and is used for being transferred to a preset package plugin, so as to initialize the preset package plugin. The agent layer can package the codes into independent files by generating json format data objects, so that the code debugging and maintenance are easier and more convenient, and the code readability is improved. After sending the call request information to the proxy layer, the proxy layer configures the data object according to the call request information. Specifically, at the proxy layer, after receiving legal call request information, a service name, a request structure body and a response structure body are configured, and a json format data object is generated according to the configured service name, the request structure body and the response structure body. Because the data object is in json format, the service data can be converted into json format data through the json format data object and returned to the terminal where the user is located.
For example, when the proxy layer receives the call request information of the instant messaging tool to start the map, the proxy layer configures the service name as the map according to the call request information, and configures the request structure and the response structure according to the call request information of the start map. The final proxy layer will generate a json-formatted data object corresponding to the launch map.
205. And calling a preset package plug-in according to the data object.
The preset package plug-in is arranged on the proxy layer.
In some embodiments, the calling a preset package plugin according to the data object includes:
assembling the encapsulated call request information into a request structure body according to the data object and the preset encapsulation plugin;
transmitting the request structure to a server according to the preset package plug-in;
calling an interface protocol service proxy to the telecommunication terminal service according to the association relation between the service name and the telecommunication terminal service at the proxy layer;
acquiring a response structure body generated by the server based on the request structure body according to the preset package plug-in;
analyzing the response structure body according to the preset package plug-in, disassembling the response structure body into a script object, and taking the script object as the execution result.
For example, when the preset package plugin is a Wireless Unified Protocol (WUP) plugin, the WUP service proxy is called to a micro service architecture (Total Application Framework, TAF) service through a service name, and after data is acquired, the response structure is disassembled into a common js object. Through the WUP-proxy plugin, the service layer can take the intermediate result of this common js object. The communication interface is based on the JCE protocol, which is the bottom-most part of the TAF framework. Each communication interface defines a request structure and a response structure based on JCE protocol. Invoking WUP service refers to TAF service of a series of interfaces provided by the service, a platform layer builds a WUP basic service, the association relation between the service name and the TAF service is set in the configuration of the WUP basic service, and the front end is proxied to the TAF service of the service through the service name and the WUP basic service. The TAF service is used for providing service processing thread class to count various call information reported by the service.
In other embodiments, the preset package plug-in should also be generated according to the data object before the preset package plug-in is invoked. The proxy layer can determine the service type of the service to be processed corresponding to the call request information according to the data object. After obtaining the service type of the service to be processed, determining an interface to be called corresponding to the service type and a function corresponding to the interface to be called according to the service type of the service to be processed. And the agent layer acquires a calling component template according to the functions required by the interface to be called, and finally assembles a plurality of calling component templates to generate a preset packaging plug-in. Optionally, the calling component template is constructed in advance according to the service type.
Specifically, the call component template pool can be constructed in advance according to the service type corresponding to the required function. In the calling component template pool, different calling component templates, namely components A to H, are constructed corresponding to different functions, and are all calling component templates. And acquiring components required to be contained in realizing the service types according to different service types to be processed, and generating a preset package plug-in from the components.
For example, the correspondence between the service type and the component template may be as shown in table 1 below.
TABLE 1
Referring to table 1, the following correspondence can be obtained: when the service type is service 1, the preset package plug-in corresponding to the service 1 comprises a component A, a component B, a component C and a component D, and the components are assembled to generate the preset package plug-in of the service 1; when the service type is service 2, the preset package plugin corresponding to service 2 includes a component C, a component E, a component F and a component H, and the components are assembled to generate the preset package plugin of service 2.
In some embodiments, when the service type of the service to be processed changes, the preset package plug-in should change accordingly to adapt to the call requirement, which may be specifically expressed as: after the service type of the service to be processed is determined according to the data object, the service type is judged, and whether the service type is changed is confirmed. When the service type changes, determining the changed service type, and determining a calling component to be updated according to the changed service type. And finally updating the calling component to be updated into a preset package plug-in.
206. And obtaining an execution result of the preset package plug-in.
After obtaining the data object of which the proxy layer configuration is completed, the specific execution process of the preset package plug-in comprises the following steps: according to the data object, namely the request structure body, the response structure body and the service name of the agent layer configuration interface, encapsulating the call request information according to the generated json format data object, and assembling the encapsulated call request information into a request structure body; and finally acquiring data, namely a response structure body sent after the completion of the execution, by using the service name proxy to proxy service, disassembling the received response structure body to obtain a final execution result, and transmitting the final execution result to a proxy layer. And finally, the agent layer acquires an execution result of the preset package plug-in. Here, the proxy service is understood as a service type included in the call request information executed by the server. The information transmission is based on a JCE protocol, which is a binary system-based custom protocol. The protocol is the bottom-most part of the framework, and based on the JCE protocol, each interface defines a request structure and a response structure to perform the calling process.
207. And sending the execution result to a service layer and outputting the result.
After the agent layer obtains the final execution result of the preset package plug-in, the final execution result is sent to the service layer and output to obtain the final execution result.
For example, when the call request information requests to start music, the mobile terminal sends the call request information to a remote server through a preset package plug-in to obtain an execution result, and the execution result is sent to a service layer. The service layer obtains the final execution result and outputs the final result, and the output result is finally the starting music application.
In some embodiments, a schematic diagram of generating a preset package insert for different traffic types is shown in fig. 3. When the service type is service 1, the components to be called corresponding to the service 1 are component A, component B, component C and component D, so that the component A, component B, component C and component D are respectively obtained from a calling component template pool, and the preset package plug-in of the service 1 is obtained by assembling. When another service type is acquired as service 2, the components to be called corresponding to service 2 are component E, component F, component H and component C. Since the component C is multiplexed for both of the two different service types for the component C in which the same function is implemented, the repeated development of codes is reduced.
In some embodiments, when the service type is changed, if the function to be implemented by the service is changed, the preset package plug-in of the service type may also be changed. As shown in fig. 4, the service type is service 1, and the preset package plug-in of service 1 includes a component a, a component B, a component C and a component D for the functions required to be implemented by service 1. When the service type is changed to service 3, the functions required for the service are changed at this time. The components that are to be invoked are also changed for the functions that are to be implemented by service 3. In order to ensure that the original preset package plug-in is not influenced to be called after the service type is changed into the service 3, the preset package plug-in is updated. Specifically, the service type is changed from service 1 to service 3, the function required to be realized by the changed service 3 is determined, and the changed component G, component F, component H and component C are determined according to the function required to be realized by the service 3. And assembling the changed component G, the component F, the component H and the component C into a preset package plug-in of the service 3. When the service type is changed to service 3, as compared with service 1, component C is multiplexed in the changed service 3.
In some embodiments, when the version changes, for example, when the service version deployed by the service layer is upgraded, the functions that can be implemented before and after the upgrade for the same service type are different, and the specific implemented function changes may include cases of adding a function, deleting a function, replacing a function, and the like. Specifically, the service type is service 1, and the corresponding preset package plug-in includes component a, component B, component C and component D. When the version is upgraded, three changes may occur, namely adding, deleting or replacing the functions required to be implemented by the service 1.
1) When the function of service 1 is added, as shown in fig. 5.
When the service 1 is updated from the first version to the second version, a is a preset package plug-in of the service 1 of the first version, and b is a preset package plug-in of the service 1 of the second version. The service 1 is added with a data processing function, and components with the data processing function are correspondingly added in a preset package plug-in. For the first version of service 1, the components needed in implementing the call function include component a, component B, component C, and component D. Because the second version of service 1 is added with the data processing function, the original preset package plug-in is not influenced by the addition of the data processing function part to ensure that the service 1 can still normally call the preset package plug-in and update the preset package plug-in. Specifically, the function corresponding to the service 1 is changed, and a new data processing function can be realized. Determining a data processing function required to be realized by the upgraded service 1, determining a newly added component E according to the realized data processing function, and assembling the newly added component E with an original preset package plug-in, thereby obtaining the preset package plug-in corresponding to the service 1 of the second version. The updated preset package plug-in comprises a component A, a component B, a component D, a component E and a component C. Compared with service 1 before version upgrade, service 1 after version upgrade adds component E. And adding the component E into the preset package plug-in of the service 1 to obtain the preset package plug-in of the service 1 after version upgrading.
2) When the function of service 1 is deleted, as shown in fig. 6.
After the service 1 is upgraded from the first version to the second version, a in fig. 6 is a preset package plug-in of the first version service 1, and b is a preset package plug-in of the second version service 1. Service 1 no longer requires implementation of voice functions, and components of voice functions are deleted correspondingly in preset package plug-ins. For the service 1 of the first version, the components needed when the calling function is realized comprise a component A, a component B, a component C and a component D, and the voice function is realized by the component C in the original preset package plug-in unit because the voice function is deleted by the service 1 of the second version. In order to ensure that the service 1 of the second version does not influence the calling of the original preset package plugin due to the deletion of the voice function part, the service 1 is ensured to still normally call the preset package plugin, and the plugin is updated. Specifically, the function corresponding to service 1 changes, and the voice function is no longer realized. Determining the deleted voice function of the second version of service 1, determining the component C to be deleted according to the deleted voice function, deleting the component C in the original preset package plug-in, and thus obtaining the preset package plug-in corresponding to the updated service 1. The preset package plug-in of the updated service 1 comprises a component A, a component B and a component D. Compared with the version before the upgrade, the service 1 after the upgrade deletes the component C. And deleting the component C from the preset package plug-in of the original service 1 to obtain the preset package plug-in of the service 1 after version upgrading.
3) When replacing the functionality of service 1, as shown in fig. 7.
After the service 1 is upgraded from the first version to the second version, a in fig. 7 is a preset package plug-in of the first version service 1, and b is a preset package plug-in of the second version service 1. The voice function of the service 1 is improved, and components of the voice function are correspondingly replaced in a preset package plug-in. Aiming at the obligation 1 of the first version, the components needed when the calling function is realized comprise a component A, a component B, a component C and a component D, and as the voice function of the service 1 of the second version is improved, the component C in the original preset package plug-in realizes the voice function. In order to ensure that the updated service 1 does not influence the calling of the original preset package plug-in due to the improvement of the voice function part, the service 1 can still normally call the preset package plug-in, and the plug-in is updated. Specifically, the corresponding function of the service 1 is changed correspondingly, and the voice function in the original preset package plug-in is improved. And determining an improved voice function of the upgraded service 1, determining a component C to be replaced according to the voice function to be improved, and replacing the component C in the original preset package plug-in unit with the component E, thereby obtaining the preset package plug-in unit corresponding to the upgraded service 1. The preset package plug-in of the updated service 1 comprises a component A, a component B, a component D and a component E. In service 1 after the version upgrade, component C is replaced with component E, compared to service 1 before the version upgrade. And replacing the component C in the original service 1 with the component E to obtain the preset package plug-in of the service 1 after version upgrading.
Compared with the existing mechanism, in the embodiment of the application, when the call request information of the user is received, the validity of the call request information is checked at the service layer, and the call request information is sent to the proxy layer. And configuring a data object according to the call request information at the proxy layer, calling a preset package plug-in according to the data object, acquiring an execution result of the preset package plug-in, and finally transmitting the execution result to a service layer and outputting the execution result. According to the scheme, the interface calling code is packaged into the plug-in capable of being utilized for many times, so that calling details are packaged, decoupling of general logic and interface logic is achieved, code redundancy is reduced, meanwhile, the plug-in can be reused to adapt to different development environments, and development efficiency and project code maintainability can be improved.
The plurality of mobile terminals in the embodiments of the present application may form a system based on a communication protocol. The system according to the embodiments of the present application may be a distributed system formed by connecting a client and a plurality of nodes (any form of computing device in an access network, such as a server and a user terminal) through a form of network communication.
Taking the distributed system as an example of a blockchain system, referring To fig. 8, fig. 8 is a schematic diagram of an alternative architecture of the distributed system 800 applied To the blockchain system according To the embodiment of the present application, where the architecture is formed by a plurality of nodes (arbitrary computing devices in an access network, such as servers and user terminals) and clients, and a Peer-To-Peer (P2P) network is formed between the nodes, and the P2P protocol is an application layer protocol running on top of a transmission control protocol (Transmission Control Protocol, TCP) protocol. In a distributed system, any machine, such as a server, a terminal, may join to become a node, including a hardware layer, an intermediate layer, an operating system layer, and an application layer.
Referring to the functionality of each node in the blockchain system shown in fig. 8, the functions involved include:
1) The routing, the node has basic functions for supporting communication between nodes.
Besides the routing function, the node can also have the following functions:
2) The application is used for being deployed in a block chain to realize specific service according to actual service requirements, recording data related to the realization function to form recorded data, carrying a digital signature in the recorded data to represent the source of task data, sending the recorded data to other nodes in the block chain system, and adding the recorded data into a temporary block when the source and the integrity of the recorded data are verified by the other nodes.
For example, the services implemented by the application include:
2.1 A service layer for verifying validity of call request information received from other nodes; sending the verification result to other nodes in the block chain system when the verification result is legal; and generating error information when the verification result is illegal.
2.2 A proxy layer for configuring a service name, a request structure, and a response structure, generating a data object, and transmitting the generated data object to other nodes in the blockchain system.
2.3 The package plug-in is used for assembling the received call request information into a request structure body, sending the request structure body to the server, receiving the response structure body executed by the server, disassembling the response structure body to generate json objects, and obtaining the execution result of the final call request.
3) The blockchain comprises a series of blocks (Bloc k) which are connected with each other according to the generated sequence time, the new blocks are not removed once being added into the blockchain, and record data submitted by nodes in the blockchain system are recorded in the blocks.
Referring to fig. 9, fig. 9 is an optional Block Structure (Block Structure) provided in the embodiment of the present application, where each Block includes a hash value of a transaction record stored in the Block (hash value of the Block) and a hash value of a previous Block, and each Block is connected by the hash value to form a Block chain. In addition, the block may include information such as a time stamp at the time of block generation. The Blockchain (Blockchain), which is essentially a de-centralized database, is a string of data blocks that are generated in association using cryptographic methods, each of which contains associated information that is used to verify the validity (anti-counterfeiting) of its information and to generate the next block.
Any technical features mentioned in the embodiments corresponding to any one of fig. 1a to fig. 7 are also applicable to the embodiments corresponding to fig. 10 and fig. 11 in the present application, and the following similar parts will not be repeated.
The above describes an interface calling method in the embodiments of the present application, and the following describes an apparatus for executing the interface calling method in the embodiments of the present application.
Referring to fig. 10, a schematic structural diagram of an interface calling device shown in fig. 10 is shown, and the interface calling device can be applied to front-end development, call a background interface, and the like. The device in the embodiment of the present application can implement the steps corresponding to the interface calling method performed in the embodiment corresponding to fig. 2. The functions implemented by the device can be implemented by hardware, or can be implemented by executing corresponding software by hardware. The hardware or software includes one or more modules corresponding to the functions described above, which may be software and/or hardware. The device may include an input/output module 1001, a verification module 1002, and a processing module 1003, and the interface calling device may perform the steps in the interface calling method as performed in the embodiment corresponding to fig. 2, as follows:
the input/output module 1001 is configured to receive call request information of a user;
wherein the invocation request information is typically triggered by the user through a user interface component. Specifically, the user may trigger a call request behavior at the user interface component, where the call request behavior includes call request information, which is received by the input output module 1001.
In some implementations, the call request information can include an identification of the communication protocol, an application version number, a request identification, a serialization manner, reserved bytes, a request ID, and the like.
A verification module 1002, configured to verify, at a service layer, validity of the call request information received by the input/output module;
the input/output module 1001 is further configured to send the call request information to the processing module 1003 after the verification module 1002 verifies the validity of the call request information received by the input/output module, so that the processing module 1003 performs a subsequent operation according to the call request information.
And a processing module 1003, configured to configure a data object according to the call request information. Specifically, after receiving the legal call request information checked by the checking module 1002, the processing module 1003 configures a service name, a request structure body and a response structure body, and generates a json data object according to the configured service name, the request structure body and the response structure body.
The processing module 1003 is further configured to generate a preset package plug-in according to the data object before the preset package plug-in is invoked according to the data object. Specifically, the processing module 1003 determines, according to the data object, a service type of the service to be processed corresponding to the call request information. After the service type of the service to be processed is obtained, determining an interface to be called according to the service type of the service to be processed, acquiring a plurality of calling component templates according to the interface to be called, and finally assembling the plurality of calling component templates to generate a preset package plug-in. The calling component template is constructed in advance according to the service type.
After the data object is configured, the processing module 1003 invokes a preset package plug-in according to the data object; acquiring an execution result of a preset package plug-in through the input/output module 1001; the execution result is sent to a service layer through the input/output module 1001 and output.
In some embodiments, the processing module 1003 is further configured to construct a calling component template according to the service type before the obtaining a plurality of calling component templates according to the interface to be called.
The specific implementation process of the preset package plug-in comprises the following steps: according to the data object, namely, the processing module 1003 configures a request structure body, a response structure body and a service name of an interface, encapsulates the call request information according to the json format data object generated by the above, and assembles the encapsulated call request information into a request structure body; the assembled request structure is proxied to proxy service through the service name, the data is finally acquired, namely, the response structure sent after the execution is completed, the received response structure is disassembled, the final execution result is obtained, and the final execution result is transmitted to the processing module 1003. The processing module 1003 finally obtains the execution result of the preset package insert.
Compared to the existing mechanism, in the embodiment of the present application, the processing module 1003 logically extracts the preset package plug-in from the calling code. When the processing module receives the call request information through the input/output module 1001, the call request information is sent to the server through the preset package plug-in, and the final execution result is obtained and output through the input/output unit. According to the scheme, the interface calling code is packaged into the plug-in capable of being used for multiple times, so that calling details are packaged, the processing module 1003 can repeatedly use the packaged preset package plug-in, decoupling of general logic and interface logic is achieved, code redundancy is reduced, meanwhile, the plug-in can be repeatedly used to adapt to different development environments, and development efficiency and project code maintainability can be improved.
The interface calling device in the embodiment of the present application is described above from the viewpoint of a modularized functional entity, and the interface calling device in the embodiment of the present application is described below from the viewpoint of hardware processing, respectively. The embodiment of the application further provides a computer device, as shown in fig. 11, which shows a schematic structural diagram of the computer device designed by the application, specifically:
Fig. 11 is a schematic structural diagram of a computer device provided in an embodiment of the present application, where the computer device may have a relatively large difference due to configuration or performance, and may include one or more processors 1103 (e.g., one or more central processing units) and memory 1102 (e.g., one or more mass storage devices). Wherein the memory 1102 may be transient storage or persistent storage. The program stored in the memory 1102 may include one or more modules (not shown), each of which may include a series of instruction operations on the server. Still further, the processor 1103 may be arranged to communicate with the memory 1102 and execute a series of instruction operations in the memory 1102 on a computer device.
The computer device may also include one or more input-output units 1101; although not shown, the computer device may also include one or more power supplies, one or more wired or wireless network interfaces, and/or one or more operating systems, such as Windows Server, mac OS X, unix, linux, freeBSD, etc., which are not described in detail herein. The steps performed by the computer device in the above embodiments may be based on the computer device structure shown in fig. 11. In particular, in this embodiment, the processor 1103 in the computer device loads executable files corresponding to the processes of one or more application programs into the memory 1102 according to the following instructions, and the processor 1103 executes the application programs stored in the memory 1102, so as to implement various functions as follows:
Receiving call request information of a user through the input-output unit 1101; verifying the validity of the call request information; configuring a data object according to the call request information; invoking a preset package plug-in according to the data object; acquiring an execution result of a preset package plug-in; the execution result is output through the input-output unit 1101.
It should be noted that, in the embodiment of the present application, the apparatus shown in fig. 10 may have a structure shown in fig. 11, the physical device corresponding to the input/output module 1001 in the embodiment of fig. 10 may be the input/output unit 1101, and the physical device corresponding to the verification module 1002 and the processing module 1003 in the embodiment of fig. 10 may be the processor 1103. The input/output unit 1101 and the processor 1103 can implement the same or similar functions as the input/output module 1001, the verification module 1002 and the processing module 1003 provided in the foregoing device embodiment corresponding to the device, and the memory 1102 stores a computer program to be invoked when the processor executes the interface invoking method described above.
In the foregoing embodiments, the descriptions of the embodiments are emphasized, and for parts of one embodiment that are not described in detail, reference may be made to related descriptions of other embodiments.
It will be clearly understood by those skilled in the art that, for convenience and brevity of description, the specific working processes of the systems, apparatuses and modules described above may refer to the corresponding processes in the foregoing method embodiments, which are not repeated herein.
In the embodiments provided in the present application, it should be understood that the disclosed method, apparatus, and computer device may be implemented in other manners. For example, the apparatus embodiments described above are merely illustrative, and for example, the division of the modules is merely a logical function division, and there may be additional divisions when actually implemented, for example, multiple modules or components may be combined or integrated into another system, or some features may be omitted or not performed. Alternatively, the coupling or direct coupling or communication connection shown or discussed with each other may be an indirect coupling or communication connection via some interfaces, devices or modules, which may be in electrical, mechanical, or other forms.
The modules described as separate components may or may not be physically separate, and components shown as modules may or may not be physical modules, i.e., may be located in one place, or may be distributed over a plurality of network modules. Some or all of the modules may be selected according to actual needs to achieve the purpose of the solution of this embodiment.
In addition, each functional module in each embodiment of the present application may be integrated into one processing module, or each module may exist alone physically, or two or more modules may be integrated into one module. The integrated modules may be implemented in hardware or in software functional modules. The integrated modules, if implemented in the form of software functional modules and sold or used as a stand-alone product, may be stored in a computer readable storage medium.
In the above embodiments, it may be implemented in whole or in part 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 the computer program is loaded and executed on a computer, the flow or functions described in accordance with embodiments of the present application are fully or partially produced. The computer may be a general purpose computer, a special purpose computer, a computer network, or other programmable apparatus. The computer instructions may be stored in a computer-readable storage medium or transmitted from one computer-readable storage medium to another computer-readable storage medium, for example, the computer instructions may be transmitted from one website, computer, server, or data center to another website, computer, server, or data center by a wired (e.g., coaxial cable, fiber optic, digital Subscriber Line (DSL)) or wireless (e.g., infrared, wireless, microwave, etc.). The computer readable storage medium may be any available medium that can be stored by a computer or a data storage device such as a server, data center, etc. that contains an integration of one or more available media. The usable medium may be a magnetic medium (e.g., floppy Disk, hard Disk, magnetic tape), an optical medium (e.g., DVD), or a semiconductor medium (e.g., solid State Disk (SSD)), etc.
The foregoing describes in detail the technical solution provided by the embodiments of the present application, in which specific examples are applied to illustrate the principles and implementations of the embodiments of the present application, where the foregoing description of the embodiments is only used to help understand the methods and core ideas of the embodiments of the present application; meanwhile, as those skilled in the art will have variations in the specific embodiments and application scope according to the ideas of the embodiments of the present application, the present disclosure should not be construed as limiting the embodiments of the present application in view of the above.
Claims (9)
1. An interface calling method, the method comprising:
receiving call request information of a user;
verifying the validity of the call request information at a service layer;
sending the call request information to an agent layer;
at the proxy layer, configuring a data object according to the call request information;
determining the service type of the service to be processed according to the data object;
determining an interface to be called according to the service type;
acquiring a plurality of calling component templates according to the interface to be called;
generating a preset package plug-in according to the plurality of calling component templates;
Invoking a preset package plug-in according to the data object;
acquiring an execution result of the preset package plug-in;
and sending the execution result to the service layer and outputting the execution result.
2. The method of claim 1, wherein prior to the obtaining a plurality of calling component templates from the interface to be called, the method further comprises:
and constructing a calling component template according to the service type.
3. The method according to claim 1, wherein after said determining the service type of the service to be processed from said data object, said method further comprises:
judging whether the service type changes or not;
when the service type changes, determining the changed service type;
determining a calling component to be updated according to the changed service type;
and updating the calling component to be updated to a preset package plug-in.
4. A method according to any one of claims 1 to 3, wherein, at the proxy layer, configuring a data object according to the call request information comprises:
at the proxy layer, configuring a service name, a request structure body and a response structure body according to the calling request information;
And generating the data object according to the service name, the request structure body and the response structure body, wherein the data object is used for bearing data when requesting or responding to the call request information.
5. The method according to claim 4, wherein the calling a preset package plug-in according to the data object, and obtaining an execution result of the preset package plug-in, includes:
assembling the call request information into a request structure body according to the data object and the preset package plug-in;
transmitting the request structure to a server according to the preset package plug-in;
calling an interface protocol service proxy to the telecommunication terminal service according to the association relation between the service name and the telecommunication terminal service at the proxy layer;
acquiring a response structure body generated by the server based on the request structure body according to the preset package plug-in;
analyzing the response structure body according to the preset package plug-in, disassembling the response structure body into a script object, and taking the script object as the execution result.
6. The method according to claim 1, wherein the method further comprises:
and setting service logic of each calling interface according to the service type at the service layer.
7. The method of claim 1, wherein the results of execution of the interface call are maintained on a blockchain node.
8. An interface calling device, the device comprising:
the input/output module is used for receiving call request information of a user;
the verification module is used for verifying the validity of the call request information received by the input/output module at a service layer;
the input/output module is also used for sending the call request information to the proxy layer;
the processing module is used for configuring a data object according to the calling request information at the proxy layer; determining the service type of the service to be processed according to the data object; determining an interface to be called according to the service type; acquiring a plurality of calling component templates according to the interface to be called; generating a preset package plug-in according to the plurality of calling component templates; invoking a preset package plug-in according to the data object; acquiring an execution result of the preset package plug-in through the input/output module; and sending the execution result to a service layer through the input and output module and outputting the execution result.
9. A computer device comprising a transceiver, a memory, and a processor; the memory stores an application program, and the processor is configured to execute the application program in the memory to perform the operations in the interface calling method of any one of claims 1 to 7.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201911307130.9A CN112988409B (en) | 2019-12-18 | 2019-12-18 | Interface calling method and device, computer equipment and storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201911307130.9A CN112988409B (en) | 2019-12-18 | 2019-12-18 | Interface calling method and device, computer equipment and storage medium |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN112988409A CN112988409A (en) | 2021-06-18 |
| CN112988409B true CN112988409B (en) | 2024-01-30 |
Family
ID=76343800
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201911307130.9A Active CN112988409B (en) | 2019-12-18 | 2019-12-18 | Interface calling method and device, computer equipment and storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN112988409B (en) |
Families Citing this family (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN114374727B (en) * | 2022-01-13 | 2024-04-02 | 平安付科技服务有限公司 | Data calling method and device based on artificial intelligence, electronic equipment and medium |
| CN114489850B (en) * | 2022-01-20 | 2023-08-22 | 中广核工程有限公司 | Calling method and device of design software, computer equipment and storage medium |
| CN114721745B (en) * | 2022-05-24 | 2022-10-25 | 统信软件技术有限公司 | Method and device for loading and using local plug-in by browser and computing equipment |
Citations (7)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN102681854A (en) * | 2012-05-18 | 2012-09-19 | 华为技术有限公司 | Service execution method, server and computer system |
| CN103812873A (en) * | 2014-03-03 | 2014-05-21 | 华为软件技术有限公司 | Business service request processing method and device |
| WO2017054531A1 (en) * | 2015-09-30 | 2017-04-06 | 中兴通讯股份有限公司 | Yang model-based compiling method, and corresponding interface, component, and system |
| CN109474759A (en) * | 2018-10-24 | 2019-03-15 | 咪咕音乐有限公司 | Information processing method, device and storage medium |
| CN109582303A (en) * | 2018-10-31 | 2019-04-05 | 平安科技（深圳）有限公司 | General purpose module call method, device, computer equipment and storage medium |
| CN109739573A (en) * | 2018-12-27 | 2019-05-10 | 深圳市多度科技有限公司 | Realize the processing method and processing device that api interface calls, the system for realizing api interface |
| CN110298769A (en) * | 2019-06-13 | 2019-10-01 | 浙江口碑网络技术有限公司 | The processing method for service request of ordering, apparatus and system |
-
2019
- 2019-12-18 CN CN201911307130.9A patent/CN112988409B/en active Active
Patent Citations (7)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN102681854A (en) * | 2012-05-18 | 2012-09-19 | 华为技术有限公司 | Service execution method, server and computer system |
| CN103812873A (en) * | 2014-03-03 | 2014-05-21 | 华为软件技术有限公司 | Business service request processing method and device |
| WO2017054531A1 (en) * | 2015-09-30 | 2017-04-06 | 中兴通讯股份有限公司 | Yang model-based compiling method, and corresponding interface, component, and system |
| CN109474759A (en) * | 2018-10-24 | 2019-03-15 | 咪咕音乐有限公司 | Information processing method, device and storage medium |
| CN109582303A (en) * | 2018-10-31 | 2019-04-05 | 平安科技（深圳）有限公司 | General purpose module call method, device, computer equipment and storage medium |
| CN109739573A (en) * | 2018-12-27 | 2019-05-10 | 深圳市多度科技有限公司 | Realize the processing method and processing device that api interface calls, the system for realizing api interface |
| CN110298769A (en) * | 2019-06-13 | 2019-10-01 | 浙江口碑网络技术有限公司 | The processing method for service request of ordering, apparatus and system |
Also Published As
| Publication number | Publication date |
|---|---|
| CN112988409A (en) | 2021-06-18 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN109995713B (en) | Service processing method in micro-service framework and related equipment | |
| CN112988409B (en) | Interface calling method and device, computer equipment and storage medium | |
| US6757899B2 (en) | Dynamic CORBA gateway for CORBA and non-CORBA clients and services | |
| US6804816B1 (en) | Method and template for developing device-centric network management applications | |
| CN110032392B (en) | Service management method and device, storage medium and electronic equipment | |
| CN111600909A (en) | Data processing method, device, protocol conversion equipment and storage medium | |
| WO2001033381A9 (en) | Shared internet storage resource, user interface system, and method | |
| US10817284B2 (en) | Melding of mediation flow service component architecture (SCA) components | |
| US8250226B2 (en) | Generating one or more clients for generating one or more synthetic transactions with one or more web service operations | |
| US20030055862A1 (en) | Methods, systems, and articles of manufacture for managing systems using operation objects | |
| US20170270157A1 (en) | TCP/IP Network Automation and Orchestration Tools | |
| CN113010378B (en) | Log processing method and device of microservice module, storage medium and electronic device | |
| US20210344766A1 (en) | Systems and methods for decentralization of blockchain-based processes employing a blockchain-associated front end or blockchain-associated user interface | |
| CN113434175B (en) | Data processing method, device, storage medium and equipment | |
| US20090037829A1 (en) | Framework to integrate web services with on-premise software | |
| CN111367685B (en) | Interface calling method and device, computer equipment and storage medium | |
| CN113296987B (en) | Interface calling method and device for calling module, computer equipment and storage medium | |
| WO2009033424A1 (en) | A method and system for obtaining information of user's commands and device for registering user's commands | |
| CN114610598A (en) | Test method, test device, electronic equipment and computer readable storage medium | |
| Scherfke | aiomas Documentation | |
| CN113973139A (en) | Message processing method and device | |
| CN118092982B (en) | Multi-cluster operation and maintenance method, equipment and medium for cloud native application | |
| US11966719B2 (en) | Event consumption for high-level programing language platform | |
| CN114398082B (en) | Compatible operation method and device for frame type block chain application | |
| US20240036946A1 (en) | Event provisioning for high-level programing language platform |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |