Component custom configuration method and system based on low-code platform

Abstract

The application discloses a component self-defining configuration method and system based on a low-code platform, belongs to the technical field of low-code development, and comprises the following steps: a reusable dynamic structure unit library is constructed by decomposing component functions into atomized dynamic structure units and defining metadata and context contracts of the dynamic structure units, component functions are atomized and decomposed into template segments, logic controllers and metadata descriptors, standardized metadata and context contracts are defined, a reusable dynamic structure unit library with high cohesion and low coupling is constructed, and the reusable dynamic structure unit library supports function category tagging retrieval, a version control mechanism guarantees historical version backtracking and automatic upgrading, resources are packaged into standardized modules to simplify integration processes, and the application significantly reduces the cost of repeated development, thereby providing an efficient and extensible unit basis for dynamic configuration.

Description

TECHNICAL FIELD

[0001] The application belongs to the technical field of low-code development, and particularly relates to a component custom configuration method and system based on a low-code platform. BACKGROUND

[0002] With the wide application of low-code platforms, users have increasingly high requirements for the flexibility, reusability and environmental adaptability of components. The components in existing low-code platforms usually exist in an integral form, have high functional coupling degree, are difficult to split and combine as needed, have low reusability and high maintenance cost. In addition, component configuration is usually dependent on static rules, cannot be dynamically adjusted according to device types, network states, user behaviors and other contexts, and lacks real-time response capability. In terms of resource loading, there are problems such as redundant loading and missing security checks. In terms of interface updating, a full-rending mechanism is generally used, which has large performance overhead and poor user experience. At the same time, there is a lack of full-link recording and analysis mechanism for the configuration process, making it difficult to realize problem tracing and continuous optimization.

[0003] However, the component custom configuration of the existing low-code platform still has certain defects. The existing technology is difficult to be disassembled into independent units, lacks standardized metadata and context contract definition, resulting in low reusability of component library, chaotic version management, complex integration process, high repeated development cost, inability to support multi-scene dynamic configuration demand, low maintenance efficiency and poor expansibility. The strategy rules are statically preset, and the component adaptation or exception handling cannot be dynamically triggered according to the real-time environment. The execution accuracy is low and lacks effect recording mechanism, resulting in mismatch between component behavior and user intention or environmental change, inability to continuously optimize, dependence of the scheduling system on static configuration, inability to real-time analyze strategy rules and respond to multi-source signals, high signal processing delay and lack of priority sorting and dependency verification, resulting in inaccurate resource loading, slow response, unstable system performance in device switching or network fluctuation, low resource utilization and low running efficiency. Therefore, the component custom configuration method and system based on a low-code platform are proposed. SUMMARY

[0004] The application aims to provide a component custom configuration method and system based on a low-code platform to solve the problems in the background art.

[0005] To achieve the above-mentioned purpose, the application provides the following technical solution: a component custom configuration method based on a low-code platform, comprising the following steps:

[0006] S1. Constructing a reusable dynamic structure unit library by disassembling component functions into atomized dynamic structure units and defining metadata and context contracts of the dynamic structure units;

[0007] S2. Registering and configuring a multi-source listener of contexts, user intentions and real-time data streams based on the metadata contracts of the dynamic structure units.

[0008] S3. Define context-aware policy rules based on the signal targets covered by the listener;

[0009] S4. The component microkernel parses the policy rules at runtime and receives real-time signals from multiple source listeners to generate a context-aware dynamic structural unit scheduling plan.

[0010] S5. Based on the dynamic structural unit scheduling plan, dynamically load the required dynamic structural unit code from the central resource manager and instantiate it.

[0011] S6. Perform a difference comparison and stateless coordination update of the rendering tree between the newly instantiated dynamic structural unit set and the currently running dynamic structural unit set.

[0012] S7. By recording snapshots of the dynamic configuration process across the entire chain, it provides analytical basis for policy rule optimization and intelligent synchronization with the future environment.

[0013] Preferably, step S1, constructing a reusable dynamic structural unit library, includes: decomposing the functionality of the components into atomic-level, independent dynamic structural units according to the minimum functional independent operation standard;

[0014] Preferably, the dynamic structural unit includes: template fragment, logic controller, and metadata descriptor.

[0015] For each dynamic structural unit in the list of dynamic structural units formed after functional decomposition, create a standard metadata description file: basic attributes, behavioral attributes, style attributes, and dependencies.

[0016] Define runtime environment constraints for each dynamic structural unit: environment constraints and data flow contracts.

[0017] The dynamic structural units, metadata, and context contracts are centrally managed to form a reusable dynamic structural unit library.

[0018] Preferably, step S2, extracting metadata contracts from the dynamic structural unit library to determine the monitoring requirements, includes the following steps:

[0019] Environmental constraint analysis: Identify the environmental signals that need to be monitored based on the context contract of the dynamic structural unit;

[0020] Behavioral attribute extraction: parsing the event triggering rules and data binding rules of dynamic structural units;

[0021] Data stream binding analysis: Identify the real-time data stream signals that need to be monitored based on the data stream contract.

[0022] According to the context contract of the dynamic structure unit, register the listener to capture the device type, network state, user role environment signal.

[0023] Context listener registration: according to the context contract of the dynamic structure unit, register the listener to capture the device, network, user role and other environmental signals, trigger the adaptation logic of the dynamic structure unit, and bind the listener to the corresponding signal source through the context management interface provided by the platform.

[0024] User intent listener registration: according to the event trigger rule of the dynamic structure unit, register the listener to capture the user operation intent, trigger the interaction logic of the dynamic structure unit, and associate the user intent with the behavior attribute of the dynamic structure unit through the event bus.

[0025] Real-time data stream listener registration: according to the data stream contract of the dynamic structure unit, register the listener to listen to the data source update, drive the state refresh of the dynamic structure unit, and bind the listener to the data stream source through the data subscription interface.

[0026] Preferably, the S2, according to the context contract of the dynamic structure unit, configures the trigger condition of the listener and sets the execution order of the listener, associates the output signal of the listener with the dependency relationship of the dynamic structure unit;

[0027] According to the current state of the dynamic structure unit, dynamically adjust the enabled state of the listener, when multiple listeners compete for the same signal, decide the execution order according to the priority, and configure the error retry strategy and timeout fuse rule of the listener, and write it into the platform standard configuration format file.

[0028] Through the event bus of the platform, the signal distribution of the listener is uniformly managed, the independent listener resources are allocated to different dynamic structure units, and the performance monitoring probe is inserted at the key node of the listener.

[0029] Preferably, the S3, the context-aware policy rule definition step includes: analyzing the signal type captured from the registered context, user intent, real-time data stream listener, and identifying the dependency relationship between signals, and associating the signal with the metadata contract of the dynamic structure unit.

[0030] According to the analysis result, formulate the context-aware policy rule, including: formulating environmental adaptation rule, user intent response rule and data stream response rule three kinds of context-aware policy rules.

[0031] Directly associate the policy rule with the signal trigger condition of the listener, adjust the metadata contract of the dynamic structure unit according to the rule execution result, such as style attribute, dependency relationship, etc., and record the adjustment effect of the dynamic structure unit after rule execution.

[0032] Preferably, the S4, dynamic structure unit scheduling step includes: docking the policy rule and the registered listener with the signal receiving module of the microkernel, and synchronizing the currently running dynamic structure unit when the microkernel is initialized.

[0033] The microkernel subscribes to the signals of the listener through the event bus, classifies the signals by type and priority, and de-duplicates or merges the repeated or conflicting signals.

[0034] The real-time signals are matched with the trigger conditions of the policy rule, specific operation instructions of the dynamic structure unit are formulated according to the matching result, and the dependency relationship is verified; the instructions are scheduled according to the dependency relationship and priority order.

[0035] Preferably, the S5 identifies the dynamic structure unit specified in the scheduling plan, extracts the dependency of each dynamic structure unit according to the metadata contract, and verifies whether the version of the dynamic structure unit specified in the scheduling plan is consistent with the version in the current reusable dynamic structure unit library.

[0036] Preferably, according to the dynamic structure unit name and version number, the corresponding resource package is retrieved from the reusable dynamic structure unit library, the cached resources are preferentially used, if not hit, the remote warehouse is accessed, the high-priority unit is loaded into the memory in advance, and the waiting time during subsequent scheduling is reduced.

[0037] The dynamic structure unit code is injected into the runtime environment through the modular loading mechanism, and it is verified whether the loaded code conforms to the metadata contract to prevent version mismatch or structural error. The system scans whether there is a potential risk to ensure that it conforms to the platform security policy.

[0038] Preferably, the loaded code is instantiated into a runnable dynamic structure unit object, and the dependencies are injected, including: calling the constructor or factory method of the dynamic structure unit to generate an instance object, automatically injecting the dependencies according to the metadata contract, binding the instance with the current runtime context, synchronizing the state of the new instance to the microkernel and the listener, triggering the initialization hook of the dynamic structure unit, completing resource allocation and event binding, and if instantiation fails, triggering the rollback mechanism.

[0039] Preferably, the S6 determines the added, removed, and modified units by comparing the old and new sets through the unique identifier of the dynamic structure unit, checks the dependency relationship changes between the units in real time, verifies whether the new unit conforms to the current running environment constraints, avoids the misupdate of incompatible units, generates update instructions only for the difference part according to the difference comparison result, and sorts the update instructions according to the dependency relationship and user visibility.

[0040] By comparing the new and old rendering trees through the virtual DOM mechanism, multiple update instructions are combined into one transaction for execution, ensuring that the update process does not depend on the internal state of the current rendering tree, re-binding the updated dynamic structure unit with the runtime environment, and re-associating the event trigger of the dynamic structure unit with the listener.

[0041] Preferably, the S7 extracts dynamic configuration data from the runtime environment of S1-S6 in real time, generates snapshot data segments, stores snapshots according to key stages of the configuration process, stores snapshot data in a standardized format, assigns a unique identifier to each snapshot, and supports historical version comparison;

[0042] A visual report of the configuration process is generated through snapshot data to assist in optimization and problem troubleshooting, and the historical configuration state is traced back through snapshot data to reproduce and repair problems.

[0043] Preferably, the component custom configuration system based on the low-code platform comprises:

[0044] Dynamic structure unit library construction module: by decomposing component functions into atomic dynamic structure units and defining their metadata and context contracts, a reusable dynamic structure unit library is constructed;

[0045] Multi-source listener registration and configuration module: based on the metadata contract of the dynamic structure unit, the context, user intent, and real-time data stream multi-source listener are registered and configured;

[0046] Context-aware strategy rule definition module: according to the listening target of the multi-source listener, the context-aware strategy rule is defined;

[0047] Dynamic scheduling plan generation module: by parsing the strategy rule through the component microkernel runtime and receiving real-time signals from the multi-source listener, a context-aware dynamic structure unit scheduling plan is generated;

[0048] Dynamic structure unit loading and instantiation module: according to the dynamic structure unit scheduling plan, the central resource manager dynamically loads the required dynamic structure unit code from the reusable dynamic structure unit library and instantiates it;

[0049] Rendering tree stateless coordinated update module: the newly instantiated new dynamic structure unit set is compared with the currently running dynamic structure unit set, and the rendering tree is updated in a stateless and coordinated manner;

[0050] Full-link snapshot analysis module: records the dynamic configuration process snapshot of the full link.

[0051] Compared with the prior art, the present application has the following advantages:

[0052] 1、The application realizes high reuse, environment adaptation and dynamic scheduling of components through the construction of an atomic dynamic structure unit library, the registration of multi-source listeners and the definition of context-aware strategy rules; combined with microkernel runtime analysis, stateless coordination update and full-link snapshot recording, the system performance, security and maintainability are significantly improved, enabling efficient, intelligent and traceable full-process optimization of low-code platform component configuration, greatly reducing development costs and enhancing experience;

[0053] 2、The application constructs a reusable dynamic structure unit library with high cohesion and low coupling by atomizing component functions into template fragments, logic controllers and metadata descriptors, and defining standardized metadata and context contracts; this design supports functional category-based indexed retrieval, version control mechanisms ensure historical version backtracking and automatic upgrading, resource packaging as standardized modules simplifies the integration process, significantly reducing the cost of repeated development and providing an efficient and scalable unit foundation for dynamic configuration;

[0054] 3、The application dynamically defines three types of strategy rules: environment adaptation, user intent response and data flow response, and directly associates rules with listener signals and sets priorities; based on real-time environment, the application automatically triggers component adaptation or data exception handling to improve the accuracy of policy execution; rule execution effect records support continuous optimization to accurately match component behavior with user intent and environmental changes;

[0055] 4、The application generates a dynamic scheduling plan by real-time parsing of strategy rules and receiving listener signals; signals are classified and deduplicated by type and priority; scheduling instructions are sorted based on dependencies to achieve millisecond-level response, improve scheduling decision accuracy, and enable the system to quickly respond to changes in scenarios such as device switching and network fluctuations, ensuring the accuracy of component loading and updating and improving overall operational efficiency and resource utilization;

[0056] 5、The application compares new and old sets of dynamic structure units using unique identifiers, generates update instructions only for the differences, and combines the virtual DOM mechanism for batch merging and execution; stateless updates ensure independence from the internal state of the rendering tree, improving rendering performance and significantly improving interface smoothness; the differential rollback mechanism only restores the differences when an update fails, preserving other normal updates, reducing rendering latency, and significantly optimizing the interactive experience in performance-sensitive scenarios such as mobile devices, ensuring high availability and user experience consistency. BRIEF DESCRIPTION OF DRAWINGS

[0057] Figure 1 The running process of the component self-defined configuration method based on the low-code platform of the application Figure 1 ;

[0058] Figure 2 The running process of the component self-defined configuration method based on the low-code platform of the application Figure 2 ;

[0059] Figure 3 The running flow of the component custom configuration method based on the low-code platform of the application Figure 3 ;

[0060] Figure 4 The structural schematic diagram of the component custom configuration system based on the low-code platform of the application. DETAILED DESCRIPTION

[0061] The technical solutions in the embodiments of the application will be apparently and completely described below with reference to the drawings in the embodiments of the application. Obviously, the described embodiments are only part of the embodiments of the application, rather than all the embodiments of the application. Based on the embodiments in the application, all other embodiments obtained by a person of ordinary skill in the art without creative labor fall within the protection scope of the application.

[0062] EMBODIMENT

[0063] Please refer to Figures 1-4 The application provides a technical solution comprising the following steps:

[0064] S1, constructing a reusable dynamic structural unit library by decomposing a component function into atomized dynamic structural units and defining metadata and context contracts thereof;

[0065] S2, registering and configuring a context, user intention and real-time data stream multi-source listener based on metadata contracts of the dynamic structural units;

[0066] S3, defining context-aware policy rules according to signal targets covered by the listener;

[0067] S4, parsing policy rules by a component microkernel runtime and receiving real-time signals of the multi-source listener to generate a context-aware dynamic structural unit scheduling plan;

[0068] S5, dynamically loading required dynamic structural unit codes from a central resource manager and instantiating according to the dynamic structural unit scheduling plan;

[0069] S6, performing difference comparison and stateless coordination update of a rendering tree between a newly instantiated new dynamic structural unit set and a currently running dynamic structural unit set;

[0070] S7, providing analysis basis for policy rule optimization and intelligent synchronization of future environments by recording a full-link dynamic configuration process snapshot.

[0071] In this embodiment, the S1, the step of constructing the reusable dynamic structure unit library comprises: decomposing the functions of the components into atomic and independent dynamic structure units according to the minimum independent operation standard of functions;

[0072] Specifically, the dynamic structure unit comprises:

[0073] Template fragment: a piece of UI fragment, such as a Vue, React component, or HTML segment.

[0074] Logic controller: JavaScript code for processing template fragment business logic, data read-write, and life cycle.

[0075] Metadata descriptor: declares the ID, version, input / output data contract, configurable parameters, and dependency or mutual exclusion relationship with other dynamic structure units of the dynamic structure unit.

[0076] Specifically, a standard metadata description file is created for each dynamic structure unit in the list:

[0077] Basic attributes: define unique identifier, name, type, version number, and description;

[0078] Behavior attributes: describe event triggering rules and data binding rules. Event triggering rules: such as click, load;

[0079] Style attributes: define layout parameters and visual styles. Define layout parameters: such as position, size, etc. Visual styles: such as color, font, border, etc.

[0080] Dependency relationship: list of dependent other dynamic structure units and resources, such as API, database table;

[0081] Specifically, runtime environment constraints are defined for each dynamic structure unit:

[0082] Environment constraints: device type, network condition, and user role are specified. Device type: such as PC / mobile terminal, network condition: such as low-bandwidth strategy, user role: such as permission control;

[0083] Data flow contract: define input, output data type and data source binding rule.

[0084] Centralize management of dynamic structure units and metadata, context contract, and form reusable dynamic structure unit library:

[0085] Classification management: organize the unit library by function category, support tag-based retrieval: such as form class-input box; function category: such as UI component, data processing;

[0086] Version control: maintain historical version records for each dynamic structure unit, support version rollback and automatic upgrade;

[0087] Resource packaging: package unit code, metadata, dependent resources into standardized modules: such as NPM packages.

[0088] In this embodiment, S2 extracts metadata description files and context contracts from the dynamic structural unit library, determines the needs to be monitored, and the steps include:

[0089] Environmental constraint analysis: according to the context contract of the dynamic structural unit, such as device type, network condition, user role, identify the environmental signals to be monitored, such as screen resolution, bandwidth status;

[0090] Behavior attribute extraction: parse the event trigger rules and data binding rules of the dynamic structural unit, determine the user intent signals to be monitored, such as form submission, chart interaction.

[0091] Data flow binding analysis: according to the data flow contract, such as input / output data type, data source binding rule, identify the real-time data flow signals to be monitored, such as API response, database update.

[0092] According to the context contract of the dynamic structural unit, register the listener to capture the device type, network state, and user role environmental signals.

[0093] Context listener registration: according to the context contract of the dynamic structural unit, register the listener to capture the device, network, and user role environmental signals, trigger the adaptation logic of the dynamic structural unit, and bind the listener to the corresponding signal source through the context management interface provided by the platform, such as browser window size change event.

[0094] User intent listener registration: according to the event trigger rules of the dynamic structural unit, register the listener to capture the user operation intent, trigger the interaction logic of the dynamic structural unit, and bind the user intent to the behavior attribute of the dynamic structural unit through the event bus.

[0095] Real-time data flow listener registration: according to the data flow contract of the dynamic structural unit, register the listener to listen to the data source update, drive the state refresh of the dynamic structural unit, and bind the listener to the data flow source through the data subscription interface.

[0096] In this embodiment, S2 configures the trigger conditions of the listener according to the context contract of the dynamic structural unit, sets the execution order of the listener, and associates the output signal of the listener with the dependency relationship of the dynamic structural unit.

[0097] According to the current state of the dynamic structure unit, the enabled state of the listener is dynamically adjusted, when multiple listeners compete for the same signal, the execution order is determined according to the priority, and the error retry strategy and timeout fuse rule of the listener are configured and written into the platform standard configuration format file.

[0098] The signal distribution of the listener is uniformly managed through the event bus of the platform, independent listener resources are allocated for different dynamic structure units, and performance monitoring probes are inserted at key nodes of the listener, such as signal triggering and response execution.

[0099] In the embodiment, the S3, the context-aware policy rule definition step includes: capturing and analyzing signal types from registered contexts, user intentions, and real-time data stream listeners, and identifying the dependency relationship between signals, and associating the signals with the metadata contract of the dynamic structure unit.

[0100] Specifically, according to the analysis result, the context-aware policy rule is formulated, including:

[0101] Formulate environment adaptation rules: according to specific environmental conditions, such as low bandwidth, trigger the adaptation logic of the dynamic structure unit, and combine the context contract of the dynamic structure unit to limit its behavior in specific environments;

[0102] Formulate user intention response rules: trigger the behavior logic of the dynamic structure unit according to the user operation intention, such as automatic verification and data filtering;

[0103] Formulate data flow response rules: when the data source is updated, drive the state refresh of the dynamic structure unit, and when the data flow is abnormal, such as API timeout, trigger the standby logic, such as error prompt or fallback logic.

[0104] Specifically, different categories of rules are assigned priorities, when multiple rules are triggered at the same time, the execution order is determined through the dependency relationship, and for mutually exclusive rules, condition judgment or fallback strategy is adopted.

[0105] The signal triggering conditions of the policy rules and the listener are directly associated, the metadata contract of the dynamic structure unit is adjusted according to the rule execution result, and the adjustment effect of the dynamic structure unit is recorded after the rule execution.

[0106] In the embodiment, the S4, the dynamic structure unit scheduling plan step includes: interfacing the policy rules and the registered listener with the signal receiving module of the microkernel, and synchronizing the currently running dynamic structure unit when the microkernel is initialized.

[0107] The microkernel subscribes to the signals of the listener through the event bus, classifies the signals according to type and priority, and removes or merges repeated or conflicting signals.

[0108] The real-time signal is matched with the triggering condition of the strategy rule, specific operation instructions of the dynamic structure unit are formulated according to the matching result, and the dependency relationship is verified; the instructions are dispatched according to the dependency relationship and priority order.

[0109] In this embodiment, the S5 identifies the dynamic structure unit specified in the scheduling plan, extracts the dependency of each dynamic structure unit according to the metadata contract, and verifies whether the version of the dynamic structure unit specified in the scheduling plan is consistent with the version in the current reusable dynamic structure unit library.

[0110] Specifically, according to the dynamic structure unit name and version number, the corresponding resource package is retrieved from the reusable dynamic structure unit library, the cached resources are preferentially used, if not hit, the remote warehouse is accessed, and the high-priority unit (such as frequently used basic components) is loaded into the memory in advance to reduce the waiting time during subsequent scheduling.

[0111] It should be understood that the dynamic structure unit code is injected into the runtime environment through the modular loading mechanism, and whether the loaded code meets the metadata contract, such as interface field and dependency relationship, is verified to prevent version mismatch or structural error. The system scans whether there is a potential risk in the code, such as malicious scripts or unauthorized API calls, to ensure compliance with the platform security policy.

[0112] Specifically, the loaded code is instantiated into a runnable dynamic structure unit object, and the dependencies are injected, including: calling the constructor or factory method of the dynamic structure unit to generate an instance object, automatically injecting the dependencies according to the metadata contract, binding the instance with the current runtime context, synchronizing the state of the new instance to the microkernel and the listener, triggering the initialization hook of the dynamic structure unit, completing resource allocation and event binding, and if instantiation fails, such as missing dependencies or code errors, triggering the rollback mechanism to unload the loaded unit code and restore to the running state before loading.

[0113] In this embodiment, the S6 determines the added, removed, and modified units by comparing the old and new sets through the unique identifier of the dynamic structure unit, checks the change of the dependency relationship between the units in real time, verifies whether the new unit meets the constraints of the current running environment, avoids incompatible units from being mistakenly updated, generates update instructions only for the difference part according to the difference comparison result, and sorts the update instructions according to the dependency relationship (preferentially loading the dependent units) and user visibility (preferentially updating the units in the current visible area).

[0114] Specifically, the new and old rendering trees are compared through the virtual DOM mechanism, multiple update instructions are combined into one transaction for execution, the update process is ensured to be independent of the internal state of the current rendering tree, the updated dynamic structure unit is re-bound with the runtime environment, and the event trigger of the dynamic structure unit is re-associated with the listener.

[0115] If the update fails, only the differences will be rolled back, while other normal updates will be retained; the reason for the update failure will be recorded in the log system.

[0116] In this embodiment, step S7 extracts dynamic configuration data in real time from the runtime environment of S1-S6, generates snapshot data fragments, and stores snapshots in segments according to the key stages of the configuration process, such as scheduling plan generation, unit loading, and rendering update. The snapshot data is stored in a standardized format, and a unique identifier is assigned to each snapshot to support historical version comparison.

[0117] By generating visual reports of the configuration process using snapshot data, optimization and troubleshooting can be aided. Snapshot data can also be used to trace back historical configuration states, enabling problem reproduction and repair verification.

[0118] In this embodiment, the component customization configuration system based on the low-code platform includes:

[0119] Dynamic Structural Unit Library Building Module: This module builds a reusable dynamic structural unit library by deconstructing component functionality into atomic dynamic structural units and defining their metadata and context contracts.

[0120] Multi-source listener registration and configuration module: Based on the metadata contract of dynamic structural units, it performs registration and configuration of multi-source listeners for context, user intent and real-time data stream.

[0121] Context-aware policy rule definition module: Defines context-aware policy rules based on the listening targets of multi-source listeners.

[0122] Dynamic scheduling plan generation module: It parses policy rules through the component microkernel runtime and receives real-time signals from multiple source listeners to generate a context-aware dynamic structural unit scheduling plan.

[0123] Dynamic structural unit loading and instantiation module: According to the dynamic structural unit scheduling plan, the central resource manager dynamically loads the required dynamic structural unit code from the reusable dynamic structural unit library and instantiates it.

[0124] The render tree stateless coordination update module compares the differences between the newly instantiated set of dynamic structural units and the currently running set of dynamic structural units, and performs stateless coordination updates to the render tree.

[0125] End-to-end snapshot analysis module: records snapshots of the dynamic configuration process across the entire link.

[0126] Working principle: By decomposing component functions into atomic dynamic structural units, each unit contains template fragments, logic controllers, and metadata descriptors, forming independent modules with high cohesion and low coupling; by defining standardized metadata models and context contracts, the describability and manageability of the units are achieved.

[0127] Based on the defined metadata contract, the system extracts the runtime environment requirements of each dynamic structural unit and registers corresponding multi-source listeners. By analyzing environmental constraints, behavioral attributes, and data flow contracts, the system identifies the device status, user operations, and data update signals that need to be monitored, and registers context, user intent, and real-time data flow listeners respectively. These listeners are bound to specific signal sources through platform interfaces and configured with trigger conditions, execution priorities, and exception handling strategies. Signal distribution is uniformly managed through an event bus. Real-time signals captured by the registered listeners are combined with the metadata contracts of the dynamic structural units to define context-aware policy rules. The system parses signal types and their... Dependencies are defined, and three categories of rules are established: environment adaptation, user intent response, and data flow response. Priorities and conflict resolution mechanisms are set. Policy rules are directly associated with listener signals and are automatically triggered when specific conditions are met, driving the behavior adjustment of dynamic structural units. The execution effect of rules is recorded. Policy rules and registered listeners are integrated through a component microkernel to achieve runtime dynamic scheduling. During microkernel initialization, the current component state is loaded, and real-time signals from multiple source listeners are received through the event bus. After the signals are classified, deduplicated, and prioritized, they are matched with policy rules to generate specific scheduling instructions. The instructions are sorted according to dependencies and priorities to form a scheduling plan.

[0128] According to the generated scheduling plan, the central resource manager loads the required dynamic structural units from the reusable dynamic structural unit library on demand; first, it verifies the unit version and dependencies, prioritizing the use of local cached resources, and obtaining them from remote repositories when necessary; after the loaded code undergoes integrity verification and security scanning, it is injected into the runtime environment through a modularization mechanism; subsequently, the system calls the constructor to instantiate the unit, automatically injecting dependencies and binding the runtime context; the state of the new instance is synchronized to the microkernel and listeners, completing initialization; the instantiated set of new dynamic structural units is compared with the currently running set of units to identify newly added, deleted, and modified units; based on the comparison results, minimal update instructions are generated and sorted by dependency and priority; through Mechanisms such as the virtual DOM enable the system to perform batch update operations without relying on the current rendering state, ensuring efficient and consistent interface refresh. After the update, the unit is rebound to the runtime environment, and the event listener is synchronized. If the update fails, the system only rolls back the differences, ensuring overall stability. During the entire S1-S6 process, key data at each stage is collected in real time to generate a full-link snapshot of the dynamic configuration process. The snapshot is stored in segments according to the scheduling plan, unit loading, rendering update, etc., using a standardized format and assigned a unique identifier, supporting version comparison. Through visual analysis, the configuration process can be tracked, performance bottlenecks can be identified, and problem scenarios can be reproduced. The snapshot data is also used for strategy optimization and fault repair verification, forming a closed-loop feedback.

[0129] While embodiments of the application have been shown and described, it is to be understood that the application is not limited to the details of the embodiments described, since various modifications can be made by those skilled in the art, without departing from the spirit and scope of the application, which are defined by the appended claims and their equivalents.

[0130] The above description of the application and its embodiments is not restrictive, and the embodiments shown in the drawings are only one of the embodiments of the application, and the actual structure is not limited thereto. In general, if a person skilled in the art is inspired by it, without departing from the purpose of the application, without creative design, similar structure and embodiments of the technical solution should belong to the protection scope of the application.

Claims

1. A method for component customization configuration based on a low-code platform, characterized in that, The method comprises the following steps: S1, constructing a reusable dynamic structural unit library by decomposing component functions into atomized dynamic structural units and defining their metadata contracts and context contracts; S2, registering and configuring context, user intent, and real-time data stream multi-source listeners based on the metadata contracts of the dynamic structural units; S3, defining context-aware policy rules according to the listening targets of the multi-source listeners; S4, parsing the policy rules by the component microkernel runtime and receiving real-time signals from the multi-source listeners to generate a context-aware dynamic structural unit scheduling plan; S5, dynamically loading the required dynamic structural unit code from the reusable dynamic structural unit library and instantiating it according to the dynamic structural unit scheduling plan; S6, comparing the newly instantiated dynamic structural unit set with the currently running dynamic structural unit set and performing stateless coordination updates on the rendering tree; S7, recording snapshots of the dynamic configuration process of the entire link; The S3 comprises: capturing signal types from the registered context, user intent, and real-time data stream listeners, analyzing the dependencies between the signals, and associating the signals with the metadata contracts of the dynamic structural units; According to the analysis results, context-aware policy rules are formulated, including environment adaptation rules, user intent response rules, and data stream response rules; The policy rules are directly associated with the signal trigger conditions of the listeners, and the metadata contracts of the dynamic structural units are adjusted according to the rule execution results, and the adjustment effects of the dynamic structural units are recorded after the rule execution.

2. The method of claim 1, wherein: The S1 comprises: decomposing the functions of the components into atomic, independent dynamic structural units according to the minimum independent running standard, and the dynamic structural units include template fragments, logic controllers, and metadata descriptors; A standard metadata description file is created for each dynamic structural unit in the dynamic structural unit list formed after function decomposition: basic attributes, behavior attributes, style attributes, and dependency relationships; Runtime environment constraints are defined for each dynamic structural unit: environment constraints and data flow contracts; The dynamic structural units and metadata, context contracts are centrally managed to form a reusable dynamic structural unit library.

3. The method of claim 1, wherein: The S2 comprises: extracting metadata description files and context contracts from the dynamic structural unit library, determining the listening requirements, and the steps include: Environment constraint analysis: identifying the environment signals to be listened to according to the context contracts of the dynamic structural units; Behavior attribute extraction: parsing the event trigger rules and data binding rules of the dynamic structural units; Data flow binding analysis: identifying real-time data stream signals to be listened to according to the data flow contracts; According to the context contracts of the dynamic structural units, register listeners to capture device types, network states, and user role environment signals; Context listener registration: according to the context contract of the dynamic structure unit, register the listener to capture the device, network, user role environment signal, trigger the adaptation logic of the dynamic structure unit, bind the listener to the corresponding signal source through the context management interface provided by the platform; User intent listener registration: according to the event trigger rule of the dynamic structure unit, register the listener to capture the user operation intent, trigger the interaction logic of the dynamic structure unit, and associate the user intent with the behavior attribute of the dynamic structure unit through the event bus; Real-time data stream listener registration: according to the data stream contract of the dynamic structure unit, register the listener to listen to the data source update, and bind the listener to the data stream source through the data subscription interface.

4. The method of claim 3, wherein: S2, according to the context contract of the dynamic structure unit, configure the trigger condition of the listener, set the execution order of the listener, and associate the output signal of the listener with the dependency relationship of the dynamic structure unit; According to the current state of the dynamic structure unit, dynamically adjust the enabled state of the listener, when multiple listeners compete for the same signal, decide the execution order according to the priority, and configure the error retry strategy and timeout fuse rule of the listener; Through the event bus of the platform, the signal distribution of the listener is uniformly managed, independent listener resources are allocated for different dynamic structure units, and performance monitoring probes are inserted at key nodes of the listener.

5. The method of claim 1, wherein: S4, the dynamic structure unit scheduling plan step includes: connecting the policy rule and the registered listener with the signal receiving module of the microkernel, and synchronizing the currently running dynamic structure unit when the microkernel is initialized; Match the real-time signal with the trigger condition of the policy rule, formulate the specific operation instruction of the dynamic structure unit according to the matching result, and schedule the instruction according to the dependency relationship and priority order.

6. The method of claim 1, wherein: S5, identify the dynamic structure unit specified in the scheduling plan, extract the dependency of each dynamic structure unit according to the metadata contract and verify the availability, retrieve the corresponding resource package from the reusable dynamic structure unit library according to the dynamic structure unit name and version number, preferentially use the cached resources, and if not hit, get from the remote warehouse; Through the modular loading mechanism, the dynamic structure unit code is injected into the runtime environment, the loaded code is instantiated as a runnable dynamic structure unit object, and the dependency is injected, including: calling the constructor method of the dynamic structure unit, generating an instance object, automatically injecting the dependency according to the metadata contract, binding the instance with the current runtime context, synchronizing the state of the new instance to the microkernel and the listener, triggering the initialization hook of the dynamic structure unit, completing resource allocation and event binding, and if instantiation fails, triggering the rollback mechanism.

7. The method of claim 1, wherein: S6, compare the new and old sets through the unique identifier of the dynamic structure unit, determine the added, removed and modified units, generate update instructions only for the difference part according to the difference comparison result, and sort the update instructions according to the dependency relationship and user visibility; By comparing the new and old rendering trees through the virtual DOM mechanism, multiple update instructions are combined into one transaction execution, ensuring that the update process does not depend on the internal state of the current rendering tree, and re-binding the updated dynamic structure unit with the runtime environment, and re-associating the event trigger of the dynamic structure unit with the listener.

8. The method of claim 1, wherein: S7, real-time extraction of dynamic configuration data from the runtime environment of S1-S6, generation of snapshot data segments, storage of snapshots by key stages of the configuration process, storage of snapshot data in a standardized format, allocation of a unique identifier to each snapshot, generation of a visual report of the configuration process from snapshot data, assistance in optimization and problem troubleshooting, and backtracking of historical configuration states from snapshot data for problem reproduction and repair verification.

9. A component customization configuration system based on a low-code platform, which is implemented based on the method of claim 1, comprising: a dynamic structure unit library construction module: reusable dynamic structure unit libraries are constructed by decomposing component functions into atomic dynamic structure units and defining their metadata and context contracts; a multi-source listener registration configuration module: based on the metadata contract of dynamic structure units, register and configure context, user intent, and real-time data stream multi-source listeners; a context-aware strategy rule definition module: according to the listening targets of multi-source listeners, define context-aware strategy rules; a dynamic scheduling plan generation module: parse strategy rules through component microkernel runtime and receive real-time signals from multi-source listeners to generate context-aware dynamic structure unit scheduling plans; a dynamic structure unit loading and instantiation module: according to the dynamic structure unit scheduling plan, the central resource manager dynamically loads the required dynamic structure unit code from the reusable dynamic structure unit library and instantiates it; a stateless coordinated update module for rendering trees: difference comparison and stateless coordinated update of the rendering tree are performed between the newly instantiated new dynamic structure unit set and the currently running dynamic structure unit set; a full-link snapshot analysis module: records the dynamic configuration process snapshot of the full link.

Images