A method and system for dynamic binding and parsing of multi-source heterogeneous data in a low-code platform

Abstract

The application belongs to the technical field of computer software, and discloses a dynamic binding and analysis method and system for multi-source heterogeneous data in a low-code platform, which comprises the following steps: using a recursive path serialization algorithm, a lexical rule is disassembled into an ordered attribute access sequence, and a business field identifier is extracted based on the ordered attribute access sequence to output a listening queue with a dependency relationship; the listening queue is used as a driving basis to perform multi-dimensional layered retrieval and data aggregation operation, and an evaluation strategy is selected according to the execution result and the complexity of the reference mode, and a memory isolation cloning result is output to complete data binding and analysis processing. The application constructs a self-describing protocol with conflict avoidance capability to solve the problem that static JSON configuration cannot directly express dynamic logic in a low-code environment, and can statically extract field-level fine-grained dependencies and establish accurate responsive listening.

Description

Technical Field

[0001] This invention relates to the field of computer software technology, and in particular to a method and system for dynamic binding and parsing of multi-source heterogeneous data in a low-code platform. Background Technology

[0002] With the rise of low-code development platforms, front-end UI structures and business logic are usually serialized into static JSONSchema (configuration schema objects). Under this architecture, since the JSON format only supports static types (such as strings, numbers, and booleans), it cannot directly contain dynamic variable references or complex runtime logic, resulting in a natural gap between static configuration protocols and dynamic runtime states.

[0003] Currently, implementing dynamic data binding in low-code scenarios faces the following core challenges: (1) Static string addressing problem: In JSON string values, there is a lack of a standardized, non-intrusive syntax to reference heterogeneous data across namespaces (such as local state, global context, environment parameters), which forces developers to write a lot of glue code to manually synchronize data.

[0004] (2) Risk of coupling between configuration and logic: Some existing solutions attempt to embed JavaScript script fragments directly in JSON, but this not only greatly increases the difficulty of maintaining the configuration, but also introduces serious security risks of cross-site scripting (XSS) attacks caused by JavaScript execution script function "eval()".

[0005] (3) Lack of responsive granularity: Traditional string replacement engines often lack fine-grained dependency tracking. Minor changes to local fields in the configuration string often trigger a full component re-rendering, resulting in significant performance loss when dealing with large-scale form scenarios.

[0006] (4) Data type degradation and pollution: Simple string replacement will force all reference results to be converted to text, resulting in the loss of the original object or array characteristics. At the same time, the sharing of reference data by multiple components can easily lead to the global state source being accidentally tampered with.

[0007] Therefore, how to provide a method and system for dynamic binding and parsing of multi-source heterogeneous data in a low-code platform is an urgent problem to be solved. Summary of the Invention

[0008] This invention provides a method and system for dynamic binding and parsing of multi-source heterogeneous data in a low-code platform, in order to solve the problems mentioned above in the prior art.

[0009] According to a first aspect of the present invention, a method for dynamic binding and parsing of multi-source heterogeneous data in a low-code platform is provided.

[0010] In one embodiment, the method for dynamic binding and parsing of multi-source heterogeneous data in the low-code platform includes: Using a recursive path serialization algorithm, lexical rules are decomposed into ordered attribute access sequences, and business field identifiers are extracted based on the ordered attribute access sequences to output a listening queue with dependencies. The listening queue is used as the driving force to perform multi-dimensional hierarchical retrieval and data aggregation operations. The evaluation strategy is selected based on the complexity of the execution results and the reference pattern, and the memory-isolated clone results are output to complete the data binding parsing process.

[0011] In one embodiment, a recursive path serialization algorithm is used to decompose lexical rules into ordered attribute access sequences, and business field identifiers are extracted based on the ordered attribute access sequences to output a listening queue with dependencies, including: Capture dynamic reference candidates, and use a preset conflict avoidance protocol to determine the activation status of the reference candidates. Based on the activation status, split the reference candidates to obtain an ordered property access sequence. Field identifiers are extracted based on ordered attribute access sequences, and differential dependency registration and global state-oriented update processing are performed on the field identifiers. Based on the processing results, a listening queue with dependencies is output.

[0012] In one embodiment, dynamic reference candidates are captured, and a preset conflict avoidance protocol is used in conjunction with the determination of the activation state of the reference candidates. Based on the activation state, the reference candidates are split to obtain an ordered attribute access sequence including: Based on the test static configuration environment, capture all dynamic reference candidates from static text and backtrack to scan the escape status bit of the predecessor offset corresponding to each reference candidate; The escape sequencer of the reference candidate is determined based on the escape status bit, and the status of the reference candidate is determined by combining it with the preset conflict avoidance protocol. If the escape sequence of the candidate is active, a parsing suppression signal is sent to the parser, and escape sequence stripping is performed. The literal is output based on the stripping result, and the binding and parsing process ends. If the escape sequence of a reference candidate is not active, the reference candidate is determined to be active, and the path resolution logic is activated to apply string splitting and generate an ordered property access sequence.

[0013] In one embodiment, field identifiers are extracted based on ordered attribute access sequences, and differential dependency registration and global state-oriented update processing are performed on the field identifiers. The output of the listening queues with dependencies, based on the processing results, includes: The prefix marker of the ordered attribute access sequence is obtained by calling the preset prefix mask stripping technique, and after stripping the prefix marker, the business field identifier pointing to the business state machine is extracted. Classify and determine the data source type of the dependent fields corresponding to the business field identifiers to complete the automatic identification of dynamic and static dependencies; Based on the results of dynamic and static dependency identification, perform differentiated dependency registration and global state-oriented update processing, and output a listening queue with dependency relationships.

[0014] In one embodiment, classifying and determining the data source type of the dependent fields corresponding to the business field identifier to achieve automatic identification of dynamic and static dependencies includes: If the prefix of the business field identifier corresponds to the application-level environment context, then the dependent field of the business field identifier is determined to be a static constant dependency. The data value of the static constant dependency remains stable throughout the component's lifecycle and will not trigger real-time response changes. If the prefix of the business field identifier corresponds to the global business state container, then the dependent field of the business field identifier is determined to be a dynamic business dependency. The data value of the dynamic business dependency changes with business operations, and the associated component needs to be updated. If the business field identifier does not contain a prefix marker, then the dependent field of the business field identifier is determined to be a component local state dependency. Local state dependencies are updated by the component's own local state management mechanism and do not need to be registered with the global state manager.

[0015] In one embodiment, differential dependency registration and global state-oriented update processing are performed based on the dynamic and static dependency identification results, and the output listening queue with dependency relationships includes: Dependency fields that are static constant dependencies are removed and not registered. Meanwhile, dependency fields that are determined to be local state dependencies of the component are handled by the component's internal management mechanism and are not registered to the observer set of the global state manager. The dependency fields identified as dynamic business dependencies are registered in the observer set of the global business state container, establishing a mapping relationship between the core business field paths and the corresponding observers; Based on the differential dependency registration results, determine the changed dependency fields, calculate the hash value of the business field path of the corresponding dependency relationship, and use the hash value to find the observer set corresponding to the dependency field in the mapping relationship of the global business state container. By waking up the observer collection, the associated components that have dependencies on the dependent fields are driven to obtain the listening queue used to execute the rendering calculation process.

[0016] In one embodiment, the listening queue is used as the driving force to perform multi-dimensional hierarchical retrieval and data aggregation operations. An evaluation strategy is selected based on the execution results and the complexity of the reference pattern, and a memory-isolated clone result is output to complete the data binding parsing process, including: Based on the real-time runtime environment, a differentiated scheduling strategy is matched; when the real-time runtime environment is a visual design environment, it is represented as a non-executing state, and the listening queue needs to be directly passed through without performing real-time evaluation operations; when the real-time runtime environment is a production runtime environment, it is represented as an executing state, and the parsing instruction needs to be activated to enter the real-time evaluation link. When entering the real-time evaluation link, the ordered attribute access sequence is used as the address navigation. The attribute path recursive addressing is performed in the heterogeneous namespace, and the defense verification operation is implemented in the addressing to obtain the data value of the ordered attribute access sequence. Based on the complexity of the data values ​​and reference patterns of the ordered access sequence, an evaluation strategy is selected and executed to perform serialization-based deep cloning processing, thus completing the data binding parsing operation.

[0017] In one embodiment, the heterogeneous namespace consists of a global business state container and a routing parameter pool; The routing parameter pool includes memory routes, context routes, route parameter routes, and identity routes.

[0018] In one embodiment, memory routing is used to identify the formData prefix in the ordered attribute access sequence, locate the global business state container, and read the corresponding data values ​​level by level according to the field hierarchy order of the ordered attribute access sequence records; Context routing is used to identify the context prefix in an ordered property access sequence, locate the application-level environment context, and read the corresponding data values ​​level by level according to the field hierarchy order of the records in the ordered property access sequence; The routing parameter routing is used to identify the params prefix in the ordered attribute access sequence, locate the environment routing parameter pool, and read the corresponding data values ​​level by level according to the field hierarchy recorded in the ordered attribute access sequence; Identity routing is used to identify the auth prefix in an ordered sequence of attribute accesses, redirect to the identity authentication and authorization data source, and extract the current user's access token and related identity information.

[0019] In one embodiment, an evaluation strategy is selected based on the complexity of the data values ​​and reference patterns of the ordered attribute access sequence, and the evaluation strategy is executed to perform serialization-based deep cloning processing to complete the data binding parsing operation, including: When the reference to be parsed is a composite pattern string of multiple variable references, the data values ​​of the ordered attribute access sequence are converted into string patterns in turn, and then concatenated according to the original pattern string format, and the string output result is output. When the reference to be resolved is a single variable reference, it is determined to be in type-preserving mode. The data values ​​of the ordered property access sequence are generated according to the serialization to deserialization process to generate a mirror copy that is physically isolated from the original object. The mirror copy is then returned to the rendering layer as the deep clone output to complete the data binding and parsing operation.

[0020] According to a second aspect of the present invention, a dynamic binding and parsing system for multi-source heterogeneous data in a low-code platform is provided.

[0021] In one embodiment, the dynamic binding and parsing system for multi-source heterogeneous data in the low-code platform includes: The relational queue output unit is used to decompose lexical rules into ordered attribute access sequences using a recursive path serialization algorithm, and extract business field identifiers based on the ordered attribute access sequences to output a listening queue with dependencies. The binding parsing processing unit is used to perform multi-dimensional hierarchical retrieval and data aggregation operations based on the listening queue, and selects the evaluation strategy according to the complexity of the execution result and the reference pattern, and outputs the memory-isolated clone result to complete the data binding parsing processing.

[0022] In one embodiment, the relation queue output unit includes: The access sequence output module is used to capture dynamic reference candidates and, by combining a preset conflict avoidance protocol with the determination of the activation status of the reference candidates, splits the reference candidates based on the activation status to obtain an ordered attribute access sequence. The listening queue output module is used to extract field identifiers based on ordered attribute access sequences, perform differentiated dependency registration and global state-oriented update processing on the field identifiers, and output the listening queue with dependencies based on the processing results.

[0023] In one embodiment, the access sequence output module, when capturing dynamic reference candidates and using a preset conflict avoidance protocol combined with determining the activation state of the reference candidates, splits the reference candidates based on the activation state to obtain an ordered attribute access sequence, includes: Based on the test static configuration environment, capture all dynamic reference candidates from static text and backtrack to scan the escape status bit of the predecessor offset corresponding to each reference candidate; The escape sequencer of the reference candidate is determined based on the escape status bit, and the status of the reference candidate is determined by combining it with the preset conflict avoidance protocol. If the escape sequence of the candidate is active, a parsing suppression signal is sent to the parser, and escape sequence stripping is performed. The literal is output based on the stripping result, and the binding and parsing process ends. If the escape sequence of a reference candidate is not active, the reference candidate is determined to be active, and the path resolution logic is activated to apply string splitting and generate an ordered property access sequence.

[0024] According to a third aspect of the present invention, a computer device is provided.

[0025] In some embodiments, the computer device includes a memory and a processor, the memory storing a computer program, and the processor executing the computer program to implement the steps of the method described above.

[0026] According to a fourth aspect of the present invention, a computer-readable storage medium is provided.

[0027] In one embodiment, a computer program is stored on the computer-readable storage medium, which, when executed by a processor, implements the steps of the above method.

[0028] The technical solutions provided by the embodiments of the present invention may include the following beneficial effects: 1. This invention addresses the problem that static JSON configuration in low-code environments cannot directly express dynamic logic. It constructs a self-describing protocol with conflict avoidance capabilities, enabling static extraction of fine-grained field-level dependencies and the establishment of precise reactive listeners. Simultaneously, the parsing engine utilizes layered routing and non-executable attribute path recursive addressing algorithms to achieve unified aggregation of heterogeneous data across namespaces while ensuring execution safety. Combined with a type-aware deep cloning protection mechanism, it effectively solves the problems of type loss and state pollution while achieving high-performance response, realizing a closed-loop end-to-end system from static configuration awareness to dynamic response-driven operation.

[0029] 2. This invention constructs a self-describing protocol in a static string and combines it with static analysis and non-executable addressing techniques to achieve a closed-loop end-to-end from static JSON configuration to dynamic responsive rendering, solving the performance and type loss problems without introducing script execution risks.

[0030] 3. By bridging the gap in static configuration, this invention successfully achieves high-performance referencing of heterogeneous data across namespaces in a static JSON environment where scripts cannot be executed. Through precise field-level registration, the computational cost of re-parsing is significantly reduced compared to a full refresh solution. At the same time, the combination of post-state verification and non-executable addressing ensures parsing security in complex network environments and prevents injection attacks. Combined with a memory isolation cloning mechanism, it ensures the integrity of complex data structures and the immutability of the global state source.

[0031] It should be understood that the above general description and the following detailed description are exemplary and explanatory only, and are not intended to limit the invention. Attached Figure Description

[0032] The accompanying drawings, which are incorporated in and form part of this specification, illustrate embodiments consistent with the invention and, together with the description, serve to explain the principles of the invention.

[0033] Figure 1 This is a flowchart illustrating a method for dynamic binding and parsing of multi-source heterogeneous data in a low-code platform according to an exemplary embodiment; Figure 2 This is a schematic diagram of a dynamic binding and parsing system for multi-source heterogeneous data in a low-code platform, according to an exemplary embodiment. Figure 3 This is a schematic diagram of the structure of a computer device according to an exemplary embodiment. Detailed Implementation

[0034] The following description and accompanying drawings fully illustrate specific embodiments described herein to enable those skilled in the art to practice them. Some portions and features of certain embodiments may be included in or replace portions and features of other embodiments. The scope of the embodiments herein includes the entire scope of the claims and all available equivalents thereof. The various embodiments described herein are presented in a progressive manner, with each embodiment focusing on its differences from other embodiments; similar or identical parts between embodiments can be referred to interchangeably.

[0035] The modules in the apparatus or system of this application can be implemented entirely or partially through software, hardware, or a combination thereof. These modules can be embedded in or independent of the processor in a computer device in hardware form, or stored in the memory of a computer device in software form, so that the processor can call and execute the operations corresponding to each module.

[0036] Where there is no conflict, the embodiments and features in the embodiments of the present invention can be combined with each other.

[0037] Figure 1 An embodiment of the dynamic binding and parsing method for multi-source heterogeneous data in a low-code platform according to the present invention is shown.

[0038] In this optional embodiment, the method for dynamic binding and parsing of multi-source heterogeneous data in the low-code platform includes: Step S101: Using a recursive path serialization algorithm, the lexical rules are decomposed into ordered attribute access sequences, and business field identifiers are extracted based on the ordered attribute access sequences to output the listening queues with dependencies. Step S102: Use the listening queue as the driving basis to perform multi-dimensional hierarchical retrieval and data aggregation operations, and select the evaluation strategy according to the complexity of the execution result and the reference pattern, and output the memory-isolated clone result to complete the data binding parsing process.

[0039] Specifically, its implementation process includes the following five core processes: (1) Construct a self-describing data reference protocol: Define lexical rules for the JSON static configuration environment that include a preset start identifier, apply a recursive path serialization algorithm to decompose it into an ordered attribute access sequence, and execute conflict avoidance logic based on post-state verification. (2) Perform field-level reactive dependency registration: Static scan the ordered attribute access sequence to extract the core business field identifier, use dynamic and static color filtering logic to filter non-reactive paths, and then use the observer mechanism to register the live dependency path to the precise listening queue of the state manager. (3) Implement environment-aware logical routing: obtain the runtime environment identifier and distribute the parsing logic between the visual design environment and the production runtime environment; (4) Implement multidimensional data security retrieval: Use the ordered attribute access sequence as address navigation, perform non-executable attribute path recursive addressing in the heterogeneous namespace containing the global business state container, identity authentication context and routing parameter pool, and perform existence defense verification in the addressing to drive security circuit breaking; (5) Implement type-aware memory-safe isolation evaluation: Determine the complexity of the pattern string and perform deep cloning based on serialization on the output results that meet the single path characteristics to sever the memory reference association between the result and the original data source.

[0040] The post-state verification logic refers to detecting the activation state of the escape sequencer at the offset position of the starting identifier and determining whether the candidate is in literal protection state or instruction activation state, thereby achieving precise stripping of the escape logic; the dynamic and static color filtering logic refers to actively identifying non-changeable driving paths pointing to the application's global context and browser environment parameters and removing them from the reactive listening queue to achieve on-demand registration.

[0041] The precise listening queue ensures that the corresponding update function is re-executed only when a physical change is detected in a specific field under a registered path, using the path hash. Addressing requests are dynamically routed to the in-memory business state container, the currently logged-in user's identity credential repository, or the browser environment parameter object using a preset prefix identifier. Deep cloning processes utilize serialization algorithms to convert the target value into an intermediate snapshot character stream, and then reconstruct the image object in an independent memory address space through deserialization, thus protecting the immutability of the original state container.

[0042] In this optional embodiment, a recursive path serialization algorithm is used to decompose lexical rules into ordered attribute access sequences, and business field identifiers are extracted based on the ordered attribute access sequences to output a listening queue with dependencies. This includes: capturing dynamic reference candidates, using a preset conflict avoidance protocol to determine the activation status of the reference candidates, splitting the reference candidates based on the activation status to obtain ordered attribute access sequences; extracting field identifiers based on the ordered attribute access sequences, and performing differentiated dependency registration and global state-oriented update processing on the field identifiers, and outputting a listening queue with dependencies based on the processing results.

[0043] In this optional embodiment, capturing dynamic reference candidates and using a preset conflict avoidance protocol to determine the activation state of the reference candidates, and splitting the reference candidates based on the activation state to obtain an ordered attribute access sequence includes: capturing all dynamic reference candidates from static text based on a test static configuration environment, and backtracking to scan the escape status bit of the predecessor offset corresponding to each reference candidate; determining the escape sequencer of the reference candidate based on the escape status bit, and combining it with the preset conflict avoidance protocol to determine the state of the reference candidate; if the escape sequencer of the reference candidate is in an active state, a parsing suppression signal is sent to the parser, and escape sequencer stripping is performed, and a literal is output based on the stripping result, ending the binding and parsing process; if the escape sequencer of the reference candidate is not in an active state, it is determined that the reference candidate is in an instruction active state, and the path parsing logic is activated to apply string splitting to generate an ordered attribute access sequence.

[0044] In this optional embodiment, extracting field identifiers based on ordered attribute access sequences and performing differentiated dependency registration and global state-oriented update processing on the field identifiers, and outputting a listening queue with dependencies based on the processing results includes: obtaining prefix tags of ordered attribute access sequences by calling a preset prefix mask stripping technique, and extracting business field identifiers pointing to the business state machine after stripping the prefix tags; classifying and judging the data source types of the dependent fields corresponding to the business field identifiers to complete the automatic identification of dynamic and static dependencies; performing differentiated dependency registration and global state-oriented update processing based on the dynamic and static dependency identification results, and outputting a listening queue with dependencies.

[0045] In this optional embodiment, classifying and judging the data source type of the dependent field corresponding to the business field identifier to complete the automatic identification of dynamic and static dependencies includes: if the prefix of the business field identifier corresponds to the application-level environment context, then the dependent field of the business field identifier is determined to be a static constant dependency. The data value of the static constant dependency remains stable during the component's lifecycle and will not trigger real-time response changes; if the prefix of the business field identifier corresponds to the global business state container, then the dependent field of the business field identifier is determined to be a dynamic business dependency. The data value of the dynamic business dependency changes with business operations and needs to trigger the update of the associated component; if the business field identifier does not contain a prefix, then the dependent field of the business field identifier is determined to be a component local state dependency. The local state dependency is updated by the component's own local state management mechanism and does not need to be registered with the global state manager.

[0046] In this optional embodiment, based on the results of dynamic and static dependency identification, differentiated dependency registration and global state-oriented update processing are performed. The output listening queue with dependencies includes: removing dependency fields that are static constant dependencies without registration; and handling dependency fields that are determined to be component local state dependencies by the component's internal management mechanism without registering them to the observer set of the global state manager; registering dependency fields that are determined to be dynamic business dependencies to the observer set of the global business state container, establishing a mapping relationship between the core business field path and the corresponding observer; determining the changed dependency fields based on the differentiated dependency registration results, calculating the hash value of the corresponding business field path, and using the hash value to find the observer set corresponding to the dependency field in the mapping relationship of the global business state container; and obtaining the listening queue for executing the rendering calculation process by waking up the observer set to drive the associated components that have dependencies on the dependency fields.

[0047] In this optional embodiment, the multi-dimensional hierarchical retrieval and data aggregation operations are performed using the listening queue as the driving basis. An evaluation strategy is selected based on the execution result and the complexity of the reference pattern, and a memory-isolated cloning result is output to complete the data binding parsing process. This includes: matching a differentiated scheduling strategy based on the real-time runtime environment; when the real-time runtime environment is a visual design environment, it is in a non-executing state, requiring direct pass-through of the listening queue without performing real-time evaluation operations; when the real-time runtime environment is a production runtime environment, it is in an executing state, requiring activation of the parsing instruction to enter the real-time evaluation link; when entering the real-time evaluation link, the ordered attribute access sequence is used as the addressing navigation, performing recursive addressing of attribute paths within the heterogeneous namespace, and implementing defense verification operations during addressing to obtain the data value of the ordered attribute access sequence; based on the data value of the ordered attribute access sequence and the complexity of the reference pattern, an evaluation strategy is selected and executed to implement serialization-based deep cloning processing, completing the data binding parsing operation.

[0048] In this optional embodiment, the heterogeneous namespace consists of a global business state container and a routing parameter pool. The routing parameter pool includes memory routing, context routing, routing parameter routing, and identity routing. Memory routing is used to identify the `formData` prefix in the ordered attribute access sequence, locate the global business state container, and read the corresponding data values ​​level by level according to the field hierarchy recorded in the ordered attribute access sequence. Context routing is used to identify the `context` prefix in the ordered attribute access sequence, locate the application-level environment context, and read the corresponding data values ​​level by level according to the field hierarchy recorded in the ordered attribute access sequence. Routing parameter routing is used to identify the `params` prefix in the ordered attribute access sequence, locate the environment routing parameter pool, and read the corresponding data values ​​level by level according to the field hierarchy recorded in the ordered attribute access sequence. Identity routing is used to identify the `auth` prefix in the ordered attribute access sequence, redirect to the identity authentication and authorization data source, and extract the current user's access token and related identity information.

[0049] In this optional embodiment, an evaluation strategy is selected based on the data values ​​of the ordered attribute access sequence and the complexity of the reference pattern. The evaluation strategy is then executed to perform serialization-based deep cloning processing to complete the data binding parsing operation. This includes: when the reference to be parsed is a comprehensive pattern string of multiple variable references, the data values ​​of the ordered attribute access sequence are sequentially converted into string patterns and concatenated according to the original pattern string format to output a string output result; when the reference to be parsed is a single variable reference, it is determined to be a type-preserving pattern. The data values ​​of the ordered attribute access sequence are then processed according to the serialization to deserialization process to generate a mirror copy that is physically isolated from the original object. The mirror copy is then returned to the rendering layer as the deep cloning output result to complete the data binding parsing operation.

[0050] Figure 2 An embodiment of a dynamic binding and parsing system for multi-source heterogeneous data in a low-code platform according to the present invention is shown.

[0051] In this optional embodiment, the dynamic binding and parsing system for multi-source heterogeneous data in the low-code platform includes: The relation queue output unit 201 is used to decompose lexical rules into ordered attribute access sequences using a recursive path serialization algorithm, and extract business field identifiers based on the ordered attribute access sequences to output a listening queue with dependencies. The binding parsing processing unit 202 is used to perform multi-dimensional hierarchical retrieval and data aggregation operations based on the listening queue, and selects the evaluation strategy according to the complexity of the execution result and the reference pattern, and outputs the memory-isolated clone result to complete the data binding parsing processing.

[0052] In this optional embodiment, the relation queue output unit 201 includes: The access sequence output module is used to capture dynamic reference candidates and, by combining a preset conflict avoidance protocol with the determination of the activation status of the reference candidates, splits the reference candidates based on the activation status to obtain an ordered attribute access sequence. The listening queue output module is used to extract field identifiers based on ordered attribute access sequences, perform differentiated dependency registration and global state-oriented update processing on the field identifiers, and output the listening queue with dependencies based on the processing results.

[0053] In this optional embodiment, the access sequence output module, when capturing dynamic reference candidates and using a preset conflict avoidance protocol to determine the activation state of the reference candidates, splits the reference candidates based on the activation state to obtain an ordered attribute access sequence, includes: capturing all dynamic reference candidates from static text based on a test static configuration environment, and backtracking to scan the escape status bit of the predecessor offset corresponding to each reference candidate; determining the escape sequence leader of the reference candidate based on the escape status bit, and combining it with the preset conflict avoidance protocol to determine the state of the reference candidate; if the escape sequence leader of the reference candidate is in an active state, sending a parsing suppression signal to the parser and performing escape sequence leader stripping processing, outputting a literal based on the stripping result, and ending the binding and parsing processing; if the escape sequence leader of the reference candidate is not in an active state, determining that the reference candidate is in an instruction active state, and activating the path parsing logic to apply string splitting to generate an ordered attribute access sequence.

[0054] To facilitate understanding of the above technical solution of the present invention, the following further explains the technical solution of the present invention from the perspective of architecture and principle. Through five highly interlocking links, a cross-dimensional technical closed loop is constructed. A complex pattern string covering diverse heterogeneous data sources (local state, global form model, application environment context, routing parameters, and authentication credentials) demonstrates the closed-loop process from static configuration to dynamic rendering. The initial input (JSON configuration value) is the pattern string "id / :formData.manager.name / \:literal / :context.userProfile.id / :params.orderId / :auth.accessToken". The specific implementation steps are as follows: Step 1: Construct a self-describing reference protocol with conflict avoidance capabilities; Lexical analysis logic: For a JSON static configuration environment, a lexical system consisting of a bootstrap unit, a start identifier, and an addressing connector is defined. A recursive path serialization algorithm is applied to decompose the input pattern string into an ordered attribute access sequence (Tokens).

[0055] Conflict avoidance measures: To avoid the dependence of traditional regular expressions on the browser environment when handling escape logic, a post-state bit offset detection algorithm is adopted. First, a full capture is performed through the regular expression superset; then, for each candidate, the escape state bit of its predecessor offset is scanned back. If an active leading character is detected, parsing suppression is performed to ensure that the escape literal is not misparsed.

[0056] Logical support: The ordered attribute access sequence (Tokens) generated in this step serves as the core data structure and is output to the downstream steps.

[0057] Specifically, the first step is to achieve full capture. The matching engine captures six dynamic reference candidates from static text: ":id", ":formData.manager.name", "\:literal", ":context.userProfile.id", ":params.orderId", and ":auth.accessToken". Then, using the post-state bit offset detection algorithm, for the candidate "\:literal", an active escape sequence "\" is detected at the offset position before the start identifier ":". According to the preset conflict avoidance protocol, it is determined that the candidate is in the literal protection state. A parsing suppression signal is immediately sent to the parser, and escape character stripping is performed. Finally, the literal ":literal" is output.

[0058] For other active items: if an unescaped start identifier is detected, it is determined to be in the instruction active state, and the subsequent path resolution logic is activated.

[0059] Simultaneously, recursive serialization is performed, applying a recursive decomposition algorithm to candidates in the "instruction active state," i.e., string splitting, to generate ordered attribute access sequences. For example: ":id" is converted to "['id']"; ":formData.manager.name" is converted to "['formData', 'manager', 'name']"; ":context.userProfile.id" is converted to "['context', 'userProfile', 'id']"; ":params.orderId" is converted to "['params', 'orderId']"; ":auth.accessToken" is converted to "['auth', 'accessToken']".

[0060] Step 2: Perform static analysis and field-level reactive dependency registration; Dependency extraction logic: Static scan the Tokens sequence output in step one, use the prefix mask stripping algorithm to remove namespace tags, and extract the core business field identifiers that point to the business state machine.

[0061] Precise registration protocol: Implement dynamic and static color filtering to identify and eliminate environmental constant paths with no change driving characteristics. Through a reactive subscription mechanism, establish an independent observer set (ObserverSet) for each active KeyPath in the global business state container.

[0062] Targeted update mechanism: This step establishes a mapping between configuration and atomic data. When the observer set detects a data change, it can accurately wake up this logic chain through path hash and enter step three to re-execute, avoiding unnecessary computational overhead.

[0063] Specifically, the first step is to extract the field identifier: apply the prefix mask stripping algorithm, that is, the system statically scans the Tokens sequence output in step one, removes the common prefix formData, and extracts the core business field path manager.name, for example, extract the core business field path "manager.name" from ":formData.manager.name".

[0064] Static / dynamic character recognition: Analysis revealed that ":context.userProfile.id" (application-level environment context) and ":params.orderId" (URL path parameter) are static constants. In this scenario, such data usually does not trigger real-time responsive changes to the UI.

[0065] Precise registration: Remove the above static dependencies, only "manager.name" (global business state container) is registered to the observer collection of the state manager, while ":id" has no prefix and uses id directly, indicating that it is getting data from the local business state of the current component. It is updated with the component refresh and is not registered.

[0066] Targeted update mechanism: This on-demand registration mechanism optimizes system load. When the value of "manager.name" in the global business state container undergoes a physical change, the container will accurately locate and wake up only the observer set corresponding to that field through path hash (that is, the container will traverse all components registered to the observer set, find the registration items that depend on manager.name, and then re-render and refresh the registration items). The woken set drives the associated components to re-enter the process of steps three to five, and quickly calculate the output result using the existing token sequence, thereby achieving extremely high-performance local precise update.

[0067] Step 3: Dynamic routing of execution paths for environment awareness; Distribution mechanism: Real-time detection of the runtime environment. If it is in a visual design environment, it is determined to be in a non-execution state and the original reference mode is directly passed through for editing. If it is in a production runtime environment, the parsing instruction is officially activated and the subsequent real-time evaluation chain is entered.

[0068] Step 4: Secure hierarchical retrieval and addressing of multi-source heterogeneous data; Layered distribution: The parsing engine distributes requests to heterogeneous namespaces based on path prefixes, including: global business state container, identity authentication and permission context, environment routing parameter pool, and external response cache, etc.

[0069] Non-executable addressing step: The algorithm receives the Tokens sequence output from step one and treats it as memory addressing navigation. Starting from the root object, it performs memory offset access sequentially and incorporates an existence defense check before each jump. If a path break is detected, it immediately performs a safety circuit breaker and returns a default value.

[0070] Security causal logic: This method replaces script execution with data navigation, eliminating the possibility of malicious code injection at the physical layer.

[0071] Specifically, its implementation process includes two parts: (1) Hierarchical retrieval flow: When a change signal is detected, the parsing engine performs multi-dimensional distribution carrying the token sequence: Memory routing: Locate the global business state container via the "formData" prefix, and read it level by level according to the sequence "['manager', 'name']"; Context routing: Locates the application-level environment context by the "context" prefix, and reads it level by level according to the sequence "['userProfile', 'id']"; Routing parameters: The environment routing parameter pool is located by the prefix "params", and read level by level according to the sequence "['orderId']"; Identity routing: Redirects to the identity authentication and authorization data source via the "auth" prefix, and extracts the current user's access token.

[0072] (2) Safety circuit break: Sandbox isolation is achieved through non-executable retrieval during the addressing process, and automatic circuit break is performed when intermediate nodes are missing to prevent rendering crashes.

[0073] Step 5: Type-aware memory isolation evaluation and output; Complexity determination: Detect the structure of the reference pattern and automatically switch between type preservation or template splicing mode.

[0074] Physical isolation method: Perform deep cloning based on snapshot serialization for complex data types. Utilize a serialization algorithm (i.e., the JSON.stringify() function in JavaScript) to convert the target value into an independent character stream snapshot, and then reconstruct the mirror object through deserialization in a physically isolated new memory address space.

[0075] This method severs the memory reference chain between UI components and the state container, ensuring the immutability of the global state and preventing unintended pollution of the core state source caused by logical side effects on the component side.

[0076] Specifically, different evaluation strategies are executed based on the complexity of the reference pattern, and the final output is as follows: Scenario 1 (Template Concatenation): For the above comprehensive pattern string, obtain the values ​​of each variable in sequence (assuming: id=3000, manager.name=Zhang San etc.), perform string concatenation, and finally output: 3000 / Zhang San / :literal / admin / ORD001 / JWT_TOKEN_ABC.

[0077] Scenario 2 (Type Preservation): If the configuration item is only a single variable reference: formData.manager, the system determines it to be in type preservation mode. After the engine obtains the target object "{name:'Zhang San', role:'Supervisor'}", it generates a physically isolated mirror copy through the serialization-refactoring process. After the UI rendering layer obtains this copy, any local modifications to it will not pollute the original state container, thus maintaining the immutability of the state.

[0078] In one embodiment, a computer device is provided, which may be a server, and its internal structure diagram may be as follows: Figure 3 As shown, the computer device includes a processor, memory, and a network interface connected via a system bus. The processor provides computing and control capabilities. The memory includes a non-volatile storage medium and internal memory. The non-volatile storage medium stores an operating system, computer programs, and a database. The internal memory provides an environment for the operation of the operating system and computer programs in the non-volatile storage medium. The database stores static and dynamic information data. The network interface communicates with external terminals via a network connection. When the computer program is executed by the processor, it implements the steps in the above method embodiments.

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

[0080] In addition, the present invention also provides a computer device, including a memory and a processor, wherein the memory stores a computer program, and the processor executes the computer program to implement the steps in the above method embodiments.

[0081] In addition, the present invention also provides a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the steps in the above method embodiments.

[0082] Those skilled in the art will understand that all or part of the processes in the methods of the above embodiments can be implemented by a computer program instructing related hardware. The computer program can be stored in a non-volatile computer-readable storage medium, and when executed, it can include the processes of the embodiments of the methods described above. Any references to memory, storage, databases, or other media used in the embodiments provided by this invention can include at least one of non-volatile and volatile memory. Non-volatile memory can include read-only memory (ROM), magnetic tape, floppy disk, flash memory, or optical storage, etc. Volatile memory can include random access memory (RAM) or external cache memory. By way of illustration and not limitation, RAM can be in various forms, such as static random access memory (SRAM) or dynamic random access memory (DRAM), etc.

[0083] This invention is not limited to the structures described above and shown in the accompanying drawings, and various modifications and changes can be made without departing from its scope. The scope of this invention is limited only by the appended claims.

Claims

1. A method for dynamic binding and parsing of multi-source heterogeneous data in a low-code platform, characterized in that, The method includes: Using a recursive path serialization algorithm, lexical rules are decomposed into ordered attribute access sequences, and business field identifiers are extracted based on the ordered attribute access sequences to output a listening queue with dependencies. The listening queue is used as the driving force to perform multi-dimensional hierarchical retrieval and data aggregation operations. The evaluation strategy is selected based on the complexity of the execution results and the reference pattern, and the memory-isolated clone results are output to complete the data binding parsing process.

2. The method for dynamic binding and parsing of multi-source heterogeneous data in a low-code platform according to claim 1, characterized in that, The process of using a recursive path serialization algorithm to decompose lexical rules into ordered attribute access sequences and extracting business field identifiers based on these sequences to output a listening queue with dependencies includes: Capture dynamic reference candidates, and use a preset conflict avoidance protocol to determine the activation status of the reference candidates. Based on the activation status, split the reference candidates to obtain an ordered property access sequence. Field identifiers are extracted based on ordered attribute access sequences, and differential dependency registration and global state-oriented update processing are performed on the field identifiers. Based on the processing results, a listening queue with dependencies is output.

3. The method for dynamic binding and parsing of multi-source heterogeneous data in a low-code platform according to claim 2, characterized in that, The process involves capturing dynamic reference candidates and using a preset conflict avoidance protocol combined with determining the activation state of the reference candidates. Based on the activation state, the reference candidates are split to obtain an ordered attribute access sequence, including: Based on the test static configuration environment, capture all dynamic reference candidates from static text and backtrack to scan the escape status bit of the predecessor offset corresponding to each reference candidate; The escape sequencer of the reference candidate is determined based on the escape status bit, and the status of the reference candidate is determined by combining it with the preset conflict avoidance protocol. If the escape sequence of the candidate is active, a parsing suppression signal is sent to the parser, and escape sequence stripping is performed. The literal is output based on the stripping result, and the binding and parsing process ends. If the escape sequence of a reference candidate is not active, the reference candidate is determined to be active, and the path resolution logic is activated to apply string splitting and generate an ordered property access sequence.

4. The method for dynamic binding and parsing of multi-source heterogeneous data in a low-code platform according to claim 3, characterized in that, The process of extracting field identifiers based on ordered attribute access sequences, performing differentiated dependency registration and global state-oriented update processing on these field identifiers, and outputting a listening queue with dependencies based on the processing results includes: The prefix marker of the ordered attribute access sequence is obtained by calling the preset prefix mask stripping technique, and after stripping the prefix marker, the business field identifier pointing to the business state machine is extracted. Classify and determine the data source type of the dependent fields corresponding to the business field identifiers to complete the automatic identification of dynamic and static dependencies; Based on the results of dynamic and static dependency identification, perform differentiated dependency registration and global state-oriented update processing, and output a listening queue with dependency relationships.

5. The method for dynamic binding and parsing of multi-source heterogeneous data in a low-code platform according to claim 4, characterized in that, The step of classifying and judging the data source type of the dependent fields corresponding to the business field identifiers to complete the automatic identification of dynamic and static dependencies includes: If the prefix of the business field identifier corresponds to the application-level environment context, then the dependent field of the business field identifier is determined to be a static constant dependency. The data value of the static constant dependency remains stable throughout the component's lifecycle and will not trigger real-time response changes. If the prefix of the business field identifier corresponds to the global business state container, then the dependent field of the business field identifier is determined to be a dynamic business dependency. The data value of the dynamic business dependency changes with business operations and needs to trigger the update of the associated components. If the business field identifier does not contain a prefix marker, then the dependent field of the business field identifier is determined to be a component local state dependency. The local state dependency is updated by the component's own local state management mechanism and does not need to be registered with the global state manager.

6. The method for dynamic binding and parsing of multi-source heterogeneous data in a low-code platform according to claim 5, characterized in that, The process of performing differentiated dependency registration and global state-oriented update based on dynamic and static dependency identification results outputs a listening queue with dependency relationships, including: Dependency fields that are static constant dependencies are removed and not registered. Meanwhile, dependency fields that are determined to be local state dependencies of the component are handled by the component's internal management mechanism and are not registered to the observer set of the global state manager. The dependency fields identified as dynamic business dependencies are registered in the observer set of the global business state container, establishing a mapping relationship between the core business field paths and the corresponding observers; Based on the differential dependency registration results, determine the changed dependency fields, calculate the hash value of the business field path of the corresponding dependency relationship, and use the hash value to find the observer set corresponding to the dependency field in the mapping relationship of the global business state container. By waking up the observer collection, the associated components that have dependencies on the dependent fields are driven to obtain the listening queue used to execute the rendering calculation process.

7. The method for dynamic binding and parsing of multi-source heterogeneous data in a low-code platform according to claim 1, characterized in that, The process of using the listening queue as the driving force to perform multi-dimensional hierarchical retrieval and data aggregation operations, selecting an evaluation strategy based on the execution results and the complexity of the reference pattern, and outputting memory-isolated clone results to complete the data binding parsing process includes: Based on the real-time runtime environment, a differentiated scheduling strategy is matched; when the real-time runtime environment is a visual design environment, it is in a non-execution state, and the listening queue needs to be directly passed through without performing real-time evaluation operations; when the real-time runtime environment is a production runtime environment, it is in an execution state, and the parsing instruction needs to be activated to enter the real-time evaluation link. When entering the real-time evaluation link, the ordered attribute access sequence is used as the address navigation. The attribute path recursive addressing is performed in the heterogeneous namespace, and the defense verification operation is implemented in the addressing to obtain the data value of the ordered attribute access sequence. Based on the complexity of the data values ​​and reference patterns of the ordered access sequence, an evaluation strategy is selected and executed to perform serialization-based deep cloning processing, thus completing the data binding parsing operation.

8. The method for dynamic binding and parsing of multi-source heterogeneous data in a low-code platform according to claim 7, characterized in that, The heterogeneous namespace consists of a global business state container and a routing parameter pool; The routing parameter pool includes memory routing, context routing, routing parameter routing, and identity routing.

9. The method for dynamic binding and parsing of multi-source heterogeneous data in a low-code platform according to claim 8, characterized in that, The memory routing is used to identify the formData prefix in the ordered attribute access sequence, locate the global business state container, and read the corresponding data values ​​level by level according to the field hierarchy order of the ordered attribute access sequence records; The context routing is used to identify the context prefix in the ordered attribute access sequence, locate the application-level environment context, and read the corresponding data values ​​level by level according to the field hierarchy order recorded in the ordered attribute access sequence; The routing parameter routing is used to identify the params prefix in the ordered attribute access sequence, locate the environment routing parameter pool, and read the corresponding data values ​​level by level according to the field hierarchy order recorded in the ordered attribute access sequence; The identity routing is used to identify the auth prefix in the ordered attribute access sequence, redirect to the identity authentication and authorization data source, and extract the current user's access token and related identity information.

10. The method for dynamic binding and parsing of multi-source heterogeneous data in a low-code platform according to claim 9, characterized in that, The step of selecting an evaluation strategy based on the complexity of the data values ​​and reference patterns of the ordered access sequence, and executing the evaluation strategy to perform serialization-based deep cloning processing to complete the data binding parsing operation includes: When the reference to be parsed is a composite pattern string of multiple variable references, the data values ​​of the ordered attribute access sequence are converted into string patterns in turn, and then concatenated according to the original pattern string format, and the string output result is output. When the reference to be resolved is a single variable reference, it is determined to be in type-preserving mode. The data values ​​of the ordered property access sequence are generated according to the serialization to deserialization process to generate a mirror copy that is physically isolated from the original object. The mirror copy is then returned to the rendering layer as the deep clone output to complete the data binding and parsing operation.

11. A dynamic binding and parsing system for multi-source heterogeneous data in a low-code platform, characterized in that, The system includes: The relational queue output unit is used to decompose lexical rules into ordered attribute access sequences using a recursive path serialization algorithm, and extract business field identifiers based on the ordered attribute access sequences to output a listening queue with dependencies. The binding parsing processing unit is used to perform multi-dimensional hierarchical retrieval and data aggregation operations based on the listening queue, and selects the evaluation strategy according to the complexity of the execution result and the reference pattern, and outputs the memory-isolated clone result to complete the data binding parsing processing.

12. The dynamic binding and parsing system for multi-source heterogeneous data in a low-code platform according to claim 11, characterized in that, The relation queue output unit includes: The access sequence output module is used to capture dynamic reference candidates and, by combining a preset conflict avoidance protocol with the determination of the activation status of the reference candidates, splits the reference candidates based on the activation status to obtain an ordered attribute access sequence. The listening queue output module is used to extract field identifiers based on ordered attribute access sequences, perform differentiated dependency registration and global state-oriented update processing on the field identifiers, and output the listening queue with dependencies based on the processing results.

13. The dynamic binding and parsing system for multi-source heterogeneous data in a low-code platform according to claim 12, characterized in that, The access sequence output module, when capturing dynamic reference candidates and using a preset conflict avoidance protocol combined with determining the activation state of the reference candidates, splits the reference candidates based on the activation state to obtain an ordered attribute access sequence, includes the following: Based on the test static configuration environment, capture all dynamic reference candidates from static text and backtrack to scan the escape status bit of the predecessor offset corresponding to each reference candidate; The escape sequencer of the reference candidate is determined based on the escape status bit, and the status of the reference candidate is determined by combining it with the preset conflict avoidance protocol. If the escape sequence of the candidate is active, a parsing suppression signal is sent to the parser, and escape sequence stripping is performed. The literal is output based on the stripping result, and the binding and parsing process ends. If the escape sequence of a reference candidate is not active, the reference candidate is determined to be active, and the path resolution logic is activated to apply string splitting and generate an ordered property access sequence.

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

Images