WO2023160289A1

WO2023160289A1 - Mini-program storage call

Info

Publication number: WO2023160289A1
Application number: PCT/CN2023/071496
Authority: WO
Inventors: 曾家龙
Original assignee: 支付宝(杭州)信息技术有限公司
Priority date: 2022-02-25
Filing date: 2023-01-10
Publication date: 2023-08-31
Also published as: CN114510296B; CN114510296A

Abstract

Embodiments of the present description disclose a mini-program storage call method and apparatus, and a device. The solution comprises: before a mini-program is about to initiate a storage API call request to a client, accessing the cache of the mini-program; verifying whether storage data with respect to the storage API call request is stored in the cache of the mini-program; if yes, filtering out the storage API call request for the client, and performing, according to the storage data in the cache of the mini-program, a storage-related operation corresponding to the storage API call request; and otherwise initiating the storage API call request to the client.

Description

Small program storage call

technical field

This specification relates to the field of Internet technology, especially the storage and calling of applets.

Background technique

With the development of technology, there are more and more functions of application integration. At present, the client of an application can mount the corresponding applets of other different applications, so that users can realize the control of other applications in the client of this application only through the applets of other applications without installing the client. operations to provide convenience to users. During the operation of the applet, it needs to borrow the storage space of the client to store data and interact frequently with the client. Based on this, a more efficient applet storage and calling scheme is needed.

Contents of the invention

One or more embodiments of this specification provide a method, device, device, and storage medium for storing and calling applets to solve the following technical problem: a more efficient solution for storing and calling applets is needed.

A method for storing and invoking an applet provided by one or more embodiments of this specification, the applet runs on a client, and the method includes: before the applet initiates a storage API call request to the client , access the cache of the applet itself; check whether the storage data targeted by the storage API call request is stored in the cache of the applet itself; if so, filter out the storage API call for the client Request, and according to the storage data in the cache of the applet itself, implement the storage-related operation corresponding to the storage API call request; otherwise, initiate the storage API call request to the client.

A device for storing and invoking a small program provided by one or more embodiments of this specification, the small program runs on a client, and the device includes: an access module, when the small program wants to initiate a storage API to the client Before calling the request, access the cache of the applet itself; the verification module checks whether the storage data targeted by the storage API call request is saved in the cache of the applet itself; the implementation module, in the verification If the result of the module is yes, filter out the storage API call request for the client, and realize the storage correlation corresponding to the storage API call request according to the storage data in the cache of the applet itself. Operation: the initiating module, when the result of the verification module is negative, initiates the storage API call request to the client.

A device for storing and invoking an applet provided by one or more embodiments of the present specification, the applet runs on a client, and the device includes at least one processor and a memory communicatively connected to the at least one processor. The memory stores instructions executable by the at least one processor, the instructions are executed by the at least one processor, so that the at least one processor can: Before initiating a storage API call request, access the cache of the applet itself; check whether the storage data targeted by the storage API call request is stored in the cache of the applet itself; if so, filter for the client Call the storage API request, and implement the storage-related operations corresponding to the storage API call request according to the storage data in the cache of the applet itself; otherwise, initiate the storage API call to the client ask.

A non-volatile computer storage medium provided by one or more embodiments of this specification stores computer-executable instructions, and the computer-executable instructions are set to: when the applet is to initiate a storage API to the client Before calling the request, access the cache of the applet itself; check whether the storage data targeted by the storage API call request is saved in the cache of the applet itself; if so, filter out the cache for the client storing the API call request, and implementing a storage-related operation corresponding to the storage API call request according to the stored data in the cache of the applet itself; otherwise, initiating the storage API call request to the client.

The above-mentioned at least one technical solution adopted by one or more embodiments of this specification can achieve the following beneficial effects: when the applet needs to call the stored data, it first checks the cache of the applet itself to determine whether the required data exists. If it exists, it can be called directly without requesting the client to call it. If it does not exist, initiate a storage API call request to the client. This can improve the efficiency of small program storage data calls, especially for repeated writing and reading of stored data, and reduce unnecessary interaction between the small program and the client, thereby reducing additional communication overhead and small program running performance Overhead, improve the smoothness of the running of the applet, and improve the running of the applet.

Description of drawings

In order to more clearly illustrate the technical solutions in the embodiments of this specification or the prior art, the following will briefly introduce the drawings that need to be used in the description of the embodiments or the prior art. Obviously, the drawings in the following description are only These are some embodiments described in this specification. Those skilled in the art can also obtain other drawings based on these drawings without any creative effort.

Fig. 1 is a schematic flowchart of a method for storing and invoking a small program provided by one or more embodiments of this specification;

Figure 2a is a schematic diagram of storage writing in an application scenario;

Fig. 2b is a schematic diagram of storage asynchronous writing in an application scenario provided by one or more embodiments of this specification;

FIG. 3 is a schematic diagram of wrong key recording in an application scenario provided by one or more embodiments of this specification;

Fig. 4 is a detailed flowchart of the method in Fig. 1 in an application scenario provided by one or more embodiments of this specification;

Fig. 5 is a schematic structural diagram of a small program storage and calling device provided by one or more embodiments of this specification;

Fig. 6 is a schematic structural diagram of a device for storing and invoking applets provided by one or more embodiments of this specification.

Detailed ways

Embodiments of this specification provide a method, device, device, and storage medium for storing and invoking applets.

In order to enable those skilled in the art to better understand the technical solutions in this specification, the technical solutions in the embodiments of this specification will be clearly and completely described below in conjunction with the drawings in the embodiments of this specification. Obviously, the described The embodiments are only some of the embodiments of the present application, but not all of them. Based on the embodiments of this specification, all other embodiments obtained by persons of ordinary skill in the art without creative efforts shall fall within the scope of protection of this application.

In one or more embodiments of this specification, when the applet needs to call the application programming interface (Application Programming Interface, API), the cache of the applet itself is first checked to determine that there is a corresponding cache in the cache of the applet itself. When storing data, it can be called directly from the applet's own cache without sending a storage API call request to the client. When it is determined that there is no corresponding stored data in the mini-program's own cache, it initiates a storage API call request to the client. In this way, the communication interaction between the applet and the client can be reduced, the communication overhead can be reduced, the efficiency of calling the stored data of the applet can be improved, and the response rate of the applet can be improved. Based on this idea, the following will be described in detail.

Fig. 1 is a schematic flowchart of a method for storing and invoking an applet provided by one or more embodiments of this specification. The method can be applied to different business fields, such as e-commerce business fields, instant messaging business fields, official business fields, payment business fields, and the like. This process can be executed by computing devices in the corresponding field (such as mobile terminals held by users in payment services, etc.), and some input parameters or intermediate results in the process allow manual intervention and adjustment to help improve accuracy.

The flow in Fig. 1 may include the following steps.

S102: Before the applet initiates a storage API call request to the client, access the cache of the applet itself.

The relationship between the applet and the client is a dependent and dependent relationship. The applet runs on the client, stores data through the client’s storage space, and communicates with the client based on the storage API provided by the client. Interact and call the stored data.

In one or more embodiments of this specification, the cache of the applet itself is a temporary storage dependent on the applet itself, and generally exists in a terminal held by a user, such as a mobile phone, a tablet computer, a computer, and the like. The storage space of the client usually also includes the storage space hosted in the server. The cache of the applet itself exists with the life cycle of the applet, and has nothing to do with the storage space of the client. Wherein, the life cycle of the applet indicates the duration of the applet in the client from being activated to being stopped during one use.

When the applet calls the stored data from its own cache, it can directly call without calling the storage API, which can improve the efficiency of stored data calls, improve the response rate of the applet, and reduce the communication between the applet and the client. unnecessary interaction and reduce the workload of interaction. Therefore, the storage of the applet in its own cache may also be referred to as near-end storage.

S104: Check whether the storage data targeted by the storage API call request is stored in the cache of the applet itself.

When the applet needs to call the stored data, it can first check the cache of the applet itself to determine whether the required stored data is stored in it, so as to determine whether it is necessary to call the client's storage API. Wherein, the verification method can be determined by the form of the stored data, such as matching according to the key-value pairs of the stored data.

S106: If yes, filter out the storage API call request for the client, and implement a storage-related operation corresponding to the storage API call request according to the storage data in the cache of the applet itself.

If the applet's own cache has the required storage data, the applet can directly obtain the required storage data from its own cache without sending a storage API call request to the client. Afterwards, the applet can perform storage-related operations according to the stored data in its own cache, including storage write operations, storage read operations, storage update operations, storage delete operations, and the like.

S108: Otherwise, initiate the storage API call request to the client.

If the required storage data does not exist in the mini-program's own cache, the mini-program needs to initiate a storage API call request to the client to obtain the required storage data from the client's storage space.

In one or more embodiments of this specification, when the applet needs to call the stored data, it first checks the cache of the applet itself to determine whether the required data exists. If it exists, it can be called directly without requesting the client to call it. If it does not exist, initiate a storage API call request to the client. This can improve the efficiency of small program storage data calls, especially for repeated writing and reading of stored data, and reduce unnecessary interaction between the small program and the client, thereby reducing additional communication overhead and small program running performance Overhead, improve the smoothness of the running of the applet, and improve the running of the applet.

Based on the method in FIG. 1 , this specification also provides some specific implementations and extensions of the method, which will be further described below.

In one or more embodiments of the present specification, when the applet executes the storage write operation, it respectively executes the storage write operation on the cache of the applet itself and the client. On the one hand, the store write operation is performed on the cache of the applet itself, so as to write the data to be written corresponding to the applet into the cache of the applet itself. On the other hand, a storage API call request is initiated to the client, so that the client also executes a storage write operation to persist the data to be written corresponding to the applet in the storage space corresponding to the client.

The cache of the applet itself is relatively independent from the storage space of the client. The storage space corresponding to the client does not belong to the applet and does not include the cache of the applet itself. The stored data in the mini program's own cache is temporary storage, which disappears with the termination of the mini program's life cycle, and the stored data in the client's storage space is persistent storage, which does not change with the change of the mini program's life cycle.

By writing the stored data into the cache of the applet itself, the applet can directly call the stored data from its own cache, which is convenient and fast, and improves the efficiency of calling, and the stored data is also written into the storage space of the client, and the stored data can be processed. Persistent storage, so that when the next life cycle of the applet is started, the relevant storage memory can be retained to provide convenience for users.

Further, when the applet performs a storage write operation to the client, it generates risk filling data according to the data to be written corresponding to the applet. According to the risk filling data, initiate a storage API call request to the client, so that the client first persists the risk filling data in the corresponding storage space of the client, and at the end of the life cycle of the applet, also executes the storage write Operation, replace the persistent risk filling data in the storage space corresponding to the client with the data to be written corresponding to the applet.

The risk-filled data refers to the data that is related to the data to be written but hides the real information in the data to be written. Specifically, according to the set corresponding relationship, the data to be written can be split, converted, sequenced, etc. to obtain the risk filling data. The risk filling data can be represented as data completely irrelevant to the data to be written, or as data containing non-private parts of the data to be written.

During the life cycle of the applet, the client's storage space stores risk-filled data, that is, the client cannot know the real information in the data to be written, which can ensure the security of the data to be written, even if the client exists. The risk of data leakage, but the real information of the data to be written will not be leaked. At the end of the life cycle of the applet, the stored risk filling data is replaced with the data to be written, which ensures that the client can store the data to be written generated by the applet. Moreover, this storage method can ensure that the data stored in the client's storage space is the latest stored data in the life cycle of the applet, avoiding the fact that the stored data in the client's storage space is not updated, and there is a contradiction with the stored data required by the applet The problem.

Furthermore, when the applet performs a storage write operation to its own cache and the client respectively, it sends a storage API call request to the client asynchronously compared to performing a storage write operation to the cache of the applet itself. Also, after the store write operation is performed on the applet's own cache, the data written by the store write operation can be read from the applet's own cache immediately. It should be noted that in the past, if the applet directly made this kind of write to the client (in the past, the synchronous write call was executed), the data just written should be read immediately, because the applet calls the storage API of the client to execute the storage write The input operation takes a long time, so it may block the subsequent read operation, but this problem is solved in this solution. By executing the storage write operation asynchronously, the stored data can be read immediately after the stored data is written into the Mini Program's own cache, ensuring the smoothness of storage writing and reading, and improving the response efficiency of the Mini Program.

As shown in Figure 2a, when the applet performs storage write operations, if it first writes data to the client’s storage space through the storage API, it will hinder subsequent storage read operations, making the applet need to wait for the client to complete the storage. The written storage data can only be read after the write operation, which blocks the normal business process and prolongs the waiting time for the user's operation.

As shown in FIG. 2 b , when the applet performs a storage write operation, it first writes the data to be written into the cache of the applet itself (ie, the near-end cache). Since the writing time of the near-end cache is short and fast, the written storage data can be read immediately afterwards. Afterwards, asynchronously writing the data to be written into the storage space of the client will not affect the storage read operation.

In one or more embodiments of this specification, when the applet performs a storage read operation, after verifying the applet's own cache, it can directly read the stored data from the applet's own cache and return it to the applet. This can avoid repeated calls to the client storage API when reading data, save the performance overhead of the applet, and improve the data call efficiency of the applet.

Furthermore, before verifying whether the storage data targeted by the storage API call request is stored in the cache of the applet itself, an applet cache management object can also be generated for the cache of the applet itself according to the base class of the storage cache manager, so that Use the applet to cache the instance of the management object, access the cache of the applet itself, and perform verification.

Furthermore, according to the base class of the storage cache manager, a plug-in cache management object can also be generated for the cache of the plug-in of the application, wherein the client belongs to the application or another application. According to the storage API call request and/or the specified application identifier, select the target object from the applet cache management object and the plug-in cache management object, so as to determine that the storage API call request is initiated through the applet or the plug-in. Similar to the applet cache management object, the plug-in cache management object can manage the cache allocated for the plug-in itself, and then temporarily store and access the data of the plug-in in the cache, thereby reducing the plug-in's impact on its client or other applications. disturb.

In one or more embodiments of this specification, if the storage-related operation corresponding to the storage API call request initiated by the applet is not a storage erase operation, the client can filter out the operation after verification in the cache of the applet itself. Store API call requests. If the storage-related operation is a storage erase operation, clear the stored data in the cache of the applet itself, and initiate a storage API call request to the client, so that the stored data related to the applet persisted by the client outside the cache is also deleted. clear.

Furthermore, the cache of the applet itself runs in the life cycle of the applet, and when the life cycle of the applet ends, the cache of the applet itself is destroyed, so that the stored data in the cache of the applet itself is lost. However, the stored data in the client's storage space is not affected by the end of the applet's life cycle, so that the stored data can continue to be called when the next life cycle of the applet starts. Since the near-end cache of the applet only exists in the life cycle of the applet, if the near-end cache data is destroyed at the end of the life cycle of the applet, there will be no persistence problem of the cache data, which is different from the old and new cache data. contradiction problem.

Furthermore, stored data includes keys in key-value pairs. When the storage-related operation performed by the applet is a storage read operation, if the client responds to the storage API call request and executes the storage read operation, it fails to read the value of the key, indicating that the storage data does not exist corresponding to the key. value, the key is determined to be an incorrect key and recorded, so as to filter out storage API call requests for reading the value of the incorrect key, and avoid subsequent repeated execution of storage read operations on the incorrect key. Afterwards, after writing a value for the wrong key by performing a storage write operation, indicating that the wrong key already has a corresponding value in the stored data, it can be determined that the key is no longer a wrong key, and the record can be modified .

As shown in Figure 3, when the applet performs a storage read operation, it records the error key according to the result of the read failure to form the storage data of the error key array. After the subsequent applet executes the storage write operation and corrects the wrong key, it can delete the wrong key recorded in the wrong key array.

In combination with the previous description, one or more embodiments of this specification provide a detailed flow diagram of the method in Figure 1 in an application scenario, in which some of the previous optional solutions are used, and the process is shown in Figure 4 Show.

In the process of Figure 4, for the storage write operation, when the applet calls the storage API for the first time, it checks in the cache of the applet itself according to the key-value pair (Key-Value, KV) corresponding to the data to be written. test to determine if the same key-value pair exists. Generally, when calling for the first time, the same KV cannot be hit, so the applet needs to write the key-value pair corresponding to the data to be written into the cache of the applet itself, and also into the storage space of the client. For example, you can communicate with the client through JSAPI CALL BRIDGE to call the storage API.

When the applet calls the storage API again, it checks in the cache of the applet itself according to the data to be written to determine whether the same key-value pair KV exists. If there is the same key-value pair, it means that the applet has written the data to be written into the cache of the applet itself. If the applet is not treating the data to be written or it is the first call, it can directly return the verification in the cache of the applet itself. result. If the same key-value pair does not exist, it means that the applet has not stored the data in its own cache, that is, the data has not been stored in the client's storage space, then write the data to be written into the cache of the applet itself and in the storage space of the client.

For the storage read operation, according to the key of the data to be read, check whether there is a corresponding value in the cache of the applet itself. If there is a value corresponding to the key to be read, the corresponding value can be directly returned to the applet. If there is no value corresponding to the key to be read, then call the storage API of the client to query the corresponding value in the storage space of the client.

For the storage erasing operation, it is necessary to clear the stored data in the cache of the applet itself, and also clear the stored data in the client's storage space.

Based on the same idea, one or more embodiments of this specification also provide devices and devices corresponding to the above method, as shown in FIG. 5 and FIG. 6 .

Fig. 5 is a schematic structural diagram of a device for storing and invoking a small program provided by one or more embodiments of this specification. The small program runs on the client, and the device includes: an access module 502. Before the client initiates a storage API call request, it accesses the cache of the applet itself; the verification module 504 checks whether the storage data targeted by the storage API call request is stored in the cache of the applet itself; The realization module 506, when the result of the verification module 504 is yes, filters out the storage API call request for the client, and realizes The storage-related operation corresponding to the storage API call request; the initiating module 508, when the result of the verification module 504 is negative, initiates the storage API call request to the client.

Optionally, the storage-related operation is a storage write operation; the initiating module 508 executes the storage write operation on the cache of the applet itself, so as to write the data to be written corresponding to the applet, Write in the cache of the applet itself; initiate the storage API call request to the client, so that the client also executes the storage write operation, and writes the to-be-written data corresponding to the applet The data is persisted in the storage space corresponding to the client, and the storage space corresponding to the client does not belong to the applet and does not include the cache of the applet itself.

Optionally, the initiating module 508 generates risk filling data according to the data to be written corresponding to the applet; according to the risk filling data, initiates the storage API call request to the client, so that all The client first persists the risk filling data in the storage space corresponding to the client, and at the end of the life cycle of the applet, by also executing the storage write operation, the client The risk filling data persisted in the corresponding storage space is replaced with the data to be written corresponding to the applet.

Optionally, the initiating module 508, relative to executing the storage write operation on the cache of the applet itself, sends the storage API call request to the client asynchronously; the device also includes immediate reading module 510, the immediate read module 510, after the initiating module 508 executes the storage write operation on the cache of the applet itself, executes: immediately read from the cache of the applet itself through the storage The data written by the write operation.

Optionally, the storage-related operation is a storage read operation; the realization module 506 reads the stored data from the cache of the applet itself, and returns it to the applet.

The device may further include a generation module 512, and before the verification module 504 verifies whether the storage data targeted by the storage API call request is stored in the cache of the applet itself, execute: According to the base class of the storage cache manager, an applet cache management object is generated for the cache of the applet itself, so that the cache of the applet itself can be accessed through the instance of the applet cache management object, and the calibration can be executed. test.

Optionally, the device further includes a selection module 514, before the verification module 504 verifies whether the storage data targeted by the storage API call request is saved in the cache of the applet itself , execute: generate a plug-in cache management object for the plug-in cache of the application according to the base class of the storage cache manager, wherein the client belongs to the application or another application; call the request and/or specify according to the storage API The application identifier of the application, and select a target object from the applet cache management object and the plug-in cache management object.

The apparatus may further include a determination module 516, and before the implementation module 506 filters out the storage API call request for the client, the determination module 516: determines that the storage-related operation is not a storage erasure operation; The device also includes a clearing module 518, and the clearing module 518 executes: if the storage-related operation is a storage erase operation, clear the stored data in the cache of the applet itself; storing the API call request, so that the stored data persisted by the client outside the cache is also cleared.

Optionally, the stored data includes a key in a key-value pair, and the storage-related operation is a storage read operation; the device further includes an error recording module 520, and the error recording module 520 sends an error message to the initiating module 508 After the client initiates the storage API call request, execute: if the client fails to read the value of the key when executing the storage read operation in response to the storage API call request, then Determining the key as an error key and recording it to filter out storage API call requests for reading the value of the error key; after writing a value for the key by performing a storage write operation, determining the The above key is no longer an error key.

Optionally, the cache of the applet itself runs in the life cycle of the applet, and the device further includes a destroying module 522, and the destroying module 522 executes: when the life cycle of the applet ends, destroy The applet's own cache, and thus the stored data in the applet's own cache, is lost.

Fig. 6 is a schematic structural diagram of a device for storing and invoking a small program provided by one or more embodiments of this specification. The small program runs on a client, and the device includes: at least one processor; A memory communicatively connected to a processor; wherein the memory stores instructions executable by the at least one processor, the instructions are executed by the at least one processor, so that the at least one processor can: Before the applet initiates a storage API call request to the client, access the cache of the applet itself; check whether the storage data targeted by the storage API call request is saved in the cache of the applet itself ; If so, filter out the storage API call request for the client, and implement the storage-related operations corresponding to the storage API call request according to the storage data in the cache of the applet itself; otherwise, send The client initiates the storage API calling request.

Based on the same idea, one or more embodiments of this specification also provide a non-volatile computer storage medium corresponding to the above method, which stores computer-executable instructions, and the computer-executable instructions are configured to: Before the applet initiates a storage API call request to the client, access the cache of the applet itself; check whether the storage data targeted by the storage API call request is saved in the cache of the applet itself; if , then filter out the storage API call request for the client, and implement the storage-related operations corresponding to the storage API call request according to the storage data in the cache of the applet itself; otherwise, send the The client initiates the storage API call request.

In the 1990s, the improvement of a technology can be clearly distinguished as an improvement in hardware (for example, improvements in circuit structures such as diodes, transistors, and switches) or improvements in software (improvement in method flow). However, with the development of technology, the improvement of many current method flows can be regarded as the direct improvement of the hardware circuit structure. Designers almost always get the corresponding hardware circuit structure by programming the improved method flow into the hardware circuit. Therefore, it cannot be said that the improvement of a method flow cannot be realized by hardware physical modules. For example, a programmable logic device (Programmable Logic Device, PLD) (such as a field programmable gate array (Field Programmable Gate Array, FPGA)) is such an integrated circuit, the logic function of which is determined by the user's programming of the device. It is programmed by the designer to "integrate" a digital system on a PLD, instead of asking a chip manufacturer to design and make a dedicated integrated circuit chip. Moreover, nowadays, instead of making integrated circuit chips by hand, this kind of programming is mostly realized by "logic compiler (logic compiler)" software, which is similar to the software compiler used when program development and writing, but before compiling The original code of the computer must also be written in a specific programming language, which is called a hardware description language (Hardware Description Language, HDL), and there is not only one kind of HDL, but many kinds, such as ABEL (Advanced Boolean Expression Language) , AHDL (Altera Hardware Description Language), Confluence, CUPL (Cornell University Programming Language), HDCal, JHDL (Java Hardware Description Language), Lava, Lola, MyHDL, PALASM, RHDL (Ruby Hardware Description Language), etc., are currently the most commonly used The most popular are VHDL (Very-High-Speed Integrated Circuit Hardware Description Language) and Verilog. It should also be clear to those skilled in the art that only a little logical programming of the method flow in the above-mentioned hardware description languages and programming into an integrated circuit can easily obtain a hardware circuit for realizing the logic method flow.

The controller may be implemented in any suitable way, for example the controller may take the form of a microprocessor or processor and a computer readable medium storing computer readable program code (such as software or firmware) executable by the (micro)processor , logic gates, switches, application specific integrated circuits (Application Specific Integrated Circuit, ASIC), programmable logic controllers and embedded microcontrollers, examples of controllers include but are not limited to the following microcontrollers: ARC 625D, Atmel AT91SAM, Microchip PIC18F26K20 and Silicone Labs C8051F320, the memory controller can also be implemented as part of the control logic of the memory. Those skilled in the art also know that, in addition to realizing the controller in a purely computer-readable program code mode, it is entirely possible to make the controller use logic gates, switches, application-specific integrated circuits, programmable logic controllers, and embedded The same function can be realized in the form of a microcontroller or the like. Therefore, such a controller can be regarded as a hardware component, and the devices included in it for realizing various functions can also be regarded as structures within the hardware component. Or even, means for realizing various functions can be regarded as a structure within both a software module realizing a method and a hardware component.

The systems, devices, modules, or units described in the above embodiments can be specifically implemented by computer chips or entities, or by products with certain functions. A typical implementing device is a computer. Specifically, the computer may be, for example, a personal computer, a laptop computer, a cellular phone, a camera phone, a smart phone, a personal digital assistant, a media player, a navigation device, an email device, a game console, a tablet computer, a wearable device, or Combinations of any of these devices.

For the convenience of description, when describing the above devices, functions are divided into various units and described separately. Of course, when implementing this specification, the functions of each unit can be implemented in one or more pieces of software and/or hardware.

Those skilled in the art should understand that the embodiments of this specification may be provided as methods, systems, or computer program products. Accordingly, the embodiments of the present description may take the form of an entirely hardware embodiment, an entirely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, embodiments of the present description 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, etc.) having computer-usable program code embodied therein.

The specification is described with reference to flowcharts and/or block diagrams of methods, devices (systems), and computer program products according to embodiments of the specification. It should be understood that each procedure and/or block in the flowchart and/or block diagram, and a combination of procedures and/or blocks in the flowchart and/or block diagram can be realized by computer program instructions. These computer program instructions may be provided to a general purpose computer, special purpose computer, embedded processor, or processor of other programmable data processing equipment to produce a machine such that the instructions executed by the processor of the computer or other programmable data processing equipment produce a An apparatus for realizing the functions specified in one or more procedures of the flowchart and/or one or more blocks of the block diagram.

These computer program instructions may also be stored in a computer-readable memory capable of directing a computer or other programmable data processing apparatus to operate in a specific manner, such that the instructions stored in the computer-readable memory produce an article of manufacture comprising instruction means, the instructions The device realizes the function specified in one or more procedures of the flowchart and/or one or more blocks of the block diagram.

These computer program instructions can also be loaded onto a computer or other programmable data processing device, causing a series of operational steps to be performed on the computer or other programmable device to produce a computer-implemented process, thereby The instructions provide steps for implementing the functions specified in the flow chart or blocks of the flowchart and/or the block or blocks of the block diagrams.

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

Memory may include non-permanent storage in computer readable media, in the form of random access memory (RAM) and/or nonvolatile memory such as read-only memory (ROM) or flash RAM. Memory is an example of computer readable media.

Computer-readable media, including both permanent and non-permanent, removable and non-removable media, can be implemented by any method or technology for storage of information. 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 Disc (DVD) or other optical storage, Magnetic tape cartridge, tape magnetic disk storage or other magnetic storage device or any other non-transmission medium that can be used to store information that can be accessed by a computing device. As defined herein, computer-readable media excludes transitory computer-readable media, such as modulated data signals and carrier waves.

It should also be noted that the term "comprises", "comprises" or any other variation thereof is intended to cover a non-exclusive inclusion such that a process, method, article, or apparatus comprising a set of elements includes not only those elements, but also includes Other elements not expressly listed, or elements inherent in the process, method, commodity, or apparatus are also included. Without further limitations, an element defined by the phrase "comprising a ..." does not exclude the presence of additional identical elements in the process, method, article or apparatus comprising said element.

The specification 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 present description 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 storage devices.

Each embodiment in this specification is described in a progressive manner, the same and similar parts of each embodiment can be referred to each other, and each embodiment focuses on the differences from other embodiments. In particular, for the apparatus, equipment, and non-volatile computer storage medium embodiments, since they are basically similar to the method embodiments, the description is relatively simple, and for relevant parts, please refer to the part of the description of the method embodiments.

The foregoing describes specific embodiments of this specification. Other implementations are within the scope of the following claims. In some cases, the actions or steps recited in the claims can be performed in an order different from that in the embodiments and still achieve desirable results. In addition, the processes depicted in the accompanying figures do not necessarily require the particular order shown, or sequential order, to achieve desirable results. Multitasking and parallel processing are also possible or may be advantageous in certain embodiments.

The above description is only one or more embodiments of this specification, and is not intended to limit this specification. Various modifications and changes will occur to one or more embodiments of this description for those skilled in the art. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of one or more embodiments of this specification shall be included within the scope of claims of this specification.

Claims

A method for storing and invoking an applet, the applet is run on a client, and the method includes:

Before the applet initiates a storage API call request to the client, access the cache of the applet itself;

Verifying whether the storage data targeted by the storage API call request is stored in the cache of the applet itself;

If so, filter out the storage API call request for the client, and implement storage-related operations corresponding to the storage API call request according to the storage data in the cache of the applet itself;

Otherwise, initiate the storage API call request to the client.
The method according to claim 1, wherein the storage-related operation is a storage write operation;

The initiating the storage API call request to the client specifically includes:

Executing the storage write operation on the cache of the applet itself, so as to write the data to be written corresponding to the applet into the cache of the applet itself;

Initiate the storage API call request to the client, so that the client also executes the storage write operation to store the data to be written corresponding to the applet in the storage space corresponding to the client For persistence, the storage space corresponding to the client does not belong to the applet, and does not include the cache of the applet itself.
The method according to claim 2, wherein the initiating the storage API call request to the client, so that the client also executes the storage write operation, and writes the to-be-written data corresponding to the applet The data is persisted in the storage space corresponding to the client, specifically including:

Generate risk filling data according to the data to be written corresponding to the applet;

According to the risk filling data, initiate the storage API call request to the client, so that the client first persists the risk filling data in the storage space corresponding to the client, and in the When the life cycle of the applet ends, the risk filling data persisted in the storage space corresponding to the client is replaced with the data to be written corresponding to the applet by also performing the storage write operation.
The method according to claim 2, said initiating said storage API call request to said client, specifically comprising:

Relative to performing the storage write operation on the cache of the applet itself, asynchronously send the storage API call request to the client;

After the storage write operation is performed on the cache of the applet itself, the method further includes:

The data written by the storage write operation is immediately read from the applet's own cache.
The method according to claim 1, wherein the storage-related operation is a storage read operation;

According to the stored data in the cache of the applet itself, implementing the storage-related operations corresponding to the storage API call request specifically includes:

The stored data is read from the cache of the applet itself, and returned to the applet.
The method according to claim 1, before verifying whether the storage data targeted by the storage API call request is stored in the cache of the applet itself, the method further comprises:

According to the base class of the storage cache manager, an applet cache management object is generated for the cache of the applet itself, so that the cache of the applet itself can be accessed through the instance of the applet cache management object, and the calibration can be executed. test.
The method according to claim 6, before verifying whether the storage data targeted by the storage API call request is stored in the cache of the applet itself, the method further comprises:

Generate a plug-in cache management object for the cache of the plug-in of the application according to the base class of the storage cache manager, wherein the client belongs to the application or another application;

Select a target object from the applet cache management object and the plug-in cache management object according to the storage API call request and/or the specified application identifier.
The method according to claim 1, before filtering out the storage API call request for the client, the method further comprises:

Determining that the storage-related operation is not a storage erasure operation;

If the storage-related operation is a storage erasure operation, the method further includes:

clearing the stored data in the cache of the applet itself;

Initiating the storage API call request to the client, so that the storage data persisted by the client outside the cache is also cleared.
The method according to claim 1, wherein the stored data comprises a key in a key-value pair, and the storage-related operation is a storage read operation;

After initiating the storage API call request to the client, the method further includes:

If the client fails to read the value of the key when performing the storage read operation in response to the storage API call request, then determine the key as an error key and record it to filter out a Storage API call request to read the value of said erroneous key;

After writing a value for the key by performing a store write operation, it is determined that the key is no longer an erroneous key.
The method according to any one of claims 1 to 9, wherein the cache of the applet itself runs in the lifecycle of the applet, the method further comprising:

When the life cycle of the applet ends, the cache of the applet itself is destroyed, so that the stored data in the cache of the applet itself is lost.
A device for storing and invoking a small program, the small program runs on a client, and the device includes:

An access module, before the applet initiates a storage API call request to the client, accesses the cache of the applet itself;

A verification module, which verifies whether the storage data targeted by the storage API call request is stored in the cache of the applet itself;

An implementation module, if the result of the verification module is yes, filter out the storage API call request for the client, and implement the storage according to the storage data in the cache of the applet itself Storage-related operations corresponding to the storage API call request;

An initiating module, in the case that the result of the checking module is negative, initiating the storage API calling request to the client.
The apparatus according to claim 11, wherein the storage-related operation is a storage write operation;

The initiating module executes the storage write operation on the cache of the applet itself, so as to write the data to be written corresponding to the applet into the cache of the applet itself;

Initiate the storage API call request to the client, so that the client also executes the storage write operation to store the data to be written corresponding to the applet in the storage space corresponding to the client For persistence, the storage space corresponding to the client does not belong to the applet, and does not include the cache of the applet itself.
The device according to claim 12, wherein the initiating module generates risk filling data according to the data to be written corresponding to the applet;

According to the risk filling data, initiate the storage API call request to the client, so that the client first persists the risk filling data in the storage space corresponding to the client, and in the When the life cycle of the applet ends, by also executing the storage write operation, the risk filling data persisted in the storage space corresponding to the client is replaced with the data to be written corresponding to the applet.
The device according to claim 12, wherein the initiating module sends the storage API call request to the client asynchronously relative to executing the storage write operation on the cache of the applet itself;

The device further includes an immediate reading module, and after the initiating module executes the storage write operation on the cache of the applet itself, the immediate reading module executes:

The data written by the storage write operation is immediately read from the applet's own cache.
The apparatus according to claim 11, wherein the storage-related operation is a storage read operation;

The implementation module reads the stored data from the cache of the applet itself, and returns it to the applet.
The device according to claim 11, further comprising a generating module, the generating module verifies whether the storage targeted by the storage API call request is saved in the cache of the applet itself in the verification module Before data, execute:

According to the base class of the storage cache manager, an applet cache management object is generated for the cache of the applet itself, so that the cache of the applet itself can be accessed through the instance of the applet cache management object, and the calibration can be executed. test.
The device according to claim 16, further comprising a selection module, and the selection module verifies whether the storage targeted by the storage API call request is stored in the cache of the applet itself in the verification module. Before data, execute:

Generate a plug-in cache management object for the cache of the plug-in of the application according to the base class of the storage cache manager, wherein the client belongs to the application or another application;

Select a target object from the applet cache management object and the plug-in cache management object according to the storage API call request and/or the specified application identifier.
The device according to claim 11, further comprising a determination module, before the realization module filters out the storage API call request for the client, the determination module executes:

Determining that the storage-related operation is not a storage erasure operation;

The apparatus also includes a cleanup module that performs:

If the storage-related operation is a storage erasure operation, clearing the stored data in the cache of the applet itself;

Initiating the storage API call request to the client, so that the storage data persisted by the client outside the cache is also cleared.
The device according to claim 11, wherein the stored data includes a key in a key-value pair, and the storage-related operation is a storage read operation;

The device also includes an error recording module, and after the initiating module initiates the storage API call request to the client, the error recording module executes:

If the client fails to read the value of the key when performing the storage read operation in response to the storage API call request, then determine the key as an error key and record it to filter out a storage API call request to read the value of said erroneous key;

After writing a value for the key by performing a store write operation, it is determined that the key is no longer an erroneous key.
The device according to any one of claims 11 to 19, wherein the cache of the applet itself runs in the life cycle of the applet, and the device further includes a destroying module, the destroying module executes:

When the life cycle of the applet ends, the cache of the applet itself is destroyed, so that the stored data in the cache of the applet itself is lost.
A small program storage and calling device, the small program runs on the client, the device includes at least one processor and a memory connected to the at least one processor in communication; wherein, the memory stores information that can be used by the instructions executed by at least one processor, the instructions being executed by the at least one processor, to enable the at least one processor to:

Before the applet initiates a storage API call request to the client, access the cache of the applet itself;

Verifying whether the storage data targeted by the storage API call request is stored in the cache of the applet itself;

If so, filter out the storage API call request for the client, and implement storage-related operations corresponding to the storage API call request according to the storage data in the cache of the applet itself;

Otherwise, initiate the storage API call request to the client.