A software development method and system based on a low-code platform

Abstract

This invention relates to the field of software development and automated programming technology, specifically a software development method and system based on a low-code platform. The method includes: constructing a process meta-model containing extended nodes such as transaction boundary nodes and asynchronous callback nodes through a visual designer; parsing this model into a platform-independent extended colored Petri net intermediate representation using a semantic parsing engine; compiling this intermediate representation into complete executable source code of the target technology stack using a layered code generator, wherein high-quality chained call code is generated for special structures such as asynchronous callback nodes; and establishing and maintaining a bidirectional index mapping relationship between meta-model nodes and source code abstract syntax tree nodes, thereby achieving bidirectional synchronous updates between the model and the code. This invention solves the problems of existing low-code platforms being unable to visually define complex enterprise-level logic and the disconnect between models and code, achieving end-to-end support and sustainable evolution from visual design to deployable code.

Description

Technical Field

[0001] This invention relates to the field of software development and automated programming technology, specifically to a software development method and system based on a low-code platform. Background Technology

[0002] Low-code development platforms aim to lower the barrier to application development and improve delivery efficiency through visual drag-and-drop and configuration. However, existing low-code platforms are mainly geared towards simple form-driven applications (such as CRUD operations and simple approval workflows), and have significant shortcomings when dealing with enterprise-level core systems (such as e-commerce transactions and financial payments), specifically:

[0003] First, there is a lack of support for distributed transactions. Enterprise-level business logic typically involves data consistency operations across multiple microservices or databases. Existing mainstream low-code platforms (such as OutSystems and Mendix) can usually only generate code for single-database transactions, and cannot define and manage the boundaries and compensation logic (such as TCC and Saga patterns) of distributed transactions at a visual level. Developers must write complex transaction coordination and rollback code manually, leaving the platform's output as only a "semi-finished product" that cannot be directly deployed and run, severely negating the efficiency advantages of low-code.

[0004] Secondly, the existing platform's graphical components are poor at expressing complex control flows. For business scenarios involving multiple nested loops, parallel branches, and asynchronous callback combinations (e.g., in batch order processing, each order needs to call multiple external services in parallel and wait for results asynchronously), the existing platform's graphical components either cannot model such complex logic or generate code with a messy structure and poor readability (e.g., creating a difficult-to-maintain "callback hell"), failing to meet the requirements of enterprise-level applications for code quality and maintainability.

[0005] Finally, the model and code are severely disconnected and cannot be synchronized bidirectionally. Traditional low-code platforms or code generators often adopt a "one-time generation" model. Once developers manually optimize or modify the generated code, the corresponding visual model becomes invalid. Subsequent maintenance and iteration can only directly access the source code, completely losing the core value of low-code visual design. Although some platforms attempt reverse engineering, they can usually only restore the page UI structure and cannot accurately reconstruct complex business logic models, resulting in an irreversible divergence between the model and code.

[0006] Therefore, there is an urgent need in this field for an innovative low-code development solution that can not only visually orchestrate complex enterprise-level business logic and generate high-quality, directly executable code, but also maintain real-time, accurate, and bidirectional synchronization between the design model and the underlying code throughout the entire development and maintenance process. Summary of the Invention

[0007] The purpose of this invention is to provide a software development method and system based on a low-code platform to solve the problems mentioned in the background art.

[0008] In a first aspect, the present invention provides a software development method based on a low-code platform, comprising the following steps:

[0009] The system receives user input through a visual designer and builds an extended process meta-model of the business process, which includes extended nodes for defining enterprise-level business logic. The extended nodes include at least: transaction boundary nodes for defining distributed transaction boundaries and asynchronous callback nodes for defining asynchronous calls and processing.

[0010] The semantic parsing engine parses the extended process metamodel into a platform-independent extended colored Petri net intermediate representation; wherein, the asynchronous callback node is parsed into a subnet structure in the extended colored Petri net consisting of a trigger transition, a callback waiting library, and a callback processing transition;

[0011] The layered code generator performs layered compilation based on the intermediate representation of the extended colored Petri net to generate complete executable source code for the target technology stack; wherein, the compilation of the asynchronous callback node subnet generates chained call code based on asynchronous programming primitives;

[0012] Establish and maintain a bidirectional index mapping relationship between nodes in the extended process meta-model and nodes in the abstract syntax tree of the generated source code, and realize bidirectional synchronous updates between the extended process meta-model and the source code based on the mapping relationship.

[0013] Furthermore, the extended node also includes a loop structure node for defining the iteration logic; the semantic parsing engine parses the loop structure node into a loop control structure in the extended colored Petri net.

[0014] Furthermore, the transaction boundary node includes a transaction start node and a transaction end node; the semantic parsing engine parses the transaction start node and transaction end node into a pair of special transitions in the extended colored Petri net, namely the transaction start transition and the transaction end transition, and the network area between them is marked as the transaction protected area, and the tokens flowing through this area are appended with a transaction context identifier.

[0015] Furthermore, the layered code generator performs layered compilation by: identifying the protected area of ​​the transaction, adding distributed transaction management annotations to the corresponding methods in the generated source code, and generating corresponding transaction rollback or compensation logic framework code.

[0016] Furthermore, the bidirectional synchronous update based on the mapping relationship includes:

[0017] When a change is detected in the extended process metamodel, the affected source code location is located through the bidirectional index mapping relationship, and the source code is locally incrementally updated while retaining existing manual modifications in the source code that conform to preset specifications.

[0018] When a change is detected in the source code, the abstract syntax tree of the changed source code is parsed, the affected extended process metamodel element is located by comparing differences and the bidirectional index mapping relationship, and the element's attributes are updated or a prompt is given in the visual designer.

[0019] Secondly, the present invention provides a software development system based on a low-code platform for implementing the above method, comprising:

[0020] A visual designer that provides an interface for building and editing extended process metamodels that include transaction boundary nodes and asynchronous callback nodes;

[0021] A semantic parsing engine, connected to the visual designer, is used to convert the extended process metamodel into an extended colored Petri net intermediate representation;

[0022] A layered code generator, connected to the semantic parsing engine, is used to compile the intermediate representation into complete executable source code;

[0023] A bidirectional synchronization engine connects the visual designer and the source code repository respectively, and is used to maintain a bidirectional index mapping between the metamodel and the source code, and drive the collaborative changes of the two.

[0024] Compared with the prior art, the beneficial effects achieved by the present invention are:

[0025] By introducing extended meta-models such as transaction boundary nodes and asynchronous callback nodes, developers can directly define complex enterprise-level logic such as distributed transactions and asynchronous calls at the visual level. Based on formalized extended colored Petri net intermediate representations and layered compilation technology, it can generate high-quality, clearly structured (e.g., avoiding callback hell) target code that can be directly deployed and run, greatly improving the ability of low-code platforms to handle core business logic.

[0026] By establishing and maintaining a bidirectional index mapping between extended process metamodel nodes and source code abstract syntax tree nodes, the pain point of traditional low-code platforms—where the "model-code" relationship is severed once manually modified—is fundamentally solved. It supports local incremental updates from model changes to code (retaining manual code), as well as automatic synchronization and suggestions from code modifications to the model, ensuring the continuous effectiveness of visual design throughout the software lifecycle and protecting the investment value of low-code.

[0027] Visually defining distributed transaction boundaries and automatically generating transaction management code lowers the barrier to entry and reduces the error rate for developers manually writing complex transaction logic. Compiling graphical business logic into standard asynchronous programming paradigm code improves the readability and maintainability of the generated code. A two-way synchronization mechanism enables seamless collaboration between graphical design and code development modes, adapting to the needs of scenarios with varying complexity, and ultimately improving the efficiency of software delivery and iteration. Attached Figure Description

[0028] The accompanying drawings are provided to further illustrate the invention and form part of the specification. They are used in conjunction with embodiments of the invention to explain the invention and do not constitute a limitation thereof. In the drawings:

[0029] Figure 1 This is an architecture diagram of the software development system based on a low-code platform according to the present invention;

[0030] Figure 2 This is an example diagram of the extended process meta-model of the present invention;

[0031] Figure 3 This is a schematic diagram of the layered code generation process of the present invention;

[0032] Figure 4 This is a flowchart of the bidirectional synchronization mechanism of the present invention. Detailed Implementation

[0033] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0034] This invention provides a software development method based on a low-code platform, comprising the following steps:

[0035] S1. Constructing an Extended Process Metamodel: Using a visual designer, the system receives user drag-and-drop and configuration operations to construct a process metamodel representing the business logic. This metamodel defines three core extended node types above the basic control flow nodes (sequence, branch):

[0036] Transaction boundary node: Used to define the scope of a distributed transaction, including the transaction start node and the transaction end node. Its attributes include transaction mode and timeout policy.

[0037] Loop structure nodes: used to define iteration logic, including For loop, ForEach loop and While loop nodes, whose attributes include iteration variables, set expressions or loop conditions.

[0038] Asynchronous callback node: Used to define asynchronous calls and callback processing. Its node attributes include the asynchronous call target and the definition of the callback sub-process.

[0039] S2. Generate an Extended Colored Petri Net Intermediate Representation: The semantic parsing engine parses the process metamodel and generates a platform-independent extended colored Petri net as an intermediate representation. This intermediate representation maps metamodel nodes to Petri net transitions, maps execution states or data waiting points to places, and uses tokens carrying data structures to flow within the net to represent data flow. The key extension is:

[0040] The transaction boundary node is mapped to a special pair of TX_BEGIN and TX_END transitions. The places and transitions in between form a protected area, and tokens flowing through this area are appended with a global transaction identifier.

[0041] The asynchronous callback node is mapped as a subnet structure consisting of "trigger transition", "callback waiting place" and "callback processing transition", which accurately describes the causal relationship between asynchronous call and response.

[0042] The cyclic structure nodes are mapped to the cyclic control structure in Petri nets, and iterative semantics are formed through transitions and connections between places.

[0043] S3. Perform layered compilation and code generation: The code generator receives the extended colored Petri net intermediate representation and compiles it layer by layer into the source code of the target technology stack according to the following three layers:

[0044] Flow control layer: Traverses the control flow of the intermediate representation, and translates the sequential, branching, looping and asynchronous callback subnet structures into synchronous / asynchronous control statements (such as for loops and CompletableFuture chained calls) in the target language (such as Java) to achieve logic flattening and avoid callback nesting.

[0045] Transaction Aspect Layer: Identifies the transaction-protected regions (TX_BEGIN to TX_END) in the intermediate representation, automatically adds distributed transaction annotations (such as @GlobalTransactional) to the corresponding methods in the generated code, and injects the logic framework for transaction confirmation, rollback, or compensation.

[0046] Data binding layer: Based on the token's color set (data structure) definition, it generates the corresponding data entity class, interface contract (such as FeignClient), and object mapping converter code.

[0047] S4. Establish and maintain a bidirectional AST synchronization mechanism: Build and maintain a bidirectional index mapping table that precisely associates each node in the process metamodel with a specific node position in the abstract syntax tree of the generated code.

[0048] Forward synchronization (model⟶code): When the metamodel changes, the corresponding node in the AST is located through the mapping table, and the code block is replaced or refactored within a minimal scope, while retaining the code manually added by the developer that conforms to the preset specifications.

[0049] Reverse synchronization (code⟶model): When the source code file is detected to have been modified, its AST is parsed, the affected metamodel elements are located by comparing differences with the mapping table, and the corresponding node attributes or structures in the visual model are automatically updated, while providing visual prompts in the designer.

[0050] S5. Synchronization Conflict Handling and Intelligent Merging Strategy: To ensure the robustness of bidirectional synchronization, the system adopts the following strategy:

[0051] Change type identification: The engine identifies the type of code change, such as adding statements inside the mapping node (e.g., adding logs), modifying expressions, deleting statements, or modifying the signature of methods created by the generator.

[0052] Preset specification protection: For code manually added by developers that conforms to preset specifications (e.g., within code blocks marked with specific annotations, or private methods that follow specific naming patterns), the engine will strictly preserve these code blocks when performing "Model⟶Code" synchronization.

[0053] Conflict Detection and Alerts: When a semantic conflict is detected between manually modified code and the logic expressed by the model (e.g., manually deleting a service call defined in the model, or modifying the scope of a transaction boundary), the engine cannot resolve it automatically. In this case, the bidirectional synchronization engine will not forcibly overwrite the code, but will highlight the corresponding model node in the visual designer, issue a conflict warning to the developer, and provide a difference comparison view. The developer then decides whether to update the code based on the model or adjust the model based on the code, thereby completing the synchronization.

[0054] This invention provides a software development system based on a low-code platform, comprising:

[0055] Visual Designer: Provides a graphical interface for building and editing process meta-models that include the extended node types.

[0056] Semantic parsing engine: Connected to the designer, it is used to parse the process metamodel into an extended colored Petri net intermediate representation.

[0057] Layered code generator: Connected to the semantic parsing engine, it is used to compile the intermediate representation into complete project source code of the target technology stack that can be directly compiled and run.

[0058] Bidirectional synchronization engine: Connects the visual designer and the source code project respectively, and is used to maintain the bidirectional index mapping between the model and the code, and drive the collaborative changes of both.

[0059] Deployment and runtime containers: used to compile, package, and deploy the generated source code project.

[0060] Example 1: Bulk Order Refund Process

[0061] This embodiment uses a typical enterprise-level business scenario of "bulk order refunds" as an example to illustrate the implementation process of the present invention. The business logic requires: traversing the refund application list, freezing funds and updating the order status for each application in a distributed transaction, and asynchronously sending messages and processing callbacks after the transaction succeeds.

[0062] Step S1: Construct an extended process metamodel

[0063] Developers drag and drop components in the visual designer to build the process model: First, drag in a ForEach loop node and configure its collection variable as refundList. Within the loop, drag and configure the following nodes in sequence: a transaction start node (transaction mode TCC selected); a service call node (calling the AccountService.freezeFund() method); a service call node (calling the OrderService.markRefunding() method); a transaction end node; and an asynchronous callback node (configured with its "call operation" to send a message to RocketMQ's REFUND_TOPIC, and its "callback sub-process" as a log recording node).

[0064] Step S2: Generate the intermediate representation of the extended shaded Petri net

[0065] The semantic parsing engine parses the above model into an extended colored Petri net intermediate representation. The entire ForEach loop is mapped to a loop transition and its corresponding place structure; the start and end nodes of a transaction are mapped to TX_BEGIN and TX_END transitions, respectively, and the calling nodes between them become a sequence of transitions protected by the transaction boundary; the asynchronous callback node is mapped to a subnet consisting of a trigger transition SendToMQ, a waiting place WaitForCallback, and a callback transition LogResult.

[0066] Step S3: Layered Compilation and Code Generation

[0067] The code generator targets Java 11, Spring Boot, Seata, and RocketMQ stacks, compiling intermediate representations. In the flow control layer, it generates a `batchRefund` method containing a for loop. Service calls within the loop are translated into synchronous code, and asynchronous callback subnets are translated into chained calls of `CompletableFuture.runAsync(...).thenRun(...)`. In the transaction aspect layer, it identifies transactional regions and automatically adds the `@GlobalTransactional` annotation to the `batchRefund` method. In the data binding layer, it generates classes such as `RefundRequestDTO` and `AccountServiceClient` based on the data structure. Finally, it generates a complete, runnable Maven project.

[0068] Steps S4 and S5: Example of bidirectional synchronization

[0069] Suppose a developer manually adds a debug log line `log.info("Processing order:{}",item.getOrderId());` within a `for` loop in the generated `BatchRefundService.java` file, after transaction commit and before asynchronous sending. The bidirectional synchronization engine detects the file change, parses its AST, and, by comparing differences and querying the bidirectional index mapping table, locates the code position corresponding to a specific location within the `ForEach` loop in the visual model. The engine then automatically inserts a "log" node at the corresponding location in the visual model, configuring its `message` attribute to `"Processing order:{item.orderId}"`. When the developer reopens the designer, the log node is displayed on the canvas, achieving automatic synchronization between code and model. If the developer manually deletes a service call node defined by the model, the engine will detect this semantic conflict and highlight a warning in the designer, awaiting the developer's decision.

[0070] Example 2: Flash Sale Inventory Deduction and Compensation Process

[0071] This example demonstrates support for complex compensation logic (Saga pattern). The process is as follows: deduct inventory → create an order → if order creation fails, compensate (increase) inventory.

[0072] During modeling, developers drag and drop the transaction start node (selecting the Saga mode), the deduct inventory service node, the create order service node, and the transaction end node. They also configure the create order node's "failure compensation operation" to call the add inventory service.

[0073] During code generation, the system automatically generates the call registration logic (registered to the transaction context) for the compensation method (i.e., increasing inventory) at the order creation service call site, in addition to the normal call logic. When order creation fails, the distributed transaction framework will automatically trigger the compensation (i.e., increasing inventory) for the previously successful inventory deduction operation.

[0074] In a two-way synchronization scenario, if the developer modifies the compensation logic in the code (such as adding logs during compensation), the two-way synchronization engine can reverse-synchronize this change to the "compensation operation" configuration item of the corresponding node in the visualization model, or prompt the user when a conflict is detected.

[0075] Finally, it should be noted that the above descriptions are merely preferred embodiments of the present invention and are not intended to limit the present invention. Although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art can still modify the technical solutions described in the foregoing embodiments or make equivalent substitutions for some of the technical features. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the protection scope of the present invention.

Claims

1. A software development method based on a low-code platform, characterized in that, Includes the following steps: The system receives user input through a visual designer and builds an extended process meta-model of the business process, which includes extended nodes for defining enterprise-level business logic. The extended nodes include at least: transaction boundary nodes for defining distributed transaction boundaries and asynchronous callback nodes for defining asynchronous calls and processing. The semantic parsing engine parses the extended process metamodel into a platform-independent extended colored Petri net intermediate representation; wherein, the asynchronous callback node is parsed into a subnet structure in the extended colored Petri net consisting of a trigger transition, a callback waiting library, and a callback processing transition; The layered code generator performs layered compilation based on the intermediate representation of the extended colored Petri net to generate complete executable source code for the target technology stack; wherein, the compilation of the asynchronous callback node subnet generates chained call code based on asynchronous programming primitives; Establish and maintain a bidirectional index mapping relationship between nodes in the extended process meta-model and nodes in the abstract syntax tree of the generated source code, and realize bidirectional synchronous updates between the extended process meta-model and the source code based on the mapping relationship.

2. The software development method based on a low-code platform according to claim 1, characterized in that, The extended nodes also include loop structure nodes for defining iteration logic; the semantic parsing engine parses the loop structure nodes into loop control structures in the extended colored Petri net.

3. The software development method based on a low-code platform according to claim 1, characterized in that, The transaction boundary nodes include transaction start nodes and transaction end nodes; the semantic parsing engine parses the transaction start nodes and transaction end nodes into a pair of special transitions in the extended colored Petri net, namely the transaction start transition and the transaction end transition, and the network area between them is marked as the transaction protected area, and the tokens flowing through this area are attached with transaction context identifiers.

4. The software development method based on a low-code platform according to claim 3, characterized in that, The layered code generator performs layered compilation by: identifying the protected area of ​​the transaction, adding distributed transaction management annotations to the corresponding methods in the generated source code, and generating the corresponding transaction rollback or compensation logic framework code.

5. The software development method based on a low-code platform according to claim 1, characterized in that, The bidirectional synchronous update based on the mapping relationship includes: When a change is detected in the extended process metamodel, the affected source code location is located through the bidirectional index mapping relationship, and the source code is locally incrementally updated while retaining existing manual modifications in the source code that conform to preset specifications. When a change is detected in the source code, the abstract syntax tree of the changed source code is parsed, the affected extended process metamodel element is located by comparing differences and the bidirectional index mapping relationship, and the element's attributes are updated or a prompt is given in the visual designer.

6. A software development system based on a low-code platform that implements the method as described in any one of claims 1-5, characterized in that, include: A visual designer that provides an interface for building and editing extended process metamodels that include transaction boundary nodes and asynchronous callback nodes; A semantic parsing engine, connected to the visual designer, is used to convert the extended process metamodel into an extended colored Petri net intermediate representation; A layered code generator, connected to the semantic parsing engine, is used to compile the intermediate representation into complete executable source code; A bidirectional synchronization engine connects the visual designer and the source code repository respectively, and is used to maintain a bidirectional index mapping between the metamodel and the source code, and drive the collaborative changes of the two.

Images