CN112199398A - Cache processing method, terminal and computer storage medium - Google Patents
Cache processing method, terminal and computer storage medium Download PDFInfo
- Publication number
- CN112199398A CN112199398A CN202011138207.7A CN202011138207A CN112199398A CN 112199398 A CN112199398 A CN 112199398A CN 202011138207 A CN202011138207 A CN 202011138207A CN 112199398 A CN112199398 A CN 112199398A
- Authority
- CN
- China
- Prior art keywords
- data
- cache
- memorycache
- processing method
- memory
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
- 238000003672 processing method Methods 0.000 title claims abstract description 35
- 238000012544 monitoring process Methods 0.000 claims abstract description 29
- 230000006870 function Effects 0.000 claims description 13
- 238000004590 computer program Methods 0.000 claims description 7
- 238000013507 mapping Methods 0.000 claims description 7
- 238000000034 method Methods 0.000 claims description 7
- 230000008859 change Effects 0.000 abstract description 11
- 238000010586 diagram Methods 0.000 description 6
- 230000002093 peripheral effect Effects 0.000 description 5
- 230000008901 benefit Effects 0.000 description 3
- 238000004891 communication Methods 0.000 description 3
- 238000011161 development Methods 0.000 description 3
- 238000005516 engineering process Methods 0.000 description 3
- 230000002085 persistent effect Effects 0.000 description 3
- 238000012545 processing Methods 0.000 description 3
- 238000013459 approach Methods 0.000 description 2
- 238000013500 data storage Methods 0.000 description 2
- 238000007726 management method Methods 0.000 description 2
- 230000007246 mechanism Effects 0.000 description 2
- 238000010295 mobile communication Methods 0.000 description 2
- 230000003068 static effect Effects 0.000 description 2
- 230000002123 temporal effect Effects 0.000 description 2
- 238000013499 data model Methods 0.000 description 1
- 230000003111 delayed effect Effects 0.000 description 1
- 238000001514 detection method Methods 0.000 description 1
- 238000009434 installation Methods 0.000 description 1
- 239000004973 liquid crystal related substance Substances 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 229920000642 polymer Polymers 0.000 description 1
- 230000008569 process Effects 0.000 description 1
- 230000001360 synchronised effect Effects 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/20—Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
- G06F16/24—Querying
- G06F16/245—Query processing
- G06F16/2455—Query execution
- G06F16/24552—Database cache management
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/20—Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
- G06F16/23—Updating
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Databases & Information Systems (AREA)
- Data Mining & Analysis (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Computational Linguistics (AREA)
- Memory System Of A Hierarchy Structure (AREA)
Abstract
The invention discloses a cache processing method, which is applied to a terminal, creates a MemoryCache object, and writes data to be cached into the MemoryCache object to form cache data; and monitoring cache data in the MemoryCache object, and executing corresponding operation according to a monitoring result. By the mode, the business data is cached and monitored uniformly, so that operation can be executed in real time according to the change of the cached data, and the user experience is improved.
Description
Technical Field
The present invention relates to the field of cache technologies, and in particular, to a cache processing method, a terminal, and a computer storage medium.
Background
In the prior art, some service data acquired by an APP terminal from a cloud terminal need to be temporarily cached, and the inside of a program lacks management on the validity of the cached data. In addition, when the cached data changes, the terminal cannot respond to the change of the data in time after the cached data is updated due to lack of a monitoring function, so that delay occurs and user experience is affected.
Disclosure of Invention
The invention aims to provide a cache processing method, a terminal and a computer storage medium, which are used for uniformly caching and monitoring business data and realizing timely refreshing of cache data.
In order to solve the above technical problem, the present application provides a cache processing method, applied to a terminal, including:
creating a memory cache object, and writing the data to be cached into the memory cache object to form cache data;
and monitoring cache data in the memory cache object, and executing corresponding operation according to a monitoring result.
The creating a MemoryCache object and writing the data to be cached into the MemoryCache object to form cache data includes:
creating a MemoryCache object when the application is started;
opening a preset interface of the memory cache object;
and adding a pair of key-value data in a memory mapping table to store the cache data, wherein the key-value data comprises a cache data type and cache data contents.
The preset interface of the MemoryCache object comprises initValue, setValue, getValue, addListener and removeListener.
Wherein the monitoring data in the MemoryCache object includes:
creating a ValueNotifier object;
and binding the MemoryCache object and the ValueNotifier object by calling the addListener interface so as to monitor the cache data.
Wherein, the executing the corresponding operation according to the monitoring result notification comprises:
and when the ValueNotifier object monitors that the cache data in the MemoryCache object changes, informing a monitoring function to update the data so as to refresh the display data of the terminal interface.
Wherein the monitoring data in the MemoryCache object further comprises:
and calling the removeListener interface to remove the monitoring of the cache data in the MemoryCache object.
Wherein, after adding a pair of key-value data to store the cache data in the memory mapping table, the method further comprises:
when the cache data comprises persistent storage, converting the cache data content into a json character string;
and storing the json character string into a local memory through SharedPreferences.
Before writing the data to be cached into the MemoryCache object, the method further includes:
and acquiring data to be cached acquired through network access and/or generated by project service.
The present application further provides a terminal, including:
at least one processor;
at least one memory coupled to the at least one processor and storing instructions for execution by the at least one processor, the instructions when executed by the at least one processor causing the apparatus to perform a cache processing method as described above.
The present application further provides a computer storage medium having computer program instructions stored thereon; which when executed by a processor implement a cache processing method as described above.
The application relates to a cache processing method, a terminal and a computer storage medium, wherein the cache processing method comprises the following steps: creating a MemoryCache object, and writing data to be cached into the MemoryCache object to form cached data; and monitoring cache data in the MemoryCache object, and executing corresponding operation according to a monitoring result. By the mode, the business data is cached and monitored uniformly, so that operation can be executed in real time according to the change of the cached data, and the user experience is improved.
The foregoing description is only an overview of the technical solutions of the present application, and in order to make the technical means of the present application more clearly understood, the present application may be implemented in accordance with the content of the description, and in order to make the above and other objects, features, and advantages of the present application more clearly understood, the following preferred embodiments are described in detail with reference to the accompanying drawings.
Drawings
Fig. 1 is an application environment diagram illustrating a cache processing method according to an embodiment of the present invention;
fig. 2 is a flowchart illustrating a cache processing method according to an embodiment of the present invention;
FIG. 3 is a class diagram illustrating a cache processing method according to an embodiment of the invention;
fig. 4 is a specific flowchart of a cache processing method according to an embodiment of the present invention;
fig. 5 is one of the structural diagrams of the terminal shown according to the embodiment of the present invention;
fig. 6 is a second schematic structural diagram of the terminal shown in fig. 5.
Detailed Description
The following description of the embodiments of the present application is provided for illustrative purposes, and other advantages and capabilities of the present application will become apparent to those skilled in the art from the present disclosure.
In the following description, reference is made to the accompanying drawings that describe several embodiments of the application. It is to be understood that other embodiments may be utilized and that mechanical, structural, electrical, and operational changes may be made without departing from the spirit and scope of the present application. The following detailed description is not to be taken in a limiting sense, and the scope of embodiments of the present application is defined only by the claims of the issued patent. The terminology used herein is for the purpose of describing particular embodiments only and is not intended to be limiting of the application.
Although the terms first, second, etc. may be used herein to describe various elements in some instances, these elements should not be limited by these terms. These terms are only used to distinguish one element from another.
Also, as used herein, the singular forms "a", "an" and "the" are intended to include the plural forms as well, unless the context indicates otherwise. It will be further understood that the terms "comprises," "comprising," "includes" and/or "including," when used in this specification, specify the presence of stated features, steps, operations, elements, components, items, species, and/or groups, but do not preclude the presence, or addition of one or more other features, steps, operations, elements, components, species, and/or groups thereof. The terms "or" and/or "as used herein are to be construed as inclusive or meaning any one or any combination. Thus, "A, B or C" or "A, B and/or C" means "any of the following: a; b; c; a and B; a and C; b and C; A. b and C ". An exception to this definition will occur only when a combination of elements, functions, steps or operations are inherently mutually exclusive in some way.
Fig. 1 is a schematic application environment diagram of the cache processing method according to the embodiment of the present invention, and includes a terminal 11 and a cloud server 12. It should be understood that the number of terminals 11 and cloud servers 12 in fig. 1 and installation positions thereof are merely illustrative. There may be any number of terminals 11 and cloud servers 12 associated, as desired for implementation. Data communication is possible between the terminal 11 and the cloud server 12. After the terminal 11 acquires the service data to be cached from the cloud server 12, the MemoryCache object is created for storage, monitoring and observation are implemented, the cached data is updated in time, the situations of interface data error and slow update caused by untimely data synchronization are avoided, and the user experience is improved.
Fig. 2 is a flowchart illustrating a cache processing method according to an embodiment of the present invention. As shown in fig. 2, a cache processing method provided in an embodiment of the present invention includes:
step 201: creating a MemoryCache object, and writing data to be cached into the MemoryCache object to form cached data;
step 202: and monitoring cache data in the MemoryCache object, and executing corresponding operation according to a monitoring result.
Some data in the project need to be cached uniformly, which is generally data to be cached generated through network access and/or project services, such as token, user information, device information, service data, and the like, and meanwhile, memory caching, persistent caching, and observation need to be supported, so that the user experience of the APP is smoother. For the current situation, the embodiment creates a MemoryCache object when the application is started, and opens a preset interface of the MemoryCache object. And after the data to be cached is obtained, writing the data to be cached into the MemoryCache object to form cached data. And adding a pair of key-value data storage cache data in the memory mapping table, wherein the key-value data comprises cache data types and cache data contents.
The memory Cache class provided by the Net Framework 4.0 can be used for conveniently caching data in a program and conveniently managing the validity of the data, and similar functions of the Cache class commonly used in ASP. The preset interfaces of the MemoryCache objects comprise initValue, setValue, getValue, addListener and removeListener. And creating a single-case MemoryCache object when the application is started, and opening interfaces of initValue, setValue, getValue, addListener, removeListener and the like for service use. When the network layer obtains data, the network layer writes the data through setValue of the MemoryCache, and the MemoryCache adds a pair of (key, value) data in the memory mapping table to store the cache data, where the key is the type of the data, and the value is any object, such as the content of the cache data. If persistent storage is required, value is encoded as a json string written to local storage.
Meanwhile, the terminal page monitors data change through addListener so as to refresh the display data of the terminal interface in time. For example, the Token is a string of character strings generated by the server, and is used as a Token requested by the client, after the server logs in for the first time, the server generates a Token and returns the Token to the client, and the client only needs to take the Token to request data before later, and does not need to take the user name and the password again. When a user inputs login information on a terminal interface, token data is cached into a MemoryCache object, meanwhile, the MemoryCache object binds the cached data to a ValueNotifier object through an addListener interface, and when the login information of the user is modified, the ValueNotifier monitors the change and informs a monitoring program to update corresponding modified data in time, so that the corresponding data of the terminal interface is updated in time, and the influence of delayed updating of the data on user experience is avoided.
Fig. 3 is a class diagram illustrating a cache processing method according to an embodiment of the present invention. As shown in FIG. 3, the static structure of the data model of the present embodiment is shown, including the classes present in the model, the internal structure of the classes, and their relationships to other classes. The MemoryCache object opens five interfaces initValue < T > (), setValue < T > (), getValue < T > (), addListener < T > (), and removelListener < T > (). The memory cache object is bound with the ValueNotifier, and cache data is monitored by creating a ValueNotifier object. In addition, when the cache data in the MemoryCache object needs to be stored persistently, the cache data content is stored to the local memory through SharedPreferences.
The memory cache provides a data storage mechanism with a time complexity of O (1). Time complexity refers to the computational effort required to execute an algorithm. The temporal complexity is often expressed in terms of large O symbols, excluding the low order terms and leading coefficients of this function. Using this approach, the temporal complexity can be said to be asymptotic, which looks at the situation when the input value size approaches infinity. In this embodiment, the memory cache is used to cache the service data, so that the problem of user experience caused by network requests can be reduced, the stored data can be observed, and the requirement that the display of each page is kept synchronous when the data changes can be met.
In one embodiment, data delivery and state management is implemented on the cached data by the ValueNotifier. ValueNotifier inherits to ChangeNotifier and can register a listening event. ValueNotifier contains a value that when changed sends the snoop result to the listener. The snoop function finds that the value changes, which is equivalent to calling the set method, will notifyListeners snoop the data in the MemoryCache object. During implementation, a ValueNotifier object is created, monitoring of data change is added and cancelled respectively at initState and dispose, a button is clicked to modify a value in the ValueNotifier, a monitoring function is called back to update, and refreshing reconstruction of an interface is completed. And then binding the MemoryCache object with the ValueNotifier object by calling an addListener interface so as to monitor the cache data. And then, executing corresponding operation according to the monitoring result notice. And when the ValueNotifier object monitors the data change in the MemoryCache object, informing a monitoring function to update the data so as to refresh the display data of the terminal interface. Furthermore, snoops on cached data in the MemoryCache object may also be removed by calling a removeListener interface.
In one embodiment, the MemoryCache object adds a pair of key-value data in the memory mapping table, that is, a key (value) stores cache data, the key is a type of the data, and the value is an arbitrary object, such as cache data content. And when the cache data comprises the parameters needing to be stored persistently, converting the cache data content into json character strings, and storing the json character strings to a local memory through SharedPreferences. In Android development, it is often necessary to save a small amount of simple type data locally, as set by the user. The data to be saved may only have one or two character strings, and the lightweight data is generally selected to be saved by using SharedPreferences. The SharedPreferences is a lightweight storage class provided by an Android platform and is suitable for storing software configuration parameters. Data is generally stored in an xml file, and the file is stored in a/data/data/< package name >/shared _ prefs directory. Simple configuration parameters are stored in Map form. Sharedreferences are essentially xml files that hold data in "key-value" pairs, with the advantage of not creating Application, static variable OOM (out of memory), and null pointer problems.
Fig. 4 is a specific flowchart illustrating a cache processing method according to an embodiment of the present invention. As shown in fig. 4, when App starts, a single-case MemoryCache instance is generated and initialized: MemoryCache mem ═ MemoryCache.
When caching api network access switches to data or service generated data, such as caching wallettinfomodel:
mem.setValue<WalletInfoModel>(walletInfo)；
listening for changes to the WallletInfoModel:
mem.addListener<WalletInfoModel>((){
//do something
})；
in the UI page, the change of walletlnfo model is monitored by using the method of mem. For example, when other applications call a wallet application to pay, the MemoryCache object created by the terminal uses an addListener interface to bind to a ValueNotifier object to realize data monitoring and observation of a service interface. When the payment operation is completed, the balance of the wallet application changes, the ValueNotifier monitors the data change, and the monitoring function is informed in time to refresh the balance interface of the wallet application through the setValue and getValue interfaces. When snooping is not required, the MemoryCache object uses the removeListener interface to relieve snooping. The embodiment can be implemented in the development environment of the flutter framework, and in other embodiments, the working mechanism can also be implemented in android and ios through different development languages, which are all within the protection scope of the present application.
The cache processing method of the embodiment is applied to a terminal, and comprises the following steps: creating a MemoryCache object, and writing data to be cached into the MemoryCache object to form cached data; and monitoring cache data in the MemoryCache object, and executing corresponding operation according to a monitoring result. By the mode, the business data is cached and monitored uniformly, so that operation can be executed in real time according to the change of the cached data, and the user experience is improved.
As shown in fig. 5, the present application also provides a terminal 10, including: at least one processor 106 and at least one memory 102, the memory 102 storing a computer program, when the processor 106 runs the computer program, the above-mentioned cache processing method is realized.
The processor 106 of this embodiment executes the specific process of the above steps, which is described in detail in the related description of the embodiment of the cache processing method and is not described herein again.
Referring to fig. 6, in actual implementation, the terminal 10 includes a memory 102, a memory controller 104, one or more processors 106 (only one of which is shown), a peripheral interface 108, a radio frequency module 150, a positioning module 112, a camera module 114, an audio module 116, a screen 118, and a key module 160. These components communicate with each other via one or more communication buses/signal lines 122.
It will be appreciated that the configuration shown in FIG. 6 is merely exemplary, and that terminal 10 may include more or fewer components than shown in FIG. 6, or may have a different configuration than shown in FIG. 6. The components shown in fig. 6 may be implemented in hardware, software, or a combination thereof.
The memory 102 may be used to store software programs and modules, such as program instructions/modules corresponding to the cache processing method in the embodiment of the present application, and the processor 106 executes various functional applications and data processing by running the software programs and modules stored in the storage controller 104, so as to implement the above cache processing method.
The memory 102 may include high speed random access memory, and may also include non-volatile memory, such as one or more magnetic storage devices, flash memory, or other non-volatile solid-state memory. In some examples, the memory 102 may further include memory located remotely from the processor 106, which may be connected to the terminal 10 via a network. Examples of such networks include, but are not limited to, the internet, intranets, local area networks, mobile communication networks, and combinations thereof. Access to the memory 102 by the processor 106, and possibly other components, may be under the control of the memory controller 104.
In some embodiments, the peripheral interface 108, the processor 106, and the memory controller 104 may be implemented in a single chip. In other examples, they may be implemented separately from the individual chips.
The rf module 150 is used for receiving and transmitting electromagnetic waves, and implementing interconversion between the electromagnetic waves and electrical signals, so as to communicate with a communication network or other devices. Rf module 150 may include various existing circuit elements for performing these functions, such as an antenna, a radio frequency transceiver, a digital signal processor, an encryption/decryption chip, a Subscriber Identity Module (SIM) card, memory, and so forth. The rf module 150 may communicate with various networks such as the internet, an intranet, a wireless network, or with other devices via a wireless network. The positioning module 112 is used for acquiring the current position of the terminal 10. Examples of the positioning module 112 include, but are not limited to, a global positioning satellite system (GPS), a wireless local area network-based positioning technology, or a mobile communication network-based positioning technology.
The camera module 114 is used to take a picture or video. The pictures or videos taken may be stored in the memory 102 and transmitted through the radio frequency module 150.
The screen 118 provides an output interface between the terminal 10 and the user. In particular, screen 118 displays video output to the user, the content of which may include text, graphics, video, and any combination thereof. Some of the output results are for some of the user interface objects. It is understood that the screen 118 may also include a touch screen. The touch screen provides both an output and an input interface between the terminal 10 and a user. In addition to displaying video output to users, touch screens also receive user input, such as user clicks, swipes, and other gesture operations, so that user interface objects respond to these user input. The technique of detecting user input may be based on resistive, capacitive, or any other possible touch detection technique. Specific examples of touch screen display units include, but are not limited to, liquid crystal displays or light emitting polymer displays.
The key module 160 also provides an interface for user input to the terminal 10, and the user can press different keys to cause the terminal 10 to perform different functions.
The present application further provides a computer storage medium having computer program instructions stored thereon; the computer program instructions, when executed by the processor, implement the cache processing method as described in the above embodiments.
In practical implementation, the computer storage medium is applied to the terminal shown in fig. 5 or fig. 6, so that intelligent monitoring is realized.
The above embodiments are merely illustrative of the principles and utilities of the present application and are not intended to limit the application. Any person skilled in the art can modify or change the above-described embodiments without departing from the spirit and scope of the present application. Accordingly, it is intended that all equivalent modifications or changes which can be made by those skilled in the art without departing from the spirit and technical concepts disclosed in the present application shall be covered by the claims of the present application.
Claims (10)
1. A cache processing method is applied to a terminal, and is characterized by comprising the following steps:
creating a memory cache object, and writing data to be cached into the memory cache object to form cache data;
and monitoring cache data in the memory cache object, and executing corresponding operation according to a monitoring result.
2. The cache processing method according to claim 1, wherein the creating a MemoryCache object, writing data to be cached in the MemoryCache object, and forming cache data includes:
creating a MemoryCache object when the application is started;
opening a preset interface of the memory cache object;
adding a pair of key-value data in a memory mapping table to store the cache data, wherein the key-value data comprises a cache data type and cache data contents.
3. The cache processing method according to claim 2, wherein the predetermined interface of the MemoryCache object comprises initValue, setValue, getValue, addListener, removeListener.
4. The cache processing method according to claim 3, wherein the snooping data in the MemoryCache object comprises:
creating a ValueNotifier object;
and binding the MemoryCache object and the ValueNotifier object by calling the addListener interface so as to monitor the cache data.
5. The cache processing method according to claim 4, wherein the performing the corresponding operation according to the snoop result notification includes:
and when the ValueNotifier object monitors that the cache data in the MemoryCache object changes, informing a monitoring function to update the data so as to refresh the display data of the terminal interface.
6. The cache processing method of claim 4, wherein the snooping data in the MemoryCache object further comprises:
and calling the removeListener interface to remove the monitoring of the cache data in the MemoryCache object.
7. The cache processing method according to claim 2, wherein after adding a pair of key-value data in the memory mapping table to store the cache data, further comprising:
when the cache data need to be stored persistently, converting the cache data content into a json character string;
and storing the json character string into a local memory through SharedPreferences.
8. The cache processing method according to claim 1, wherein before writing the data to be cached in the MemoryCache object, the method further comprises:
and acquiring data to be cached acquired through network access and/or generated by project service.
9. A terminal, comprising:
at least one processor;
at least one memory coupled to the at least one processor and storing instructions for execution by the at least one processor, the instructions when executed by the at least one processor causing the apparatus to perform the cache processing method of any of claims 1 to 8.
10. A computer storage medium having computer program instructions stored thereon; the computer program instructions, when executed by a processor, implement a cache processing method as claimed in any one of claims 1 to 8.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011138207.7A CN112199398A (en) | 2020-10-22 | 2020-10-22 | Cache processing method, terminal and computer storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011138207.7A CN112199398A (en) | 2020-10-22 | 2020-10-22 | Cache processing method, terminal and computer storage medium |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN112199398A true CN112199398A (en) | 2021-01-08 |
Family
ID=74010813
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202011138207.7A Pending CN112199398A (en) | 2020-10-22 | 2020-10-22 | Cache processing method, terminal and computer storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN112199398A (en) |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN102073494A (en) * | 2010-12-30 | 2011-05-25 | 用友软件股份有限公司 | Method and device for managing cache data |
| CN107038222A (en) * | 2017-03-24 | 2017-08-11 | 福建天泉教育科技有限公司 | Database caches implementation method and its system |
| CN107103068A (en) * | 2017-04-18 | 2017-08-29 | 聚好看科技股份有限公司 | The update method and device of service buffer |
-
2020
- 2020-10-22 CN CN202011138207.7A patent/CN112199398A/en active Pending
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN102073494A (en) * | 2010-12-30 | 2011-05-25 | 用友软件股份有限公司 | Method and device for managing cache data |
| CN107038222A (en) * | 2017-03-24 | 2017-08-11 | 福建天泉教育科技有限公司 | Database caches implementation method and its system |
| CN107103068A (en) * | 2017-04-18 | 2017-08-29 | 聚好看科技股份有限公司 | The update method and device of service buffer |
Non-Patent Citations (1)
| Title |
|---|
| 徐宜生: "FlutterDojo设计之道—状态管理之路（一）", Retrieved from the Internet <URL:https://mp.weixin.qq.com/s/HVjPXgoJFXOqBSYlbbZk7w> * |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US20200258133A1 (en) | Installable web applications | |
| WO2014116563A1 (en) | Resource calling for hybrid applications | |
| CN109040339B (en) | Cross-domain request processing method, device and equipment based on AJAX | |
| CN111459364B (en) | Icon updating method and device and electronic equipment | |
| CN112256231B (en) | Volume control method, device, terminal and storage medium | |
| US12056095B2 (en) | Host-level persistent volume management for container clouds | |
| KR20150075140A (en) | Message control method of electronic apparatus and electronic apparatus thereof | |
| CN112261047A (en) | Gateway access method, mobile terminal and computer storage medium | |
| CN113220366A (en) | Sub-application starting method and device, terminal and server | |
| CN112269959A (en) | Display content control method and device, readable medium and electronic equipment | |
| CN114528517A (en) | View processing method and device, electronic equipment and computer readable medium | |
| CN112306524A (en) | System upgrading method, electronic device and computer storage medium | |
| CN115470432A (en) | Page rendering method and device, electronic equipment and computer readable medium | |
| CN113377647B (en) | Page processing method, device, server, terminal and readable storage medium | |
| CN110995842A (en) | Method, device and equipment for downloading service data and storage medium | |
| US9288189B2 (en) | Retrieving both sensitive and non-sensitive content in a secure manner | |
| CN112199398A (en) | Cache processing method, terminal and computer storage medium | |
| CN114327453B (en) | Page display method, device, equipment and storage medium | |
| EP3853725A1 (en) | Connected application experience | |
| CN111324386B (en) | Method and device for starting split application program, electronic equipment and storage medium | |
| CN110086880B (en) | Method and apparatus for creating instances of network requests | |
| EP4028909A1 (en) | Method and system of re-associating location mappings for uniform resource identifier named objects | |
| CN112148417A (en) | Page adjusting method and device, electronic equipment and computer readable medium | |
| CN112163176A (en) | Data storage method and device, electronic equipment and computer readable medium | |
| CN113742617A (en) | Cache updating method and device |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| WD01 | Invention patent application deemed withdrawn after publication | ||
| WD01 | Invention patent application deemed withdrawn after publication |
Application publication date: 20210108 |