A Static Resource Loading Method, Device, Equipment, and Storage Medium

Abstract

The present invention discloses a method, apparatus, device and storage medium for loading static resources. The method includes: receiving a static resource loading request, where the static resource loading request carries a target address; encrypting the target address through an md5 encryption algorithm to obtain a target key; if the target key is found in the hash linked list, obtaining a target value corresponding to the target key in the hash linked list; performing loading and display according to the target value, and moving the target object corresponding to the target key and the target value to the forefront of the hash linked list. Through the technical solution of the present invention, the problems of memory overflow risk and excessive occupation of device storage space by the app are solved.

Description

Technical Field

[0001] Embodiments of the present invention relate to the field of computer technologies, and in particular, to a method, apparatus, device, and storage medium for loading static resources. Background Art

[0002] In order to improve the acquisition speed of static resources of mobile apps, improve page fluency, and thus enhance the user experience, existing technical solutions all adopt a three-level caching method to process static resources such as images, CSS, and JS files. The specific solutions are as follows:

[0003] When a mobile app receives a request for loading static resources, it first checks whether the currently requested static resource exists in the memory. If it exists, the static resource is directly returned and loaded; if the static resource cannot be found in the memory, the mobile app traverses and searches for the static resource in its sandbox directory. If the resource is found, it is stored in the memory for subsequent use, and then the resource is loaded and displayed; if the static resource cannot be found in the mobile app's sandbox directory, the resource is downloaded through a network request and stored in the memory and the app's sandbox directory.

[0004] The above method is a widely used three-level caching method for static resources, which can effectively improve the loading speed of static resources and enhance the user experience. However, this method still has the following problems:

[0005] (1) In order to accelerate the loading speed of static resources, a large number of static resources are stored in the memory. However, the above method fails to effectively manage the static resources stored in the memory, resulting in an infinite increase in the app's used memory as more and more resources are stored in the memory, and eventually leading to a situation where the memory usage is too large or even a memory overflow occurs.

[0006] (2) Since static resources are also stored in the app's sandbox directory, the stored resources are not effectively managed, and invalid static resources are not cleaned up, resulting in a continuous increase in the app's storage space. At the same time, if there are too many files in the app's sandbox directory, when traversing all files to search for static resources, the loading speed will be too slow, it will take too much time to display static resources, and there may even be problems such as file read / write thread locks.

[0007] (3) When the static resource to be loaded does not exist in either the memory or the app's sandbox directory, a network request needs to be sent to the background server to obtain the resource. However, frequently sending requests directly to the background server through the network not only takes a long time but also increases the pressure on the background server. Summary of the Invention

[0008] An embodiment of the present invention provides a static resource loading method, apparatus, device, and storage medium to solve the problems of memory overflow risk and excessive occupation of device storage space by the app.

[0009] In a first aspect, an embodiment of the present invention provides a static resource loading method, including:

[0010] Receiving a static resource loading request, where the static resource loading request carries a target address;

[0011] Encrypting the target address through the md5 encryption algorithm to obtain a target key;

[0012] If the target key is found in the hash linked list, obtaining the target value corresponding to the target key in the hash linked list;

[0013] Loading and displaying according to the target value, and moving the target object corresponding to the target key and target value to the front end of the hash linked list.

[0014] Further, it further includes:

[0015] If the target key is not found in the hash linked list, querying the data table according to the target key;

[0016] If the target key is found in the data table, obtaining the target sandbox directory storage path corresponding to the target key in the data table;

[0017] Obtaining the target static resource corresponding to the static resource loading request from the sandbox directory according to the target sandbox directory storage path;

[0018] Loading and displaying the target static resource.

[0019] Further, after obtaining the target static resource corresponding to the static resource loading request from the sandbox directory according to the target sandbox directory storage path, it further includes:

[0020] Obtaining the current occupied space of the memory;

[0021] If the current occupied space of the memory is less than the first preset storage space threshold, adding the target object corresponding to the target key and target value to the front end of the hash linked list;

[0022] If the current occupied space of the memory is greater than or equal to the first preset storage space threshold, deleting the object at the last end of the hash linked list;

[0023] Add the target object corresponding to the target key and target value to the front end of the hash linked list.

[0024] Further, after loading and displaying the static resources corresponding to the static resource loading request, it further includes:

[0025] Obtain the current timestamp;

[0026] Update the most recently used timestamp of the target resource corresponding to the target key in the data table to the current timestamp.

[0027] Further, if the target key is not found in the hash linked list and the data table is queried according to the target key, it further includes:

[0028] If the target key is not found in the data table, send the static resource loading request to the CDN server;

[0029] Receive the target static resource corresponding to the static resource loading request returned by the CDN server;

[0030] Store the target static resource under the sandbox directory.

[0031] Further, if the target key is not found in the data table, sending the static resource loading request to the CDN server includes:

[0032] If the target key is not found in the data table, send the static resource loading request to the CDN server so that the CDN server queries whether the target static resource corresponding to the static resource loading request is stored locally. If the target static resource is stored locally by the CDN server, return the target static resource. If the target static resource is not stored locally by the CDN server, send the static resource loading request to the remote server, receive the target static resource corresponding to the static resource loading request returned by the remote server, store the target static resource locally, and return the target static resource.

[0033] Further, storing the target static resource under the sandbox directory includes:

[0034] Obtain the current occupied space of the sandbox directory;

[0035] If the current occupied space of the sandbox directory is less than the second preset storage space threshold, store the target static resource under the sandbox directory;

[0036] If the current occupied space of the sandbox directory is greater than or equal to the second preset storage space threshold, delete the first historical record in the data table, where the first historical record is the record corresponding to the resource's most recently used timestamp at the end after sorting the resource's most recently used timestamps in the data table in descending order;

[0037] Delete the first static resource corresponding to the first historical record;

[0038] Store the target static resource under the sandbox directory.

[0039] In a second aspect, an embodiment of the present invention further provides a static resource loading device, which includes:

[0040] A receiving module, configured to receive a static resource loading request, where the static resource loading request carries a target address;

[0041] An encryption module, configured to encrypt the target address through an md5 encryption algorithm to obtain a target key;

[0042] An obtaining module, configured to obtain the target value corresponding to the target key in the hash linked list if the target key is found in the hash linked list;

[0043] A display module, configured to perform loading and display according to the target value, and move the target object corresponding to the target key and the target value to the front end of the hash linked list.

[0044] In a third aspect, an embodiment of the present invention further provides a computer device, including a memory, a processor, and a computer program stored on the memory and executable on the processor, where when the processor executes the program, it implements the static resource loading method as described in any one of the embodiments of the present invention.

[0045] In a fourth aspect, an embodiment of the present invention further provides a computer-readable storage medium, on which a computer program is stored, and when the program is executed by a processor, it implements the static resource loading method as described in any one of the embodiments of the present invention.

[0046] Embodiments of the present invention receive a static resource loading request, where the static resource loading request carries a target address; encrypt the target address through an md5 encryption algorithm to obtain a target key; if the target key is found in the hash linked list, obtain the target value corresponding to the target key in the hash linked list; perform loading and display according to the target value, and move the target object corresponding to the target key and the target value to the front end of the hash linked list, so as to solve the problems of memory overflow risk and excessive occupation of device storage space by the app. BRIEF DESCRIPTION OF THE DRAWINGS

[0047] In order to more clearly illustrate the technical solutions of the embodiments of the present invention, the following will briefly introduce the drawings required for use in the embodiments. It should be understood that the following drawings only show some embodiments of the present invention, and therefore should not be regarded as limiting the scope. For those of ordinary skill in the art, without creative efforts, other related drawings can also be obtained based on these drawings.

[0048] Figure 1 is a flowchart of a static resource loading method in an embodiment of the present invention;

[0049] Figure 1a is a diagram of a hash linked list in an embodiment of the present invention;

[0050] Figure 1b is another diagram of a hash linked list in an embodiment of the present invention;

[0051] Figure 1c is another diagram of a hash linked list in an embodiment of the present invention;

[0052] Figure 1d is another diagram of a hash linked list in an embodiment of the present invention;

[0053] Figure 1e is another diagram of a hash linked list in an embodiment of the present invention;

[0054] Figure 2 is a schematic structural diagram of a static resource loading device in an embodiment of the present invention;

[0055] Figure 3 is a schematic structural diagram of an electronic device in an embodiment of the present invention;

[0056] Figure 4 is a schematic structural diagram of a computer-readable storage medium containing a computer program in an embodiment of the present invention. DETAILED DESCRIPTION OF THE EMBODIMENTS

[0057] The present invention will be further described in detail below with reference to the drawings and embodiments. It can be understood that the specific embodiments described herein are only used to explain the present invention, rather than limiting the present invention. In addition, it should be noted that for the sake of description, only parts related to the present invention are shown in the drawings, rather than all the structures. In addition, without conflict, the embodiments in the present invention and the features in the embodiments can be combined with each other.

[0058] Before discussing the exemplary embodiments in more detail, it should be noted that some exemplary embodiments are described as processes or methods depicted as flowcharts. Although the flowcharts depict operations (or steps) as sequential processes, many of the operations can be implemented in parallel, concurrently, or simultaneously. In addition, the order of the operations can be rearranged. The process can be terminated when its operations are completed, but it can also have additional steps not included in the drawings. The process can correspond to a method, function, procedure, subroutine, subprogram, etc. In addition, without conflict, the embodiments in the present invention and the features in the embodiments can be combined with each other.

[0059] The term "comprising" and its variations used in the present invention are open-ended, that is, "including but not limited to". The term "based on" is "at least partially based on". The term "an embodiment" means "at least one embodiment".

[0060] It should be noted that: similar reference numerals and letters denote similar items in the following drawings. Therefore, once an item is defined in one drawing, it does not need to be further defined and explained in subsequent drawings. At the same time, in the description of the present invention, the terms "first", "second", etc. are only used for distinguishing descriptions and cannot be understood as indicating or implying relative importance.

[0061] Figure 1 The flowchart of a static resource loading method provided for an embodiment of the present invention. This embodiment is applicable to the situation of static resource loading. This method can be executed by the static resource loading device in the embodiment of the present invention. The static resource loading device can be implemented in software and / or hardware, such as Figure 1 shown, the static resource loading method specifically includes the following steps:

[0062] S110, receive a static resource loading request, where the static resource loading request carries a target address.

[0063] Specifically, receiving a static resource loading request, for example, a mobile app needs to load a background image background.png on a page, and the link url carried in the static resource loading request is "https: / / xxx.com.cn / xx / background.png".

[0064] S120, encrypt the target address through the md5 encryption algorithm to obtain a target key.

[0065] Specifically, encrypt the target address through the md5 encryption algorithm to obtain a target key. For example, encrypt the target address url through the md5 encryption algorithm, and use the encrypted md5 value as the target key.

[0066] S130. If the target key is found in the hash linked list, obtain the target value corresponding to the target key in the hash linked list.

[0067] Specifically, check whether the target key exists in the hash linked list. If it exists, directly obtain the target value corresponding to the target key in the hash linked list. If it does not exist, search for static resources in the app sandbox directory or obtain static resources through network requests.

[0068] Specifically, as Figure 1a shown, use a hash linked list to store the static resources to be loaded. Use the md5 value of the target address carried by the resource request as the target key, and store the static resource itself as the value. If 4 static resources are currently stored, these four static resources are inserted into the right end of the linked list in chronological order.

[0069] Specifically, if the target key is found in the hash linked list, obtain the target value corresponding to the target key in the hash linked list. For example, it can be to query in the hash linked list established in the memory space through the target key. If the target key is found in the hash linked list, obtain the target value corresponding to the target key in the hash linked list.

[0070] S140. Load and display according to the target value, and move the target object corresponding to the target key and target value to the front end of the hash linked list.

[0071] Among them, the target value is the target static resource corresponding to the target key.

[0072] Specifically, load and display the target static resource corresponding to the target key, and move the target key and the target static resource as the target object to the front end of the hash linked list. As Figure 1b shown, when the mobile app needs to load static resource 2, the data of static resource 2 exists in the hash linked list. Remove static resource 2 from between its predecessor node and successor node, and re-insert it into the right end of the linked list. At this time, the right end of the hash linked list becomes the newly accessed static resource 2, and the left end is still the least recently accessed static resource 1.

[0073] Optionally, it further includes:

[0074] If the target key is not found in the hash linked list, query the data table according to the target key;

[0075] If the target key is found in the data table, obtain the storage path of the target sandbox directory corresponding to the target key in the data table;

[0076] Obtain the target static resource corresponding to the static resource loading request from the sandbox directory according to the storage path of the target sandbox directory;

[0077] Load and display the target static resource.

[0078] Among them, the data table includes: ID, md5 value of the url, storage path of the sandbox directory, and resource last used timestamp. For example, the specific form of the data table is shown in Table 1:

[0079] Table 1

[0080] ID MD5 value of the url Sandbox directory storage path Resource's most recent usage timestamp ... 1 ababa1234 / sdcard / xxx / 1.png 11111111 ... 2 bbaba1214 / sdcard / xxx / 2.png 22222222 ... 3 cbcca3234 / sdcard / xxx / 3.png 33333333 ... 4 adcea4354 / sdcard / xxx / 4.png 44444444 ...

[0081] Specifically, receive a static resource loading request, the static resource loading request carries the url, obtain the md5 value of the url. If the md5 value of the url is ababa1234, and if ababa1234 is not found in the hash linked list, then query whether ababa1234 exists in the data table. If it exists, obtain the storage path of the target sandbox directory / sdcard / xxx / 1.png corresponding to ababa1234. Then, obtain the target static resource corresponding to the static resource loading request from the sandbox directory according to the storage path of the target sandbox directory / sdcard / xxx / 1.png corresponding to the target key, and load and display the target static resource.

[0082] Optionally, after obtaining the target static resource corresponding to the static resource loading request from the sandbox directory according to the storage path of the target sandbox directory, it further includes:

[0083] Obtain the current occupied space of the memory;

[0084] If the current occupied space of the memory is less than the first preset storage space threshold, add the target object corresponding to the target key and target value to the front end of the hash linked list;

[0085] If the current occupied space of the memory is greater than or equal to the first preset storage space threshold, delete the object at the end of the hash linked list;

[0086] Add the target object corresponding to the target key and target value to the front end of the hash linked list.

[0087] Among them, the first preset storage space threshold can be set by the user or by the system, and the embodiments of the present invention do not limit this. For example, in order to ensure the overall performance of the app, after multiple attempts, the storage upper limit of static resources stored in memory is set to 5MB. This value can not only ensure the loading speed of static resources but also minimize the occupation of memory space.

[0088] Among them, the front end of the hash linked list can be the Figure 1a right end of the hash linked list as shown. The rear end of the hash linked list can be the Figure 1a left end of the hash linked list as shown.

[0089] Among them, the object at the rear end of the hash linked list is the least recently accessed object. When the memory cache capacity reaches the upper limit, it is necessary to delete the least recently accessed object and then insert the target static resource at the right end of the hash linked list as the most recently accessed static resource.

[0090] Optionally, after loading and displaying the static resource corresponding to the static resource loading request, it further includes:

[0091] Obtain the current timestamp;

[0092] Update the most recently used timestamp of the target resource corresponding to the target key in the data table to the current timestamp.

[0093] As shown in Table 1, the data table stores the key and the most recently used timestamp of the resource corresponding to the key. Therefore, after using the static resource, it is necessary to synchronously update the most recently used timestamp of the resource. This is convenient for later managing the resources according to the most recently used timestamp of the resources. For example, when the storage space is insufficient, the resources that have not been used for a long time are deleted.

[0094] Optionally, if the target key is not found in the hash linked list, after querying the data table according to the target key, it further includes:

[0095] If the target key is not found in the data table, send the static resource loading request to the CDN server;

[0096] Receive the target static resource corresponding to the static resource loading request returned by the CDN server;

[0097] Store the target static resource in the sandbox directory.

[0098] Specifically, if the target key is not found in the data table, the static resource loading request is sent to the CDN server; the CDN server checks whether the target static resource corresponding to the static resource loading request is stored locally. If the target static resource is stored locally by the CDN server, the target static resource is returned. If the target static resource is not stored locally by the CDN server, the static resource loading request is sent to the remote server, the target static resource corresponding to the static resource loading request returned by the remote server is received, the target static resource is stored locally, and the target static resource is returned.

[0099] Optionally, if the target key is not found in the data table, sending the static resource loading request to the CDN server includes:

[0100] If the target key is not found in the data table, the static resource loading request is sent to the CDN server, so that the CDN server checks whether the target static resource corresponding to the static resource loading request is stored locally. If the target static resource is stored locally by the CDN server, the target static resource is returned. If the target static resource is not stored locally by the CDN server, the static resource loading request is sent to the remote server, the target static resource corresponding to the static resource loading request returned by the remote server is received, the target static resource is stored locally, and the target static resource is returned.

[0101] Optionally, storing the target static resource in the sandbox directory includes:

[0102] Obtain the current occupied space of the sandbox directory;

[0103] If the current occupied space of the sandbox directory is less than the second preset storage space threshold, store the target static resource in the sandbox directory;

[0104] If the current occupied space of the sandbox directory is greater than or equal to the second preset storage space threshold, delete the first historical record in the data table. The first historical record is the record corresponding to the resource usage timestamp of the last resource after sorting the resource usage timestamps in the data table in descending order;

[0105] Delete the first static resource corresponding to the first historical record;

[0106] Store the target static resource in the sandbox directory.

[0107] Among them, the second preset storage space threshold can be set by the user or by the system, and the embodiments of the present invention do not limit this. To ensure the overall performance of the app, the storage upper limit for storing static resources in the app sandbox directory is set to 100MB. This value can not only ensure the loading speed of static resources but also minimize the occupation of device storage space.

[0108] Among them, the first historical record is the timestamp of the most recent use of the resource that is farthest from the current time. As shown in Table 1, the first historical record is: a row of data with the md5 value of the url being ababa1234, that is, the first row of data in Table 1.

[0109] In order to improve the loading speed of static resources by the mobile app in the embodiments of the present invention, usually, the resource will be first searched in the memory. If the required static resource cannot be found, it will be searched in the app sandbox directory or obtained through a network request. To quickly obtain the resource when accessing it again later, a common solution is to directly store the static resource in the memory. However, the problem with this solution is that more and more resources will be stored in the memory, eventually causing the used memory of the app to increase infinitely, and then resulting in a situation where the memory usage is too large or even a memory overflow occurs. In response to this situation, some people propose randomly deleting some static resources when the memory is about to run out to release the memory and avoid memory overflow. However, the biggest drawback of this solution is that if the deleted resources happen to be the resources that will be frequently loaded by the app, it will lead to a significant reduction in performance, which runs counter to the original goal.

[0110] Therefore, in order to avoid memory overflow when storing static resources in the used memory and not affect the performance of the app in loading static resources, the embodiments of the present invention adopt an optimized LRU algorithm to manage the memory space for storing static resources. LRU stands for Least Recently Used, which means the least recently used. The design principle of the LRU algorithm is: if a piece of data has not been accessed in a recent period of time, then the possibility of it being accessed in the future is also very small. That is to say, when the limited space is full of data, the data that has not been accessed for the longest time should be eliminated. The specific method of using the LRU algorithm when static resources are stored in the memory is described as follows:

[0111] (1) As Figure 1a shown, use LinkedHashMap (implemented by a linked list and a hash table) to store the static resources to be loaded, use the md5 value of the resource request address as the key, and store the static resource itself as the value. If 4 static resources are currently stored, these four static resources are inserted into the right end of the linked list in chronological order.

[0112] (2) As Figure 1b shown, when the mobile app needs to load static resource 2, the data of static resource 2 exists in the hash linked list. Remove static resource 2 from between its predecessor node and successor node, and re-insert it at the rightmost end of the linked list. At this time, the rightmost end of the hash linked list becomes the newly accessed static resource 2, and the leftmost end is still the least recently accessed static resource 1.

[0113] (3) As Figure 1c shown, when the mobile app needs to load static resource 5, since there is no data of static resource 5 in the current hash linked list, search in the app sandbox directory or obtain the static resource through network requests, and insert it into the cache. At this time, the rightmost end of the hash linked list is the newly accessed static resource 5, and the leftmost end is the least recently accessed static resource 1.

[0114] (4) As Figure 1d shown, the mobile app needs to load static resource 4. By the same token, move static resource 4 from its original position to the rightmost side of the hash linked list, and update the value of the static resource. At this time, the rightmost end of the hash linked list is the newly accessed static resource 4, and the leftmost end is still the least recently accessed static resource 1.

[0115] (5) As Figure 1e shown, finally when the mobile app needs to load static resource 6, static resource 6 is not in the memory cache and needs to be inserted into the hash linked list. Assume that the memory cache capacity has reached the upper limit at this time, and the least recently accessed data must be deleted first. Then the static resource 1 located at the leftmost end of the hash linked list will be deleted, and then static resource 6 will be inserted into the rightmost end as the newly accessed static resource.

[0116] The above is the management solution for static resources stored in the memory space proposed by LRU in the embodiments of the present invention. At the same time, in order to ensure the overall performance of the app, after multiple attempts, the storage upper limit of static resources stored in the memory is set to 5MB. This value can not only ensure the loading speed of static resources, but also minimize the occupation of memory space to the greatest extent.

[0117] The specific embodiments of the optimization solution provided by the embodiments of the present invention are described as follows:

[0118] The mobile app needs to load the background image background.png on the page. The request link URL is "https: / / xxx.com.cn / xx / background.png". First, encrypt the URL through the MD5 encryption algorithm, and use the encrypted MD5 value as the key. Then, query in the hash linked list established in the memory space through this key value. If the key value exists in the hash linked list, return its corresponding value and load and display it. At the same time, move the queried key / value object to the front end of the hash linked list. If the key value cannot be queried, obtain it by searching in the app sandbox directory or initiating a network request.

[0119] After obtaining the required static resources by searching in the app sandbox directory or initiating a network request, it is necessary to store the background.png image itself as the value in the memory. At this time, it is necessary to judge whether the memory space for storing static resources exceeds the set maximum storage space of 5MB.

[0120] If the memory space for storing static resources has not reached the set maximum storage space, directly move the corresponding key / value object to the front end of the hash linked list.

[0121] If the memory space for storing static resources has reached the set maximum storage space, first, it is necessary to clear the least recently used static resources in the memory space, that is, clear the object stored on the leftmost side of the hash linked list. Then, insert the latest key / value object to the front end of the hash linked list.

[0122] After all, the memory space is limited. Therefore, in order to further improve the loading speed of static resources, static resources are usually also stored in the app sandbox directory. Although loading static resources in the app sandbox directory is slower than directly loading resources in the memory, more static resources can be stored in the app sandbox directory. Although this method can further improve the loading speed of static resources, there are problems such as difficult management of static resources in the sandbox directory, abuse of storage space, and slow speed of facilitating the search for static resources. These problems not only make the loading speed of static resources gradually slower, but also cause the app to occupy more and more storage space, affecting the user experience.

[0123] Therefore, on the premise of using the app sandbox directory to improve the loading speed of static resources, the strategy for storing static resources in the sandbox directory is optimized, which not only improves the resource loading speed but also reasonably manages the storage space and controls the occupied storage capacity. The embodiment of the present invention also uses an optimized LRU algorithm to manage the app sandbox directory space for storing static resources. The specific usage method of the LRU algorithm when static resources are stored in the app sandbox directory is described as follows:

[0124] (1) First, create a data table in the app local database to maintain the usage status of static resources. This data table mainly includes fields such as the md5 value of the resource url, the location of the resource in the app sandbox directory, and the timestamp of the resource's most recent use. Then calculate the md5 value of the request address of the static resources that need to be stored in the sandbox directory, and store the resources in a specific static resource storage directory under the app sandbox directory. For example, currently 4 static resources are stored, as shown in Table 1, and these four static resources are stored in the above data table.

[0125] (2) At this time, when the mobile app needs to load static resource 5, since the static resource does not exist in either the memory or the app sandbox directory, the static resource is obtained through a network request and stored in the app sandbox directory, and a new piece of data is inserted into the data

[0126] table. At this time, the most recently accessed static resource in the app sandbox directory is resource 5 with the largest timestamp of the most recent use in the data table, and the least recently accessed is resource 1 with the smallest timestamp of the most recent use. As shown in Table 2:

[0127] Table 2

[0128] ID MD5 value of the url Sandbox directory storage path Resource's most recent usage timestamp ... 1 ababa1234 / sdcard / xxx / 1.png 11111111 ... 2 bbaba1214 / sdcard / xxx / 2.png 22222222 ... 3 cbcca3234 / sdcard / xxx / 3.png 33333333 ... 4 adcea4354 / sdcard / xxx / 4.png 44444444 ... 5 sdsad4567 / sdcard / xxx / 5.png 55555555 ...

[0129] (3) Next, when the mobile app needs to load static resource 2, the data of static resource 2 exists in the app sandbox directory. Update the timestamp of the most recent use corresponding to static resource 2 in the data table to the timestamp corresponding to the current time. At this time, the most recently accessed static resource in the app sandbox directory is resource 2 with the largest timestamp of the most recent use in the data table, and the least recently accessed is resource 1 with the smallest timestamp of the most recent use. As shown in Table 3:

[0130] Table 3

[0131] ID MD5 value of the url Sandbox directory storage path Resource's most recent usage timestamp ... 1 ababa1234 / sdcard / xxx / 1.png 11111111 ... 2 bbaba1214 / sdcard / xxx / 2.png 66666666 ... 3 cbcca3234 / sdcard / xxx / 3.png 33333333 ... 4 adcea4354 / sdcard / xxx / 4.png 44444444 ... 5 sdsad4567 / sdcard / xxx / 5.png 55555555 ...

[0132] (4) Next, the mobile app needs to load static resource 4. Similarly, update the timestamp of the most recently used time corresponding to static resource 4 in the data table to the timestamp corresponding to the current time. At this time, the static resource that has been most recently accessed in the app sandbox directory is resource 4 with the largest timestamp of the most recently used time in the data table, while the least recently accessed is still resource 1 with the smallest timestamp of the most recently used time. As shown in Table 4:

[0133] Table 4

[0134] ID MD5 value of the url Sandbox directory storage path Resource's most recent usage timestamp ... 1 ababa1234 / sdcard / xxx / 1.png 11111111 ... 2 bbaba1214 / sdcard / xxx / 2.png 66666666 ... 3 cbcca3234 / sdcard / xxx / 3.png 33333333 ... 4 adcea4354 / sdcard / xxx / 4.png 77777777 ... 5 sdsad4567 / sdcard / xxx / 5.png 55555555 ...

[0135] (5) Finally, when the mobile app needs to load static resource 6, since static resource 6 is not in the app sandbox directory, it needs to be stored in the app sandbox directory and synchronously inserted into the data table. Assume that the cache capacity of the app sandbox directory has reached the upper limit at this time, and the least recently accessed data must be deleted first. Then, sort the records in the data table in descending order according to the timestamp of the most recently used time of the resource, and then delete the record at the end. At the same time, synchronously delete the static resource located under the app sandbox directory pointed to by this record; finally, store static resource 6 under the app sandbox directory, synchronously insert the data into the data table, and use it as the most recently accessed static resource. As shown in Table 5:

[0136] Table 5

[0137] ID MD5 value of the url Sandbox directory storage path Resource's most recent usage timestamp ... 2 bbaba1214 / sdcard / xxx / 2.png 66666666 ... 3 cbcca3234 / sdcard / xxx / 3.png 33333333 ... 4 adcea4354 / sdcard / xxx / 4.png 77777777 ... 5 sdsad4567 / sdcard / xxx / 5.png 55555555 ... 6 bdhda7896 / sdcard / xxx / 6.png 88888888 ...

[0138] The above is the management solution of LRU for static resources stored in the app sandbox directory space in the embodiment of the present invention. At the same time, in order to ensure the overall performance of the app, after multiple attempts, the storage upper limit of static resources stored in the app sandbox directory is set to 100MB. This value can not only ensure the loading speed of static resources, but also minimize the occupation of device storage space.

[0139] The specific embodiments of this optimization solution are described as follows:

[0140] The mobile app needs to load the background image background.png on the page. The request link URL is "https: / / xxx.com.cn / xx / background.png". First, encrypt the URL using the md5 encryption algorithm, and use the encrypted md5 value as the key. Then, query in the hash linked list established in the memory space using this key value. If not found, search in the data table using this key value to see if there is a corresponding record. If the key value is found in the data table, obtain the corresponding static resource under the sandbox directory according to the sandbox directory storage path in this record, then return and load it for display, and at the same time update the resource's most recently used timestamp field corresponding to this record in the data table; if the key value cannot be found, obtain it by initiating a network request.

[0141] After obtaining the required static resources by initiating a network request, the background.png image itself needs to be stored in the app's sandbox directory. At this time, it is necessary to determine whether the app's sandbox directory space for storing static resources exceeds the set maximum storage space of 100MB.

[0142] If the app's sandbox directory space for storing static resources has not reached the set maximum storage space, directly store the static resource in the sandbox directory and insert a record into the data table at the same time.

[0143] If the app's sandbox directory space for storing static resources has reached the set maximum storage space, first, it is necessary to clear the least recently used static resources in the sandbox directory space. First, sort the data in the data table in descending order according to the resource's most recently used timestamp, then delete the last record, and at the same time delete the static resource corresponding to this record under the app's sandbox directory. Finally, store the latest static resource in the sandbox directory and insert a record into the data table at the same time.

[0144] When the app is loading static resources and finds that the required static resources do not exist in either the memory or the app sandbox directory, it will send a request to obtain the static resources directly to the backend server by initiating a network request. However, this solution will cause frequent access to the backend server to request resources, resulting in a long page loading time and increased pressure on the backend server. Therefore, the embodiments of the present invention propose a solution to establish a dedicated static resource microservice and introduce a CDN server. The full name of CDN is Content Delivery Network, which is a content delivery network. Its purpose is to add a new network architecture to the existing Internet, publish the content of the website to the "edge" of the network closest to the user, so that users can obtain the required content nearby, solve the Internet network congestion situation, and improve the response speed of users accessing the website.

[0145] First, establish a dedicated static resource microservice. The only function of this microservice is to provide access to static resources and does not provide any functional interfaces to the outside world. Then, configure a CDN server for this static resource microservice to cache the static resources requested by the mobile app, which not only improves the speed of obtaining static resources but also greatly reduces the access pressure on the source server site.

[0146] The specific embodiments of this optimization solution are described as follows:

[0147] The mobile app needs to load the background image background.png on the page. When the static resource cannot be found in both the memory and the app sandbox directory, it will obtain the static resource through a network request. This request will first reach the CDN server. If the static resource has been cached on the CDN server, it will directly return the resource.

[0148] If the static resource has not been cached on the CDN server, it will obtain the static resource by sending a request to the source site. After obtaining it, it will return the static resource to the mobile app and cache the static resource on the CDN server for subsequent requests for this static resource.

[0149] The specific process of the optimization solution for displaying static resources of mobile apps based on three - level caching proposed by the embodiments of the present invention is as follows:

[0150] (1) For all static resources loaded in memory, establish a unified class for storage, and at the same time, monitor the memory usage of this class and the usage times of each static resource at any time. When a memory pressure warning is received, sort the usage frequencies of the static resources and preferentially clean up the static resources with fewer usage times and excessive memory occupancy.

[0151] (2) For the static resources stored in the app sandbox directory, not only should the device storage space occupied by the resource storage be managed to timely clean up invalid and inactive resources, but also when storing static resources, mark and store them in multiple categories in the sandbox, and search for static resources by identifying the marks to improve the resource access speed.

[0152] (3) For the situation where frequent access to the background server to request resources causes long page loading time and increased pressure on the background server, a solution of establishing a dedicated static resource microservice and introducing a CDN server is proposed.

[0153] In the embodiment of the present invention, for the problems of memory shortage and memory overflow that may be caused by caching static resources in memory, an optimized LRU algorithm is adopted to effectively manage the static resources in memory, and on the premise of ensuring the static resource loading speed, the problem of consuming a large amount of memory space is solved; for the problems of abusing device storage space and too slow resource query speed that may be caused by caching static resources in the app sandbox directory, the database is operated by optimizing the LRU algorithm idea to effectively manage and record the static resources in the app sandbox directory, and on the premise of ensuring the static resource loading speed, the usage efficiency of the sandbox directory space is optimized. For the situation where the process of obtaining resources through network requests takes a long time and will cause too much pressure on the source site server, an optimization solution is proposed. By establishing a dedicated static resource microservice and using a CDN server to cache static resources, not only the speed of obtaining network static resources is improved, but also the pressure on the source site server is relieved.

[0154] The technical solution of this embodiment is to receive a static resource loading request, where the static resource loading request carries a target address; encrypt the target address through the md5 encryption algorithm to obtain a target key; query the target key in the hash linked list, and then obtain the target value corresponding to the target key in the hash linked list; perform loading and display according to the target value, and move the target object corresponding to the target key and target value to the front end of the hash linked list to solve the problems of memory overflow risk and excessive device storage space occupied by the app.

[0155] Figure 2 It is a structural schematic diagram of a static resource loading device provided by an embodiment of the present invention. This embodiment is applicable to the situation of static resource loading. The device can be implemented in software and / or hardware, and the device can be integrated in any device that provides static resource loading functions, such as Figure 2 As shown, the static resource loading device specifically includes: a receiving module 210, an encryption module 220, an obtaining module 230, and a display module 240.

[0156] Among them, a receiving module is used to receive a static resource loading request, where the static resource loading request carries a target address;

[0157] An encryption module is used to encrypt the target address through the md5 encryption algorithm to obtain a target key;

[0158] An obtaining module is used to obtain the target value corresponding to the target key in the hash linked list if the target key is found in the hash linked list;

[0159] A display module is used to perform loading and display according to the target value, and move the target object corresponding to the target key and the target value to the forefront of the hash linked list.

[0160] The above product can execute the method provided in any embodiment of the present invention, and has the corresponding functional modules and beneficial effects of the execution method.

[0161] The technical solution of this embodiment is to receive a static resource loading request, where the static resource loading request carries a target address; encrypt the target address through the md5 encryption algorithm to obtain a target key; if the target key is found in the hash linked list, obtain the target value corresponding to the target key in the hash linked list; perform loading and display according to the target value, and move the target object corresponding to the target key and the target value to the forefront of the hash linked list, so as to solve the problems of memory overflow risk and excessive storage space occupied by the app on the device.

[0162] Figure 3 It is a schematic structural diagram of an electronic device in an embodiment of the present invention. Figure 3 A block diagram of an exemplary electronic device 12 suitable for implementing the embodiments of the present invention is shown. Figure 3 The shown electronic device 12 is only an example and should not impose any limitation on the functions and usage scope of the embodiments of the present invention.

[0163] As Figure 3 shown, the electronic device 12 is presented in the form of a general-purpose computing device. The components of the electronic device 12 may include, but are not limited to: one or more processors or processing units 16, a system memory 28, and a bus 18 connecting different system components (including the system memory 28 and the processing unit 16).

[0164] Bus 18 represents one or more of several types of bus architectures, including a memory bus or memory controller, a peripheral bus, an Accelerated Graphics Port, a processor, or a local bus using any of the various bus architectures. By way of example, these architectures include, but are not limited to, Industry Standard Architecture (ISA) bus, Micro Channel Architecture (MCA) bus, Enhanced ISA bus, Video Electronics Standards Association (VESA) local bus, and Peripheral Component Interconnect (PCI) bus.

[0165] Electronic device 12 typically includes a variety of computer system readable media. These media can be any available media that can be accessed by electronic device 12, including volatile and nonvolatile media, removable and non-removable media.

[0166] System memory 28 may include computer system readable media in the form of volatile memory, such as Random Access Memory (RAM) 30 and / or cache memory 32. Electronic device 12 may further include other removable / non-removable, volatile / nonvolatile computer system storage media. By way of example only, storage system 34 can be used for reading and writing on non-removable, nonvolatile magnetic media ( Figure 3 not shown, typically referred to as a "hard disk drive"). Although Figure 3 not shown in, a disk drive for reading and writing on a removable nonvolatile disk (such as a "floppy disk"), and an optical disk drive for reading and writing on a removable nonvolatile optical disk (Compact Disc-Read Only Memory (CD-ROM), Digital Video Disc-Read Only Memory (DVD-ROM), or other optical media) can be provided. In these cases, each drive can be connected to bus 18 through one or more data media interfaces. System memory 28 may include at least one program product having a set (e.g., at least one) of program modules configured to perform the functions of the embodiments of the present invention.

[0167] A program / utilities 40 having a set (at least one) of program modules 42 can be stored in, for example, the system memory 28. Such program modules 42 include, but are not limited to, an operating system, one or more application programs, other program modules, and program data. Each or some combination of these examples may include the implementation of a network environment. The program modules 42 generally execute the functions and / or methods in the embodiments described in the present invention.

[0168] The electronic device 12 can also communicate with one or more external devices 14 (such as a keyboard, a pointing device, a display 24, etc.), and can also communicate with one or more devices that enable a user to interact with the electronic device 12, and / or communicate with any device that enables the electronic device 12 to communicate with one or more other computing devices (such as a network card, a modem, etc.). Such communication can be carried out through the input / output (I / O) interface 22. Additionally, in this embodiment of the electronic device 12, the display 24 does not exist as an independent entity but is embedded in the mirror. When the display surface of the display 24 is not being displayed, the display surface of the display 24 visually merges with the mirror surface. Moreover, the electronic device 12 can also communicate with one or more networks (such as a Local Area Network (LAN), a Wide Area Network (WAN), and / or a public network, such as the Internet) through the network adapter 20. As shown in the figure, the network adapter 20 communicates with other modules of the electronic device 12 through the bus 18. It should be understood that although not shown in the figure, other hardware and / or software modules can be used in conjunction with the electronic device 12, including but not limited to: microcode, device drivers, redundant processing units, external disk drive arrays, Redundant Arrays of Independent Disks (RAID) systems, tape drives, and data backup storage systems, etc.

[0169] The processing unit 16 executes various functional applications and data processing by running the programs stored in the system memory 28, such as implementing the static resource loading method provided by the embodiments of the present invention:

[0170] Receive a static resource loading request, where the static resource loading request carries a target address;

[0171] Encrypt the target address through the md5 encryption algorithm to obtain a target key;

[0172] If the target key is found in the hash linked list, obtain the target value corresponding to the target key in the hash linked list;

[0173] Load and display according to the target value, and move the target object corresponding to the target key and target value to the front end of the hash linked list.

[0174] Figure 4 This is a schematic structural diagram of a computer-readable storage medium including a computer program in an embodiment of the present invention. An embodiment of the present invention provides a computer-readable storage medium 61, on which a computer program 610 is stored. When the program is executed by one or more processors, it implements the static resource loading method provided by all embodiments of the present application:

[0175] Receive a static resource loading request, where the static resource loading request carries a target address;

[0176] Encrypt the target address through the md5 encryption algorithm to obtain a target key;

[0177] If the target key is found in the hash linked list, obtain the target value corresponding to the target key in the hash linked list;

[0178] Load and display according to the target value, and move the target object corresponding to the target key and target value to the front end of the hash linked list.

[0179] Any combination of one or more computer-readable media can be used. A computer-readable medium can be a computer-readable signal medium, a computer-readable storage medium, or any combination of the two. A computer-readable storage medium can be, for example, but not limited to, an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination of the above. More specific examples (non-exhaustive list) of computer-readable storage media include: an electrical connection having one or more wires, a portable computer disk, 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 disk read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the above. In an embodiment of the present invention, a computer-readable storage medium can be any tangible medium that contains or stores a program, and the program can be used by or in combination with an instruction execution system, apparatus, or device.

[0180] A computer-readable signal medium may include a data signal propagated in a baseband or as part of a carrier wave, in which computer-readable program code is carried. Such a propagated data signal may take many forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination of the foregoing. A computer-readable signal medium may also be any computer-readable medium other than a computer-readable storage medium, which can send, propagate, or transmit a program for use by or in connection with an instruction execution system, apparatus, or device.

[0181] The program code contained on a computer-readable medium may be transmitted using any appropriate medium, including but not limited to wireless, wire, optical fiber cable, RF, etc., or any suitable combination of the foregoing.

[0182] In some embodiments, the client, server may communicate using any currently known or future-developed network protocol such as HTTP (Hyper Text Transfer Protocol), and may be interconnected with digital data communication in any form or medium (e.g., a communication network). Examples of communication networks include local area networks (“LANs”), wide area networks (“WANs”), the Internet (e.g., the Internet), and end-to-end networks (e.g., ad hoc end-to-end networks), as well as any currently known or future-developed networks.

[0183] The above-mentioned computer-readable medium may be contained in the above-mentioned electronic device; or may exist separately without being assembled into the electronic device.

[0184] The computer program code for performing the operations of the present invention may be written in one or more programming languages or combinations thereof. The programming languages include object-oriented programming languages such as Java, Smalltalk, C++, and also include conventional procedural programming languages—such as the “C” language or similar programming languages. The program code may be executed entirely on the user's computer, partially on the user's computer, executed as a stand-alone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In the case of a remote computer, the remote computer may be connected to the user's computer through any type of network including a local area network (LAN) or a wide area network (WAN), or may be connected to an external computer (e.g., by using an Internet service provider to connect through the Internet).

[0185] The flowcharts and block diagrams in the accompanying drawings illustrate the possible architectures, functions, and operations of systems, methods, and computer program products according to various embodiments of the present disclosure. In this regard, each block in the flowchart or block diagram may represent a module, a segment of a program, or a portion of code that contains one or more executable instructions for implementing the specified logical function. It should also be noted that, in some alternative implementations, the functions noted in the blocks may occur in a different order than that noted in the accompanying drawings. For example, two consecutive blocks shown may actually be executed substantially in parallel, or they may sometimes be executed in the reverse order, depending on the functions involved. It should also be noted that each block in the block diagrams and / or flowcharts, and combinations of blocks in the block diagrams and / or flowcharts, can be implemented by a dedicated hardware-based system that performs the specified functions or operations, or by a combination of dedicated hardware and computer instructions.

[0186] The units involved in the embodiments described in the present disclosure can be implemented in software or in hardware. In some cases, the name of the unit does not constitute a limitation on the unit itself.

[0187] The functions described above in the embodiments of the present invention can be at least partially performed by one or more hardware logic components. For example, without limitation, exemplary types of hardware logic components that can be used include: Field Programmable Gate Arrays (FPGA), Application Specific Integrated Circuits (ASIC), Application Specific Standard Products (ASSP), System on a Chip (SOC), Complex Programmable Logic Devices (CPLD), and so on.

[0188] In the context of the present disclosure, a machine-readable medium can be a tangible medium that can contain or store a program for use by or in connection with an instruction execution system, apparatus, or device. A machine-readable medium can be a machine-readable signal medium or a machine-readable storage medium. A machine-readable medium can include, but is not limited to, electronic, magnetic, optical, electromagnetic, infrared, or semiconductor systems, apparatus, or devices, or any suitable combination of the foregoing. More specific examples of a machine-readable storage medium would include an electrical connection based on 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.

[0189] Note that the above is only the preferred embodiment of the present invention and the technical principles applied. Those skilled in the art will understand that the present invention is not limited to the specific embodiments described herein, and various obvious changes, re-adjustments and substitutions can be made by those skilled in the art without departing from the protection scope of the present invention. Therefore, although the present invention has been described in more detail through the above embodiments, the present invention is not limited to the above embodiments. Without departing from the concept of the present invention, more other equivalent embodiments can be included, and the scope of the present invention is determined by the scope of the appended claims.

Claims

1. A static resource loading method, characterized in that, Including: Receiving a static resource loading request, where the static resource loading request carries a target address; Encrypting the target address through the md5 encryption algorithm to obtain a target key; If the target key is found in the hash linked list, obtaining the target value corresponding to the target key in the hash linked list; Performing loading and display according to the target value, and moving the target object corresponding to the target key and target value to the front end of the hash linked list; If the target key is not found in the hash linked list, querying a data table according to the target key; If the target key is found in the data table, obtaining the target sandbox directory storage path corresponding to the target key in the data table; Obtaining the target static resource corresponding to the static resource loading request from under the sandbox directory according to the target sandbox directory storage path; Performing loading and display on the target static resource; Wherein, the data table includes ID, the md5 value of the url, the sandbox directory storage path, and the resource's most recent usage timestamp; After the step of if the target key is not found in the hash linked list, querying the data table according to the target key, further including: If the target key is not found in the data table, sending the static resource loading request to the CDN server; If the CDN server locally stores the target static resource, returning the target static resource; If the CDN server does not locally store the target static resource, sending the static resource loading request to a remote server, receiving the target static resource corresponding to the static resource loading request returned by the remote server, storing the target static resource locally, and returning the target static resource; Receiving the target static resource corresponding to the static resource loading request returned by the CDN server; Storing the target static resource under the sandbox directory.

2. The method according to claim 1, characterized in that, After obtaining the target static resource corresponding to the static resource loading request from under the sandbox directory according to the target sandbox directory storage path, further including: Obtaining the current occupied space of the memory; If the current occupied space of the memory is less than a first preset storage space threshold, adding the target object corresponding to the target key and target value to the front end of the hash linked list; If the current occupied space of the memory is greater than or equal to the first preset storage space threshold, deleting the object at the end of the hash linked list; Adding the target object corresponding to the target key and target value to the front end of the hash linked list.

3. The method according to claim 1, characterized in that, After performing loading and display on the static resource corresponding to the static resource loading request, further including: Obtaining the current timestamp; Updating the target resource's most recent usage timestamp corresponding to the target key in the data table to the current timestamp.

4. The method according to claim 1, characterized in that, Storing the target static resource under the sandbox directory includes: Obtaining the current occupied space of the sandbox directory; If the current occupied space of the sandbox directory is less than a second preset storage space threshold, storing the target static resource under the sandbox directory; If the current occupied space of the sandbox directory is greater than or equal to the second preset storage space threshold, delete the first historical record in the data table, where the first historical record is the record corresponding to the resource's most recent usage timestamp at the end after sorting the resource's most recent usage timestamps in the data table in descending order; Delete the first static resource corresponding to the first historical record; Store the target static resource under the sandbox directory.

5. A static resource loading device, characterized in that, Includes: A receiving module, configured to receive a static resource loading request, where the static resource loading request carries a target address; An encryption module, configured to encrypt the target address through an md5 encryption algorithm to obtain a target key; An obtaining module, configured to, if the target key is found in the hash linked list, obtain the target value corresponding to the target key in the hash linked list; A display module, configured to perform loading and display according to the target value, and move the target object corresponding to the target key and the target value to the front end of the hash linked list; If the target key is not found in the hash linked list, query the data table according to the target key; If the target key is found in the data table, obtain the target sandbox directory storage path corresponding to the target key in the data table; Obtain the target static resource corresponding to the static resource loading request from under the sandbox directory according to the target sandbox directory storage path; Perform loading and display on the target static resource; Wherein, the data table includes ID, the md5 value of the url, the sandbox directory storage path, and the resource's most recent usage timestamp; If the target key is not found in the data table, send the static resource loading request to the CDN server; If the CDN server locally stores the target static resource, return the target static resource; If the CDN server does not locally store the target static resource, send the static resource loading request to the remote server, receive the target static resource corresponding to the static resource loading request returned by the remote server, store the target static resource locally, and return the target static resource; Receive the target static resource corresponding to the static resource loading request returned by the CDN server; Store the target static resource under the sandbox directory.

6. An electronic device, characterized in that, Includes: One or more processors; A memory, configured to store one or more programs; When the one or more programs are executed by the one or more processors, the processors implement the method according to any one of claims 1-4.

7. A computer-readable storage medium containing a computer program, on which a computer program is stored, characterized in that, When the program is executed by one or more processors, it implements the method according to any one of claims 1-4.

Images