CN112000398A

CN112000398A - Method and device for determining bottom layer interface call link, computer equipment and medium

Info

Publication number: CN112000398A
Application number: CN202010826212.0A
Authority: CN
Inventors: 陈强松
Original assignee: Suzhou Dajiaying Information Technology Co Ltd
Current assignee: Suzhou Dajiaying Information Technology Co Ltd
Priority date: 2020-08-17
Filing date: 2020-08-17
Publication date: 2020-11-27
Anticipated expiration: 2040-08-17
Also published as: CN112000398B

Abstract

The invention discloses a method, a device, equipment and a medium for determining a bottom layer interface call link, wherein the method comprises the following steps: scanning the micro-service static code to obtain an initialization reference object of a bottom layer interface, function definition information of each function and interface definition information of each interface; establishing a corresponding relation between the interface and the interface realization method according to the interface definition information of each interface and the function definition information of each function; analyzing the function definition information of each function to obtain function description information of each function, and generating inter-function calling information according to each function definition information and each function description information; and taking the initialized reference object of each bottom layer interface as a recursion starting point, and recursively generating a calling link of each bottom layer interface according to the corresponding relation between the interface and the interface implementation method and/or the calling information among the functions. The technical scheme of the embodiment of the invention can accurately and completely generate the call link of the bottom layer interface only by analyzing the micro-service static code.

Description

Method and device for determining bottom layer interface call link, computer equipment and medium

Technical Field

The embodiment of the invention relates to computer technology, in particular to a method and a device for determining a bottom layer interface call link, computer equipment and a medium.

Background

In the development process of a software project, a front-end client and a back-end server (generally, a bottom database) need to be interfaced, and the client needs to access the server through a bottom Interface defined by a developer, for example, an Application Programming Interface (API), to provide a micro service to the outside.

In the prior art, a plurality of layers may exist between a client and a server, and an interface corresponding to each layer is realized in each layer, so that the client may finally realize calling of a certain bottom layer interface in the server in a layer-by-layer calling manner. For example, tier 1 and tier 2 are included between the client and the server, where tier 1 is typically a presentation tier directly connected to the client. When the client wants to call the bottom interface A of the server, only the interface 1 in the layer 1 needs to be called, the background calls the interface 2 in the layer 2 through the interface 1 in the layer 1, and then the mode that the interface 2 in the layer 2 calls the bottom interface A is used, and finally the calling of the bottom interface A is realized. The bottom layer interface a- > interface 2- > interface 1 is a call link for the bottom layer interface a.

The inventor discovers that in the process of implementing the invention: when a layered architecture is used between a client and a server, when a bottom layer interface in a new version is changed, it is difficult to determine which interfaces in each layer need to be correspondingly adjusted with the bottom layer interface, and if interface coverage is required in an actual calling process, the situation of incomplete coverage can occur due to excessive layers, so that the problem of incompatibility of the new version and the old version can occur with a high probability.

Disclosure of Invention

The embodiment of the invention provides a method and a device for determining a calling link of a bottom interface, computer equipment and a storage medium, wherein the calling link of the bottom interface can be accurately and completely generated only by analyzing a static code of a micro service.

In a first aspect, an embodiment of the present invention provides a method for determining a call link of a bottom interface, where the method includes:

scanning the micro-service static code to obtain an initialization reference object of at least one bottom layer interface, function definition information of each function in the micro-service static code and interface definition information of each interface;

establishing a corresponding relation between interfaces and an interface implementation method according to the interface definition information of each interface and the function definition information of each function;

analyzing the function definition information of each function to obtain function description information of each function, and generating at least one piece of inter-function call information according to each piece of function definition information and each piece of function description information;

and recursively generating a calling link of each bottom layer interface by taking the initialized reference object of each bottom layer interface as a recursive starting point according to the corresponding relation between the interface and the interface implementation method and/or the calling information among the functions.

In a second aspect, an embodiment of the present invention further provides a device for determining a call link of a bottom interface, where the device includes:

the basic information acquisition module is used for scanning the micro-service static code and acquiring an initialization reference object of at least one bottom layer interface, function definition information of each function in the micro-service static code and interface definition information of each interface;

a corresponding relation establishing module, configured to establish a corresponding relation between the interfaces and the interface implementation method according to the interface definition information of each interface and the function definition information of each function;

the inter-function call information generation module is used for analyzing the function definition information of each function to obtain function description information of each function, and generating at least one piece of inter-function call information according to each piece of function definition information and each piece of function description information;

and the call link generation module is used for recursively generating the call link of each bottom layer interface by taking the initialized reference object of each bottom layer interface as a recursive starting point according to the corresponding relation between the interface and the interface implementation method and/or the call information among the functions.

In a third aspect, an embodiment of the present invention further provides a computer device, where the computer device includes:

one or more processors;

storage means for storing one or more programs;

when executed by the one or more processors, cause the one or more processors to implement a method for determining an underlying interface call link as described in any embodiment of the invention.

In a fourth aspect, an embodiment of the present invention further provides a computer storage medium, on which a computer program is stored, where the computer program, when executed by a processor, implements the method for determining an underlying interface call link according to any embodiment of the present invention.

The technical scheme of the embodiment of the invention obtains the initialized reference object of the bottom layer interface, the corresponding relation between the interface and the interface realization method and the calling information among the functions in the micro-service static code by scanning and analyzing the micro-service static code; and by taking the initialized quoting object of each bottom layer interface as a recursion starting point, generating a calling link of each bottom layer interface in a recursion mode according to the corresponding relation between the interface and the interface implementation method and/or calling information among the functions, and accurately and completely generating the calling links corresponding to each bottom layer interface, so that when a certain bottom layer interface is changed, all middle-layered calling interfaces influenced by the bottom layer interface can be accurately and quickly positioned, and the problem of incomplete interface coverage is thoroughly avoided.

Drawings

Fig. 1 is a flowchart of a method for determining a call link of a bottom interface according to a first embodiment of the present invention;

fig. 2 is a flowchart of a method for determining a bottom interface call link according to a second embodiment of the present invention;

fig. 3 is a flowchart of a method for determining a call link of a bottom interface according to a third embodiment of the present invention;

fig. 4a is a flowchart of a method for determining a call link of a bottom interface according to a fourth embodiment of the present invention;

FIG. 4b is a schematic view illustrating a visualization of a bottom layer interface call link to which the embodiment of the present invention is applicable;

fig. 5 is a structural diagram of a determination apparatus of a bottom interface call link in the fifth embodiment of the present invention;

fig. 6 is a schematic structural diagram of a computer device in the sixth embodiment of the present invention.

Detailed Description

The present invention will be described in further detail with reference to the accompanying drawings and examples. It is to be understood that the specific embodiments described herein are merely illustrative of the invention and are not limiting of the invention. It should be further noted that, for the convenience of description, only some of the structures related to the present invention are shown in the drawings, not all of the structures.

It should be further noted that, for the convenience of description, only some but not all of the relevant aspects of the present invention are shown in the drawings. Before discussing exemplary embodiments in more detail, it should be noted that some exemplary embodiments are described as processes or methods depicted as flowcharts. Although a flowchart may describe the operations (or steps) as a sequential process, many of the operations can be performed in parallel, concurrently or simultaneously. In addition, the order of the operations may be re-arranged. The process may be terminated when its operations are completed, but may have additional steps not included in the figure. The processes may correspond to methods, functions, procedures, subroutines, and the like.

Example one

Fig. 1 is a flowchart of a method for determining a call link of a bottom layer interface according to an embodiment of the present invention, where this embodiment is applicable to a case where a call link of each bottom layer interface in a project is generated according to a microservice static code of the project, and the method may be executed by a determination apparatus for a call link of a bottom layer interface, where the apparatus may be implemented by software and/or hardware, and may generally be integrated in a terminal or a server having a data processing function, and the method of this embodiment specifically includes the following steps:

s110, scanning the micro-service static code to obtain at least one initialization reference object of a bottom layer interface, function definition information of each function in the micro-service static code and interface definition information of each interface.

In this embodiment, the bottom layer interface specifically refers to an interface for directly calling a bottom layer database, or an interface for directly performing information interaction with a bottom layer server. Generally, the direct call to the underlying interface is complicated, and therefore, in the prior art, a hierarchical structure is made to shield the direct call to the underlying interface. The user calls the application layer (or the presentation layer) function layer by layer in each layer in a mode of using the application layer (or the presentation layer) function in the application layer (or the presentation layer), and finally calls a certain bottom layer interface.

The initialization reference object of the bottom layer interface specifically refers to a function or other interfaces which directly call the bottom layer interface. Generally, the initialization reference object is placed in a hierarchy that is directly connected to the underlying interface.

In this embodiment, in order to access the underlying database, a plurality of micro service static codes are written to form a set engineering project. The calling links of the bottom interfaces are hidden in the function definition information of the functions and the interface definition information of the interfaces in the micro-service static codes, and the calling links of the bottom interfaces can be finally obtained by performing semantic and syntactic analysis on the function definition information and the interface definition information.

Generally, when writing micro service static code, a software developer will add certain annotation content to the code, and in particular, will add description information on interfaces in each interface file, and by analyzing the above content, it can automatically determine which interfaces are the underlying interfaces, and in addition, the developer uses different naming methods when defining functions or interfaces, for example: in the microservice static code implemented in the Go language, one interface is defined with the type interface name interface as the head of the defined structure, and one function is defined in the form of the func function name (form parameter list) (return value list) { function body }, so that the function definition information of each function and the interface definition information of each interface can be acquired in the microservice static code by the known and fixed function and interface definition form.

And S120, establishing a corresponding relation between the interfaces and the interface realization method according to the interface definition information of each interface and the function definition information of each function.

In some cases, some interfaces need to call one or more functions to implement corresponding interface functions, and at this time, methods matching the one or more functions need to be implemented in the interfaces in advance.

For example, an interface definition file including one or more interface implementation methods is shown below.

Obviously, two methods getAge () and getName () are defined in the defined interface peoples, and if an interface function is to be normally implemented, the two methods getAge () and getName () need to be implemented in the interface definition file, that is, the method implemented in the interface needs to match the definitions of the two functions in the function definition file.

When it is determined that the interfaces implement all the methods defined in the interfaces according to the interface definition information of each of the interfaces and the function definition information of each of the functions, a correspondence relationship between the interfaces and the interface implementation methods may be established.

S130, analyzing the function definition information of each function to obtain function description information of each function, and generating at least one piece of inter-function calling information according to each piece of function definition information and each piece of function description information.

The function description information specifically refers to information for describing basic content of a function. Optionally, the function description information may include: the method comprises the following steps of function name, whether the function comprises call chain information or not, whether the function directly refers to an underlying interface or not, the position of the function in a code, the file name of a file where the function is located, the name of a micro service where the function is located, annotation information of the function and the like.

Specifically, the function description information corresponding to one function may be identified by analyzing a syntax structure of the function definition information. After the function description information is obtained, inter-function call information may be generated, and the inter-function call information may be described by a structural body in which a relationship between a called function and a caller function is recorded, where the called function refers to a function called by the caller function.

S140, recursively generating a calling link of each bottom layer interface by taking the initialized reference object of each bottom layer interface as a recursive starting point according to the corresponding relation between the interfaces and the interface implementation method and/or the calling information among the functions.

In this embodiment, the initialized reference object is a function or an interface that directly calls a bottom-layer interface, and after the initialized reference object is determined, the corresponding relationship between the interface and the interface implementation method and the call relationship between the functions may be continuously queried according to the initialized reference object until recursion to the upper-layer service interface occurs. The upper layer service interface is an interface for directly interacting with a user, or an interface in the last layer in the hierarchical structure. And a call link from the bottom layer interface to the upper layer service interface can be constructed.

Generally, if no other interface calls (implements) the bottom layer interface, or no other interface calls a link node (function) included in a call link of the bottom layer interface, a call link of the bottom layer interface can be obtained only by using a call relationship between functions; however, if there are other interfaces to call the bottom layer interface or the link node included in the call link of the bottom layer interface, only analyzing the call relationship between the functions cannot completely obtain a complete call link of the bottom layer interface, and therefore, the call link of the bottom layer interface can be completely obtained only by combining the corresponding relationship between the interfaces and the interface implementation method.

Optionally, the calling link corresponding to the bottom layer interface may be obtained by drawing in a drawing manner, where a starting point of the calling link is a bottom layer interface, and an end point of the calling link is a service interface.

Example two

Fig. 2 is a flowchart of a method for determining a bottom layer interface call link according to a second embodiment of the present invention, which is further embodied based on the above embodiments, in this embodiment, the operation of scanning a micro service static code to obtain an initialization reference object of at least one bottom layer interface, function definition information of each function in the micro service static code, and interface definition information of each interface is embodied as: calling an AST tool, and scanning the micro-service static code to obtain AST structure data; and analyzing the AST structure data to obtain an initialization reference object of at least one bottom layer interface, function definition information of each function in the micro-service static code and interface definition information of each interface.

Correspondingly, as shown in fig. 2, the scheme of the embodiment of the present invention specifically includes the following steps:

s210, calling an AST tool, and scanning the micro-service static code to obtain AST structure data.

In this embodiment, for the micro-service static code written in Go language, the AST (Abstract Syntax tree) tool owned by Go language may be used to generate AST structure data matching with the micro-service static code.

Wherein the abstract syntax tree is an abstract representation of the source code syntax structure. It represents the syntactic structure of the programming language in the form of a tree, each node on the tree representing a structure in the source code. The syntax is said to be "abstract" in that the syntax does not represent every detail that appears in the true syntax. For example, nesting brackets are implicit in the structure of the tree and are not present in the form of nodes; whereas a conditional jump statement like the if-condition-then may be represented using a node with two branches.

S220, analyzing the AST structure data to obtain an initialization reference object of at least one bottom layer interface, function definition information of each function in the micro-service static code and interface definition information of each interface.

After the AST structure data is obtained, the initialization reference object of at least one underlying interface, the function definition information of each function in the micro-service static code, and the interface definition information of each interface may be obtained by setting a syntax analyzer.

Optionally, analyzing the AST structure data, and acquiring an initialization reference object of at least one underlying interface may include:

in the AST structure data, acquiring each alternative interface referred by a handle mode and a referrer object of each alternative interface; identifying at least one bottom layer interface in each alternative interface according to the label information of each alternative interface; and taking the reference object of each bottom layer interface as the initial reference object of each bottom layer interface.

Generally, the underlying interfaces are all referenced in the form of handles, so-called handles, that is, pointers of pointers, and after acquiring the candidate interfaces referenced by the handles, the underlying interfaces can be further identified in the candidate interfaces.

Specifically, the following code is an optional implementation manner of acquiring, in the AST structure data, candidate interfaces referenced by a handle manner and a referrer object of each candidate interface in a scanning manner.

After the alternative interfaces referred by the handle mode are obtained through the code, the label information (Tag) of each alternative interface can be analyzed to determine which interfaces are the underlying interfaces.

Specifically, the code shown below is an optional implementation manner for analyzing the AST structure data to obtain function definition information of each function and interface definition information of each interface in the micro service static code.

And S230, establishing a corresponding relation between the interfaces and the interface implementation method according to the interface definition information of each interface and the function definition information of each function.

S240, analyzing the function definition information of each function to obtain function description information of each function, and generating at least one piece of inter-function call information according to each piece of function definition information and each piece of function description information.

And S250, recursively generating a calling link of each bottom layer interface by taking the initialized reference object of each bottom layer interface as a recursive starting point according to the corresponding relation between the interfaces and the interface implementation method and/or the calling information among the functions.

According to the technical scheme of the embodiment of the invention, the AST structure data is analyzed by using the AST tool carried by the programming language to obtain the AST structure data, and then the AST structure data is analyzed, so that the corresponding relation between the interface and the interface realization method and the call information among the functions can be simply, conveniently and quickly obtained without excessive extra workload, and the workload of programming a programmer to additionally write the realization code of the call link generation method and the complexity of the realization code are reduced.

On the basis of the foregoing embodiments, scanning the microservice static code may specifically be: and scanning the micro-service static code corresponding to the target project in a compiling stage of the target project.

The advantages of such an arrangement are: the influence on the whole target project on-line and running process can be reduced to the maximum extent, and the effectiveness and reliability of the service provided by the target project are ensured.

On the basis of the foregoing embodiments, scanning the microservice static code may specifically be: and starting a plurality of parallel threads, and using each parallel thread to perform parallel scanning on the micro-service static code.

The reason for this is that: the micro service data is numerous, and a large amount of time is consumed in a single-thread scanning mode, so that a multi-route (lightweight thread of Go language) mode can be started to perform parallel scanning, and the scanning efficiency is improved.

On the basis of the foregoing embodiments, scanning the microservice static code may specifically be: the microservice static code is periodically scanned every set timed interval (e.g., 1 day, or 1 week, or 1 month, etc.).

The reason for this is that: by periodically scanning the microservice static code, the timeliness of the generated call link can be guaranteed, considering that the microservice code in the target project is dynamically updated.

EXAMPLE III

Fig. 3 is a flowchart of a method for determining a call link of a bottom layer interface according to a third embodiment of the present invention, where the third embodiment of the present invention is further embodied based on the foregoing embodiments, and in this embodiment, function definition information of each function is analyzed to obtain function description information of each function, an operation of generating at least one piece of inter-function call information according to each piece of function definition information and each piece of function description information is performed, and the function definition information of each function is analyzed to obtain function description information of each function, and an operation of generating at least one piece of inter-function call information according to each piece of function definition information and each piece of function description information is further embodied, accordingly, as shown in fig. 3, a scheme according to the third embodiment of the present invention specifically includes the following steps:

s310, scanning the micro service static code to obtain at least one initialization reference object of a bottom layer interface, function definition information of each function in the micro service static code and interface definition information of each interface.

S320, acquiring method definition information of each target method in the interface definition information of the currently processed target interface.

S330, if each piece of method definition information is matched with any piece of function definition information, determining that each target method defined in the target interface is realized.

In particular, the following code illustrates an alternative implementation in which the target methods defined in the target interface are determined to be implemented.

Specifically, the manner of determining that each target method defined in the target interface is implemented is to compare whether each method defined in the interface is completely consistent with the function definition information of a certain function (typically, the entry parameter and the return value are completely consistent).

If it is determined that each method in an interface is completely consistent with the function definition information of a function, it is determined that the interface realizes all methods, and thus it can be determined that the interface is effectively available, and further, a corresponding relationship between the interface and each method realized by the interface can be established.

S340, establishing a corresponding relation between the target interface and each target method.

And S350, performing keyword identification and/or key sentence pattern identification in the function definition information of each function, and acquiring function description information of each function.

Among them, those skilled in the art can understand that: regardless of the programming language in which the microservice static code is programmed, the syntax and syntactic structure of the programming language must be followed when writing the constructor definition file. Therefore, by analyzing the function definition information according to the syntax and the syntax structure, the function description information of each function can be obtained.

Optionally, the function description information may include at least one of: the method comprises the following steps of function name, whether call chain information is included in the function, whether the function directly refers to an underlying interface, the position of the function in code, the file name of a file where the function is located, the name of a micro service where the function is located and annotation information of the function.

The following code shows a storage form of the function description information after the function description information is obtained through analysis.

In the above data structure, the name of the function, whether the interface definition exists, whether a call chain exists, a return value, and an entry parameter are stored.

S360, if a function calling statement for a second function is identified in the function definition information of the first function, generating a piece of inter-function calling information according to the first function, the second function and the function description information of the second function.

As indicated above, since the microservice static code is written according to a syntax or syntax specific to the programming language, the call of one function to another function also needs to follow a specific structure, for example, when the code is written using Go speech, the following structure can be used when implementing that another function is referred to in a certain function: res, sts: getlogbybankname (). By analyzing the structure of each statement included in each function definition information, corresponding function call information can be identified and obtained, and further a first function and a second function can be determined.

The second function is a called function, the first function is a calling function, and the calling function calls the called function.

Optionally, generating a piece of inter-function call information according to the first function, the second function, and the function description information of the second function may specifically include:

establishing a target structure by taking the second function as a structure name; adding the function name of the first function into the target structure body as a calling function; and adding the function description information of the second function into the target structure, and taking the target structure as a piece of inter-function calling information.

The following structure shows an alternative implementation of the inter-function call information.

S370, taking the initialized reference object of each bottom layer interface as a recursion starting point, and recursively generating a calling link of each bottom layer interface according to the corresponding relation between the interfaces and the interface implementation method and/or the calling information among the functions.

Example four

Fig. 4a is a flowchart of a method for determining a call link of a bottom layer interface according to a fourth embodiment of the present invention, which is further embodied based on the foregoing embodiments, in this embodiment, an operation of recursively generating a call link of each bottom layer interface according to a correspondence between the interface and an interface implementation method and/or call information between functions with the initialization reference object of each bottom layer interface as a recursive starting point is further embodied, and accordingly, as shown in fig. 4a, the scheme of the embodiment of the present invention specifically includes the following steps:

s410, scanning the micro-service static code to obtain at least one initialization reference object of a bottom layer interface, function definition information of each function in the micro-service static code and interface definition information of each interface.

S420, establishing a corresponding relation between the interfaces and the interface realization method according to the interface definition information of each interface and the function definition information of each function.

S430, analyzing the function definition information of each function to obtain function description information of each function, and generating at least one piece of inter-function call information according to each piece of function definition information and each piece of function description information.

S440, acquiring the initialization reference object of the currently processed target bottom layer interface as a currently called link node.

S450, judging whether the current call link node is an upper layer service node: if so, go to S460, otherwise, go to S470.

The upper layer service node specifically refers to a service interface in the last layer in the hierarchical structure, that is, an interface that a user directly calls.

And S460, ending the recursion process, and generating a calling link of the target bottom layer interface according to all the determined calling link nodes.

Optionally, the step of generating the call link of the target underlying interface according to all the determined call link nodes may specifically be:

when the recursion flow is finished, the target bottom layer interface is taken as a drawing starting point, the calling link of the target bottom layer interface is drawn according to the calling sequence of each calling link node, and function description information matched with each calling link node is added to each calling link node of the calling link.

Fig. 4b is a schematic view illustrating a visualization of a bottom-layer interface call link to which the embodiment of the present invention is applied.

S470, according to the current call link node, inquiring the call information between the functions, and executing S480.

S480, judging whether at least one item of target function calling information using the current calling link node as a called function exists: if yes, go to S490; otherwise, S4100 is performed.

And S490, after the caller function in the call information between the target functions is determined as a new current call link node, returning to execute S450.

S4100, inquiring the corresponding relation between the interface and the interface implementation method according to the current call link node, and executing S4110.

S4110, judging whether the current calling link node is matched with a target interface: if yes, go to S4120; otherwise, return to execute S450.

S4120, acquiring at least one target interface implementation method corresponding to the target interface in the corresponding relation, and executing S4130.

S4130, taking each target interface implementation method as a new current call link node, and returning to execute S450.

On the basis of the foregoing embodiments, after recursively generating the call links of each bottom-layer interface, the method may further include: when detecting that a target bottom layer interface is changed, inquiring a target calling link matched with the target bottom layer interface, and positioning at least one target service interface matched with the target bottom layer interface according to the target calling link.

Through the arrangement, when the bottom layer external interface is changed, the corresponding influence range and the corresponding code anchor point can be quickly searched. The method and the system are convenient for developers to modify last time, and then specific upper-layer business interfaces using the bottom-layer service interface can be captured, so that the bottom-layer developers can conveniently judge whether the change is reasonable or not.

EXAMPLE five

Fig. 5 is a structural diagram of a device for determining a bottom interface call link according to a fifth embodiment of the present invention, as shown in fig. 5, the device includes: a basic information obtaining module 510, a corresponding relationship establishing module 520, an inter-function call information generating module 530, and a call link generating module 540, wherein:

a basic information obtaining module 510, configured to scan the micro service static code, and obtain an initialization reference object of at least one bottom layer interface, function definition information of each function in the micro service static code, and interface definition information of each interface;

a corresponding relationship establishing module 520, configured to establish a corresponding relationship between the interfaces and the interface implementation methods according to the interface definition information of each interface and the function definition information of each function;

an inter-function call information generating module 530, configured to analyze function definition information of each function to obtain function description information of each function, and generate at least one piece of inter-function call information according to each piece of function definition information and each piece of function description information;

a calling link generating module 540, configured to recursively generate a calling link of each bottom-layer interface according to a correspondence between the interface and an interface implementation method and/or calling information between functions, with the initialization reference object of each bottom-layer interface as a recursive starting point.

On the basis of the above embodiments, the basic information obtaining module 510 may include:

an AST structure data generating unit, configured to invoke an AST tool, scan the micro-service static code, and obtain AST structure data;

and the information acquisition unit is used for analyzing the AST structure data and acquiring an initialization reference object of at least one bottom layer interface, function definition information of each function in the micro-service static code and interface definition information of each interface.

On the basis of the foregoing embodiments, the information obtaining unit may specifically be configured to:

in the AST structure data, acquiring each alternative interface referred by a handle mode and a referrer object of each alternative interface;

identifying at least one bottom layer interface in each alternative interface according to the label information of each alternative interface;

and taking the reference object of each bottom layer interface as the initial reference object of each bottom layer interface.

On the basis of the foregoing embodiments, the corresponding relationship establishing module 520 may be specifically configured to:

acquiring method definition information of each target method in interface definition information of a currently processed target interface;

determining that each target method defined in the target interface is implemented if each of the method definition information matches any of the function definition information;

and establishing a corresponding relation between the target interface and each target method.

On the basis of the foregoing embodiments, the inter-function call information generating module 530 may specifically include:

a function description information acquisition unit, configured to perform keyword recognition and/or key sentence pattern recognition on function definition information of each function, and acquire function description information of each function;

and the calling information generating unit is used for generating a piece of inter-function calling information according to the first function, the second function and the function description information of the second function if the function calling statement of the second function is identified in the function definition information of the first function.

On the basis of the foregoing embodiments, the call information generating unit may be specifically configured to:

establishing a target structure by taking the second function as a structure name;

adding the function name of the first function into the target structure body as a calling function;

and adding the function description information of the second function into the target structure, and taking the target structure as a piece of inter-function calling information.

On the basis of the foregoing embodiments, the function description information may include at least one of the following items:

the method comprises the following steps of function name, whether call chain information is included in the function, whether the function directly refers to an underlying interface, the position of the function in code, the file name of a file where the function is located, the name of a micro service where the function is located and annotation information of the function.

On the basis of the foregoing embodiments, the call link generating module 540 may specifically be configured to:

acquiring the initialization reference object of the currently processed target underlying interface as a current calling link node,

judging whether the current call link node is an upper service node: if so, ending the recursion process, otherwise, inquiring the calling information among the functions according to the current calling link node;

if at least one item of target function calling information with the current calling link node as a called function exists, determining a calling function in the target function calling information as a new current calling link node, and returning to execute the operation of judging whether the current calling link node is an upper service node;

if it is determined that at least one item of target function calling information using the current calling link node as a called function does not exist, inquiring the corresponding relation between an interface and an interface implementation method according to the current calling link node;

if the current calling link node is matched with the target interface, acquiring at least one target interface implementation method corresponding to the target interface in the corresponding relation;

after each target interface implementation method is used as a new current call link node, returning to execute the operation of judging whether the current call link node is an upper service node or not;

if the current calling link node is not matched with any interface, ending the recursion process;

and when the recursion flow is ended, generating a calling link of the target bottom layer interface according to all the determined calling link nodes.

On the basis of the foregoing embodiments, the invoking link generating module 540 may be further specifically configured to:

On the basis of the foregoing embodiments, the basic information obtaining module 510 may be specifically configured to perform at least one of the following:

in the compiling stage of the target project, scanning the micro-service static code corresponding to the target project;

starting a plurality of parallel threads, and using each parallel thread to perform parallel scanning on the micro-service static code; and

and periodically scanning the micro-service static codes at set time intervals.

On the basis of the above embodiments, the method may further include: and the positioning module is used for inquiring a target calling link matched with the target bottom layer interface after the calling links of all the bottom layer interfaces are generated recursively and when the target bottom layer interface is detected to be changed, and positioning at least one target service interface matched with the target bottom layer interface according to the target calling link.

The determining device for the bottom layer interface call link provided by the embodiment of the invention can execute the determining method for the bottom layer interface call link provided by any embodiment of the invention, and has corresponding functional modules and beneficial effects of the executing method.

EXAMPLE six

Fig. 6 is a schematic structural diagram of a computer device according to a sixth embodiment of the present invention. FIG. 6 illustrates a block diagram of an exemplary computer device 12 suitable for use in implementing embodiments of the present invention. The computer device 12 shown in FIG. 6 is only an example and should not bring any limitations to the functionality or scope of use of embodiments of the present invention.

As shown in FIG. 6, computer device 12 is in the form of a general purpose computing device. The components of computer device 12 may include, but are not limited to: one or more processors or processing units 16, a system memory 28, and a bus 18 that couples various system components including the system memory 28 and the processing unit 16.

Bus 18 represents one or more of any of several types of bus structures, including a memory bus or memory controller, a peripheral bus, an accelerated graphics port, and a processor or local bus using any of a variety of bus architectures. By way of example, such architectures include, but are not limited to, Industry Standard Architecture (ISA) bus, micro-channel architecture (MA6) bus, enhanced ISA bus, Video Electronics Standards Association (VESA) local bus, and peripheral component interconnect (P6I) bus.

Computer device 12 typically includes a variety of computer system readable media. Such media may be any available media that is accessible by computer device 12 and includes both volatile and nonvolatile media, removable and non-removable media.

The system memory 28 may include computer system readable media in the form of volatile memory, such as Random Access Memory (RAM)30 and/or cache memory 32. Computer device 12 may further include other removable/non-removable, volatile/nonvolatile computer system storage media. By way of example only, storage system 34 may be used to read from and write to non-removable, nonvolatile magnetic media (not shown in FIG. 6, and commonly referred to as a "hard drive"). Although not shown in FIG. 6, a magnetic disk drive for reading from and writing to a removable, nonvolatile magnetic disk (e.g., a "floppy disk") and an optical disk drive for reading from or writing to a removable, nonvolatile optical disk (e.g., a 6D-ROM, DVD-ROM, or other optical media) may be provided. In these cases, each drive may be connected to bus 18 by one or more data media interfaces. Memory 28 may include at least one program product having a set (e.g., at least one) of program modules that are configured to carry out the functions of embodiments of the invention.

A program/utility 40 having a set (at least one) of program modules 42 may be stored, for example, in memory 28, such program modules 42 including, but not limited to, an operating system, one or more application programs, other program modules, and program data, each of which examples or some combination thereof may comprise an implementation of a network environment. Program modules 42 generally carry out the functions and/or methodologies of the described embodiments of the invention.

The computer device 12 may also communicate with one or more external devices 14 (e.g., keyboard, pointing device, display 24, etc.), with one or more devices that enable a user to interact with the device/terminal/server 12, and/or with any device (e.g., network card, modem, etc.) that enables the device/terminal/server 12 to communicate with one or more other computing devices. Such communication may be through an input/output (I/O) interface 22. Also, computer device 12 may communicate with one or more networks (e.g., a Local Area Network (LAN), a Wide Area Network (WAN), and/or a public network such as the Internet) via network adapter 20. As shown, network adapter 20 communicates with the other modules of computer device 12 via bus 18. It should be understood that although not shown in the figures, other hardware and/or software modules may be used in conjunction with computer device 12, including but not limited to: microcode, device drivers, redundant processing units, external disk drive arrays, RAID systems, tape drives, and data backup storage systems, among others.

The processing unit 16 executes various functional applications and data processing by executing programs stored in the system memory 28, for example, implementing the determination method of the underlying interface call link provided by the embodiment of the present invention.

Namely: when executed by the one or more processors, cause the one or more processors to perform: scanning the micro-service static code to obtain an initialization reference object of at least one bottom layer interface, function definition information of each function in the micro-service static code and interface definition information of each interface; establishing a corresponding relation between interfaces and an interface implementation method according to the interface definition information of each interface and the function definition information of each function; analyzing the function definition information of each function to obtain function description information of each function, and generating at least one piece of inter-function call information according to each piece of function definition information and each piece of function description information; and recursively generating a calling link of each bottom layer interface by taking the initialized reference object of each bottom layer interface as a recursive starting point according to the corresponding relation between the interface and the interface implementation method and/or the calling information among the functions.

EXAMPLE seven

The sixth embodiment of the invention also provides a computer readable storage medium. Having stored thereon a computer program which, when executed by a processor, implements: scanning the micro-service static code to obtain an initialization reference object of at least one bottom layer interface, function definition information of each function in the micro-service static code and interface definition information of each interface; establishing a corresponding relation between interfaces and an interface implementation method according to the interface definition information of each interface and the function definition information of each function; analyzing the function definition information of each function to obtain function description information of each function, and generating at least one piece of inter-function call information according to each piece of function definition information and each piece of function description information; and recursively generating a calling link of each bottom layer interface by taking the initialized reference object of each bottom layer interface as a recursive starting point according to the corresponding relation between the interface and the interface implementation method and/or the calling information among the functions.

Computer storage media for embodiments of the invention may employ any combination of one or more computer-readable media. The computer readable medium may be a computer readable signal medium or a computer readable storage medium. 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 (a non-exhaustive list) of the computer readable storage medium would include the following: 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.

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, wireline, optical fiber cable, RF, etc., or any suitable combination of the foregoing.

Computer program code for carrying out operations for aspects of the present invention may be written in any combination of one or more programming languages, including an object oriented programming language such as Java, Smalltalk, C + + or the like and conventional procedural programming languages, such as the "C" programming language or similar programming languages. The program code may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. In the case of a remote computer, the remote computer may be connected to the user's computer through any type of network, including a Local Area Network (LAN) or a Wide Area Network (WAN), or the connection may be made to an external computer (for example, through the Internet using an Internet service provider).

It is to be noted that the foregoing is only illustrative of the preferred embodiments of the present invention and the technical principles employed. It will be understood by those skilled in the art that the present invention is not limited to the particular embodiments described herein, but is capable of various obvious changes, rearrangements and substitutions as will now become apparent to those skilled in the art without departing from the scope of the invention. Therefore, although the present invention has been described in greater detail by the above embodiments, the present invention is not limited to the above embodiments, and may include other equivalent embodiments without departing from the spirit of the present invention, and the scope of the present invention is determined by the scope of the appended claims.

Claims

1. A method for determining a call link of a bottom layer interface comprises the following steps:

2. The method of claim 1, wherein scanning the micro service static code to obtain at least one initialization referencing object of an underlying interface, function definition information of each function in the micro service static code, and interface definition information of each interface comprises:

calling an Abstract Syntax Tree (AST) tool to scan the micro-service static codes to obtain AST structure data;

and analyzing the AST structure data to obtain an initialization reference object of at least one bottom layer interface, function definition information of each function in the micro-service static code and interface definition information of each interface.

3. The method of claim 2, wherein parsing the AST structure data to obtain an initialization reference object for at least one underlying interface comprises:

4. The method according to claim 1, wherein establishing a correspondence between interfaces and interface implementation methods according to the interface definition information of each interface and the function definition information of each function includes:

5. The method of claim 1, wherein analyzing function definition information of each function to obtain function description information of each function, and generating at least one inter-function call information according to each of the function definition information and each of the function description information, comprises:

performing keyword identification and/or key sentence pattern identification in the function definition information of each function to obtain function description information of each function;

and if a function calling statement for a second function is identified in the function definition information of the first function, generating a piece of inter-function calling information according to the first function, the second function and the function description information of the second function.

6. The method of claim 5, wherein generating an inter-function call message according to the first function, the second function, and the function description information of the second function comprises:

7. The method of claim 5, wherein the function description information comprises at least one of:

8. The method according to claim 1, wherein recursively generating a call link of each bottom-layer interface according to a correspondence between the interface and an interface implementation method and/or call information between the functions, with the initialization reference object of each bottom-layer interface as a recursive starting point, comprises:

9. The method of claim 8, wherein generating the call link of the target underlying interface according to all the determined call link nodes when the recursive process is ended comprises:

10. The method of claim 1, wherein scanning for microservice static code comprises at least one of:

and periodically scanning the micro-service static codes at set time intervals.

11. The method of claim 1, wherein after recursively generating call links for each of the underlying interfaces, the method further comprises:

when detecting that a target bottom layer interface is changed, inquiring a target calling link matched with the target bottom layer interface, and positioning at least one target service interface matched with the target bottom layer interface according to the target calling link.

12. An apparatus for determining an underlying interface call link, comprising:

13. A computer device, characterized in that the computer device comprises:

one or more processors;

storage means for storing one or more programs;

when executed by the one or more processors, cause the one or more processors to implement the method for determining an underlying interface call link as recited in any of claims 1-11.

14. A computer storage medium having stored thereon a computer program, characterized in that the program, when being executed by a processor, implements the method for determining an underlying interface call link according to any one of claims 1-11.