CN113625998A - Request processing method and device - Google Patents
Request processing method and device Download PDFInfo
- Publication number
- CN113625998A CN113625998A CN202110912665.XA CN202110912665A CN113625998A CN 113625998 A CN113625998 A CN 113625998A CN 202110912665 A CN202110912665 A CN 202110912665A CN 113625998 A CN113625998 A CN 113625998A
- Authority
- CN
- China
- Prior art keywords
- interface
- parallel
- calling
- remote
- mark
- 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
- 238000003672 processing method Methods 0.000 title abstract description 26
- 238000000034 method Methods 0.000 claims abstract description 168
- 238000004458 analytical method Methods 0.000 claims abstract description 36
- 238000013507 mapping Methods 0.000 claims abstract description 18
- 239000003795 chemical substances by application Substances 0.000 claims description 23
- 238000012545 processing Methods 0.000 claims description 22
- 238000001028 reflection method Methods 0.000 claims description 16
- 238000010276 construction Methods 0.000 claims description 12
- 230000002776 aggregation Effects 0.000 claims description 11
- 238000004220 aggregation Methods 0.000 claims description 11
- 238000004590 computer program Methods 0.000 claims description 10
- 230000004931 aggregating effect Effects 0.000 claims description 5
- 239000003550 marker Substances 0.000 claims 1
- 238000011161 development Methods 0.000 abstract description 6
- 238000010586 diagram Methods 0.000 description 21
- 235000010627 Phaseolus vulgaris Nutrition 0.000 description 16
- 244000046052 Phaseolus vulgaris Species 0.000 description 16
- 230000008569 process Effects 0.000 description 12
- 230000007246 mechanism Effects 0.000 description 7
- 238000004891 communication Methods 0.000 description 6
- 230000006870 function Effects 0.000 description 6
- 238000007726 management method Methods 0.000 description 4
- 230000004048 modification Effects 0.000 description 4
- 238000012986 modification Methods 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
- 238000012423 maintenance Methods 0.000 description 3
- 230000004044 response Effects 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
- 239000004065 semiconductor Substances 0.000 description 2
- 238000013459 approach 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
- 230000006872 improvement 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
- 239000013307 optical fiber Substances 0.000 description 1
- 230000003068 static effect Effects 0.000 description 1
- 238000006467 substitution reaction Methods 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/20—Software design
-
- 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: responding to the received call request, and generating a required parameter object for the pre-constructed parallel call executer; 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 actuator, so that the parallel calling actuator searches an interface method corresponding to the interface mark according to a first incidence 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. The method realizes that the remote interfaces can be freely combined and called by one-time development on the premise of not introducing any external dependence, reduces the complexity of parallel calling of the remote interfaces and is convenient to maintain.
Description
Technical Field
The present invention relates to the field of computer technologies, and in particular, to a request processing method and apparatus.
Background
A report usually contains a plurality of index data, and the index data usually comes from a plurality of remote interfaces provided by data services. At present, when a report is generated, request parameters of different remote interfaces are constructed by combining data required to be displayed on each display page, and calling of the remote interfaces is placed into a Java instance and executed concurrently, so that the remote interfaces return data according to a data format agreed with the display page, and the return data of the remote interfaces can be processed subsequently to obtain a required result.
In the process of implementing the invention, the prior art at least has the following problems:
under the condition that the calling mode of the remote interface, the returned data format and the like are changed, all methods using the remote interface need to be checked and modified; in the case of a newly added remote interface, a code for calling the newly added remote interface needs to be added to an original code, and meanwhile, a processing procedure for returning data needs to be added at all positions where data of the newly added remote interface is used, especially, in the case where returning data of a plurality of remote interfaces needs to be aggregated, so that a large amount of modification needs to be performed on the original code.
Disclosure of Invention
In view of this, embodiments of the present invention provide a request processing method and apparatus, in which an entry parameter and an interface flag required for invoking a remote interface are assembled into a parameter object, a parallel invocation executor queries an interface method to be invoked according to the interface flag in the parameter object, and invokes the interface methods in parallel, and further maps return data of the remote interface into a final result according to an analysis policy.
To achieve the above object, according to an aspect of an embodiment of the present invention, a request processing method is provided.
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 the pre-constructed parallel call executer; the parallel calling executor is used for calling a remote interface in parallel, and the parameter object comprises an entry parameter and a predefined interface mark which are required for calling the remote interface; the parameter object is transmitted into the parallel calling actuator, so that the parallel calling actuator searches an interface method corresponding to the interface mark according to a first incidence 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 of the found interface method includes: searching an interface instance corresponding to the interface mark according to a second incidence relation between the stored interface mark and the interface instance; and transmitting the searched interface instance and the input parameters of the searched interface method into a reflection method as parameters, and executing the reflection method in parallel by adopting a plurality of threads.
Optionally, the parameter object is a plurality of objects; 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 parameter objects and parameters configured for the minimum execution units in advance; wherein the parameters of the minimum execution unit include 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 in parallel by adopting a plurality of threads comprises the following steps: calling 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: and writing the return data of the remote interface into the result set.
Optionally, the method further comprises: adding the interface mark in the definition information of the remote interface, and adding an interface method annotation at an entrance of the interface method to be called; and the annotation value of the interface method annotation 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 calling actuator, and a corresponding interface mark is obtained according to the interface method annotation marked in the remote method of the first object; generating a first association relation by taking the name of the interface mark as a key name and the interface method marked with the interface method annotation as a corresponding key value, and storing the first association relation to a first container of the parallel calling actuator; generating a second association relation by taking the name of the interface mark as a key name and taking an interface instance as a corresponding key value, and storing the second association relation to a second container of the parallel calling actuator; wherein the interface instance is a first object to which the interface method belongs.
Optionally, the obtaining the return data of the remote interface, and mapping the return data to a predefined result object according to a set parsing policy includes: calling an analyzer agent contained in the parallel calling actuator to search an analysis strategy corresponding to an interface mark according to a third correlation relation between the interface mark and the analysis strategy; and acquiring the return data of the remote interfaces according to the searched analysis strategy, aggregating the return data of the remote interfaces to obtain an aggregation result, and assigning the aggregation result to a predefined result object.
Optionally, the method further comprises: transmitting a second object for realizing a resolver into the construction method of the resolver 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 agent; the acquiring the return data of the remote interface comprises: inquiring a second object corresponding to the resolver name according to the resolver name carried in the searched resolution strategy and the fourth incidence relation; and acquiring return data of the remote interface by using the searched second object reflection.
Optionally, the interface is marked as an interface enumeration or a string constant.
To achieve the above object, according to another aspect of the embodiments of the present invention, there is provided a request processing apparatus.
A request processing device of an embodiment of the present invention includes: the parameter generation module is used for responding to the received calling request and generating a required parameter object for the pre-constructed parallel calling actuator; the parallel calling executor is used for calling a remote interface in parallel, and the parameter object comprises an entry 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 actuator, so that the parallel calling actuator searches the interface method corresponding to the interface mark according to the first incidence 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 search calling module is further configured to search, according to a second association relationship between the stored interface tag and the interface instance, an interface instance corresponding to the interface tag; and transmitting the searched interface instance and the input parameters of the searched interface method into a reflection method as parameters, and executing the reflection method in parallel by adopting a plurality of threads.
Optionally, the parameter object is a plurality of objects; the device further comprises: the minimum execution unit generating module is used for generating a plurality of corresponding minimum execution units according to the parameter objects and the parameters configured for the minimum execution units in advance; wherein the parameters of the minimum execution unit include 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 device 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 newly-added module is used for newly adding the interface mark in the definition information of the remote interface and newly adding an interface method annotation at an entrance of the interface method to be called; and the annotation value of the interface method annotation is the interface mark.
Optionally, the apparatus further comprises: the container initialization module is used for transmitting a first object for realizing the remote interface into the construction method of the parallel calling actuator and acquiring a corresponding interface mark according to an interface method annotation marked in a remote method of the first object; generating a first association relation by taking the name of the interface mark as a key name and the interface method marked with the interface method annotation as a corresponding key value, and storing the first association relation to a first container of the parallel calling actuator; generating a second association relation by taking the name of the interface mark as a key name and taking an interface instance as a corresponding key value, and storing the second association relation to a second container of the parallel calling actuator; wherein the interface instance is a first object to which the interface method belongs.
Optionally, the result mapping module is further configured to invoke an analyzer agent included in the parallel invocation actuator, so as to search an analysis policy corresponding to the interface tag according to a third correlation between the interface tag and the analysis policy; and acquiring the return data of the remote interfaces according to the searched analysis strategy, aggregating the return data of the remote interfaces to obtain an aggregation result, and assigning the aggregation result to a predefined result object.
Optionally, the apparatus further comprises: the resolver agent instantiation module is used for transmitting a second object for realizing a resolver into the construction method of the resolver 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 agent; the result mapping module is further configured to query a second object corresponding to the resolver name according to the resolver name and the fourth association relation carried in the found resolution policy; and acquiring return data of the remote interface by using the searched second object reflection.
Optionally, the interface is marked as an interface enumeration or a string constant.
To achieve the above object, according to still another aspect of embodiments of the present invention, there is provided an electronic apparatus.
An electronic device of an embodiment of the present invention includes: one or more processors; a storage device, configured to store one or more programs, which when executed by the one or more processors, cause the one or more processors to implement a request processing method according to an embodiment of the present invention.
To achieve the above object, according to still another aspect of 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 that, 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 input parameters and interface marks required by calling a remote interface into a parameter object, subsequently inquiring interface methods required to be called by a parallel calling actuator according to the interface marks in the parameter object, calling the interface methods in parallel, mapping return data of the remote interface into a final result according to an analysis strategy, realizing one-time development and freely combining and calling the remote interface on the premise of not introducing any external dependence, simultaneously improving the robustness and the service expansibility of the whole process, reducing the complexity of parallel calling of the remote interface 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 respectively generating corresponding minimum execution units for each parameter object, and then utilizing the minimum execution units to call the interface method in parallel, so that when a new remote interface is accessed, the workload of encapsulating parameters can be reduced as much as possible, and meanwhile, the returned data is stored in the minimum execution units to wait for the identification of the resolver agent. By adding an 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, different remote interfaces can be distinguished conveniently.
The interface method and the interface instance marked by the interface method annotation are stored through the Java container technology, and a lightweight processing architecture is realized. By means of the self-defined analysis strategy, on-demand aggregation processing of return data of the multiple remote interfaces is achieved, and the processing flow is improved. By searching the second object corresponding to the resolution name, the data returned by the remote interface can be dynamically acquired by utilizing a reflection mechanism. And the remote interface is identified by using the interface enumeration mark, so that the management is convenient.
Further effects of the above-mentioned non-conventional alternatives will be 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 invention;
FIG. 2 is a diagram illustrating the structure of Java classes used in the request processing method according to the embodiment of the present invention;
FIG. 3 is a schematic main flow chart diagram of a request processing method according to an embodiment of the invention;
FIG. 4 is a schematic diagram illustrating an assembly principle of parameter objects in a request processing method according to an embodiment of the present invention;
FIG. 5 is a schematic main flowchart of a method for 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 employed;
FIG. 8 is a schematic diagram of a computer apparatus suitable for use in an electronic device to implement an embodiment of the invention.
Detailed Description
Exemplary embodiments of the present invention are described below with reference to the accompanying drawings, in which various details of embodiments of the invention are included to assist understanding, and which are to be considered as 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 the main steps of a request processing method according to an embodiment of the present invention.
As shown in fig. 1, the request processing method according to the embodiment of the present invention mainly includes the following steps:
step S101: and generating required parameter objects for the pre-constructed parallel calling executors in response to the received calling requests. The front-end sends a call request to a target interface, which may be, for example, a report interface for generating reports. And after receiving the calling request, the target interface generates a required parameter object for the pre-constructed parallel calling actuator according to the remote interface required to be called. The parallel calling executor is used for calling the remote interface in parallel. The parameter objects include entries required to invoke the remote interface, and predefined interface tags identifying the interface methods that need to be invoked.
Step S102: and transmitting the parameter object into the parallel calling actuator, so that the parallel calling actuator searches the interface method corresponding to the interface mark according to the first incidence relation between the stored interface mark and the interface method, and calls the searched interface method in parallel. And calling a parallel calling actuator, searching the interface method corresponding to the interface mark contained in the parameter object by the parallel calling actuator according to the first incidence relation between the stored interface mark and the interface method, 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 actual requirements, an analysis strategy can be configured in advance, and the analysis strategy is used for analyzing the returned data into a required result object, so that parallel calling of the remote interface and processing of the returned data are completed. In an embodiment, the resolution strategy can be divided into three categories, namely single Bean resolution, array Bean resolution and aggregation of multiple Bean resolutions. Where Bean is a software component model that describes Java.
The single Bean analysis maps the acquired return data to a result object through a get method or a reflection mechanism. In the case that the array Bean analysis is directed at the condition that the returned data of the remote interface is a List (List), the analysis needs to traverse the obtained 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 analysis. And aggregating a plurality of Bean analyses aiming at the condition that the result object is a combination of return data from a plurality of remote interfaces, acquiring the return data by the analysis through a get method or a reflection mechanism, and aggregating 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 the embodiment of the present invention. As shown in fig. 2, the implementation process of the request processing method according to the embodiment of the present invention is divided into four parts, namely preparation, parameter object construction, parallel calling of an executor and parser execution. The preparation part is used for defining annotation of method level (namely interface method annotation) and marking which are interface methods of the remote interface which need to be called actually. The parameter object building 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 resolver agent. The first container, namely the methodMap, is used for storing the first incidence relation between the interface mark and the interface method; the second container, namely the objectMap, is used for storing the second incidence relation between the interface mark and the interface instance; the threadPooleExecutor taskExecutor is used for concurrently calling the thread; resultpartpartserproxy is the resolver proxy.
The parser is used for parsing the mapping relation between the return data and the final result object, and the design scheme based on the parsing strategy and the proxy mode is implemented in the embodiment. The analytic strategies are mainly divided into three categories: single Bean resolution, array Bean resolution, and aggregate multiple Bean resolutions.
Fig. 3 is a main flow diagram of a request processing method according to an embodiment of the present invention. As shown in fig. 3, the request processing method according to the embodiment of the present invention mainly includes the following steps:
step S301: a remote interface is developed. In the step, an interface mark needs to be added in definition information of the remote interface, then the remote interface is normally developed and called, an interface method annotation is added at an entrance of the interface method needing to be called, and an annotation value of the interface method annotation is the added interface mark.
The interface identifier is used to distinguish different remote interfaces, and the interface identifier of each remote interface is different. Interface enumeration is used as an interface mark, and the management is easier compared with character string constants. Interface members of various data types, such as enumeration type, string type, 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, the parser needs to be implemented by itself, and in a preferred embodiment, the parser with certain generality can be implemented on the returned data by combining with a Java reflection mechanism. The universal resolver can reflect and acquire return data through a configured get method name, and map the return data to a result object.
In addition, if the existing resolver can not resolve the return data of the remote interface, a new resolver needs to be developed, and the parserName () method of the resolver corresponds to the name of the interface tag.
In the embodiment, in order to return the result object to the front end, a target interface is also required to be developed. The target interface assembles parameter objects required by the parallel call executors as required and calls the queryDataAsync () method of the parallel call executors. Wherein the Class of the queryDataAsync () method is the Class of incoming return data. The parameter object includes entries and interface tags required to invoke the remote interface. When the number of the input parameters is multiple, the input parameters are put into the array in sequence.
Step S302: and constructing a parallel calling executor. The parallel call executor comprises a first container, a second container, a thread pool and a resolver agent, and the parallel call executor is constructed, namely the first container and the second container are initialized, the resolver agent is instantiated, and the thread pool is initialized. The resolver agent stores a fourth incidence relation with the resolver name as the key name and the second object as the corresponding key value. Wherein the second object is an object for implementing the parser. The specific implementation of this step is described later with respect to fig. 5.
Step S303: and under the condition of receiving a call request of the front end, generating a parameter object required by the parallel call actuator according to the remote interface needing to be called. After receiving a calling request from a front end, a target interface assembles a parameter object (LhmReqParam) required by a parallel calling actuator according to a remote interface required to be called by the target interface.
The assembly of the parameter object is a process of generating a "class structure diagram-parameter object", specifically, a remote call parameter (including an entry and an interface flag required for calling a remote interface) is generated first and then encapsulated in the parameter object. The class structure diagram shows the static structure of the model, in particular, the classes existing in the model, the internal structure of the classes, the relationship between the classes and other classes, and the like.
Fig. 4 is a schematic diagram illustrating an assembly principle of parameter objects in the request processing method according to the embodiment of the present invention. As shown in fig. 4, in this embodiment, the entry and interface tags corresponding to the same remote interface are assembled into corresponding parameter objects, and all the parameter objects are merged into a List to obtain a final parameter object.
Step S304: and transmitting the parameter object into a parallel calling executor, so that the parallel executor generates a corresponding minimum execution unit according to the parameter object and the parameter configured for the minimum execution unit in advance. The target interface transmits the object parameters to the parallel calling executor. And the parallel calling actuator initializes and copies all parameters in the minimum execution unit (LhmReqHandler) according to the transmitted parameter object to obtain the corresponding minimum execution unit. The minimum execution unit is a class calling an interface method of the remote interface through reflection, and parameters contained in the minimum execution unit are shown in table 1.
TABLE 1
In table 1, column 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 executors, so that the workload of encapsulating the remote interface references when accessing a new remote interface is reduced as much as possible.
Step S305: and calling the minimum execution unit, and searching an interface method and an interface instance corresponding to the interface mark according to the stored first incidence relation and the second incidence relation. The minimum execution unit searches an interface method corresponding to the interface mark contained in the parameter object according to the stored first incidence relation; and searching the interface instance corresponding to the interface mark contained in the parameter object according to the stored second incidence relation.
Step S306: and transmitting the searched interface instance and the input parameters of the searched interface method into a reflection method as parameters, executing the reflection method in parallel by adopting a plurality of threads, and writing the return data of the remote interface into a result set. This step is used to invoke the interface method of the remote interface through the reflection mechanism, and then assign the return data of the remote interface to the result set. The reflection method is executed in parallel in the step, and the reflection method can be realized by a Java thread pool and CountDownLatch. Wherein, the CountDownLatch can enable one thread to continue executing after waiting for other threads to finish respective work.
In an embodiment, the reflection method is an invoke () method, which is used as follows: public Object invoke (Object obj, Object.. args), that is, there are two parameters for the method, obj is the Object of the called method and args is the argument of the called method.
Step S307: the parser proxy is invoked to identify return data in the result set by the parser proxy and map the return data into the result object. The parser agent identifies the returned data in the result set, and then maps the returned data to the result object according to a set parsing strategy.
When return data in the result set is identified, an analysis strategy corresponding to the interface tag needs to be searched according to a third association relation between the interface tag and the analysis strategy, then a second object corresponding to the resolver name is inquired according to the resolver name and a fourth association relation carried in the searched analysis strategy, and then the searched second object is used for reflection to obtain return data of the remote interface.
If the analysis policy is to aggregate multiple Bean analyses, the returned data of multiple remote interfaces can be aggregated to obtain an aggregation result, and the aggregation result is assigned to a predefined result object. Illustratively, assume that the result object TestBean class includes two attributes id and totalNum, the return data for remote interface a includes two attributes id and numA, the return data for remote interface B includes two attributes id and numB, and totalNum is derived from the numA + numB addition of the same id in remote interface a and remote interface B.
Assuming that return data of the remote interface a is acquired first by a get method or a reflection mechanism, a new result object TestBean is generated, and the attributes of the new result object TestBean are as follows: id is a.id; totalNum ═ a.numa; when the return data of the remote interface B is acquired, totalNum in the TestBean with id equal to b.id is found and added, and at this time, totalNum equal to totalNum + numB is obtained, and then the final result object is obtained.
The embodiment decouples the process from batch interface access to return data processing in the prior art, and realizes parallel calling of a plurality of remote interfaces and processing of return data only through the Java self-owned technology and a software development design mode on the premise of not introducing any external dependence, thereby improving the robustness and service expansibility of the whole process, reducing the complexity of parallel calling of the remote interfaces and facilitating maintenance. 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 container-stored remote interface call object information (including class name, method name) and the parser object information may be put into a database, and the remote interface call object may be instantiated in a reflection manner, so as to implement a configurable remote interface access and return data mapping scheme.
For the above mode, the configuration information called by the remote interface needs to be inquired 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 the remote interface calling object according to the class name, then constructing a parallel calling actuator according to the step S302, and executing the subsequent steps. It will be appreciated that in this approach, the interface is labeled as a remote task name. In addition, when the parallel call executor is constructed, instantiated remote interface call objects need to be transmitted to a constructor of the parallel call executor.
Fig. 5 is a schematic main flow diagram of constructing a parallel call executor in the request processing method according to the embodiment of the present invention. As shown in fig. 5, an implementation process (i.e., step S302) for constructing a parallel call executor according to an embodiment of the present invention mainly includes the following steps:
step S501: and transmitting a first object for realizing a remote interface into a construction method of the parallel calling actuator, and acquiring a corresponding interface mark according to an interface method annotation marked in a remote method of the first object. The step is used for acquiring all objects which realize the remote interface, and determining whether to store the objects in the container according to whether the remote methods of the objects have interface method annotation. In the embodiment, all objects that implement the remote interface may be obtained by a spring (a Java development framework) injection manner.
Step S502: a first container of parallel call executors is initialized. And generating a first association relation by taking the acquired name of the interface mark as a key name (key) and the interface method marked with the interface method annotation as a corresponding key value (value), and storing the first association relation to a first container of the parallel call executor.
Step S503: a second container of parallel call executors is initialized. Generating a second association relation by taking the acquired name of the interface mark as a key name (key) and the interface instance as a corresponding key value (value), and storing the second association relation to a second container of the parallel call actuator; the interface instance is a first object to which the interface method belongs.
Step S504: a resolver agent is instantiated. And transmitting a second object for realizing the resolver to a construction method of the resolver agent, generating a fourth association relationship by taking the resolver name as a key name (key) and the second object as a corresponding key value (value), and storing the fourth association relationship into a third container (namely, a parserMap container) of the resolver agent. Wherein the incoming second object does not contain a proxy class. The resolver name is the value returned by the parserName () method.
Step S505: a thread pool is initialized. And initializing a thread pool for calling the remote interfaces in parallel.
The parallel call executor constructed in 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 blocks 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:
and the parameter generating module 601 is configured to generate a required parameter object for the pre-constructed parallel call executor in response to the received call request. The front-end sends a call request to a target interface, which may be, for example, a report interface for generating reports. And after receiving the calling request, the target interface generates a required parameter object for the pre-constructed parallel calling actuator according to the remote interface required to be called. The parallel calling executor is used for calling the remote interface in parallel. The parameter objects include entries required to invoke the remote interface, and predefined interface tags identifying the interface methods that need to be invoked.
The search calling module 602 is configured to send the parameter object to the parallel calling executor, so that the parallel calling executor searches, according to the first association relationship between the stored interface tag and the interface method, the interface method corresponding to the interface tag, and calls the searched interface method in parallel. And calling a parallel calling actuator, searching the interface method corresponding to the interface mark contained in the parameter object by the parallel calling actuator according to the first incidence relation between the stored interface mark and the interface method, and calling the searched interface method in parallel through the initialized thread pool.
A result mapping module 603, configured to obtain return data of the remote interface, and map the return data to a predefined result object according to a set parsing policy. According to actual requirements, an analysis strategy can be configured in advance, and the analysis strategy is used for analyzing the returned data into a required result object. In an embodiment, the resolution strategy can be divided into three categories, namely single Bean resolution, array Bean resolution and aggregation of multiple Bean resolutions. Where Bean is a software component model that describes Java.
In addition, the request processing apparatus 600 according to the embodiment of the present invention may further include: a minimum execution unit generation module, a write module, a add module, a container initialization module, and a parser 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 parameter objects and the parameters configured for the minimum execution units in advance; wherein the parameters of the minimum execution unit include the entry, the interface flag, an interface method corresponding to the interface flag, an interface instance corresponding to the interface flag, and a result set.
And the writing module is used for writing the return data of the remote interface into the result set. The newly-added module is used for newly adding the interface mark in the definition information of the remote interface and newly adding an interface method annotation at an entrance of the interface method to be called; and the annotation value of the interface method annotation is the interface mark.
The container initialization module is used for transmitting a first object for realizing the remote interface into the construction method of the parallel calling actuator and acquiring a corresponding interface mark according to an interface method annotation marked in a remote method of the first object; generating a first association relation by taking the name of the interface mark as a key name and the interface method marked with the interface method annotation as a corresponding key value, and storing the first association relation to a first container of the parallel calling actuator; generating a second association relation by taking the name of the interface mark as a key name and taking an interface instance as a corresponding key value, and storing the second association relation to a second container of the parallel calling actuator; wherein the interface instance is a first object to which the interface method belongs.
The resolver agent instantiation module is used for transmitting a second object for realizing a resolver into the construction method of the resolver 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 agent.
It can be seen from the above description that, by assembling the entry and interface marks required for calling the remote interface into a parameter object, subsequently querying the interface methods to be called by the parallel calling executor according to the interface marks in the parameter object, calling the interface methods in parallel, and then mapping the returned data of the remote interface into a final result according to the parsing strategy, the remote interface can be freely combined and called by one-time development on the premise of not introducing any external dependency, meanwhile, the robustness and service expansibility of the whole process are improved, the complexity of parallel calling of the remote interface is reduced, and the maintenance is facilitated.
Fig. 7 illustrates an exemplary system architecture 700 to which the request processing method or request processing apparatus of embodiments of the invention may be applied.
As shown in fig. 7, the system architecture 700 may include terminal devices 701, 702, 703, a network 704, and a server 705. The network 704 serves to provide a medium for communication links between the terminal devices 701, 702, 703 and the server 705. Network 704 may include various connection types, such as wired, wireless communication links, or fiber optic cables, to name a few.
A user may use the terminal devices 701, 702, 703 to interact with a server 705 over a network 704, 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 smart phones, tablet computers, laptop portable computers, desktop computers, and the like.
The server 705 may be a server that provides various services, such as a background management server that processes call requests sent by an administrator using the terminal apparatuses 701, 702, and 703. The background management server may generate a parameter object, search for an interface method, invoke the interface method in parallel, obtain return data, map the return data to a result object, and feed back a processing result (e.g., the result object) to the terminal device.
It should be noted that the request processing method provided in the embodiment of the present application is generally executed by the server 705, and accordingly, the request processing apparatus 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.
The invention also provides an electronic device and a computer readable medium according to the embodiment of the invention.
The electronic device of the present invention includes: one or more processors; a storage device, configured to store one or more programs, which when executed by the one or more processors, cause the one or more processors to implement a request processing method according to an embodiment of the present invention.
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, shown is a block diagram of a computer system 800 suitable for use in implementing an electronic device of an embodiment of the present invention. The electronic device shown in fig. 8 is only an example, and should not bring any limitation to the functions and the scope of use of the embodiments of the present 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 in accordance with 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 necessary for the operation of the computer system 800 are also stored. The CPU 801, ROM 802, and RAM 803 are connected to each other via a bus 804. An input/output (I/O) interface 805 is also connected to bus 804.
The following components are connected to the I/O interface 805: an input portion 806 including a keyboard, a mouse, and the like; an output section 807 including a signal such as a Cathode Ray Tube (CRT), a Liquid Crystal Display (LCD), and the like, and a speaker; a storage portion 808 including a hard disk and 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. A drive 810 is also connected to the I/O interface 805 as necessary. 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 necessary, so that a computer program read out therefrom is mounted on the storage section 808 as necessary.
In particular, the processes described above with respect to the main step diagrams may be implemented as computer software programs, according to embodiments of the present disclosure. 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 containing program code for performing the method illustrated in the main step diagram. In such an embodiment, the computer program can be downloaded and installed from a network through the communication section 809 and/or installed from the removable medium 811. The computer program executes the above-described functions defined in the system of the present invention when executed by the Central Processing Unit (CPU) 801.
It should be noted that the computer readable medium shown in the present invention can be a computer readable signal medium or a computer readable storage medium or any combination of the two. A computer readable storage medium may be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination 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 present invention, 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, a computer readable signal medium may include a propagated data signal with computer readable program code embodied therein, for example, in baseband or as part of a carrier wave. Such a propagated data signal may take many forms, including, but not limited to, electro-magnetic, optical, or any suitable combination thereof. 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 flowchart 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 described in the embodiments of the present invention may be implemented by software or hardware. The described modules may also be provided in a processor, which may be described as: a processor includes a parameter generation module, a lookup invocation module, and a result mapping module. Where the names of these modules do not in some cases constitute a limitation on the modules themselves, for example, a 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 separate and not incorporated into the device. The computer readable medium carries one or more programs which, when executed by a device, cause the device to comprise: responding to the received call request, and generating a required parameter object for the pre-constructed parallel call executer; the parallel calling executor is used for calling a remote interface in parallel, and the parameter object comprises an entry parameter and a predefined interface mark which are required for calling the remote interface; the parameter object is transmitted into the parallel calling actuator, so that the parallel calling actuator searches an interface method corresponding to the interface mark according to a first incidence 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 entry parameters and the interface marks required by calling the remote interface are assembled into the parameter object, the parallel calling actuator is used for inquiring the interface methods to be called subsequently according to the interface marks in the parameter object, the interface methods are called in parallel, and then the returned data of the remote interface is mapped into a final result according to the analysis strategy.
The product can execute the method provided by the embodiment of the invention, and has corresponding functional modules and beneficial effects of the execution method. For technical details that are not described in detail in this embodiment, reference may be made to the method provided by the embodiment of the present invention.
The above-described embodiments should not be construed as limiting the scope of the invention. Those skilled in the art will appreciate that various modifications, combinations, sub-combinations, and substitutions can occur, depending on design requirements and other factors. Any modification, equivalent replacement, and improvement made within the spirit and principle of the present invention should be included in the protection scope of the present invention.
Claims (11)
1. A method for processing a request, comprising:
responding to the received call request, and generating a required parameter object for the pre-constructed parallel call executer; the parallel calling executor is used for calling a remote interface in parallel, and the parameter object comprises an entry parameter and a predefined interface mark which are required for calling the remote interface;
the parameter object is transmitted into the parallel calling actuator, so that the parallel calling actuator searches an interface method corresponding to the interface mark according to a first incidence 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.
2. The method of claim 1, wherein said invoking the located interface method in parallel comprises:
searching an interface instance corresponding to the interface mark according to a second incidence relation between the stored interface mark and the interface instance;
and transmitting the searched interface instance and the input parameters of the searched interface method into a reflection method as parameters, and executing the reflection method in parallel by adopting a plurality of threads.
3. The method of claim 2, wherein the parameter object is plural; 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 parameter objects and parameters configured for the minimum execution units in advance; wherein the parameters of the minimum execution unit include 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 in parallel by adopting a plurality of threads comprises the following steps: calling 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: and writing the return data of the remote interface into the result set.
4. The method of claim 1, further comprising:
adding the interface mark in the definition information of the remote interface, and adding an interface method annotation at an entrance of the interface method to be called; and the annotation value of the interface method annotation is the interface mark.
5. The method of claim 4, further comprising:
a first object for realizing the remote interface is transmitted into the construction method of the parallel calling actuator, and a corresponding interface mark is obtained according to the interface method annotation marked in the remote method of the first object;
generating a first association relation by taking the name of the interface mark as a key name and the interface method marked with the interface method annotation as a corresponding key value, and storing the first association relation to a first container of the parallel calling actuator;
generating a second association relation by taking the name of the interface mark as a key name and taking an interface instance as a corresponding key value, and storing the second association relation to a second container of the parallel calling actuator; wherein the interface instance is a first object to which the interface method belongs.
6. The method of claim 1, wherein the obtaining the return data of the remote interface and mapping the return data to a predefined result object according to a set parsing policy comprises:
calling an analyzer agent contained in the parallel calling actuator to search an analysis strategy corresponding to an interface mark according to a third correlation relation between the interface mark and the analysis strategy;
and acquiring the return data of the remote interfaces according to the searched analysis strategy, aggregating the return data of the remote interfaces to obtain an aggregation result, and assigning the aggregation result to a predefined result object.
7. The method of claim 6, further comprising:
transmitting a second object for realizing a resolver into the construction method of the resolver 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 agent;
the acquiring the return data of the remote interface comprises:
inquiring a second object corresponding to the resolver name according to the resolver name carried in the searched resolution strategy and the fourth incidence relation;
and acquiring return data of the remote interface by using the searched second object reflection.
8. The method according to any of claims 1 to 7, wherein the interface marker is an interface enumeration or a string constant.
9. A request processing apparatus, comprising:
the parameter generation module is used for responding to the received calling request and generating a required parameter object for the pre-constructed parallel calling actuator; the parallel calling executor is used for calling a remote interface in parallel, and the parameter object comprises an entry 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 actuator, so that the parallel calling actuator searches the interface method corresponding to the interface mark according to the first incidence 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.
10. An electronic device, comprising:
one or more processors;
a storage device for storing one or more programs,
when executed by the one or more processors, cause the one or more processors to implement the method of any one of claims 1-8.
11. A computer-readable medium, on which a computer program is stored, which, when being executed by a processor, carries out the method according to any one of claims 1-8.
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 true CN113625998A (en) | 2021-11-09 |
| CN113625998B 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) |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN114090135A (en) * | 2021-11-24 | 2022-02-25 | 北京金堤科技有限公司 | Method and device with error correction function and supporting cross-platform calling component |
| CN115495718A (en) * | 2022-09-19 | 2022-12-20 | 广东云徙智能科技有限公司 | Method, device and equipment for authorizing back-end capability based on front-end declaration |
Citations (7)
| 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 |
| 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 |
-
2021
- 2021-08-10 CN CN202110912665.XA patent/CN113625998B/en active Active
Patent Citations (7)
| 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 |
| 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中对象关系映射的研究与实现", 计算机技术与发展, no. 03, pages 94 - 96 * |
| 徐学东: "基于Java动态代理的构件重构框架", 长春工程学院学报, pages 65 - 67 * |
| 柴晓前, 陈平: "基于反射植入的面向对象程序动态分析机制", 微机发展, no. 05, pages 12 - 14 * |
Cited By (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN114090135A (en) * | 2021-11-24 | 2022-02-25 | 北京金堤科技有限公司 | Method and device with error correction function and supporting cross-platform calling component |
| CN114090135B (en) * | 2021-11-24 | 2024-05-24 | 北京金堤科技有限公司 | Method and device with error correction function and supporting cross-platform calling component |
| CN115495718A (en) * | 2022-09-19 | 2022-12-20 | 广东云徙智能科技有限公司 | Method, device and equipment for authorizing back-end capability based on front-end declaration |
| CN115495718B (en) * | 2022-09-19 | 2023-10-13 | 广东云徙智能科技有限公司 | Front-end statement-based back-end capability authorization method, device and equipment |
Also Published As
| Publication number | Publication date |
|---|---|
| CN113625998B (en) | 2023-11-03 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| EP3876116B1 (en) | Method and apparatus for running mini program, electronic device, and storage medium | |
| US9778967B2 (en) | Sophisticated run-time system for graph processing | |
| US10387171B2 (en) | Configurable development platform integrating heterogeneous persistence systems | |
| US8122292B2 (en) | Debugging of business flows deployed in production servers | |
| US9304835B1 (en) | Optimized system for analytics (graphs and sparse matrices) operations | |
| US8146054B2 (en) | Hybrid data object model | |
| US11086827B1 (en) | Dataset schema and metadata management service | |
| US11036560B1 (en) | Determining isolation types for executing code portions | |
| US11204746B2 (en) | Encoding dependencies in call graphs | |
| CN111666293A (en) | Database access method and device | |
| CN113625998B (en) | Request processing method and device | |
| CN113419740B (en) | Program data stream analysis method and device, electronic equipment and readable storage medium | |
| US11074260B2 (en) | Space-efficient methodology for representing label information in large graph data for fast distributed graph query | |
| US20200175163A1 (en) | Feedback-directed static analysis | |
| US10528344B2 (en) | Modular points-to analysis | |
| CN111459991B (en) | Information query method and device | |
| CN111324395B (en) | Calling method, device and computer readable storage medium | |
| CN111158777A (en) | Component calling method and device and computer readable storage medium | |
| US12001458B2 (en) | Multi-cloud object store access | |
| US20060265387A1 (en) | Method and apparatus for loading artifacts | |
| US10620946B1 (en) | Dynamic modeling for opaque code during static analysis | |
| CN114238391A (en) | Data paging query method and device, electronic equipment and storage medium | |
| CN111915304B (en) | Data processing method, device, equipment and storage medium for digital element | |
| US20180167437A1 (en) | Logical data object web services | |
| US20230237032A1 (en) | On-demand ingestion of records from a staging storage into a primary database |
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 |