CN119938033A

CN119938033A - Methods for page rendering, execution engines, and page building methods

Info

Publication number: CN119938033A
Application number: CN202311440697.XA
Authority: CN
Inventors: 曹鸿
Original assignee: Tencent Technology Shenzhen Co Ltd
Current assignee: Tencent Technology Shenzhen Co Ltd
Priority date: 2023-11-01
Filing date: 2023-11-01
Publication date: 2025-05-06

Abstract

The present disclosure provides a method, apparatus, device and medium for page rendering, and an execution engine and a page building method. According to the method, events in the modules and linkage between the modules and other modules are analyzed through logic configuration of each module generated together with each module forming the page, a user interface in the module and the events are bound according to the logic configuration of each module in page rendering, and the events associated with the linkage between the modules are monitored, so that real-time dynamic response rendering of the page is realized. The method can generate each module and generate logic configuration for describing the association relation among all parts in the module at the same time so as to uniformly manage the triggering of events in the modules, the definition of the method and the linkage configuration, and the association relation among all modules in a page is connected in series through the linkage configuration, so that all modules are mutually matched in communication.

Description

Method for page rendering, execution engine and page construction method

Technical Field

The present disclosure relates to the field of cloud technology, and more particularly, to a method, apparatus, device, and medium for page rendering, and an execution engine and a page building method.

Background

In modern front-end development, developers have faced the problems of long development period, difficult multiplexing of various parts of development, and the like. For example, in low code engines, improving reusability, improving execution efficiency, and improving the low code development experience have been a challenge. The parts such as modules, logic (actions), user Interfaces (UIs), events (events), linkage and the like are difficult to be connected in series in a good way, and reusability and flexibility are not improved well due to the fact that the coupling property between the parts is strong, mutual dependence and the like.

Therefore, there is a need for a page rendering method that can concatenate modules, logic, UIs, events, linkages, etc.

Disclosure of Invention

To solve the above-described problems, the present disclosure renders modules by using a logical configuration of each module included in a page when rendering the page, wherein UIs of the modules are connected in series with events and linkages of the modules according to the logical configuration for implementing monitoring-based responsive rendering of a user interface.

Embodiments of the present disclosure provide a method, apparatus, device and medium for page rendering, and an execution engine and a page building method.

Embodiments of the present disclosure provide a method for page rendering, the page comprising a plurality of modules, wherein each module comprises one or more user interfaces, the method comprising obtaining a logical configuration of the page, the logical configuration comprising a logical configuration of each of the plurality of modules, wherein the logical configuration of each module is generated with the modules and is used to describe events in the modules and linkages between the modules and other modules, for each of the plurality of modules, monitoring events associated with the linkages in the modules based on the logical configuration of the modules and binding one or more events for the one or more user interfaces of the modules, and for each of the plurality of modules, rendering one or more user interfaces of the modules based on the monitoring of events associated with the linkages in the modules and the one or more events bound for the one or more user interfaces of the modules.

Embodiments of the present disclosure provide an execution engine configured in a module for building pages, the module including one or more user interfaces, the execution engine configured to obtain a logical configuration of the module, wherein the logical configuration of the module is generated with the module and is used to describe events in the module and linkages between the module and other modules, monitor events associated with the linkages in the module based on the logical configuration of the module and bind one or more events for the one or more user interfaces of the module, and render one or more user interfaces of the module based on the monitoring of events associated with the linkages in the module and the one or more events bound for the one or more user interfaces of the module.

Embodiments of the present disclosure provide a page building method including selecting, by a page builder, one or more modules from a set of modules generated by a module generator, each of the one or more modules configured with an execution engine as described above, each of the one or more modules including a logical configuration and one or more user interfaces, wherein the logical configuration of each module is generated by the module generator along with the modules and is used to describe events in the modules and linkages between the modules and other modules, and building, by the page builder, a page based on the selected one or more modules.

Embodiments of the present disclosure provide an apparatus for page rendering, the page comprising a plurality of modules, wherein each module comprises one or more user interfaces, the apparatus comprising a configuration acquisition component configured to acquire a logical configuration of the page, the logical configuration comprising a logical configuration of each of the plurality of modules, wherein the logical configuration of each module is generated with the module and is used to describe events in the module and links between the module and other modules, an association configuration component configured to monitor events associated with the links in the module based on the logical configuration of the module for each of the plurality of modules and bind one or more events for one or more user interfaces of the module, and a page rendering component configured to render the one or more user interfaces for each of the plurality of modules based on the monitoring of events associated with the links in the module and the one or more events bound for the one or more user interfaces of the module.

Embodiments of the present disclosure provide an apparatus for page rendering comprising one or more processors and one or more memories, wherein the one or more memories have stored therein a computer executable program which, when executed by the processors, performs a method for page rendering as described above.

Embodiments of the present disclosure provide a computer readable storage medium having stored thereon computer executable instructions which, when executed by a processor, are for implementing a method for page rendering as described above.

Embodiments of the present disclosure provide a computer program product or computer program comprising computer instructions stored in a computer readable storage medium. A processor of a computer device reads the computer instructions from a computer-readable storage medium, the processor executing the computer instructions, causing the computer device to perform a method for page rendering according to an embodiment of the present disclosure.

The method provided by the embodiment of the disclosure analyzes the event in the module and the linkage between the module and other modules by utilizing the logic configuration of each module generated together with each module forming the page, so that the user interface in the module and the event are bound according to the logic configuration of each module in the rendering of the page, and the event associated with the linkage between the modules is monitored, so that the real-time dynamic response rendering of the page is realized. The method of the embodiment of the invention can generate the logic configuration for describing the association relation among the parts in each module while generating each module so as to uniformly manage the triggering of the event in the module, the definition of the method and the linkage configuration, and the association relation among the modules in the page is connected in series through the linkage configuration, so that the modules are mutually matched in communication, and finally the dynamic rendering of the whole page is completed.

Drawings

In order to more clearly illustrate the technical solutions of the embodiments of the present disclosure, the drawings that are used in the description of the embodiments will be briefly described below. It should be apparent that the drawings in the following description are only some exemplary embodiments of the present disclosure, and that other drawings may be obtained from these drawings by those of ordinary skill in the art without undue effort.

FIG. 1 is a schematic diagram illustrating a scenario for implementing user interaction with a user terminal according to an embodiment of the present disclosure;

FIG. 2 is a flow chart illustrating a method for page rendering according to an embodiment of the present disclosure;

FIG. 3A is a schematic block diagram illustrating performing a rendering process and a trigger linkage process according to an embodiment of the present disclosure;

FIG. 3B is a schematic block diagram illustrating the flow of an execution triggering event according to an embodiment of the present disclosure;

FIG. 4 is a flow chart illustrating event communication in an execution engine according to an embodiment of the present disclosure;

fig. 5 is a schematic diagram illustrating a logical configuration of an example lottery module according to an embodiment of the disclosure;

FIG. 6 is a schematic diagram illustrating data acquisition and change monitoring via an event bus according to an embodiment of the present disclosure;

FIG. 7 is a schematic flow diagram illustrating reactive UI rendering for a module to be rendered according to an embodiment of the disclosure;

FIG. 8A is a schematic flow diagram illustrating load caching for actions according to an embodiment of the present disclosure;

FIG. 8B is a schematic flow diagram illustrating delayed loading for actions in accordance with an embodiment of the present disclosure;

FIG. 9 is a system architecture diagram illustrating a system for page rendering according to an embodiment of the present disclosure;

FIG. 10 is a schematic diagram illustrating the construction and application of pages according to an embodiment of the present disclosure;

FIG. 11 is a schematic diagram illustrating an apparatus for page rendering according to an embodiment of the present disclosure;

FIG. 12 shows a schematic diagram of an apparatus for page rendering in accordance with an embodiment of the present disclosure, and

Fig. 13 illustrates a schematic diagram of an architecture of an exemplary computing device, according to an embodiment of the present disclosure.

Detailed Description

In order to make the objects, technical solutions and advantages of the present disclosure more apparent, exemplary embodiments according to the present disclosure will be described in detail with reference to the accompanying drawings. It should be apparent that the described embodiments are only some of the embodiments of the present disclosure and not all of the embodiments of the present disclosure, and that the present disclosure is not limited by the example embodiments described herein.

In the present specification and drawings, steps and elements having substantially the same or similar are denoted by the same or similar reference numerals, and repeated descriptions of the steps and elements will be omitted. Meanwhile, in the description of the present disclosure, the terms "first," "second," and the like are used merely to distinguish the descriptions, and are not to be construed as indicating or implying relative importance or order.

Unless defined otherwise, all technical and scientific terms used herein have the same meaning as commonly understood by one of ordinary skill in the art to which this disclosure belongs. The terminology used herein is for the purpose of describing embodiments of the invention only and is not intended to be limiting of the invention.

For purposes of describing the present disclosure, the following presents concepts related to the present disclosure.

The method for page rendering of the present disclosure may be based on Cloud technology (Cloud technology). Cloud technology refers to a hosting technology for unifying serial resources such as hardware, software, network and the like in a wide area network or a local area network to realize calculation, storage, processing and sharing of data. The cloud technology is based on the general names of network technology, information technology, integration technology, management platform technology, application technology and the like applied by the cloud computing business mode, can form a resource pool, and is flexible and convenient as required. Cloud computing technology will become an important support. Background services of technical networking systems require a large amount of computing, storage resources, such as video websites, picture-like websites, and more portals. Along with the high development and application of the internet industry, each article possibly has an own identification mark in the future, the identification mark needs to be transmitted to a background system for logic processing, data with different levels can be processed separately, and various industry data needs strong system rear shield support and can be realized only through cloud computing.

In particular, the methods for page rendering of the present disclosure may be based on artificial intelligence cloud services. Artificial intelligence cloud services are also commonly referred to as AIaaS (AI AS A SERVICE, chinese "AI as service"). The service mode of the artificial intelligent platform is the mainstream at present, and particularly, the AIaaS platform can split several common AI services and provide independent or packaged services at the cloud. The service mode is similar to an AI theme mall, all developers can access one or more artificial intelligence services provided by the use platform through an API interface, and partial advanced developers can deploy and operate and maintain cloud artificial intelligence services special to themselves by using an AI framework and AI infrastructure provided by the platform. For example, in the method for page rendering of the present disclosure, a logic configuration for describing the association between UIs, events, methods, linkages, and logic in a page module may be generated by synchronizing in the generation phase of the module and co-provided with the module to an operator for deploying and managing web services.

The method for page rendering of the present disclosure may be based on a Low-Code Engine (Low-Code Engine). A low code engine is a software development tool that is intended to help developers build applications in a faster, simpler manner. Conventional application development typically requires a large amount of manual code and technical knowledge, while low code engines enable developers to create applications using drag and drop, configuration, and a small amount of code by providing a visual development interface and predefined components. The low-code engine can be mainly characterized by comprising 1, a visual development interface, 2, a predefined component and a template, wherein the visual development interface is provided by the low-code engine, the user interface and logic of an application program can be built by a developer through dragging and dropping the component, setting attributes and configuration rules, 2, the predefined component and the template are provided by the low-code engine, the predefined component and the template comprise a form, a report, a workflow, database integration and the like, the application program can be quickly built by the developer directly using the components, and 3, the automatic code generation is realized, and the low-code engine can automatically generate bottom codes of most application programs, so that the workload of manual coding is reduced. And 4. Quick iteration and deployment, namely enabling the developer to quickly iterate and modify the application program, and realizing the change of the function through simple configuration and adjustment. At the same time, the low code engine also provides simplified deployment and release procedures, enabling applications to be quickly brought online and delivered. The methods for page rendering of the present disclosure may be an improved method for a low code engine, where modules, logic, UIs, events, methods, linkages, etc. in the low code engine are concatenated.

The method for page rendering of the present disclosure may be based on Domain-specific language (DSL). DSL is a programming language specifically designed for a particular domain or problem domain. DSL is more focused on solving domain-specific problems than general-purpose programming languages (such as Java, python), providing higher-level, more compact grammar and expressive power, and closer to domain-specific concepts and requirements. The design goal of DSL is to enable domain experts to directly describe and solve problems using programming languages without having to go deep into the underlying programming details. In the method for page rendering, the complex association relation and logic of the modules can be expressed in a more visual and readable mode based on DSL, so that operators can more conveniently understand and manage the relation among various parts, development efficiency and maintainability of codes are improved, and corresponding logic can be executed according to DSL defined relation more accurately during operation.

Some concepts involved in the method for page rendering of the present disclosure are described below. First, UIs (user interfaces), events, methods, linkages, and logic mentioned for the method for page rendering of the present disclosure are concepts independent of each other, but there is a certain association between them.

UI (user interface) a UI may refer to an interface that a user sees and manipulates when interacting with software. It includes various visual elements such as keys, text boxes, drop-down menus, and the like. Definition of the UI is typically implemented through front-end technologies such as HTML, CSS, and JavaScript.

Events (events) an event may refer to an action triggered when a user performs an operation on the UI, such as clicking a key, entering text, etc. The events may be predefined or custom. For example, a "click" event triggered when a key is clicked, or an "input" event triggered when a box is entered into content. Events can generally be responded to and processed by adding an event monitor (EVENT LISTENER).

Method a method may refer to a piece of executable code for performing a particular function or operation. Methods are typically packaged in functions or classes for invocation when needed. The method may be predefined or custom. For example, a method of calculating the sum of two numbers may be defined as a function.

Action an action may refer to a particular operation or task performed in an application that represents a user or system-triggered event or request to perform some function or to cause a particular action. The action may be an interactive operation on the user interface or a task of background processing. The actions may be predefined or custom. For example, an action is performed upon clicking a key, which may be, for example, displaying a pop-up window, sending a network request, etc.

Linkage INTERACTIVITY linkage may refer to interactions and effects between different UI elements. When the state or value of one UI element changes, changes or operations of other UI elements may be triggered. For example, when an option in a drop down menu is selected, it may result in content updates or operation execution of other related UI elements.

In summary, the solution provided by the embodiments of the present disclosure relates to cloud technologies, artificial intelligence cloud services, low code engines, domain-specific languages, and the like, and the embodiments of the present disclosure will be further described below with reference to the accompanying drawings.

Fig. 1 is a schematic view illustrating a scenario for implementing an interactive operation of a user with a user terminal according to an embodiment of the present disclosure.

As shown in fig. 1, a user may perform an interactive operation with a user terminal. Wherein a user may trigger a particular event in a page on the user terminal by performing a particular operation (e.g., including but not limited to a click operation, an input operation, etc.) on the user terminal, the triggered event may be transmitted to the server over the network for the server to perform a corresponding response process to the trigger event, e.g., generate corresponding page rendering data. The server may then return the generated page rendering data to the user terminal over the network, thereby performing a corresponding rendering operation on the page at the user terminal. Alternatively, the user terminal may specifically include, but is not limited to, a smart phone, a tablet computer, a laptop portable computer, a desktop computer, a vehicle-mounted terminal, a wearable device, and the like. The user terminal may also be a client that installs a browser or various applications, including system applications and third party applications. Optionally, the network may be an internet of things (Internet of Things) based on the internet and/or a telecommunication network, which may be a wired network or a wireless network, for example, it may be a Local Area Network (LAN), a Metropolitan Area Network (MAN), a Wide Area Network (WAN), a cellular data communication network, or an electronic network capable of implementing an information exchange function, where the user terminal and the server may be directly or indirectly connected through a wired or wireless communication manner, and the present application is not limited herein. The server may be an independent physical server, a server cluster or a distributed system formed by a plurality of physical servers, or a cloud server providing cloud services, cloud databases, cloud computing, cloud functions, cloud storage, network services, cloud communication, middleware services, domain name services, security services, CDNs, basic cloud computing services such as big data and artificial intelligent platforms.

In modern front-end development, the problems of long development period, difficulty in multiplexing all parts and the like are always challenges facing developers. These problems stem primarily from the many aspects involved in front-end development, including UI design, front-end logic, data processing, event handling, etc., and the association and collaboration between these aspects requires the developer to manually write large amounts of code and logic.

In traditional front-end development, a developer needs to write code manually to define page structure, style, and behavior. This approach presents problems such as long development cycles (due to the need to write large amounts of code manually, front-end development cycles are relatively long, especially for complex applications), parts that are difficult to multiplex (due to lack of unified components and modular mechanisms, parts of front-end development that are difficult to multiplex, resulting in code redundancy and maintenance difficulties), and tandem (association and collaboration between different aspects involved in front-end development (e.g., UI, logic, events, etc.) are difficult to express and implement in a concise and clear manner).

In the low code engine, developers can use concepts of templates, modules, logic, UIs, events, methods, linkages, etc. to describe and organize the various parts of the application. However, in low code engines, concatenation between these parts still presents challenges. Because of the flexibility and customizable nature of low code engines, different engines may define and implement associations between these portions in different ways. This makes it difficult to concatenate these parts in a generic and compact way, so that the developer still needs to face complex configurations when using a low code engine.

In view of the above, prior art solutions typically implement interaction and action responses between components by a user adding events to the individual components (modules). The user may add different trigger conditions (such as click, double click, long press, etc.) on the component to trigger the corresponding action. These actions are typically developed in advance and are distributed into a library of materials used by the component, or another component may be selected to link the component events in response to the triggered actions. The user may select an existing action from the action list or define a new action by custom code. Finally, the user uses DSL (Domain specific language) to describe the association of these events and actions and builds them into the renderer for execution.

However, in the above-described technical solution, there are the following problems:

1. The above technical solution is based on event addition at the component level, and is difficult to add actions at the level of DOM (Document Object Model ) with finer granularity in the component, the above technical solution is usually to trigger actions by adding events to the component, but for DOM elements with finer granularity in the component, events cannot be directly added, and the events need to be implemented through encapsulation and exposure interfaces of the component. This approach increases the complexity of development and maintenance costs;

2. The linkage between the components is difficult to maintain and reuse, and in the technical scheme, the linkage between the components is usually realized through manual configuration and coding. This approach is difficult to maintain and multiplex, and particularly when the complexity of the application increases, a large amount of code needs to be written to handle the interaction logic between the components, increasing the difficulty and workload of development;

3. The number of actions in the action list is small or compatibility problems may exist, in the above technical solution, the provided action list is usually limited and compatibility problems may exist. For some specific business scenarios, proper actions may not be found to meet the needs, requiring the developer to develop and configure themselves. In addition, because different browsers and devices support different degrees of actions, compatibility problems may exist, and configuration personnel are required to understand whether the actions are compatible;

4. The deployment and maintenance cost of the renderer is high, which is not beneficial to the rapid update iteration expansion of other functions: in the above technical solution, the renderer is a core component for implementing action execution, but deployment and maintenance of the renderer requires a certain cost and resource investment. When other functions need to be updated, iterated or expanded, the renderer may need to be modified and redeployed, increasing the complexity of development and operation;

5. in the technical scheme, the triggering parameters of the actions are limited, and the actions can be triggered only by simple triggering conditions. For some complex traffic scenarios, more flexible and rich trigger parameters may be required to implement. In addition, the above technical solutions often lack support for the action triggering sequence and conditions, and are difficult to meet some complex interaction requirements.

The present disclosure provides, based on this, a method for page rendering that renders modules by using a logical configuration of each module included in a page when rendering the page, wherein UIs of the modules are connected in series with events and linkages of the modules according to the logical configuration for implementing monitoring-based responsive rendering of a user interface.

Fig. 2 is a flowchart illustrating a method 200 for page rendering according to an embodiment of the present disclosure.

Fig. 3A is a schematic block diagram illustrating execution of a rendering flow 300 and a trigger linkage flow 310 according to an embodiment of the present disclosure. Fig. 3B is a schematic block diagram illustrating an execution triggering event flow 320 according to an embodiment of the present disclosure. Fig. 4 is a flow chart illustrating event communication in an execution engine according to an embodiment of the present disclosure.

The method for page rendering as shown in fig. 2 will be described with reference to fig. 3A to 4.

Before performing the steps shown in FIG. 2, a global data store (store) for page rendering may first be initialized, as shown by reference numeral 301 in FIG. 3A. Alternatively, a data store repository may refer to a system or component for storing and managing data that may provide a structured way to store and retrieve data, and also provide some additional functionality such as data backup, data recovery, data access control, and the like.

In an embodiment of the present disclosure, as shown in FIG. 4, a global event bus (401) may be created for a page at the same time as the page loads and used as a global data store repository, i.e., the data store repository (402) is initialized with the event bus for storing data required for all subsequent operations. Thus, according to embodiments of the present disclosure, the method for page rendering may further comprise a step of creating an event bus for the page, which may be used to monitor for triggers of events in the page, prior to the following steps S201-S203 (which will be described below with reference to fig. 6).

As shown in fig. 2, in step S201, a logical configuration of a page may be obtained, the page may include a plurality of modules, wherein each module may include one or more user interfaces, the logical configuration may include a logical configuration of each of the plurality of modules, wherein the logical configuration of each module is generated with the module and is used to describe events in the module and linkages between the module and other modules.

In embodiments of the present disclosure, upon execution of page rendering, a logical configuration of a page may be obtained (302), which may include a logical configuration of each module in the page, and parsed (303) to obtain the event, method, and linkage configuration of each module in the page. It should be noted that the logical configuration of each module is generated together with the corresponding module. That is, in the embodiments of the present disclosure, a logic configuration for describing relationships such as event-triggered and linked configurations in respective modules may be synchronously generated when respective modules for constituting a page are generated, and the logic configuration may be used to parse various association relationships of the respective modules in a page rendering stage.

Further, in embodiments of the present disclosure, which may take page rendering in a browser environment as an example, the method for page rendering of the present disclosure may perform page rendering at browser Runtime, and thus, the main logic of page rendering may be performed at a Runtime (run time) layer, where the run time layer may refer to the Runtime environment of a software system, which is an intermediate layer between an operating system and an application program, for providing a series of Runtime services and resource management functions to support execution and execution of the application program. Of course, it should be understood that page rendering in the browser environment described above is used in this disclosure by way of example only and not limitation, and that the methods of the present disclosure for page rendering may be equally applicable to page rendering tasks in other situations.

Alternatively, the logical configuration of a module may refer to configuring and controlling the behavior of the module according to specific requirements and conditions when an application (e.g., browser) is running. In this case, each module may have a specific configuration to define events, methods, linkages, etc. therein according to its specific functions and logic.

As an example, the logical configuration of each module may be used to describe the associations that exist between modules, such as UIs, events, methods, linkages, actions, and the like. An event may refer to a specific interaction operation or a specific event triggered by a module, and by configuring the event, an operation or logic that the module should perform under a specific condition may be defined. A method may refer to a particular function or operation that a module may invoke, by which a particular action or logic that the module may perform may be defined. Linkage may refer to the interrelation and interaction between modules, and by configuring the linkage, the dependency and interaction rules between modules may be defined to achieve more complex functions and interaction effects, e.g., the linkage may include interactions and effects between different UI elements involved in different modules. By providing independent logic configuration for each module, the behavior of the modules can be controlled and customized more flexibly, and different modules can define events, methods, linkages, etc. according to their own needs and logic, so as to achieve more accurate and personalized functions, thereby making interactions between modules more flexible and scalable.

In embodiments of the present disclosure, to enable real-time dynamic rendering of an entire page, linkage between modules needs to be configured in the logical configuration of each module. By way of example, in the method for page rendering of the present disclosure, a couple of linkage configurations may be considered, ① user interface linkages, in which different modules may interact and change according to user input as the user operates on the user interface. For example, when a user enters data in a form, other relevant fields may be automatically populated or updated based on the entered content, ② event-driven linkage-the different modules or components in the software system (e.g., browser) may be linked by the triggering and processing of events. For example, when a key is clicked, an event can be triggered, other components can execute corresponding operations or updates according to the event, ③ data linkage can be performed between different data sources or data modules so as to maintain the consistency and synchronization of data. For example, when the value of one data module changes, other modules or components depending on the value can be automatically updated, ④ systems can be linked, and different software systems or services can be linked to realize data sharing, function expansion or cooperative work. For example, two systems may exchange and share data via an API interface, or one system may call a function of the other system to accomplish a particular task.

As described above, the ganged configuration is important in the logical configuration of each module, which enables the software system (e.g., browser) to respond and update in real time according to different inputs and events. Through linkage configuration, better user experience can be provided, flexibility and interactivity of a software system are improved, and meanwhile efficiency and usability of the system are improved. Of course, it should be understood that the several linkage arrangements provided above are merely exemplary and not limiting in this disclosure, and that other linkage arrangements may be employed with the methods of the present disclosure for page rendering as well.

Alternatively, the logical configuration of each module may be represented as a DSL that is generated at the same time as the module is generated, which may be a specific language for describing the associations between the various parts (e.g., events, methods, linkages, etc.) in the module. For example, the DSL may be a custom language that is specifically used to describe and define associations between various components, such as dependencies, execution order, and the like. While the page is running, the execution engine may parse and execute the rendering of the module according to the DSL of the module, including processing the logic and interactions of the various parts according to the associations described by the DSL.

Fig. 5 is a schematic diagram illustrating a logical configuration of an example lottery module according to an embodiment of the disclosure.

As shown in fig. 5, for a lottery module 500 given as an example, the logical configuration generated for the lottery module 500 may include, but is not limited to, an association 510, an association 520, an association 530, and an association 540. Wherein the association relationship 510 describes an association between a UI, an event, and an action, that is, an association between a UI-lottery interface (shown as an outermost black box in fig. 5), an event- "loading event", and an action- "query lottery number", which indicates that the "loading event" is bound for the UI, and the action "query lottery number" is executed in response to the trigger of the "loading event". The association relationship 520 also describes the association between the UI, the event, and the action, that is, the association between the UI-lottery initiation button (shown as the black box of the innermost layer in fig. 5), the event- "click event", and the action- "start lottery", which indicates that the "click event" is bound for the UI, and the action "start lottery" is performed in response to the trigger of the "click event". The association relationship 530 describes an association between a UI and a method, that is, an association between a UI-lottery interface (shown as the outermost black box in fig. 5) and a method- "refresh lottery number", which indicates that the method "refresh lottery number" is defined for the UI, which may be exposed to other nodes (e.g., modules or UIs, etc.) as an interface of the UI for other nodes to call functions of the UI (e.g., call the method "refresh lottery number" in other modules or UIs of the page). The association relation 540 describes an association between the UI and the data, that is, an association between the UI-lottery remaining number display interface and the data- "state value of lottery remaining number", which indicates that the data "state value of lottery remaining number" is bound for the UI, that is, the value displayed by the UI is updated instantaneously as the data "state value of lottery remaining number" changes. As noted above, fig. 5 illustrates some example logic configurations of the present disclosure, but this should not be taken as a limitation on the logic configurations of the present disclosure.

Optionally, the logical configuration of each module may include, but is not limited to, events, methods, and linkages. For example, an event may include an Identifier (ID), name (name), type (type), action (action), and data (data) of a node, the type may support defining an event such as a load, click, etc., a method may include an ID and action of a node, etc., and a linkage may include an ID of a node, an ID of a monitoring node (listenID), an event name (EVENTNAME), an ID of a target node (target ID), an action, and data. Where a node may correspond to a module (or a UI in the module), each node has a unique ID for identifying the node. The ID may be a string, number, or other type of identifier that uniquely identifies the node in the system.

That is, interaction and communication between nodes may be achieved through events, methods, and linkages, where an event, as a message between nodes, may be used to notify other nodes that a particular event or state change has occurred, and a method may be that a node is exposed to an interface of other nodes, and that other nodes call the functions of the node, and the linkages may provide collaboration and interaction between multiple nodes, where an operation or state change of one node may trigger a response of other nodes. The method for exposing the node is provided and maintained by the node itself, so that compatibility problems are not required to be considered. Thus, the logical configuration of each module is serially connected with the life cycle of the whole module, and through the configuration, the event triggering and the method calling inside the module and the linkage among the modules can be realized.

As described above, the methods for page rendering of the present disclosure may be based on module development accomplished by a module producer through operations such as fine-grained event binding (e.g., events may be added at a DOM level of very fine granularity within a module, trigger actions) and action association to individual UIs in a module, at a module generation stage, whose output may include module data to be rendered as well as the logical configuration of the module.

Thus, in performing page rendering, for the data store created as above, a respective sub data store (sub store) may be created for each node (409) by using the node ID as an identifier, and a respective sub event bus (410) may be created. According to an embodiment of the present disclosure, the method for page rendering of the present disclosure may further include, for each of the plurality of modules, creating a sub-event bus in the event bus for the module for individually storing state values of one or more user interfaces of the module. Alternatively, the data of each node (e.g., state inside the node, calculation result, processed message, etc.) may be mounted on its sub-store, which serves as a container for storing and managing the node data, and isolation and encapsulation of the data may be achieved. Therefore, the child store of each node can store own data, and other nodes can only access and operate the data by calling methods or subscribing events, so that maintainability and expandability of the system can be improved, and dependency relations among modules can be reduced. For example, for events, methods, linkages in the logical configuration of each module, which may have the same ID, i.e., node ID, these data may all be mounted on the child store of that node. For example, a child store of each node may store a corresponding dictionary table (dictionary) for that node, which may store node data in key-value pairs (keys) where each data key has a unique canonical name for identifying and retrieving values by the unique key, thereby reducing data field redundancy, usage of canonical data.

As shown in fig. 3A, in the rendering flow 300 for a page, after initializing a data store (301), acquiring a logical configuration of a module (302), and analyzing the logical configuration (303), a linkage event of the module may be monitored (304) based on the logical configuration of each module.

Thus, in step S202, for each of the plurality of modules, events associated with the linkage in the module may be monitored and one or more events bound for one or more user interfaces of the module based on the logical configuration of the module.

Alternatively, to enable communication between the modules, a state manager may be used, wherein the event bus described above is used as a common carrier for data access, and access to data of pages and monitoring of changes in data are enabled by monitoring events using the event bus.

According to an embodiment of the disclosure, the monitoring of events associated with the linkage in the module based on the logical configuration of the module may include monitoring for triggers of events associated with the linkage in the module using the event bus.

Alternatively, an event bus may be a mechanism for communicating between different modules that allows decoupling and interaction between modules by publishing and subscribing to events, the event bus may be considered a central scheduler for receiving and distributing events, where modules may publish events to the event bus, and other modules may receive and respond accordingly by subscribing to the events, thereby enabling interlocking between modules.

According to embodiments of the disclosure, the monitoring of the triggering of events associated with the linkage in the module with the event bus may include triggering the events associated with the linkage in the module in the event bus in response to triggering events associated with the linkage in the module during execution of actions of the page, and executing actions corresponding to the linkages in response to the event bus monitoring the events associated with the linkage in the module triggered in the event bus.

As an example, as shown in fig. 3A, an event bus may monitor an event (e.g., the event may be of any type, the tag may carry data and parameters) triggered in any of the modules (i.e., an action performed in the module triggers a ganged event, as shown by reference numeral 311 in fig. 3A) and issued over the event bus (i.e., the event bus triggers a ganged event, as shown by reference numeral 312 in fig. 3A), and after the triggering of the event is detected (313), perform a corresponding action of the ganged (314), e.g., send the event to other modules subscribed to the event.

Fig. 6 is a schematic diagram illustrating data acquisition and change monitoring via an event bus according to an embodiment of the present disclosure.

As shown in fig. 6, the event bus 600 of the present disclosure may primarily implement monitoring functions for events (e.g., data access events 620 and data change events 630 mounted on the event bus 600, etc.). Optionally, the event bus of the present disclosure may return a corresponding result to the triggering party of an event in response to monitoring the triggering of the event. For example, for event bus 600, FIG. 6 shows an example monitoring process in three situations. For the case 601 for synchronous acquisition of values, where a data access event 620 is triggered in a module (and the trigger may be with a parameter), the event bus may monitor the trigger of the data access event 620 and return the data value that the module expects to acquire to the module. For the case 602 for modifying a value, where the current value of a certain data is modified in a certain module and a data change event 630 is triggered (and the trigger may carry a parameter), the event bus may monitor the trigger of the data change event 630 and return subscribers monitoring for changes to the data (e.g., for notifying the subscribers of changes to the data). For the case 603 for monitoring data changes, where it is desired to monitor certain data in a module and a subscription function is added to the data change event 630, the event bus 610 may also monitor the module's subscription to the event and add the module to the subscriber who subsequently returns to monitor the change in the data. In addition, the monitoring of event bus 610 may also return an event clean up function to support the cleaning up of the monitoring after invocation. Of course, the various cases described above for data acquisition and change monitoring via an event bus are by way of example only and not limitation, and the methods of the present disclosure are equally applicable to other cases.

As described above, the state manager may enable access to data and monitoring of changes in data by mounting various events (e.g., the data access event 620 and the data change event 630 described above, etc.) on the event bus, where the mounting may include associating the event bus with the events so that the corresponding processing logic can be triggered when the events occur. In addition, the process of data access and data change monitoring through these events can be encapsulated into a data synchronization method or Hook (Hook) function call in the act framework, etc., to ensure the need for data access and responsive data change monitoring in the subsequent process.

By using the event bus to monitor the events associated with the linkage in the modules, a decoupling and loose coupling communication mode can be realized between the modules, wherein publishers do not need to directly know the existence of subscribers, only need to publish events, and subscribers do not need to know specific publishers, only need to subscribe to interesting events. Therefore, maintainability and expandability of codes can be improved, and dependency relationships among modules can be reduced.

Further, as shown at reference numeral 305 in fig. 3A, for each of the plurality of modules, one or more events may be bound for one or more user interfaces of the module based on the logical configuration of the module. Optionally, related events (such as the loading event, the clicking event, etc. described above with reference to fig. 5) may be bound for each UI in the module to implement a corresponding association relationship.

Alternatively, as shown in FIG. 4, the state manager (406) may be invoked by the execution engine to perform event binding (408) through state management (407). For example, by parsing the logical configuration of the module by the execution engine, the state manager may be utilized to mount events for the UI of the module, and so on.

Next, in step S203, for each of the plurality of modules, one or more user interfaces of the module may be rendered based on the monitoring of events associated with the linkage in the module and the one or more events bound for the one or more user interfaces of the module.

Optionally, reactive rendering for the module may be implemented based on triggering of the linked event and/or event triggering in the module. According to embodiments of the present disclosure, the event bus may be used as a data store repository for page rendering for storing status values of a user interface of the page. As described above, the event bus may store state values (e.g., through a child store for each module) involved in the UIs in the modules to enable reactive rendering for the UIs in the modules based on monitoring of the event bus for changes in data.

According to embodiments of the present disclosure, the rendering of one or more user interfaces of the module based on the monitoring of events associated with a linkage in the module and the one or more events bound for the one or more user interfaces of the module may include re-rendering respective user interfaces of the module in response to the event bus monitoring a state value change occurring in the event bus by performing an action corresponding to the linkage, performing an action corresponding to one of the one or more events bound for the one or more user interfaces of the module in response to the one or more events being triggered, and re-rendering respective user interfaces of the module in response to the event bus monitoring a state value change occurring in the event bus by performing an action corresponding to the event.

Optionally, rendering one or more user interfaces of the module based on monitoring events associated with the linkage in the module and the one or more events bound for the one or more user interfaces of the module may include a process flow as shown in trigger linkage flow 310 in fig. 3A and trigger event flow 320 in fig. 3B, respectively.

Alternatively, as shown in the triggered linkage flow 310 in FIG. 3A, in the event of a state value change in the event bus due to execution of an action corresponding to linkage (314), the associated UIs may be re-rendered based on the changed state values to update the state values in those UIs.

Specifically, as shown in fig. 3B, after a specific event (e.g., "click event" or the like in fig. 5) is triggered in any one of the modules (321), an action corresponding to the event (e.g., "start lottery" or the like in fig. 5) may be loaded and executed (322, 323). For example, as shown in FIG. 4, an action (403) may be loaded by the execution engine and the action (404) performed. Further, as described above with reference to FIG. 6, execution of this action may access the UI state value (405), and the execution engine may call the state manager (406) to perform state management (407) (e.g., the mount data access event and the data change event described above) to monitor the relevant events (408).

Alternatively, an action in the present disclosure may refer to a logical fragment that may support returning a function for clearing side effects to avoid environmental pollution due to execution of the action, and to avoid duplicate data problems that may occur when the action is executed twice. Optionally, the actions in the disclosure need to define the parameters of the actions before development and the events possibly triggered by the actions, so as to ensure the safety of the types of the actions, and the strong verification of the types of the actions can avoid the problems of inconsistent protocols such as inconsistent types, undefined parameters and the like. Optionally, in the development process of the action, the input parameters, the output parameters and the like of the action can be updated through one key of a Command line interface tool (Command LINE INTERFACE, CLI), a type script (TYPESCRIPT (TS)) is automatically generated and written into a TS type file to restrict the development process of a developer and provide TS type checking, so that the development quality of the action is ensured. Alternatively, the actions may, for example, support obtaining a currently triggered event object, support accessing dictionary table data on the current node, support triggering an event corresponding to the current action, and the disclosure is not limited in this regard.

Next, if execution of the action modifies a state value in the UI (324) and the event bus monitors the state value for a change (325), the associated UI may be re-rendered based on the changed state value.

A process of re-rendering the relevant UI in response to the UI state value being modified due to the execution of the action will be described in detail with reference to fig. 7.

Fig. 7 is a schematic flow diagram illustrating reactive UI rendering for a module to be rendered according to an embodiment of the disclosure.

As shown in fig. 7, the object of the rendering is to render a reactive UI for a module to be rendered 701, wherein the reactive UI may refer to a UI capable of automatically changing according to a change of data. Specifically, the module to be rendered 701 may include a UI to be displayed, and the flowchart shown in fig. 7 may include event binding and data reaction for the UI in the module to be rendered 701.

Alternatively, for event binding, the IDs of all UI nodes in the module may first be looked up (702), and the corresponding events are bound for each of these nodes (703). As an example, all UI nodes of the module to be rendered may be traversed in a recursive manner, and the event to be executed and the event to be triggered are matched based on the mounted position, so as to implement event binding. For example, the location where the event needs to be mounted can be automatically found according to the name of the event in the logic configuration.

Optionally, for data reaction, the data state changes in the sub store to which the module corresponds may be monitored (704) and a simple expression calculated upon action triggering (705) to provide flexible parameter delivery. Thus, in FIG. 7, the reactive UI may eventually be rendered based on the triggering of the bundled event and the corresponding parameter delivery.

As an example, an expression of a parameter may be parsed before an action is performed, a string therein extracted, the string parsed, and the expression calculated. After the calculation is completed, a new character string can be spliced to be transmitted to the action as the value of the parameter. The parsed expression here may obtain the state value of the node, supporting the retrieval of sub-data from the state value and transfer to the action. The method and the device can support the needs of most scenes by simply analyzing and executing the expressions by self, and the triggering parameters support the transfer expressions, and support the synchronous calculation of the latest parameter values when triggering actions, so that the action configuration is more flexible.

As described above, based on the logical configuration of each module, real-time reactive rendering of the UI in the module can be achieved using the association of events, methods and linkages in the module.

By real-time reactive rendering of the UI in the module, when any state value of the UI in the module changes, the UI can be re-rendered to ensure that the latest data is always displayed.

As an example, considering that the method for page rendering of the present disclosure is mainly used on the user terminal side, the network environment thereof may be relatively complex, and optimization or automatic retry may also need to be performed for the parts related to network operations, such as interface requests, file downloads, and the like, due to the influence of network fluctuations, in the embodiment of the present disclosure, in order to improve the execution performance of the method, optimize the user experience, reduce useless network bandwidth consumption, the method for page rendering of the present disclosure further provides a loading buffer mechanism for actions. According to an embodiment of the present disclosure, the method for page rendering of the present disclosure may further include directly multiplexing a previously returned loading result for an action if the action is initiated again for a loaded action during rendering of the page, performing concurrent loading for a different action, and performing reloading for a limited number of loading times if the action loading fails for the same action.

Fig. 8A is a schematic flow diagram illustrating load caching for actions according to an embodiment of the present disclosure. In the execution of the method for page rendering of the present disclosure, there may be a case where a plurality of actions are loaded at the same time. In page loading, multiple actions may be used simultaneously, so the flow shown in FIG. 8A may control the loading of actions. As shown in fig. 8A, an action to be performed may first be acquired 801, and next, a load caching mechanism may be performed, i.e., a determination may be made as to whether the action has been loaded 802, and in the event that the action has been loaded, the action is not repeatedly loaded, but rather the previously returned load results 806 for the action are directly multiplexed. In the case that the action is not loaded, it may be determined in step 803 whether the action is being loaded, and if yes, the action is waiting for loading 805 of the action, and if no, the action is written into the wait for loading queue 804 to perform concurrent loading on different actions, thereby improving response performance, and the loading of the actions does not affect each other. Finally, a fail-over mechanism may also be employed for loading of an action, i.e., if the action fails to load, the action may be reloaded a limited number of times to prevent accidental load failure due to network fluctuations.

As another example, to enhance the user experience, to ensure that pages can respond quickly and timely to user operations, the methods for page rendering of the present disclosure may also use a pre-load mechanism for actions. According to an embodiment of the present disclosure, the method for page rendering of the present disclosure may further include preloading one or more actions in the page for the page, the one or more actions not previously loaded and having a use potential, as shown at 306 in FIG. 3A.

Fig. 8B is a schematic flow diagram illustrating delayed loading for actions according to an embodiment of the present disclosure.

As shown in FIG. 8B, when a user enters the client page 810, regardless of whether an action is used, the actions may be preloaded as long as the action is an action that has not been loaded and may be used (loaded) in the future. Therefore, the pre-loading mechanism can ensure that the interactive operation executed by the user is responded immediately without delay caused by loading of actions, so that the page is used more smoothly, and better user experience is brought.

It should be noted that the event bus is used as a global data storage repository, and is used for providing all data such as state values, dictionary tables and the like required by subsequent operations to the state manager, and all data of events/linkages and the like are also from the global data storage repository, and input and output of action execution are also obtained and assigned from the data storage repository, and the rendering of the UI is also to implement reactive rendering according to the data storage repository. Thus, the data store repository serves as the core of the execution engine, concatenating the complete lifecycle of the page through the publish-subscribe and status sharing of events, and provides the individual modules with the ability to share data and individually access data, while also providing the UI with the ability to display reactively.

As described above, based on the above method for page rendering, events in modules and links between modules and other modules are resolved by using the logic configuration of each module generated together with each module constituting a page, so that in the page rendering, for each module, a user interface in the module is bound with the events according to the logic configuration of the module, and events associated with the links between modules are monitored, so as to implement real-time dynamic responsive rendering of the page. The method can generate the logic configuration for describing the association relation among the parts in each module while generating each module so as to uniformly manage the triggering of events in the modules, the definition of the method and the linkage configuration, and the association relation among the modules in the page is connected in series through the linkage configuration, so that the modules are mutually matched in communication, and finally the dynamic rendering of the whole page is completed.

Fig. 9 is a system architecture diagram illustrating a system for page rendering according to an embodiment of the present disclosure.

As shown in fig. 9, in a system architecture for page rendering, a module generator 910, a page builder 920, a state manager 930, an event bus 940, and a renderer 950 may be included. Wherein,

Alternatively, the module generator 910 may generate new modules (and/or templates, where a template may correspond to a complete page and may include multiple modules; e.g., a template may be used as a DSL generated by the supermodule generator 910, after which the operator may select the template, create his own page and edit, such as replace pictures, modify documents, modify configurations, etc.), and after verification testing may be put on the page builder 920 for configuration use. The UI and logic may be concatenated with each other through the development configuration of the module generator 910 to synchronize the logic configuration of the generation module (and/or template).

Alternatively, the page builder 920 may support creation of new pages based on the modules (and/or templates) generated by the module generator 910 and support configuring and managing pages of personalized business needs, e.g., the types of pages may include active pages, store pages, content pages, etc. For example, an operator may quickly configure a desired page at page builder 920 using modules (and/or templates) generated by module generator 910, and the process supports quick previews, publishing experience environments (i.e., deploying software, applications, or websites from a development environment or testing environment to an environment simulating a real user experience for trial and feedback by a user), publishing on-the-fly environments (i.e., deploying software, applications, or websites from a development environment or testing environment to an actual running production environment for access and use by a real user), and the like.

Optionally, the disclosure also proposes an execution engine configured in a module for building pages, the module may include one or more user interfaces, the execution engine may be configured to obtain a logical configuration of the module, wherein the logical configuration of the module is generated with the module and is used to describe events in the module and linkages between the module and other modules, monitor events associated with linkages in the module based on the logical configuration of the module and bind one or more events for one or more user interfaces of the module, and render one or more user interfaces of the module based on the monitoring of events associated with linkages in the module and the one or more events bound for one or more user interfaces of the module.

As described above, the execution engine may be used to perform the operations described above with reference to fig. 2, and the execution engine may be built in a module generated by the module generator 910 as shown in fig. 9 to perform a method for page rendering in a page rendering phase, for example, to obtain association relations (912) between UIs, logics, events, actions, etc. from a logical configuration of the module for performing UI rendering, etc.

The module generated by the module generator 910 described above may be essentially a component that the page builder 920 may operate, but may differ from other modules that the page builder 920 may operate by including the execution engine 911 described above in the module. The execution engine 911 of the present disclosure may operate stably and use smoothly in various scenarios, and may also provide more rich and flexible functionality for the module generator 910. By configuring the execution engine 911 in each module generated by the module generator 910, the rendering process of all modules can be completed by using the execution engine 911 in combination with the state manager 930, the event bus 940, and the renderer 950, thereby improving the efficiency of module generation and page rendering.

Fig. 10 is a schematic diagram illustrating the construction and application of a page according to an embodiment of the present disclosure.

According to an embodiment of the disclosure, the disclosure also proposes a page building method comprising selecting, by a page builder, one or more modules from a set of modules generated by a module generator, each of the one or more modules being configurable with an execution engine as described above, each of the one or more modules being configurable with one or more user interfaces, wherein the logical configuration of each module is generated by the module generator together with the modules and is used to describe events in the modules and linkages between the modules and other modules, and building, by the page builder, a page based on the selected one or more modules. As described above and shown in FIG. 10, the construction of page 1040 may include the generation 1001 of modules by module generator 1010 and the configuration 1002 of modules by page constructor 1020.

According to an embodiment of the disclosure, the page building method may further include generating, by the module generator, the set of modules for the module generator, each module of the set of modules may include the execution engine, a logic configuration, and one or more user interfaces, and adding each module of the set of modules as selectable components to an editor of the page builder, the editor of the page builder may include a plurality of selectable components for building a page, wherein each selectable component corresponds to one module of the set of modules. Alternatively, as shown in FIG. 10, module generator 1010 may generate a module for page builder 1020, which may include a UI (JSX), logic configuration, and execution engine. The generated modules may be included in a set of modules for page builder 1020 and may be added to the page builder's editor for building pages as selectable components at page builder 1020 for building pages. That is, the module generated by module generator 1010 may be the smallest stand-alone unit that may be added into the editor of page builder 1020.

According to an embodiment of the present disclosure, selecting, by a page builder, one or more modules from a set of modules generated by a module generator may include selecting, by the page builder, one or more selectable components from an editor of the page builder according to a predetermined task for building a page corresponding to the predetermined task. Optionally, at the page builder, the operator of the page builder may select a component for building the page from the set of selectable components according to a predetermined task, e.g., by selecting one or more selectable components from an editor, wherein the predetermined task may be determined by the operator of the page builder operating according to personalized needs.

Constructing, by a page builder, a page based on the selected one or more modules may include arranging, by the page builder, the selected one or more selectable components according to the predetermined task to construct the page. Alternatively, at the page builder, an operator of the page builder may operate to customize the page according to the personalized needs, e.g., may select components in the editor from among their needs, and arrange the selected components (e.g., by dragging, copying, pasting, etc.) to complete the page build.

The page construction method can enable the module generated by the module generator 1010 to be more flexible and universal, provide richer functions and safer and more flexible configuration modes for configuration personnel, and enable page rendering to be safer and more stable by using a unified execution engine, so that user experience is optimized.

Fig. 11 is a schematic diagram illustrating an apparatus 1100 for page rendering according to an embodiment of the present disclosure.

According to an embodiment of the present disclosure, the apparatus 1100 for page rendering may include a configuration acquisition part 1101, an association configuration part 1102, and a page rendering part 1103.

Similarly, in addition to the components described above, the apparatus for page rendering of the present disclosure may also include components for creating an event bus for the page. The event bus may be used as a global data store repository, i.e. the data store repository is initialized with the event bus for storing data required for all subsequent operations. Alternatively, a data store repository may refer to a system or component for storing and managing data that may provide a structured way to store and retrieve data, and also provide some additional functionality such as data backup, data recovery, data access control, and the like.

The configuration acquisition component 1101 may be configured to acquire a logical configuration of the page, the logical configuration including a logical configuration of each of the plurality of modules, wherein the logical configuration of each module is generated with the module and is used to describe events in the module and linkages between the module and other modules. Alternatively, the configuration acquisition section 1101 may perform the operation described above with reference to step S201.

In the embodiment of the disclosure, when performing page rendering, the logic configuration of the page may be acquired, and the acquired logic configuration may be parsed to obtain the event, method and linkage configuration of each module in the page, where the logic configuration of the page may include the logic configuration of each module in the page. It should be noted that the logical configuration of each module is generated together with the corresponding module. That is, in the embodiments of the present disclosure, a logic configuration for describing relationships such as event-triggered and linked configurations in respective modules may be synchronously generated when respective modules for constituting a page are generated, and the logic configuration may be used to explain various association relationships of the respective modules in a page rendering stage.

Further, in embodiments of the present disclosure, which may take page rendering in a browser environment as an example, the apparatus for page rendering of the present disclosure may perform page rendering at browser Runtime, and thus, the main logic of page rendering may be performed at a Runtime (run time) layer, where the run time layer may refer to the Runtime environment of a software system, which is an intermediate layer between an operating system and an application program, for providing a series of Runtime services and resource management functions to support execution and running of the application program. Of course, it should be understood that page rendering in the browser environment described above is used in this disclosure by way of example only and not limitation, and that the apparatus for page rendering of this disclosure may be equally applicable to page rendering tasks in other situations.

For example, the logical configuration of each module may be used to describe the associations that exist between modules, such as UIs, events, methods, linkages, actions, and the like. An event may refer to a specific interaction operation or a specific event triggered by a module, and by configuring the event, an operation or logic that the module should perform under a specific condition may be defined. A method may refer to a particular function or operation that a module may invoke, by which a particular action or logic that the module may perform may be defined. Linkage can refer to the mutual association and interaction between modules, and through configuration linkage, the dependency relationship and interaction rule between modules can be defined so as to realize more complex functions and interaction effects. By providing independent logic configuration for each module, the behavior of the modules can be controlled and customized more flexibly, and different modules can define events, methods, linkages, etc. according to their own needs and logic, so as to achieve more accurate and personalized functions, thereby making interactions between modules more flexible and scalable.

Optionally, the logical configuration of each module may include, but is not limited to, events, methods, and linkages. For example, an event may include an Identifier (ID), name (name), type (type), action (action), and data (data) of a node, the type may support defining an event such as a load, click, etc., a method may include an ID and action of a node, etc., and a linkage may include an ID of a node, an ID of a monitoring node (listenID), an event name (EVENTNAME), an ID of a target node (target ID), an action, and data. Where a node may correspond to a module (or UI in a module), each node has a unique ID for identifying the node. The ID may be a string, number, or other type of identifier that uniquely identifies the node in the system.

Interaction and communication between nodes can be achieved through events, methods and linkage, wherein the events are used as messages between the nodes and can be used for notifying other nodes that a specific event or state change occurs, the method can be that the nodes are exposed to interfaces of other nodes, the nodes are used for calling functions of the nodes, the linkage can provide cooperation and interaction among a plurality of nodes, and the operation or state change of one node can trigger the response of the other nodes. Thus, the logical configuration of each module is serially connected with the life cycle of the whole module, and through the configuration, the event triggering and the method calling inside the module and the linkage among the modules can be realized.

After the configuration acquisition section 1101 completes acquiring the logical configuration and resolving the logical configuration, the linkage event of the module may be monitored based on the logical configuration of each module.

The association configuration component 1102 may be configured to monitor events associated with linkages in the modules based on the logical configuration of the modules for each of the plurality of modules and bind one or more events for one or more user interfaces of the modules. Alternatively, the association configuration section 1102 may perform the operations described above with reference to step S202.

For example, to enable communication between modules, a state manager may be used in which the event bus described above is used as a common carrier for data access, with access to data of pages and monitoring of changes to data being enabled by monitoring events using the event bus.

Optionally, for each of the plurality of modules, one or more events may be bound for one or more user interfaces of the module based on the logical configuration of the module. Optionally, related events (e.g., loading events, clicking events, etc.) may be bound for each UI in the module to achieve a corresponding association.

The page rendering component 1103 may be configured to render, for each of the plurality of modules, one or more user interfaces of the module based on the monitoring of events associated with the linkage in the module and the one or more events bound for the one or more user interfaces of the module. Alternatively, the page rendering section 703 may perform the operation described above with reference to step S203.

For example, reactive rendering for a module may be implemented based on triggering of linked events and/or event triggers in the module. As described above, the event bus may store state values (e.g., through a child store for each module) involved in the UIs in the modules to enable reactive rendering for the UIs in the modules based on monitoring of the event bus for changes in data.

Optionally, based on the logic configuration of each module, the real-time reactive rendering of the UI in the module may be implemented using the association of events, methods, and linkages in the module. By real-time reactive rendering of the UI in the module, when any state value of the UI in the module changes, the UI can be re-rendered to ensure that the latest data is always displayed.

According to yet another aspect of the present disclosure, there is also provided an apparatus for page rendering. Fig. 12 shows a schematic diagram of an apparatus 2000 for page rendering according to an embodiment of the present disclosure.

As shown in fig. 12, the apparatus 2000 for page rendering may include one or more processors 2010, and one or more memories 2020. Wherein said memory 2020 has stored therein computer readable code which, when executed by said one or more processors 2010, can perform a method for page rendering as described above.

The processor in embodiments of the present disclosure may be an integrated circuit chip having signal processing capabilities. The processor may be a general purpose processor, a Digital Signal Processor (DSP), an Application Specific Integrated Circuit (ASIC), an off-the-shelf programmable gate array (FPGA) or other programmable logic device, discrete gate or transistor logic, discrete hardware components. The disclosed methods, steps, and logic blocks in the embodiments of the present application may be implemented or performed. A general purpose processor may be a microprocessor or the processor may be any conventional processor or the like, and may be of the X86 architecture or ARM architecture.

In general, the various example embodiments of the disclosure may be implemented in hardware or special purpose circuits, software, firmware, logic, or any combination thereof. Some aspects may be implemented in hardware, while other aspects may be implemented in firmware or software which may be executed by a controller, microprocessor or other computing device. While aspects of the embodiments of the present disclosure are illustrated or described as block diagrams, flow charts, or using some other pictorial representation, it is well understood that the blocks, apparatus, systems, techniques or methods described herein may be implemented in, as non-limiting examples, hardware, software, firmware, special purpose circuits or logic, general purpose hardware or controller or other computing devices, or some combination thereof.

For example, a method or apparatus according to embodiments of the present disclosure may also be implemented by means of the architecture of computing device 3000 shown in fig. 13. As shown in fig. 13, computing device 3000 may include a bus 3010, one or more CPUs 3020, a Read Only Memory (ROM) 3030, a Random Access Memory (RAM) 3040, a communication port 3050 connected to a network, an input/output component 3060, a hard disk 3070, and the like. A storage device in the computing device 3000, such as a ROM 3030 or hard disk 3070, may store various data or files for processing and/or communication use of the methods for page rendering provided by the present disclosure and program instructions executed by the CPU. The computing device 3000 may also include a user interface 3080. Of course, the architecture shown in FIG. 13 is merely exemplary, and one or more components of the computing device shown in FIG. 13 may be omitted as may be practical in implementing different devices.

According to yet another aspect of the present disclosure, a computer-readable storage medium is also provided. The computer storage medium has computer readable instructions stored thereon. When executed by a processor, the computer-readable instructions may perform a method for page rendering according to embodiments of the present disclosure described with reference to the above figures. The computer readable storage medium in embodiments of the present disclosure may be volatile memory or nonvolatile memory, or may include both volatile and nonvolatile memory. The non-volatile memory may be read-only memory (ROM), programmable read-only memory (PROM), erasable programmable read-only memory (EPROM), electrically erasable programmable read-only memory (EEPROM), or flash memory. Volatile memory can be Random Access Memory (RAM), which acts as external cache memory. By way of example, and not limitation, many forms of RAM are available, such as Static Random Access Memory (SRAM), dynamic Random Access Memory (DRAM), synchronous Dynamic Random Access Memory (SDRAM), double data rate synchronous dynamic random access memory (ddr SDRAM), enhanced Synchronous Dynamic Random Access Memory (ESDRAM), synchronous Link Dynamic Random Access Memory (SLDRAM), and direct memory bus random access memory (DR RAM). It should be noted that the memory of the methods described herein is intended to comprise, without being limited to, these and any other suitable types of memory. It should be noted that the memory of the methods described herein is intended to comprise, without being limited to, these and any other suitable types of memory.

Embodiments of the present disclosure also provide a computer program product or computer program comprising computer instructions stored in a computer readable storage medium. A processor of a computer device reads the computer instructions from a computer-readable storage medium, the processor executing the computer instructions, causing the computer device to perform a method for page rendering according to an embodiment of the present disclosure.

It is noted that the flowcharts and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present disclosure. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of code, which comprises at least one executable instruction for implementing the specified logical function(s). It should also be noted that, in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems which perform the specified functions or acts, or combinations of special purpose hardware and computer instructions.

The exemplary embodiments of the present disclosure described in detail above are illustrative only and are not limiting. Those skilled in the art will understand that various modifications and combinations of these embodiments or features thereof may be made without departing from the principles and spirit of the disclosure, and such modifications should fall within the scope of the disclosure.

Claims

1. A method for page rendering, wherein the page includes a plurality of modules, wherein each module includes one or more user interfaces, the method comprising:

Acquire a logic configuration of the page, the logic configuration including a logic configuration of each module in the plurality of modules, wherein the logic configuration of each module is generated together with the module and is used to describe an event in the module and a linkage between the module and other modules;

For each module in the plurality of modules, based on the logic configuration of the module, monitoring events associated with linkage in the module, and binding one or more events to one or more user interfaces of the module; and

For each module in the plurality of modules, one or more user interfaces of the module are rendered based on monitoring events associated with linkages in the module and the one or more events bound to the one or more user interfaces of the module.

2. The method of claim 1, further comprising:

Creating an event bus for the page, wherein the event bus is used to monitor the triggering of events in the page;

Wherein, monitoring the events associated with the linkage in the module based on the logic configuration of the module includes monitoring the triggering of the events associated with the linkage in the module by using the event bus.

3. The method of claim 2, wherein the monitoring of the triggering of events associated with the linkage in the modules using the event bus comprises:

In response to an event associated with the linkage in the module being triggered during execution of an action of the page, triggering the event associated with the linkage in the module in the event bus; and

In response to the event bus detecting the event associated with the linkage in the module being triggered in the event bus, an action corresponding to the linkage is executed.

4. The method of claim 3, wherein the event bus is used as a data storage repository for page rendering, for storing the state value of the user interface of the page;

The rendering of one or more user interfaces of the module based on monitoring events associated with the linkage in the module and the one or more events bound to the one or more user interfaces of the module includes:

In response to the event bus detecting a change in a state value occurring in the event bus by executing an action corresponding to the linkage, re-rendering a corresponding user interface of the module;

In response to one of the one or more events bound to one or more user interfaces of the module being triggered, executing an action corresponding to the event; and

In response to the event bus detecting a change in a state value in the event bus caused by executing an action corresponding to the event, the corresponding user interface of the module is re-rendered.

5. The method of claim 4, further comprising:

For each module in the plurality of modules, a sub-event bus is created for the module in the event bus, so as to separately store state values of one or more user interfaces of the module.

6. The method of claim 1, further comprising:

During the rendering of the page, for an action that has been loaded, when the action is initiated again, the loading result previously returned for the action is directly reused;

Perform concurrent loading for different actions; and

For the same action, if the loading of the action fails, reloading is performed with a limited number of loading times.

7. The method of claim 1, further comprising:

For the page, one or more actions in the page are preloaded, the one or more actions not previously loaded and potentially usable.

8. An execution engine, configured in a module for building a page, the module comprising one or more user interfaces, the execution engine being configured to:

Acquire a logic configuration of the module, wherein the logic configuration of the module is generated together with the module and is used to describe events in the module and linkages between the module and other modules;

Based on the logic configuration of the module, monitor events associated with the linkage in the module, and bind one or more events to one or more user interfaces of the module; and

Based on monitoring events associated with linkages in the module and the one or more events bound to the one or more user interfaces of the module, one or more user interfaces of the module are rendered.

9. A page construction method, comprising:

A page builder selects one or more modules from a module set generated by a module generator, each of the one or more modules being configured with the execution engine according to claim 8, and each of the one or more modules comprising a logic configuration and one or more user interfaces, wherein the logic configuration of each module is generated together with the module by the module generator and is used to describe events in the module and linkages between the module and other modules; and

The page builder builds the page based on the selected module or modules.

10. The method of claim 9, further comprising:

The module generator generates the module set for the module generator, each module in the module set includes the execution engine, a logic configuration, and one or more user interfaces; and

Each module in the module set is added as a selectable component to an editor of the page builder, the editor of the page builder comprising a plurality of selectable components for building a page, wherein each selectable component corresponds to a module in the module set.

11. The method of claim 10, wherein the selecting, by the page builder, one or more modules from the module set generated by the module generator comprises:

The page builder selects one or more selectable components from an editor of the page builder according to a predetermined task to build a page corresponding to the predetermined task.

12. The method of claim 11, wherein the page builder constructs the page based on the selected one or more modules, comprising:

The page builder arranges the selected one or more selectable components according to the predetermined task to construct the page.

13. A device for page rendering, the page comprising a plurality of modules, each of which comprises one or more user interfaces, the device comprising:

a configuration acquisition component configured to acquire a logic configuration of the page, wherein the logic configuration includes a logic configuration of each module in the plurality of modules, wherein the logic configuration of each module is generated together with the module and is used to describe an event in the module and a linkage between the module and other modules;

an association configuration component configured to monitor, for each module in the plurality of modules, events associated with linkage in the module based on the logic configuration of the module, and bind one or more events to one or more user interfaces of the module; and

The page rendering component is configured to render one or more user interfaces of each module in the multiple modules based on monitoring events associated with the linkage in the module and the one or more events bound to the one or more user interfaces of the module.

14. A device for page rendering, comprising:

one or more processors; and

One or more memories, wherein a computer executable program is stored, and when the computer executable program is executed by the processor, the method according to any one of claims 1 to 7 is performed.

15. A computer program product, stored on a computer-readable storage medium, and comprising computer instructions which, when executed by a processor, cause a computer device to perform the method of any one of claims 1 to 7.

16. A computer-readable storage medium having computer-executable instructions stored thereon, wherein the instructions are used to implement the method according to any one of claims 1 to 7 when executed by a processor.