High-performance page presentation acceleration method suitable for data visual interface

Abstract

The invention provides a high-performance page presentation acceleration method suitable for a data visualization interface, and relates to the technical field of data visualization, comprising: caching page data according to a preset condition, the page data comprising page chart data and associated query conditions and configuration conditions; when the user accesses the page for the first time, if effective cache data exists, directly returning the cached page data to shorten the loading time; the method comprises the following steps: monitoring a user operation state at a client, and when a system is in an idle state, performing background preloading on an unopened page; if the effective server cache data exists in the preloaded page, preferentially obtaining the data from the cache; user operation is monitored in real time in the preloading process, if it is detected that a user initiates a page switching or query request, preloading is paused to respond to the user operation preferentially, and preloading is recovered after the user operation is completed.

Description

Technical Field

[0001] This application belongs to the technical field of data visualization, and specifically relates to a high-performance page rendering acceleration method applicable to data visualization interfaces. Background Art

[0002] With the rapid development of data visualization technology, business intelligence (BI) systems and data analysis tools have gradually become the core support for enterprise decision-making. Data visualization products usually consist of multiple pages, and users switch between different pages through the navigation menu to obtain multi-dimensional analysis views. However, with the explosion of data volume and the increasing demand for real-time performance from users, the existing technology faces significant challenges in terms of page loading efficiency and user experience.

[0003] The current mainstream data visualization systems generally adopt the "load on demand" strategy. The specific process includes: when the user enters the system, only the default page (such as the home page) is loaded, and the remaining pages are in an unloaded state; when the user first switches to another page, the data loading of that page is triggered; the accessed pages retain the client state to accelerate subsequent switches.

[0004] Since only the default page is loaded, when the user first accesses the system, they need to wait for the complete fetching and calculation of the initial page data, resulting in a too long first-screen loading time; when the user first switches to an unloaded page, they need to wait for the real-time calculation and transmission of the data of that page, causing operation interruptions; when the user frequently switches pages, if the target page is not cached or pre-loaded, each switch requires reloading, resulting in the accumulation of response delays and affecting the user experience; the background does not implement dynamic resource regulation, and page loading and real-time user operations may compete for computing resources, further exacerbating the delay. Summary of the Invention

[0005] This application provides a high-performance page rendering acceleration method applicable to data visualization interfaces to solve one of the above technical problems.

[0006] The technical solution adopted by this application is as follows:

[0007] An embodiment of this application provides a high-performance page rendering acceleration method applicable to data visualization interfaces, including:

[0008] Caching page data according to preset conditions, where the page data includes page chart data and associated query conditions and configuration conditions;

[0009] When the user first accesses a page, if there is valid cached data, directly return the cached page data to shorten the loading time;

[0010] Listen to the user operation state on the client side, and when the system is idle, preload the unopened pages in the background;

[0011] If there is valid server cache data in the preloaded page, the data is preferentially retrieved from the cache;

[0012] During the preloading process, monitor user operations in real time. If it is detected that the user initiates a page switch or query request, pause the preloading to preferentially respond to the user operation, and resume the preloading after the user operation is completed.

[0013] According to an embodiment of the present application, the caching of page data according to preset conditions is specifically as follows:

[0014] Automatically execute the data fetching and operation of the page data according to a preset time interval or trigger condition, and update the cache;

[0015] When the user accesses an uncached page, execute the complete data fetching and operation process, and save the result as cache data;

[0016] Set a validity period or resource occupancy threshold for the cache data, and automatically destroy and regenerate it after timeout or exceeding the threshold.

[0017] According to an embodiment of the present application, the configuration of the page data cache is in units of pages, and supports individually disabling the cache function for charts to meet the real-time data requirements.

[0018] According to an embodiment of the present application, the pages preloaded in the background are loaded in the form of a hidden layer, and the preloading process supports pausing, resuming, and priority adjustment.

[0019] According to an embodiment of the present application, the real-time monitoring of user operations during the preloading process, if it is detected that the user initiates a page switch or query request, pauses the preloading to preferentially respond to the user operation, and resumes the preloading after the user operation is completed, further includes:

[0020] When the user switches to a preloaded page, directly display the preloading result;

[0021] If the target page has not been preloaded, preferentially load the currently requested page and pause the background preloading task.

[0022] A high-performance page rendering acceleration device applicable to a data visualization interface, comprising:

[0023] A server-side data cache module for generating, updating, and returning page cache data according to preset conditions;

[0024] A client-side page preloading module for loading unvisited pages in the background in an idle state and dynamically adjusting the preloading task according to user operations;

[0025] A resource scheduling control module for monitoring user operations in real time and coordinating the resource allocation between the server cache and client preloading.

[0026] According to an embodiment of the present application, the server data cache module includes:

[0027] An active refresh unit configured to trigger data update at regular intervals;

[0028] A passive response unit configured to generate a cache when the user accesses for the first time;

[0029] A cache management unit configured to manage the cache life cycle according to the validity period or resource threshold.

[0030] According to an embodiment of the present application, the client page preloading module includes:

[0031] A preloading execution unit for loading page data in a hidden layer;

[0032] An activity monitoring unit for detecting user queries or page switching operations to control the start and stop of preloading.

[0033] A computer-readable storage medium having a program stored thereon, characterized in that when the program is executed by a processor, it implements the steps in a high-performance page rendering acceleration method applicable to a data visualization interface.

[0034] An electronic device includes a memory, a processor, and a program stored on the memory and executable on the processor, characterized in that when the processor executes the program, it implements the steps in a high-performance page rendering acceleration method applicable to a data visualization interface.

[0035] Due to the above technical solutions, the beneficial effects obtained by the present application are as follows:

[0036] The present application pre-generates and caches page chart data and its associated query conditions. When the user accesses for the first time, the cached data can be directly called, avoiding the overhead of real-time computing and significantly reducing the first-screen loading delay; it supports a flexible caching strategy: through the active refresh (timed update) and passive refresh (generated on demand) mechanisms, it ensures the timeliness and resource utilization rate of the cached data, and at the same time allows disabling caching for charts to adapt to real-time data requirements. When the system is idle, unvisited pages are preloaded in the background, and the server cache data is used to accelerate the preloading process. When the user switches pages, the preloading result can be directly displayed, eliminating the waiting time; the page is loaded in a hidden layer to avoid interfering with the user's current operation, and the preloading order is optimized by adjusting the priority. Monitor user switching or query requests, pause preloading to prioritize real-time operation resources, and resume background tasks after the operation is completed to avoid performance degradation caused by resource competition; adjust the data loading path in combination with the server cache status to further reduce the problem of repeated waiting.

[0037] Through the synergistic effect of the above steps, the efficient operation of the data visualization system is achieved. The first-screen loading time is reduced by more than 30%, and the page switching latency is reduced to the millisecond level. Server-side caching reduces duplicate calculations, and client-side preloading makes full use of idle resources. It supports the hybrid scenario of real-time data and static data, meeting diverse business needs. BRIEF DESCRIPTION OF THE DRAWINGS

[0038] The drawings described herein are used to provide a further understanding of the present application and constitute a part of the present application. The illustrative embodiments of the present application and their descriptions are used to explain the present application and do not constitute an improper limitation of the present application. In the drawings:

[0039] Figure 1 It is a schematic flowchart of a high-performance page rendering acceleration method applicable to a data visualization interface provided by an embodiment of the present application. DETAILED DESCRIPTION OF THE EMBODIMENTS

[0040] In order to more clearly illustrate the overall concept of the present application, the following will be described in detail by way of examples in conjunction with the accompanying drawings of the specification.

[0041] In the following description, many specific details are set forth in order to fully understand the present application. However, the present application may be implemented in other ways different from those described herein. Therefore, the scope of protection of the present application is not limited by the specific embodiments disclosed below. It should be noted that, without conflict, the embodiments of the present application and the features in each embodiment may be combined with each other.

[0042] In the present application, unless otherwise clearly defined and limited, the first feature being "on" or "under" the second feature may be that the first and second features are in direct contact, or the first and second features are indirectly in contact through an intermediate medium. In the description of this specification, the description of reference terms such as "one embodiment", "some embodiments", "example", "specific example", or "some examples" means that the specific features, structures, materials, or characteristics described in connection with the embodiment or example are included in at least one embodiment or example of the present application. In this specification, the schematic representations of the above terms do not necessarily refer to the same embodiment or example. Moreover, the specific features, structures, materials, or characteristics described may be combined in any one or more embodiments or examples in a suitable manner.

[0043] Embodiment 1

[0044] As Figure 1 shown, a high-performance page rendering acceleration method applicable to a data visualization interface includes:

[0045] Cache the page data according to preset conditions, where the page data includes page chart data and associated query conditions and configuration conditions.

[0046] Specifically, the "data caching" mentioned here refers to the data generated and saved through processes such as data fetching and calculation, and this data can be returned to the client as page chart data.

[0047] Location: The data cache is stored on the server side rather than the client side, which enables it to be shared and used by multiple requests.

[0048] Sharing and reuse: The cached content includes query conditions and configuration conditions. As long as the same conditions are met, the same cached data can be reused.

[0049] Valid time and conditions: The cache usually has a set expiration period or resource occupancy threshold. Once it times out or exceeds the threshold, it will be destroyed, and whether to regenerate it is determined according to user configuration.

[0050] Different from server-side rendering: The data cache module focuses on the acquisition and processing of chart data and does not involve the rendering work of the client page.

[0051] Function points

[0052] Save data cache: When the cache function of the page is enabled, the system will perform data fetching and calculation for the selected page under the selected query conditions on the server side and save the results as cache.

[0053] Actively refresh data cache: Support setting an interval to automatically update the cache, such as triggering an update every day at midnight or every few hours.

[0054] Passively refresh data cache: If the cache is enabled on the page but no active refresh is set, and there is no cached data currently, the first access will trigger the complete data fetching and calculation process and save it as cache.

[0055] Disable cache for charts separately: For charts that require real-time data, the cache can be configured not to be used separately to meet different business requirements.

[0056] Operation process

[0057] Enable the cache function in the page configuration, and you can choose the active or passive refresh mode.

[0058] The server automatically generates and refreshes the cache data regularly according to the configuration.

[0059] When the user opens the page, if there is valid cached data, directly read the chart data from the cache and skip the database data fetching and logic processing steps.

[0060] If there is no valid cache, the system will perform normal database data retrieval and calculations, and save the results as cache data simultaneously.

[0061] For example, suppose there is a sales data analysis dashboard that contains multiple pages, such as "Total Sales", "Sales Distribution by Region", "Monthly Sales Trend", etc. Each page consists of different charts, such as bar charts, pie charts, and line charts.

[0062] Enable cache function: The cache function is enabled for the "Total Sales" page in the system, and it is set to actively refresh the cache at 2 am every day.

[0063] Preset condition setting: Preset conditions include query conditions and configuration conditions such as time range (e.g., the past month), product category (all categories), and geographical region (national scope).

[0064] Cache generation process: At 2 am every day, the server will automatically execute a complete data retrieval and calculation process, obtain data that meets the above query conditions (i.e., national sales of all products in the past month), and save it as cache data.

[0065] User access experience: When a user first accesses the "Total Sales" page on the same day, since there is already valid cache data, the system directly reads the data from the cache without having to perform complex database queries and calculations again, thus greatly shortening the loading time.

[0066] Real-time data requirement processing: Suppose a certain pie chart on the "Sales Distribution by Region" page needs to display the latest real-time data, so it is configured separately not to use the cache. When a user accesses this page, the system will perform real-time data queries and calculations and will not use the cache data.

[0067] Passive refresh example: If the "Monthly Sales Trend" page is not set to actively refresh the cache and there is no valid cache data currently. Then when a user first accesses this page, the system will execute a complete data retrieval and calculation process and save the results as cache data. The next time a user accesses the same page, if the cache data is still valid, it can directly use the cache data; otherwise, it recalculates and updates the cache.

[0068] Validity period management: The validity period of the cache is set to one day. After this time period, even if there is cache data, it will be destroyed, and new cache data will be regenerated the next time it is accessed.

[0069] In this way, the system can pre-cache page diagrams under specific query conditions and configuration conditions.

[0070] Furthermore, based on user behavior analysis: The system can dynamically adjust the caching strategy according to the user's access habits and behavior patterns. For example, if the data of certain pages or charts is frequently accessed, a more frequent active refresh period can be set to ensure that this data is always up-to-date. In addition to the preset global caching strategy, a more flexible on-demand caching mechanism can also be implemented. When an increase in demand for a specific chart or page is detected, temporarily increase its caching priority or extend the cache expiration period.

[0071] Introduce a multi-level caching architecture. Not only implement caching on the server side, but also consider deploying cache nodes on the client side or edge servers to further reduce latency and improve response speed. For large data visualization systems, a distributed caching solution can be adopted, storing the cached data distributedly on multiple nodes to improve the scalability and fault tolerance of the system.

[0072] Support incremental updates of cached data instead of full updates, that is, only update the part of the data that has changed, thereby reducing unnecessary consumption of computing resources and accelerating the cache update speed. Combine with the business logic to trigger the cache refresh process when a specific event occurs (such as new data arrives, the user submits new filtering conditions, etc.) to ensure that the cached data always reflects the latest status.

[0073] Use machine learning algorithms to build a prediction model to predict which pages or charts are likely to be accessed, preload the relevant cached data, and improve the cache hit rate. Automatically adjust the cache size and life cycle parameters according to the actual running situation to maximize the cache utilization rate while ensuring that the system performance is not affected.

[0074] To prevent the leakage of sensitive information, encrypt the cached data to ensure that even if the cached data is illegally obtained, the content cannot be directly read. Implement strict access control policies to ensure that only authorized users can access specific cached data, protecting data privacy and security.

[0075] When the user first accesses a page, if there is valid cached data, directly return the cached page data to shorten the loading time.

[0076] Specifically, cache generation under preset conditions: According to a preset time interval or trigger condition (such as automatic refresh at 2 am every day), the server will fetch and calculate the page data and update the cache. When the user accesses a page that is not cached, the system will execute the complete data acquisition and calculation process and save the result as cached data.

[0077] Cache expiration management: Each cached data has its expiration period or resource occupancy threshold. Once the expiration period is exceeded or the resource occupancy limit is exceeded, the corresponding cached data will be destroyed and regenerated.

[0078] Cache Usage at First Visit: When a user first visits a page, the system first checks if there is valid cached data for that page. If there is valid cached data, the system does not perform a new data acquisition and calculation process. Instead, it directly reads the required data from the cache and quickly returns it to the client for display. This can significantly reduce the page loading time and enhance the user experience. If there is no valid cached data, the system will follow the normal process to acquire and process the data, and while presenting the processed data to the user, it will also save this data as a new cache for subsequent use.

[0079] Enhancing User Experience: This approach is particularly suitable for scenarios where data display does not change frequently, such as daily reports and monthly analysis reports. By pre-caching this data, it can provide an almost instant response speed when users first visit, greatly improving the system's response efficiency.

[0080] For data that needs to be updated in real-time, the timeliness of the data can be ensured by separately configuring the chart not to use the cache function.

[0081] Suppose there is a data analysis platform that includes a page for displaying the sales situation in the past month. To improve the user experience, the administrator sets the cache data of this page to be automatically refreshed at 2 am every day. When a new user first visits this page at 9 am:

[0082] The system first detects the existing cached data (since it has been 7 hours since the last refresh);

[0083] Confirms that the cached data is still within the valid period and does not exceed the resource limit;

[0084] Directly reads the required data from the cache and quickly renders the page for display to the user without waiting for the completion of a new data query and calculation process.

[0085] For example, assume there is a page named "Daily Sales Amount" in the system, which shows the total sales amount for each day in the most recent 30 days. Since this data does not change in real-time (usually updated once a day), it is very suitable for caching.

[0086] Cache Settings and Operation Process

[0087] Cache Generation under Preset Conditions: The system administrator configures the data cache of the "Daily Sales Amount" page to be automatically refreshed at 2 am every day. When the set time point is reached, the server will execute the data acquisition and calculation process and save the result as cached data.

[0088] User's First Page Visit: A new employee logs into the system for the first time at 9 am and navigates to the "Daily Sales" page. The system detects that there is valid cached data currently available (since it has not exceeded the one-day validity period since the last update).

[0089] Return Cached Data Directly: The system directly reads the data required for the "Daily Sales" page from the cache and quickly renders the page for the user. This means that the user does not need to wait for the system to re-query the database and perform related calculation processes, thus greatly shortening the page loading time.

[0090] Enhanced User Experience: The new employee can immediately see the latest sales data chart without having to endure a long loading wait. For data that needs to be viewed frequently but does not change often, such as "Daily Sales" in this example, this caching strategy greatly enhances user satisfaction and work efficiency.

[0091] Specific Implementation Details

[0092] Cache Validity Period Management: In this example, the data cache for the "Daily Sales" page is set with a 24-hour validity period. Once this time period is exceeded, even if there is cached data, it will be considered invalid, and the system will recalculate and update the cache the next time it is accessed.

[0093] Handling after Cache Expiration: If the user accesses the page after the cache has expired, the system will execute the full data acquisition and calculation process and save the new results as cached data for subsequent use.

[0094] Flexible Adjustment: For certain charts or data with high real-time requirements, the caching function can be disabled individually to ensure that the latest data is displayed every time it is accessed.

[0095] Furthermore, not only should it be checked whether the cache exists, but also the validity of the cache content should be carefully verified. For example, ensure that the cached data has not been tampered with and is consistent with the latest data through version numbers or checksums (checksum).

[0096] Intelligent Cache Expiration Detection: Develop a more intelligent cache expiration detection mechanism, such as automatically adjusting the cache validity period based on the data change frequency instead of a fixed time interval.

[0097] Adopt a transaction mechanism when updating the cache to ensure data consistency and integrity even in case of errors during the update process. Handle the situation where multiple concurrent requests attempt to access or update the same cache item simultaneously to avoid data inconsistency issues.

[0098] Use an efficient data compression algorithm to reduce the size of cached data, thereby accelerating the transmission speed and saving storage space. For particularly large data sets, a chunking approach can be adopted for caching, enabling partial data to be loaded and displayed more quickly without having to wait for the entire data set to finish loading.

[0099] Although caching has been used to speed up loading, for very complex pages, a progressive loading strategy can be further adopted, that is, first display the core information and then gradually load other non-critical content. Anticipate and preload data that may be needed in advance based on the user's browsing habits or prediction models to further reduce waiting time.

[0100] To protect sensitive information, encrypted data can be stored in the cache, and only authenticated clients can decrypt and use this data. Define different cache access permissions for different user roles to restrict unauthorized access.

[0101] Monitor the user operation status on the client side. When the system is idle, perform background preloading of unopened pages.

[0102] Specifically, monitor the user operation status

[0103] Activity monitoring: The client includes a resource activity listener for monitoring user interaction behaviors. This includes but is not limited to operations such as page loading, query execution, and menu switching.

[0104] Judge the system status: Based on the monitored information, the system can determine whether it is currently in an idle state. For example, if there are no ongoing data loading or query requests on the foreground page, the system is considered to be in an idle state.

[0105] Condition-triggered preloading: When it is detected that the system enters the idle state, start background preloading tasks. These tasks will perform data loading for pages that the user has not opened yet but may access.

[0106] Hidden layer loading: Preloading is carried out in the form of hidden layers, which means that even if a page is being preloaded, it will not affect the content that the current user is viewing. This approach ensures that the fluency and response speed of the front-end interface are not affected.

[0107] Pause and resume mechanism: If during the preloading process, the user starts a new operation (such as initiating a query request or switching pages), immediately pause the preloading to give priority to handling the user request. Once the user operation is completed and the system enters the idle state again, the preloading task will automatically resume.

[0108] Priority adjustment: Dynamically adjust the priorities of different preloading tasks according to the actual situation. For example, for pages that are predicted to be more likely to be accessed based on user behavior, higher priorities can be assigned to speed up their loading.

[0109] Practical application example: Suppose in a data visualization system, the user opens the home page H and finishes loading. At this time, the system listens and discovers that the user has no further operations for the moment (i.e., the system is in an idle state). Then, the system starts to preload the contents of menu pages A, B, and C in the background.

[0110] If the user suddenly decides to switch to menu page B, ideally, since the page has been preloaded, it can be immediately displayed without additional waiting for the loading time. If the user switches to a page that has not been preloaded yet, the system will prioritize the loading of this page and pause other background preloading tasks simultaneously.

[0111] For example, suppose a market analyst is using this data visualization system to view the sales overview page (home page) and has completed the loading of this page. Next, let's see how to apply the background preloading mechanism to enhance the user experience.

[0112] Initial state: The market analyst opens the home page of the system, and the data on the home page has been fully loaded.

[0113] Monitor the user operation status: The resource activity listener built into the client starts to monitor the user's operations. In this example, the analyst has no further operations for the moment (such as switching to other pages or performing new queries).

[0114] Detect the idle state of the system: The system determines through the listener that there is no ongoing data loading or query request currently, so it considers the system to be in an idle state.

[0115] Start background preloading tasks: Since the system is in an idle state, the client decides to start background preloading of pages that have not been opened but may be accessed. For example, the system can choose to preload the two pages of "Regional Sales Analysis" and "Product Category Sales Situation".

[0116] These pages will be loaded in the background in the form of hidden layers without affecting the content of the currently displayed home page.

[0117] Pause and resume preloading: During the preloading process, if the analyst suddenly decides to switch to the "Regional Sales Analysis" page, the system will immediately detect this operation and pause all other background preloading tasks to prioritize the loading of the "Regional Sales Analysis" page.

[0118] If the analyst returns to the home page and stops operating again, the system will resume the previous background preloading task and continue to load the unfinished "Product Category Sales" page.

[0119] Actual experience improvement: When the analyst first tries to switch to the "Regional Sales Analysis" page, since the page has been preloaded, it can be displayed almost instantaneously without additional waiting for the loading time.

[0120] For the "Product Category Sales" page, even if the analyst tries to access it before the preloading is completed, since some data has been preloaded in advance, the total loading time will be much shorter than the case without preloading.

[0121] Intelligent priority adjustment: The system can adjust the preloading priorities of different pages according to the user's browsing history or prediction models. For example, if the system finds that the analyst often views the "Regional Sales Analysis" page, it can preferentially preload this page during idle time.

[0122] Effective utilization of caching: If there is valid server-side cached data for the preloaded page, the data can be directly obtained from the cache, further accelerating the preloading speed.

[0123] Real-time consideration: For those data charts that need to be updated in real time, the cache can be separately configured not to be used to ensure that the latest data is obtained each time it is loaded.

[0124] Furthermore, not only monitor whether there is user interaction (such as clicks, swipes, etc.), but also monitor the types of tasks currently being executed (such as data queries, chart rendering, etc.) to more accurately judge the actual load situation of the system. By analyzing the user's browsing habits and historical records, predict the pages that may be accessed next and adjust the preloading priorities in advance.

[0125] Automatically adjust the number of preloading tasks in progress according to the device performance and network conditions to avoid over-occupying system resources and causing slow response in the foreground.

[0126] Differentiated processing based on content importance: Give higher preloading priorities to key business modules or content with high access frequencies to ensure that these parts can be presented to users faster.

[0127] Decompose complex pages into multiple smaller parts and load them step by step in the order of importance. For example, first load the page framework and basic data, and then fill in the detailed information. If new data changes are found during the preloading process, only update the changed parts instead of the entire page; at the same time, merge similar requests to reduce the server burden.

[0128] When a network interruption or other abnormal situation occurs during the preloading process, it should be able to pause and record the current progress, and continue to complete the remaining tasks when conditions permit. If the preloading failure affects the user experience, a function to quickly switch to the original loading mode should be provided to ensure that the basic functions are not affected.

[0129] Ensure that all preloaded data is encrypted during transmission to prevent the leakage of sensitive information. Implement strict permission management for preloaded content to ensure that only authorized users can access the corresponding resources.

[0130] Design a preloading solution that is compatible with multiple operating systems and browsers to ensure a consistent and good experience on both desktop and mobile devices. Adjust the preloaded content and format according to different device characteristics (such as screen size and resolution) to maximize the utilization of available resources.

[0131] If there is valid server-side cached data for the preloaded page, the data should be preferentially obtained from the cache.

[0132] Specifically, cache generation: Set specific conditions (such as timed triggering or event-driven) on the server side to automatically execute the data fetching and calculation of the page data, and save the results as cached data.

[0133] When a user first visits a certain page, if there is no ready cached data for that page, the system will execute the complete data fetching and calculation process and save the final result as a cache.

[0134] Cache validity management: Each cache has a set expiration date or resource occupancy threshold. Once the expiration date is exceeded or the resource limit is exceeded, the corresponding cached data will be destroyed and regenerated.

[0135] The system will regularly check the validity of the cache to ensure that the cached data used is always the latest and valid.

[0136] Cache usage during background preloading: When the client is idle and starts background preloading of unopened pages, the system first checks whether there is valid cached data for these pages on the server side.

[0137] If there is valid cached data, the system will directly read the required data from the cache without having to execute the time-consuming data fetching and calculation steps again.

[0138] Suppose there is a data visualization interface for an e-commerce platform, which contains a page named "Monthly Sales Analysis" that shows the sales statistics for each month. To optimize performance, the administrator configures the data of this page to be updated once every day at midnight and stored in the server-side cache.

[0139] User Behavior: A market analyst logs into the system at 9:00 am to view the content of other pages, and the system is in an idle state at this time.

[0140] Background Preloading Start: After detecting that the system is currently in an idle state, the system decides to perform background preloading on the "Monthly Sales Analysis" page that has not been accessed yet but may be needed.

[0141] Cache Check and Usage: Before attempting to load the "Monthly Sales Analysis" page, the system first checks whether there is valid cached data for this page on the server. Since an update was just completed the previous night, valid cached data is found.

[0142] Quick Response: The system directly reads the required charts and data from the cache without repeating the data query and calculation process, greatly shortening the preloading time.

[0143] User Experience Enhancement: When the market analyst finally switches to the "Monthly Sales Analysis" page, the latest sales statistics can be seen almost immediately without waiting for data loading and processing.

[0144] For example, assume that a market analyst is using this data visualization system to view the sales overview page and the system is in an idle state. At this time, the system decides to perform background preloading on the "Regional Sales Analysis" page that has not been opened yet but may be needed.

[0145] Initial State: The market analyst opens the home page (sales overview) of the system and completes the loading of this page.

[0146] Monitoring User Operation Status: The resource activity listener built into the client starts monitoring the user's operations. In this example, the analyst has no further operations for the time being (such as switching to other pages or performing new queries).

[0147] Detecting System Idle State: The system determines through the listener that there are no ongoing data loading or query requests currently, so it considers the system to be in an idle state.

[0148] Starting Background Preloading Task: Since the system is in an idle state, the client decides to start background preloading the page that has not been opened yet but may be accessed - in this case, the "Regional Sales Analysis" page.

[0149] Checking Server Cache: Before attempting to load the "Regional Sales Analysis" page, the system first checks whether there is already valid cached data for this page on the server.

[0150] Assume that the system is configured to automatically refresh the cache data of all pages at 2:00 am every day, and the current time is 9:00 am, so the cached data of the "Regional Sales Analysis" page is still valid.

[0151] Prefer to obtain data from the cache: Since there is valid cached data, the system will not re - execute the time - consuming data acquisition and calculation steps, but directly read the required data from the server - side cache.

[0152] These data will be quickly loaded into the hidden layer of the client, ready to be immediately displayed when the user actually accesses the page.

[0153] Improved user experience: When the market analyst finally decides to switch to the "Regional Sales Analysis" page, since the page has been pre - loaded and the data is obtained from the cache, the latest sales analysis charts and data can be seen almost immediately without additional waiting for the loading time.

[0154] Handle the situation of no cache or expired cache: If in a certain situation, the cached data does not exist or has expired, the system will automatically execute the complete data acquisition and calculation process, and save the newly generated results as cached data for subsequent use.

[0155] Multi - level cache strategy: If the system adopts a multi - level cache strategy (such as having both local cache and distributed cache), then before checking the server - side cache, the local cache can be checked first. If there is available local cached data, it can be directly used to further reduce latency.

[0156] Intelligent cache update: Suppose the system detects certain specific condition changes (such as new sales data arriving), it can trigger an immediate update of the cache to ensure that the latest data can be provided even within non - scheduled refresh cycles.

[0157] Furthermore, introduce a version number for each cache item to ensure that the version number increases each time it is updated. When the client requests cached data, it can check whether the version of the cache is the latest. Use a checksum to verify the integrity of the cached data to ensure that the data has not been tampered with and remains consistent.

[0158] Dynamically adjust the cache expiration period according to the actual change frequency of the data. For example, for frequently changing data, shorten the cache expiration period; while for relatively stable data, extend the expiration period. Analyze the user access pattern and adopt a longer cache expiration period for data that is frequently accessed but not often changed.

[0159] Before transmitting the cached data from the server to the client, use an efficient compression algorithm to reduce the data volume, thereby accelerating the transmission speed and saving bandwidth.

[0160] For a large cached data set, adopt a chunked transmission method, allowing partial data to arrive first and be displayed to the user without having to wait for the entire data set to be fully loaded.

[0161] Support partial data updates only for the changed parts instead of full - scale updates, which can reduce unnecessary consumption of computing resources while ensuring data currency.

[0162] If multiple concurrent requests need the same or similar cached data, the server can merge these requests and return the required data at once, reducing the workload of repeated processing.

[0163] To prevent sensitive information leakage, encrypt the cached data stored and transmitted on the server side to ensure that only authenticated clients can decrypt and use this data. Implement strict access control policies, define the access rights of different user roles to cached data, restrict unauthorized access, and protect data security and privacy.

[0164] In a distributed environment, improve the high availability and fault - tolerance of the system by replicating cached data across multiple nodes to ensure that the system can still provide cached data normally even if a certain node fails. When the cache becomes invalid or is lost, the system can automatically trigger the process of regenerating the cache and accelerate the recovery process by making the best use of existing data fragments as much as possible.

[0165] During the pre - loading process, listen to user operations in real - time. If it detects that the user initiates a page switch or query request, pause the pre - loading to give priority to the user operation and resume the pre - loading after the user operation is completed.

[0166] Specifically, listen to user operations in real - time

[0167] Activity monitoring unit: The client - side page pre - loading module contains an activity monitoring unit dedicated to monitoring user interaction behaviors such as page switching and query requests.

[0168] This monitoring is carried out in real - time and can quickly capture any user operation.

[0169] Judge the type of user operation:

[0170] When the user performs a specific operation (such as clicking a menu item to switch pages or submitting a query request), the system will recognize these actions and evaluate their impact on the current task.

[0171] If it detects that the user is initiating a new page switch or query request, the system will immediately take action to adjust resource allocation.

[0172] Pause and resume the pre - loading task

[0173] Pause pre - loading: Once the system detects that the user has initiated a new page switch or query request, it will immediately pause the ongoing background pre - loading task.

[0174] The purpose of doing this is to release system resources to quickly respond to the immediate needs of users and ensure the fluency and response speed of the user interface.

[0175] Prioritize user requests: After pausing preloading, the system focuses all available resources on processing the user's current requests, whether it is loading a new page or performing a query operation.

[0176] This process usually involves obtaining the latest data from the server, rendering page content, or presenting query results.

[0177] Resume preloading: Once the user's request is properly processed and the system enters the idle state again, the previously paused preloading tasks will automatically resume.

[0178] The system will continue the unfinished preloading work to prepare for possible subsequent operations.

[0179] Suppose in a data visualization platform, the user opens the home page and starts viewing some basic statistical data. At this time, the system is in the idle state, and the client starts the background preloading task to preload other potentially accessible pages in advance, such as "Sales Overview" and "Regional Analysis".

[0180] Initial state: The system is preloading the data of the "Sales Overview" page in the background.

[0181] User behavior trigger: The user suddenly decides to switch to the "Product Category Sales" page.

[0182] Pause preloading: The system immediately detects the user's behavior and pauses the preloading task of the "Sales Overview".

[0183] Prioritize responding to user requests: The system quickly switches to processing the user's request, loads and displays the content of the "Product Category Sales" page.

[0184] Resume preloading: Once the "Product Category Sales" page is fully loaded and the user has no further operations, the system returns to the idle state again and resumes the preloading task of the previously paused "Sales Overview" page.

[0185] For example, assume that a market analyst is using this data visualization system to view the home page, and the system is in the idle state and starts background preloading of the unopened "Regional Sales Analysis" page.

[0186] Specific process of background preloading and user interaction

[0187] Initial state: The market analyst opens the home page of the system, and the data on the home page has been fully loaded.

[0188] Start background preloading task: The system detects that it is currently in an idle state and starts to preload the data of the "Regional Sales Analysis" page in the background. At this time, the data of the "Regional Sales Analysis" page is being loaded in the background in the form of a hidden layer.

[0189] Monitor user operation status: The resource activity listener built into the client continuously monitors the user's operations. For example, when the analyst has no further operations for the time being (i.e., the system is in an idle state), the background preloading continues.

[0190] User initiates a new operation: During the preloading process, the market analyst suddenly decides to switch to the "Product Category Sales" page. At this time, the system immediately detects this operation.

[0191] Pause preloading: Once it detects that the user has initiated a new page switching request, the system immediately pauses the background preloading task of the "Regional Sales Analysis" page that is in progress. This is done to ensure that the system can concentrate resources to quickly respond to the user's immediate needs and guarantee the fluency of the user experience.

[0192] Prioritize user requests: The system quickly turns to process the user's new request, prioritizing the loading and display of the content of the "Product Category Sales" page. If there is also cached data for the "Product Category Sales" page, the system will directly obtain the data from the cache to speed up the loading.

[0193] Complete user request: After the "Product Category Sales" page is successfully loaded and displayed to the user, the system enters the idle state again.

[0194] Resume preloading: The system detects that it has entered the idle state again and resumes the background preloading task of the "Regional Sales Analysis" page that was previously paused. If part of the data of the "Regional Sales Analysis" page has been loaded during the pause, the system will continue to load the remaining data from where it was paused last time.

[0195] Actual experience improvement: When the market analyst needs to view the "Regional Sales Analysis" page later, since most of the data has been preloaded in the background, the complete page content can be seen almost immediately without waiting for a long time to load. If the analyst tries to access the page before the preloading is completed, the system will prioritize the loading of this page and pause other background preloading tasks to ensure that the user can see the required information as soon as possible.

[0196] Furthermore, not limited to page switching and query requests, other types of user interaction behaviors such as scrolling and clicking on specific elements can also be monitored to more accurately judge the user's immediate needs. Use machine learning algorithms to analyze the user's historical behavior patterns, predict the operations that the user may take in advance, and adjust the preloading strategy accordingly.

[0197] Dynamically adjust the priorities of preloading tasks and other system tasks according to the importance and urgency of the user's current operation. For example, when the user performs an important query, significantly reduce the priority of the preloading task. When it is detected that the system resources are tense, automatically reduce or pause the preloading task to ensure that the fluency of foreground operations is not affected.

[0198] When pausing the preloading, record the current loading progress and status information so that when resuming, it can continue to load from the breakpoint instead of starting the whole process over again. For critical data that needs to be frequently accessed, these data can be preferentially loaded during the pause of preloading to ensure that even if the user switches back to the original page, some content can be quickly displayed.

[0199] Even during the pause of preloading, a progressive loading prompt can be provided to the user to let the user understand the processing progress of the system, thereby improving transparency and satisfaction. Provide a visual background task management interface that allows the user to view the status of all background tasks (including preloading tasks) currently in progress and manually control the pause or resume of some tasks.

[0200] If an error occurs during the pause or resume process, the system should have a corresponding error handling mechanism that can automatically attempt to fix the problem or give a clear error prompt. Set up an automatic recovery strategy to ensure that in any situation (such as network interruption, system crash, etc.), the preloading task can automatically resume and continue to execute when conditions permit.

[0201] During the process of pausing and resuming preloading, ensure that all data transmissions involved are encrypted to prevent the leakage of sensitive information. Implement strict permission verification for each preloading task to ensure that only authorized users can trigger or resume these tasks, protecting the security and privacy of the data.

[0202] According to an embodiment of the present application, caching the page data according to preset conditions specifically includes:

[0203] Automatically execute the data fetching and calculation of the page data according to a preset time interval or trigger condition, and update the cache;

[0204] When the user accesses an uncached page, execute the complete data fetching and calculation process and save the result as cached data;

[0205] Set a validity period or resource occupancy threshold for the cached data, and automatically destroy and regenerate it after expiration or exceeding the threshold.

[0206] Specifically, automatically execute the data fetching and calculation of the page data according to a preset time interval or trigger condition, and update the cache

[0207] Preset time interval: The system can set a fixed time interval (e.g., 2:00 am every day). At this time point, the system automatically performs the operations of obtaining and calculating page data, and saves the results as cache. This method is applicable to pages with relatively low data change frequency and relatively stable data.

[0208] Trigger conditions: In addition to scheduled tasks, specific trigger conditions can also be set to start the cache update process. For example, when relevant data in the background database changes, or when the administrator manually triggers an update, the system will automatically perform data fetching and calculation for the page data and update the corresponding cache.

[0209] When a user accesses an uncached page, the complete data fetching and calculation process is executed, and the results are saved as cache data

[0210] First access processing: If the page requested by the user has never been cached, the system needs to execute the data acquisition and calculation process from scratch. This usually involves interacting with the database to extract the latest data, and then performing necessary calculations or formatting based on this data.

[0211] Cache generation: Once the above process is completed, the system saves the finally obtained data as cache data. In this way, in subsequent requests for the same page, as long as the cache is still valid, the data in the cache can be directly used without having to repeat the time-consuming data acquisition and calculation steps.

[0212] Set an expiration period or resource occupancy threshold for the cache data, and automatically destroy and regenerate it after expiration or exceeding the threshold

[0213] Expiration period management: Each cache data has a set expiration period. This expiration period can be flexibly adjusted according to business requirements. For example, for some frequently changing data, a shorter expiration period can be set; while for relatively stable data, a longer expiration period can be set. Once the expiration period is exceeded, the cache data is considered expired and will no longer be used.

[0214] Resource occupancy threshold: In addition to the expiration period, a resource occupancy threshold can also be set for the cache data. This means that if the cache data occupies too many server resources (such as memory), even if it has not reached its expiration period, it may be automatically destroyed and regenerated. This method helps prevent system performance degradation caused by excessive caching.

[0215] Automatic destruction and regeneration: When the cache data expires or exceeds the resource occupancy threshold, the system will automatically destroy it and re-execute the data acquisition and calculation process when the page is requested next time to generate new cache data.

[0216] According to an embodiment of the present application, the configuration of the page data cache is page-based and supports disabling the cache function separately for each chart to meet the real-time data requirements.

[0217] Specifically, overall control: The cache settings can be configured based on the entire page. This means that administrators or developers can select which pages need to enable caching and the specific parameters of these caches (such as refresh frequency, expiration date, etc.).

[0218] Unified management: Through the cache configuration at the page level, it is more convenient to manage and maintain the cache policy of the system. For example, for pages with infrequent data changes but high access volume, a longer expiration date can be set to reduce the server load.

[0219] Fine-grained control: Although the cache function is enabled for the entire page, for certain specific charts, if their data needs to be updated in real time, the cache function of these charts can be disabled separately. This ensures that even if the data of other parts of the page is obtained from the cache, these key charts can display the latest information.

[0220] Enhanced flexibility: This fine-grained control method enables the system to better adapt to different business scenarios. For example, in a complex page containing multiple charts, some charts may display daily summary data, while others need to display real-time transaction data updated every minute. In this case, the cache of the latter charts can be disabled to meet the real-time requirements.

[0221] Data freshness: By allowing the cache function to be disabled separately for each chart, the system can provide the freshest data according to actual needs. This is particularly important for application scenarios with extremely high requirements for data timeliness, such as financial transaction monitoring and online advertising effect tracking.

[0222] User experience optimization: Reasonable use of cache and real-time data loading strategies can not only improve the page loading speed but also ensure that the information seen by users is the latest, thereby enhancing the user experience and satisfaction.

[0223] Suppose there is a data visualization dashboard on an e-commerce platform, which contains the following types of charts:

[0224] Sales overview chart (showing the sales trend in the past month)

[0225] Real-time order status chart (showing the current ongoing orders)

[0226] Customer distribution map (showing the geographical distribution of customers)

[0227] In this example:

[0228] For the "Sales Overview Chart", since its data is relatively stable, caching can be enabled and the cache can be set to automatically refresh at midnight every day.

[0229] For the "Real-time Order Status Chart", since it needs to display the latest order status, the caching function should be disabled separately to ensure that the latest data can be obtained from the database every time the page is loaded.

[0230] For the "Customer Distribution Map", if the data update frequency is low, caching can also be enabled; but if it is found that a large number of new customers have been added in a certain region, the caching for this chart can be considered disabled, or the cache expiration period can be shortened.

[0231] According to an embodiment of the present application, the pages pre-loaded in the background are loaded in the form of hidden layers, and the pre-loading process supports pausing, resuming, and priority adjustment.

[0232] Specifically, the pages pre-loaded in the background are loaded in the form of hidden layers

[0233] Hidden layer loading:

[0234] Does not affect the current interface: When the system is idle, background pre-loading of unopened but potentially accessible pages begins. The data for these pages is loaded in the form of hidden layers in the background, which means that even while the data is being pre-loaded, it will not affect the content or operations that the user is currently viewing.

[0235] Prepare content in advance: In this way, once the user decides to switch to a pre-loaded page, the system can immediately display the content of that page without having to wait for new data requests and processing.

[0236] The pre-loading process supports pausing

[0237] Pausing pre-loading:

[0238] Respond to immediate needs: If during the pre-loading process, the system detects that the user has initiated a new page switch or query request, the ongoing pre-loading task will be immediately paused. This is to ensure that the system can concentrate resources to quickly respond to the user's immediate needs and guarantee the fluency of foreground operations.

[0239] Resource reallocation: Pausing pre-loading allows the system to release more computing resources for processing the user's current request, avoiding performance degradation caused by executing multiple tasks simultaneously.

[0240] The pre-loading process supports resuming

[0241] Resuming pre-loading:

[0242] Continuing Unfinished Tasks: Once the user's request is properly processed and the system enters the idle state again, the previously suspended preloading tasks will automatically resume. This enables the system to continue preparing for subsequent possible operations without disturbing the user's actions.

[0243] Resume from Breakpoint: When resuming preloading, the system can continue loading the remaining data from the point where it was last suspended instead of starting from scratch, thus saving time and resources.

[0244] The preloading process supports priority adjustment

[0245] Priority Adjustment:

[0246] Dynamic Priority Adjustment: Based on the user's browsing habits or prediction models, the system can dynamically adjust the priorities of different preloading tasks. For example, for pages that are predicted to be more likely to be accessed according to the user's behavior, higher priorities can be assigned to speed up their loading.

[0247] Reasonable Resource Allocation: By adjusting priorities, the most important data can be preferentially loaded with limited system resources to ensure the continuity and efficiency of the user experience.

[0248] Suppose a market analyst is using a data visualization platform to view the sales overview page, and the system is in the idle state. The system starts to preload the "Regional Sales Analysis" page in the background that has not been opened.

[0249] Initial State: The system starts to load the data of the "Regional Sales Analysis" page in the background in a hidden layer.

[0250] Monitoring User Operations: The resource activity listener built into the client continuously monitors the user's operations.

[0251] User Initiates a New Operation: During the preloading process, the market analyst suddenly decides to switch to the "Product Category Sales" page. At this time, the system detects this operation and immediately suspends the preloading task of the "Regional Sales Analysis" page to give priority to processing the user's new request.

[0252] Resume Preloading: Once the "Product Category Sales" page is successfully loaded and presented to the user, the system enters the idle state again, and then resumes the preloading task of the previously suspended "Regional Sales Analysis" page.

[0253] Priority Adjustment: If the system predicts that the user is more likely to access the "Product Category Sales" page next, then it can adjust the priorities of the preloading tasks to preferentially load the data related to this page.

[0254] According to an embodiment of the present application, during the preloading process, the system listens to user operations in real time. If it detects that the user initiates a page switching or query request, it pauses the preloading to prioritize responding to the user operation, and resumes the preloading after the user operation is completed. This further includes:

[0255] When the user switches to a preloaded page, the preloading result is directly displayed.

[0256] If the target page has not been preloaded completely, the currently requested page is preferentially loaded, and the background preloading task is paused.

[0257] Specifically, the real-time listening:

[0258] The system has an activity monitoring unit built-in, which is responsible for monitoring the user's operation behaviors in real time (such as page switching, query requests, etc.). This enables the system to respond immediately when the user starts a new operation.

[0259] Detecting user actions:

[0260] When the user initiates a page switching or query request, the system will detect these actions. For example, if the user switches from the current page A to page B, or submits a query request to obtain specific data.

[0261] Pausing the preloading to prioritize responding to the user operation

[0262] Pausing the preloading:

[0263] Once the system detects that the user has initiated a new page switching or query request, it immediately pauses the ongoing background preloading task. This is done to ensure that the system can concentrate resources to quickly respond to the user's immediate needs and avoid performance degradation caused by executing multiple tasks simultaneously.

[0264] Prioritizing responding to the user operation:

[0265] After pausing the preloading, the system focuses all available resources on processing the user's current request. This means that whether it is loading a new page or performing a query operation, the system will prioritize completing these tasks to ensure the fluency and response speed of the user experience.

[0266] Resuming the preloading after the user operation is completed

[0267] Resuming the preloading:

[0268] Once the user's request is properly processed and the system enters the idle state again, the previously paused preloading task will automatically resume. The system will continue the unfinished preloading work to prepare for possible subsequent operations.

[0269] Further details: Handling preloaded and incompletely preloaded pages

[0270] Directly display the preloading result:

[0271] If the user switches to a page that has completed preloading, the system can directly display the content of that page without reloading the data. This is because the preloaded data has been prepared in the background and stored in the cache, and can be quickly presented to the user, reducing the waiting time.

[0272] Prioritize loading the currently requested page:

[0273] If the target page that the user switches to has not completed preloading, the system will prioritize loading the currently requested page. This means that the system will interrupt any ongoing background preloading tasks and instead focus on meeting the user's immediate needs.

[0274] Pause background preloading tasks:

[0275] When prioritizing the loading of the page requested by the user, the system will pause all other background preloading tasks to ensure there are sufficient resources to quickly respond to the user's operations. These preloading tasks will only be resumed after the user's request is completed.

[0276] Suppose a market analyst is using a data visualization platform to view the home page, and the system is in an idle state. The system starts to perform background preloading on the unopened "Regional Sales Analysis" page.

[0277] Initial state: The system starts to load the data of the "Regional Sales Analysis" page in the background in a hidden layer.

[0278] Monitor user operations: The built-in resource activity listener on the client continuously monitors the user's operations.

[0279] The user initiates a new operation: During the preloading process, the market analyst suddenly decides to switch to the "Product Category Sales" page. At this time, the system detects this operation and immediately pauses the preloading task of the "Regional Sales Analysis" page.

[0280] Prioritize handling the user's request: The system quickly switches to handling the user's new request and prioritizes loading and displaying the content of the "Product Category Sales" page.

[0281] Resume preloading: Once the "Product Category Sales" page is successfully loaded and displayed to the user, the system enters the idle state again, and then resumes the preloading task of the previously paused "Regional Sales Analysis" page.

[0282] Directly display the preloading result: If the analyst later decides to switch to the preloaded "Regional Sales Analysis" page, the system can directly display the content of that page without reloading the data.

[0283] Preferentially load the currently requested page: If the analyst switches to a page that has not been pre-loaded yet, the system will preferentially complete the loading of that page while pausing other background pre-loading tasks.

[0284] A high-performance page rendering acceleration device applicable to a data visualization interface, comprising:

[0285] A server-side data caching module for generating, updating, and returning page cache data according to preset conditions;

[0286] A client-side page pre-loading module for background loading of unvisited pages in an idle state and dynamically adjusting pre-loading tasks according to user operations;

[0287] A resource scheduling and control module for monitoring user operations in real time and coordinating the resource allocation between the server-side cache and the client-side pre-loading.

[0288] According to an embodiment of the present application, the server-side data caching module includes:

[0289] An active refresh unit configured to trigger data update at regular intervals;

[0290] A passive response unit configured to generate a cache when the user accesses for the first time;

[0291] A cache management unit configured to manage the cache life cycle according to the expiration period or resource threshold.

[0292] According to an embodiment of the present application, the client-side page pre-loading module includes:

[0293] A pre-loading execution unit for loading page data in a hidden layer;

[0294] An activity monitoring unit for detecting user query or page switching operations to control the start and stop of pre-loading.

[0295] A computer-readable storage medium, on which a program is stored, characterized in that when the program is executed by a processor, the steps in the high-performance page rendering acceleration method applicable to a data visualization interface are implemented.

[0296] An electronic device, including a memory, a processor, and a program stored on the memory and executable on the processor, characterized in that when the processor executes the program, the steps in the high-performance page rendering acceleration method applicable to a data visualization interface are implemented.

[0297] What is not described in this application can be implemented by adopting or referring to the existing technologies.

[0298] Each embodiment in this specification is described in a progressive manner. For the same or similar parts among the embodiments, reference can be made to each other, and the key point of each embodiment is to illustrate the differences from other embodiments.

[0299] The above description is only for the embodiments of the present application and is not intended to limit the present application. For those skilled in the art, various changes and modifications can be made to the present application. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present application shall be included within the scope of the claims of the present application.

Claims

1. A high-performance page rendering acceleration method applicable to a data visualization interface, characterized in that, Including: Caching page data according to preset conditions, where the page data includes page chart data and associated query conditions and configuration conditions; When a user first accesses a page, if there is valid cached data, directly return the cached page data to shorten the loading time; Listen for the user operation status on the client side, and when the system is in an idle state, preload unopened pages in the background; If there is valid server-side cached data for the preloaded page, preferentially obtain the data from the cache; During the preloading process, continuously listen for user operations. If it is detected that the user initiates a page switch or query request, pause the preloading to preferentially respond to the user operation, and resume the preloading after the user operation is completed.

2. The method according to claim 1, characterized in that, The caching of page data according to preset conditions is specifically as follows: Automatically execute data fetching and calculation of page data according to a preset time interval or trigger condition, and update the cache; When a user accesses an uncached page, execute the complete data fetching and calculation process, and save the result as cached data; Set a validity period or resource occupancy threshold for the cached data, and automatically destroy and regenerate it after expiration or exceeding the threshold.

3. The method according to claim 2, wherein The configuration of the page data cache is page-based and supports disabling the cache function separately for each chart to meet real-time data requirements.

4. The method according to claim 1, wherein The pages preloaded in the background are loaded in the form of a hidden layer, and the preloading process supports pausing, resuming, and priority adjustment.

5. The method according to claim 4, characterized in that, The continuously listening for user operations during the preloading process, and if it is detected that the user initiates a page switch or query request, pausing the preloading to preferentially respond to the user operation, and resuming the preloading after the user operation is completed, further includes: When the user switches to a preloaded page, directly display the preloading result; If the target page has not been preloaded completely, preferentially load the currently requested page and pause the background preloading task.

6. A high-performance page rendering acceleration device applicable to a data visualization interface, characterized in that, Including: A server-side data caching module for generating, updating, and returning page cache data according to preset conditions; A client-side page preloading module for loading unvisited pages in the background in an idle state and dynamically adjusting the preloading task according to user operations; A resource scheduling and control module for continuously listening for user operations and coordinating the resource allocation between the server-side cache and the client-side preloading.

7. The device according to claim 6, characterized in that, The server-side data caching module includes: An active refresh unit configured to trigger data update regularly; A passive response unit configured to generate a cache when a user first accesses; A cache management unit configured to manage the cache life cycle according to the validity period or resource threshold.

8. The device according to claim 6, characterized in that The client-side page preloading module includes: A preloading execution unit for loading page data in a hidden layer; An activity listening unit for detecting user query or page switch operations to control the start and stop of preloading.

9. A computer-readable storage medium having a program stored thereon, characterized in that, When the program is executed by a processor, it implements the steps in the high-performance page rendering acceleration method applicable to a data visualization interface according to any one of claims 1-5.

10. An electronic device, comprising a memory, a processor, and a program stored on the memory and executable on the processor, characterized in that, When the processor executes the program, it implements the steps in the high-performance page rendering acceleration method applicable to a data visualization interface according to any one of claims 1-5.

Images