CN115061743A

CN115061743A - Interface calling method and device, computer readable medium and electronic equipment

Info

Publication number: CN115061743A
Application number: CN202210640763.7A
Authority: CN
Inventors: 朱超; 刘桦; 黄勇; 张剑秋
Original assignee: Guangdong Oppo Mobile Telecommunications Corp Ltd
Current assignee: Guangdong Oppo Mobile Telecommunications Corp Ltd
Priority date: 2022-06-08
Filing date: 2022-06-08
Publication date: 2022-09-16

Abstract

The disclosure provides an interface calling method and device, a computer readable medium and electronic equipment, and relates to the technical field of computers. The method comprises the following steps: responding to a calling request of a target application program, and determining first result data corresponding to the target application program from a first cache unit of a system service side; synchronizing the first result data to a second cache unit at the side of the target application program; determining a target application program interface according to the calling request; and matching second result data corresponding to the target application program interface in the first result data stored in the second cache unit so that the target application program directly calls the second result data from the second cache unit to complete the calling of the target application program interface. The method and the device can effectively improve the starting speed and the running speed of the application program, reduce the load of a system service process, improve the fluency of the system and reduce the power consumption of the equipment.

Description

Interface calling method and device, computer readable medium and electronic equipment

Technical Field

The present disclosure relates to the field of computer technologies, and in particular, to an interface calling method, an interface calling apparatus, a computer-readable medium, and an electronic device.

Background

With the development of science and technology, smart phones are widely used, and people realize various functions through Application programs (APPs) installed in smart phones. Generally, in a terminal system, in order to ensure the security of data, each process is independently operated, and other process resources cannot be directly used. Therefore, when a service process provides a service for a process in which an Application program is located, the service is generally implemented through inter-process communication (e.g., a cross-process communication mechanism binder in an Android system), specifically, corresponding Application Programming interfaces (APIs, which are hereinafter referred to as Application program interfaces) may be set for the services in advance, and the Application program may call the APIs corresponding to the service to use resources in the service process, so as to implement a desired function.

At present, in the related art, in a cold start or use process of an application APP, an API that calls the same system service through a binder many times exists, which not only needs to consume more time, but also causes an increase in load of the system service, and reduces system performance.

Disclosure of Invention

The present disclosure aims to provide an interface calling method, an interface calling apparatus, a computer readable medium, and an electronic device, so as to at least increase the starting speed and the running speed of an application program to a certain extent, reduce the load of a system service process, increase the smoothness of a system, and reduce the power consumption of the device.

According to a first aspect of the present disclosure, there is provided an interface calling method, including:

responding to a calling request of a target application program, and determining first result data corresponding to the target application program from a first cache unit of a system service side;

synchronizing the first result data to a second cache unit on the side of the target application program;

determining a target application program interface according to the calling request;

and matching second result data corresponding to the target application program interface from the first result data stored in the second cache unit, so that the target application program directly calls the second result data from the second cache unit.

According to a second aspect of the present disclosure, there is provided an interface calling apparatus, including:

the first result data determining module is used for responding to a calling request of a target application program and determining first result data corresponding to the target application program from a first cache unit of a system service side;

the first result data synchronization module is used for synchronizing the first result data to a second cache unit on the side of the target application program;

the interface determining module is used for determining a target application program interface according to the calling request;

and the local calling module is used for matching second result data corresponding to the target application program interface from the first result data stored in the second cache unit so as to enable the target application program to directly call the second result data from the second cache unit.

According to a third aspect of the present disclosure, a computer-readable medium is provided, on which a computer program is stored, which computer program, when being executed by a processor, is adapted to carry out the above-mentioned method.

According to a fourth aspect of the present disclosure, there is provided an electronic apparatus, comprising:

a processor; and

a memory for storing one or more programs that, when executed by the one or more processors, cause the one or more processors to implement the above-described method.

According to the interface calling method provided by an embodiment of the disclosure, when a calling request of a target application program is detected, first result data corresponding to the target application program may be determined from a first cache unit of a system service side, then the first result data is synchronized to a second cache unit of the target application program side, a target application program interface is determined according to the calling request, and finally the target application program directly matches second result data corresponding to the target application program interface from the second cache unit. On one hand, result data obtained by historical calling of an application program interface of the application program are cached in a first cache unit at a system service side, when the next calling is needed, the result data are directly obtained from the first cache unit, the application program interface does not need to wait for the result data to be fed back, the response speed of the interface calling is improved, the load pressure of a system service process is reduced, the fluency of the system is improved, and the power consumption of terminal equipment is reduced; on the other hand, when the application program requests to call the relevant interface, the result data corresponding to the application program is synchronized to the local second cache unit of the application program from the first cache unit, and the call of the target application program interface is directly completed locally, so that the data communication path can be reduced, the acquisition efficiency of the result data is improved, and the starting speed and the running speed of the application program are effectively improved.

It is to be understood that both the foregoing general description and the following detailed description are exemplary and explanatory only and are not restrictive of the disclosure.

Drawings

The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate embodiments consistent with the present disclosure and together with the description, serve to explain the principles of the disclosure. It is to be understood that the drawings in the following description are merely exemplary of the disclosure, and that other drawings may be derived from those drawings by one of ordinary skill in the art without the exercise of inventive faculty. In the drawings:

FIG. 1 illustrates a schematic diagram of an exemplary system architecture to which embodiments of the present disclosure may be applied;

FIG. 2 is a schematic diagram illustrating a framework for invoking an application program interface via cross-process communication in an exemplary embodiment of the present disclosure;

FIG. 3 is a flow diagram schematically illustrating an interface invocation method in an exemplary embodiment of the present disclosure;

fig. 4 is a schematic diagram illustrating a framework for caching result data by a first caching unit on a system service side in an exemplary embodiment of the disclosure;

FIG. 5 is a block diagram schematically illustrating a framework for implementing a local calling application program interface through a second cache unit in an exemplary embodiment of the disclosure;

FIG. 6 is a schematic flow chart illustrating selective caching of interface call data in an exemplary embodiment of the disclosure;

FIG. 7 is a schematic flow chart illustrating a process for periodically persisting result data in an exemplary embodiment of the present disclosure;

FIG. 8 is a block diagram illustrating a framework for updating cached result data in an exemplary embodiment of the present disclosure;

fig. 9 schematically illustrates a composition diagram of an interface invocation means in an exemplary embodiment of the present disclosure;

fig. 10 shows a schematic diagram of an electronic device to which embodiments of the present disclosure may be applied.

Detailed Description

Example embodiments will now be described more fully with reference to the accompanying drawings. Example embodiments may, however, be embodied in many different forms and should not be construed as limited to the examples set forth herein; rather, these embodiments are provided so that this disclosure will be thorough and complete, and will fully convey the concept of example embodiments to those skilled in the art. The described features, structures, or characteristics may be combined in any suitable manner in one or more embodiments.

Furthermore, the drawings are merely schematic illustrations of the present disclosure and are not necessarily drawn to scale. The same reference numerals in the drawings denote the same or similar parts, and thus their repetitive description will be omitted. Some of the block diagrams shown in the figures are functional entities and do not necessarily correspond to physically or logically separate entities. These functional entities may be implemented in the form of software, or in one or more hardware modules or integrated circuits, or in different networks and/or processor devices and/or microcontroller devices.

Fig. 1 is a schematic diagram illustrating a system architecture of an exemplary application environment to which an interface calling method and apparatus according to an embodiment of the present disclosure may be applied.

As shown in fig. 1, the system architecture 100 may include one or more of

terminal devices

101, 102, 103, a network 104, and a server 105. The network 104 serves as a medium for providing communication links between the

terminal devices

101, 102, 103 and the server 105. Network 104 may include various connection types, such as wired, wireless communication links, or fiber optic cables, to name a few. The

terminal devices

101, 102, 103 may be various electronic devices running applications, including but not limited to portable computers, smart phones, tablets, wearable devices, and the like. It should be understood that the number of terminal devices, networks, and servers in fig. 1 is merely illustrative. There may be any number of terminal devices, networks, and servers, as desired for implementation. For example, server 105 may be a server cluster comprised of multiple servers, and the like.

The interface calling method provided by the embodiment of the present disclosure is generally executed by the

terminal devices

101, 102, and 103, and accordingly, the interface calling apparatus is generally disposed in the

terminal devices

101, 102, and 103. However, it is easily understood by those skilled in the art that the interface calling method provided in the embodiment of the present disclosure may also be executed by the server 105, and accordingly, the interface calling device may also be disposed in the server 105, which is not particularly limited in the exemplary embodiment. For example, in an exemplary embodiment, the developer may obtain first result data corresponding to the target application in the test environment, and then upload the first result data to the server 105, and when the

terminal device

101, 102, 103 detects a call request of the target application, the server 105 sends the first result data corresponding to the target application to the first cache unit or the second cache unit of the

terminal device

101, 102, 103 through the network 104.

In the related art, as shown with reference to fig. 2, the terminal device 210 may include a system service side 220 and an application side 230. Taking an App cold start request of the application program in the terminal device 210 as an example, the App cold start process in the application program side 230 may be summarized as follows: starting the process of the App, loading the related resources of the process, starting an App interface and displaying the App interface. When the application program on the application program side 230 is in cold start, generally, the API of the system service (PMS, DMS, etc.) of the system service side 220 is called by multiple binders to obtain result data returned by the API, for example, the result data may be information such as package parameter information package, display parameter information display, license information permission, and the like. When obtaining the relevant information of the system service, the binder generally needs to call the API of the same system service for multiple times, however, the data returned by the API of the same system service is generally the same, and multiple binder calls need to consume more time, which causes the load of the system service process to increase, resulting in a slower starting speed of the application program.

Based on one or more problems in the related art, the present disclosure provides an interface calling method, and an interface calling method and an interface calling apparatus according to exemplary embodiments of the present disclosure are described below by taking a terminal device as an example to execute the method.

Fig. 3 is a flowchart illustrating an interface calling method in the present exemplary embodiment, which may include the following steps S310 to S340:

in step S310, in response to a call request of a target application, first result data corresponding to the target application is determined from a first cache unit on a system service side.

In an exemplary embodiment, the call request refers to a request instruction for requesting the system service process to call the application program interface by the target application program when the terminal device starts running. For example, the invocation request may be a cold start request generated when the user triggers an icon of the target application and starts the target application. In the cold start process of an application program, generally, an API related to a system Service needs to be called to a system Service process system _ server many times through a cross-process communication mechanism, for example, the system Service may be a Package Management Service (PMS) of the application program, or a Display Management Service (DMS) of the application program, and the like.

The call request can also be an interactive request generated by triggering a certain function control by a user during the running process of the target application program. For example, when a user uses a rear camera of a photographing application program, a flash start control is triggered, and at this time, the application program calls an API related to flash hardware to a system service process to obtain result data related to flash hardware fed back by the API. Of course, the call request may also be other types of request instructions for requesting the system service process to call the application program interface, and the type of the request instruction for calling the application program interface is not limited in this embodiment.

The first cache unit is a control module arranged on the system service side and used for caching and managing result data returned by the relevant application program interfaces, for example, when the application program runs, the result data returned by each application program interface called by the application program can be captured and cached by the first cache unit, and when the application program calls the same application program interface next time, the corresponding result data is directly returned without calling the same application program interface again. Specifically, the first cache unit may store the result data according to the identification data of the application program (e.g., a package name of the application program), and directly query the result data related to the application program according to the identification data of the application program when a call request of the application program is detected subsequently.

The first result data refers to all result data related to the target application program cached in the first cache unit.

In step S320, the first result data is synchronized to a second cache unit on the side of the target application program.

In an exemplary embodiment, the second cache unit refers to a local cache module, which is arranged on the side of the target application program and is used for storing the first result data corresponding to the target application program.

The synchronization refers to a process of backing up first result data corresponding to the target application program in the first cache unit to the second cache unit, or updating the first result data in the second cache unit through the first result data in the first cache unit, and through data synchronization, consistency and integrity of the first result data stored at the system service side and the target application program side can be ensured.

For example, the result data a of the interface call corresponding to the application program a and the result data B of the interface call corresponding to the application program B are currently stored in the first cache unit of the system service side; if the application program B is started on the application program side, at this time, the application program process corresponding to the application program B sends a synchronization request to the first cache unit of the system service side (e.g., system _ server process), and then the first cache unit may perform result data query according to the synchronization request. Specifically, after receiving the synchronization request, the first cache unit may match the result data B corresponding to the application program B according to the identification data of the application program B in the synchronization request, and then back up the result data B to the second cache unit on the application program side through an interprocess communication mechanism or a data synchronization tool, so as to synchronize the first result data to the second cache unit on the target application program side; of course, during the use of the application program B, the second cache unit may send the synchronization request to the first cache unit again within a certain time interval, and the first cache unit will re-query the latest result data B according to the synchronization request, and then overwrite the result data B in the second cache unit with the latest result data B.

When a call request of the target application program is detected, all result data related to the target application program, that is, first result data corresponding to the target application program, may be matched from the first cache unit of the system service side according to the identification data of the target application program included in the call request. Then, the first cache unit may send a synchronization request to the second cache unit, and after the second cache unit agrees, the first cache unit may synchronize the determined first result data to the second cache unit, so that the target application program may directly query, in the second cache unit, the result data returned by the currently required API interface without acquiring from the system service process.

In step S330, a target application program interface is determined according to the call request.

In an exemplary embodiment, the target application program interface refers to an application program interface to be called by a call request of a target application program, for example, when the call request is a cold start request, the target application program interface may be an application program interface related to a packet management service PMS, or an application program interface related to a display management service DMS of the application program, specifically, the target application program interface to be called currently is related to a type of the call request of the target application program, which is not particularly limited in this exemplary embodiment.

In step S340, second result data corresponding to the target application program interface is matched from the first result data stored in the second cache unit, so that the target application program directly calls the second result data from the second cache unit.

In an exemplary embodiment, the second result data refers to result data returned by the target application program interface when the system service process calls the target application program interface. That is, the first result data may include a plurality of result data returned by the target application program when the plurality of application program interfaces are called in the using process, the second result data may include result data returned by the target application program interface, and the first result data includes the second result data.

For example, the application program side runs an application program B (i.e., a target application program), the result data B (i.e., first result data) synchronized from the first cache unit is stored in the second cache unit, and the result data B may include result data of a plurality of application program interfaces corresponding to the application program B, for example, the result data B may include result data 1 generated by calling the application program interface 1 and result data 2 generated by calling the application program interface 2; assuming that the application program B needs to call the application program interface 2 (i.e., the target application program interface) in the running process, a call request is generated at this time, after the second cache unit receives the call request, the result data 2 may be queried in the result data B according to the identification data of the application program interface 2 included in the call request, and the queried result data 2 is returned to the application program B, so that the result data 2 (i.e., the second result data) corresponding to the application program interface 2 that needs to be called at present is matched in the result data B stored in the second cache unit.

It should be noted that "first" and "second" in the "first result data" and "second result data" in this embodiment are only used for distinguishing different result data returned by the application program interface, and have no special meaning, and should not cause any special limitation to this exemplary embodiment.

After the first cache unit synchronizes the first result data corresponding to the target application program to the second cache unit, the target application program can directly obtain the second result data required by the call request in the local second cache unit without obtaining the second result data from the system service process through a cross-process communication mechanism, so that the communication path is effectively shortened, the obtaining efficiency of the second result data is improved, and the load pressure of the system service process is reduced.

Meanwhile, in the subsequent use process of the application program, if the second cache unit has the required result data, the result data can be directly obtained in the second cache unit; if the second cache unit does not have the required result data, the result data can be acquired from the system service process through a cross-process communication mechanism, at the moment, the first cache unit can cache the result data record and synchronize the result data record into the second cache unit, and the process is repeated, so that more and more result data are cached into the second cache unit along with the use of the application program, the starting speed and the response speed of the application program are further improved, and the fluency of the application program is effectively improved.

Next, the interface calling method in steps S310 to S340 will be described in detail.

In an exemplary embodiment, in response to a first call request of each application program to an application program interface, interface call data corresponding to the application program interface may be recorded, and then the interface call data may be stored in a first cache unit on a system service side.

For example, the first call request may be a first cold start call request generated when the application program is started after the application program is installed in the terminal device, or may be a first interaction request generated after a certain function is triggered after the application program is installed in the terminal device, which is not particularly limited in this example embodiment.

The interface call data refers to data related to an application program interface called by the first call request, for example, the interface call data may include, but is not limited to, identification data of an application program interface, result data returned when the application program interface is called, and the like, and this example embodiment is not limited thereto.

When a first call request of each application program to the application program interface is detected, interface call data corresponding to the application program interface can be recorded, and then the interface call data is stored in a first cache unit at a system service side, so that the subsequent use is facilitated, the access of the application program to a system service process is reduced, and the load pressure of the system service process is reduced. And with the continuous use of the application program, the richer the first result data related to the target application program is cached in the first cache unit, the less the subsequent application program has access to the system service process, that is, the smoother the use of the application program is.

In addition, when a first call request of each application program to the application program interface is detected, not only is result data returned when the application program interface is called recorded, but also identification data corresponding to the application program interface, identification data of the application program and the like are recorded, matching query for subsequent call use is facilitated, and the acquisition efficiency of the result data is further improved.

Fig. 4 schematically illustrates a framework diagram for caching result data by a first caching unit on the system service side in an exemplary embodiment of the disclosure.

Referring to fig. 4, the terminal device 410 may include a system service side 420 and an application program side 430, where the system service side 420 may be provided with a first cache unit 440, and the first cache unit is configured to cache result data returned when each application program calls an application program interface for the first time. Taking an App cold start request of an application program in the terminal device 410 as an example, when the App is cold started for the first time, the App calls a system service process in the system service side 420, and acquires relevant information of the system service through a cross-process communication mechanism.

In an optional embodiment, the system service side 420 may be configured with a request collection unit 450 for capturing result data returned by calling a target API, and when the target API is detected, the request collection unit 450 may collect the result data returned by the target API, and simultaneously collect identification information corresponding to the target API and identification information of a target application program corresponding to the target API, and summarize these three data as interface call data of the target API, and cache the interface call data of the target API in the first cache unit 440.

Optionally, interface call data recorded when each application program calls the application program interface in the test environment may be obtained, where the interface call data may include, but is not limited to, identification data of the application program interface, result data returned when the application program interface is called, and the like, specifically, the interface call data may include first result data corresponding to the target application program, and the interface call data is stored in the cloud server; and when the application program is installed or a first calling request of the target application program in the terminal equipment is received, the cloud server sends first result data corresponding to the target application program and directly caches the first result data in a second cache unit on the target application program side, namely the first calling request of the target application program does not need to access the system service process, the load pressure of the system service process is further reduced, the response speed of the target application program when the target application program is installed and used for the first time is improved, and the response speed of the application program is improved in the whole process.

In an exemplary embodiment, the identification data of the target application program may be determined according to the call request, and then the first result data corresponding to the target application program may be queried through the identification data of the target application program and the identification data in the interface call data stored in the first cache unit on the system service side. When the first result data corresponding to the target application program are stored, the identification data of the application program are stored at the same time, so that the query efficiency of the first result data can be effectively improved, and the acquisition speed of the first result data is improved.

In an exemplary embodiment, the identification data of the target application program interface may be determined according to the call request, and further, the identification data of the target application program interface and the identification data in the interface call data stored from the second cache unit may match the second result data corresponding to the target application program interface. When the first result data corresponding to the target application program is stored, the identification data of the application program interface is stored at the same time, so that the matching efficiency of the second result data corresponding to the target application program interface can be effectively improved, the acquisition speed of the second result data is improved, and the starting speed and the running smoothness of the application program are further ensured.

Fig. 5 is a schematic diagram illustrating a framework for implementing a local calling application program interface through a second cache unit in an exemplary embodiment of the disclosure.

Referring to fig. 5, the terminal device 410 may be provided with a second buffer unit 550 on the application program side 430, where the second buffer unit 550 is configured to buffer the first result data related to the current cold-started target application program synchronized from the first buffer unit 440.

Continuing to take the application program App cold start request in the terminal device 410 as an example, when the App process 560 is started, the application program will perform a cache query to the first cache unit 440 in the system service side 420, determine first result data corresponding to a target application program running in the application program side 430, and synchronize the first result data corresponding to the target application program into the second cache unit 550 of the system service side 420 of the target application program.

The second cache unit 550 may receive the synchronous cache request from the first cache unit 440, complete initialization, and save the first result data corresponding to the target application program locally. The subsequent target application program starts to call the target API, and the second result data of the target application program interface is hit in the second cache unit 550, so that the second result data is directly obtained from the second cache unit 550, and the second result data does not need to be obtained in the system service process, thereby effectively improving the obtaining efficiency of the second result data and increasing the cold start speed of the application program.

In an exemplary embodiment, the screening of the result data may be implemented by the steps in fig. 6, and as shown in fig. 6, the screening may specifically include:

step S610, acquiring the access amount of the current application program interface;

step S620, in response to that the access amount is greater than or equal to the access amount threshold, storing the interface call data corresponding to the current application program interface in the first cache unit or the cloud server.

The access amount refers to the number of calls of the current application program interface within a certain time period, for example, within 10S, the current application program interface is called by the application program 100 times, and then the access amount of the current application program interface may be considered to be 100, and of course, only one possible implementation for determining the access amount of the application program interface is provided here, and a person skilled in the art may also determine the access amount of the current application program interface in other ways, which is not particularly limited in this example embodiment.

The access amount threshold is a preset numerical value used for determining the access heat of the current application program interface, for example, the access amount threshold may be 50 or 80, and may be specifically set by a user according to an actual situation, which is not limited in this example implementation.

When it is determined that the access amount of the current application program interface is greater than or equal to the access amount threshold, it may be considered that the current application program interface may be frequently called in the future, at this time, if the access amount is counted on the system service side, the interface call data corresponding to the current application program interface may be stored in the first cache unit in the system service side, of course, the access amount may also be generated when the application program is tested in the test environment, and at this time, the interface call data corresponding to the current application program interface may be stored in the cloud server.

When the access amount of the current application program interface is determined to be smaller than the access amount threshold, the current application program interface can be considered to be only occasionally called in the future use, so that interface calling data corresponding to the current application program interface does not need to be stored in the first cache unit or the cloud server, a system service process can be directly accessed when the current application program interface is called, the storage pressure of the interface calling data with smaller access amount on the first cache unit or the cloud server is avoided, and the first cache unit or the cloud server vacates a memory space to store the interface calling data with higher access amount.

The data are called through the selective storage interface, the storage pressure of the first cache unit or the cloud server is reduced, the current application program interface with high access amount is effectively served, and the acquisition efficiency of the result data is further ensured.

Optionally, the interface type of the current application program interface may be determined, where the interface type may include a first interface type and a second interface type, where the result data returned by the application program interface of the first interface type does not change with time, for example, the application program interface of the first interface type may be an application program interface related to the packet management service PMS, and the result data returned by the application program interface is a parameter such as a packet name and does not change with time; the result data returned by the application program interface of the second interface type can change along with the change of time, for example, the application program interface of the first interface type can be an application program interface related to system time service, and the result data returned by the application program interface is the current time of the system and can change along with the change of time.

For the application program interface of the first interface type, the returned result data does not change along with the change of time, so that when the current application program interface is detected to be the first interface type, the interface calling data corresponding to the current application program interface is stored in the first cache unit or the cloud server and is used as the result data which can be directly called when the application program is used subsequently.

For the application program interface of the second interface type, the returned result data can change along with the change of time, so that when the current application program interface is detected to be the second interface type, the interface calling data corresponding to the current application program interface does not need to be stored in the first cache unit or the cloud server, and the result data can be directly obtained from the system service process through cross-process communication.

It should be noted that, in this embodiment, the "first interface type" and the "second interface type" are only used for distinguishing different types of application program interfaces, and do not have any special meaning, and should not cause any special limitation to this exemplary embodiment.

According to the method, the interface calling data of the application program interface are selectively stored according to the interface type, invalid result data stored by the first cache unit or the cloud server can be effectively reduced, the storage pressure of the first cache unit or the cloud server is reduced, the current application program interface with high effective service access amount is used, and the acquisition efficiency of the result data is further ensured.

In an exemplary embodiment, the result data in the first cache unit may be stored in the database according to a preset storage period. The storage period may be a preset period for persistently storing the data in the first cache unit, for example, the storage period may be 1 day or 10 days, and the specific storage period may be determined according to the storage capacity and the size of the storage space of the first cache unit, which is not particularly limited in this example embodiment.

By storing the data in the first cache unit into the database in a persistent manner, the possibility of data coverage generated in the first cache unit when the result data needing caching is more can be effectively avoided, and the stability of the result data is ensured.

Optionally, the step in fig. 7 may be implemented to store the result data in the first cache unit into the database in a persistent manner, and as shown in fig. 7, the persistent storage may specifically include:

step S710, obtaining a calling frequency of the result data in the first cache unit;

step S720, determining target result data of which the calling frequency is greater than or equal to a frequency threshold;

step S730, storing the target result data in the first cache unit into the database according to the storage period.

The call frequency refers to the number of calls of the result data in unit time, for example, the call frequency of the result data may be 10 times/day, and the greater the call frequency, the result data is the common result data, and the stability of the result data needs to be ensured. The frequency threshold may be 5 times/day or 10 times/day, and may be specifically set by self-definition according to the actual application situation, which is not particularly limited in this example embodiment.

If the calling frequency of the result data is greater than or equal to the frequency threshold, the result data can be considered to be frequently-used result data and can be called for many times in the future, at the moment, the result data can be used as target result data, and the target result data is stored in the database in a persistent mode according to a preset storage period, so that the stability of the target result data is guaranteed.

If the calling frequency of the result data is less than the frequency threshold, the result data can be regarded as the result data which is not frequently used, and the result data can be stored in a database without persistence, so that the storage pressure of a data path of the terminal equipment is reduced.

In an exemplary embodiment, when the version change notification of the target application is detected, the first result data corresponding to the target application in the first cache unit on the system service side may be updated, and a cache update request may be sent to the second cache unit, so that the first cache unit synchronizes the updated first result data to the second cache unit.

When the version of the target application program is upgraded or reduced, the application program interface required to be called by the target application program or the result data returned by the application program interface may change, and at this time, the result data stored in the first cache unit and the second cache unit needs to be updated. Therefore, when the version of the application program changes, a version change notification of the target application program may be received, the result data in the first cache unit on the system service side may be updated based on the version change notification, and a cache update request may be sent to the second cache unit, so that the first cache unit synchronizes the updated first result data to the second cache unit.

When the version change of the application program is detected, the first result data corresponding to the target application program in the first cache unit and the second cache unit are updated in time, so that the latest first result data can be returned when the target application program acquires the first result data in the first cache unit or the second cache unit, the stable operation of the target application program is ensured, and the starting speed and the operation fluency of the target application program are further improved.

Fig. 8 schematically illustrates a framework diagram for updating cached result data in an exemplary embodiment of the present disclosure.

Referring to fig. 8, when the version of the target application running in the terminal device 410 changes, a version change notification may be sent to the system service side 420, and when receiving the version change notification of the target application, the first caching unit 440 in the system service side 420 determines a cache change condition and updates the first result data corresponding to the target application stored in the first caching unit 440, for example, updates the result data such as package, permission and the like related to the target application stored in the first caching unit 440.

Meanwhile, the first cache unit 440 sends a cache update request to the second cache unit 550 of the application side 430, and after receiving the cache update request, the second cache unit 550 initializes the memory space corresponding to the second cache unit 550, starts to acquire the updated first result data sent by the first cache unit 440, and completes the update of the first result data corresponding to the target application.

In an exemplary embodiment, the first result data corresponding to the target application in the first cache unit may be deleted when the uninstall notification of the target application is detected.

When the target application program is uninstalled, the first result data related to the target application program is not called thereafter, and the second cache unit on the target application program side is directly deleted when the target application program is uninstalled, so that the first result data corresponding to the target application program in the first cache unit also needs to be deleted, redundant data in the first cache unit is reduced, and the storage pressure of the first cache unit is reduced.

In summary, in the exemplary embodiment, when a call request of a target application is detected, first result data corresponding to the target application may be determined from a first cache unit on a system service side, then the first result data is synchronized to a second cache unit on the target application side, a target application interface is determined according to the call request, and finally the target application directly matches second result data corresponding to the target application interface from the second cache unit. On one hand, result data obtained by calling an application program interface historically by an application program are cached in a first cache unit on a system service side, when the next calling is needed, the result data are directly obtained from the first cache unit, the application program interface does not need to wait for feedback of the result data, the response speed of interface calling is improved, the load pressure of a system service process is reduced, the fluency of a system is improved, and the power consumption of terminal equipment is reduced; on the other hand, when the application program requests to call the relevant interface, the result data corresponding to the application program is synchronized to the local second cache unit of the application program from the first cache unit, and the call of the target application program interface is directly completed locally, so that the data communication path can be reduced, the acquisition efficiency of the result data is improved, and the starting speed and the running speed of the application program are effectively improved.

It is noted that the above-mentioned figures are merely schematic illustrations of processes involved in methods according to exemplary embodiments of the present disclosure, and are not intended to be limiting. It will be readily understood that the processes shown in the above figures are not intended to indicate or limit the chronological order of the processes. In addition, it is also readily understood that these processes may be performed synchronously or asynchronously, e.g., in multiple modules.

Further, as shown in fig. 9, an interface invoking apparatus 900 is further provided in this example embodiment, and may include a first result data determining module 910, a first result data synchronizing module 920, an interface determining module 930, and a local invoking module 940. Wherein:

the first result data determining module 910 is configured to determine, in response to a call request of a target application, first result data corresponding to the target application from a first cache unit on a system service side;

the first result data synchronization module 920 is configured to synchronize the first result data to a second cache unit on the side of the target application;

the interface determining module 930 is configured to determine a target application program interface according to the call request;

the local calling module 940 is configured to match second result data corresponding to the target application program interface from the first result data stored in the second cache unit, so that the target application program directly calls the second result data from the second cache unit.

In an exemplary embodiment, the interface calling apparatus 900 may further include an interface calling data recording unit, and the interface calling data recording unit may be configured to:

responding to a first calling request of each application program to an application program interface, and recording interface calling data corresponding to the application program interface;

storing the interface calling data into the first cache unit;

the interface calling data comprises identification data of each application program, identification data of the application program interface and result data returned when the application program interface is called.

In an exemplary embodiment, the interface calling apparatus 900 may further include a data preprocessing unit, and the data preprocessing unit may be configured to:

acquiring interface calling data recorded when each application program calls an application program interface in a test environment, and storing the interface calling data to a cloud server, wherein the interface calling data comprises first result data corresponding to the target application program;

responding to a first calling request of the target application program, acquiring the first result data from the cloud server, and caching the first result data into the second caching unit.

In an exemplary embodiment, the first result data determination module 910 may be configured to:

determining the identification data of the target application program according to the calling request;

and inquiring first result data corresponding to the target application program from a first cache unit of a system service side through the identification data of the target application program.

In an exemplary embodiment, the local invocation module 940 may be used to:

determining the identification data of the target application program interface according to the calling request;

and matching second result data corresponding to the target application program interface from the first result data stored in the second cache unit through the identification data of the target application program interface.

In an exemplary embodiment, the interface calling apparatus 900 may further include a data caching unit, and the data caching unit may be configured to:

acquiring the access amount of a current application program interface;

and responding to the fact that the access amount is larger than or equal to the access amount threshold value, and storing interface calling data corresponding to the current application program interface to a first cache unit or a cloud server.

In an exemplary embodiment, the data caching unit may further be configured to:

determining the interface type of a current application program interface, wherein the interface type comprises a first interface type and a second interface type, the result data returned by the application program interface of the first interface type can not change along with the change of time, and the result data returned by the application program interface of the second interface type can change along with the change of time;

and responding to the detection that the current application program interface is of the first interface type, and storing interface calling data corresponding to the current application program interface into a first cache unit or a cloud server.

In an exemplary embodiment, the interface invoking device 900 may further include a data persistence unit, which may be configured to:

and storing the result data in the first cache unit into a database according to a preset storage period.

In an exemplary embodiment, the data persistence unit may be further configured to:

acquiring the calling frequency of the result data in the first cache unit;

determining target result data for which the calling frequency is greater than or equal to a frequency threshold;

and storing the target result data in the first cache unit into the database according to the storage period.

In an exemplary embodiment, the first result data synchronization module 920 may be configured to:

in response to detecting the version change notification of the target application program, updating first result data corresponding to the target application program in the first cache unit; and

and sending a cache updating request to the second cache unit so that the first cache unit synchronizes the updated first result data to the second cache unit.

In an exemplary embodiment, the first result data synchronization module 920 may be further configured to:

and in response to detecting the uninstalling notification of the target application program, deleting the first result data corresponding to the target application program in the first cache unit.

The specific details of each module in the above apparatus have been described in detail in the method section, and details that are not disclosed may refer to the method section, and thus are not described again.

As will be appreciated by one skilled in the art, aspects of the present disclosure may be embodied as a system, method or program product. Accordingly, various aspects of the present disclosure may be embodied in the form of: an entirely hardware embodiment, an entirely software embodiment (including firmware, microcode, etc.) or an embodiment combining hardware and software aspects that may all generally be referred to herein as a "circuit," module "or" system.

The exemplary embodiment of the present disclosure provides an electronic device for implementing an interface calling method, which may be the

terminal device

101, 102, 103 or the server 105 in fig. 1. The electronic device includes at least a processor and a memory for storing executable instructions of the processor, the processor configured to execute the interface call method via execution of the executable instructions.

The following takes the electronic apparatus 1000 in fig. 10 as an example, and exemplifies the configuration of the electronic apparatus in the present disclosure. The electronic device 1000 shown in fig. 10 is only an example and should not bring any limitation to the functions and the scope of use of the embodiments of the present disclosure.

As shown in fig. 10, the electronic device 1000 is embodied in the form of a general purpose computing device. The components of the electronic device 1000 may include, but are not limited to: at least one processing unit 1010, at least one memory unit 1020, a bus 1030 that couples various system components including the memory unit 1020 and the processing unit 1010, and a display unit 1040.

The storage unit 1020 stores a program code, which can be executed by the processing unit 1010, so that the processing unit 1010 executes the interface calling method in this specification.

The memory unit 1020 may include readable media in the form of volatile memory units, such as a random access memory unit (RAM)1021 and/or a cache memory unit 1022, and may further include a read only memory unit (ROM) 1023.

Storage unit 1020 may also include a program/utility 1024 having a set (at least one) of program modules 1025, such program modules 1025 including, but not limited to: an operating system, one or more application programs, other program modules, and program data, each of which, or some combination thereof, may comprise an implementation of a network environment.

Bus 1030 may be any one or more of several types of bus structures including a memory unit bus or memory unit controller, a peripheral bus, an accelerated graphics port, a processing unit, and a local bus using any of a variety of bus architectures.

The electronic device 1000 may also communicate with one or more external devices 1070 (e.g., sensor devices, bluetooth devices, etc.), with one or more devices that enable a user to interact with the electronic device 1000, and/or with any devices (e.g., routers, modems, etc.) that enable the electronic device 1000 to communicate with one or more other computing devices. Such communication may occur through input/output (I/O) interfaces 1050. Also, the electronic device 1000 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 the network adapter 1060. As shown, the network adapter 1060 communicates with the other modules of the electronic device 1000 over the bus 1030. It should be appreciated that although not shown, other hardware and/or software modules may be used in conjunction with the electronic device 1000, including but not limited to: microcode, device drivers, redundant processing units, external disk drive arrays, RAID systems, tape drives, data backup storage systems, and sensor modules (e.g., gyroscope sensors, magnetic sensors, acceleration sensors, distance sensors, proximity light sensors, etc.).

Through the above description of the embodiments, those skilled in the art will readily understand that the exemplary embodiments described herein may be implemented by software, or by software in combination with necessary hardware. Therefore, the technical solution according to the embodiments of the present disclosure may be embodied in the form of a software product, which may be stored in a non-volatile storage medium (which may be a CD-ROM, a usb disk, a removable hard disk, etc.) or on a network, and includes several instructions to enable a computing device (which may be a personal computer, a server, a terminal device, or a network device, etc.) to execute the method according to the embodiments of the present disclosure.

Exemplary embodiments of the present disclosure also provide a computer-readable storage medium having stored thereon a program product capable of implementing the above-described method of the present specification. In some possible embodiments, various aspects of the disclosure may also be implemented in the form of a program product comprising program code for causing a terminal device to perform the steps according to various exemplary embodiments of the disclosure described in the above-mentioned "exemplary methods" section of this specification, when the program product is run on the terminal device.

It should be noted that the computer readable media shown in the present disclosure may be computer readable signal media or computer readable storage media or any combination of the two. A computer readable storage medium may be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination of the foregoing. More specific examples of the computer readable storage medium may include, but are not limited to: an electrical connection having one or more wires, a portable computer diskette, a hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing.

In the present disclosure, a computer readable storage medium may be any tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device. In contrast, in the present disclosure, a computer readable signal medium may comprise a propagated data signal with computer readable program code embodied therein, either 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 be any computer readable medium that is not a computer readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device. Program code embodied on a computer readable medium may be transmitted using any appropriate medium, including but not limited to: wireless, wire, fiber optic cable, RF, etc., or any suitable combination of the foregoing.

Furthermore, program code for carrying out operations of the present disclosure may be written in any combination of one or more programming languages, including an object oriented programming language such as Java, 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 computing device, partly on the user's device, as a stand-alone software package, partly on the user's computing device and partly on a remote computing device, or entirely on the remote computing device or server. In the case of a remote computing device, the remote computing device may be connected to the user computing device through any kind of network, including a Local Area Network (LAN) or a Wide Area Network (WAN), or may be connected to an external computing device (e.g., through the internet using an internet service provider).

Other embodiments of the disclosure will be apparent to those skilled in the art from consideration of the specification and practice of the invention disclosed herein. This application is intended to cover any variations, uses, or adaptations of the disclosure following, in general, the principles of the disclosure and including such departures from the present disclosure as come within known or customary practice in the art to which the disclosure pertains. It is intended that the specification and examples be considered as exemplary only, with a true scope and spirit of the disclosure being indicated by the following claims.

It will be understood that the present disclosure is not limited to the precise arrangements described above and shown in the drawings and that various modifications and changes may be made without departing from the scope thereof. The scope of the present disclosure is to be limited only by the terms of the appended claims.

Claims

1. An interface calling method, comprising:

2. The method of claim 1, further comprising:

storing the interface calling data into the first cache unit;

3. The method of claim 1, further comprising:

4. The method according to any one of claims 1 to 3, wherein the determining, from a first cache unit on a system service side, first result data corresponding to the target application program comprises:

5. The method according to any one of claims 1 to 3, wherein the matching of the first result data stored in the second cache unit with the second result data corresponding to the target API comprises:

6. A method according to claim 2 or 3, characterized in that the method further comprises:

acquiring the access amount of a current application program interface;

7. The method of claim 6, further comprising:

8. The method of claim 1, further comprising:

9. The method according to claim 8, wherein the storing the result data in the first cache unit into a database according to a preset storage period comprises:

acquiring the calling frequency of the result data in the first cache unit;

determining target result data for which the call frequency is greater than or equal to a frequency threshold;

10. The method of claim 1, wherein the synchronizing the first result data to the second cache unit of the target application comprises:

11. The method of claim 1, further comprising:

12. An interface invoking device, comprising:

13. A computer-readable medium, on which a computer program is stored which, when being executed by a processor, carries out the method according to any one of claims 1 to 11.

14. An electronic device, comprising:

a processor; and

a memory for storing executable instructions of the processor;

wherein the processor is configured to perform the method of any of claims 1 to 11 via execution of the executable instructions.