Transaction object instantiation method and system based on virtual pre-execution model and atomization anchor point implantation

Abstract

The invention discloses a transaction object instantiation method and system based on a virtual pre-execution model and atomization anchor point implantation. The method comprises the following steps: constructing a source data container supporting a Web DOM and a graphic engine; executing memory sandbox rehearsal of an application layer, and constructing a virtual model in a server-side memory to carry out logic simulation independent of a database; and after the verification is passed, creating a transaction object, and reconstructing an original node into an atomization interaction anchor point. Meanwhile, dynamic permission fusing is achieved through environment fingerprints and a rendering pipeline interceptor, and on the premise that the integrity of memory data is kept, mask replacement is only conducted on sensitive data in the view drawing stage. According to the method, the problem of data fault is effectively solved, dirty data caused by tentative writing is eliminated, and safe decoupling of data transmission and visual rendering is realized.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of computer collaborative office, instant messaging, distributed data processing, industrial digital twin and zero trust security, and in particular to a method and system for solving the data fault problem in unstructured documents, graphic canvases, industrial monitoring large screens and instant messaging messages, using virtual model verification and atomic index technology to realize object instantiation, and combining environment fingerprints for rendering layer security truncation. BACKGROUND

[0002] In modern enterprise information management, collaborative office and industrial internet scenarios, data usually exists in multiple forms: one is unstructured or semi-structured data used for front-end display and communication (such as text paragraphs in documents, chat bubbles in instant messaging IM, graphic nodes in online whiteboard Canvas, and virtual instrument panels in industrial SCADA systems), and the other is structured transaction objects used for back-end business flow and execution (such as task orders, approval process instances, transaction orders, and PLC control instructions in databases).

[0003] The existing technology has significant technical bottlenecks when processing the interaction of the above two data forms:

[0004] 1. Data fault and rendering architecture limitation: existing solutions are mostly limited to Web DOM structure rich text editors. With the rise of high-performance tools such as Figma, Google Docs Canvas version, and industrial digital twin 3D engines, more and more applications have moved away from DOM and use Canvas, WebGL or Native Engine for pixel-level self-drawing. In these "black box" pixel streams, traditional DOM node replacement technology fails, making it impossible to convert graphic areas into interactive business objects.

[0005] 2. Invalid I / O and dirty data problem: existing solutions usually directly initiate write requests to the database (tentative write). If the write fails due to business logic errors (such as insufficient inventory, time conflicts, and industrial device parameter overruns), it will not only cause invalid network I / O and database lock overhead, but also easily leave failed dirty data records in the system.

[0006] 3. Experience fragmentation: when the back-end business logic verification fails, traditional solutions often need to refresh the entire page or pop up a modal dialog box, interrupting the user's flow.

[0007] 4. Security defense weakness and display layer risk: the traditional scheme relies on static account permissions (ACL). In a non-trusted network environment, even if the user's permissions are legal, there is a risk of displaying sensitive data (such as financial data, core process parameters). And the existing desensitization scheme is mostly performed on the server side to truncate data. Once the environment is safe, the complete data needs to be requested from the network, causing experience lag and bandwidth waste. SUMMARY

[0008] The application provides a transaction object instantiation method and system based on a virtual pre-execution model and atomic anchor implantation, aiming to solve the problems of data discontinuity, dirty data generation and lack of dynamic security defense in the prior art.

[0009] The technical solution of the application is as follows:

[0010] A transaction object instantiation method based on a virtual pre-execution model and atomic anchor implantation, comprising:

[0011] A source data container containing a plurality of discrete data block nodes is constructed, and the nodes support Web DOM, native view hierarchy, virtual widget tree or bitmap / vector-based graphics rendering engine (Canvas / WebGL) and other visualization rendering structures.

[0012] Perform an application layer memory sandbox rehearsal step: analyze the metadata of the discrete data block nodes, and generate a transient virtual pre-execution model in the volatile memory of the application server.

[0013] Perform non-persistent logic simulation and dependency checking independent of the database storage engine on the virtual pre-execution model to verify the compliance of business rules, timing logic and cross-object resource locks.

[0014] If the simulation fails, the error is fed back to the front end through non-blocking interaction, and no database log is left; when the verification passes, the instantiation process is triggered to create a persistent transaction execution object in the storage medium.

[0015] Perform an atomic bidirectional anchor implantation step: write a source pointer pointing to the original node, and reconstruct the original node to inject an atomic interactive anchor object to establish a bidirectional synchronization channel. For graphics engines such as Canvas, objectization is achieved using virtual coordinate mapping and post-processing layer rendering technology.

[0016] The application also provides a dynamic permission fuse and transaction object security rendering method based on environment fingerprint, comprising:

[0017] Before rendering the anchor object, calculate a dynamic environment fingerprint containing network, device hardware and random factors.

[0018] Fingerprint is compared with a security whitelist, and if not matched, a fuse mechanism is triggered. The mechanism is implemented through a data stream interceptor at the rendering pipeline level, keeping the original data complete in memory, replacing sensitive data with a mask only in the view drawing stage, and removing event listeners.

[0019] The beneficial effects of the present application include:

[0020] 1. Generalized container adaptation and Canvas support: By abstracting the "visual rendering structure" and introducing "virtual coordinate mapping", the technical solution is extended to Web DOM, Native App and high-performance Canvas / WebGL rendering engines, solving the data discontinuity problem of new generation productivity tools and industrial software.

[0021] 2. Eliminate invalid I / O and resource lock competition: The present application adopts "application layer virtual pre-execution" mechanism, which is fundamentally different from traditional "database transaction rollback". The virtual pre-execution model runs completely in volatile memory, completely eliminating the generation of dirty data and waste of database resources caused by logical errors.

[0022] 3. Rendering layer security truncation and broad applicability: The "rendering pipeline interception" technology is introduced, realizing the dynamic decoupling of data transmission (Data Transport) and visual presentation (Visual Presentation). The present application is not only suitable for document collaboration, but also can be seamlessly applied to financial transaction terminals, medical image workstations and industrial SCADA systems. Especially in the industrial digital twin scene, using the environment fingerprint fuse mechanism of the present application, multi-dimensional dynamic access control based on "people + place + time" can be realized only in the display layer without changing the underlying industrial protocol (such as MQTT, Modbus) data transmission logic, effectively preventing sensitive process parameters from being leaked in non-secure areas. BRIEF DESCRIPTION OF DRAWINGS

[0023] Figure 1 The method flowchart of the first embodiment of the present application is shown in the figure;

[0024] Figure 2 The logical comparison chart of the virtual pre-execution model and the traditional database transaction processing is shown in the figure;

[0025] Figure 3 The flowchart of the dynamic permission fuse mechanism based on environment fingerprint is shown in the figure, including the rendering pipeline interception logic;

[0026] Figure 4 The virtual coordinate mapping and anchor point implantation schematic diagram in the Canvas environment is shown in the figure;

[0027] Figure 5A bidirectional mapping graph of multi-form source data containers and atomized interaction anchor objects. DETAILED DESCRIPTION

[0028] Definitions and explanations of terms

[0029] For the convenience of those skilled in the art, the following core terms are defined in this application, and the protection scope is not limited to the specific implementation forms described below:

[0030] 1. Virtual Pre-execution Model:

[0031] Refers to a logical entity built in the application layer volatile memory (RAM) before data is persisted in storage (such as writing to a hard disk database) to simulate, verify, and predict business results.

[0032] Scope: Not only includes sandbox-based isolation environments, but also includes logical trial processes based on rule engines (Rule Engine), finite state machines (FSM), or script interpreters (such as V8 Context).

[0033] Technical form: It can be a server-side memory object image, or a local simulation logic based on WebAssembly (Wasm) executed on an edge node or client. As long as it is a logical verification and state inference that does not trigger the underlying storage engine transaction commit (Commit), it belongs to the scope of this definition.

[0034] 2. Render Pipeline Interceptor:

[0035] Refers to any control logic or code aspect between the data source and the final pixel rendering in the computer graphics rendering process. This term covers all mainstream front-end framework and graphics engine rendering intervention technologies, including but not limited to:

[0036] Virtual DOM Level: For declarative frameworks such as React and Vue, it refers to the interception during the execution of the render() function, the diff algorithm comparison phase, or the patch patch application phase. For example, by proxying objects to hijack data reading, or masking sensitive fields in high-order components (HOC).

[0037] Instruction Call Level: For HTML5 Canvas, Flutter Skia Engine or Native GDI+, it refers to the override, decoration or Hook function interception of the underlying drawing API (such as ctx.fillText, ctx.drawImage).

[0038] Shader Level: For WebGL, Three.js or Unity 3D Engine, it refers to the conditional judgment logic injected in the Vertex Shader or Fragment Shader, which dynamically discards pixels or changes rendering colors according to Uniform variables (such as security status flags).

[0039] Embodiment One: Core Method Flow and Canvas Adaptation

[0040] This embodiment corresponds to claims 1 and 4.

[0041] When processing source data containers based on Canvas or WebGL (such as high-performance online tables or design tools), discrete data block nodes no longer correspond to DOM nodes, but to a virtual layer or Scene Graph Node in the rendering engine.

[0042] When the user selects an area on the Canvas (such as a rectangular note in the design diagram) and initiates an instantiation request:

[0043] Coordinate Mapping: The system records the {x, y, width, height} of the area in the canvas coordinate system and the current transformation matrix (Matrix).

[0044] Virtual Node Construction: Create a non-visual virtual proxy node in memory, use the above coordinate information as its metadata, and associate the corresponding business text content.

[0045] Virtual Pre-execution: Build a virtual model in the application layer RAM and perform logical simulation without occupying database connections.

[0046] Anchor implantation: After instantiation, the system does not destroy the underlying pixel data, but injects a post-processing layer into the Canvas's render loop. This layer draws interactive anchor components (such as SVG overlays or Canvas self-drawing UI) on top of the original pixels according to the recorded coordinates. This "separate rendering" ensures that the original high-performance engine's rendering logic is not destroyed, while giving the pixel area the ability to "objectify".

[0047] Example Two: Virtual Pre-execution Model and Dirty Data Defense

[0048] This embodiment corresponds to claims 2, 3.

[0049] When the virtual pre-execution model detects a logical conflict (such as inventory becoming negative, schedule overlapping) in memory:

[0050] The backend generates a "transient error object" containing error code and metadata, without recording any database error log. The backend immediately destroys the virtual model in memory.

[0051] The error object is pushed to the front end through a long connection channel. The front end does not refresh the page, but directly overlays a pop-up layer on the corresponding discrete data block node (or Canvas coordinate area) through JavaScript or Native operation to display error information.

[0052] This process ensures that the system does not store garbage logs internally, and users can obtain feedback without refreshing the page.

[0053] Example Three: Dynamic Permission Fusing and Rendering Layer Truncation Based on Environment Fingerprint

[0054] This embodiment corresponds to claims 9, 10, 11, and details how to achieve secure "visual fusing" in the rendering layer without modifying the backend data stream or destroying the data structure.

[0055] Environment fingerprint generation:

[0056] Fingerprint = Hash( Combine( f1(Net_Seg), f2(Dev_ID), f3(Geo_Info),f4(Salt) ) )

[0057] Where Hash() is a one-way hash function, Net_Seg is the network IP segment feature, Dev_ID is the device physical identifier, Geo_Info is the geographic location code, and Salt is a random salt value.

[0058] Rendering layer truncation technology implementation:

[0059] The system adopts the AOP (Aspect-Oriented Programming) idea, and implants the interception aspect in the render() life cycle function or rendering instruction of the anchor object:

[0060] Data flow preservation: The original JSON data packet (including sensitive amounts, approval opinions, etc.) pushed by the server is complete to the client memory.

[0061] Render pipeline interception (Render Pipeline Interception):

[0062] For DOM / React / Vue architecture: In the virtual DOM generation stage, the interceptor wraps the data binding Getter method. When the rendering engine tries to read object.amount for display, the interceptor detects the current environment fingerprint state. If it is in the "fused state", the Getter method returns the mask string "******".

[0063] For Canvas / Flutter architecture: Intercept the underlying drawing instruction (Draw Call). For example, intercept the canvas.fillText(text, x, y) instruction. When it is detected that the instruction corresponds to a sensitive field and the environment is unsafe, the interceptor dynamically replaces the text parameter with a placeholder or directly skips the execution of the instruction.

[0064] Event shielding: The interceptor takes over the interactive event in the capture phase, and if the fuse is effective, it prevents the event from being passed and triggers a security prompt.

[0065] Through the above mechanism, the dynamic separation of the data transmission layer and the view presentation layer is realized, and if the user environment instantaneously recovers safety (such as switching back to the internal network VPN), the system can restore complete data display without re-requesting the network.

[0066] Embodiment four: system architecture

[0067] The system includes:

[0068] Source data construction module: responsible for adapting Web DOM, native view and Canvas / WebGL rendering structure analysis.

[0069] Virtual sandbox engine: core module, responsible for logical simulation and lock-free trial calculation in application layer memory.

[0070] Instantiated execution engine: responsible for persistent writing of the database and atomic anchor replacement.

[0071] Security control module: responsible for fingerprint calculation, whitelist comparison, and rendering pipeline interception.

[0072] Two-way communication module: Maintains the publish-subscribe channel and is responsible for status push.

[0073] Example 5: Secure Rendering Based on Industrial Digital Twin and IoT Dashboard

[0074] This embodiment demonstrates the application of the present invention in Industrial Internet of Things (IIoT) and Supervisory Control and Data Acoustics (SCADA) scenarios.

[0075] 1. Source data container and node structure:

[0076] In industrial digital twin systems, the source data container is represented as a "3D factory model" or a "real-time monitoring dashboard." The discrete data block nodes within it are represented as virtual instruments bound to sensor data, equipment status indicators, or production line yield curves. These nodes are typically rendered using Canvas or WebGL for high performance.

[0077] 2. Applications of virtual pre-execution:

[0078] When an operator attempts to modify the operating parameters of a device (such as adjusting the "furnace temperature setting" from 800℃ to 1200℃):

[0079] Traditional problem: Directly issuing commands may damage the device hardware or trigger a safety shutdown.

[0080] This solution involves building a "virtual pre-execution model" of the device in the edge gateway or cloud memory, and simulating it in conjunction with current physical constraints (such as pressure thresholds and coolant flow rates). If the simulation results indicate that excessively high temperatures will cause the pressure vessel to explode, the backend generates a "transient error object," and the frontend dashboard rejects the operation through red highlighting or vibration feedback, without issuing any instructions to the PLC (Programmable Logic Controller).

[0081] Example 6: SCADA View Circuit Breaker Based on Geofencing and Roles

[0082] In large-screen monitoring scenarios, data streams are often broadcast.

[0083] Scenario Description: In a chemical plant, a low-level inspector and a chief engineer are each using their respective tablets to view the real-time status of the same reactor.

[0084] Fingerprint calculation: The system generates an environmental fingerprint based on the physical location of the tablet computer (Geo-fencing, such as whether it is in the control room), the device's MAC address, and the current shift time.

[0085] Rendering interception:

[0086] Chief Engineer's Perspective: Environmental fingerprint matching whitelist. The Canvas is drawn normally, displaying the specific "Core Pressure Value: 12.5 MPa" and "Formula Component Ratio".

[0087] From the inspector's perspective: Although the data packet has arrived at the terminal (containing specific values), the rendering pipeline interceptor detects insufficient fingerprint permissions. During the WebGL rendering phase, the "core stress value" is automatically replaced with a "normal / abnormal" status color block, and the "recipe ingredient ratio" area is rendered with a blurred frosted glass effect, achieving physical isolation between data transmission and visual presentation.

[0088] Those skilled in the art should understand that the above embodiments are for illustrative purposes only and are not intended to limit the scope of the invention. For those skilled in the art, various improvements and modifications can be made without departing from the principles of the invention, and these improvements and modifications should also be considered within the scope of protection of the invention.

Claims

1. A transactional object instantiation method based on virtual pre-execution model and atomic anchoring, characterized by, The method comprises the following steps: constructing a source data container comprising a plurality of discrete data block nodes, each of the discrete data block nodes having an independent visual rendering structure and metadata attribute, the visual rendering structure comprising at least one of a Web Document Object Model (DOM) tree, a native application view hierarchy, a virtual widget tree, a bitmap or vector-based graphics rendering engine context (Canvas / WebGL), or an instant messaging message body; performing an application layer memory sandbox pre-play step: traversing the source data container, parsing the metadata attribute of the discrete data block node, extracting a control instruction set, and aggregating a transient virtual pre-execution model in a volatile memory space of an application server; performing a non-persistent logic simulation and dependency check independent of a database storage engine on the virtual pre-execution model, the logic simulation comprising a business trial calculation and resource competition simulation based on a current service end state snapshot; when the dependency check passes and a validity condition is met, triggering an instantiation process, creating a persistent transaction execution object in a target storage medium based on the virtual pre-execution model, and allocating a transaction unique identifier; performing an atomized bidirectional anchor implantation step: based on a data consistency control protocol, writing a source pointer pointing to the original discrete data block node UUID in a system table of the transaction execution object; and synchronously reconstructing the metadata structure of the discrete data block node, encapsulating the transaction unique identifier as an atomized interactive anchor object injected into the node, and establishing a bidirectional data channel; for the graphics rendering engine context, the atomized bidirectional anchor implantation step comprises: registering a bounding box of the discrete data block node in a virtual coordinate system, establishing an event listening mapping of the coordinate area and the transaction unique identifier, and drawing a corresponding custom graphics layer in the rendering loop; the atomized interactive anchor object appears in any one of the following forms: a rich-text hyperlink, a dynamic card, an interactive widget, a post-processing graphics layer, an industrial virtual instrument, or an embedded applet container.

2. The method of claim 1, wherein, It also comprises a non-blocking interactive visualization step based on virtual simulation feedback: when the logic simulation or dependency check fails, the virtual pre-execution model generates a transient error object containing conflict type and resource occupation details in memory, and immediately destroys the virtual pre-execution model; the service end pushes the transient error object to the source data container through a long connection channel, locks the metadata state of the discrete data block node, and prohibits it from initiating a new instantiation request; without refreshing the host page and without repainting non-related nodes, directly dynamically superimposing a floating prompt layer or injecting an error state style class on the visual rendering structure of the discrete data block node to intuitively display the business rule conflict or resource competition details that cause the simulation to fail.

3. The method of claim 2, wherein, The generation and pushing process of the transient error object is configured not to trigger any database-level error log recording or rollback operation; The front end receives the transient error object and only maintains the error state in the volatile memory of the current session. Once the source data container is closed or refreshed, the error state is discarded, ensuring that the system does not retain invalid attempt records.

4. The method of claim 1, wherein, The dependency check on the virtual pre-execution model is specifically configured to be performed without triggering a database write-ahead log (WAL) and without occupying a database connection lock resource, and includes: A completely isolated simulation execution context is constructed in the application layer memory; A global state snapshot of the server is loaded into the memory, and it is checked at the memory object level whether the control instruction set has cross-object resource competition or deadlock risk; The timing result of the simulation calculation business logic is verified to determine whether it violates the global clock constraint of the system; If any simulation step fails, the virtual pre-execution model is discarded and the memory resources are released, and any write request to the database storage engine is blocked.

5. The method of claim 1, wherein, After establishing a bidirectional data channel, state synchronization is achieved in the following way: A global state management context and a unified communication channel are initialized in the running environment of the source data container; The transaction unique identifier in the atomized interaction anchor object and the rendering handle of the discrete data block node are taken as a mapping pair and registered in the subscription list of the global state management context; When the unified communication channel receives a state change push message of the transaction execution object, the global state management context performs routing retrieval according to the transaction unique identifier and distributes instructions to drive the corresponding discrete data block node to update the visual rendering structure.

6. The method of claim 1, wherein, The data consistency control protocol includes any one of the following: local database transaction, distributed two-phase commit (2PC), compensating transaction (TCC), or Saga mode: Only when the write of the source pointer and the injection of the anchor object both return an acknowledgement signal, the global change is committed; If any operation times out or fails, compensation logic or rollback operation is performed, and the virtual model in the memory is destroyed.

7. The method of claim 1, wherein, It also includes a version backtracking mechanism based on the source pointer: When the state of the transaction execution object changes critically, the original discrete data block node is located through the source pointer; A snapshot operation is triggered for the discrete data block node, and the node content before the change is serialized and stored in the version history chain; The version hash value is recorded in the interaction anchor object to ensure that the transaction execution state and the context version of the source data container content are consistent.

8. The method of claim 1, wherein, The data analysis process includes: Parsing the attribute label of the discrete data block node to identify whether it contains heterogeneous data reference attributes; If it does, the attribute field of the external object is called through the microservice interface to generate a text block containing dynamic reference links; If it points to local description data, a preset syntax assembly rule is called to splice the entity data in the metadata field.

9. A method for dynamic permission fusing and transaction object security rendering based on environmental fingerprint, characterized in that, The following steps are included: When the client tries to instantiate a transaction object or render an existing interaction anchor object, the rendering request is intercepted and a security check process is started; Obtain the runtime environment parameters of the current operating terminal, and calculate a dynamic environment fingerprint based on multi-dimensional feature combination logic; the multi-dimensional feature combination at least includes network link features, physical device unique identification, and anti-replay random factors; Read the security policy configuration of the transaction object, and perform real-time comparison between the dynamic environment fingerprint and a preset security environment whitelist; Select a rendering strategy according to the comparison result: If the comparison is successful, a bidirectional real-time data channel is established with the server, the anchor object is rendered in a full-function interaction mode, and the user is allowed to directly perform read-write synchronization operations on the backend transaction through the anchor object; If the comparison fails or the environment fingerprint belongs to an unknown device, a permission fuse mechanism is triggered, a data flow interceptor is started at the client rendering pipeline level, the anchor object is rendered in a desensitization static mode or a locking mode, and the key business values are hidden and the interaction function is disabled.

10. The method of claim 9, wherein, The rendering of the anchor object in the desensitization static mode or the locking mode is implemented through a rendering pipeline interceptor, and the rendering pipeline interceptor is configured to perform the following operations: Before the rendering instruction of the anchor object is submitted to a graphics processing unit (GPU) or a document flow, a rendering context is captured through a proxy interceptor; The integrity of the original data stream in the memory is not modified, and only in the view drawing stage, the text nodes or graphic instructions containing sensitive data are replaced with a mask character generation function; The layout placeholder framework of the anchor object is retained, the size consistent with the full-function mode is maintained, and the host page is prevented from occurring reflow; All event listeners inside the anchor object are removed or disabled, and the response callback of the interaction button is directed to an empty function or a security warning pop-up window; A semi-transparent environment risk prompt mask is overlaid on the top layer of the view level of the anchor object, and the environment fingerprint dimension identifier causing the fuse is displayed on the mask layer.

11. The method of claim 9, wherein, In the step of calculating the dynamic environment fingerprint, a one-way hash algorithm containing a weight factor is used to generate a unique fingerprint string: Fingerprint = Hash( Combine( f1(Net_Seg), f2(Dev_ID), f3(Geo_Info), f4(Salt) ) ) Wherein, Hash is an encryption hash function, Net_Seg is a network IP segment feature, Dev_ID is a device physical address or a unique device identifier UDID, Geo_Info is a geographic location code, and Salt is a one-time random salt value based on a current time window; Combine is a preset feature splicing or weighted sum function, and f1 to f4 are corresponding feature extraction or weighted processing functions.

12. A transaction object instantiation and security rendering system, comprising: It comprises: A source data construction module for constructing a source data container containing discrete data block nodes, adapting to Web DOM, native view, and Canvas / WebGL graphic rendering engine; A virtual sandbox engine for constructing a transient virtual pre-execution model in the application layer memory space, and performing the logic simulation independent of the database storage engine as claimed in claim 1, and generating a transient error object when the simulation fails; An instantiation execution engine for creating a transaction execution object and performing atomic bi-directional anchor implantation upon passing the verification; A security control module for performing environment fingerprinting and dynamic permission circuit breaking as claimed in claim 9, including a render pipeline interceptor; A bi-directional communication module for maintaining publish-subscribe channels between discrete data chunk nodes and the transaction execution object, and responsible for pushing error states or update instructions.

Images