Information display method and device, computer device, storage medium and program product

Abstract

The application relates to an information display method and device, computer equipment, a computer readable storage medium and a computer program product. The method comprises the following steps: in response to a page display instruction, displaying a page comprising a guide component; recording the display duration of the page; in the case that an interactive operation of the page is detected, generating an event chain based on the page display instruction, the display duration and the interactive operation; generating guide information based on a guide strategy matched by the event chain; and displaying the guide information near the position of the guide component. The method can reduce the time sequence dependence across pages and realize information guidance in a complex business scenario.

Description

Technical Field

[0001] This application relates to the field of information display technology, and in particular to an information display method, apparatus, computer equipment, computer-readable storage medium, and computer program product. Background Technology

[0002] With the development of internet technology, people are becoming increasingly active and frequent in their online activities, causing most user behavior to shift from offline to online. Therefore, servers configure various information interaction rules and match these rules with user profiles obtained through big data mining to deliver information.

[0003] However, when using traditional user profiles for information push, the expressive power of its rules relies heavily on users' historical data, resulting in significant data latency. Therefore, existing technologies primarily aggregate single indicators within a fixed time window for real-time data analysis, but this data processing is heavily dependent on the time window. Summary of the Invention

[0004] Therefore, it is necessary to provide an information display method, apparatus, computer device, computer-readable storage medium, and computer program product that can overcome the time window limitation in order to address the above-mentioned technical problems.

[0005] In a first aspect, this application provides an information display method, the method comprising:

[0006] In response to a page display instruction, display a page including a guide component;

[0007] Record the display duration of the page;

[0008] Upon detecting an interactive operation on the page, an event chain is generated based on the page display instruction, the display duration, and the interactive operation;

[0009] Guidance information is generated based on the guidance strategy of the event chain matching;

[0010] The guidance information is displayed near the location of the guidance component.

[0011] On the other hand, this application also provides an information display device, the device comprising:

[0012] The display module is used to respond to page display instructions and display a page including a guide component;

[0013] A recording module is used to record the display duration of the page;

[0014] The generation module is used to generate an event chain based on the page display instruction, the display duration, and the interaction operation when an interactive operation on the page is detected.

[0015] The matching module is used to generate guidance information based on the guidance strategy of the event chain matching.

[0016] A guidance module is used to display the guidance information near the location of the guidance component.

[0017] On the other hand, this application also provides a computer device. The computer device includes a memory and a processor, the memory storing a computer program, and the processor executing the computer program to implement the information display steps in any of the above embodiments.

[0018] On the other hand, this application also provides a computer-readable storage medium. The computer-readable storage medium stores a computer program thereon, which, when executed by a processor, implements the information display steps in any of the above embodiments.

[0019] On the other hand, this application also provides a computer program product. The computer program product includes a computer program that, when executed by a processor, implements the information display steps in any of the above embodiments.

[0020] The aforementioned information display method, apparatus, computer device, computer-readable storage medium, and computer program product, in response to a page display instruction, display a page including a guidance component; record the display duration of the page; generate an event chain based on the page display instruction, the display duration, and the interaction operation when an interactive operation on the page is detected; generate guidance information based on a guidance strategy matched by the event chain; and display the guidance information near the location of the guidance component. Thus, by introducing a time-sequential link feature through the display duration, it is helpful to span the page's lifecycle; moreover, the page display instruction, display duration, and interaction operation are all arranged as link features, forming multi-layered nested event combinations, so that data-related instructions or operations, as well as corresponding time events, are all considered link features in the same event chain. This breaks through the limitations of traditional windows, enables the processing of complex temporal logic, reduces cross-page temporal dependencies, and realizes information guidance in complex business scenarios. Attached Figure Description

[0021] To more clearly illustrate the technical solutions in the embodiments of this application or related technologies, the drawings used in the description of the embodiments of this application or related technologies will be briefly introduced below. Obviously, the drawings described below are only some embodiments of this application. For those skilled in the art, other related drawings can be obtained based on these drawings without creative effort.

[0022] Figure 1 This is an application environment diagram of the information display method in one embodiment;

[0023] Figure 2 This is a flowchart illustrating an information display method in one embodiment;

[0024] Figure 3 This is a schematic diagram of the process for generating guidance information in one embodiment;

[0025] Figure 4 This is a schematic diagram of the guidance information and its interface in one embodiment;

[0026] Figure 5 This is a schematic diagram of the program architecture of an information display method in one embodiment;

[0027] Figure 6 This is a schematic diagram of the program processing flow of an information display method in one embodiment;

[0028] Figure 7 This is a structural block diagram of an information display device in one embodiment;

[0029] Figure 8 This is an internal structural diagram of a computer device in one embodiment. Detailed Implementation

[0030] To make the objectives, technical solutions, and advantages of this application clearer, the following detailed description is provided in conjunction with the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative and not intended to limit the scope of this application.

[0031] It should be noted that the terms "first," "second," etc., used in this application can be used to describe various types of data, but these data are not limited by these terms. These terms are only used to distinguish between the first type of data and the second type of data. The term "multiple" used in this application refers to two or more. The term "and / or" used in this application refers to one of the schemes, or any combination of multiple schemes.

[0032] The information display method provided in this application embodiment can be applied to, for example, Figure 1In the application environment shown, terminal 102 communicates with server 104 via a network. A data storage system can store the data that server 104 needs to process. The data storage system can be integrated onto server 104, or it can be located in the cloud or on another network server.

[0033] The terminal 102 can be, but is not limited to, various personal computers, laptops, smartphones, tablets, IoT devices, and portable wearable devices. IoT devices can include smart speakers, smart TVs, smart air conditioners, smart in-vehicle systems, and projection devices. Portable wearable devices can include smartwatches, smart bracelets, and head-mounted displays. Head-mounted displays can be virtual reality (VR) devices, augmented reality (AR) devices, and smart glasses. The server 104 can be a standalone physical server, a server cluster or distributed system composed of multiple physical servers, or a cloud server providing cloud computing services.

[0034] In one exemplary embodiment, such as Figure 2 As shown, an information display method is provided, which can be applied to... Figure 1 The terminal in the process includes the following steps 202 to 210. Wherein:

[0035] Step 202: In response to the page display instruction, display the page including the guide component.

[0036] A page display instruction is an operation command that instructs a terminal to display a specific page. The events generated by a page display instruction not only control the terminal to display a specific page but also serve as link characteristics for subsequent event chains, forming the contextual characteristics of the event chain to initiate the page's event chain lifecycle. Optionally, page display instructions include, but are not limited to, at least one of page entry operations and page click operations for a target object.

[0037] A guidance component is a component that analyzes and displays guidance information in real time by analyzing page-triggered commands while the page is displayed. The guidance component is controlled by an event chain; it can be adjusted based on the conditions met by the event chain to display information. Using a guidance component allows for the determination of appropriate guidance information at the right time, providing new information guidance channels. Optionally, the guidance component can serve as an entry point for accessing intelligent customer service or human assistance functions.

[0038] The page includes at least a guide component and may also include components for providing other functions. The page is capable of supporting corresponding interactive operations to meet the page's interactive needs. Optionally, the page can be a computer terminal page, a mobile phone page, or a mini-program page.

[0039] In some embodiments, in response to a page display instruction, a session page is established; a page identifier is obtained by mapping the identifier of the session page and the identifier of the target object that sent the page display instruction; and the session page is marked with the page identifier.

[0040] In one example, if a page display instruction indicating that a target object has entered the first page is detected, the first page, including the guide component, is displayed; if a page display instruction indicating that a target object has entered the first page is detected, a second page, including the guide component, is displayed; wherein the first page and the second page are different pages. Thus, when a target object such as an agent or user enters a different page, information is displayed on that page.

[0041] Step 204: Record the display duration of this page.

[0042] Display duration is the length of time a page is displayed. It represents the amount of time a target audience spends on the page acquiring information, reflecting the importance of that information to them and thus forming a temporal characteristic across page hierarchy. Therefore, display duration introduces a temporally sequential link characteristic, which is helpful across the page's lifecycle.

[0043] In some embodiments, in response to a page display instruction, a page display event and a page timer event are generated; the page display event refers to displaying a page including a guide component; the page timer event refers to starting to record the duration of the page display event; the result of this recording duration is the display duration of the page.

[0044] In some embodiments, when displaying a page including a guide component and recording the display duration of the page, corresponding page display events and page timed events are used as two link features, arranged in the order that page display events precede page timed events to obtain an initial event chain. Thus, at the stage of receiving the page display instruction and display duration, an initial event chain is constructed, and subsequent events generated by the page can be added to this initial event chain in sequence to form a corresponding lifecycle.

[0045] Step 206: If an interactive operation is detected on the page, an event chain is generated based on the page display instructions, display duration, and interactive operation.

[0046] Interactive actions are operations performed on a webpage, including but not limited to page exit actions, component actions, and click actions; component actions include but are not limited to component entry actions or component exit actions. Interactive actions can represent interactive events generated during the interaction process. Using interactive events as link characteristics, they reflect the information and state of the page and can form contextual control information for the interaction process.

[0047] An event chain is an event queue arranged sequentially according to the generation order of interactive events. Since page display instructions, display duration, and interactive operations are all arranged as chain features, contextual information can be formed by the chain features triggered by page display instructions and the chain features triggered by each interactive operation. At the same time, a temporal pattern can be constructed by the chain features formed by the display duration to represent the dwell time or pause of the target object on the page, thus forming a multi-layered nested event combination.

[0048] In some embodiments, page display instructions, display duration, and interactive operations are all used as link features; event chains are formed by combining the link features; each newly generated link feature can be combined into the original event chain, or a preset number of link features can be combined into the original event chain when the number of generated link features reaches a preset number.

[0049] Step 208: Generate boot information based on the boot strategy of event chain matching.

[0050] A guidance strategy is a set of conditions that match an event chain. When the characteristics of an event chain satisfy a certain set of conditions, guidance information can be obtained by mapping based on this set of conditions. Optionally, the guidance strategy includes the type and sequence conditions of page display instructions, display duration, and interactive operations, to form diverse guidance information.

[0051] The guidance information is service information corresponding to the event chain; the guidance information page generated by the terminal will be different when the guidance strategy for matching the event chain is different. Optionally, the guidance information can be information used to access intelligent customer or human consultation functions. For example, the guidance information can be "What is the difference between this data resource of type A and other data resources of type A?" or "Please click on area B to learn about the characteristics of this data resource in aspect B."

[0052] In some embodiments, when the page display instruction is a first display type, the display duration is a first duration interval, and the interactive operation is a first interaction type, a first guidance strategy matching the event chain is determined, and guidance information of the first guidance strategy is output; when the page display instruction is a second display type, the display duration is a second duration interval, and the interactive operation is a second interaction type, a second guidance strategy matching the event chain is determined, and guidance information of the second guidance strategy is output.

[0053] Step 210: Display boot information near the location of the boot component.

[0054] The vicinity of the location refers to the area that has a fixed positional relationship with the guide component. Optionally, the vicinity of the location includes, but is not limited to, a position with a preset distance from the guide component; and a dialog box or bubble generated by the guide component, in which case the area within the dialog box or bubble is used to display guide information.

[0055] In some embodiments, guidance information is displayed in a target area near the location of the guidance component. For example, the area within a dialog box or bubble is used to display the guidance information; or, a display area is defined at a position with a preset distance from the guidance component, and the guidance information is displayed in this display area.

[0056] In the aforementioned information display method, in response to a page display instruction, a page including a guide component is displayed. The page display duration is recorded, which introduces a time-series link feature, facilitating the transition across the page's lifecycle. Upon detecting page interaction, an event chain is generated based on the page display instruction, display duration, and interaction. At this point, the page display instruction, display duration, and interaction are all arranged as link features, forming multi-layered nested event combinations. This ensures that data-related instructions or operations, as well as corresponding time events, are all considered link features within the same event chain. This overcomes traditional window limitations, enabling the processing of complex temporal logic, reducing cross-page temporal dependencies, and facilitating information guidance in complex business scenarios. Guidance information is generated based on an event chain matching guidance strategy and displayed near the guide component.

[0057] In some embodiments, such as Figure 3 As shown, an event chain is generated based on page display instructions, display duration, and interactive operations, including steps 302-304; correspondingly, guidance information is generated based on the guidance strategy matching the event chain, including steps 306-308; wherein:

[0058] Step 302: Using page display instructions, display duration, and interactive operations as characteristics of each link, determine the combined event chain obtained by combining the characteristics of each link.

[0059] Link characteristics include events that occur on the page and descriptive events that occur on the page in response to those events. When the page is displayed via a page display instruction (a link event), the display duration is used as the descriptive event for the page under the influence of the page display instruction. Interactive actions also trigger corresponding events on the page; therefore, events triggered by interactive actions can be used as link characteristics.

[0060] A combined event chain is obtained by arranging and combining events that occur on a page in the order they are triggered. The characteristics of each link in the combined event chain can be added in real-time based on user actions, making the combined event chain relatively real-time.

[0061] In some embodiments, corresponding page display events and page timed events are used as two types of event chain features. The page display events are arranged in the order they precede the page timed events to obtain an initial event chain. Then, whenever an interactive operation is received, event chain features are constructed based on the received interaction, and these newly constructed event chain features are combined with the initial event chain to obtain a combined event chain. Thus, at the stage of receiving the page display instruction and display duration, an initial event chain is constructed. Events generated by subsequent interactive operations on the page can be added sequentially to this initial event chain to form a combined event chain, ensuring a high degree of real-time performance for the guidance information.

[0062] Step 304: Determine the link characteristics based on the instruction parameters of the interactive operation on the page, and add the link characteristics to the combined event chain to obtain the adjusted event chain.

[0063] Command action parameters are descriptive parameters of interactive operations on the page; they represent the steps or processes that generate the interactive operation on the page. Command action parameters can be implemented on the entire page or on a specific component of the page. Interaction count is the number of times the same interactive operation is triggered on the page or a page component, indicating the repetition of the interactive operation and forming a new dimension of analysis. For example, the interaction count could be the number of click commands or swipe commands in a certain area. Interaction time point is the time point at which the interactive operation is acquired; based on the time point at which the interactive operation is acquired, the temporal characteristics of the corresponding interactive operation are recorded to form multi-dimensional interaction information.

[0064] The adjusted duration is the duration for displaying the adjusted information, which is obtained by adjusting the page through interactive operations. When the interactive operation is a single click, the adjusted duration is the duration after the single click. When the interactive operation is a page exit operation, the adjusted duration is the duration after the single page exit operation.

[0065] In some embodiments, the current event time of the current interaction is appended to the click trigger time list, and the event chain version number is immediately incremented and the updated event chain is output immediately after the update, so that the interaction time is used as a link feature.

[0066] In some embodiments, when an interactive operation is used to adjust the information displayed on the page, a timed event is established based on the time point at which the interactive operation adjusts the information displayed on the page, and the duration is recorded based on the timed event to obtain the adjusted duration.

[0067] In some embodiments, the adjusted features are used as page link features, and these features are added to the combined event chain to obtain the page event chain. Thus, a page event chain corresponding to the page is constructed, and a page-level event chain is built for events triggered by the page.

[0068] Step 306: Among the candidate guidance strategies, determine the target guidance strategy that matches the combined event chain or the adjusted event chain.

[0069] A candidate guidance strategy is a set of criteria to be filtered; a candidate guidance strategy can be constructed from various logic trees. Candidate guidance strategies can be dynamically selected based on at least one of the target object and page, or they can be pre-defined.

[0070] A target guidance strategy is a guidance strategy that matches a specific event chain. When candidate guidance strategies include guidance strategies that match combined event chains, the target guidance strategy includes guidance strategies that match combined event chains; when candidate guidance strategies only include guidance strategies that match adjusted event chains, the target guidance strategy includes guidance strategies that match adjusted event chains.

[0071] In some embodiments, a logic tree corresponding to a candidate bootstrapping strategy is determined; the logic tree is matched with the combined event chain and the adjusted event chain respectively; a matching result is obtained; and a target bootstrapping strategy is determined based on the logic tree indicated by the matching result. Thus, using a logic tree for matching ensures that candidate bootstrapping strategies are arranged according to ordered conditions, which helps to determine the target bootstrapping strategy more accurately.

[0072] Step 308: Generate guidance information based on the target guidance strategy.

[0073] In one embodiment, upon detecting that an interactive operation adjusts the page display information, a timed event is established based on the time point of the interaction that adjusts the page display information. The adjusted duration recorded by the timed event is added to the combined event chain to obtain the time-adjusted event chain. Correspondingly, guidance information is generated based on a guidance strategy matching the event chain, including: determining a target guidance strategy that matches the combined event chain or the time-adjusted event chain from candidate guidance strategies; and generating guidance information based on the target guidance strategy.

[0074] In one embodiment, an event chain is generated based on page display instructions, display duration, and interactive operations. This includes: using page display instructions, display duration, and interactive operations as features of each link, determining a combined event chain obtained by combining the features of each link; determining the number of interactions on the page, and adding the link features converted from the number of interactions to the combined event chain to obtain a frequency-adjusted event chain. Correspondingly, guidance information is generated based on a guidance strategy matching the event chain. This includes: determining a target guidance strategy that matches the combined event chain or the frequency-adjusted event chain from candidate guidance strategies; and generating guidance information based on the target guidance strategy.

[0075] For example, the event chain cache is searched to see if a target click event with the same page identifier and component identifier as the current original click event already exists. If it does not exist, a new target click event object is created, its interaction count is initialized to 1, and the current event time is added to the click trigger time list. If it already exists, an accumulation operation is performed on the cached target click event: the interaction count is incremented by 1, and the current event time is appended to the click trigger time list. Immediately after the update, the event chain version number is incremented and output.

[0076] Therefore, after obtaining the combined event chain using the link features, the number of interactions on the page is used as the dimension for constructing the guidance information, so that the link features of the interaction number conversion are added to the combined event chain, resulting in the frequency-adjusted event chain.

[0077] In this embodiment, after obtaining the combined event chain using link features, the number of interactions or the adjusted duration of the interactive operation on the page are determined. At least one parameter of the number of interactions or the adjusted duration is used as the construction dimension of the guidance information, so that the instruction action parameter itself is also converted into link features and added to the combined event chain to form a more granular event chain, which helps to more accurately analyze the target guidance strategy and guidance information adapted to the page.

[0078] In some embodiments, determining link features based on the instruction action parameters of interactive operations on the page, and adding the link features to the combined event chain to obtain an adjusted event chain includes: determining the component instruction action parameters of the interactive operation; the component instruction action parameters are generated when adjusting page components; the instruction action parameters include the number of interactions with the page component, the interaction time point, and / or the adjusted duration; obtaining the adjusted features of the component based on the component instruction action parameters; and determining the component event chain obtained by combining the component link features, using the interactive operations and the adjusted features of the component as the link features of each component. Correspondingly, in the candidate guidance strategies, determining the target guidance strategy that matches the combined event chain or the adjusted event chain includes: determining the target guidance strategy that matches the combined event chain or the component event chain in the candidate guidance strategies.

[0079] Component instruction parameters are descriptive parameters used when interactive operations process page components; they represent the steps or processes that generate the interactive operation within the page component; component instruction parameters can be implemented by the page component. The number of interactions for a page component is the number of times the same interactive operation is triggered within the same page component, indicating the repetition of the interactive operation across different page components, thus forming a detailed dimension for component analysis. For example, the number of interactions could be the number of click or swipe commands for a guiding component. The interaction time point is the time point at which the interactive operation is obtained; based on the time point at which the interactive operation is obtained, the temporal characteristics of the corresponding interactive operation are recorded to form multi-dimensional interaction information.

[0080] Component chain characteristics are the chain features used to construct the event chain of a component; component chain characteristics include events that occur to the page component, as well as descriptive events that the page component experiences under the action of those events. Component chain characteristics reflect the specific operations and descriptive events for the component.

[0081] A component event chain is an event chain set for page components. The component event chain can represent the event sequence of the component hierarchy, forming a refined dimension of component control, so as to select a more suitable guidance strategy for the state of the page component.

[0082] In some embodiments, the current event time of the current interaction is appended to the click trigger time list, and the event chain version number is immediately incremented and the updated event chain is output immediately after the update, so that the interaction time of the component is used as a component chain feature.

[0083] In some embodiments, when an interactive operation is used to adjust the information displayed by a page component, a timed event is established based on the time point at which the page is adjusted by the interactive operation, and the duration is recorded based on the timed event to obtain the adjusted duration; the component link characteristics are determined based on the adjusted duration.

[0084] In some embodiments, a logic tree corresponding to the candidate guidance strategy is determined; the logic tree is matched with the combined event chain, the page event chain, and the component event chain respectively; the matching results are obtained; and the target guidance strategy is determined based on the logic tree indicated by the matching results. Thus, using a logic tree for matching ensures that the candidate guidance strategies are arranged according to ordered conditions, which helps to more accurately determine the target guidance strategy. Furthermore, using the combined event chain for the situation before the page change, the page event chain for the situation after the page hierarchy change, and the component event chain for the situation after the component hierarchy change, three types of event chains are formed. These three event chains create a multi-dimensional information control strategy, allowing for greater control over more dimensions and improving the accuracy of the analysis.

[0085] In this embodiment, each page component is refined to form a component-level event chain. This allows the generation of guidance information to not only dynamically change depending on the entire page but also to adapt to local page component adjustments. This results in a more granular component event chain, enabling more accurate analysis of the target guidance strategy adapted to the page component and generating guidance information more tailored to the target object and the page.

[0086] In some embodiments, generating an event chain based on page display instructions, display duration, and interactive operations includes: if the interactive operation is a triggering event in the page, determining whether the initial event chain has an ending event corresponding to the interactive operation; the initial event chain includes at least an event representing a page display instruction and an event representing a display duration; if there is no ending event, and the initial event chain includes a source triggering event from the same target object as the interactive operation, then when the configured duration of the interactive operation is greater than the duration of the source triggering event on the event chain, determining the adjusted duration of the interactive operation based on the configured duration, using the interactive operation and the adjusted duration as link features, adding the link features to the initial event chain to obtain the adjusted event chain.

[0087] Events that indicate page display commands and events that indicate display duration are different links in the event chain. Triggering events are interactive events that arrive before ending events; triggering events indicate that the page begins to enter a certain state, while ending events indicate that the page leaves a certain state. The entry event of the target component is a triggering event, while the exit event of the target component is an ending event.

[0088] Same-origin trigger events are events stored in the initial event chain. When an interaction is detected, the same-origin trigger event is already stored in the initial event chain. Same-origin trigger events are also trigger-type events. Because the process of converting page interactions into events and adding the events to the chain is time-consuming, one possible order on the page is: first, execute the interaction, determine the timing of the interaction, and then execute the operation to obtain the same-origin trigger event; another possible order is: first, execute the operation to obtain the same-origin trigger event, then execute the interaction, and determine the timing of the interaction. Since only one of these two orders can usually exist during each browsing session, the interaction has a configurable duration, and by tracking the duration of the same-origin trigger event in the initial event chain, the corresponding time point can be traced to determine which order is correct and which is incorrect.

[0089] The configuration duration is the time taken from the moment the interactive operation is triggered when the page is triggered; it can represent the sequential order of various instructions on the page. For example, if an interactive operation is triggered at the first moment, then at the second moment of out-of-order detection, the configuration duration corresponding to this interactive operation is determined based on the time difference between the first moment and the second moment.

[0090] Optionally, if the initial event chain does not include triggering events from the same target object as the interactive operation, the duration of the interactive operation on the event chain is determined based on the configured duration. The duration of the interactive operation and the event chain is used as the link feature, and the link feature is added to the initial event chain to obtain the adjusted event chain.

[0091] In some embodiments, if the interaction that needs to be responded to at the current moment is an entry event of a target component, and the initial event chain contains a departure event of this target component, then the interaction that needs to be responded to at the current moment is discarded.

[0092] In some embodiments, based on one or more preset duration thresholds in the business configuration, the timing of each interactive operation is calculated using the current event time as a reference. Specifically, a delayed trigger task is registered with the underlying processing time timer (ProcessingTimeTimer), and the original event is temporarily stored in the timer cache state. When any timer expires and triggers, the system retrieves the same-source trigger event from the same target object in the event chain cache. If no same-source trigger event exists, a new target browsing page event is created, and its configured duration is used to calculate the browsing duration.

[0093] In this embodiment, a verification rule is established to determine the order of events formed by triggering events and ending events, thereby filtering out out-of-order operations between triggering and ending events. When there is no out-of-order order between triggering and ending events, since the order in which triggering events arrive at the event chain cache may differ, the timing of events triggered by the same source is detected to determine the actual order of triggering events and events triggered by the interaction in the actual usage process. This allows for adjustment of the initial event chain, resulting in a corresponding adjusted event chain that more accurately reflects the actual operation of the page.

[0094] In some embodiments, after generating guidance information based on the guidance strategy of event chain matching, the method further includes: if the event chain includes target link features representing the closed loop of the event chain, then the cache of the closed loop event chain is released; if the event chain does not include target link features, then the cache of the event chain is maintained until the duration of the end event reaches the cache clearing duration threshold, and then the cache of the event chain is cleared; the duration of the end event includes the display duration or the adjusted duration of the page.

[0095] A target event chain feature refers to an event chain added by an interactive operation to an event chain containing a triggering event, where the target event chain feature is the closing event corresponding to that triggering event. For example, if the event of entering a page is determined based on a page display instruction, then the target event chain feature is the event of closing that page; if the event chain contains an event that triggers a page component, then the target event chain feature could be the event of closing that page component.

[0096] The clearing duration threshold is a lifecycle threshold for the event chain, used to control the lifecycle of the event chain from a time perspective. Optionally, page event chains and component event chains have their own lifecycles; however, the clearing duration thresholds for page event chains and component event chains can be the same or different.

[0097] In some embodiments, if the original behavior event is the end of the lifecycle of the current pageSessionId, or a new page display instruction from the user is detected, a cache clearing instruction is actively triggered. The event chain includes a target link feature representing the closed loop of the event chain, in order to destroy the current event chain cache and terminate its lifecycle.

[0098] In some embodiments, if the original behavioral event does not belong to the above target link characteristics, the event chain cache is maintained, but a uniform final expiration time, such as 30 minutes, is configured for the event chain cache. When the display duration or the adjusted duration of the page reaches the corresponding final expiration time, the underlying state incremental cleanup mechanism is started to limit the maximum number of session caches residing in physical memory within the same time segment, and to prevent the massive number of unclosed "orphan caches" caused by network anomalies from causing memory overflow (OOM) in the stream computing system.

[0099] In some embodiments, if the extended parameters of the target link feature include a page unload flag, a page destruction signal is also returned to clear the entire event chain cache. There are two cleanup methods: one is proactive cleanup, which is based on page or component-level end events, such as entering a new page, closing a page, entering a new component, or closing a component; the other is passive cleanup, which is based on set expiration events.

[0100] In some embodiments, if an interaction operation indicates an end-of-event event, and this end-of-event event matches a triggering event in the event chain, then the duration of the end-of-event event is determined based on the duration of the triggering event in the event chain, since the corresponding triggering event has not yet arrived due to out-of-order arrival or has not registered a timer. If an interaction operation indicates an end-of-event event, and this end-of-event event does not match any of the events in the event chain, then the duration of the end-of-event event is determined based on the difference between the duration of the event indicated by the interaction operation and the configured duration of the end-of-event event. For example, the duration of the end-of-event event is the difference between the departure time and the actual browsing time.

[0101] In an exemplary embodiment, the system extracts the actual stay duration (stayMs) from the extended parameters of the current event and matches it with the target browsing page event of the same origin in the event chain cache. If a match is successful, the actual browsing duration is updated to the actual stay duration, and the end flag is set to true. If no target browsing page event of the same origin is matched, the triggered event has not yet arrived due to out-of-order arrival or has not registered a timer. Therefore, the event occurrence time is deduced based on the actual stay duration, and a complete ended target browsing page event is directly constructed and written to the event chain cache. The expression for deducing the event occurrence time is: Event Time = Departure Time - Actual Stay Duration.

[0102] In this embodiment, the event chain stored in the cache can release memory under two conditions. One condition is that the event chain includes target link features representing the closed loop of the event chain. In this case, the mapping result of the event chain clearly indicates that the event chain needs to be released. This method ensures that the lifecycle of the event chain is not entirely dependent on time, thus guaranteeing processing effectiveness. The other way to terminate the lifecycle of the event chain is when the duration of the event reaches a preset value. At this point, the browsing time of the page or a certain component has been relatively long, and the corresponding lifecycle can be terminated to reduce interactive operations. Therefore, by using these two methods to terminate the lifecycle, the long tail of event chain states and useless data are effectively avoided, preventing the risk of infinite state expansion.

[0103] In some embodiments, before displaying a page including a guide component, the method further includes: determining a target object that triggers the page display instruction; combining the identifier of the target object with the identifier of the page to obtain an event chain identifier; encrypting and mapping the event chain identifier to a cache address corresponding to the event chain; and storing the event chain according to the cache address.

[0104] The target object is the object that controls the page, representing a user or agent; the target object can be a data object or a business object. Optionally, a data object is a collection of data representing attributes used to represent a user or agent; for example, the target object could be categorized by age group. A business object, on the other hand, is a user segmented according to business needs; for example, the target object could be an object that requires business A or business B.

[0105] The identifier of a target object represents the identity information of the target object and is used to distinguish different target objects. The identifier of a target object corresponds one-to-one with the target object. It can be the primary key of the target object in the corresponding database and is used to determine the data corresponding to the target object in the database.

[0106] A page identifier is used to mark the page to be displayed; the page identifier is determined before the page is displayed, so that each session page has a unique identifier. Optionally, the page identifier is determined on a session basis, and each page identifier can be deleted when the target object closes the page.

[0107] Event chain identifiers are dynamically changed based on the target object and page. They are used to mark event chains to identify the target object and page associated with each chain; they are also used to delete cached addresses of event chains to isolate event chains from different objects or pages.

[0108] In some embodiments, whenever a page display instruction triggered by a target object is obtained, the identifier of the target object and the identifier of the page are concatenated to obtain an event chain identifier; the event chain identifier is used as a key feature, and a hash mapping is performed on the key feature to obtain a hash mapping result; the cache address corresponding to the event chain is determined according to the cache address corresponding to the hash mapping result; and the event chain is stored according to the logical area indicated by the cache address.

[0109] In one example embodiment, the terminal receives and parses the original behavior event of the target object. If the original behavior event is any of the following page display instructions: page entry, page exit, module entry, module exit, or click operation, the target object's identifier (userId) is extracted from the page display instruction to obtain the target object's representation. The page identifier for the current session is also extracted from the page display instruction to obtain the session identifier (pageSessionId). An event chain identifier is generated based on the target object's identifier and the session identifier. This event chain identifier is used as a composite primary key to logically partition the streaming data. The partitioning rule is determined by the hash value of the key; all events from the same user will be routed to the same subtask.

[0110] In this embodiment, an event chain identifier is established for each page of each target object. This event chain identifier dynamically changes with the target object and the page, forming an efficient event chain marking method. Based on this, the event chain identifier is used to encrypt and map the corresponding cache address. This allows the cache address used by the target object to dynamically change with the page identifier each time, isolating different target objects in the logical areas of each page, forming corresponding control chains, and ensuring high processing efficiency.

[0111] In some embodiments, the method further includes: converting a business condition table into a first mapping dictionary by business node, determining a second mapping dictionary based on the association between business nodes, and determining a third mapping dictionary based on the parent and child nodes of the business nodes; obtaining a list of child nodes of the current node based on the third mapping dictionary; if the list of child nodes is empty, determining that the current node is a leaf node, extracting the condition identifier associated with the leaf node from the first mapping dictionary, and adding the condition identifier to the leaf node; if the list of child nodes is not empty, determining that the current node is a non-leaf node, extracting the association logic of the non-leaf node from the second mapping dictionary, and writing the association logic into the node attribute, until each child node of the current node traverses the determination step of the leaf node, thus obtaining a logic tree; and determining the event chain matching guidance strategy among the candidate guidance strategies corresponding to each logic tree.

[0112] A business node is a node in a business process flow. Each business node has corresponding rules and can also be called a rule node. Through business nodes, the processing procedures under different business functions can be decoupled, so as to execute the corresponding processing logic more efficiently.

[0113] The first mapping dictionary is used to determine the candidate conditions that a business node must meet, in order to establish the correspondence between the conditions. For example, the range of time a page is displayed is a candidate condition, and entering a specific page is another candidate condition.

[0114] The second mapping dictionary is used to determine the logical relationships between candidate conditions; the logical relationships can be parallel, represented by AND; or they can be selective, represented by OR.

[0115] The third mapping dictionary is used to determine the dependency or sequence relationships between business nodes, thereby determining the relationships between the nodes. For example, if the first node is the parent node of the second node and the second node is the child node of the first node, then the list of child nodes of the first node includes the second node, and each second node forms a branch of the logical tree.

[0116] The current node is the business node used to determine the logic tree and candidate guidance strategies; the current node may have a corresponding candidate guidance strategy. Optionally, the current node can be determined based on the current page or event chain. The business condition table is used to represent the conditions that a specific business needs to meet. The business condition table uses business nodes as foreign keys and is a data set that maps leaf nodes to specific business judgment condition configurations.

[0117] In an exemplary embodiment, the identifier of a business node is ruleId, the identifier of a parent business node is parentRuleId, and the condition is represented as condition; therefore, the first mapping dictionary is represented as ruleId→condition; the second mapping dictionary is represented as ruleId→ruleNode; and the third mapping dictionary is represented as parentRuleId→List.

[0118] The business condition table clearly defines the conditions that the event chain may meet and identifies the business nodes corresponding to each business condition. The relationship between the data structures is determined through each business node, so that the coupling between the rule stage table of each business and the business is moderate, making each business node reusable.

[0119] Leaf nodes are used to determine the conditions used in the matching process; non-leaf nodes are used to determine the relationships between the conditions; through the relationship between leaf nodes and non-leaf nodes, a tree-like condition structure can be established to facilitate the formation of a non-linear and ordered matching method.

[0120] In some embodiments, the conditions in the business condition table are extracted using the identifier of the business node as the index, resulting in a first mapping dictionary with the identifier of the business node as the index and the conditions as the values.

[0121] The business condition table is converted into a first mapping dictionary based on business nodes. Then, a second and third mapping dictionary are constructed from the business node table, with each business node and its parent business node as the basis. The business node table stores the judgment logic skeleton through a parent-child structure with reference relationships. Each node carries its own identifier, parent business node, and associated logic type (conditionRelation: AND / OR). Subsequently, using the root rule identifier of the candidate guidance strategy as the entry point, recursive tree-building logic is executed: the third mapping dictionary is queried to obtain the list of child nodes of the current node. If the child node list is empty, it is determined to be a leaf node, and its associated conditions are extracted from the first mapping dictionary and attached to that node. If the child node list is not empty, it is determined to be a non-leaf node, and its declared associated logic type (AND / OR) is extracted from the second mapping dictionary and written into the node attributes. This tree-building logic is then recursively executed for each child node until a leaf node is reached.

[0122] In this embodiment, the candidate conditions required for each node are determined by the first mapping dictionary; the logical relationship between different nodes in the condition dimension is determined by the second mapping dictionary; and the parent-child dependency relationship of business nodes is clarified by the third mapping dictionary, which clarifies the specific business, so that the three mapping dictionaries are decoupled from each other, each mapping dictionary has relatively independent logic, and the probability of data conflict between different mapping dictionaries is reduced. Thus, through the step-by-step condition verification and Boolean tree logic routing engine built into the logic tree, a complete closed loop from event feature extraction to final intervention strategy issuance is realized.

[0123] In an exemplary embodiment, firstly, steps 202-206 involve the integration of original operation tracking points; specifically, using the page (pageSessionId) as the core of the event chain, the interactive operations in the originally discrete and disordered front-end tracking logs are precisely assembled and constructed into an event information chain with complete time correlation; interactive operations include, but are not limited to, click operations, browsing operations, and page entry or exit operations. Secondly, steps 208 and 210 involve real-time business intervention and outreach; specifically, when the assembled event chain is received from the cleaning component, the downstream system can parse the characteristics of the chain in milliseconds and immediately trigger the preset supply strategy; for example, a user enters the insurance product page -> stays for 20 seconds -> clicks the calculation tool. Thus, the mini-program page displays a guidance question generated by a model or rule pushed by the guidance component, which can be clicked to jump to intelligent or human customer service. This guidance question is a type of guidance information; such as... Figure 4 As shown, the guiding message is "What is the difference between this content and other content?".

[0124] In one embodiment, such as Figure 5 As shown, it includes the Weblog system, Flink real-time computing components, a strategy module, and a channel module; among which:

[0125] The Weblog system is used to connect to the front-end event tracking and reporting service. It agrees on a reporting protocol with the front-end and includes interactive operations such as enterPage, leavePage, click, enterView, and leaveView. The structure is as follows:

[0126] {

[0127] "tag": "scrm-user-behave", / / cmq tags

[0128] "appID": "wx7f3f0032b6e6f0cc", / / appId

[0129] "userID": "9f42c2dc9444407d8b1f4c460f6079be",

[0130] "sessionID": "41110173225542327642412", / / Session ID, a new session will be created when the application starts.

[0131] "pageSessionId":"" / / Page session ID, a new ID is set each time the page loads, used to associate user behavior after entering the page.

[0132] "pageID": "pages / product / index?productCode=PP36", / / Page id

[0133] "event": "enterPage", / / Event type, such as page entry event

[0134] "eventType": "enterView",

[0135] "eventTime": "20241122143434343", / / Event occurrence time

[0136] "reportTime": "20241122143434343", / / Event reporting time

[0137] "elementID": "insureForm.importantModal.show", / / module id

[0138] "message": "",

[0139] "wtag": "",

[0140] "params": "{\"type\":\"popup\"}", / / Extended parameters

[0141] "md": null

[0142] }

[0143] The Flink Real-Time Computing Component is used to interface with the interactive operation stream pushed by the front-end Weblog and convert it into a structured event chain.

[0144] like Figure 6 As shown, in a stream processing architecture without a set watermark and no predetermined time window, this component executes the following processing flow based on the underlying keyedprocessFunction:

[0145] The first step is event reception and composite key extraction. The received and parsed push interaction operations are processed. Specifically, if the interaction operation is any of the following: page entry (enterPage), page exit (leavePage), component entry (enterView), component exit (leaveView), or click, the target object's identifier (userId) and page identifier (pageSessionId) are extracted from the interaction operation. A joint event chain identifier is generated based on the target object's identifier and the page identifier. This event chain identifier is then used to logically partition the streaming data. The partitioning rule is determined by the hash value of the event chain identifier, which is the key, obtained by combining the target object's identifier (i.e., userId) and the page identifier (pageSessionId). In this partitioning process, a hash calculation is first performed based on the event chain identifier, and then the modulus of the calculated hash value is non-linearly mapped. Therefore, all events from the same user will be routed to the same Flink subtask.

[0146] The second step, page lifecycle initialization and cache mapping, checks the local memory mapping state (MapState) of the stream computing system to see if a corresponding page lifecycle event chain cache exists for the generated event chain identifier. If it does not exist, a brand new event chain cache is instantiated, and the current interaction operation is identified as the starting node of the page and loaded into the cache, entering a new lifecycle. If it exists, the event chain cache corresponding to the current pageSessionId is directly extracted, and based on the system's underlying strict serial execution mechanism for the event chain identifier dimension, the serial execution mechanism is a lock-free mutual exclusion-lock-free process driven by process event data and timer time. The mutual exclusion mechanism is implemented by relying on the single-threaded event loop architecture of the underlying stream computing engine. Specifically, data-driven process event calls and time-driven timer callbacks are uniformly encapsulated into an indistinguishable execution unit (Mail), placed into the same first-in-first-out queue (Mailbox), and retrieved one by one by a single worker thread and executed synchronously to form an event stream. Since all data events and timer events with the same event chain identifier are hash-routed to the subtask of the same operator, and the Mailbox in the subtask is consumed by only one thread, process events and timers are strictly serialized in the time dimension and safely enter the subsequent event cleaning and aggregation logic.

[0147] The event chain is accumulated based on standard nodes calculated in real time and is related to the original events. The event chain may not have sliding; it only involves pruning. Events at the beginning of the chain are pruned when the version field exceeds a certain threshold to prevent the chain from becoming too long. There are two expiration strategies: one is proactive cleanup, which involves listening for end-of-chain events; the other is passive cleanup, which is based on the duration of the end event and the corresponding timeout termination mechanism.

[0148] The event chain cache is as follows:

[0149] {

[0150] "appId": "testAppId", / / Application ID

[0151] "userId": "testUserId", / / User ID

[0152] "openId": "oc2P70DPlzsV2qqDPj1DqWGykFNc", / / WeChat openId

[0153] "sessionId": "testSessionid", / / Application-level session ID, created when the application starts.

[0154] "pageSessionId": "testPageSessionid", / / Page-level session ID, event chain aggregation dimension

[0155] "events": [

[0156] {

[0157] "eventType": "click", / / Click event

[0158] "eventTime": "20241125153620100", / / Event occurrence time (milliseconds precision)

[0159] "reportTime": "20241125153620", / / Front-end reporting time (seconds precision)

[0160] "pageId": "pages / home / index", / / Page path

[0161] "productCode": "P001", / / Product code

[0162] "processTime": "20241125153620150", / / Flink processing time

[0163] "arriveTime": "20241125153620200", / / Arrival time in Flink

[0164] "params": { "buttonName": "submit"}, / / Extended parameters

[0165] "elementId": "btn_submit", / / Component ID

[0166] "count": 1, / / Total number of clicks

[0167] "clickEventTime": ["20241125153620100"] / / Trigger time for each click

[0168] },

[0169] {

[0170] "eventType": "view_page", / / Page display event

[0171] "eventTime": "20241125153608265",

[0172] "reportTime": "20241125153608",

[0173] "pageId": "pages / home / index",

[0174] "productCode": "P001",

[0175] "processTime": "20241125153608300",

[0176] "arriveTime": "20241125153608350",

[0177] "params": { "source": "wechat_miniprogram", "scene": "1001"},

[0178] "duration": 15000, / / Flink determines the duration of traffic (ms)

[0179] "realDuration": 15200, / / Actual reported display duration (ms)

[0180] "endTag": true / / Received the leavePage tag to end

[0181] },

[0182] {

[0183] "eventType": "view_element", / / Component display event

[0184] "eventTime": "20260409094931772",

[0185] "reportTime": "20260409094932",

[0186] "pageId": "pages / tools / comprehensive / index?channel=C208.16.3&tabId=yiliao",

[0187] "productCode": "",

[0188] "processTime": "20260409094931772",

[0189] "arriveTime": "20260409094932608",

[0190] "params": "{\"wecareServiceId\":\"...\",\"type\":\"scroll\",\"attrs\":{...}}", / / Component configuration (JSON)

[0191] "elementId": "wecareKf.justExposure", / / Component ID

[0192] "duration": 0, / / No departure event received, duration is 0

[0193] "realDuration": 0,

[0194] "endTag": false / / Browsing not finished

[0195] },

[0196] {

[0197] "eventType": "view_page", / / Page display event

[0198] "eventTime": "20260409094930827",

[0199] "reportTime": "20260409094930",

[0200] "pageId": "pages / tools / comprehensive / index?channel=C208.16.3&tabId=yiliao",

[0201] "productCode": "",

[0202] "processTime": "20260409094935827",

[0203] "arriveTime": "20260409094931635",

[0204] "params": "{\"stayMs\":68243,\"load\":false,\"unload\":false}", / / Duration of stay / loading status

[0205] "duration": 5000, / / Flink calculates the trigger dwell time value

[0206] "realDuration": 68243, / / Actual dwell time reported by the frontend

[0207] "endTag": true / / LeavePage received

[0208] }

[0209] ],

[0210] "triggerTime": "20260409095039572", / / The time output to MQ, used to calculate end-to-end latency.

[0211] "version": 5 / / Cache version number, incremented by 1 with each update, optimistic locking to prevent duplicates.

[0212] }

[0213] The third step involves classifying, cleaning, and performing time-series aggregation calculations. Specifically, for the extracted event chain cache, a targeted cleaning and aggregation mechanism is executed based on the specific type of the current interaction operation, transforming the heterogeneous original front-end event tracking data into a standardized operation chain structure.

[0214] In one example, page interactions include click events, which are aggregated in real-time. Specifically, the event chain cache is checked to see if a target click event with the same page and component identifier as the current original click event already exists. If it doesn't exist, a new target click event object is created, its interaction count is initialized to 1, and the interaction time is added to the click trigger time list. If it already exists, an accumulation operation is performed on the cached target click event: the interaction count is incremented by 1, and the interaction time is appended to the click trigger time list. Immediately after the update, the event chain version number is incremented and output.

[0215] In another example, the triggered interactive operations on the page include page browsing triggered operations (enterPage); these involve out-of-order detection and timer registration steps. Specifically, the system first matches the preset business configuration based on the page identifier of the current event; if no matching page configuration is found, the event is discarded. If the interactive operation matches the configured operation, the system searches the event chain cache to see if a target browsing page event of the same origin already exists and its end identifier is true; if a target browsing page event of the same origin exists and its end identifier is true, it is determined to be an out-of-order message scenario, meaning that the end event arrives before the trigger event, the current trigger event is discarded, and the predetermined statistical results of the cached events are retained; if no out-of-order event exists, the system calculates the timed trigger times based on one or more preset duration thresholds in the business configuration, using the interaction time as a reference, registers delayed trigger tasks with the underlying processing time timer (ProcessingTimeTimer), and temporarily stores the original event in the timer cache state. When any timer expires, the system retrieves the same-origin event from the event chain cache: if no same-origin target browsing page event exists and its end flag is not true, a new target browsing page event is created, with its configured duration used as the defined traffic duration, and the end flag is set to not ended; if a same-origin target browsing page event already exists and its end flag is not true, it is overwritten and updated only if the configured duration is longer than the cached defined traffic duration; if a same-origin target browsing page event already exists and its end flag is true, it indicates that the end event has arrived before the timer, and this timed update is skipped.

[0216] Correspondingly, the closing-loop verification and duration correction of the page browsing termination operation (leavePage) corresponding to the page browsing trigger operation are performed on the page browsing termination operation. Specifically, the display duration (stayMs) is extracted from the extended parameters of the current event, and the same-origin target browsing page event is matched in the event chain cache. If a match is found, the actual display duration is updated to the display duration, and the termination flag is set to true. If no match is found (i.e., the trigger event has not yet arrived due to out-of-order delivery or no timer is registered), the event occurrence time is deduced from the display duration (event time = departure time - display duration), and a complete terminated target browsing page event is directly constructed and written to the event chain cache. After the update, the event chain version number is immediately incremented and output. If the extended parameters of the event contain a page unload flag (unload), a page destruction signal is returned simultaneously to clear the entire event chain cache. An example structure is as follows:

[0217] The example structure is as follows:

[0218] {

[0219] "tag": "scrm-user-behave",

[0220] "appID": "wx7f3f0032b6e6f0cc",

[0221] "userID": "865babb5913b4b1e894cac6d36fc380b",

[0222] "sessionID": "89088173252060463381709",

[0223] "pageSessionId": "4lqVP3uV0Hg07kJt",

[0224] "pageID": "pages / product / common / productDetail / index?productCode=PH5H",

[0225] "event": "",

[0226] "eventType": "leavePage",

[0227] "elementID": "",

[0228] / / `unload` being true indicates the end of the session lifecycle at the `pageSessionId` level.

[0229] "params": "{\"stayMs\":68243,\"load\":false,\"unload\":true}","openID": "oqYLv0LTNfsApI-pOK6uesAfrfr0",

[0230] "eventTime": "20241125154329136",

[0231] "reportTime": "20241125154329"

[0232] }

[0233] In one example, for the refined component chain characteristics, this could involve deduplication of module browsing triggered events (enterView) and timer registration. For events carrying specific component identifiers (such as the identifier of the exposed component in the bootstrapping service), the system performs deduplication: it searches the event chain cache to see if a component display event with the same component identifier already exists. If it already exists, it ignores this report, ensuring that only the first exposure of the same component is recorded. For general component display events, the out-of-order detection and timer registration logic is the same as that for page browsing triggered events, the difference being that the matching dimension adds the component identifier (elementId), and the generated target object is the component display event (view-element).

[0234] Correspondingly, the component link feature can also be the module browsing end event (leaveView) corresponding to the module browsing trigger event; specifically, its closed-loop verification and duration correction processing logic is symmetrical to the above page browsing end event (leavePage), the difference is that the matching dimension is a combination of page identifier and component identifier, the generated target object is the component display event (view-element), and its actual display duration is also extracted from the extended parameters.

[0235] {

[0236] "tag": "scrm-user-behave",

[0237] "appID": "wx7f3f0032b6e6f0cc",

[0238] "userID": "865babb5913b4b1e894cac6d36fc380b",

[0239] "sessionID": "89088173252060463381709",

[0240] "pageSessionId": "4lqVP3uV0Hg07kJt",

[0241] "pageID": "pages / product / common / productDetail / index?productCode=PH5H",

[0242] "event": "",

[0243] "eventType": "leaveView",

[0244] "elementID": "wecareKf.justExposure",

[0245] "params": "{\"stayMs\":5000}",

[0246] "openID": "oqYLv0LTNfsApI-pOK6uesAfrfr0",

[0247] "eventTime": "20241125154329136",

[0248] "reportTime": "20241125154329"

[0249] }

[0250] The fourth step, full event chain delivery and closed-loop determination, involves pushing the updated entire event chain cache to the downstream business intervention pipeline after the cleaning and aggregation calculation of any interactive operation. Simultaneously, it determines whether the current event meets the lifecycle clearing conditions: if the interactive operation is the end-of-life event of the current page, or a new page intervention event for the user is detected, a cache clearing instruction is proactively triggered to destroy the current event chain cache and terminate its lifecycle; if the interactive operation is not the aforementioned end-of-life event, the event chain cache is maintained, but a uniform final expiration time (e.g., 30 minutes) is forcibly configured for the cache; and the underlying state incremental cleanup mechanism is activated to limit the maximum number of page caches residing in physical memory within the same time frame, preventing massive unclosed orphan caches caused by network anomalies from triggering an OutOfMemoryError (OOM) in the stream computing system.

[0251] The strategy module utilizes a built-in step-by-step condition verification and Boolean tree logic routing engine. After the downstream strategy triggering component receives the standard event chain, the terminal extracts event features from the strategy module, completing a closed loop until the final supply strategy is issued. This process specifically includes two main stages: rule matching and result rendering.

[0252] The first stage is policy matching and hit determination based on Boolean trees.

[0253] The first step of the first phase is condition identification and collection. This specifically includes: First, initializing the strategy execution resource context based on the product identifier and interaction operation set in the current event chain object; then, extracting the target object's identifier from the current event chain cache object, which can be appId, userId, openId, sessionId, pageSessionId, etc.; next, extracting the product code from the first operation in the event chain as the strategy routing dimension; the product code can refer to productCode. Remotely querying the A / B testing service to obtain the current user's experiment group information (abTestItems) on associated components, assembling the target object's identifier, routing dimension, experiment context, and interaction operation set into a strategy execution resource context object for subsequent condition identification and strategy routing stages to complete the matching of the guidance strategy and the event chain. Subsequently, querying the pre-built strategy configuration library to obtain all trigger condition templates associated with the current product, including but not limited to: specific interaction operation condition USER_BEHAVE_TYPE, experiment group label condition ABTestItem, etc. The strategy execution resource context is sequentially substituted into each trigger condition template for step-by-step verification. In the step-by-step verification, all atomic condition templates under the current product need to be traversed. According to one type of interaction operation or experimental group, the type of each condition is used to match the corresponding matcher. The matcher extracts the corresponding data from the resource context and compares them one by one according to the event type, page, component, and comparison operator (= / >= / <= / != / > / <) defined in the condition template. If a match is found, the condition ID and its attached parameters are encapsulated into TimelyConditionParamsDTO and stored in the activation condition set for consumption in the subsequent Boolean tree determination stage.

[0254] The matcher can be UserBehaveMatch or TestTagMatch.

[0255] The policy execution resource context structure is as follows:

[0256] {

[0257] "appId": "wx7f3f0032b6e6f0cc", / / Application identifier (unique ID for mini-program / official account)

[0258] "userId": "865babb5913b4b1e894cac6d36fc380b", / / Unique user identifier

[0259] "openId": "oqYLv0LTNfsApI-pOK6uesAfrfr0", / / User's WeChat openId

[0260] "sessionId": "89088173252060463381709", / / Application-level session ID

[0261] "pageSessionId": "4lqVP3uV0Hg07kJt", / / Page-level session ID, event chain aggregation dimension

[0262] "productCode": "P001", / / Product code, extracted from events[0], the core dimension of policy routing.

[0263] / / Page path (not currently assigned a value, reserved field)

[0264] "pageId": "pages / product / common / productDetail / index",

[0265] / / Event Behavior Chain

[0266] "events": [ {

[0267] "eventType": "click",

[0268] "eventTime": "20260409153620100",

[0269] "elementId": "btn_submit",

[0270] "productCode": "P001",

[0271] "params": {"buttonName": "submit"},

[0272] "count": 1,

[0273] "clickEventTime": ["20260409153620100"]

[0274] },

[0275] {

[0276] "eventType": "view_page",

[0277] "eventTime": "20260409153608265",

[0278] "pageId": "pages / home / index",

[0279] "productCode": "P001",

[0280] "duration": 15000,

[0281] "realDuration": 15200,

[0282] "endTag": true

[0283] },

[0284] {

[0285] "eventType": "view_element",

[0286] "eventTime": "20260409094931772",

[0287] "elementId": "aiRender.exposure",

[0288] "productCode": "",

[0289] "params": {"attrs": {"componentId": "AN001", "businessType": "CONSULT"}},

[0290] "duration": 0,

[0291] "realDuration": 0,

[0292] "endTag": false

[0293] }

[0294] ],

[0295] "eventVersion": 5, / / Event chain cache version number, used for optimistic locking to prevent duplicates.

[0296] "abTestItems": [ / / AB experiment grouping information, obtained from remote query experiment service]

[0297] {

[0298] "componentId": "AN001", / / Experimental component ID, matching tComponentId in the policy condition

[0299] "testTag": "experiment_group_A" / / Experiment group label (control group / experimental group), affecting exposure rule determination

[0300] } ]

[0302] }

[0303] The second step of the first phase involves the dynamic construction of the strategy Boolean rule tree. Specifically, for the candidate guidance strategy list retrieved for the current product, the system uses pre-loaded rule mapping relationships to construct a logical decision tree model for each candidate guidance strategy. The logical decision tree model includes a trigger rule tree for determining whether a match has occurred and an exposure rule tree for determining whether display is allowed; wherein, the leaf nodes of the logical decision tree are mapped to a single specific trigger condition identifier; and the non-leaf nodes are mapped to the logical association types between the conditions (such as association with / AND, or / OR).

[0304] The steps for constructing the related tables include: the system loads three related data tables under the current product dimension from the pre-configured strategy configuration library: the strategy definition table (timely_service_strategy), the rule node table (timely_service_strategy_rule), and the condition table (timely_service_strategy_condition). Specific field relationships are shown in the ER diagram of the strategy-rule-condition and result record tables below. Specifically, the strategy definition table records the root rule identifier (including the trigger rule root node and the exposure rule root node) and rendering output configuration for each candidate guidance strategy; the rule node table stores the topological skeleton of the logical judgment tree in a self-referencing parent-child structure, with each node carrying its own identifier (ruleId), parent node identifier (parentRuleId), and related logical type (conditionRelation: AND / OR); the condition table uses the rule node identifier as a foreign key to map leaf nodes to specific business judgment condition configurations.

[0305] The construction process is as follows: First, the system constructs a first mapping dictionary (ruleId→condition) based on the rule node identifier of the condition table. Then, it constructs a second mapping dictionary (ruleId→ruleNode) and a third mapping dictionary (parentRuleId→List) based on the node identifier and parent node identifier of the rule node table. Next, using the root rule identifier of the candidate guidance strategy as the entry point, the system executes recursive tree-building logic: it queries the third mapping dictionary to obtain the list of child nodes of the current node. If the child node list is empty, it is determined to be a leaf node, and its associated atomic condition identifier is extracted from the first mapping dictionary and attached to the node. If the child node list is not empty, it is determined to be a non-leaf node, and its declared associated logical type (AND / OR) is extracted from the second mapping dictionary and written into the node attribute. This tree-building logic is then recursively executed for each child node until all branches reach a leaf node. Each candidate guidance strategy constructs an independent logical judgment tree, using the trigger rule root identifier and the exposure rule root identifier as entry points, together forming the complete judgment model of the strategy. The artifacts, along with the rendering configurations of the strategy (functionCode, styleCode, welcomeTag, etc.), are serialized and cached in a distributed Redis cache. Subsequent strategy executions will directly deserialize and use them, avoiding repeated construction.

[0306] Based on this, the conversion effect data verification strategy is optimized: After the strategy is launched, strategy hit rate, strategy exposure based on A / B testing, and component clicks will be used for comparison and optimization. In other words, the strategy configuration is first guided by historical data, then the timing of the capture is calculated in real time, and then the conversion data is used to verify the effect. Finally, the strategy is optimized.

[0307] The third step of the first phase includes recursive verification and strategy decision-making. Specifically, for each candidate guidance strategy's constructed logic decision tree, a depth-first recursive Boolean verification is performed: if a leaf node is reached, it is checked whether its trigger condition identifier exists in the activation condition set of the first phase; if it exists, the leaf node returns True, and its attached feature parameters are extracted simultaneously; otherwise, it returns False; if a non-leaf node is reached, based on its declared relational logic type (AND / OR), aggregated Boolean operations are performed on the return values ​​of all its subordinate child nodes. If the root node results calculated by both the trigger rule tree and the exposure rule tree of a candidate guidance strategy are True, then the candidate guidance strategy is determined to have been successfully hit. In the case where multiple strategies are hit simultaneously, the system will output the optimal single supply strategy combination according to a preset selection mode (such as large model intelligent decision-making or local priority fallback).

[0308] The second phase of the strategy module includes rendering of dynamic reach results based on the DSL.

[0309] The first step of the second phase includes: deduplication and anti-bouncing interception using a cache (Redis). Specifically, it extracts the identifier (UserId) and page identifier (PageSessionId) of the current target object, and queries the global result deduplication cache for the most recently triggered policy identifier of the current page. If the policy identifier of the optimal supply policy matches the most recently recorded policy identifier in the cache, it is determined to be a redundant trigger, and the system skips subsequent rendering logic and only refreshes the underlying state version; otherwise, it proceeds to the rendering of subsequent components.

[0310] The second step of the second phase includes: assembling rendering context parameters. Specifically, a globally unique execution sequence number (ExecuteId) is generated for the optimal supply strategy; the basic attributes of the strategy are written into the result entity to be issued; simultaneously, user identity features, product code, and trigger feature parameters extracted during the aforementioned Boolean validation are combined and encapsulated to generate a rendering context mapping set. The basic attributes include style code (StyleCode), welcome tag, and hot topic Q&A tags, etc.

[0311] The third step of the second phase includes: DSL dynamic compilation and signaling delivery. Specifically, if the optimal supply strategy includes specific dynamic rendering function code, the system calls the internal Domain-Specific Language (DSL) rendering engine, using the pre-encapsulated rendering context mapping set as input parameters, to perform dynamic data filling and cloud function generation. Finally, the execution output of the DSL engine is structured and encapsulated into a tool communication message, which, together with the aforementioned basic attributes, is assembled into the final standard downlink intervention result package. The system then flushes this intervention result package into the global result anti-duplicate cache pool, asynchronously stores it in the database, and responds to the front-end interface layer, completing real-time user intervention across the entire chain.

[0312] For example, a Boolean tree structure (browsing for more than 20 seconds and [clicking on component A or component B]):

[0313] {

[0314] "ruleId": "Rule_Root", / / rule ID

[0315] "isLeaf": false, / / Whether it is a leaf node

[0316] "conditionRelation": "AND", / / conditional relationship AND

[0317] "children": [

[0318] {

[0319] "ruleId": "Rule_Node1",

[0320] "isLeaf": true,

[0321] "conditionId": "Condition_C1" / / Browse 20-second conditions

[0322] },

[0323] {

[0324] "ruleId": "Rule_Node2",

[0325] "isLeaf": false,

[0326] "conditionRelation": "OR", / / conditional relationship OR

[0327] "children": [

[0328] {

[0329] "ruleId": "Rule_Node3",

[0330] "isLeaf": true,

[0331] "conditionId": "Condition_C2" / / Click component A

[0332] },

[0333] {

[0334] "ruleId": "Rule_Node4",

[0335] "isLeaf": true,

[0336] "conditionId": "Condition_C3" / / Click component B

[0337] } ]

[0339] } ]

[0341] }

[0342] The third stage of the strategy module includes the persistence of intervention results bound to the experimental context. Specifically, a complete strategy execution result record entity is constructed, encapsulating the target object's identifier, execution sequence number, business scenario code, along with the rule details of hits and exposures from the previous steps, dynamically generated execution code, and complete delivery result messages into an intervention snapshot. This intervention snapshot, along with the bound experimental context tag, is persistently written to the execution result database (timely_service_execute_result). This persistent record will serve as the objective factual benchmark data for the server to confirm the delivery of intervention actions, providing a high-precision denominator data source for downstream systems' server-side delivery-client exposure-user click-final conversion funnel analysis, as well as for measuring the differences in strategy effectiveness based on different experimental groups.

[0343] Building upon this, a channel component is also used. Specifically, the server deploys a highly available channel control component between the client and the strategy execution backend. Due to the uncontrollable millisecond-level latency between upstream stream computing engine push and asynchronous strategy execution, the server adopts a decoupled mode of asynchronous computing and short polling retrieval. For strategy result polling requests initiated by the client, the server uses the channel component to execute the following processing flow:

[0344] First, based on the currently extracted page identifier, a Stop-Poll status check is initiated with the backend policy cache cluster. If the backend returns that the policy flow for this page has physically terminated (e.g., the user completely closes the page), or that all associated policy determinations for this page have reached a final state, the channel component directly constructs a Stop-Poll control message and sends it back to the client. Upon receiving this Stop-Poll control message, the client automatically destroys its local polling timer, thereby significantly reducing the overhead of long-connection and concurrent database queries on the server. If it is determined that the page is still in an active polling period, the policy rendering result is retrieved.

[0345] Next, for polling requests in the active period, the channel component uses the primary key of the current target object's identifier and the page identifier to perform a point lookup in the global high-speed anti-duplicate cache pool to retrieve the underlying asynchronous strategy rendering result for that user. If no valid result is retrieved from the cache, or the result object is empty (i.e., the underlying Flink state machine has not yet been triggered or the asynchronous strategy is still being calculated), the channel component packages the current request into a miss status message (containing HitStrategy: false, StopPoll: false) and responds to the client, guiding the client to continue fetching in the next polling cycle. If the rendering result entity containing the strategy identifier is successfully retrieved from the cache, the channel component will downgrade, de-identify, and re-encapsulate the entity. It extracts the strategy hit status, style template identifier, execution serial number, and associated base model parameters; and assembles them into a structured standard downlink response object.

[0346] Therefore, this embodiment proposes a guided service outreach method and system based on real-time operation chain aggregation and Boolean rule trees. By performing real-time streaming processing on user-reported operation data, it achieves dynamic identification and calculation of complex operation sequences. In Fink, based on timer and operation chain structure design, a configurable Boolean tree combination rule and gray-scale experiment verification mechanism control rule hit rate and front-end component exposure. By analyzing hit and exposure, it determines click-through conversion rate and optimal outreach timing. Combined with user profiles and contextual information, it leverages a large model to generate personalized service methods and redirection guidance. This solution achieves an integrated guided service capability of real-time operation chain driving, dynamic rule configuration, and intelligent content generation, significantly improving the accuracy and timeliness of service response.

[0347] In an optional embodiment, steps 202-208 overcome the limitations of traditional windows to achieve the processing of complex temporal logic. Specifically, a self-built delayed cache (onTimeCache) combined with Flink's underlying imerService cleverly solves the problem that traditional time-window-based methods cannot finely track complex state transitions across windows. This empowers stream computing to handle complex business scenarios with cross-temporal dependencies, such as identifying high-potential churn users as those who remain on a page for N seconds without clicking. Furthermore, when dealing with high concurrency and large-volume user tracking data surges on the web, the business-driven proactive lifecycle release mechanism, TTL, and behavior chain pruning, combined with Flink's underlying incremental recycling mechanism, effectively avoid the risk of infinite state expansion caused by long-tailed states and useless data.

[0348] In some alternative implementations, an external caching scheme can be used, in which case the internal dual cache for stream processing is moved to an external in-memory computing cluster (such as Redis). Instead of maintaining eventsCache and onTimeCache internally in Flink, Flink is reduced to a purely stateless log dispatcher and parser. Each time data is received, a centralized Redis cluster is requested via network I / O to query and update the Session state chain. Redis's ZSet is used for delayed queue control, and Redis's built-in TTL is used for cleanup. While this approach reduces the memory pressure on Flink itself, the latency of network requests becomes immeasurable, sacrificing the microsecond-level throughput performance based on Flink's state-memory architecture.

[0349] In some alternative embodiments, during the system's data flow, state caching, and anti-duplicate recording stages, the current embodiment primarily uses structured objects or JSON-based strings (e.g., serializing ventsInfoDTO or ResultJson into JSONString) for storage and transmission in the Flink stream processing engine, Redis cache, and MySQL execution records. This data serialization and caching scheme can be replaced with an efficient data compression and transmission scheme based on a native binary serialization protocol to further address memory consumption and large key blocking issues under massive high-concurrency events.

[0350] It should be understood that although the steps in the flowcharts of the embodiments described above are shown sequentially according to the arrows, these steps are not necessarily executed in the order indicated by the arrows. Unless explicitly stated herein, there is no strict order restriction on the execution of these steps, and they can be executed in other orders. Moreover, at least some steps in the flowcharts of the embodiments described above may include multiple steps or multiple stages. These steps or stages are not necessarily completed at the same time, but can be executed at different times. The execution order of these steps or stages is not necessarily sequential, but can be performed alternately or in turn with other steps or at least some of the steps or stages of other steps.

[0351] Based on the same inventive concept, this application also provides an information display device for implementing the information display method described above. The solution provided by this device is similar to the solution described in the above method; therefore, the specific limitations in one or more information display device embodiments provided below can be found in the limitations of the information display method described above, and will not be repeated here.

[0352] In one exemplary embodiment, such as Figure 7 As shown, an information display device is provided, the device comprising:

[0353] Display module 702 is used to display a page including a guide component in response to a page display instruction;

[0354] Recording module 704 is used to record the display duration of the page;

[0355] The generation module 706 is used to generate an event chain based on the page display instruction, the display duration, and the interaction operation when an interactive operation on the page is detected.

[0356] The matching module 708 is used to generate guidance information based on the guidance strategy of the event chain matching;

[0357] The guidance module 710 is used to display the guidance information near the location of the guidance component.

[0358] In one embodiment, the generation module 706 is configured to:

[0359] Using the page display instructions, the display duration, and the interactive operations as characteristics of each link, a combined event chain is determined by combining the characteristics of each link.

[0360] Based on the instruction parameters of the interactive operation on the page, the link characteristics are determined, and the link characteristics are added to the combined event chain to obtain the adjusted event chain; wherein, the instruction parameters include the number of interactions, the interaction time point, and / or the adjusted duration; the adjusted duration is the display duration of the adjusted information, and the adjusted information is obtained by adjusting the page through the interactive operation;

[0361] The matching module 708 is used for:

[0362] Among the candidate guidance strategies, a target guidance strategy that matches the combined event chain or the adjusted event chain is determined.

[0363] Guidance information is generated based on the target guidance strategy.

[0364] In one embodiment, the generation module 706 is configured to:

[0365] Determine the component instruction action parameters for the interactive operation; the component instruction action parameters are generated when adjusting the page component; the instruction action parameters include the number of interactions, the interaction time point, and / or the adjusted duration for the page component;

[0366] The adjusted features of the component are obtained based on the component instruction parameters.

[0367] Using the interactive operations and component instruction parameters for the components as the characteristics of each component link, a component event chain obtained by combining the characteristics of each component link is determined;

[0368] The matching module 708 is used for:

[0369] Among the candidate guidance strategies, a target guidance strategy that matches the combined event chain or the component event chain is determined.

[0370] In one embodiment, the generation module 706 is configured to:

[0371] If the interactive operation belongs to the triggering event in the page, then it is determined whether there is an ending event corresponding to the interactive operation in the initial event chain; the initial event chain includes at least an event representing the page display instruction and an event representing the display duration;

[0372] If the aforementioned end-of-event occurs, the interaction will be discarded.

[0373] If there is no such end event, and the initial event chain includes a source-triggered event from the same target object as the interaction operation, then when the configured duration of the interaction operation is greater than the duration of the source-triggered event on the event chain, the adjusted duration of the interaction operation is determined based on the configured duration. The interaction operation and the adjusted duration are used as link features, and the link features are added to the initial event chain to obtain the adjusted event chain.

[0374] In one embodiment, after the guidance information is generated based on the event chain matching guidance strategy, the matching module 708 is configured to:

[0375] If the event chain includes target link features representing a closed loop of the event chain, then the cache of the closed loop of the event chain is released;

[0376] If the event chain does not include the target link feature, the event chain is cached until the duration of the end event reaches the cache clearing duration threshold, at which point the event chain cache is cleared; the duration of the end event includes the display duration or the adjusted duration of the page.

[0377] In one embodiment, prior to the display including a page with a guide component, the display module 702 is configured to:

[0378] Identify the target object that triggers the page display instruction;

[0379] The event chain identifier is obtained by combining the identifier of the target object with the identifier of the page;

[0380] The event chain identifier is encrypted and mapped to the cache address corresponding to the event chain;

[0381] The event chain is stored according to the cache address.

[0382] In one embodiment, the matching module 708 is configured to:

[0383] The business condition table is converted into a first mapping dictionary according to the business node, and a second mapping dictionary is determined according to the association relationship between the business nodes. A third mapping dictionary is determined according to the parent and child nodes of the business nodes.

[0384] The list of child nodes of the current node is obtained based on the third mapping dictionary. If the list of child nodes is empty, the current node is determined to be a leaf node. The conditions associated with the leaf node are extracted from the first mapping dictionary and the conditions are added to the leaf node.

[0385] If the list of child nodes is not empty, the current node is determined to be a non-leaf node. The association logic of the non-leaf node is extracted from the second mapping dictionary and written into the node attribute. The logic tree is obtained when the child nodes of the current node traverse the leaf node determination step.

[0386] Among the candidate guidance strategies corresponding to each of the logic trees, the guidance strategy matching the event chain is determined.

[0387] Each module in the aforementioned information display device can be implemented entirely or partially through software, hardware, or a combination thereof. These modules can be embedded in or independent of the processor in a computer device, or stored in the memory of a computer device as software, so that the processor can call and execute the operations corresponding to each module.

[0388] In one exemplary embodiment, a computer device is provided, which may be a terminal, and its internal structure diagram may be as follows: Figure 8 As shown, the computer device includes a processor, memory, input / output interfaces, a communication interface, a display unit, and an input device. The processor, memory, and input / output interfaces are connected via a system bus, and the communication interface, display unit, and input device are also connected to the system bus via the input / output interfaces. The processor provides computing and control capabilities. The memory includes non-volatile storage media and internal memory. The non-volatile storage media stores the operating system and computer programs. The internal memory provides an environment for the operation of the operating system and computer programs stored in the non-volatile storage media. The input / output interfaces are used for exchanging information between the processor and external devices. The communication interface is used for wired or wireless communication with external terminals; wireless communication can be achieved through Wi-Fi, mobile cellular networks, Near Field Communication (NFC), or other technologies. The display unit is used to create a visually visible image and can be a display screen, a projection device, or a virtual reality imaging device. The display screen can be an LCD screen or an e-ink screen. The input device of the computer device can be a touch layer covering the display screen, or buttons, trackballs, or touchpads set on the casing of the computer device, or external keyboards, touchpads, or mice, etc.

[0389] Those skilled in the art will understand that Figure 8 The structure shown is merely a block diagram of a portion of the structure related to the present application and does not constitute a limitation on the computer device to which the present application is applied. Specific computer devices may include more or fewer components than those shown in the figure, or combine certain components, or have different component arrangements.

[0390] In one embodiment, a computer device is also provided, including a memory and a processor, wherein the memory stores a computer program, and the processor executes the computer program to implement the steps in the above method embodiments.

[0391] In one embodiment, a computer-readable storage medium is provided having a computer program stored thereon that, when executed by a processor, implements the steps in the above method embodiments.

[0392] In one embodiment, a computer program product is provided, including a computer program that, when executed by a processor, implements the steps in the above method embodiments.

[0393] It should be noted that the user information (including but not limited to user device information, user personal information, etc.) and data (including but not limited to data used for analysis, data stored, data displayed, etc.) involved in this application are all information and data authorized by the user or fully authorized by all parties, and the collection, use and processing of the relevant data must comply with relevant regulations.

[0394] Those skilled in the art will understand that all or part of the processes in the methods of the above embodiments can be implemented by a computer program instructing related hardware. The computer program can be stored in a non-volatile computer-readable storage medium, and when executed, it can include the processes of the embodiments of the above methods. Any references to memory, databases, or other media used in the embodiments provided in this application can include at least one of non-volatile memory and volatile memory. Non-volatile memory can include read-only memory (ROM), magnetic tape, floppy disk, flash memory, optical memory, high-density embedded non-volatile memory, resistive random access memory (ReRAM), magnetic random access memory (MRAM), ferroelectric random access memory (FRAM), phase change memory (PCM), graphene memory, etc. Volatile memory can include random access memory (RAM) or external cache memory, etc. By way of illustration and not limitation, RAM can take many forms, such as Static Random Access Memory (SRAM) or Dynamic Random Access Memory (DRAM). The databases involved in the embodiments provided in this application may include at least one type of relational database and non-relational database. Non-relational databases may include, but are not limited to, blockchain-based distributed databases. The processors involved in the embodiments provided in this application may be general-purpose processors, central processing units, graphics processing units, digital signal processors, programmable logic devices, quantum computing-based data processing logic devices, artificial intelligence (AI) processors, etc., and are not limited to these.

[0395] The technical features of the above embodiments can be combined in any way. For the sake of brevity, not all possible combinations of the technical features in the above embodiments are described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this application.

[0396] The embodiments described above are merely illustrative of several implementation methods of this application, and while the descriptions are specific and detailed, they should not be construed as limiting the scope of this application. It should be noted that those skilled in the art can make various modifications and improvements without departing from the concept of this application, and these all fall within the protection scope of this application. Therefore, the protection scope of this application should be determined by the appended claims.

Claims

1. An information display method, characterized in that, The method includes: In response to a page display instruction, display a page including a guide component; Record the display duration of the page; Upon detecting an interactive operation on the page, an event chain is generated based on the page display instruction, the display duration, and the interactive operation; Guidance information is generated based on the guidance strategy of the event chain matching; The guidance information is displayed near the location of the guidance component.

2. The method according to claim 1, characterized in that, The generation of an event chain based on the page display instruction, the display duration, and the interactive operation includes: Using the page display instructions, the display duration, and the interactive operations as characteristics of each link, a combined event chain is determined by combining the characteristics of each link. Based on the instruction parameters of the interactive operation on the page, the link characteristics are determined, and the link characteristics are added to the combined event chain to obtain the adjusted event chain; wherein, the instruction parameters include the number of interactions, the interaction time point, and / or the adjusted duration; the adjusted duration is the display duration of the adjusted information, and the adjusted information is obtained by adjusting the page through the interactive operation; Based on the event chain matching guidance strategy, guidance information is generated, including: Among the candidate guidance strategies, a target guidance strategy that matches the combined event chain or the adjusted event chain is determined. Guidance information is generated based on the target guidance strategy.

3. The method according to claim 2, characterized in that, The process of determining link characteristics based on the instruction action parameters of the interactive operation on the page, and adding the link characteristics to the combined event chain to obtain the adjusted event chain includes: Determine the component instruction action parameters for the interactive operation; the component instruction action parameters are generated when adjusting the page component; the instruction action parameters include the number of interactions, the interaction time point, and / or the adjusted duration for the page component; The adjusted features of the component are obtained based on the component instruction parameters. Using the interactive operations and component instruction parameters for the components as the characteristics of each component link, a component event chain obtained by combining the characteristics of each component link is determined; The step of determining the target guidance strategy that matches the combined event chain or the adjusted event chain from the candidate guidance strategies includes: Among the candidate guidance strategies, a target guidance strategy that matches the combined event chain or the component event chain is determined.

4. The method according to claim 1, characterized in that, The generation of an event chain based on the page display instruction, the display duration, and the interactive operation includes: If the interactive operation belongs to the triggering event in the page, then it is determined whether there is an ending event corresponding to the interactive operation in the initial event chain; the initial event chain includes at least an event representing the page display instruction and an event representing the display duration; If the aforementioned end-of-event occurs, the interaction will be discarded. If there is no such end event, and the initial event chain includes a source-triggered event from the same target object as the interaction operation, then when the configured duration of the interaction operation is greater than the duration of the source-triggered event on the event chain, the adjusted duration of the interaction operation is determined based on the configured duration. The interaction operation and the adjusted duration are used as link features, and the link features are added to the initial event chain to obtain the adjusted event chain.

5. The method according to claim 1, characterized in that, After generating the boot information based on the event chain matching boot strategy, the method further includes: If the event chain includes target link features representing a closed loop of the event chain, then the cache of the closed loop of the event chain is released; If the event chain does not include the target link feature, the event chain is cached until the duration of the end event reaches the cache clearing duration threshold, at which point the event chain cache is cleared; the duration of the end event includes the display duration or the adjusted duration of the page.

6. The method according to claim 1, characterized in that, Before the display includes a page with a guide component, the method further includes: Identify the target object that triggers the page display instruction; The event chain identifier is obtained by combining the identifier of the target object with the identifier of the page; The event chain identifier is encrypted and mapped to the cache address corresponding to the event chain; The event chain is stored according to the cache address.

7. The method according to claim 1, characterized in that, The method further includes: The business condition table is converted into a first mapping dictionary according to the business node, and a second mapping dictionary is determined according to the association relationship between the business nodes. A third mapping dictionary is determined according to the parent and child nodes of the business nodes. The list of child nodes of the current node is obtained based on the third mapping dictionary. If the list of child nodes is empty, the current node is determined to be a leaf node. The conditions associated with the leaf node are extracted from the first mapping dictionary and the conditions are added to the leaf node. If the list of child nodes is not empty, the current node is determined to be a non-leaf node. The association logic of the non-leaf node is extracted from the second mapping dictionary and written into the node attribute. The logic tree is obtained when the child nodes of the current node traverse the leaf node determination step. Among the candidate guidance strategies corresponding to each of the logic trees, the guidance strategy matching the event chain is determined.

8. An information display device, characterized in that, The device includes: The display module is used to respond to page display instructions and display a page including a guide component; A recording module is used to record the display duration of the page; The generation module is used to generate an event chain based on the page display instruction, the display duration, and the interaction operation when an interactive operation on the page is detected. The matching module is used to generate guidance information based on the guidance strategy of the event chain matching. A guidance module is used to display the guidance information near the location of the guidance component.

9. A computer device comprising a memory and a processor, wherein the memory stores a computer program, characterized in that, When the processor executes the computer program, it implements the steps of the method according to any one of claims 1 to 7.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by a processor, it implements the steps of the method according to any one of claims 1 to 7.

11. A computer program product, comprising a computer program, characterized in that, When the computer program is executed by a processor, it implements the steps of the method according to any one of claims 1 to 7.

Images