CN110704295B

CN110704295B - Data calling method, device, equipment and system

Info

Publication number: CN110704295B
Application number: CN201810750177.1A
Authority: CN
Inventors: 王特
Original assignee: Alibaba Group Holding Ltd
Current assignee: Alibaba Group Holding Ltd
Priority date: 2018-07-10
Filing date: 2018-07-10
Publication date: 2023-04-11
Anticipated expiration: 2038-07-10
Also published as: CN110704295A

Abstract

The application discloses a data calling method, a device, equipment and a system, which are used for determining a data calling process formed on the basis of at least one service calling relation; judging whether the service in the at least one service calling relation is associated to a target debugging version, wherein the target debugging version is a special case of a basic function version of the service; and determining the service route in the at least one service calling relationship according to the judgment result. By utilizing the technical scheme, whether the service to be called is associated with the target debugging version or not is judged in advance, the version of the service to be called at present can be determined, the route to the specific version of the service is determined according to the judgment result, and the problem of calling errors is solved.

Description

Data calling method, device, equipment and system

Technical Field

The present application relates to the field of computer technologies, and in particular, to a data calling method, apparatus, device, and system.

Background

With the development of information technology, a network service provider (such as a website or an application program APP) can provide rich business services for users. For network service providers, in the software development phase, developers can develop and debug different business services, and usually, business services with different functions are distributed on different machines to complete development and debugging. Then there is a data call between the versions of different business services.

As the content and types of services increase, the calling process for data may include a plurality of services based on calling relationship, increasing the complexity of calling relationship and the length of calling path, which may have a problem of error in service calling during debugging.

Disclosure of Invention

The technical problem to be solved by the embodiment of the application is that in the prior art, a service call error problem exists in a software debugging process.

The embodiment of the application adopts the following technical scheme:

the embodiment of the application provides a data calling method, which comprises the following steps:

determining a data calling process formed based on at least one service calling relation;

judging whether the service in the at least one service calling relation is associated to a target debugging version, wherein the target debugging version is a special case of a basic function version of the service;

and determining the service route in the at least one service calling relation according to the judgment result.

The embodiment of the present application further provides a data calling method, including:

if the version of the service in the at least one service invocation relation comprises a target debugging version, establishing association between the service in the at least one service invocation relation and the target debugging version, wherein the target debugging version is a special case of a basic function version of the service.

An embodiment of the present application further provides a data calling apparatus, including:

the calling process determining module is used for determining a data calling process formed on the basis of at least one service calling relation;

the judging module is used for judging whether the service in the at least one service calling relation is related to a target debugging version, wherein the target debugging version is a special case of a basic function version of the service;

and the service route determining module is used for determining the service route in the at least one service calling relation according to the judgment result.

the determining module is used for determining a data calling process formed on the basis of at least one service calling relation;

and the establishing module is used for establishing the association between the service in the at least one service calling relation and the target debugging version if the version of the service in the at least one service calling relation comprises the target debugging version, wherein the target debugging version is a special case of the basic function version of the service.

An embodiment of the present application further provides a data call system, including:

a basic environment layer for running a basic function version of at least one service;

the debugging environment layer runs a target debugging version, and the target debugging version is a special case of a basic function version of corresponding service in the basic environment layer;

and calling the control layer, determining a data calling process formed based on at least one service calling relation, judging whether the service in the at least one service calling relation is associated to the target debugging version, and determining the service route in the at least one service calling relation according to the judgment result.

An embodiment of the present application further provides an electronic device, including at least one processor and a memory, where the memory stores a program and is configured to be executed by the at least one processor to:

Embodiments of the present application also provide a computer-readable storage medium, which includes a program for use in conjunction with an electronic device, where the program is executable by a processor to perform the following steps:

An embodiment of the present application further provides an electronic device, including at least one processor and a memory, where the memory stores programs and is configured to be executed by the at least one processor to:

if the service version in the at least one service invocation relation comprises a target debugging version, establishing association between the service in the at least one service invocation relation and the target debugging version, wherein the target debugging version is a special case of a basic function version of the service.

The embodiment of the application adopts at least one technical scheme which can achieve the following beneficial effects:

when determining a data call process formed based on at least one service call relationship, it may be determined whether a service in the at least one service call relationship is associated with a target debug version, where the target debug version is a special case of a basic function version of the service, and then a service route in the at least one service call relationship is determined according to a determination result. In this case, when the service is called, it is determined in advance whether the service to be called is associated with the target debug version, the version of the service to be called at present can be determined, and the specific version of the service is determined according to the determination result, thereby solving the problem of calling error.

Drawings

The accompanying drawings, which are included to provide a further understanding of the application and are incorporated in and constitute a part of this application, illustrate embodiment(s) of the application and together with the description serve to explain the application and not to limit the application. In the drawings:

fig. 1 is a schematic structural diagram of a data call system provided in an embodiment of the present specification;

FIG. 2 is a block diagram of an example application of the data call system shown in FIG. 1;

fig. 3 is a schematic flowchart of a data calling method provided in an embodiment of the present specification;

fig. 4 is a schematic diagram of a service invocation relationship provided in an embodiment of the present specification;

fig. 5 is a schematic flowchart of a data call method provided in an embodiment of the present specification;

FIG. 6 is a flowchart of an application example of the data call method shown in FIG. 3 according to an embodiment of the present disclosure;

FIG. 7 is a flowchart of an application example of the data call method shown in FIG. 5 according to an embodiment of the present specification;

fig. 8 is a schematic structural diagram of a data call device according to an embodiment of the present disclosure;

fig. 9 is a schematic structural diagram of a data call apparatus according to an embodiment of the present disclosure.

Detailed Description

The problems in the prior art are analyzed, and the prior art provides two software development environment strategies. One of the strategies allocates a full amount of basic environment to each developer, where the basic environment is an operating environment of a complete set of services, and usually runs a relatively stable service version (hereinafter referred to as a basic function version) for debugging and invoking in software development. Since the base environment requires a large number of machine resources to be deployed, for example, the number of machine resources is a single base environment resource multiplied by the number of developers. This mode can avoid cross-calls between machines, but when the base environment is updated, configuration updates need to be made for each machine, which requires a large amount of maintenance to maintain the multiple configurations. Another strategy is that all developers share one basic environment, and all software needing debugging is deployed in the corresponding basic environment. Each developer respectively develops and modifies a part of the software corresponding to different services, so that a plurality of versions of the same software are combined and then deployed in a basic environment to form an updated version. Therefore, the basic function version and the update version of the stable debugging service are deployed simultaneously in the basic environment, when the calling service is debugged, the basic function version and the corresponding update version are difficult to distinguish accurately, the problem of calling error exists, and even the problem of distinguishing each update version exists. Once a problem arises with debugging, it is difficult to distinguish which version is problematic due to the interplay between the different versions. In addition, since a debugger needs to release software to the basic environment, the software needs to be redeployed each time the software is changed, which affects development efficiency.

The embodiment of the specification provides an improved data calling method, device, equipment and system, and a data calling process formed based on at least one service calling relationship is determined; judging whether the service in the at least one service calling relation is associated to a target debugging version, wherein the target debugging version is a special case of a basic function version of the service; and determining the service route in the at least one service calling relationship according to the judgment result. By using the technical scheme described in the embodiment of the specification, when calling, whether the service needing to be called is associated with the target debugging version or not is judged in advance, the version of the service needing to be called at present can be determined, and the specific version of the service is determined according to the judgment result, so that the problem of calling errors is solved.

To make the objects, technical solutions and advantages of the present application more clear, the technical solutions of the present application will be clearly and completely described below with reference to specific embodiments of the present application and the accompanying drawings. It should be apparent that the described embodiments are only a few embodiments of the present application, and not all embodiments. All other embodiments obtained by a person of ordinary skill in the art based on the embodiments in the present application without making any creative effort belong to the protection scope of the present application.

The technical solutions provided by the embodiments of the present application are described in detail below with reference to the accompanying drawings.

Fig. 1 is a schematic structural diagram of a data call system provided in an embodiment of the present specification, where the structure is shown as follows.

The data call system may include: a basic environment layer 101, a debugging environment layer 102 and a call control layer 103;

the base environment layer 101 is used to: running a base function version of at least one service;

the debug environment layer 102 is configured to: running a target debug version, which is a special case of a basic function version of a corresponding service in the basic environment layer 101;

the call control layer 103 is used to: determining a data calling process formed based on at least one service calling relation; judging whether the service in the at least one service calling relation is associated to a target debugging version or not; and determining the service route in the at least one service calling relationship according to the judgment result.

In one example application, the base environment layer 101 may provide a complete set of service execution environments that typically execute relatively stable versions of services, such as service a, service B, service C, service D, service E, and other base services for debugging calls in software development.

The debug environment layer 102 may be a virtual execution environment in form, and may be a set of independent and complete debug environments in use. In practical applications, the current software developer modifies the software services (such as service a and service B) in the debugging environment layer 102, the service a 'and service B' of the target debugging version are stored locally, and the rest of the software services C, service D and service E can be called from the basic environment layer 101 by routing to the basic environment layer 101 through the call control layer 103.

The service runs in a corresponding machine, so that the service a and the service B of the basic function version in the basic environment layer 101 shown in fig. 1 correspond to the machines a and B, respectively, and other machines in the basic environment layer 101 are not listed one by one; the target debug version of services A 'and B' in debug environment layer 102 shown in FIG. 1 correspond to machines A 'and B', respectively.

Referring to the data call process identified by the solid arrow, after the call control layer 103 receives the data call request sent by the machine a ', it determines that the service in at least one service call relationship is associated with the target debug version, determines the service route to the machine B' where the target debug version is located, and may further determine the target debug version of the service from the debug environment layer 102.

Referring to the data call process indicated by the dashed arrow, after the call control layer 103 receives the data call request sent by the machine a, it determines that the service in the at least one service call relationship is not associated with the target debug version, determines a service route to the machine B where the basic function version is located, and may further determine the basic function version of the service from the basic environment layer 101.

In this case, the base environment layer 101 and the debug environment layer 102 can be regarded as isolated, and the problem of call error can be solved. The debugger can debug the local debug environment layer 102 without affecting the service versions in other debug environment layers 102 or affected by the service versions in other debug environment layers 102, and can accurately determine which version has a problem when a debug error occurs. In addition, each modification of the software service is limited locally, repeated deployment on the basic environment layer 101 and the other debugging environment layers 102 is not needed, and the software development efficiency is high.

With the data call system described in the embodiment of the present specification, each user develops a small number of services that are unstable in debugging in the debugging environment layer 102, and the remaining services are supplemented by the basic function version of the services provided by the basic environment layer 101 through the isolation technology. In this way, multiple sets of debug environment layers 102 can be defined in the data call system, and in effect, each user appears to have exclusive ownership of the entire debug environment layer 102, while in reality most of the services are provided by the underlying environment layer 101.

FIG. 2 is a block diagram of an example application of the data call system shown in FIG. 1.

The call control layer 200 described in the embodiment of the present specification may include a Domain Name System (DNS) 201, a plug-in access layer 202, and a load balancing layer 203. The domain name system 201 is configured to parse the identification information of the data call node in the data call request, and determine domain name information. The plug-in access layer 202 is configured to determine whether a service in the at least one service invocation relationship is associated with the target debug version, and send a service route to the load balancing layer 203. The load balancing layer 203 is configured to provide services according to the IP address list corresponding to the services. Load balancing may provide an effective and transparent method of expanding the bandwidth of network devices and servers, increasing throughput, enhancing network data processing capacity, and improving network flexibility and availability.

Fig. 3 is a schematic flowchart of a data call method provided in an embodiment of the present specification, where the method is as follows. The embodiment of the specification describes a definition phase of a target debugging version.

Step 301: a data calling process constructed based on at least one service calling relationship is determined.

The data calling process can refer to a service calling link formed based on a service calling relation, and in a complete application program software, service data can be interdependent. For example, the call path for data a: x → Y → Z, wherein the dependency condition of X comprises service Y, and the dependency condition of service Y comprises service Z, therefore X → Y, Y → Z respectively represent two service call relations, and the data X is finally obtained by calling services Y and Z in sequence. In embodiments of the present specification, the data invocation process may also include other numbers of service invocation relationships based on the concatenation of invocation relationships.

As an application example, a service invocation relationship may be a call between two different services in the same software, such as a service developer developing a promoted content, such as a shopping cart (e.g., service X), that relies on a promoted advertisement (service Y); the service invocation relationship may also be a call between two different software applications, such as an application currently being developed that requires a service to invoke another application, such as an application currently being developed that requires a promotional advertisement in another application, and the promotional advertisement content invoked from the other application is displayed when the corresponding interface of the application currently being developed is opened.

In this embodiment of the present specification, the data invoking process may include a service invoking relationship, where data to be invoked is a service. Therefore, currently, a software developer can determine a data calling process formed based on at least one service calling relation in a software service development process or a debugging process.

In this embodiment of the present description, in the data call system, a current software developer may send development information of a target debug version of a current service to a call control layer in a development process of the target debug version of the service, where the development information of the target debug version may record a data call process, and the data call process may include at least one service call relationship. The call control layer may receive development information of the target debug version of at least one service; and processing the received development information of the target debugging version of the at least one service, and further determining a data calling process based on at least one service calling relation of the target debugging version.

In the embodiment of the present specification, information such as identification information of a service invocation node, identification information of a service source node, and service identification information may be obtained according to the service invocation relationship.

Step 303: if the version of the service in the at least one service invocation relation comprises a target debugging version, establishing association between the service in the at least one service invocation relation and the target debugging version, wherein the target debugging version is a special case of a basic function version of the service.

In this case, the service in the service invocation relationship is associated to the target debug version, not to the base function version. In this way, in the debugging and calling stage, when a call request for the service is received, it may be first determined whether the association exists, and if so, it is determined that the service is routed to the target debugging version, rather than to the base function version.

In this embodiment of the present specification, establishing an association between a service in the at least one service invocation relationship and a target debug version may include:

determining identification information of at least one calling relation node in the service calling relation;

and establishing association between the identification information of the at least one calling relation node and the identification information of the target debugging version.

In this case, the identification information of the invocation relation node may be identification information of the service invocation node and/or identification information of the service origin node. Establishing an association between the identification information of the at least one calling relationship node and the identification information of the target debugging version may include:

and establishing association between the identification information of the starting node of the data calling process and the identification information of the target debugging version. Thus, in conjunction with the above regarding FIG. 1, the starting node of the data call process is defined at the corresponding debug environment level.

In this specification embodiment, the identification information of the calling relationship node may include a name, a domain name, and the like of the calling relationship node, for example, a machine name, a domain name of a machine configuration. Thus, determining identification information of at least one calling relationship node in the service calling relationship comprises:

determining a domain name of at least one calling relation node in a service calling relation;

establishing an association between the identification information of the at least one calling relationship node and the target debugging version may include:

and establishing association between the domain name of at least one calling relation node and the target debugging version.

In this embodiment of the present specification, establishing an association between the identification information of the at least one call relation node and the identification information of the target debug version may include:

if the data calling process comprises at least two service calling relations of joint debugging, different target debugging versions corresponding to the at least two service calling relations are marked as the same debugging environment identification information;

and establishing association between the identification information of the at least one calling relation node and the identification information of the same debugging environment.

In an application example, referring to fig. 4, one of the debug environment layers T1 includes a service invocation relationship I: u → V; another debug environment layer T2 includes a service invocation relationship II: w → H, since the dependency condition of V contains W, the two debug environment layers T1 and T2 can be merged into one debug environment layer T, whose service call relationship III is denoted as U → V → W → H. The merging is not a physical merging, but a virtual merging is performed based on a service call relation, and a piece of debugging environment identification information is configured.

In this specification embodiment, after establishing the association between the service in the at least one service invocation relationship and the target debug version, the association between the service in the at least one service invocation relationship and the target debug version may be stored. For example, the association between the service in the service invocation relation and the target debugging version is stored in a cache for debugging invocation.

By using the technical scheme described in the embodiment of the specification, the incidence relation between the served version and the target debugging version in the data calling process is defined according to the service calling relation, and the incidence relation enables the calling relation nodes corresponding to the target debugging version to form a virtual isolation environment independent of the basic function version, so that the problem of calling errors of the service version can be solved during debugging.

Fig. 5 is a schematic flowchart of a data call method provided in an embodiment of the present specification, where the method is shown as follows. The technical solution described in the embodiments of the present specification is a data call flow at a debugging stage.

Step 502: and determining a data calling process formed based on at least one service calling relation.

In this embodiment, the executing agent of step 502 may be a software debugging node, for example, a running machine that develops software, and determines at least one service invocation relationship in a data invocation process.

In this embodiment, in combination with the data call system shown in fig. 1, the execution subject of step 502 may also be a call control layer, and the call control layer determines a data call process configured based on at least one service call relationship according to the received data call request. Specifically, before determining a data calling process formed based on at least one service calling relationship, a data calling request may be received, where the data calling request includes calling information for data; at this time, a data calling process configured based on at least one service calling relationship may be determined according to the calling information for the data.

The data call request may carry identification information of the call relationship node, and the call information of the data may include at least one of identification information of a data source, identification information of the data, at least one service call relationship included in the data call process, and other information, which are not listed here. This helps the call control layer determine the data calling process and at least one service calling relationship therein.

Specifically, the call control layer may determine at least one service call relationship according to the summary information of the data, or directly obtain the data call process and the at least one service call relationship included in the data call information.

Step 504: and judging whether the service in the at least one service calling relation is associated to a target debugging version, wherein the target debugging version is a special case of the basic function version of the service.

The special case may refer to a specific example of the basic function version of the service, for example, if the service is an advertisement, the basic function version is a general advertisement, and the target debugging version is a promotion advertisement.

In this embodiment of the present specification, determining whether a service in at least one service invocation relationship is associated with a target debug version may include:

acquiring identification information of at least one calling relation node in a service calling relation;

and judging whether the identification information of the at least one calling relation node is associated to the target debugging version.

At this time, the identification information of the calling relationship node may include a machine name, a domain name of the machine configuration, and the like.

Thus, determining whether the identification information of the at least one call relation node is associated with the target debug version may include:

analyzing the identification information of at least one calling relation node, and determining the domain name of the at least one calling relation node;

and judging whether the identification information of the at least one calling relation node is associated to a target debugging version or not according to the domain name of the at least one calling relation node.

In this embodiment of the present specification, determining whether the identification information of the at least one call relation node is associated with the target debug version may include:

and judging whether the identification information of the starting node of the data calling process is associated to the target debugging version.

Determining whether the identification information of the start node of the data call process is associated with the target debugging version may include: and judging whether the identification information of the starting node of the data calling process is associated with at least one target debugging version. For example, in a data call process: in A0 → B0 → C0, it can be determined whether the identification information of the start node corresponding to A0 is associated with the target debug version corresponding to at least one of B0 and C0.

If the data call request is received before determining at least one service call relationship in the data call process, the starting node of the data call process is the initiating node of the data call request.

In this case, if the identification information of the start node of the data call process is associated with the target debug version, it indicates that the call relationship node to which the start node and the target debug version belong may belong to the same debug environment layer, or both may belong to different debug environment layers.

In this embodiment of the present specification, if the identification information of the start node of the data call process is not associated with the target debug version, it may be determined that the service of the at least one call relation node is routed to the target debug version.

In this embodiment of the present specification, if the identification information of the start node of the data call process is not associated with the target debug version, it may be further determined whether the identification information of at least one other call relationship node in the data call process is associated with the target debug version. Then, a service route in the at least one service invocation relationship may be determined according to a determination result of whether the identification information of the at least one other invocation relationship node is associated with the target debug version. For example, for the data call process A0 → B0 → C0, if the identification information of the call relation node corresponding to A0 and B0 is not associated to the target debug version, it may be determined that the service in B0 → C0 is routed to the basic function version of C0; if the identification information of the call relation node corresponding to A0 is not associated with the target debug version, but the identification information of the call relation node corresponding to B0 is associated with the target debug version, it may be determined that the service in B0 → C0 is routed to the target debug version of C0.

In an embodiment of the present specification, the identification information of the at least one call relationship node may be matched based on a mapping relationship between the identification information of the call relationship node and the identification information of the target debug version; and then, judging whether the identification information of at least one calling relation node is associated to the target debugging version or not according to the matching result.

Referring to the above about step 303, a mapping relationship between the identification information of the call relationship node and the identification information of the target debug version may be established in advance according to the service call relationship.

For example, in a calling relationship node that is cascaded together in a data calling process, if a service developed by at least one calling relationship node includes a base function version and a target debug version, a mapping relationship may be established in advance between identification information of the target debug version and identification information of at least one calling relationship node. Therefore, when debugging and calling, the mapping relation can be matched by using the identification information of each calling relation node, and whether the identification information of at least one calling relation node has a matched target debugging version or not can be inquired.

If the identification information of at least one calling relationship node is matched with the target debugging version after being inquired, the identification information of at least one calling relationship node can be determined to be associated with the target debugging version, otherwise, the identification information of each calling relationship node is not associated with the target debugging version after not being matched with the target debugging version.

In an embodiment of this specification, matching, based on a mapping relationship between identification information of a call relation node and identification information of a target debug version, identification information of at least one call relation node includes:

and inquiring a memory area of mapping relation between the identification information of the calling relation node and the identification information of the target debugging version according to the identification information of at least one calling relation node.

In this embodiment of the present specification, the storage area may be a Cache (referred to as a Cache), and the Cache may query a mapping relationship between identification information of a call relationship node and identification information of a target debug version. Firstly, searching needed data from a cache, if the needed data is found, directly executing the data, and if the needed data is not found, searching the data from an in-memory database. Since caches run much faster than memory, the role of caches is to help hardware run faster.

In this embodiment of the present specification, if at least two different target debug versions of joint debugging are marked as the same debug environment identification information in advance, matching the identification information of at least one call relation node based on the mapping relationship between the identification information of the call relation node and the identification information of the target debug version may include:

and matching the identification information of the at least one calling relation node based on the mapping relation between the identification information of the calling relation node and the same debugging environment mark information.

In this embodiment of the present specification, determining whether a service in the at least one service invocation relationship is associated with a target debug version may include:

it is determined whether the dependency condition of the data includes a target debug version of the at least one service.

The dependency condition of data refers to a dependency condition that achieves the result of the data.

Wherein the dependency condition of the data may be determined from the data itself, and then it is determined whether the determined dependency condition of the data comprises a target debug version of at least one service. Specifically, summary information of the data may be called; and determining the dependence condition of the data according to the summary information of the data.

In an application example, if data of a software service is modified, a dependency condition of the data is written in the data or a dependency condition, such as a domain name, a dependent service name, or the like, is updated on the data. For example, a call to the base function version is indicated in the original data, and a call to the target debug version is indicated in the modified data.

Step 506: and determining the service route in the at least one service calling relation according to the judgment result.

Here, the determination result of whether the service in the at least one service invocation relationship is associated with the target debug version may include yes or no. Determining the service route in the at least one service invocation relationship according to the judgment result, including:

if the judgment result is yes, determining the service route of the target debugging version;

and if the judgment result is negative, determining the service route of the basic function version.

Referring to the content of step 504, when determining whether the identification information of the start node of the data invoking process is associated with the target debugging version, if the determination result is yes, determining a service route to the target debugging version; if the judgment result is negative, the service route of the basic function version can be determined.

In this embodiment of the present specification, when the determination result is negative, it indicates that the start node of the data call process is independent from the debug environment layer, and at this time, it may be further determined whether the identification information of at least one other call relation node in the data call process is associated with the target debug version. In this case, the service route in the at least one service invocation relationship is determined according to the determination result of whether the identification information of the at least one other invocation relationship node is associated with the target debug version.

Specifically, if the determination result is yes, the service route to the target debug version may be determined.

However, if it is determined that the identification information of each of the other invocation relation nodes is not associated with the target debug version, it is determined that the service in the at least one service invocation relation is routed to the base function version.

When the execution subject in the embodiments of the present specification is a call control layer, after a service route is determined, a data call process may be started according to the determined service route, and the data is obtained by calling;

and sending the called data, wherein the called data is used for debugging. The data resulting from the call is sent to the debugger.

When the execution subject of the embodiment of the present specification is a developer, the data may be directly called after determining the service route.

Starting a data calling process, including sequentially serving based on a service calling relation in the data calling process until the data is obtained.

By using the data call scheme described in the embodiments of the present specification, whether a service is routed to a base function version or a target debug version can be determined according to a result of determining whether the service is associated with the target debug version in a service call relationship. This may solve the problem of call errors.

Fig. 6 is a flowchart of an application example of the data call method shown in fig. 3 according to an embodiment of the present application, where the method is shown in the figure.

Step 601: acquiring debugging environment identification information, wherein the debugging environment identification information comprises identification information representing target debugging versions of a plurality of services and IP (Internet protocol) information of a machine (which can be regarded as identification information of a calling relation node);

step 603: storing debugging environment identification information into a database;

step 605: synchronizing the debugging environment identification information to a cache;

step 607: acquiring basic environment identification information, wherein the basic environment identification information can comprise domain name information of basic service;

step 609: associating the basic environment identification information with the debugging environment identification information;

step 611: sending the association between the basic environment identification information and the debugging environment identification information to a plug-in access layer;

step 613: and sending the association of the basic environment identification information and the debugging environment identification information to a load balancing layer.

Fig. 7 is a flowchart of an application example of the data call method shown in fig. 5 according to an embodiment of the present application.

Step 702: acquiring identification information of a request initiating node through a request; and

step 704: acquiring domain name information of a data source node by a request, wherein the data can be software service data;

step 706: analyzing the identification information of the request initiating node to obtain IP information;

step 708: calling IP information of a cache matching request initiating node;

if the matching is successful, determining that the IP information of the request initiating node is associated with the target debugging version of the service, executing step 710, and combining the information of the target debugging version and the domain name information of the data source node to obtain debugging environment calling information;

step 712: calling a load balancing layer by carrying the debugging environment calling information;

step 714: and calling information routing to a machine corresponding to the data source node according to the carried debugging environment.

In another alternative of this specification, step 716 is performed: acquiring IP information of a data source node through a request;

step 718: calling the IP information of the cache matching data source node;

if so, go to step 710.

If the matching results of step 718 and step 708 are not matched, step 720 may be performed: load balancing is normally called; after that time, the user can use the device,

step 722 is executed: and the load balance carries basic environment calling information to a machine corresponding to the data source node.

Referring to the content in fig. 6 above, the load balancing layer stores the association between the basic environment identification information and the debugging environment identification information, and can route to the machine in the corresponding environment as needed.

Fig. 8 is a schematic structural diagram of a data call apparatus according to an embodiment of the present disclosure, where the structure is as follows.

The data calling means may include:

a calling process determining module 801 that determines a data calling process configured based on at least one service calling relationship;

a determining module 802, configured to determine whether a service in the at least one service invocation relationship is associated with a target debug version, where the target debug version is a special case of a basic function version of the service;

the service route determining module 803 determines a service route in the at least one service invocation relationship according to the determination result.

Optionally, the determining whether the served service in the at least one service invocation relationship is associated with the target debug version includes:

acquiring identification information of at least one calling relation node in the service calling relation;

and judging whether the identification information of the at least one calling relation node is associated with the target debugging version.

Optionally, the determining whether the service in the at least one service invocation relationship is associated with the target debug version includes:

and judging whether the dependency condition of the data comprises a target debugging version of at least one service.

Based on the same inventive concept, embodiments of the present specification further provide an electronic device, including at least one processor and a memory, where the memory stores programs and is configured to be executed by the at least one processor to:

For other functions of the processor, reference may also be made to the contents described in the above embodiments, which are not described in detail herein.

Based on the same inventive concept, embodiments of the present specification further provide a computer-readable storage medium including a program for use with an electronic device, the program being executable by a processor to perform the steps of:

Fig. 9 is a schematic structural diagram of a data call apparatus according to an embodiment of the present disclosure, where the structure is as follows.

The data calling means may include:

a determining module 901, configured to determine a data calling process based on at least one service calling relationship;

the establishing module 902, if the version of the service in the at least one service invocation relationship includes a target debug version, establishes an association between the service in the at least one service invocation relationship and the target debug version, where the target debug version is a special case of the basic function version of the service.

Optionally, establishing an association between a service in the at least one service invocation relationship and the target debug version includes:

and establishing association between the identification information of the at least one calling relation node and the target debugging version.

Based on the same inventive concept, embodiments of the present specification further provide an electronic device, including at least one processor and a memory, where the memory stores a program and is configured to execute, by the at least one processor, the following steps:

In the 90 s of the 20 th century, improvements in a technology could clearly distinguish between improvements in hardware (e.g., improvements in circuit structures such as diodes, transistors, switches, etc.) and improvements in software (improvements in process flow). However, as technology advances, many of today's process flow improvements have been seen as direct improvements in hardware circuit architecture. Designers almost always obtain the corresponding hardware circuit structure by programming an improved method flow into the hardware circuit. Thus, it cannot be said that an improvement in the process flow cannot be realized by hardware physical modules. For example, a Programmable Logic Device (PLD), such as a Field Programmable Gate Array (FPGA), is an integrated circuit whose Logic functions are determined by programming the Device by a user. A digital system is "integrated" on a PLD by the designer's own programming without requiring the chip manufacturer to design and fabricate application-specific integrated circuit chips. Furthermore, nowadays, instead of manually manufacturing an Integrated Circuit chip, such Programming is often implemented by "logic compiler" software, which is similar to a software compiler used in program development and writing, but the original code before compiling is also written by a specific Programming Language, which is called Hardware Description Language (HDL), and HDL is not only one but many, such as ABEL (Advanced Boolean Expression Language), AHDL (alternate Hardware Description Language), traffic, CUPL (core universal Programming Language), HDCal, jhddl (Java Hardware Description Language), lava, lola, HDL, PALASM, rhyd (Hardware Description Language), and vhigh-Language (Hardware Description Language), which is currently used in most popular applications. It will also be apparent to those skilled in the art that hardware circuitry for implementing the logical method flows can be readily obtained by a mere need to program the method flows with some of the hardware description languages described above and into an integrated circuit.

The controller may be implemented in any suitable manner, for example, the controller may take the form of, for example, a microprocessor or processor and a computer readable medium that stores computer readable program code (e.g., software or firmware) executable by the (micro) processor, logic gates, switches, an Application Specific Integrated Circuit (ASIC), a programmable logic controller, and embedded microcontrollers, examples of which include, but are not limited to, the following microcontrollers: ARC 625D, atmel AT91SAM, microchip PIC18F26K20, and Silicone Labs C8051F320, the memory controller may also be implemented as part of the control logic for the memory. Those skilled in the art will also appreciate that, in addition to implementing the controller in purely computer readable program code means, the same functionality can be implemented by logically programming method steps such that the controller is in the form of logic gates, switches, application specific integrated circuits, programmable logic controllers, embedded microcontrollers and the like. Such a controller may thus be considered a hardware component, and the means included therein for performing the various functions may also be considered as a structure within the hardware component. Or even means for performing the functions may be regarded as being both a software module for performing the method and a structure within a hardware component.

The systems, apparatuses, modules or units described in the above embodiments may be specifically implemented by a computer chip or an entity, or implemented by a product with certain functions. One typical implementation device is a computer. In particular, the computer may be, for example, a personal computer, a laptop computer, a cellular telephone, a camera phone, a smartphone, a personal digital assistant, a media player, a navigation device, an email device, a game console, a tablet computer, a wearable device, or a combination of any of these devices.

For convenience of description, the above devices are described as being divided into various units by function, respectively. Of course, the functionality of the units may be implemented in one or more software and/or hardware when implementing the present application.

As will be appreciated by one skilled in the art, embodiments of the present invention may be provided as a method, system, or computer program product. Accordingly, the present invention may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present invention may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, and the like) having computer-usable program code embodied therein.

The present invention is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each flow and/or block of the flow diagrams and/or block diagrams, and combinations of flows and/or blocks in the flow diagrams and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.

These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including instruction means which implement the function specified in the flowchart flow or flows and/or block diagram block or blocks.

These computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide steps for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.

In a typical configuration, a computing device includes one or more processors (CPUs), input/output interfaces, network interfaces, and memory.

The memory may include forms of volatile memory in a computer readable medium, random Access Memory (RAM) and/or non-volatile memory, such as Read Only Memory (ROM) or flash memory (flash RAM). Memory is an example of a computer-readable medium.

Computer-readable media, including both permanent and non-permanent, removable and non-removable media, may implement the information storage by any method or technology. The information may be computer readable instructions, data structures, modules of a program, or other data. Examples of computer storage media include, but are not limited to, phase change memory (PRAM), static Random Access Memory (SRAM), dynamic Random Access Memory (DRAM), other types of Random Access Memory (RAM), read Only Memory (ROM), electrically Erasable Programmable Read Only Memory (EEPROM), flash memory or other memory technology, compact disc read only memory (CD-ROM), digital Versatile Disks (DVD) or other optical storage, magnetic cassettes, magnetic tape magnetic disk storage or other magnetic storage devices, or any other non-transmission medium, which can be used to store information that can be accessed by a computing device. As defined herein, a computer readable medium does not include a transitory computer readable medium such as a modulated data signal and a carrier wave.

It should also be noted that the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus. Without further limitation, an element defined by the phrases "comprising one of 8230; \8230;" 8230; "does not exclude the presence of additional like elements in a process, method, article, or apparatus that comprises that element.

The application may be described in the general context of computer-executable instructions, such as program modules, being executed by a computer. Generally, program modules include routines, programs, objects, components, data structures, etc. that perform particular tasks or implement particular abstract data types. The application may also be practiced in distributed computing environments where tasks are performed by remote processing devices that are linked through a communications network. In a distributed computing environment, program modules may be located in both local and remote computer storage media including memory storage devices.

All the embodiments in the present specification are described in a progressive manner, and the same and similar parts among the embodiments are referred to each other, and each embodiment focuses on the differences from other embodiments. In particular, for the system embodiment, since it is substantially similar to the method embodiment, the description is simple, and for the relevant points, reference may be made to the partial description of the method embodiment.

The above description is only an example of the present application and is not intended to limit the present application. Various modifications and changes may occur to those skilled in the art. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present application should be included in the scope of the claims of the present application.

Claims

1. A data calling method, comprising:

determining a service route in the at least one service calling relationship according to a judgment result;

wherein, judging whether the service in the at least one service call relation is associated to the target debugging version comprises:

judging whether the identification information of the at least one calling relation node is associated to a target debugging version;

wherein, judging whether the identification information of the at least one calling relation node is associated with the target debugging version comprises:

matching the identification information of the at least one calling relation node based on the mapping relation between the identification information of the calling relation node and the identification information of the target debugging version;

judging whether the identification information of the at least one calling relation node is associated to a target debugging version or not according to a matching result;

matching the identification information of the at least one calling relation node based on the mapping relation between the identification information of the calling relation node and the identification information of the target debugging version comprises the following steps:

and matching the identification information of at least one calling relation node based on the mapping relation between the identification information of the calling relation node and the same debugging environment identification information when different target debugging versions of at least two joint debugging are marked as the same debugging environment identification information.

2. The data call method according to claim 1, wherein determining the service route in the at least one service call relationship according to the determination result comprises:

3. The data call method according to claim 1, prior to determining the data call process constructed based on the at least one service call relationship, the data call method further comprising:

receiving a data calling request, wherein the data calling request comprises calling information of the data;

determining a data calling process constructed based on at least one service calling relationship, comprising:

and determining a data calling process formed based on at least one service calling relation according to the calling information of the data.

4. The data invocation method according to claim 3, wherein after determining service routing in the at least one service invocation relationship according to the determination result, the data invocation method comprises:

starting the data calling process according to the determined service route, and calling to obtain the data;

and sending the called data, wherein the called data is used for debugging.

5. The data calling method of claim 1, wherein determining whether the identification information of the at least one calling relationship node is associated with a target debug version comprises:

and judging whether the identification information of the initial node of the data calling process is associated with the target debugging version.

6. The data call method according to claim 5, wherein when the step of determining at least one service call relationship in a data call process is performed according to the received data call request, a start node of the data call process is determined according to an originating node of the data call request.

7. The data calling method of claim 1, wherein determining whether the identification information of the at least one calling relationship node is associated with a target debug version comprises:

judging whether the identification information of the initial node of the data calling process is related to a target debugging version or not;

if the identification information of the initial node of the data calling process is not associated to the target debugging version, judging whether the identification information of at least one other calling relation node in the data calling process is associated to the target debugging version;

and determining the service route in the at least one service invocation relation according to the judgment result of whether the identification information of the at least one other invocation relation node is associated with the target debugging version.

8. The data call method according to claim 7, wherein determining the service route in the at least one service call relation according to the determination result of whether the identification information of the at least one other call relation node is associated with the target debug version comprises:

and if the identification information of each other calling relation node is not associated to the target debugging version, determining that the service in the at least one service calling relation is routed to the basic function version.

9. The data calling method of claim 1, matching the identification information of the at least one calling relationship node based on a mapping relationship between the identification information of the calling relationship node and the identification information of the target debug version, comprising:

and inquiring a storage area of a mapping relation between the identification information of the calling relation node and the identification information of the target debugging version according to the identification information of the at least one calling relation node.

10. The data call method according to claim 9, wherein the querying a memory area for a mapping relationship between the identification information of the call relationship node and the identification information of the target debug version when the memory area is a cache includes:

and querying the cache of the mapping relation between the identification information of the calling relation node and the identification information of the target debugging version.

11. The data call method according to claim 1, wherein determining whether the identification information of the at least one call relation node is associated with a target debug version comprises:

analyzing the identification information of the at least one calling relation node, and determining the domain name of the at least one calling relation node;

and judging whether the domain name of the at least one calling relation node is associated with a target debugging version.

12. The data call method of claim 1, determining whether a service in the at least one service call relationship is associated with a target debug version, comprising:

determining whether the dependency condition of the data includes a target debug version of at least one service.

13. The data call method of claim 12, determining whether the dependency condition of the data includes a target debug version of at least one service, comprising:

determining a dependency condition of the data according to the data;

determining whether the determined dependency condition of the data includes a target debug version of at least one service.

14. A data calling method, comprising:

if the version of the service in the at least one service calling relation comprises a target debugging version, establishing association between the service in the at least one service calling relation and the target debugging version, wherein the target debugging version is a special case of a basic function version of the service;

wherein, establishing the association between the service in the at least one service call relation and the target debugging version comprises:

establishing association between the identification information of the at least one calling relation node and the identification information of the target debugging version;

wherein, establishing the association between the identification information of the at least one call relation node and the identification information of the target debugging version comprises:

if the data calling process comprises at least two service calling relations of joint calling, marking different target debugging versions corresponding to the at least two service calling relations as the same debugging environment identification information;

and establishing association between the identification information of the at least one calling relation node and the same debugging environment identification information.

15. The data call method of claim 14, determining a data call process based on at least one service call relationship, comprising:

receiving development information for the target debug version of at least one service;

and processing the received development information of the target debugging version of at least one service, and determining a data calling process formed based on at least one service calling relation.

16. The data calling method of claim 14, establishing an association between identification information of the at least one calling relationship node and identification information of a target debug version, comprising:

and establishing association between the identification information of the starting node of the data calling process and the identification information of the target debugging version.

17. The data call method according to claim 14, wherein the identification information of the at least one calling relationship node includes at least one of a name and a domain name of the calling relationship node.

18. The data call method as recited in claim 14, after establishing an association between a service in the at least one service call relationship and a target debug version, the data call method further comprising:

and storing the association between the service in the at least one service calling relation and the target debugging version.

19. A data invocation apparatus, comprising:

the service route determining module is used for determining a service route in the at least one service calling relationship according to a judgment result;

wherein the judging module is further configured to:

judging whether the identification information of the at least one calling relation node is associated to a target debugging version or not;

and matching the identification information of at least one calling relation node based on the mapping relation between the identification information of the calling relation node and the identification information of the same debugging environment when different target debugging versions of at least two joint debugging are marked as the same debugging environment identification information.

20. The data invocation device of claim 19, determining whether a service in the at least one service invocation relationship is associated with a target debug version, includes:

21. A data invocation apparatus, comprising:

the establishing module is used for establishing association between the service in the at least one service calling relation and a target debugging version if the version of the service in the at least one service calling relation comprises the target debugging version, wherein the target debugging version is a special case of a basic function version of the service;

wherein the establishing module is further configured to:

22. A data call system comprising:

a debugging environment layer, which runs a target debugging version, wherein the target debugging version is a special case of a basic function version of a corresponding service in the basic environment layer;

the calling control layer is used for determining a data calling process formed based on at least one service calling relation, judging whether the service in the at least one service calling relation is related to a target debugging version or not, and determining the service route in the at least one service calling relation according to the judgment result; wherein the call control layer is configured to implement the data call method of any one of claims 1 to 13.

23. An electronic device comprising at least one processor and a memory, the memory storing a program and configured to perform, by the at least one processor, the steps of:

wherein, judging whether the service in the at least one service call relation is associated with the target debugging version comprises:

wherein matching the identification information of the at least one call relation node based on the mapping relationship between the identification information of the call relation node and the identification information of the target debug version comprises:

24. A computer readable storage medium comprising a program for use in conjunction with an electronic device, the program being executable by a processor to perform the steps of:

determining a service route in the at least one service calling relation according to the judgment result;

25. An electronic device comprising at least one processor and a memory, the memory storing a program and configured to perform the following steps by the at least one processor:

wherein the establishing of the association between the service in the at least one service invocation relation and the target debugging version comprises:

26. A computer readable storage medium comprising a program for use in conjunction with an electronic device, the program being executable by a processor to perform the steps of:

wherein, establishing the association between the identification information of the at least one calling relation node and the identification information of the target debugging version comprises: