CN112130817A - Multi-version interface implementation method, system, device and readable storage medium - Google Patents
Multi-version interface implementation method, system, device and readable storage medium Download PDFInfo
- Publication number
- CN112130817A CN112130817A CN202010923086.0A CN202010923086A CN112130817A CN 112130817 A CN112130817 A CN 112130817A CN 202010923086 A CN202010923086 A CN 202010923086A CN 112130817 A CN112130817 A CN 112130817A
- Authority
- CN
- China
- Prior art keywords
- version
- interface
- server
- client
- attribute
- 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.)
- Withdrawn
Links
- 238000000034 method Methods 0.000 title claims abstract description 82
- 238000004891 communication Methods 0.000 claims abstract description 47
- 239000000344 soap Substances 0.000 claims abstract description 17
- 230000007246 mechanism Effects 0.000 claims description 20
- 230000008569 process Effects 0.000 claims description 12
- 238000004590 computer program Methods 0.000 claims description 10
- 230000006870 function Effects 0.000 claims description 7
- 238000004806 packaging method and process Methods 0.000 claims description 4
- 238000003032 molecular docking Methods 0.000 description 6
- 230000009471 action Effects 0.000 description 3
- 238000010586 diagram Methods 0.000 description 2
- 238000005516 engineering process Methods 0.000 description 2
- 230000008859 change Effects 0.000 description 1
- 238000005538 encapsulation Methods 0.000 description 1
- 230000008520 organization Effects 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/20—Software design
- G06F8/24—Object-oriented
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/60—Software deployment
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
- G06F8/71—Version control; Configuration management
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Computer Security & Cryptography (AREA)
- Stored Programmes (AREA)
Abstract
The application discloses a multi-version interface implementation method, a system and related components, which are applied to a client, wherein the multi-version interface implementation method comprises the following steps: acquiring interface information disclosed by a server, wherein the interface information comprises a data structure and an interface method of a support version of the server; determining a negotiated version according to the interface information and the supported version of the client; establishing communication with the server according to the negotiated version; the interface information is organized into packages in the form of soap and xml and is published through the wsdl language, and a package program and a decapsulation program of the interface information are determined through base classes and inheritance. The method and the system for realizing the multi-version interface package encapsulate the differentiated data structures and the interface methods among different versions based on the soap protocol, determine the negotiated versions supporting the client and the server in a plurality of versions, solve the problem of realizing the multi-version interface, greatly reduce the workload of development and facilitate deployment.
Description
Technical Field
The invention relates to the field of software development, in particular to a method, a system and a device for realizing a multi-version interface and a readable storage medium.
Background
Currently, software development generally adopts a fast iteration method, and with continuous update and change of customer requirements, the final delivery version of the software may be updated more than the initial version. The interface is a bridge connected with different software systems, and for a specific software release version, the interface is relatively stable, but the interface can also be changed along with the upgrade of the software version, and the original interface is not suitable any more.
In development and docking, how to simplify and unify interfaces of different versions is a relatively difficult problem, a traditional method generally develops a set of software for different interface versions, and the implementation mechanism often increases development workload and difficulty in deployment and docking of a software system.
Therefore, how to provide a solution to the above technical problems is a problem to be solved by those skilled in the art.
Disclosure of Invention
In view of the above, the present invention provides a method, a system, a device and a readable storage medium for implementing a multi-version interface, so as to solve the problems of large workload and difficult deployment in development and docking of the multi-version interface. The specific scheme is as follows:
a multi-version interface implementation method is applied to a client, and comprises the following steps:
acquiring interface information disclosed by a server, wherein the interface information comprises a data structure and an interface method of a support version of the server;
determining a negotiated version according to the interface information and the supported version of the client;
establishing communication with the server according to the negotiated version;
the interface information is organized into packages in the form of soap and xml and is issued through the wsdl language, and a package program and a decapsulation program of the interface information are determined through base classes and inheritance.
Preferably, the determining a negotiated version according to the interface information and the supported version of the client specifically includes:
comparing the support version of the server side in the interface information with the support version of the client side, and determining a support version set of the server side and the client side;
and determining the highest version in the supported version set as the negotiated version.
Preferably, the packaging procedure includes:
constructing an output element in the form of a name space and a name, and simultaneously updating the whole name space so as to add the name space of the output element into a functional domain;
if the attribute is null or not necessary, returning a null element;
if the attribute is the basic type, setting an attribute value and outputting an element;
if the attribute is the data packaging type, the packaging program is called recursively. Preferably, the decapsulation procedure includes:
traversing the attribute list of the decapsulated object in sequence;
determining a complete attribute name for each attribute list value according to the name space and xmltag of the attribute list value;
if the attribute value of the attribute list value is a list, sequentially traversing the list and executing the same single attribute value operation on each attribute value in the list;
the single attribute value operation includes:
if the attribute value is a basic attribute, converting the character into a specific value according to the basic attribute;
if the attribute value is a structure attribute, the decapsulation program is called recursively.
Preferably, the data structure and the domain name of the interface method include corresponding version-supported functions and version information.
Preferably, the process of establishing communication with the server according to the negotiated version includes:
and sending registration information to the server, wherein the registration information comprises the negotiated version and a corresponding interface implementation entrance, so that the server establishes a communication mechanism with the client through the interface implementation entrance.
Preferably, the process of the server establishing a communication mechanism with the client by the portal through the interface includes:
and the server side uses the certificate of the client side to realize that the entrance establishes a communication mechanism with the client side through the interface.
Correspondingly, this application discloses many versions interface implementation system, is applied to the customer end, many versions interface implementation system includes:
the system comprises an acquisition module, a storage module and a processing module, wherein the acquisition module is used for acquiring interface information disclosed by a server, and the interface information comprises a data structure and an interface method of a support version of the server;
the version determining module is used for determining the negotiated version according to the interface information and the supported version of the client;
and the communication establishing module is used for establishing communication with the server according to the negotiated version.
Correspondingly, this application still discloses a many versions interface realizes device, includes:
a memory for storing a computer program;
a processor for implementing the steps of the multi-version interface implementation method as claimed in any one of the above when executing the computer program.
Accordingly, the present application also discloses a readable storage medium having stored thereon a computer program which, when executed by a processor, implements the steps of the multi-version interface implementation method as described in any of the above.
The application discloses a multi-version interface implementation method, which is applied to a client and comprises the following steps: acquiring interface information disclosed by a server, wherein the interface information comprises a data structure and an interface method of a support version of the server; determining a negotiated version according to the interface information and the supported version of the client; establishing communication with the server according to the negotiated version; the interface information is organized into packages in the form of soap and xml and is issued through the wsdl language, and a package program and a decapsulation program of the interface information are determined through base classes and inheritance. The method and the system for realizing the multi-version interface package based on the soap protocol encapsulate different versions of differentiated data structures and interface methods, determine the version after negotiation which supports both the client and the server in a plurality of versions according to the support version in the interface information disclosed by the server and the support version of the client, and communicate by using the version after negotiation, thereby solving the realization problem of the multi-version interface, greatly reducing the development workload and facilitating the deployment.
Drawings
In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings used in the description of the embodiments or the prior art will be briefly described below, it is obvious that the drawings in the following description are only embodiments of the present invention, and for those skilled in the art, other drawings can be obtained according to the provided drawings without creative efforts.
FIG. 1 is a flowchart illustrating steps of a method for implementing a multi-version interface according to an embodiment of the present invention;
FIG. 2 is a block diagram of a multi-version interface implementation system according to an embodiment of the present invention;
fig. 3 is a structural distribution diagram of a multi-version interface implementation apparatus according to an embodiment of the present invention.
Detailed Description
The technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the drawings in the embodiments of the present invention, and it is obvious that the described embodiments are only a part of the embodiments of the present invention, and not all of the embodiments. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present invention.
In development and docking, how to simplify and unify interfaces of different versions is a relatively difficult problem, a traditional method generally develops a set of software for different interface versions, and the implementation mechanism often increases development workload and difficulty in deployment and docking of a software system.
The method and the system for realizing the multi-version interface package based on the soap protocol encapsulate different versions of differentiated data structures and interface methods, determine the version after negotiation which supports both the client and the server in a plurality of versions according to the support version in the interface information disclosed by the server and the support version of the client, and communicate by using the version after negotiation, thereby solving the realization problem of the multi-version interface, greatly reducing the development workload and facilitating the deployment.
The embodiment of the invention discloses a multi-version interface implementation method, which is applied to a client and comprises the following steps of:
s1: acquiring interface information disclosed by a server, wherein the interface information comprises a data structure and an interface method of a support version of the server;
specifically, the interface information of the server is generally organized and encapsulated in the form of soap and xml, and is published in the wsdl language, including differentiated data structures and interface methods between different versions. The domain name of the data structure and the interface method comprises corresponding version supporting function and version information.
Taking the encapsulation of the data structure as an example, the whole data structure is organized in the form of soap + xml, which is convenient for programming development, and the data structure utilizes the domain name: name "to define the data structure name and its attribute name, the domain name of the functional domain is described in function + version information, for example:
http://data.func.example.company.com/xsd/2.0；
before representing, a functional domain complete set comprising all domain names needs to be determined, a name space is designated according to the functional domains, attribute names are uniquely determined by combining the functional domain names with the attribute names, the attribute names under the same functional domain are not repeatable, and the attribute names under different functional domains are repeatable; meanwhile, the value range of the attribute is to be given in packaging, the value range includes a maximum value, a minimum value, whether the attribute can be empty or not, whether the attribute is a list or not, and the organization form of the data structure is as follows:
< domain name 0: structure name >
< domain name 1: attribute aa </Domain name 1: attribute a >
< domain name 1: attribute bb </domain name 1: attribute b >
< domain name 2: attribute c >
< domain name 1: attribute dd </Domain name 1: attribute d >
< domain name 3: attribute ee </Domain name e: attribute e >
</Domain name 2: attribute c >
</Domain name 0: structure name >
Similarly, the interface method may be encapsulated according to the above form, and the structure name may be replaced by a method name, and the attribute name may be replaced by a method parameter.
Further, both the encapsulation program and the decapsulation program of the interface information are determined by the base class and the inheritance, that is, the representation from the general data to the specific data is realized by the method of the base class plus the inheritance, specifically:
realizing a name space (corresponding to a functional domain in a representation method of interface information), xmltag (corresponding to a method name or a structure name in a representation method of interface information), and an attribute list (each value in the list corresponds to one attribute or one parameter in the representation method of interface information) in a base class; by means of inheritance, the specific data is provided with a namespace, xmltag and an attribute list and is specified according to the characteristics of the specific data. Furthermore, a packaging program and a decapsulating program can be implemented in the base class, wherein the packaging program is used for writing data into the data package, and the decapsulating program is used for parsing the data out of the package.
S2: determining a negotiated version according to the interface information and the supported version of the client;
specifically, step S2 includes: comparing the support version of the server in the interface information with the support version of the client to determine a support version set of the server and the client; and determining the highest version in the supported version set as the negotiated version.
It can be understood that, to implement interface docking, the version used by the server and the version used by the client must be unified during communication, and according to the interface information disclosed in step S1, it can be known which supported versions of the server exist, and the supported versions of the client are consistent at the client, so that step S2 compares the supported versions of the client and the server, and a set of supported versions supported by both can be obtained, from which the highest version is determined as the negotiated version. In particular implementations, the following may occur:
the method comprises the steps that firstly, the highest support version of a client is lower than that of a server, the highest support version supported by the client is determined as a negotiated version, and the server is ensured not to send a data structure of a version higher than the negotiated version to the client;
secondly, the highest support version of the server is lower than that of the client, the highest support version supported by the server is determined as a negotiated version, and the client is ensured not to return a data structure of a version higher than the negotiated version to the server;
and thirdly, there is no intersection between the versions supported by the server and the client, that is, the version set is zero, and at this time, there is no negotiated version, and the client and the server cannot establish communication.
S3: and establishing communication with the server according to the negotiated version.
Specifically, step S3 includes:
and sending registration information to the server, wherein the registration information comprises the negotiated version and the corresponding interface realization entrance, so that the server establishes a communication mechanism with the client through the interface realization entrance.
The client can set an interface in the client to realize the relationship between the entry and the support versions, so that all the support versions can be realized by one interface, and different support versions can be realized by a plurality of interfaces, and the description is given when the registration information is sent to the server, specifically as follows:
< one terminal implementation >
/path/to/endpointAll
[ one terminal implementation ]
< multiple terminal implementation >
/path1/to/endpointV1
/path2/to/endpointV2
[ multiple terminal implementation ]
The process that the server side establishes a communication mechanism between the entrance and the client side through the interface comprises the following steps:
the server side uses the client-side certificate to realize that the entrance establishes a communication mechanism with the client side through the interface.
The client credentials are typically user name and password credentials, but may be in other forms.
The application discloses a multi-version interface implementation method, which is applied to a client and comprises the following steps: acquiring interface information disclosed by a server, wherein the interface information comprises a data structure and an interface method of a support version of the server; determining a negotiated version according to the interface information and the supported version of the client; and establishing communication with the server according to the negotiated version. According to the method and the device, the negotiated versions of the client and the server are determined in the multiple versions according to the support version of the client and the support version of the server in the interface information disclosed by the server, and the negotiated versions are used for communication, so that the problem of realizing the multi-version interface is solved, the workload of development is greatly reduced, and the deployment is convenient.
Correspondingly, the present application discloses a multi-version interface implementation system, which is applied to a client, and as shown in fig. 2, the multi-version interface implementation system includes:
the acquisition module 01 is used for acquiring interface information disclosed by a server, wherein the interface information comprises a data structure and an interface method of a support version of the server;
the version determining module 02 is used for determining the negotiated version according to the interface information and the supported version of the client;
the communication establishing module 03 is used for establishing communication with the server according to the negotiated version;
the interface information is organized into packages in the form of soap and xml and is issued through the wsdl language, and a package program and a decapsulation program of the interface information are determined through base classes and inheritance.
According to the embodiment of the application, the negotiated versions of the client and the server are determined in the multiple versions according to the support version of the client and the support version of the server in the interface information disclosed by the server, and the negotiated versions are used for communication, so that the problem of realizing the multi-version interface is solved, the workload of development is greatly reduced, and the deployment is facilitated.
In some specific embodiments, the version determination module 02 is specifically configured to:
comparing the support version of the server side in the interface information with the support version of the client side, and determining a support version set of the server side and the client side;
and determining the highest version in the supported version set as the negotiated version.
In some specific embodiments, the interface information is encapsulated by the soap protocol and published in the wsdl language.
In some specific embodiments, the data structure and the interface method are both implemented by the soap protocol and xml format.
In some specific embodiments, the domain name of the data structure and the interface method includes corresponding version-supported function and version information.
In some specific embodiments, the communication establishing module 03 is specifically configured to:
and sending registration information to the server, wherein the registration information comprises the negotiated version and a corresponding interface implementation entrance, so that the server establishes a communication mechanism with the client through the interface implementation entrance.
In some specific embodiments, the process of the server establishing a communication mechanism with the client through the portal is implemented by the interface, and includes:
and the server side uses the certificate of the client side to realize that the entrance establishes a communication mechanism with the client side through the interface.
Correspondingly, the present application also discloses a multi-version interface implementation apparatus, which is shown in fig. 3 and includes a processor 11 and a memory 12; wherein the processing 11 implements the following steps when executing the computer program stored in the memory 12:
acquiring interface information disclosed by a server, wherein the interface information comprises a data structure and an interface method of a support version of the server;
determining a negotiated version according to the interface information and the supported version of the client;
and establishing communication with the server according to the negotiated version.
According to the embodiment of the application, the negotiated versions of the client and the server are determined in the multiple versions according to the support version of the client and the support version of the server in the interface information disclosed by the server, and the negotiated versions are used for communication, so that the problem of realizing the multi-version interface is solved, the workload of development is greatly reduced, and the deployment is facilitated.
In some specific embodiments, when the processor 11 executes the computer subprogram stored in the memory 12, the following steps may be specifically implemented:
comparing the support version of the server side in the interface information with the support version of the client side, and determining a support version set of the server side and the client side;
and determining the highest version in the supported version set as the negotiated version.
In some specific embodiments, the interface information is encapsulated by the soap protocol and published in the wsdl language.
In some specific embodiments, the data structure and the interface method are both implemented by the soap protocol and xml format.
In some specific embodiments, the domain name of the data structure and the interface method includes corresponding version-supported function and version information.
In some specific embodiments, when the processor 11 executes the computer subprogram stored in the memory 12, the following steps may be specifically implemented:
and sending registration information to the server, wherein the registration information comprises the negotiated version and a corresponding interface implementation entrance, so that the server establishes a communication mechanism with the client through the interface implementation entrance.
In some specific embodiments, the process of the server establishing a communication mechanism with the client through the portal is implemented by the interface, and includes:
and the server side uses the certificate of the client side to realize that the entrance establishes a communication mechanism with the client side through the interface.
Further, the multi-version interface implementation apparatus in this embodiment may further include:
the input interface 13 is configured to obtain a computer program imported from the outside, store the obtained computer program in the memory 12, and also be configured to obtain various instructions and parameters transmitted by an external terminal device, and transmit the instructions and parameters to the processor 11, so that the processor 11 performs corresponding processing by using the instructions and parameters. In this embodiment, the input interface 13 may specifically include, but is not limited to, a USB interface, a serial interface, a voice input interface, a fingerprint input interface, a hard disk reading interface, and the like.
And an output interface 14, configured to output various data generated by the processor 11 to a terminal device connected thereto, so that other terminal devices connected to the output interface 14 can acquire various data generated by the processor 11. In this embodiment, the output interface 14 may specifically include, but is not limited to, a USB interface, a serial interface, and the like.
And a communication unit 15 for establishing a remote communication connection between the multi-version interface implementing apparatus and the external server so that the multi-version interface implementing apparatus can mount the image file to the external server. In this embodiment, the communication unit 15 may specifically include, but is not limited to, a remote communication unit based on a wireless communication technology or a wired communication technology.
And the keyboard 16 is used for acquiring various parameter data or instructions input by a user through real-time key cap knocking.
And the display 17 is used for displaying relevant information of the multi-version interface implementation process in real time so that a user can know the implementation condition of the current multi-version interface in time.
The mouse 18 may be used to assist the user in entering data and to simplify the user's operation.
Further, embodiments of the present application also disclose a readable storage medium, where the readable storage medium includes Random Access Memory (RAM), memory, Read Only Memory (ROM), electrically programmable ROM, electrically erasable programmable ROM, registers, hard disk, removable hard disk, CD-ROM, or any other form of storage medium known in the art. The readable storage medium has stored therein a computer program which, when executed by a processor, performs the steps of:
acquiring interface information disclosed by a server, wherein the interface information comprises a data structure and an interface method of a support version of the server;
determining a negotiated version according to the interface information and the supported version of the client;
and establishing communication with the server according to the negotiated version.
According to the embodiment of the application, the negotiated versions of the client and the server are determined in the multiple versions according to the support version of the client and the support version of the server in the interface information disclosed by the server, and the negotiated versions are used for communication, so that the problem of realizing the multi-version interface is solved, the workload of development is greatly reduced, and the deployment is facilitated.
In some specific embodiments, when executed by a processor, the computer sub-program stored in the readable storage medium may specifically implement the following steps:
comparing the support version of the server side in the interface information with the support version of the client side, and determining a support version set of the server side and the client side;
and determining the highest version in the supported version set as the negotiated version.
In some specific embodiments, the interface information is encapsulated by the soap protocol and published in the wsdl language.
In some specific embodiments, the data structure and the interface method are both implemented by the soap protocol and xml format.
In some specific embodiments, the domain name of the data structure and the interface method includes corresponding version-supported function and version information.
In some specific embodiments, when executed by a processor, the computer sub-program stored in the readable storage medium may specifically implement the following steps:
and sending registration information to the server, wherein the registration information comprises the negotiated version and a corresponding interface implementation entrance, so that the server establishes a communication mechanism with the client through the interface implementation entrance.
In some specific embodiments, the process of the server establishing a communication mechanism with the client through the portal is implemented by the interface, and includes:
and the server side uses the certificate of the client side to realize that the entrance establishes a communication mechanism with the client side through the interface.
Finally, it should also be noted that, herein, relational terms such as first and second, and the like may be used solely to distinguish one entity or action from another entity or action without necessarily requiring or implying any actual such relationship or order between such entities or actions. Also, the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising an … …" does not exclude the presence of other identical elements in a process, method, article, or apparatus that comprises the element.
The present invention provides a multi-version interface implementation method, system, device and readable storage medium, which have been described in detail above, and the specific examples are applied in this document to illustrate the principle and implementation of the present invention, and the description of the above embodiments is only used to help understanding the method and its core idea of the present invention; meanwhile, for a person skilled in the art, according to the idea of the present invention, there may be variations in the specific embodiments and the application scope, and in summary, the content of the present specification should not be construed as a limitation to the present invention.
Claims (10)
1. A multi-version interface implementation method is applied to a client, and comprises the following steps:
acquiring interface information disclosed by a server, wherein the interface information comprises a data structure and an interface method of a support version of the server;
determining a negotiated version according to the interface information and the supported version of the client;
establishing communication with the server according to the negotiated version;
the interface information is organized into packages in the form of soap and xml and is issued through the wsdl language, and a package program and a decapsulation program of the interface information are determined through base classes and inheritance.
2. The method according to claim 1, wherein the determining a negotiated version according to the interface information and the supported version of the client specifically includes:
comparing the support version of the server side in the interface information with the support version of the client side, and determining a support version set of the server side and the client side;
and determining the highest version in the supported version set as the negotiated version.
3. The multi-version interface implementation method of claim 1, wherein the wrapper comprises:
constructing an output element in the form of a name space and a name, and simultaneously updating the whole name space so as to add the name space of the output element into a functional domain;
if the attribute is null or not necessary, returning a null element;
if the attribute is the basic type, setting an attribute value and outputting an element;
if the attribute is the data packaging type, the packaging program is called recursively.
4. The multi-version interface implementation method of claim 1, wherein the decapsulating procedure comprises:
traversing the attribute list of the decapsulated object in sequence;
determining a complete attribute name for each attribute list value according to the name space and xmltag of the attribute list value;
if the attribute value of the attribute list value is a list, sequentially traversing the list and executing the same single attribute value operation on each attribute value in the list;
the single attribute value operation includes:
if the attribute value is a basic attribute, converting the character into a specific value according to the basic attribute;
if the attribute value is a structure attribute, the decapsulation program is called recursively.
5. The multi-version interface implementation method of claim 1, wherein the domain name of the data structure and the interface method comprises corresponding version-supported function and version information.
6. The multi-version interface implementation method according to any one of claims 1 to 5, wherein the process of establishing communication with the server according to the negotiated version includes:
and sending registration information to the server, wherein the registration information comprises the negotiated version and a corresponding interface implementation entrance, so that the server establishes a communication mechanism with the client through the interface implementation entrance.
7. The multi-version interface implementation method of claim 6, wherein the process of the server side establishing a communication mechanism with the client side through the interface implementation portal comprises:
and the server side uses the certificate of the client side to realize that the entrance establishes a communication mechanism with the client side through the interface.
8. The utility model provides a multi-version interface implementation system which characterized in that is applied to the customer end, multi-version interface implementation system includes:
the system comprises an acquisition module, a storage module and a processing module, wherein the acquisition module is used for acquiring interface information disclosed by a server, and the interface information comprises a data structure and an interface method of a support version of the server;
the version determining module is used for determining the negotiated version according to the interface information and the supported version of the client;
the communication establishing module is used for establishing communication with the server according to the negotiated version;
the interface information is organized into packages in the form of soap and xml and is issued through the wsdl language, and a package program and a decapsulation program of the interface information are determined through base classes and inheritance.
9. A multi-version interface implementation apparatus, comprising:
a memory for storing a computer program;
a processor for implementing the steps of the multi-version interface implementation method according to any one of claims 1 to 7 when executing the computer program.
10. A readable storage medium, having stored thereon a computer program which, when executed by a processor, performs the steps of the multi-version interface implementing method according to any one of claims 1 to 7.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010923086.0A CN112130817A (en) | 2020-09-04 | 2020-09-04 | Multi-version interface implementation method, system, device and readable storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010923086.0A CN112130817A (en) | 2020-09-04 | 2020-09-04 | Multi-version interface implementation method, system, device and readable storage medium |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN112130817A true CN112130817A (en) | 2020-12-25 |
Family
ID=73847288
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202010923086.0A Withdrawn CN112130817A (en) | 2020-09-04 | 2020-09-04 | Multi-version interface implementation method, system, device and readable storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN112130817A (en) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN115695555A (en) * | 2022-09-06 | 2023-02-03 | 恒生电子股份有限公司 | Interface calling method, system, processing equipment and storage medium |
-
2020
- 2020-09-04 CN CN202010923086.0A patent/CN112130817A/en not_active Withdrawn
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN115695555A (en) * | 2022-09-06 | 2023-02-03 | 恒生电子股份有限公司 | Interface calling method, system, processing equipment and storage medium |
| CN115695555B (en) * | 2022-09-06 | 2023-09-12 | 恒生电子股份有限公司 | Interface calling method, system, processing device and storage medium |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US11595477B2 (en) | Cloud storage methods and systems | |
| CN109361550B (en) | Method, device and equipment for network equipment configuration management | |
| US20180357274A1 (en) | Dynamic, variable-data attribute data service | |
| CN111556158A (en) | Access method, access device, access equipment and storage medium of Internet of things platform | |
| CN109086147B (en) | Service interface calling method and device of application program and storage medium | |
| CN112612449A (en) | Method, device, equipment and storage medium for synchronizing webpage | |
| CN109670132A (en) | A kind of page method for drafting, device, terminal device and storage medium | |
| CN113641700A (en) | Data processing method and device based on Spring boot frame | |
| US20130159468A1 (en) | Computer implemented method, computer system, electronic interface, mobile computing device and computer readable medium | |
| CN109814915B (en) | Parameter configuration method, device, medium and electronic equipment based on lua | |
| CN113515395B (en) | Application access method and device based on multi-cloud management platform | |
| CN112130817A (en) | Multi-version interface implementation method, system, device and readable storage medium | |
| CN105930410A (en) | Data service bus architecture used for data transmission of Internet of Things | |
| CN113626512A (en) | Data processing method, device, equipment and readable storage medium | |
| JP2004246747A (en) | Wrapping method and system of existing service | |
| CN113779175B (en) | Data processing method, map service providing method, electronic device, and storage medium | |
| CN115795212A (en) | Page display method and device, electronic equipment and storage medium | |
| CN108932130B (en) | Code generation method and device for realizing server function call | |
| CN112527656A (en) | Websocket interface test method, device and equipment | |
| CN111241788A (en) | Document conversion method, device, equipment and storage medium based on linear model | |
| CN106603637B (en) | Data exchange method and system between heterogeneous gridding management platforms | |
| CN113364636B (en) | Visual configuration docking method for data of Internet of things | |
| CN114051058B (en) | Interface calling method, platform, electronic equipment and computer storage medium | |
| CN117112500B (en) | Resource management method, device, equipment and storage medium | |
| CN112688863B (en) | Gateway data processing method and device and electronic equipment |
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 | ||
| WW01 | Invention patent application withdrawn after publication | ||
| WW01 | Invention patent application withdrawn after publication |
Application publication date: 20201225 |