Page rendering methods, electronic devices, storage media and program products
By employing a multi-level caching mechanism in web pages, combined with server-side and client-side browser caching, and generating signaling to acquire and render page elements based on network conditions, the display problem of web pages under different network environments is solved, improving stability and real-time performance, and enhancing user experience.
Patent Information
- Application Number
- CN202510635348.6
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2025-05-16
- Publication Date
- 2026-11-17
AI Technical Summary
During the use of web pages, existing technologies are unable to effectively adapt to the updating and display of page elements under different network conditions, resulting in a poor user experience, especially in the case of weak or no network conditions, which may lead to problems such as blank screens or delayed page updates.
A multi-level caching mechanism is adopted, combining server-side caching and client-side browser caching. Signaling is generated based on the current network conditions to indicate how to retrieve updated custom page elements. Page elements are retrieved from the multi-level cache and rendered through scene flags.
It improves the stability and real-time performance of web pages under different network conditions, avoids white screen phenomena and page update delays, and improves user experience.
Smart Images

Figure CN123115545A_ABST
Abstract
Description
Technical Field
[0001] This application relates to the field of computer technology, and in particular to a page rendering method, electronic device, storage medium, and computer program product. Background Technology
[0002] During webpage usage, there is often a need to update the settings of page elements. When a client displays a webpage, it typically faces various network conditions, such as normal network, weak network, or no network. Therefore, to improve the display effect of updated page elements, providing a webpage rendering method that can better adapt to different network conditions has become an urgent technical problem to be solved. Summary of the Invention
[0003] In view of this, embodiments of this application provide a page rendering scheme to at least partially solve the above-mentioned problems.
[0004] According to a first aspect of the embodiments of this application, a page rendering method is provided, comprising: receiving a rendering instruction for a webpage, wherein the webpage includes custom page elements, and the custom page elements have been updated within a preset time period from the current time; generating signaling for instructing the acquisition of the updated custom page elements based on the rendering instruction and the current network conditions corresponding to the client executing the rendering instruction, wherein the signaling carries a scene flag, the scene flag indicating a method for acquiring the updated custom page elements based on a preset multi-level cache, the multi-level cache including at least a server-side cache and a client-side browser cache; acquiring the custom page elements from the multi-level cache according to the method indicated by the scene flag, and performing page rendering based on the acquired custom page elements.
[0005] According to a second aspect of the embodiments of this application, an electronic device is provided, including: a processor, a communication interface, a memory, and a communication bus, wherein the processor, the communication interface, and the memory communicate with each other through the communication bus; the memory is used to store a computer program; and the processor is used to execute the page rendering method described in the first aspect by running the computer program stored in the memory.
[0006] According to a third aspect of the embodiments of this application, a computer storage medium is provided, on which a computer program is stored, which, when executed by a processor, implements the page rendering method as described in the first aspect.
[0007] According to a fourth aspect of the embodiments of this application, a computer program product is provided, including a computer program that, when executed by a processor, implements the page rendering method as described in the first aspect.
[0008] According to the page rendering scheme provided in this application embodiment, on the one hand, since a rendering instruction for a webpage can be received, and the custom page element includes a custom page element that has been updated within a preset time period from the current time, a signaling is generated to indicate the acquisition of the updated custom page element based on the rendering instruction and the current network conditions corresponding to the client executing the rendering instruction. This signaling carries a scene flag indicating the method of acquiring the updated custom page element based on a preset multi-level cache. The multi-level cache includes at least a server-side cache and a client-side browser cache. The custom page element is then obtained from the multi-level cache according to the method indicated by the scene flag, and page rendering is performed based on the acquired custom page element. Therefore, this scheme can generate signaling based on the client's current network conditions, so that the custom page element can be reasonably acquired based on the scene flag in the signaling, and page rendering can be performed reasonably. This allows it to adapt to the needs of webpages with updated page elements, acquiring custom page elements, and performing page rendering under different network conditions. On the one hand, this solution employs multi-level caching to cache custom page elements, and this multi-level caching is implemented using a combination of server-side caching and client-side browser caching. Compared to using client-side browser caching alone, this results in better system stability. In high-traffic, high-concurrency scenarios with frequent webpage element settings, it effectively improves webpage rendering to achieve stability and real-time updates of page elements. Furthermore, by combining multi-level caching and using scenario markers generated from signaling based on the current network conditions, this solution rationally retrieves custom page elements from the multi-level cache for page rendering. This helps avoid the problem of webpages failing to display correctly in weak or no network conditions when only server-side caching is used, potentially resulting in a blank screen and poor user experience. It also helps avoid the problem of delayed client-side browser cache updates in weak or no network conditions when only client-side browser caching is used, which might require multiple page refreshes to see the latest page settings, thus effectively improving the flexibility of page rendering. Therefore, the technical solution in this application embodiment can effectively improve the display effect of updated page elements, better adapt to webpage rendering under different network conditions, and improve the user's webpage experience. Attached Figure Description
[0009] To more clearly illustrate the technical solutions in the embodiments of this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments recorded in the embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings.
[0010] Figure 1 This is a schematic diagram of a page rendering system according to an embodiment of this application.
[0011] Figure 2 This is a flowchart of a page rendering method according to an embodiment of this application.
[0012] Figure 3 This is a flowchart illustrating an optional method for rendering a page based on a time stamp, as described in an embodiment of this application.
[0013] Figure 4 This is a schematic diagram of an optional data flow in an embodiment of this application.
[0014] Figures 5A to 5D This paper illustrates an example application scenario where the page rendering scheme in the embodiments of this application is applicable.
[0015] Figure 6 A schematic diagram of an optional data flow for a page rendering scheme in an embodiment of this application is shown.
[0016] Figure 7 This is a schematic diagram of the structure of an electronic device according to an embodiment of this application. Detailed Implementation
[0017] To enable those skilled in the art to better understand the technical solutions in the embodiments of this application, the technical solutions in the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, and not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art should fall within the protection scope of the embodiments of this application.
[0018] The specific implementation of the embodiments of this application will be further described below with reference to the accompanying drawings.
[0019] Figure 1 An exemplary system applicable to embodiments of this application is shown. For example... Figure 1 As shown, the system 100 may include a cloud server 102, a communication network 104, and / or one or more user devices 106. Figure 1 The example in the text is 106 user devices.
[0020] The cloud server 102 can be any suitable device for storing information, data, programs, and / or any other suitable type of content, including but not limited to distributed storage system devices, server clusters, computing cloud server clusters, etc. In some embodiments, the cloud server 102 may include a server-side cache to cache custom page elements. In some embodiments, the cloud server 102 may provide interface services, and the user device 106 (which may be a client) may call the server-side interface to request data from the cloud server 102. In some embodiments, the cloud server 102 may perform any appropriate functions as determined by those skilled in the art.
[0021] In some embodiments, the communication network 104 can be any suitable combination of one or more wired and / or wireless networks. For example, the communication network 104 can include any one or more of the following: the Internet, an intranet, a wide area network (WAN), a local area network (LAN), a wireless network, a digital subscriber line (DSL) network, a frame relay network, an asynchronous transfer mode (ATM) network, a virtual private network (VPN), and / or any other suitable communication network. The user equipment 106 can be connected to the communication network 104 via one or more communication links (e.g., communication link 112), and the communication network 104 can be linked to the cloud server 102 via one or more communication links (e.g., communication link 114). The communication link can be any communication link suitable for transmitting data between the user equipment 106 and the cloud server 102, such as a network link, a dial-up link, a wireless link, a hardwired link, any other suitable communication link, or any suitable combination of such links.
[0022] User device 106 may include any one or more user devices suitable for displaying information, interacting with users, etc. In some embodiments, user device 106 may include any suitable type of device. For example, in some embodiments, user device 106 may include mobile devices, tablet computers, laptop computers, desktop computers, and / or any other suitable type of user device.
[0023] Optionally, when the user equipment 106 implements the scheme of the embodiments of this application, in some embodiments, the user equipment 106 can be used to execute a page rendering method. Optionally, the user equipment 106 can be a client, which can be equipped with a client browser and be able to display web pages. As an optional example, in some embodiments, the user equipment 106 can first receive a rendering instruction for a web page, wherein the web page includes custom page elements, and the custom page elements have been updated within a preset time period from the current time; then, according to the rendering instruction and the current network conditions corresponding to the client executing the rendering instruction, a signaling is generated to indicate the acquisition of the updated custom page elements, wherein the signaling carries a scene flag, the scene flag is used to indicate the method of acquiring the updated custom page elements based on a preset multi-level cache, the multi-level cache including at least a server cache and a client browser cache; then, according to the method indicated by the scene flag, the custom page elements are obtained from the multi-level cache, and page rendering is performed based on the acquired custom page elements.
[0024] However, it should be noted that the solutions in this application embodiment can also be implemented entirely by the cloud server 102, or, as mentioned above, by the cloud server 102 in conjunction with the user equipment 106.
[0025] Based on the above system, this application provides a page rendering scheme, which will be described below through several embodiments.
[0026] Figure 2 This is a flowchart illustrating the steps of a page rendering method according to an embodiment of this application. According to a first aspect of an embodiment of this application, a page rendering method is provided, referring to... Figure 2 As shown, the method includes steps S202, S204, and S206, specifically:
[0027] S202: Received rendering instruction for the webpage.
[0028] In this embodiment of the application, the web page includes custom page elements, and the custom page elements have been updated within a preset time period from the current time.
[0029] Custom page elements can be any type of page element on a webpage. Examples include, but are not limited to, text elements, icon elements, button elements, and navigation items. This application does not limit the position of custom page elements on the webpage. In some embodiments, it can be a single custom page element, or it can be one or more custom page elements within a component of the webpage.
[0030] For example, in some optional embodiments, the custom page element can be a navigation item for a webpage. Subsequent steps in this embodiment can be based on the obtained custom page element to perform page rendering, thereby updating the navigation item displayed on the webpage.
[0031] It should be understood that for various web pages, their navigation items are often subject to high traffic and high concurrency scenarios that require frequent customization. It is often necessary to customize the page elements to meet the update requirements of the navigation items. The page rendering scheme in this application embodiment can effectively improve the rendering of web pages to achieve the timeliness and stability of navigation item update settings, and can effectively realize the updated display of navigation items on web pages.
[0032] For example, navigation items can be navigation items for any application scenario. In some embodiments, navigation items can be navigation items for web pages used for office automation (OA) approvals.
[0033] For example, a webpage for office automation approvals can offer the ability to customize navigation items. For instance, it could provide an administrative backend for customizing navigation items, allowing access to settings data used for customization, and then allowing for further customization of the navigation items based on that data. Some optional customization options could include: setting arbitrary text for navigation items, setting the visibility of navigation items, setting the icon style of navigation items, setting the visibility range of navigation items (e.g., visible to all, visible to select users), etc. (This can also be combined with...) Figure 5B and Figure 5C (For reference, see the example below). There are other possible settings, but we will not limit ourselves to only one.
[0034] In this embodiment, the preset time period can be selected as needed, for example, it can be 5 seconds, 10 seconds, 30 seconds, 1 minute, 2 minutes, 5 minutes, 10 minutes, etc. There is no specific limitation here, as long as it can meet the needs of page element update settings.
[0035] S204: Generate a signaling message to indicate the acquisition of custom page elements after updating settings, based on the rendering instruction and the current network conditions corresponding to the client executing the rendering instruction.
[0036] In this embodiment of the application, the signaling carries a scene flag, which is used to indicate the method of obtaining the updated custom page elements based on the preset multi-level cache. The multi-level cache includes at least the server-side cache and the client-side browser cache.
[0037] In this embodiment, a multi-level cache is set up to facilitate the retrieval of information about custom page elements. This multi-level cache includes at least a server-side cache and a client-side browser cache. The server-side cache can be a cache set on the server, while the client-side browser cache can be a cache set locally on the client browser.
[0038] Furthermore, in this embodiment, to adapt to various network conditions, a protocol mechanism is established for retrieving updated custom page elements. This mechanism generates signaling to retrieve updated custom page elements based on the rendering instruction for the webpage and the current network conditions of the client executing the rendering instruction (i.e., the client displaying the webpage). Then, the custom page elements can be effectively retrieved from a multi-level cache according to the method indicated by the scene flag carried in the signaling, facilitating the rendering and display of the webpage.
[0039] It should be noted that the specific style of the scene flag is not limited in the embodiments of this application; it can be implemented as text, symbols, etc. in the signaling. In addition to the scene flag, the signaling may also include other data and may carry other types of flags. For example, optionally, the signaling may also carry a version flag (described below), which can be used to indicate the version information of the latest custom page element in the client browser cache. It should be understood that the version information indicated by the version flag facilitates subsequent steps in retrieving the latest custom page element from multi-level caches, thereby enabling proper page rendering.
[0040] In this application embodiment, the scene marker may include one or more. For example, in some optional embodiments, the scene marker includes at least one of a first scene marker, a second scene marker, a third scene marker, and a fourth scene marker.
[0041] Optionally, the first scene flag can be used to indicate that custom page elements cached by the client browser should be used for page rendering first.
[0042] It should be understood that if the scene flag includes the first scene flag, then the custom elements cached by the client browser can be used first for page rendering to ensure that the webpage can be effectively rendered under various conditions, including but not limited to normal network, weak network, and no network, thus avoiding the webpage failing to display correctly. Optionally, the first scene flag has a wide range of applications and can be applied to almost all usage scenarios.
[0043] Understandably, if the scene flags include the first scene flag, since it prioritizes using custom page elements cached by the client browser, in some cases, server-cached custom page elements can also be used to better meet rendering and display needs under different network environments. The optional content related to the first scene flag will be explained further below and will not be elaborated upon here.
[0044] Optionally, the second scene flag can be used to indicate that the custom page elements returned by the server should be used for page rendering first.
[0045] It should be understood that if the scene flag includes the second scene flag, the custom element returned by the server can be used first for page rendering (that is, the data cached by the server can be used first) to ensure that the webpage can be effectively rendered under various conditions, including but not limited to normal network, weak network, and no network, thus avoiding the webpage failing to display correctly. Optionally, the second scene flag has a wide range of applications and can be applied to almost all usage scenarios.
[0046] Understandably, if the scene flag includes a second scene flag, since the custom page element returned by the server is preferred, in some cases the custom page element cached by the client browser can also be used to better meet the rendering and display needs under different network environments. The optional content regarding the second scene flag will be explained further below and will not be elaborated upon here.
[0047] Optionally, the third scene flag can be used to indicate waiting for the server's response before obtaining the custom page elements for page rendering.
[0048] It should be understood that if the scene flags include the third scene flag, the custom page elements can be obtained and rendered only after waiting for the server's response. This ensures that the webpage can be effectively rendered under various conditions, including but not limited to normal network, weak network, and no network, thus preventing the webpage from failing to display correctly. Optionally, the third scene flags can be applied to scenarios such as page refresh.
[0049] Understandably, if the scene flag includes a third scene flag, since the server-side response is prioritized before obtaining the custom page elements, in some cases the server-cached custom page elements can be used, while in other cases the client-side browser-cached custom page elements can be used to better meet the rendering and display needs under different network environments. The optional aspects of the third scene flag will be explained further below and will not be elaborated upon here.
[0050] Optionally, the fourth scene flag can be used to indicate that only the custom page elements returned by the server are used for page rendering.
[0051] It should be understood that if the scene flag includes the fourth scene flag, then only the custom page elements cached on the server are used for page rendering, and it is no longer necessary to retrieve data from the client browser cache, so as to ensure that the rendered web page displays the latest custom page elements.
[0052] Optionally, the fourth scene marker can be applied to various real-time scenarios, such as previewing edited page elements. Further details regarding the optional aspects of the fourth scene marker will be provided below and will not be elaborated upon here.
[0053] It is understood that the signaling generated in the embodiments of this application includes at least one of the above scenario flags, which can flexibly and effectively adapt to the needs of retrieving custom page elements from multi-level cache and rendering pages when page elements of web pages are updated under different network conditions.
[0054] S206: Retrieve custom page elements from the multi-level cache as indicated by the scene flag, and render the page based on the retrieved custom page elements.
[0055] It can identify the scene flags of the generated signaling, obtain custom page elements from a multi-level cache including at least server-side cache and client-side browser cache in accordance with the method indicated by the scene flags, and render the web page based on the obtained custom page elements to display the rendered web page.
[0056] It should be understood that any suitable page rendering algorithm can be used for rendering based on custom page elements, and no restrictions are imposed here.
[0057] Based on this, in the embodiments of this application, through the optional implementation of steps S202 to S206 above, on the one hand, since a rendering instruction for a webpage can be received, and the custom page element includes a custom page element that has been updated within a preset time period from the current time, and based on the rendering instruction and the current network conditions corresponding to the client executing the rendering instruction, a signaling is generated to indicate the acquisition of the updated custom page element. This signaling carries a scene flag indicating the method of acquiring the updated custom page element based on a preset multi-level cache. The multi-level cache includes at least a server-side cache and a client-side browser cache. Then, according to the method indicated by the scene flag, the custom page element is obtained from the multi-level cache, and page rendering is performed based on the acquired custom page element. Therefore, this solution can generate signaling based on the client's current network conditions, so that the custom page element can be reasonably acquired based on the scene flag in the signaling, and page rendering can be performed reasonably. This allows it to adapt to the updated page elements of webpages under different network conditions and to acquire custom page elements. This solution addresses the need for page rendering. On the one hand, it employs multi-level caching to cache custom page elements, combining server-side and client-side browser caching. This approach offers better system stability compared to relying solely on client-side browser caching. In high-traffic, high-concurrency scenarios involving frequent page element settings, it effectively improves page rendering stability and real-time updates. Furthermore, by combining multi-level caching and utilizing scenario markers generated from signaling based on current network conditions, the solution retrieves custom page elements from the multi-level cache for rendering. This avoids issues like page display failures in weak or no-network conditions when using only server-side caching, resulting in a blank screen and poor user experience. It also avoids delays in client-side browser cache updates in weak or no-network conditions, requiring multiple page refreshes to see the latest settings, further enhancing page rendering flexibility. Therefore, the technical solutions in this application embodiment can effectively improve the display effect of page element updates on web pages, better adapt to web page rendering under different network conditions, and improve the user's web page experience.
[0058] The specific implementation of step S206 is not limited in this embodiment. As an example, some optional implementation schemes can be introduced below in conjunction with the first scene marker, second scene marker, third scene marker, and fourth scene marker mentioned above.
[0059] In some optional embodiments, step S206 may include: if the scene flag includes a first scene flag, then according to the first scene flag and the time flag corresponding to the client browser cache, determine whether to obtain the custom page element from the client browser cache or from the server cache, and perform page rendering based on the obtained custom page element.
[0060] Optionally, the timestamp can be a timestamp of data in the client browser cache, or any other text, symbol, etc. that indicates time; there is no single limitation.
[0061] It should be understood that in this embodiment of the application, the custom page element can be obtained from the client browser cache or the server cache based on the time flag corresponding to the first scene flag. This makes it easier to obtain the custom page element that meets the time requirements, thereby effectively rendering the page based on the obtained custom page element.
[0062] For example, alternatively, the above-mentioned optional methods can facilitate the retrieval of the latest custom page elements from the client browser cache or the server cache, thereby enabling page rendering and page updates.
[0063] In some alternative embodiments, refer to Figure 3 As shown, the process of determining whether to retrieve the custom page element from the client browser cache or the server cache based on the timestamp corresponding to the client browser cache, and then rendering the page based on the obtained custom page element, may include the following steps S302 to S308:
[0064] S302: Obtain the first custom page element from the client browser cache and render the page based on the first custom page element.
[0065] The first custom page element is the latest custom page element in the client browser cache.
[0066] In this embodiment, the latest first custom page element can be obtained from the client browser cache, and the page can be rendered once based on the first custom page element. This ensures that the web page can be rendered under various network conditions such as normal network, weak network, and no network, so that the web page will not be blank and the user waiting time will be reduced, thereby improving the user experience.
[0067] S304: Determine the timestamp of the first custom page element as the timestamp of the client browser cache, and determine whether the first custom page element is the latest custom page element in the server cache based on the timestamp of the first custom page element.
[0068] Optionally, the timestamp of the latest first custom page element in the client browser cache can be obtained and determined as the timestamp of the client browser cache. Based on the timestamp of the first custom page element cache, the server-side interface service can be used to determine whether it is the latest custom page element in the server-side cache.
[0069] Optionally, the timestamp of the second custom page element in the server cache can be obtained through the server-side interface service. This second custom page element is the latest custom page element in the server cache. Then, it is determined whether the timestamp of the first custom page element cache is the same as the timestamp of the second custom page element in the server cache. If so, the first custom page element is also the latest custom page element in the server cache; otherwise, it is not. Optionally, after the custom page elements on the webpage are updated, the relevant updated data will also be updated in the server cache. However, due to various factors such as network conditions and upload time settings, the latest second custom page element in the server cache may be the same as or different from the first custom page element. Therefore, it is necessary to determine whether the first custom page element in the client browser cache is the latest in the entire system, in order to decide whether to continue obtaining the second custom page element from the server cache for further page rendering.
[0070] S306: If not, obtain the second custom page element from the server cache.
[0071] The second custom page element is the latest custom page element in the server cache.
[0072] In this embodiment of the application, if the first custom page element is not the latest custom page element in the server cache, the server can obtain the latest second custom page element from the server cache and return it to the client.
[0073] S308: Re-render the page based on the second custom page element.
[0074] The client can re-render the page based on the latest second custom page element, so that the web page can be rendered and displayed with the latest updated custom page element.
[0075] In some optional embodiments, in contrast to step S306, if so, it is not necessary to obtain the second custom page element from the server cache again, nor is it necessary to perform another rendering; thus, only the result of the single rendering in step S302 is required. Optionally, the server-side interface service can return the determination result that the first custom page element is the latest custom page element in the server cache to the client, without returning the second custom page element.
[0076] It is understood that, through the optional embodiments of steps S302 to S308 above, the rendering of the webpage can be completed in one or two renderings, and the newly set page elements can be displayed as much as possible.
[0077] It should be understood that, through the optional implementation of steps S302 to S308 in this application embodiment, on the one hand, the latest first custom page element can be obtained from the client browser cache and a page rendering can be performed once, ensuring that the page can be rendered normally under various network conditions (such as normal network, weak network, no network, etc.), thereby avoiding the white screen phenomenon after the page element is set, improving the user experience. In addition, it can also ensure that the page rendering can still be performed normally when there is no data return due to server interface abnormality. On the other hand, the timestamp of the first custom page element is used to determine whether it is the latest custom page element in the server cache. If not, the latest second custom page element is obtained from the server cache, and the page is rendered again based on the second custom page element. This can ensure that when the network is normal, the web page can effectively display the latest updated custom page element after page rendering, thereby improving the real-time display of page rendering after page element update settings, and further improving the user experience.
[0078] Understandably, the above-mentioned alternative solutions can also be considered a fallback strategy. That is, when there is a weak network or no network, although the client browser cache may be delayed in updating, a fallback approach can be taken: instead of necessarily obtaining the latest custom page elements from the server cache, the rendering state of the latest custom page elements in the client browser cache can be maintained. This achieves a fallback page rendering, ensuring that even in weak or no network conditions, the page can still be displayed correctly, avoiding a blank screen and thus guaranteeing the user experience. Optionally, the above-mentioned alternative technical solutions have a wide range of applications and can be applied to virtually any use case.
[0079] In some optional embodiments, after obtaining the second custom page element, the page rendering method in this application embodiment further includes: caching the second custom page element to the client browser cache.
[0080] It should be noted that the second custom page element can be cached in the client browser cache before the re-rendering in step S308 above, or it can be cached in the client browser cache after the re-rendering, as long as the requirements are met.
[0081] It should be understood that, in this embodiment of the application, after obtaining the second custom page element, the second custom page element is cached in the client browser cache, so that the client browser cache can keep the data synchronized with the latest custom page element in the server cache, and realize the timely update of the custom page element in the client browser cache, so as to facilitate the subsequent retrieval of the custom page element from the client browser cache for page rendering.
[0082] In some optional embodiments, step S206 may include: if the scene flag includes a second scene flag, then according to the second scene flag, based on whether the server returns first return information, determine whether to obtain the custom page element from the server cache or from the client browser cache, and perform page rendering based on the obtained custom page element.
[0083] Optionally, when the second scene flag is included, the client can call the server interface to determine whether the server interface returns data, i.e., the first return information. Then, based on whether the server interface returns the first return information, the client can obtain the custom page element from the server cache or the client browser cache, which can facilitate obtaining the custom page element that meets the requirements, and thus effectively perform page rendering based on the obtained custom page element.
[0084] Optionally, in some embodiments, the first returned information may carry custom page elements from the server cache. This way, if it is determined based on the first returned information that a custom page element needs to be obtained from the server cache, it can be extracted from the first returned information without needing to request it from the server again. In other embodiments, the first returned information may not carry custom page elements, but instead carry indication information indicating that data can be obtained from the server cache. In this case, if it is determined based on the first returned information that a custom page element needs to be obtained from the server cache, the client can request it from the server again according to the indication information in the first returned information. The choice can be made as needed, and this application does not impose a single limitation on the embodiments.
[0085] In some optional embodiments, the above-mentioned determination of whether to retrieve the custom page element from the server cache or from the client browser cache based on whether the server returns first return information, and the page rendering based on the obtained custom page element, may include:
[0086] If so, obtain the second custom page element carried by the first returned information, and perform page rendering based on the second custom page element, wherein the second custom page element is the latest custom page element in the server cache;
[0087] If not, obtain the first custom page element from the client browser cache and render the page based on the first custom page element, where the first custom page element is the latest custom page element in the client browser cache.
[0088] Based on this, the above optional embodiments in this application can, on the one hand, effectively retrieve custom page elements from the server cache or client browser cache based on whether the server returns the first return information, ensuring that the page can be rendered normally under various network conditions (such as normal network, weak network, no network, etc.), thereby avoiding the white screen phenomenon after setting page elements and improving user experience. In addition, it can also ensure that page rendering can still be performed normally when there is no data return due to server interface abnormality. On the other hand, through the above optional solutions, it can be ensured that the latest custom page elements can be obtained from the server cache or client browser cache. Thus, when the network is normal, it can be ensured that the second custom page element carried by it can be obtained from the first return information for page rendering, effectively enabling the web page to display the latest updated custom page elements after page rendering, thereby improving the real-time display of page rendering after page element update settings and improving user experience. Alternatively, in the case of weak network or no network, the latest available custom page element (i.e., the first custom page element) can be obtained from the client browser cache, thereby ensuring that the web page can display the newest custom page elements after page rendering as much as possible, which is beneficial to improving user experience.
[0089] Optionally, under the indication of the second scenario flag, the webpage can be rendered only once. If the server successfully returns data (i.e., the first returned information), the data returned by the server is used first for page rendering. If the data is not successfully returned, data is then retrieved from the client browser cache for page rendering. In this case, it is necessary to wait for the server interface data transmission, first try to use the server-cached data, and if that fails, then use the client browser cache. This ensures that the client can render the webpage normally under various network conditions, avoiding white screen phenomena. Optionally, the above optional technical solutions have a wide range of applications and can be basically applied to various usage scenarios.
[0090] Understandably, the above-mentioned alternative solutions can also be regarded as a degradation strategy. That is, when the network is weak or there is no network, the server interface cannot return the first response information. Although the client browser cache may be delayed in updating, we can also take a step back and not necessarily obtain the latest custom page elements in the server cache. Instead, we can use the latest custom page elements in the client browser cache for page rendering, thus achieving degraded page rendering. This ensures that even when the network is weak or there is no network, the page can still be displayed normally, avoiding the white screen phenomenon and thus ensuring the user experience.
[0091] In some optional embodiments, step S206 may include: if the scene flag includes a third scene flag, then send a version flag to the server according to the third scene flag, determine whether to obtain the custom page element from the server cache or from the client browser cache based on the second return information returned by the server according to the version flag, and perform page rendering based on the obtained custom page element.
[0092] Optionally, as mentioned above, the generated signaling can carry a version flag in addition to the scenario flag. The version flag can be used to indicate the version information of the latest custom page element in the client browser cache. The version flag can be updated as the latest custom page element in the client browser cache is updated.
[0093] It should be understood that the embodiments of this application can obtain a version flag, send the version flag to the server, and the server returns second return information based on the version flag. The custom page element can be obtained from the server cache or the client browser cache based on the second return information, which can facilitate obtaining the custom page element that meets the requirements, thereby effectively rendering the page based on the obtained custom page element.
[0094] In some optional embodiments, the above-mentioned determination of whether to retrieve the custom page element from the server cache or the client browser cache based on the second return information returned by the server according to the version flag, and the page rendering based on the obtained custom page element, may include:
[0095] If the second returned information carries a second custom page element, and page rendering is performed based on the second custom page element, wherein the second custom page element is the latest custom page element in the server cache; or,
[0096] If the second returned information carries confirmation information, the first custom page element is obtained from the client browser cache, and the page is rendered based on the first custom page element. The first custom page element is the latest custom page element in the client browser cache, and the version of the first custom page element is the same as the version information indicated by the version flag.
[0097] Based on this, through the above optional embodiments in this application, on the one hand, custom page elements can be effectively obtained from the server cache or client browser cache based on the second return information returned by the server according to the version flag, ensuring that the page can be rendered normally under various network conditions (such as normal network, weak network, no network, etc.), thereby avoiding the white screen phenomenon after the page elements are set and improving the user experience; on the other hand, through the above optional solutions, it can be ensured that the latest custom page elements can be obtained from the server cache or client browser cache, so that when the network is normal, it can be ensured that the second custom page elements carried by the second return information can be obtained for page rendering, effectively enabling the web page to display the latest updated custom page elements after page rendering, which is conducive to improving the real-time display of page rendering after the page elements are updated and set, and improving the user experience. Alternatively, in the case of weak network or no network, the latest custom page element (i.e., the first custom page element) that is currently available and has the same version information and version flag can be obtained from the client browser cache, thereby ensuring that the web page can display the newest custom page elements after page rendering as much as possible, which is conducive to improving the user experience.
[0098] Optionally, the server can determine whether the version information of the second custom page element in the server cache is the same as the version information indicated by the version flag based on the version flag. If not, the server generates second return information carrying the second custom page element and returns it to the client. If so, the server generates the above confirmation information and returns it to the client. The confirmation information can indicate that the version information of the latest custom page element in the server is the same as the latest custom page element in the client browser cache.
[0099] Optionally, under the instruction of the third scenario flag, the webpage can perform page rendering only once. Sending a version flag to the server requires waiting for the server to return data (i.e., the second return information). If the server interface fails to return data, the page rendering will not use the data cached by the client browser, but will continue to wait for the server to return data. If the server returns data successfully, the page rendering will be based on whether the data is obtained from the server cache or the client browser cache, depending on the second return information. If the second return information carries a second custom page element, the second custom page element can be used for page rendering. If the second return information carries confirmation information, the first custom page element can be obtained from the client browser cache for page rendering. Optionally, the above optional technical solutions are well applicable to scenarios such as page refresh.
[0100] In some optional embodiments, step S206 may include: if the scene flag includes a fourth scene flag, obtaining the latest custom page element in the server cache, and rendering the page based on the latest custom page element.
[0101] Based on this, when the scene flag includes the fourth scene flag, only the latest custom page element in the server cache can be obtained, and then the page can be rendered based on the latest custom page element. This ensures that the web page can display the latest updated custom page element after page rendering under various network conditions, which helps to improve the real-time performance of page rendering and display after page element update settings and improves user experience.
[0102] Alternatively, in this alternative approach, it is not necessary to retrieve data cached by the client's browser or version information. Instead, the latest custom page elements cached on the server are used for page rendering, ensuring that the most up-to-date server-returned data is rendered. Optionally, the above alternative technical solution is well-suited for various real-time-critical application scenarios, such as previewing edited page elements.
[0103] In some optional embodiments, the method in this application further includes: after a custom page element in the server-side cache is updated, pushing the updated custom page element to a push system via the server, and then pushing the updated custom page element to the client browser cache via the push system. Thus, by setting up a push system, this application embodiment can achieve synchronization of updated custom page elements in the server-side cache and the client browser cache.
[0104] Optionally, the updated custom elements can be synchronously pushed to a push system via the server, and then asynchronously pushed to the client browser cache via the push system. This effectively achieves synchronization of updated custom page elements in the server-side cache and the client browser cache.
[0105] For example, Figure 4 A schematic diagram of an optional data flow in an embodiment of this application is shown, which at least illustrates the data flow between the push system, the server, and the client. For example... Figure 4 As shown, custom page elements can be set in the management backend of the webpage. The management backend saves the updated custom page elements to the server's server cache, and the server synchronously pushes the updated custom page elements to the push system. The push system then pushes the updated custom page elements to the client's browser cache. Figure 4 As shown, the client can be, but is not limited to, at least one of PC clients, mobile clients, etc. For example... Figure 4 As shown, updated custom page elements can be obtained from the server-side cache or the client-side browser cache to render the webpage.
[0106] The following is combined Figures 5A to 5D The following is an exemplary application scenario illustrating the applicability of the page rendering scheme in the embodiments of this application:
[0107] like Figure 5A It shows an example webpage, which can be understood as an office automation approval page. The webpage includes navigation items (page elements), and there can be multiple navigation items, such as: Home, Approval Center, Data Center, Plugin Center. The Home page also includes: My OA, Initiate Approval, Initiate Service, Cross-Organization Approval, Business Applications, etc.
[0108] like Figure 5B As shown, it illustrates Figure 5A The management backend page of the webpage. Figure 5B Visible in the middle Figure 5A All navigation items can be customized, such as... Figure 5B As shown, Figure 5A The homepage, approval center, data center, and plug-in center are all set to "display" status, and My OA, Initiate Approval, Initiate Service, Cross-Organization Approval, and Business Applications are elements included in the homepage;
[0109] like Figure 5CAs shown, the page elements are displayed after being customized. In this case, "Initiate Approval", "Initiate Service", "Cross-Organization Approval", and "Business Application" are set as page elements at the same level as the homepage, and "Data Center" and "Plug-in Center" are changed from "Show" to "Hidden".
[0110] After that, it can be based on Figure 5C The custom page element settings in the document implement the page rendering scheme in this embodiment. For details, please refer to the preceding text. In some cases, it can achieve the desired rendering result. Figure 5D The webpage shown, in which, Figure 5D The "Initiate Approval," "Initiate Service," "Cross-Organization Approval," and "Business Application" sections are page elements at the same level as the homepage, while the "Data Center" and "Plug-in Center" sections are hidden and no longer displayed.
[0111] It should be understood that the above Figures 5A to 5D This is merely a scenario example for ease of understanding in the embodiments of this application, and is not intended to limit the embodiments of this application in any way.
[0112] Alternatively, you can refer to Figure 6 The diagram illustrates an optional data flow of a page rendering scheme in an embodiment of this application. Figure 6 As shown in the diagram, this data flow involves users, management backend, server, push system, client, and web page. Figure 6 As shown, the data flow can be understood by referring to the following example:
[0113] Users can customize page elements (such as navigation items) on web pages through the management backend;
[0114] The management backend saves the updated custom page elements to the server's server cache;
[0115] The server will synchronously push the updated custom page elements to the push system;
[0116] The push system asynchronously pushes the updated custom page elements to the client and stores them in the client's browser cache;
[0117] Users can open web pages (taking the office automation approval page as an example) and retrieve custom page elements from the client browser cache;
[0118] For example, you can use the latest custom page element retrieved from the client browser cache (which can be the same as the latest custom page element in the server cache) to render the page and show the rendered web page with the latest settings to the user;
[0119] For example, a cached custom page element obtained from the client's browser cache (which may be different from the latest custom page element in the server cache) can be used to render the page and display the rendered cached web page to the user.
[0120] Web pages can call server-side APIs to obtain custom page elements. The server returns data, and the web page updates the client browser cache based on the returned data, thus synchronizing custom page elements between the server cache and the client browser cache.
[0121] It should be understood that the above Figure 6 This is merely an example for ease of understanding in the embodiments of this application and is not intended to limit the embodiments of this application in any way.
[0122] In summary, the technical solution of this application embodiment, on the one hand, can generate signaling based on the current network conditions of the client, so as to reasonably obtain custom page elements based on the indication of the scene flag in the signaling, and perform page rendering reasonably. This adapts to the needs of obtaining custom page elements and rendering pages after page element updates under different network conditions. On the other hand, because this solution uses multi-level caching to cache custom page elements, and the multi-level caching is implemented by combining server-side caching and client-side browser caching, the system stability is better than using client-side browser caching alone. This is particularly beneficial for high-traffic, high-concurrency scenarios where page element settings are frequently performed. This solution effectively improves webpage rendering to achieve stability and real-time updates of page elements. Furthermore, by combining multi-level caching and utilizing scene markers generated from signaling based on current network conditions, it rationally retrieves custom page elements from the multi-level cache for page rendering. This helps avoid the problem of webpages failing to display correctly in weak or no network conditions when only server-side caching is used, potentially resulting in a blank screen and poor user experience. It also helps avoid the problem of delayed client-side browser cache updates in weak or no network conditions when only client-side browser caching is used, which might require multiple page refreshes to see the latest page settings, thus effectively improving the flexibility of page rendering.
[0123] Therefore, the technical solutions in the embodiments of this application can effectively improve the display effect of page element updates on web pages, better adapt to web page rendering under different network conditions, and improve the user's web page experience.
[0124] It is understood that, through some optional technical solutions in the embodiments of this application, multi-level caching and degradation strategies are used to handle situations where custom page elements cannot be retrieved due to weak network, no network, or abnormal server interface, ensuring that web page rendering and display can still proceed normally under various network conditions or abnormal situations, and guaranteeing user experience under weak network, no network, or abnormal server interface conditions. Furthermore, through some optional technical solutions in the embodiments of this application, based on multi-level caching and degradation strategies, protocol mechanisms including scene flags and version flags can be used, and a push system can be employed to push page element setting data updates to the client in real time, ensuring real-time updates of page element settings.
[0125] It should be understood that the foregoing description of the page rendering method is merely an exemplary description of the embodiments of this application and is not intended to limit the embodiments of this application in any way.
[0126] According to a second aspect of the present application, an electronic device is provided, comprising: a processor, a communication interface, a memory, and a communication bus, wherein the processor, the communication interface, and the memory communicate with each other via the communication bus; the memory is used to store a computer program; and the processor is used to execute the page rendering method described in the first aspect by running the computer program stored in the memory.
[0127] Figure 7 A structural block diagram of an optional electronic device according to an embodiment of this application is shown. This application does not limit the specific implementation of the electronic device 1000; however, as an example, reference is made to... Figure 7 The electronic device 1000 provided in this application embodiment includes: a processor 1002, a communications interface 1004, a memory 1006, and a communication bus 1008. Wherein:
[0128] The processor 1002, communication interface 1004, and memory 1006 communicate with each other via communication bus 1008.
[0129] Communication interface 1004 is used to communicate with other electronic devices or servers.
[0130] The processor 1002 is used to execute the computer program 1010, specifically the relevant steps in any of the aforementioned page rendering method embodiments.
[0131] Specifically, computer program 1010 may include program code that includes computer operation instructions.
[0132] The processor 1002 may be a CPU, a GPU (Graphics Processing Unit), an Application Specific Integrated Circuit (ASIC), or one or more integrated circuits configured to implement the embodiments of this application. The one or more processors included in the smart device may be processors of the same type, such as one or more CPUs; or they may be processors of different types, such as one or more CPUs and one or more ASICs.
[0133] Memory 1006 is used to store computer program 1010. Memory 1006 may include high-speed RAM memory, and may also include non-volatile memory, such as at least one disk storage device.
[0134] Specifically, computer program 1010 can be used to cause processor 1002 to execute the page rendering method in any of the foregoing embodiments.
[0135] The specific implementation of each step in computer program 1010 can be found in the corresponding steps and units described in any of the foregoing page rendering method embodiments, and will not be repeated here. Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the specific working process of the devices and modules described above can be referred to the corresponding process descriptions in the foregoing method embodiments, and will not be repeated here.
[0136] The electronic device 1000 in this application embodiment has been described in detail in the foregoing page rendering method embodiment. Therefore, its related content and beneficial effects can be understood by referring to the above method embodiment, and will not be repeated here.
[0137] According to a third aspect of the embodiments of this application, the embodiments of this application also provide a computer storage medium storing a computer program thereon, which, when executed by a processor, implements the page rendering method described in any of the foregoing method embodiments. The computer storage medium includes, but is not limited to, compact disc read-only memory (CD-ROM), random access memory (RAM), floppy disk, hard disk, or magneto-optical disk, etc.
[0138] According to a fourth aspect of the embodiments of this application, the embodiments of this application also provide a computer program product, including a computer program that, when executed by a processor, implements the page rendering method as described in any of the embodiments of the plurality of method embodiments above.
[0139] The electronic device 1000 / computer storage medium / computer program product embodiments in this application have been described in detail in the foregoing page rendering method embodiments. Therefore, their related content and beneficial effects can be understood by referring to the above method embodiments, and will not be repeated here.
[0140] Furthermore, it should be noted that the user-related information (including but not limited to user device information, user personal information, etc.) and data (including but not limited to sample data used for training the model, data used for analysis, stored data, displayed data, etc.) involved in the embodiments of this application are all information and data authorized by the user or fully authorized by all parties. Moreover, the collection, use and processing of related data must comply with the relevant laws, regulations and standards of the relevant countries and regions, and corresponding operation entry points are provided for users to choose to authorize or refuse.
[0141] It should be noted that, depending on the implementation needs, the various components / steps described in the embodiments of this application can be broken down into more components / steps, or two or more components / steps or parts of the operation of components / steps can be combined into new components / steps to achieve the purpose of the embodiments of this application.
[0142] The methods described in the embodiments of this application can be implemented in hardware, firmware, or as software or computer code that can be stored in a recording medium (such as a CD-ROM, RAM, floppy disk, hard disk, or magneto-optical disk), or as computer code downloaded over a network that is originally stored in a remote recording medium or a non-transitory machine-readable medium and will be stored in a local recording medium. Thus, the methods described herein can be stored on a recording medium using a general-purpose computer, a dedicated processor, or programmable or dedicated hardware (such as an Application Specific Integrated Circuit (ASIC) or a Field Programmable Gate Array (FPGA)). It is understood that the computer, processor, microprocessor controller, or programmable hardware includes storage components (e.g., Random Access Memory (RAM), Read-Only Memory (ROM), Flash Memory, etc.) capable of storing or receiving software or computer code, which, when accessed and executed by the computer, processor, or hardware, implements the methods described herein. Furthermore, when a general-purpose computer accesses code used to implement the methods shown herein, the execution of the code transforms the general-purpose computer into a dedicated computer for executing the methods shown herein.
[0143] Those skilled in the art will recognize that the units and method steps of the various examples described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, or a combination of computer software and electronic hardware. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for specific applications, but such implementations should not be considered beyond the scope of the embodiments of this application.
[0144] The term "comprising" and its variations as used herein are open-ended, meaning "including but not limited to". The term "based on" means "at least partially based on". The term "one embodiment" means "at least one embodiment"; the term "another embodiment" means "at least one additional embodiment"; the term "some embodiments" means "at least some embodiments". It should be noted that the concepts of "first", "second", etc., mentioned in the embodiments of this application are only used to distinguish different devices, modules, or units, and are not used to limit the order of functions performed by these devices, modules, or units or their interdependencies. It should be noted that the modifications of "a" and "a plurality" mentioned in the embodiments of this application are illustrative rather than restrictive, and those skilled in the art should understand that unless otherwise expressly indicated in the context, they should be understood as "one or more".
[0145] The above embodiments are only used to illustrate the embodiments of this application, and are not intended to limit the embodiments of this application. Those skilled in the art can make various changes and modifications without departing from the spirit and scope of the embodiments of this application. Therefore, all equivalent technical solutions also fall within the scope of the embodiments of this application, and the patent protection scope of the embodiments of this application should be defined by the claims.
Claims
1. A page rendering method, comprising: Receive a rendering instruction for a webpage, wherein the webpage includes custom page elements, and the custom page elements have been updated within a preset time period from the current time. Based on the rendering instruction and the current network conditions corresponding to the client executing the rendering instruction, a signaling is generated to indicate the acquisition of the customized page element after the update settings. The signaling carries a scene flag, which is used to indicate the method of acquiring the customized page element after the update settings based on a preset multi-level cache. The multi-level cache includes at least a server-side cache and a client-side browser cache. According to the method indicated by the scene flag, the custom page element is obtained from the multi-level cache, and the page is rendered based on the obtained custom page element.
2. The method of claim 1, wherein, The scene markers include at least one of the following: The first scene flag used to indicate that custom page elements cached by the client browser should be used for page rendering first; The second scene flag is used to indicate that the custom page elements returned by the server should be used for page rendering first. A third-scene flag used to indicate waiting for a response from the server before receiving the custom page elements for page rendering; The fourth scene flag is used to indicate that the page is rendered using only the custom page elements returned by the server.
3. The method of claim 2, wherein, The step of obtaining custom page elements from the multi-level cache in accordance with the manner indicated by the scene flag, and rendering the page based on the obtained custom page elements, includes: If the scene flag includes a first scene flag, then according to the first scene flag and the time flag corresponding to the client browser cache, it is determined whether to obtain the custom page element from the client browser cache or from the server cache, and the page is rendered based on the obtained custom page element.
4. The method of claim 3, wherein, The step of determining whether to retrieve the custom page element from the client browser cache or the server cache based on the timestamp corresponding to the client browser cache, and then rendering the page based on the obtained custom page element, includes: A first custom page element is obtained from the client browser cache, and page rendering is performed based on the first custom page element, wherein the first custom page element is the latest custom page element in the client browser cache; The timestamp of the first custom page element is determined as the timestamp of the client browser cache. Based on the timestamp of the first custom page element, it is determined whether the first custom page element is the latest custom page element in the server cache. If not, then obtain the second custom page element from the server cache, wherein the second custom page element is the latest custom page element in the server cache; Based on the second custom page element, the page is rendered again.
5. The method according to claim 4, wherein, After obtaining the second custom page element, the method further includes: The second custom page element is cached in the client browser cache.
6. The method according to claim 2, wherein, The step of obtaining custom page elements from the multi-level cache in accordance with the manner indicated by the scene flag, and rendering the page based on the obtained custom page elements, includes: If the scene flag includes a second scene flag, then based on whether the server returns the first return information, it is determined whether to obtain the custom page element from the server cache or from the client browser cache, according to the second scene flag, and the page is rendered based on the obtained custom page element.
7. The method according to claim 6, wherein, The step of determining whether to retrieve the custom page element from the server cache or the client browser cache based on whether the server returns a first return information, and then rendering the page based on the obtained custom page element, includes: If so, the second custom page element carried by the first returned information is obtained, and page rendering is performed based on the second custom page element, wherein the second custom page element is the latest custom page element in the server cache; or, If not, the first custom page element is obtained from the client browser cache, and page rendering is performed based on the first custom page element, wherein the first custom page element is the latest custom page element in the client browser cache.
8. The method according to claim 2, wherein, The signaling also carries a version flag, which is used to indicate the version information of the latest custom page element in the client browser cache.
9. The method according to claim 8, wherein, The step of obtaining custom page elements from the multi-level cache in accordance with the manner indicated by the scene flag, and rendering the page based on the obtained custom page elements, includes: If the scene flag includes a third scene flag, then according to the third scene flag, the version flag is sent to the server. Based on the second return information returned by the server according to the version flag, it is determined whether to obtain the custom page element from the server cache or from the client browser cache, and the page is rendered based on the obtained custom page element.
10. The method according to claim 9, wherein, The step of determining whether to retrieve the custom page element from the server cache or the client browser cache based on the second return information returned by the server according to the version flag, and rendering the page based on the obtained custom page element, includes: If the second returned information carries a second custom page element, and page rendering is performed based on the second custom page element, wherein the second custom page element is the latest custom page element in the server cache; or, If the second returned information carries confirmation information, then the first custom page element is obtained from the client browser cache, and page rendering is performed based on the first custom page element. The first custom page element is the latest custom page element in the client browser cache, and the version of the first custom page element is the same as the version information indicated by the version flag.
11. The method according to claim 2, wherein, The step of obtaining custom page elements from the multi-level cache in accordance with the manner indicated by the scene flag, and rendering the page based on the obtained custom page elements, includes: If the scene flag includes a fourth scene flag, obtain the latest custom page element in the server cache, and perform page rendering based on the latest custom page element.
12. The method according to any one of claims 1-11, wherein, The custom page element is the navigation item of the webpage; The step of rendering the page based on the obtained custom page elements includes: The page is rendered based on the obtained custom page elements to update the navigation items displayed on the webpage.
13. An electronic device, comprising: The processor, the communication interface, the memory, and the communication bus are provided, wherein the processor, the communication interface, and the memory communicate with each other via the communication bus. The memory is used to store computer programs; The processor is configured to perform the method of any one of claims 1-12 by running the computer program stored in the memory.
14. A computer storage medium having a computer program stored thereon, which, when executed by a processor, implements the method as described in any one of claims 1-12.
15. A computer program product comprising a computer program that, when executed by a processor, implements the method as described in any one of claims 1-12.
