CN113625998B - Request processing method and device - Google Patents
Request processing method and device Download PDFInfo
- Publication number
- CN113625998B CN113625998B CN202110912665.XA CN202110912665A CN113625998B CN 113625998 B CN113625998 B CN 113625998B CN 202110912665 A CN202110912665 A CN 202110912665A CN 113625998 B CN113625998 B CN 113625998B
- Authority
- CN
- China
- Prior art keywords
- interface
- parallel
- remote
- calling
- executor
- 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
- 238000003672 processing method Methods 0.000 title abstract description 22
- 238000000034 method Methods 0.000 claims abstract description 176
- 238000004458 analytical method Methods 0.000 claims abstract description 26
- 238000013507 mapping Methods 0.000 claims abstract description 16
- 238000012545 processing Methods 0.000 claims description 26
- 238000001028 reflection method Methods 0.000 claims description 17
- 238000010276 construction Methods 0.000 claims description 14
- 238000004590 computer program Methods 0.000 claims description 10
- 230000002776 aggregation Effects 0.000 claims description 9
- 238000004220 aggregation Methods 0.000 claims description 9
- 230000004931 aggregating effect Effects 0.000 claims description 5
- 238000011161 development Methods 0.000 abstract description 8
- 238000012423 maintenance Methods 0.000 abstract description 6
- 238000010586 diagram Methods 0.000 description 20
- 235000010627 Phaseolus vulgaris Nutrition 0.000 description 16
- 244000046052 Phaseolus vulgaris Species 0.000 description 16
- 239000003795 chemical substances by application Substances 0.000 description 14
- 230000008569 process Effects 0.000 description 13
- 230000007246 mechanism Effects 0.000 description 7
- 238000004891 communication Methods 0.000 description 6
- 230000006870 function Effects 0.000 description 6
- 238000012986 modification Methods 0.000 description 4
- 230000004048 modification Effects 0.000 description 4
- 230000003287 optical effect Effects 0.000 description 4
- 238000013461 design Methods 0.000 description 3
- 238000005516 engineering process Methods 0.000 description 3
- 238000007726 management method Methods 0.000 description 3
- 230000008901 benefit Effects 0.000 description 2
- 239000000835 fiber Substances 0.000 description 2
- 230000000644 propagated effect Effects 0.000 description 2
- 230000004044 response Effects 0.000 description 2
- 239000004065 semiconductor Substances 0.000 description 2
- 238000003491 array Methods 0.000 description 1
- 230000009286 beneficial effect Effects 0.000 description 1
- 238000013506 data mapping Methods 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 238000002347 injection Methods 0.000 description 1
- 239000007924 injection Substances 0.000 description 1
- 239000004973 liquid crystal related substance Substances 0.000 description 1
- 239000003550 marker Substances 0.000 description 1
- 239000013307 optical fiber Substances 0.000 description 1
- 238000012856 packing Methods 0.000 description 1
- 230000003068 static effect Effects 0.000 description 1
- 238000006467 substitution reaction Methods 0.000 description 1
- 238000012546 transfer Methods 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/20—Software design
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/20—Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
- G06F16/25—Integrating or interfacing systems involving database management systems
- G06F16/252—Integrating or interfacing systems involving database management systems between a Database Management System and a front-end application
-
- 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/44—Arrangements for executing specific programs
- G06F9/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
- G06F9/45504—Abstract machines for programme code execution, e.g. Java virtual machine [JVM], interpreters, emulators
-
- 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/44—Arrangements for executing specific programs
- G06F9/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
- G06F9/45533—Hypervisors; Virtual machine monitors
- G06F9/45558—Hypervisor-specific management and integration aspects
-
- 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
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
- Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Databases & Information Systems (AREA)
- Data Mining & Analysis (AREA)
- Stored Programmes (AREA)
Abstract
The invention discloses a request processing method and device, and relates to the technical field of computers. One embodiment of the method comprises the following steps: responding to the received call request, and generating a required parameter object for a pre-constructed parallel call executor; the parallel calling executor is used for calling the remote interface in parallel, and the parameter object comprises an entry parameter and a predefined interface mark which are required by calling the remote interface; the parameter object is transmitted into a parallel calling executor, so that the parallel calling executor searches an interface method corresponding to the interface mark according to a first association relation between the stored interface mark and the interface method, and the searched interface method is called in parallel; and acquiring the return data of the remote interface, and mapping the return data to a predefined result object according to the set analysis strategy. The method realizes free combination and calling of the remote interfaces by one development on the premise of not introducing any external dependence, reduces the complexity of parallel calling of the remote interfaces and is convenient for maintenance.
Description
Technical Field
The present invention relates to the field of computer technologies, and in particular, to a method and an apparatus for processing a request.
Background
A report typically contains a plurality of index data, and the index data is typically from a remote interface provided by a plurality of data services. At present, when generating a report, the data required to be displayed by each display page is combined, request parameters of different remote interfaces are constructed, the call to the remote interfaces is put into a Java instance and executed concurrently, so that each remote interface returns data according to the data format agreed with the display page, and the returned data of each remote interface can be processed subsequently to obtain a required result.
In the process of realizing the invention, the prior art has at least the following problems:
in the case that the calling mode of the remote interface, the return data format and the like are changed, all methods using the remote interface need to be checked and modified; in the case of the newly added remote interface, the code for calling the newly added remote interface needs to be added in the original code, and meanwhile, the processing process of the returned data needs to be added at all positions using the newly added remote interface data, and particularly, the returned data of a plurality of remote interfaces needs to be aggregated, so that a great deal of modification is needed to the original code.
Disclosure of Invention
In view of this, an embodiment of the present invention provides a method and an apparatus for processing a request, where the method assembles an input parameter and an interface tag required for calling a remote interface into a parameter object, and then a parallel call executor queries an interface method to be called according to the interface tag in the parameter object, and calls the interface methods in parallel, so as to map return data of the remote interface into a final result according to an analysis policy, and on the premise of not introducing any external dependency, it is achieved that the remote interface can be freely combined and called by one development, and meanwhile, robustness and service expandability of the whole process are improved, complexity of parallel calling the remote interface is reduced, and maintenance is facilitated.
To achieve the above object, according to an aspect of an embodiment of the present invention, there is provided a request processing method.
The request processing method of the embodiment of the invention comprises the following steps: responding to the received call request, and generating a required parameter object for a pre-constructed parallel call executor; the parallel call executor is used for calling a remote interface in parallel, and the parameter object comprises an input parameter and a predefined interface mark which are required for calling the remote interface; the parameter object is transmitted into the parallel calling executor, so that the parallel calling executor searches an interface method corresponding to the interface mark according to a first association relation between the stored interface mark and the interface method, and the searched interface method is called in parallel; and acquiring the return data of the remote interface, and mapping the return data to a predefined result object according to a set analysis strategy.
Optionally, the parallel calling searched interface method includes: according to a second association relation between the stored interface mark and the interface instance, searching the interface instance corresponding to the interface mark; and taking the searched interface instance and the input parameters of the searched interface method as parameters to input a reflection method, and executing the reflection method in parallel by adopting a plurality of threads.
Optionally, the parameter objects are a plurality of; before the step of searching for the interface method corresponding to the interface mark, the method further includes: generating a plurality of corresponding minimum execution units according to the plurality of parameter objects and parameters configured for the minimum execution units in advance; the parameters of the minimum execution unit comprise the entry, the interface mark, an interface method corresponding to the interface mark, an interface instance corresponding to the interface mark and a result set; the method for executing the reflection method in parallel by adopting a plurality of threads comprises the following steps: invoking the minimum execution unit, and executing the reflection method in parallel by adopting a plurality of threads; after the step of executing the reflection method in parallel by using a plurality of threads, the method further comprises the following steps: and writing the return data of the remote interface into the result set.
Optionally, the method further comprises: newly adding the interface mark in the definition information of the remote interface, and newly adding an interface method annotation at the entrance of the interface method to be called; and the annotation value annotated by the interface method is the interface mark.
Optionally, the method further comprises: a first object for realizing the remote interface is transmitted into the construction method of the parallel call executor, and a corresponding interface mark is obtained according to the interface method annotation marked in the remote method of the first object; the name of the interface mark is used as a key name, the interface method marked with the interface method annotation is used as a corresponding key value, the first association relation is generated, and the first association relation is stored in a first container of the parallel call executor; the name of the interface mark is used as a key name, the interface instance is used as a corresponding key value, a second association relation is generated, and the second association relation is stored in a second container of the parallel calling executor; the interface instance is a first object to which the interface method belongs.
Optionally, the obtaining the return data of the remote interface, mapping the return data to a predefined result object according to a set parsing policy, includes: invoking a parser agent contained in the parallel invoking executor to find out a parsing strategy corresponding to the interface mark according to a third association relation between the interface mark and the parsing strategy; and acquiring the return data of the remote interfaces according to the found analysis strategy, aggregating the return data of a plurality of remote interfaces to obtain an aggregation result, and assigning the aggregation result to a predefined result object.
Optionally, the method further comprises: a second object for realizing the resolver is transmitted into the construction method of the resolver proxy; generating a fourth association relation by taking the name of the resolver as a key name and the second object as a corresponding key value, and storing the fourth association relation into a third container of the resolver proxy; the obtaining the return data of the remote interface includes: inquiring a second object corresponding to the resolver name according to the resolver name carried in the found resolution strategy and the fourth association relation; and acquiring the return data of the remote interface by using the searched second object reflection.
Optionally, the interface tag is an interface enumeration or string constant.
To achieve the above object, according to another aspect of an embodiment of the present invention, there is provided a request processing apparatus.
The request processing device of the embodiment of the invention comprises: the parameter generation module is used for responding to the received call request and generating a required parameter object for the pre-constructed parallel call executor; the parallel call executor is used for calling a remote interface in parallel, and the parameter object comprises an input parameter and a predefined interface mark which are required for calling the remote interface; the searching and calling module is used for transmitting the parameter object into the parallel calling executor so that the parallel calling executor searches the interface method corresponding to the interface mark according to the first association relation between the stored interface mark and the interface method and calls the searched interface method in parallel; and the result mapping module is used for acquiring the return data of the remote interface and mapping the return data to a predefined result object according to a set analysis strategy.
Optionally, the searching and calling module is further configured to search an interface instance corresponding to the interface tag according to a second association relationship between the stored interface tag and the interface instance; and taking the searched interface instance and the input parameters of the searched interface method as parameters to input a reflection method, and executing the reflection method in parallel by adopting a plurality of threads.
Optionally, the parameter objects are a plurality of; the apparatus further comprises: the minimum execution unit generation module is used for generating a plurality of corresponding minimum execution units according to the plurality of parameter objects and parameters configured for the minimum execution units in advance; the parameters of the minimum execution unit comprise the entry, the interface mark, an interface method corresponding to the interface mark, an interface instance corresponding to the interface mark and a result set; the searching and calling module is also used for calling the minimum execution unit and executing the reflection method in parallel by adopting a plurality of threads; the apparatus further comprises: and the writing module is used for writing the return data of the remote interface into the result set.
Optionally, the apparatus further comprises: the new adding module is used for adding the interface mark in the definition information of the remote interface and adding an interface method annotation at the entrance of the interface method to be called; and the annotation value annotated by the interface method is the interface mark.
Optionally, the apparatus further comprises: the container initializing module is used for transmitting a first object for realizing the remote interface into the construction method of the parallel calling executor, and acquiring a corresponding interface mark according to the interface method annotation marked in the remote method of the first object; the name of the interface mark is used as a key name, the interface method marked with the interface method annotation is used as a corresponding key value, the first association relation is generated, and the first association relation is stored in a first container of the parallel call executor; the name of the interface mark is used as a key name, the interface instance is used as a corresponding key value, a second association relation is generated, and the second association relation is stored in a second container of the parallel calling executor; the interface instance is a first object to which the interface method belongs.
Optionally, the result mapping module is further configured to invoke a parser agent included in the parallel invocation executor, so as to find a parsing policy corresponding to the interface tag according to a third association relationship between the interface tag and the parsing policy; and acquiring the return data of the remote interfaces according to the found analysis strategy, aggregating the return data of a plurality of remote interfaces to obtain an aggregation result, and assigning the aggregation result to a predefined result object.
Optionally, the apparatus further comprises: the analyzer agent instantiation module is used for inputting a second object for realizing the analyzer into the construction method of the analyzer agent; generating a fourth association relation by taking the name of the resolver as a key name and the second object as a corresponding key value, and storing the fourth association relation into a third container of the resolver proxy; the result mapping module is further configured to query a second object corresponding to the resolver name according to the resolver name carried in the found resolution policy and the fourth association relationship; and acquiring the return data of the remote interface by using the searched second object reflection.
Optionally, the interface tag is an interface enumeration or string constant.
To achieve the above object, according to still another aspect of the embodiments of the present invention, there is provided an electronic device.
An electronic device according to an embodiment of the present invention includes: one or more processors; and the storage device is used for storing one or more programs, and when the one or more programs are executed by the one or more processors, the one or more processors are enabled to realize a request processing method of the embodiment of the invention.
To achieve the above object, according to still another aspect of the embodiments of the present invention, there is provided a computer-readable medium.
A computer readable medium of an embodiment of the present invention has stored thereon a computer program which, when executed by a processor, implements a request processing method of an embodiment of the present invention.
One embodiment of the above invention has the following advantages or benefits:
the method comprises the steps of assembling the parameter entering and interface marks required by calling the remote interface into parameter objects, inquiring interface methods to be called according to the interface marks in the parameter objects by a parallel call executor, calling the interface methods in parallel, mapping the returned data of the remote interface into a final result according to an analysis strategy, realizing free combined call of the remote interface by one-time development on the premise of not introducing any external dependence, improving the robustness and service expansibility of the whole process, reducing the complexity of calling the remote interface in parallel, and facilitating maintenance.
By searching the interface instance corresponding to the interface mark, the interface method can be dynamically called by utilizing a reflection mechanism. And generating a corresponding minimum execution unit for each parameter object, and further, calling an interface method in parallel by using the minimum execution unit, so that the workload of packing the parameters can be reduced as much as possible when a new remote interface is accessed, and meanwhile, the returned data is stored in the minimum execution unit to wait for the identification of the analyzer agent. By adding the interface mark in the definition information of the remote interface and adding the interface method annotation at the entrance of the interface method to be called, the different remote interfaces can be distinguished conveniently.
The interface method and the interface instance marked by the interface method annotation are stored through Java container technology, so that a lightweight processing architecture is realized. The on-demand aggregation processing of the returned data of the plurality of remote interfaces is realized through the self-defined analysis strategy, and the processing flow is perfected. And searching a second object corresponding to the resolved name, so that the data returned by the remote interface can be dynamically acquired by utilizing a reflection mechanism. The remote interface is identified by using the interface enumeration mark, so that the management is convenient.
Further effects of the above-described non-conventional alternatives are described below in connection with the embodiments.
Drawings
The drawings are included to provide a better understanding of the invention and are not to be construed as unduly limiting the invention. Wherein:
FIG. 1 is a schematic diagram of the main steps of a request processing method according to an embodiment of the present invention;
FIG. 2 is a schematic diagram of a Java class structure used in a request processing method according to an embodiment of the present invention;
FIG. 3 is a schematic diagram of a main flow of a request processing method according to an embodiment of the present invention;
FIG. 4 is a schematic diagram illustrating the assembly principle of parameter objects in a request processing method according to an embodiment of the present invention;
FIG. 5 is a schematic diagram of a main flow of constructing a parallel call executor in a request processing method according to an embodiment of the present invention;
FIG. 6 is a schematic diagram of the main modules of a request processing apparatus according to an embodiment of the present invention;
FIG. 7 is an exemplary system architecture diagram in which embodiments of the present invention may be applied;
fig. 8 is a schematic structural diagram of a computer device suitable for use in an electronic apparatus to implement an embodiment of the present invention.
Detailed Description
Exemplary embodiments of the present invention will now be described with reference to the accompanying drawings, in which various details of the embodiments of the present invention are included to facilitate understanding, and are to be considered merely exemplary. Accordingly, those of ordinary skill in the art will recognize that various changes and modifications of the embodiments described herein can be made without departing from the scope and spirit of the invention. Also, descriptions of well-known functions and constructions are omitted in the following description for clarity and conciseness.
Fig. 1 is a schematic diagram of main steps of a request processing method according to an embodiment of the present invention.
As shown in fig. 1, the request processing method in the embodiment of the present invention mainly includes the following steps:
step S101: and responding to the received call request, and generating a required parameter object for the pre-constructed parallel call executor. The front end sends a call request to a target interface, which may be, for example, a report interface for generating a report. After receiving the call request, the target interface generates a required parameter object for the pre-built parallel call executor according to the remote interface which needs to be called. The parallel call executor is used for calling the remote interface in parallel. The parameter object includes an entry needed to invoke the remote interface and a predefined interface tag for identifying the interface method that needs to be invoked.
Step S102: and transmitting the parameter object into the parallel calling executor, so that the parallel calling executor searches the interface method corresponding to the interface mark according to the first association relation between the stored interface mark and the interface method, and calls the searched interface method in parallel. And calling a parallel calling executor, and searching an interface method corresponding to the interface mark contained in the parameter object according to a first association relation between the stored interface mark and the interface method by the parallel calling executor, and calling the searched interface method in parallel through the initialized thread pool.
Step S103: and acquiring the return data of the remote interface, and mapping the return data to a predefined result object according to a set analysis strategy. According to the actual requirement, an analysis strategy can be preconfigured, and the analysis strategy is used for analyzing the returned data into a required result object, so that the parallel calling of a remote interface and the processing of the returned data are completed. In an embodiment, the resolution policies may be divided into three types, single Bean resolution, array Bean resolution, and aggregate multiple Bean resolution. Where Bean is a software component model describing Java.
The single Bean parsing is to map the acquired return data onto the result object by the get method or the reflection mechanism. The analysis of the array Bean aims at the condition that returned data of a remote interface is a List (List), the analysis needs to traverse the acquired List, each piece of data in the List is respectively mapped to a result object, and the analysis principle of each piece of data is the same as that of a single Bean. And aggregating a plurality of beans to analyze the combination of the return data of the result object from a plurality of remote interfaces, wherein the analysis obtains the return data through a get method or a reflection mechanism, and aggregates the return data to obtain the result object.
Fig. 2 is a schematic diagram of a Java class structure used in the request processing method according to an embodiment of the present invention. As shown in fig. 2, the implementation procedure of the request processing method is divided into four parts, namely preparation, parameter object construction, parallel call executor and analyzer execution. Wherein the preparation section is used to define the annotation of the method level (i.e. interface method annotation), and which are the interface methods of the remote interface that actually need to be invoked are marked. The parameter object construction part is mainly used for assembling the parameter object.
The parallel call executor internally comprises two Map containers (hereinafter referred to as a first container and a second container), a thread pool and a parser agent. The first container is a methodMap and is used for storing a first association relation between the interface mark and the interface method; the second container is an objectMap, and is used for storing a second association relationship between the interface mark and the interface instance; threadPoolExecutor taskExecutor for concurrent call threads; resultParserproxy is the resolver proxy.
The parser is configured to parse a mapping relationship between the returned data and the final result object, and in an embodiment, the mapping relationship is implemented based on a design scheme of the parsing policy and the proxy mode. Resolution strategies are mainly divided into three categories: single Bean resolution, array Bean resolution, and aggregate multiple Bean resolutions.
Fig. 3 is a schematic flow chart of a request processing method according to an embodiment of the present invention. As shown in fig. 3, the request processing method in the embodiment of the present invention mainly includes the following steps:
step S301: a remote interface is developed. The method comprises the steps of adding an interface mark in definition information of a remote interface, then normally developing and realizing the call of the remote interface, adding an interface method annotation at an entrance of an interface method to be called, wherein the annotation value of the interface method annotation is the added interface mark.
The interface tags are used to distinguish between different remote interfaces, each with a different interface tag, which in embodiments may be an interface enumeration, or a string constant. With interface enumeration as an interface marker, it is easier to manage than string constants. Interface members of various data types, such as enumeration types, string types, etc., may be included in the definition information of the remote interface. In an embodiment, the remote interface may be defined using enumeration.
Since the data structure of the returned data is unpredictable, it is necessary to implement the parser by itself, and in a preferred embodiment, a parser having a certain versatility for the returned data may be implemented in combination with a Java reflection mechanism. The generic parser can obtain the return data by reflection of the configured get method name, and map the return data to the result object.
In addition, if the existing parser cannot parse the returned data of the remote interface, a new parser needs to be developed, where the parserName () method of the parser corresponds to the name of the interface tag.
In an embodiment, in order to return the result object to the front end, a target interface is also developed. The target interface assembles the parameter objects required by the parallel call executor as needed and invokes the queryDataAsync () method of the parallel call executor. Wherein the Class of the queryDataAsync () method is the Class of incoming return data. The parameter object includes the entry and interface flags required to invoke the remote interface. When the number of the input parameters is plural, the arrays are put in sequence.
Step S302: and constructing a parallel call executor. The parallel call executor comprises a first container, a second container, a thread pool and a parser agent, and the parallel call executor is constructed, namely the first container and the second container are initialized, the parser agent is instantiated, and the thread pool is initialized. The resolver proxy stores a fourth association relationship in which the resolver name is a key name and the second object is a corresponding key value. Wherein the second object is an object for implementing a parser. The specific implementation of this step is described later with respect to fig. 5.
Step S303: and under the condition that a call request of the front end is received, generating parameter objects required by the parallel call executor according to remote interfaces required to be called. After receiving the call request from the front end, the target interface assembles the parameter object (LhmReqParam) required by the parallel call executor according to the remote interface which needs to be called.
The assembly parameter object is a process of generating a class structure diagram-parameter object, specifically, a remote call parameter (including an input parameter and an interface mark required for calling a remote interface) is generated first, and then the remote call parameter is packaged into the parameter object. The class structure diagram shows the static structure of the model, especially the class, the internal structure of the class and the relation between the class and other classes.
Fig. 4 is a schematic diagram of an assembly principle of a parameter object in a request processing method according to an embodiment of the present invention. As shown in fig. 4, in this embodiment, the parameter entry and the interface mark corresponding to the same remote interface are assembled to the corresponding parameter object, and all the parameter objects are combined into a List to obtain the final parameter object.
Step S304: and transmitting the parameter object into a parallel call executor so that the parallel executor generates a corresponding minimum execution unit according to the parameter object and parameters configured for the minimum execution unit in advance. The target interface passes the object parameters into the parallel call executor. And the parallel call executor initializes and copies all parameters in the minimum execution unit (LhmReqHandler) according to the input parameter object to obtain a corresponding minimum execution unit. The minimum execution unit is a class of interface methods for calling the remote interface through reflection, and parameters contained in the class are shown in table 1.
TABLE 1
Column 1 in table 1 is the parameters that need to be initialized and column 2 is the process of assigning values. In a preferred embodiment, a minimum execution unit is generated for each parameter object of the parallel call executor, respectively, so that the workload of encapsulating the remote interface access is reduced as much as possible when accessing the new remote interface.
Step S305: and calling a minimum execution unit, and searching an interface method and an interface instance corresponding to the interface mark according to the stored first association relation and the second association relation. The minimum execution unit searches an interface method corresponding to the interface mark contained in the parameter object according to the stored first association relation; and searching an interface instance corresponding to the interface mark contained in the parameter object according to the stored second association relation.
Step S306: and taking the searched interface instance and the input parameters of the searched interface method as parameters to input the reflection method, executing the reflection method in parallel by adopting a plurality of threads, and writing the returned data of the remote interface into a result set. This step is used to invoke the interface method of the remote interface via the reflection mechanism, and then assign the return data of the remote interface to the result set. The parallel execution of the reflection method in the step can be realized by a Java thread pool and a CountDown Latch. Wherein countdown latch enables one thread to resume execution after waiting for the other threads to complete their respective work.
In an embodiment, the reflection method is an invoke () method, the usage of which is as follows: public Object invoke (Object obj, object..ars), i.e. there are two parameters of the method, obj is the Object of the called method and ars is the entry of the called method.
Step S307: the parser agent is invoked to identify return data in the result set by the parser agent, and map the return data into the result object. The parser agent identifies the return data in the result set, and then maps the return data to the result object according to the set parsing policy.
When the returned data in the result set is identified, the analysis strategy corresponding to the interface mark is searched according to the third association relation between the interface mark and the analysis strategy, then a second object corresponding to the name of the analyzer is searched according to the name of the analyzer carried in the searched analysis strategy and the fourth association relation, and the returned data of the remote interface is obtained by using the searched second object reflection.
If the analysis strategy is to aggregate a plurality of Bean analyses, the returned data of a plurality of remote interfaces can be aggregated to obtain an aggregate result, and the aggregate result is assigned to a predefined result object. Illustratively, assuming that the result object TestBean class includes two attributes, id and totalNum, the return data of remote interface a includes two attributes, id and numA, and the return data of remote interface B includes two attributes, id and numB, totalNum is derived from the sum of numa+numb of the same id in remote interface a and remote interface B.
Assuming that the return data of the remote interface a is acquired first by the get method or the reflection mechanism, a new result object TestBean is generated, and the attribute of the new result object TestBean is: id = a.id; total num = a.numa; when the return data of the remote interface B is obtained, the totalNum in the TestBean with id=b.id is found and added, and at this time, the totalnum=totalnum+numb can obtain the final result object.
According to the embodiment, the process from batch interface access to return data processing in the prior art is decoupled, and on the premise that no external dependence is introduced, parallel calling of a plurality of remote interfaces and processing of return data are realized only through Java own technology and a software development design mode, so that the robustness and service expansibility of the whole process are improved, the complexity of parallel calling of the remote interfaces is reduced, and the maintenance is convenient. Finally, one-time development is realized, a plurality of places are convenient to quote, and the remote interfaces can be freely combined and called.
In another alternative embodiment, the remote interface call object information (including class name, method name) and the parser object information stored in the container may be put into the database, and the remote interface call object is instantiated by a reflection mode, so as to implement a scheme of configurable remote interface access and return data mapping.
For the above manner, the configuration information of remote interface call needs to be queried in the database, and the configuration information comprises the method name of the remote interface, the class full name of the remote interface and the remote task name; and then instantiating the remote interface, namely instantiating a remote interface call object according to the class name, constructing a parallel call executor according to the step S302, and executing the subsequent steps. It will be appreciated that in this manner, the interface is labeled as a remote task name. In addition, when constructing the parallel call executor, the instantiated remote interface call object needs to be transferred into the construction function of the parallel call executor.
FIG. 5 is a schematic flow chart of a method for processing requests to construct a parallel call executor according to an embodiment of the present invention. As shown in fig. 5, the implementation flow (i.e. step S302) of the parallel call executor in the embodiment of the present invention mainly includes the following steps:
step S501: and a first object for realizing the remote interface is transmitted into the construction method of the parallel calling executor, and the corresponding interface mark is obtained according to the interface method annotation marked in the remote method of the first object. The step is used for acquiring all the objects which realize the remote interface and determining whether to store the objects in the container according to whether interface method notes exist in the remote methods of the objects. In the embodiment, all the objects realizing the remote interface can be obtained by means of spring (a Java development framework) injection.
Step S502: a first container of parallel call executors is initialized. And taking the acquired name of the interface mark as a key name (key), taking the interface method marked with the interface method annotation as a corresponding key value (value), generating a first association relation, and storing the first association relation into a first container of the parallel call executor.
Step S503: a second container of parallel call executors is initialized. The name of the obtained interface mark is used as a key name (key), the interface instance is used as a corresponding key value (value), a second association relation is generated, and the second association relation is stored in a second container of the parallel calling executor; the interface instance is a first object to which the interface method belongs.
Step S504: instantiate a resolver proxy. And a second object for realizing the resolver is transmitted into the construction method of the resolver proxy, the resolver name is taken as a key, the second object is taken as a corresponding key value, a fourth association relationship is generated, and the fourth association relationship is stored into a third container (namely a parserMap container) of the resolver proxy. Wherein the incoming second object does not contain a proxy class. The parser name is the value returned by the parername () method.
Step S505: and initializing a thread pool. And initializing a thread pool for calling the remote interfaces in parallel.
The parallel call executor constructed by the embodiment can store the interface method marked by the interface method annotation, the interface instance and the parser object information through the container, thereby reducing the development complexity and realizing a lightweight processing architecture.
Fig. 6 is a schematic diagram of main modules of a request processing apparatus according to an embodiment of the present invention.
As shown in fig. 6, a request processing apparatus 600 according to an embodiment of the present invention mainly includes:
the parameter generating module 601 is configured to generate a required parameter object for a pre-built parallel call executor in response to a received call request. The front end sends a call request to a target interface, which may be, for example, a report interface for generating a report. After receiving the call request, the target interface generates a required parameter object for the pre-built parallel call executor according to the remote interface which needs to be called. The parallel call executor is used for calling the remote interface in parallel. The parameter object includes an entry needed to invoke the remote interface and a predefined interface tag for identifying the interface method that needs to be invoked.
And a search and call module 602, configured to transfer the parameter object into the parallel call executor, so that the parallel call executor searches for an interface method corresponding to the interface mark according to a first association relationship between the stored interface mark and the interface method, and call the found interface method in parallel. And calling a parallel calling executor, and searching an interface method corresponding to the interface mark contained in the parameter object according to a first association relation between the stored interface mark and the interface method by the parallel calling executor, and calling the searched interface method in parallel through the initialized thread pool.
The result mapping module 603 is configured to obtain return data of the remote interface, and map the return data to a predefined result object according to a set resolution policy. According to the actual requirements, a parsing strategy can be preconfigured, and the parsing strategy is used for parsing the returned data into required result objects. In an embodiment, the resolution policies may be divided into three types, single Bean resolution, array Bean resolution, and aggregate multiple Bean resolution. Where Bean is a software component model describing Java.
In addition, the request processing apparatus 600 of the embodiment of the present invention may further include: the minimum execution unit generation module, the write module, the add module, the container initialization module, and the resolver agent instantiation module (not shown in FIG. 6). The minimum execution unit generation module is used for generating a plurality of corresponding minimum execution units according to the plurality of parameter objects and parameters configured for the minimum execution units in advance; the parameters of the minimum execution unit comprise the entry, the interface mark, an interface method corresponding to the interface mark, an interface instance corresponding to the interface mark and a result set.
And the writing module is used for writing the return data of the remote interface into the result set. The new adding module is used for adding the interface mark in the definition information of the remote interface and adding an interface method annotation at the entrance of the interface method to be called; and the annotation value annotated by the interface method is the interface mark.
The container initializing module is used for transmitting a first object for realizing the remote interface into the construction method of the parallel calling executor, and acquiring a corresponding interface mark according to the interface method annotation marked in the remote method of the first object; the name of the interface mark is used as a key name, the interface method marked with the interface method annotation is used as a corresponding key value, the first association relation is generated, and the first association relation is stored in a first container of the parallel call executor; the name of the interface mark is used as a key name, the interface instance is used as a corresponding key value, a second association relation is generated, and the second association relation is stored in a second container of the parallel calling executor; the interface instance is a first object to which the interface method belongs.
The analyzer agent instantiation module is used for inputting a second object for realizing the analyzer into the construction method of the analyzer agent; and generating a fourth association relation by taking the name of the resolver as a key name and the second object as a corresponding key value, and storing the fourth association relation into a third container of the resolver proxy.
It can be seen from the above description that, by assembling the parameter entering and interface marks required for calling the remote interface into the parameter object, the parallel call executor queries the interface methods required to be called according to the interface marks in the parameter object, and calls the interface methods in parallel, so as to map the return data of the remote interface into the final result according to the analysis strategy, and on the premise of not introducing any external dependence, the remote interface can be freely combined and called by one development, and meanwhile, the robustness and service expansibility of the whole process are improved, the complexity of parallel calling the remote interface is reduced, and the maintenance is convenient.
Fig. 7 illustrates an exemplary system architecture 700 to which a request processing method or request processing apparatus of an embodiment of the present invention may be applied.
As shown in fig. 7, a system architecture 700 may include terminal devices 701, 702, 703, a network 704, and a server 705. The network 704 is the medium used to provide communication links between the terminal devices 701, 702, 703 and the server 705. The network 704 may include various connection types, such as wired, wireless communication links, or fiber optic cables, among others.
A user may interact with the server 705 via the network 704 using the terminal devices 701, 702, 703 to receive or send messages or the like. The terminal devices 701, 702, 703 may be various electronic devices having a display screen and supporting web browsing, including but not limited to smartphones, tablets, laptop and desktop computers, and the like.
The server 705 may be a server that provides various services, for example, a background management server that processes a call request transmitted by an administrator using the terminal devices 701, 702, 703. The background management server can generate a parameter object, search an interface method, call the interface method in parallel, acquire return data, map the return data to a result object, and feed back a processing result (for example, the result object) to the terminal device.
It should be noted that, the method for processing a request provided in the embodiment of the present application is generally executed by the server 705, and accordingly, the request processing device is generally disposed in the server 705.
It should be understood that the number of terminal devices, networks and servers in fig. 7 is merely illustrative. There may be any number of terminal devices, networks, and servers, as desired for implementation.
According to an embodiment of the application, the application further provides an electronic device and a computer readable medium.
The electronic device of the present application includes: one or more processors; and the storage device is used for storing one or more programs, and when the one or more programs are executed by the one or more processors, the one or more processors are enabled to realize a request processing method of the embodiment of the application.
The computer readable medium of the present invention has stored thereon a computer program which, when executed by a processor, implements a request processing method of an embodiment of the present invention.
Referring now to FIG. 8, there is illustrated a schematic diagram of a computer system 800 suitable for use in implementing an embodiment of the present invention. The electronic device shown in fig. 8 is only an example and should not be construed as limiting the functionality and scope of use of the embodiments of the invention.
As shown in fig. 8, the computer system 800 includes a Central Processing Unit (CPU) 801 that can perform various appropriate actions and processes according to a program stored in a Read Only Memory (ROM) 802 or a program loaded from a storage section 808 into a Random Access Memory (RAM) 803. In the RAM 803, various programs and data required for the operation of the computer system 800 are also stored. The CPU 801, ROM 802, and RAM 803 are connected to each other by a bus 804. An input/output (I/O) interface 805 is also connected to the bus 804.
The following components are connected to the I/O interface 805: an input portion 806 including a keyboard, mouse, etc.; an output portion 807 including a display such as a Cathode Ray Tube (CRT), a Liquid Crystal Display (LCD), and a speaker; a storage section 808 including a hard disk or the like; and a communication section 809 including a network interface card such as a LAN card, a modem, or the like. The communication section 809 performs communication processing via a network such as the internet. The drive 810 is also connected to the I/O interface 805 as needed. A removable medium 811 such as a magnetic disk, an optical disk, a magneto-optical disk, a semiconductor memory, or the like is mounted on the drive 810 as needed so that a computer program read out therefrom is mounted into the storage section 808 as needed.
In particular, the processes described above in the main step diagrams may be implemented as computer software programs according to the disclosed embodiments of the invention. For example, embodiments of the present disclosure include a computer program product comprising a computer program embodied on a computer readable medium, the computer program comprising program code for performing the method shown in the main step diagrams. In such an embodiment, the computer program may be downloaded and installed from a network via the communication section 809, and/or installed from the removable media 811. The above-described functions defined in the system of the present invention are performed when the computer program is executed by a Central Processing Unit (CPU) 801.
The computer readable medium shown in the present invention may be a computer readable signal medium or a computer readable storage medium, or any combination of the two. The computer readable storage medium can be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or a combination of any of the foregoing. More specific examples of the computer-readable storage medium may include, but are not limited to: an electrical connection having one or more wires, a portable computer diskette, a hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing. In the context of this document, a computer readable storage medium may be any tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device. In the present invention, however, the computer-readable signal medium may include a data signal propagated in baseband or as part of a carrier wave, with the computer-readable program code embodied therein. Such a propagated data signal may take any of a variety of forms, including, but not limited to, electro-magnetic, optical, or any suitable combination of the foregoing. A computer readable signal medium may also be any computer readable medium that is not a computer readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device. Program code embodied on a computer readable medium may be transmitted using any appropriate medium, including but not limited to: wireless, wire, fiber optic cable, RF, etc., or any suitable combination of the foregoing.
The flowcharts and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present invention. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of code, which comprises one or more executable instructions for implementing the specified logical function(s). It should also be noted that, in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams or flowchart illustration, and combinations of blocks in the block diagrams or flowchart illustration, can be implemented by special purpose hardware-based systems which perform the specified functions or acts, or combinations of special purpose hardware and computer instructions.
The modules involved in the embodiments of the present invention may be implemented in software or in hardware. The described modules may also be provided in a processor, for example, as: a processor includes a parameter generation module, a lookup call module, and a result mapping module. The names of these modules do not in some way limit the module itself, for example, the parameter generation module may also be described as "a module that generates the required parameter objects for a pre-built parallel call executor in response to a received call request".
As another aspect, the present invention also provides a computer-readable medium that may be contained in the apparatus described in the above embodiments; or may be present alone without being fitted into the device. The computer readable medium carries one or more programs which, when executed by a device, cause the device to include: responding to the received call request, and generating a required parameter object for a pre-constructed parallel call executor; the parallel call executor is used for calling a remote interface in parallel, and the parameter object comprises an input parameter and a predefined interface mark which are required for calling the remote interface; the parameter object is transmitted into the parallel calling executor, so that the parallel calling executor searches an interface method corresponding to the interface mark according to a first association relation between the stored interface mark and the interface method, and the searched interface method is called in parallel; and acquiring the return data of the remote interface, and mapping the return data to a predefined result object according to a set analysis strategy.
According to the technical scheme of the embodiment of the invention, the parameter entering and interface marks required by calling the remote interface are assembled into the parameter object, the interface methods required to be called are queried by the parallel calling executor according to the interface marks in the parameter object, the interface methods are called in parallel, the returned data of the remote interface is mapped into the final result according to the analysis strategy, the remote interface can be freely combined and called by one-time development on the premise of not introducing any external dependence, the robustness and service expansibility of the whole process are improved, the complexity of calling the remote interface in parallel is reduced, and the maintenance is convenient.
The product can execute the method provided by the embodiment of the invention, and has the corresponding functional modules and beneficial effects of the execution method. Technical details not described in detail in this embodiment may be found in the methods provided in the embodiments of the present invention.
The above embodiments do not limit the scope of the present invention. It will be apparent to those skilled in the art that various modifications, combinations, sub-combinations and alternatives can occur depending upon design requirements and other factors. Any modifications, equivalent substitutions and improvements made within the spirit and principles of the present invention should be included in the scope of the present invention.
Claims (10)
1. A method of processing a request, comprising:
responding to the received call request, and generating a required parameter object for a pre-constructed parallel call executor; the parallel call executor is used for calling a remote interface in parallel, and the parameter object comprises an input parameter and a predefined interface mark which are required for calling the remote interface;
the parameter object is transmitted into the parallel calling executor, so that the parallel calling executor searches an interface method corresponding to the interface mark according to a first association relation between the stored interface mark and the interface method, and the searched interface method is called in parallel;
Obtaining the return data of the remote interface, mapping the return data to a predefined result object according to a set analysis strategy, and comprising: invoking a parser agent contained in the parallel invoking executor to find out a parsing strategy corresponding to the interface mark according to a third association relation between the interface mark and the parsing strategy; and acquiring the return data of the remote interfaces according to the found analysis strategy, aggregating the return data of a plurality of remote interfaces to obtain an aggregation result, and assigning the aggregation result to a predefined result object.
2. The method of claim 1, wherein the parallel calling the found interface method comprises:
according to a second association relation between the stored interface mark and the interface instance, searching the interface instance corresponding to the interface mark;
and taking the searched interface instance and the input parameters of the searched interface method as parameters to input a reflection method, and executing the reflection method in parallel by adopting a plurality of threads.
3. The method of claim 2, wherein the parameter object is a plurality of; before the step of searching for the interface method corresponding to the interface mark, the method further includes:
Generating a plurality of corresponding minimum execution units according to the plurality of parameter objects and parameters configured for the minimum execution units in advance; the parameters of the minimum execution unit comprise the entry, the interface mark, an interface method corresponding to the interface mark, an interface instance corresponding to the interface mark and a result set;
the method for executing the reflection method in parallel by adopting a plurality of threads comprises the following steps: invoking the minimum execution unit, and executing the reflection method in parallel by adopting a plurality of threads;
after the step of executing the reflection method in parallel by using a plurality of threads, the method further comprises the following steps: and writing the return data of the remote interface into the result set.
4. The method according to claim 1, wherein the method further comprises:
newly adding the interface mark in the definition information of the remote interface, and newly adding an interface method annotation at the entrance of the interface method to be called; and the annotation value annotated by the interface method is the interface mark.
5. The method according to claim 4, wherein the method further comprises:
a first object for realizing the remote interface is transmitted into the construction method of the parallel call executor, and a corresponding interface mark is obtained according to the interface method annotation marked in the remote method of the first object;
The name of the interface mark is used as a key name, the interface method marked with the interface method annotation is used as a corresponding key value, the first association relation is generated, and the first association relation is stored in a first container of the parallel call executor;
the name of the interface mark is used as a key name, the interface instance is used as a corresponding key value, a second association relation is generated, and the second association relation is stored in a second container of the parallel calling executor; the interface instance is a first object to which the interface method belongs.
6. The method according to claim 1, wherein the method further comprises:
a second object for realizing the resolver is transmitted into the construction method of the resolver proxy;
generating a fourth association relation by taking the name of the resolver as a key name and the second object as a corresponding key value, and storing the fourth association relation into a third container of the resolver proxy;
the obtaining the return data of the remote interface includes:
inquiring a second object corresponding to the resolver name according to the resolver name carried in the found resolution strategy and the fourth association relation;
And acquiring the return data of the remote interface by using the searched second object reflection.
7. The method according to any of claims 1 to 6, wherein the interface tags are interface enumeration or string constants.
8. A request processing apparatus, comprising:
the parameter generation module is used for responding to the received call request and generating a required parameter object for the pre-constructed parallel call executor; the parallel call executor is used for calling a remote interface in parallel, and the parameter object comprises an input parameter and a predefined interface mark which are required for calling the remote interface;
the searching and calling module is used for transmitting the parameter object into the parallel calling executor so that the parallel calling executor searches the interface method corresponding to the interface mark according to the first association relation between the stored interface mark and the interface method and calls the searched interface method in parallel;
the result mapping module is configured to obtain return data of the remote interface, map the return data to a predefined result object according to a set resolution policy, and include: invoking a parser agent contained in the parallel invoking executor to find out a parsing strategy corresponding to the interface mark according to a third association relation between the interface mark and the parsing strategy; and acquiring the return data of the remote interfaces according to the found analysis strategy, aggregating the return data of a plurality of remote interfaces to obtain an aggregation result, and assigning the aggregation result to a predefined result object.
9. An electronic device, comprising:
one or more processors;
storage means for storing one or more programs,
when executed by the one or more processors, causes the one or more processors to implement the method of any of claims 1-7.
10. A computer readable medium, on which a computer program is stored, characterized in that the program, when being executed by a processor, implements the method according to any of claims 1-7.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110912665.XA CN113625998B (en) | 2021-08-10 | 2021-08-10 | Request processing method and device |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110912665.XA CN113625998B (en) | 2021-08-10 | 2021-08-10 | Request processing method and device |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN113625998A CN113625998A (en) | 2021-11-09 |
| CN113625998B true CN113625998B (en) | 2023-11-03 |
Family
ID=78384017
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202110912665.XA Active CN113625998B (en) | 2021-08-10 | 2021-08-10 | Request processing method and device |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN113625998B (en) |
Families Citing this family (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN114090135B (en) * | 2021-11-24 | 2024-05-24 | 北京金堤科技有限公司 | Method and device with error correction function and supporting cross-platform calling component |
| CN115495718B (en) * | 2022-09-19 | 2023-10-13 | 广东云徙智能科技有限公司 | Front-end statement-based back-end capability authorization method, device and equipment |
Citations (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN109375901A (en) * | 2018-09-03 | 2019-02-22 | 平安普惠企业管理有限公司 | Interface message management method, device, computer equipment and storage medium |
| CN109445845A (en) * | 2018-09-10 | 2019-03-08 | 深圳市智美达科技股份有限公司 | Interface call method, device, computer equipment and storage medium |
| US10521195B1 (en) * | 2019-03-19 | 2019-12-31 | Servicenow, Inc. | Guided definition of an application programming interface action for a workflow |
| CN110865889A (en) * | 2018-08-27 | 2020-03-06 | 北京高绎信息技术有限公司 | Method and apparatus for transferring events between components |
| CN112181535A (en) * | 2020-09-21 | 2021-01-05 | 中国建设银行股份有限公司 | Interface calling method, device, server and storage medium |
| CN112363707A (en) * | 2020-11-25 | 2021-02-12 | 国电南瑞科技股份有限公司 | Control layer general scheduling method based on JAVA reflection technology |
Family Cites Families (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20140372970A1 (en) * | 2013-06-13 | 2014-12-18 | International Business Machines Corporation | Method to auto generate jax-rs rest service implementation classes from existing interfaces |
-
2021
- 2021-08-10 CN CN202110912665.XA patent/CN113625998B/en active Active
Patent Citations (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN110865889A (en) * | 2018-08-27 | 2020-03-06 | 北京高绎信息技术有限公司 | Method and apparatus for transferring events between components |
| CN109375901A (en) * | 2018-09-03 | 2019-02-22 | 平安普惠企业管理有限公司 | Interface message management method, device, computer equipment and storage medium |
| CN109445845A (en) * | 2018-09-10 | 2019-03-08 | 深圳市智美达科技股份有限公司 | Interface call method, device, computer equipment and storage medium |
| US10521195B1 (en) * | 2019-03-19 | 2019-12-31 | Servicenow, Inc. | Guided definition of an application programming interface action for a workflow |
| CN112181535A (en) * | 2020-09-21 | 2021-01-05 | 中国建设银行股份有限公司 | Interface calling method, device, server and storage medium |
| CN112363707A (en) * | 2020-11-25 | 2021-02-12 | 国电南瑞科技股份有限公司 | Control layer general scheduling method based on JAVA reflection technology |
Non-Patent Citations (3)
| Title |
|---|
| J2EE中对象关系映射的研究与实现;余俊新;孙涌;;计算机技术与发展(03);94-96+100 * |
| 基于Java动态代理的构件重构框架;徐学东;长春工程学院学报;65-67 * |
| 基于反射植入的面向对象程序动态分析机制;柴晓前, 陈平;微机发展(05);12-14+18 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN113625998A (en) | 2021-11-09 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US10387171B2 (en) | Configurable development platform integrating heterogeneous persistence systems | |
| US10942708B2 (en) | Generating web API specification from online documentation | |
| US20090254881A1 (en) | Code generation techniques for administrative tasks | |
| US10789362B2 (en) | Taint analysis with access paths | |
| CN113625998B (en) | Request processing method and device | |
| CN110263277B (en) | Page data display method, page data updating device, page data equipment and storage medium | |
| US11086827B1 (en) | Dataset schema and metadata management service | |
| US20140297620A1 (en) | Analytics based on pipes programming model | |
| CN109783562B (en) | Service processing method and device | |
| CN111666293A (en) | Database access method and device | |
| US11157467B2 (en) | Reducing response time for queries directed to domain-specific knowledge graph using property graph schema optimization | |
| US20210232377A1 (en) | Encoding dependencies in call graphs | |
| CN115599386A (en) | Code generation method, device, equipment and storage medium | |
| CN113419740A (en) | Program data stream analysis method and device, electronic device and readable storage medium | |
| CN108959294B (en) | Method and device for accessing search engine | |
| CN111324395B (en) | Calling method, device and computer readable storage medium | |
| CN111459991B (en) | Information query method and device | |
| US10789048B2 (en) | Namespace and class utilities for managed packages | |
| CN111158777A (en) | Component calling method and device and computer readable storage medium | |
| US20130097622A1 (en) | Framework for system communication for handling data | |
| CN117009397A (en) | Data query method, data query device, electronic equipment and storage medium | |
| US10620946B1 (en) | Dynamic modeling for opaque code during static analysis | |
| CA3089289C (en) | System and methods for loading objects from hash chains | |
| CN115687815A (en) | Page information display method, device, equipment and medium | |
| US10783245B2 (en) | Feedback-directed static analysis |
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 |