CN114416599A - Method for generating generalized call for interface test based on Dubbo service interface - Google Patents
Method for generating generalized call for interface test based on Dubbo service interface Download PDFInfo
- Publication number
- CN114416599A CN114416599A CN202210309940.3A CN202210309940A CN114416599A CN 114416599 A CN114416599 A CN 114416599A CN 202210309940 A CN202210309940 A CN 202210309940A CN 114416599 A CN114416599 A CN 114416599A
- Authority
- CN
- China
- Prior art keywords
- type
- interface
- generic
- scanning
- analysis
- 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.)
- Granted
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3668—Software testing
- G06F11/3672—Test management
- G06F11/3684—Test management for test design, e.g. generating new test cases
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3668—Software testing
- G06F11/3672—Test management
- G06F11/3688—Test management for test execution, e.g. scheduling of test suites
Abstract
The invention discloses a method for generating generalized call for interface test based on a Dubbo service interface, which comprises the steps of analyzing Jar file packages of the Dubbo service interface and scanning all Jar file packages; scanning all remote methods in the Jar package using JAVA reflection technology; analyzing the type of the remote method, and performing structured disassembly on the general type of the remote method; analyzing the type of the remote method, searching the user-defined type, and recursively analyzing the user-defined type; scanning the analysis data structure of the steps S2-S4, storing the scanning result of each time as an independent version, and storing the scanning results of a plurality of times in one project; generating a generalization call code by using a byte code technology and carrying out dynamic loading; and automatically generating test parameters to perform interface test. The invention only needs the Jar file of the Dubbo service interface, does not depend on other third-party services, has higher stability and reliability, generates generalized calling codes and simulation data test interfaces after completing scanning, and has fast execution and high efficiency.
Description
Technical Field
The invention belongs to the technical field of interface testing, and particularly relates to a method for generating generalized calls for interface testing based on a Dubbo service interface.
Background
The existing interface test is usually a Dubbo interface test based on a Jmeter, a method for manually writing a Dubbo service consumer or generalization call logic to perform the Dubbo interface test, a method for performing the Dubbo interface sensing and testing based on Swagger and other API document generation technologies, and the like. The method includes the steps that the Dubbo interface test based on the Jmeter needs to depend on a third-party tool Jmeter, various parameters of a tested interface need to be filled in manually, and test scheme sharing can be conducted only through script configuration files of the Jmeter. And the Dubbo service consumer is manually written or the generalization call logic is used for Dubbo interface test, corresponding test codes are written for different service interfaces of different projects, and the test codes need to be rewritten when the service interfaces are changed. For conducting the sensing and testing of the Dubbo interface based on the API document generation technology such as Swagger, the Dubbo service interface is not necessarily exposed through the API document tool, and there may be a case of insufficient sensing, and various parameters of the tested interface need to be manually filled in.
Therefore, the present invention provides a method for generating a generalization call for interface testing based on a Dubbo service interface, so as to solve at least some of the above technical problems.
Disclosure of Invention
The technical problem to be solved by the invention is as follows: the method for generating the generalization call based on the Dubbo service interface to perform the interface test is provided to solve at least some technical problems.
In order to achieve the purpose, the technical scheme adopted by the invention is as follows:
a method for generating generalization call for interface test based on a Dubbo service interface comprises the following steps:
step S1, analyzing Jar file packages of the Dubbo service interface, and scanning all Jar file packages;
step S2, scanning all remote methods in the Jar file package by using JAVA reflection technology;
step S3, analyzing the type of the remote method, and performing structured disassembly on the general type of the remote method;
step S4, analyzing the type of the remote method, searching the user-defined type, and recursively analyzing the user-defined type;
step S5, scanning the analysis data structure of the steps S2-S4, storing the scanning result of each time as an independent version, and storing the scanning results of multiple times in one item;
step S6, generating a generalization call code by using a byte code technology and carrying out dynamic loading;
and step S7, automatically generating test parameters to carry out interface test.
Further, the step S1 specifically includes: firstly, converting a Jar file package into a URL format, and creating a custom class loader based on the Jar file package in the URL format; the Jar package is then converted to the Jar file format and iteratively scanned.
Further, the iterative scanning method comprises: reading the name and all files of a Jar file package which is scanned currently, and storing the JAVA source files under the appointed scanning path into a set; for the scanned Jar file package in the JarFile format, the name of the Jar file package is obtained to be used as a mapping key, the set of all the scanned JAVA source files in the Jar file package is obtained to be used as a mapping value, and a mapping relation is created for each Jar file package.
Further, in the step S2, based on the mapping relationship in the step S1, a Jar package parsing structure is created by using the mapping key, and then an interface parsing structure set is created; obtaining all JAVA source files from the mapping values, and loading each JAVA source file by using a custom class loader: if the loading result is an interface, an interface analysis structure is created for the interface, all remote methods defined in the interface are read by using a JAVA reflection technology, each read remote method is mounted under the interface analysis structure, and finally all the interface analysis structures in the mapping values are stored in an interface analysis structure set.
Further, the step S3 includes: reading the generic type of the remote method by using a JAVA reflection API, and respectively acquiring a non-generic part and a generic part of the generic type; creating a type analysis structure for the generic type, and recording the generic part and the non-generic part in the type analysis structure; acquiring a generic part of the generic type from the type analysis structure; if the generic part is obtained, the analysis is completed; if the generic part is not obtained, judging the non-generic part, if the non-generic part is the generic type, creating a type analysis substructure recording the generic part and the non-generic part again, recursing until the analysis is completed, and generating an analysis result tree formed by connecting a plurality of layers of type analysis substructures in series.
Further, the step S4 specifically includes: analyzing the type analysis structure layer by layer, putting the non-generic part of each layer into a non-generic queue, storing the generic part subjected to recursive processing into a generic queue, and screening out the custom types in the non-generic queue and the generic queue; loading the custom types one by using a custom class loader, reading the type of each field of the custom type by using a JAVA reflection technology, and constructing a custom type analysis structure; creating a first mapping relation, acquiring field names of the custom types as mapping keys of the first mapping relation, acquiring a set of all field types of the custom types as mapping values of the first mapping relation, creating a second mapping relation, acquiring binary full-class names of the custom types as mapping keys of the second mapping relation, and acquiring a set of analysis results of all the custom types as mapping values of the first mapping relation.
Further, in the step S6, a template code for generalization call is preset, and after the scanning in the step S5 is completed, the template code is automatically loaded, a generalization call instance is created for each interface according to the scanning result, and the scanned remote method is dynamically implanted.
Further, according to the specific types of the remote method parameters analyzed in steps S3 and S4, test parameter generation is performed corresponding to different data types, and the generalized calling instance in step S6 is called to initiate an interface test.
Further, the test parameter generation comprises: generating a default null value for the JAVA basic data type; generating a null value corresponding to the basic data type for the packaging type of the basic data type; for the string type, a random string is generated.
Compared with the prior art, the invention has the following beneficial effects:
the interface test method is scientific and reasonable in design, convenient to use and has greater advantages compared with other interface test methods. The invention only needs Jar files of the Dubbo service interface, uses the JAVA reflection technology and the byte code generation technology in the whole process, does not depend on other third-party services, and has higher stability and reliability. The invention can scan the field level of the remote method parameter, can persistently store the scanning result and support the comparison of the scanning result for multiple times so as to rapidly identify any change of the service interface; after the scanning is finished, the generalization calling code is dynamically generated, the test can be immediately executed, and the efficiency is higher; meanwhile, the scanning result holds the parameter type information of the method, so that the simulation data can be quickly generated to carry out interface test, and the trouble of manually inputting the test data is avoided.
Drawings
FIG. 1 is a schematic flow chart of the present invention.
Detailed Description
In order to make the objects, technical solutions and advantages of the present invention more apparent, the present invention is further described in detail below with reference to the accompanying drawings. It is to be understood that the described embodiments are merely exemplary of the invention, and not restrictive of the full scope of the invention. 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.
As shown in fig. 1, the method for generating a generalization call for interface test based on a Dubbo service interface provided by the present invention includes the following steps:
step S1, analyzing Jar file packages of the Dubbo service interface, and scanning all Jar file packages;
step S2, scanning all remote methods in the Jar file package by using JAVA reflection technology;
step S3, analyzing the type of the remote method, and performing structured disassembly on the general type of the remote method;
step S4, analyzing the type of the remote method, searching the user-defined type, and recursively analyzing the user-defined type;
step S5, scanning the analysis data structure of the steps S2-S4, storing the scanning result of each time as an independent version, and storing the scanning results of multiple times in one item;
step S6, generating a generalization call code by using a byte code technology and carrying out dynamic loading;
and step S7, automatically generating test parameters to carry out interface test.
Step S1 of the present invention specifically includes: firstly, converting a Jar file package into a URL format, and creating a custom class loader based on the Jar file package in the URL format; the Jar package is then converted to the Jar file format and iteratively scanned. Before this, the user inputs all Jar packages that need to be scanned by the Dubbo service interface and Jar package paths to be scanned, and then performs analysis and scanning of subsequent Jar packages.
The iterative scanning method comprises the following steps: reading the name and all files of a Jar file package which is scanned currently, and storing the JAVA source files under the appointed scanning path into a set; for the scanned Jar file package in the JarFile format, the name of the Jar file package is obtained to be used as a mapping key, the set of all the scanned JAVA source files in the Jar file package is obtained to be used as a mapping value, a mapping relation is created for each Jar file package, and the mapping can be used for storing the scanning result of the Jar file package. In particular, the JAVA source file is a suffix class file, which is saved in the above-mentioned collection for later processing.
After step S1 of the present invention is finished, the created mapping for saving all scanned Jar portfolio results starts iterating each mapping relationship in step S2, specifically: based on the mapping relation in the step S1, creating a Jar package parsing structure using the mapping key, and then creating an interface parsing structure set; obtaining all JAVA source files from the mapping values, and loading each JAVA source file by using a custom class loader: if the loading result is an interface, an interface analysis structure is created for the interface, all remote methods defined in the interface are read by using a JAVA reflection technology, each read remote method is mounted under the interface analysis structure, and finally all the interface analysis structures in the mapping values are stored in an interface analysis structure set.
In particular, the loading of the custom class loader only needs to load the JAVA source file and does not need to perform operations such as linking, verifying, initializing and the like. Meanwhile, the custom class loader creates a new instance for each scanning so as to achieve the purpose of timely unloading the loaded type in the scanning process after each scanning is finished, thereby timely releasing system resources.
If the JAVA source file cannot be loaded through the custom class loader, saving an error log; and if the loading is successful, reading and finding that no remote method is defined in the loading, recording an exception log.
In the step of the invention, in step S3, a JAVA reflection API is used to read the remote method; performing type analysis on the return value type and the participation type of the remote method by adopting a unified algorithm; a method structure for saving remote method type resolution results is created.
The analysis algorithm of the return value type and the parameter type of the remote method comprises the following steps: for any type (including a self-defined type), firstly defaulting to be a generic type, reading the generic type of a remote method by using a JAVA reflection technology (API), and respectively acquiring a non-generic part and a generic part of the generic type; if the type is not the generic type, the generic part acquisition result is null; creating a type analysis structure for the generic type, and recording the generic part and the non-generic part in the type analysis structure; the type parsing structure is the entry of the type parsing algorithm. Acquiring a generic part of the generic type from the type analysis structure; if the generic part is obtained, the analysis is completed; if the generic part is not obtained, judging the non-generic part, if the non-generic part is the generic type, creating a type analysis substructure recording the generic part and the non-generic part again, recursing until the analysis is completed, and generating an analysis result tree formed by connecting a plurality of layers of type analysis substructures in series. When the recursion is completed, no matter how many layers of generic structures are nested in the type, the generic structure is resolved into a resolution result tree which is strung by multiple layers of type resolution substructures.
Step S4 of the present invention specifically includes: analyzing the type analysis structure of the parameters layer by layer, putting the non-generic part of each layer into a non-generic queue, storing the generic part subjected to recursive processing into a generic queue, and then screening out the self-defined types in the non-generic queue and the generic queue; loading the custom types one by using a custom class loader, reading the type of each field of the custom type by using a JAVA reflection technology, and constructing a custom type analysis structure, namely an analysis result of the custom type; creating a first mapping relation, acquiring field names of the custom types as mapping keys of the first mapping relation, acquiring a set of all field types of the custom types as mapping values of the first mapping relation, creating a second mapping relation, acquiring binary full-class names of the custom types as mapping keys of the second mapping relation, and acquiring a set of analysis results of all the custom types as mapping values of the first mapping relation.
In the remote method, after the step S3 completes the generic type parsing, the user-defined type parsing is performed, and the user-defined type is searched by parsing the parameter type parsing structure layer by layer, where the parameter type parsing structure is a self-nested structure, and generic information of each layer is completely stored. In particular, custom types do not start with JAVA and are not the underlying data types built in JAVA. And after the custom type is analyzed, all fields under the custom type are obtained, namely field definitions are obtained, and the field definitions comprise two contents of field names and field types. Therefore, the type of the remote method is divided into a JAVA basic data type and a non-JAVA built-in basic data type, the latter is a self-defined type, and the self-defined type is further divided into a packaging type of the basic data type and a character string type by field analysis of JAVA reflection technology.
Similarly, the custom class loader in step S4 only needs to load a type, and does not need to link, verify, and initialize. If the generic part exists in the custom type analysis structure, a custom type searching method is adopted to carry out recursive analysis so as to ensure that all the custom types possibly hidden in the generic part are found.
Step S5 is the parsing data structure of the scanning steps S2-S4, and stores the scanning results of each time as an independent version, and the scanning results of multiple times are stored in one entry. Each project can execute a plurality of Jar file package scanning, each scanning can change the Jar file package to be scanned, and each scanning result can be stored as an independent version so as to compare the difference between the versions in the following process.
Step S6 of the present invention is to generate generalized calling codes and perform dynamic loading by using byte code technology based on the analysis result of step S4. The method specifically comprises the following steps: presetting a template code for generalized calling, automatically loading the template code after the scanning in the step S5 is finished, creating a generalized calling instance for each interface according to the scanning result, and dynamically implanting the remote method after the scanning is finished. The process is realized by means of a ByteBuddy byte code operation tool, and because the Dubbo generalized call has a fixed format, a user only needs to input a registration center address, and the system can automatically create application configuration, registration center configuration and reference configuration information related to the generalized call for each Dubbo service interface; finally, a uniform calling entry method is provided, when a user starts the interface test, the system can call each generalized calling instance, and therefore the purpose of testing all interfaces by one key is achieved.
Step S7 of the present invention generates test parameters corresponding to different data types according to the specific types of the remote method parameters analyzed in step S3 and step S4 based on the analysis results in step S3 and step S4, and invokes the generalized invocation instance in step S6 to initiate an interface test. Wherein the test parameter generation comprises: generating a default null value for the JAVA basic data type; generating a null value corresponding to the basic data type for the packaging type of the basic data type; for the string type, a random string is generated.
Finally, it should be noted that: the above embodiments are only preferred embodiments of the present invention to illustrate the technical solutions of the present invention, but not to limit the technical solutions, and certainly not to limit the patent scope of the present invention; while the invention has been described in detail and with reference to the foregoing embodiments, it will be understood by those skilled in the art that: the technical solutions described in the foregoing embodiments may still be modified, or some or all of the technical features may be equivalently replaced; the modifications or the substitutions do not make the essence of the corresponding technical solutions depart from the scope of the technical solutions of the embodiments of the present invention; that is, the technical problems to be solved by the present invention, which are not substantially changed or supplemented by the spirit and the concept of the main body of the present invention, are still consistent with the present invention and shall be included in the scope of the present invention; in addition, the technical scheme of the invention is directly or indirectly applied to other related technical fields, and the technical scheme is included in the patent protection scope of the invention.
Claims (9)
1. A method for generating generalization call for interface test based on a Dubbo service interface is characterized by comprising the following steps:
step S1, analyzing Jar file packages of the Dubbo service interface, and scanning all Jar file packages;
step S2, scanning all remote methods in the Jar file package by using JAVA reflection technology;
step S3, analyzing the type of the remote method, and performing structured disassembly on the general type of the remote method;
step S4, analyzing the type of the remote method, searching the user-defined type, and recursively analyzing the user-defined type;
step S5, scanning the analysis data structure of the steps S2-S4, storing the scanning result of each time as an independent version, and storing the scanning results of multiple times in one item;
step S6, generating a generalization call code by using a byte code technology and carrying out dynamic loading;
and step S7, automatically generating test parameters to carry out interface test.
2. The method for generating a generalization call for interface test based on a Dubbo service interface according to claim 1, wherein the step S1 specifically comprises: firstly, converting a Jar file package into a URL format, and creating a custom class loader based on the Jar file package in the URL format; the Jar package is then converted to the Jar file format and iteratively scanned.
3. The method for interface testing based on the generalization call generated by the Dubbo service interface of claim 2, wherein the iterative scanning method comprises: reading the name and all files of a Jar file package which is scanned currently, and storing the JAVA source files under the appointed scanning path into a set; for the scanned Jar file package in the JarFile format, the name of the Jar file package is obtained to be used as a mapping key, the set of all the scanned JAVA source files in the Jar file package is obtained to be used as a mapping value, and a mapping relation is created for each Jar file package.
4. The method for interface testing based on the generalized call generated by the Dubbo service interface as claimed in claim 3, wherein in step S2, based on the mapping relationship in step S1, a Jar package parsing structure is created using a mapping key, and then an interface parsing structure set is created; obtaining all JAVA source files from the mapping values, and loading each JAVA source file by using a custom class loader: if the loading result is an interface, an interface analysis structure is created for the interface, all remote methods defined in the interface are read by using a JAVA reflection technology, each read remote method is mounted under the interface analysis structure, and finally all the interface analysis structures in the mapping values are stored in an interface analysis structure set.
5. The method for interface testing based on the generalization call generated by the Dubbo service interface of claim 4, wherein the step S3 comprises: reading the generic type of the remote method by using a JAVA reflection technology, and respectively acquiring a non-generic part and a generic part of the generic type; creating a type analysis structure for the generic type, and recording the generic part and the non-generic part in the type analysis structure; acquiring a generic part of the generic type from the type analysis structure; if the generic part is obtained, the analysis is completed; if the generic part is not obtained, judging the non-generic part, if the non-generic part is the generic type, creating a type analysis substructure recording the generic part and the non-generic part again, recursing until the analysis is completed, and generating an analysis result tree formed by connecting a plurality of layers of type analysis substructures in series.
6. The method for interface testing based on the generalization call generated by the Dubbo service interface of claim 5, wherein the step S4 comprises: analyzing the type analysis structure layer by layer, putting the non-generic part of each layer into a non-generic queue, storing the generic part subjected to recursive processing into a generic queue, and screening out the custom types in the non-generic queue and the generic queue; loading the custom types one by using a custom class loader, reading the type of each field of the custom type by using a JAVA reflection technology, and constructing a custom type analysis structure; creating a first mapping relation, acquiring field names of the custom types as mapping keys of the first mapping relation, acquiring a set of all field types of the custom types as mapping values of the first mapping relation, creating a second mapping relation, acquiring binary full-class names of the custom types as mapping keys of the second mapping relation, and acquiring a set of analysis results of all the custom types as mapping values of the first mapping relation.
7. The method for interface testing based on the generalization call generated by the libbo service interface of claim 6, wherein in the step S6, a template code of the generalization call is preset, and after the scanning in the step S5 is completed, the template code is automatically loaded, and a generalization call instance is created for each interface according to the scanning result, and the scanned remote method is dynamically embedded.
8. The method for interface testing based on the generalized call generated by the Dubbo service interface as claimed in claim 7, wherein the test parameters are generated corresponding to different data types according to the specific types of the remote method parameters analyzed in steps S3 and S4, and the generalized call instance in step S6 is invoked to initiate the interface test.
9. The method for interface testing based on the generalized call generated by the Dubbo service interface of claim 8, wherein the generation of the test parameters comprises: generating a default null value for the JAVA basic data type; generating a null value corresponding to the basic data type for the packaging type of the basic data type; for the string type, a random string is generated.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210309940.3A CN114416599B (en) | 2022-03-28 | 2022-03-28 | Method for generating generalization call for interface test based on Dubbo service interface |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210309940.3A CN114416599B (en) | 2022-03-28 | 2022-03-28 | Method for generating generalization call for interface test based on Dubbo service interface |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN114416599A true CN114416599A (en) | 2022-04-29 |
| CN114416599B CN114416599B (en) | 2022-07-01 |
Family
ID=81262810
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202210309940.3A Active CN114416599B (en) | 2022-03-28 | 2022-03-28 | Method for generating generalization call for interface test based on Dubbo service interface |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN114416599B (en) |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN115604333A (en) * | 2022-10-12 | 2023-01-13 | 江苏赛融科技股份有限公司（Cn） | Distributed big data analysis service scheduling method and system based on dubbo |
| CN115640077A (en) * | 2022-12-23 | 2023-01-24 | 云筑信息科技(成都)有限公司 | Method for generating data mapping object for easy excel based on bytecode dynamic generation technology |
Citations (12)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN103136095A (en) * | 2011-11-28 | 2013-06-05 | 阿里巴巴集团控股有限公司 | Method, device and system of test application program interface |
| US20170052884A1 (en) * | 2015-08-20 | 2017-02-23 | Ca, Inc. | Generic test automation for restful web services applications |
| CN107908565A (en) * | 2017-11-27 | 2018-04-13 | 中国银行股份有限公司 | A kind of test method and equipment |
| US20180121335A1 (en) * | 2016-10-27 | 2018-05-03 | International Business Machines Corporation | Testing a virtual network function by a virtual network tester |
| CN109151091A (en) * | 2018-09-21 | 2019-01-04 | 福建南威软件有限公司 | A kind of API gateway service for supporting dubbo agreement to call |
| CN110990153A (en) * | 2019-11-27 | 2020-04-10 | 南京甄视智能科技有限公司 | Dubbo interface caching method and device under distributed environment based on SpringCache |
| CN111913713A (en) * | 2020-06-10 | 2020-11-10 | 中国科学院软件研究所 | Heterogeneous service integration method based on service call tracking |
| CN111930635A (en) * | 2020-09-17 | 2020-11-13 | 深圳微品致远信息科技有限公司 | Swagger-based rapid automatic testing method and system |
| CN112084046A (en) * | 2020-09-12 | 2020-12-15 | 朱领军 | Dubbo generalization interface calling method and device |
| CN113377680A (en) * | 2021-07-14 | 2021-09-10 | 中国工商银行股份有限公司 | Dubbo service test system and method |
| CN113448689A (en) * | 2021-07-09 | 2021-09-28 | 中国银行股份有限公司 | Dubbo protocol conversion device and method in operation period |
| CN113742209A (en) * | 2020-11-10 | 2021-12-03 | 北京沃东天骏信息技术有限公司 | Contrast test method, device and storage medium |
-
2022
- 2022-03-28 CN CN202210309940.3A patent/CN114416599B/en active Active
Patent Citations (12)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN103136095A (en) * | 2011-11-28 | 2013-06-05 | 阿里巴巴集团控股有限公司 | Method, device and system of test application program interface |
| US20170052884A1 (en) * | 2015-08-20 | 2017-02-23 | Ca, Inc. | Generic test automation for restful web services applications |
| US20180121335A1 (en) * | 2016-10-27 | 2018-05-03 | International Business Machines Corporation | Testing a virtual network function by a virtual network tester |
| CN107908565A (en) * | 2017-11-27 | 2018-04-13 | 中国银行股份有限公司 | A kind of test method and equipment |
| CN109151091A (en) * | 2018-09-21 | 2019-01-04 | 福建南威软件有限公司 | A kind of API gateway service for supporting dubbo agreement to call |
| CN110990153A (en) * | 2019-11-27 | 2020-04-10 | 南京甄视智能科技有限公司 | Dubbo interface caching method and device under distributed environment based on SpringCache |
| CN111913713A (en) * | 2020-06-10 | 2020-11-10 | 中国科学院软件研究所 | Heterogeneous service integration method based on service call tracking |
| CN112084046A (en) * | 2020-09-12 | 2020-12-15 | 朱领军 | Dubbo generalization interface calling method and device |
| CN111930635A (en) * | 2020-09-17 | 2020-11-13 | 深圳微品致远信息科技有限公司 | Swagger-based rapid automatic testing method and system |
| CN113742209A (en) * | 2020-11-10 | 2021-12-03 | 北京沃东天骏信息技术有限公司 | Contrast test method, device and storage medium |
| CN113448689A (en) * | 2021-07-09 | 2021-09-28 | 中国银行股份有限公司 | Dubbo protocol conversion device and method in operation period |
| CN113377680A (en) * | 2021-07-14 | 2021-09-10 | 中国工商银行股份有限公司 | Dubbo service test system and method |
Non-Patent Citations (3)
| Title |
|---|
| BRANDON J. MATTHEWS 等: "Remapped Physical-Virtual Interfaces with Bimanual Haptic Retargeting", 《2019 IEEE CONFERENCE ON VIRTUAL REALITY AND 3D USER INTERFACES (VR)》, 15 August 2019 (2019-08-15), pages 19 - 27 * |
| 杨超: "基于分布式服务框架Dubbo的集群式服务器的研究与实现", 《中国优秀博硕士学位论文全文数据库(硕士)信息科技辑》, no. 3, 15 March 2018 (2018-03-15), pages 139 - 261 * |
| 郝泽铭: "基于GAN-ASD的安卓系统软件老化检测方法研究与应用", 《中国优秀博硕士学位论文全文数据库(硕士)信息科技辑》, no. 12, 15 December 2021 (2021-12-15), pages 138 - 159 * |
Cited By (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN115604333A (en) * | 2022-10-12 | 2023-01-13 | 江苏赛融科技股份有限公司（Cn） | Distributed big data analysis service scheduling method and system based on dubbo |
| CN115604333B (en) * | 2022-10-12 | 2023-09-12 | 江苏赛融科技股份有限公司 | Distributed big data analysis service scheduling method and system based on dubbo |
| CN115640077A (en) * | 2022-12-23 | 2023-01-24 | 云筑信息科技(成都)有限公司 | Method for generating data mapping object for easy excel based on bytecode dynamic generation technology |
Also Published As
| Publication number | Publication date |
|---|---|
| CN114416599B (en) | 2022-07-01 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN114416599B (en) | Method for generating generalization call for interface test based on Dubbo service interface | |
| US7152229B2 (en) | Workflow code generator | |
| US8924944B2 (en) | Implementation of distributed methods that support generic functions | |
| CN112286779B (en) | Test task processing method and device, storage medium and computer equipment | |
| US20030200350A1 (en) | Class dependency graph-based class loading and reloading | |
| US20050268285A1 (en) | Object oriented GUI test automation | |
| US20030145315A1 (en) | Exchange of data between components of distributed software having different versions of software | |
| US20220292082A1 (en) | Method, apparatus and device for parallel execution of smart contract, and medium | |
| CN110825385B (en) | Method for constructing read Native offline package and storage medium | |
| WO2021052338A1 (en) | Smart contract client program generation method, system and device, and medium | |
| EP1755050A1 (en) | A data processing system and method of storing a dataset having a hierarchical data structure in a database | |
| CN113704269B (en) | Data processing method, system, storage medium and electronic equipment | |
| CN109117175B (en) | APK decompilation-based desktop end packaging method and packaging tool for fast packaging | |
| CN112799697B (en) | Configuration file version migration method based on standard framework | |
| CN116225450A (en) | Text conversion method and apparatus, computing device and readable storage medium | |
| CN113641594B (en) | Cross-terminal automatic testing method and related device | |
| WO2023015669A1 (en) | Project dependency display method and apparatus, terminal device, and storage medium | |
| CN113312038B (en) | Implementation method for generating Java code class relay structure | |
| CN114461258A (en) | Extensible resource hot loading assembly | |
| CN117076328A (en) | Associated service data verification method and device based on ASM byte code technology | |
| CN117687682A (en) | JavaScript-based object conversion method and system | |
| Potuzak et al. | Semi-automated Algorithm for Complex Test Data Generation for Interface-based Regression Testing of Software Components | |
| CN113986884A (en) | Service construction method, device, medium and server | |
| CN114840197A (en) | Method, device, equipment and storage medium for automatically generating basic codes of websites | |
| CN114237614A (en) | Application program processing method and device, electronic equipment and storage medium |
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 | ||
| EE01 | Entry into force of recordation of patent licensing contract |
Application publication date: 20220429 Assignee: Yunzhu Information Technology (Chengdu) Co.,Ltd. Assignor: China Construction e-commerce Co.,Ltd. Contract record no.: X2023980032450 Denomination of invention: A method of generating generic calls for interface testing based on Dubbo service interface Granted publication date: 20220701 License type: Common License Record date: 20230220 |
|
| EE01 | Entry into force of recordation of patent licensing contract |