Business building method based on low code-free platform

Abstract

The invention relates to the technical field of computers, particularly provides a service building method based on a low-code-free platform, and aims at solving the technical problems that in an existing low-code platform, the coupling degree of a service process engine, a form engine and a rule engine is high, troubleshooting is difficult and the like. The method comprises the following steps: generating a unified metadata model through visual interface configuration, and defining a business process, a form, a business rule instance and an association relationship thereof in a structured mode; analyzing the model and converting the model into deployment configuration information which can be loaded by each engine according to a grammar mapping rule; a coordination rule for coordinating a multi-engine execution sequence and a data interface is automatically generated based on the incidence relation between the instances, and the coordination rule is integrated with deployment configuration information; and driving the corresponding engine to execute the service. According to the method, business and engine decoupling is realized through the unified metadata model, and pluggable replacement of the engine is supported; a collaboration rule is automatically generated through visualization, and the development threshold is reduced; and through unified time axis debugging, the operation and maintenance efficiency is improved.

Description

Technical Field

[0001] This application belongs to the field of computer science, and specifically relates to a business architecture method based on a low-code no-code platform. Background Technology

[0002] Low-code / no-code development platforms, by integrating core components such as process engines, form engines, and rule engines, enable business users to build applications visually, and have become an important tool for enterprise digital transformation. Currently, there are two main implementation methods: one is to have a fixed, deeply integrated engine built into the platform. Although a visual configuration interface is provided, the engines are tightly coupled with each other and with the platform, making replacement or upgrades difficult. The other method is to integrate multiple independent engines into the business system by directly writing code. While this offers flexible engine selection, it requires hard-coding the calling logic in the business code and handling complex data format conversions and communication coordination.

[0003] However, in the aforementioned existing technical solutions, the coupling between the engine and the platform or business code is too high, resulting in a rigid technology stack. Replacing or upgrading any engine requires modifying a large amount of underlying code, which is costly and risky. Secondly, the collaborative logic between the three engines of process, form, and rules needs to be manually coded by developers. Business personnel cannot directly participate or understand this, making it difficult to respond quickly to business changes. At the same time, when problems occur in the configured business logic, there is a lack of debugging tools from a business perspective. The troubleshooting process relies on technical personnel to check code logs, which is inefficient and has high communication costs.

[0004] Therefore, how to build a low-code, no-code platform that can both enable flexible and pluggable engines and allow business personnel to intuitively complete cross-engine collaborative configuration and debugging has become an urgent technical problem to be solved. Summary of the Invention

[0005] To address the aforementioned issues, this application provides a business setup method based on a low-code, no-code platform. This method offers the advantage that business or operations personnel can quickly locate cross-engine process blockages, rule conflicts, or data transmission failures without needing to delve into the code.

[0006] A method for building a business application based on a low-code no-code platform, the method includes: Configure through a visual operation interface to generate a unified metadata model. The unified metadata model defines business component instances and the relationships between multiple business component instances in a structured manner. Business component instances include at least business process instances, form instances, and business rule instances. Parse the unified metadata model and, according to the preset syntax mapping rules, convert each business component instance defined in the unified metadata model into deployment configuration information that can be loaded and executed by the business process engine, form engine, and rule engine. Based on the relationships between business component instances defined in the unified metadata model, collaborative rules are generated to coordinate the execution order and data interfaces between the business process engine, form engine, and rule engine, and these collaborative rules are then integrated with the deployment configuration information. The corresponding engine executes business based on the integrated deployment configuration information and collaborative rules; Collect runtime status events output by each engine during business execution, normalize the timestamps carried by each runtime status event, and then aggregate and display them on a unified visual timeline to support problem localization across engine execution logic.

[0007] The unified metadata model also defines the basic capability configurations of the low-code no-code platform in a structured manner.

[0008] Basic capability configuration includes at least one of the following models for configuring the non-functional capabilities of the system: authentication model, storage model, configuration model, plug-in model, cluster model, network model, and layout model.

[0009] Syntax mapping rules are rules corresponding to engine types, used to translate the logical description of business component instances into configuration syntax that the target engine can recognize.

[0010] Generate coordination rules for coordinating the execution order and data interfaces between engines, including: Based on the relationships between multiple business component instances, scripts or configuration files are generated to specify the process nodes that trigger rule execution, the rule calculation results that drive process jumps, or the mapping relationship between form data and process variables.

[0011] The process of collecting runtime status events from each engine and normalizing the timestamps includes: The system collects heterogeneous event streams from the business process engine, form engine, and rule engine, converts them into event data in a unified format, and aligns the timestamps of each event to the same time base based on a logical timing algorithm.

[0012] This application provides a low-code no-code platform for business development, the platform including a model management layer, a pluggable engine layer, a visual interaction layer, and a deployment execution layer; The model management layer is used to generate a unified metadata model; A pluggable engine layer, including a business process engine, form engine, and rules engine that can be deployed and replaced independently; The visual interaction layer includes a visual designer, a collaborative logic builder, and a runtime status diagnostic tool. Among them, the visual designer is used to provide a visual operation interface for users to configure business component instances and the relationships between component instances; the collaborative logic builder is used to generate collaborative rules based on the relationships in the unified metadata model; and the runtime status diagnostician is used to collect runtime status events of the pluggable engine layer, perform timestamp normalization processing, and aggregate and display them on the unified visual timeline.

[0013] The deployment execution layer connects to the model management layer and the visualization interaction layer, including the adaptation and conversion module and the rule integration and distribution module; The adaptation and conversion module is used to parse the unified metadata model and convert it into deployment configuration information according to the syntax mapping rules. The rule integration and distribution module is used to associate and integrate the collaborative rules with the deployment configuration information and drive execution.

[0014] This application also provides an electronic device, which includes at least one processor and at least one memory, the memory being data-connected to the processor, wherein the memory stores instructions that can be executed by at least one processor, the instructions being executed by at least one processor to enable at least one processor to perform the above-described method.

[0015] This application also provides a computer-storable medium storing computer instructions, which, when executed by a processor, specifically perform the steps of any of the methods described above.

[0016] This application also provides a computer program product, including computer instructions, which, when executed by a processor, specifically perform the steps of any of the methods described above.

[0017] Compared with the prior art, this application has the following advantages: To address the issues of high replacement costs and rigid technology stacks caused by excessive coupling between business process engines, form engines, and rule engines in existing low-code platforms, this invention uses a model management layer centered on a unified metadata model. This abstracts the visual configurations of business personnel into standardized descriptions that are independent of the engine, enabling specific business process engines, form engines, and rule engines to be plugged into the platform. When a particular engine needs to be replaced or upgraded, only the syntax mapping rules need to be adjusted through the adaptation and conversion module, without affecting the business logic itself defined by the unified metadata model. This decouples technical components from business logic, significantly reducing the technical risks and costs of system evolution.

[0018] The problem of cross-engine collaboration logic having to be manually coded by developers, resulting in business users being unable to participate and responding slowly to changes, can be solved by having business users perform drag-and-drop and association operations through a visual designer. These operations can be converted into standardized collaboration rules in real time and automatically integrated with deployment configuration information. This allows business intents to be directly translated into system execution logic, improving the speed and accuracy of delivering business requirements.

[0019] To address the problem of inefficiency and high communication costs associated with relying on technical personnel to manually review code logs for troubleshooting configuration errors, this invention achieves aggregated display on a unified visual timeline through timestamp normalization. This allows the execution trajectory of business logic and abnormal nodes to be presented in an intuitive graphical way, enabling business or operations personnel to quickly locate cross-engine process blockages, rule conflicts, or data transmission failures without delving into the code, thereby improving problem-solving efficiency.

[0020] Other features and advantages of this application will be set forth in the description which follows, and will be apparent in part from the description, or may be learned by practicing the application. The objectives and other advantages of this application may be realized and obtained by means of the structures pointed out in the description, claims and drawings. Attached Figure Description

[0021] To more clearly illustrate the technical solutions in the embodiments of this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0022] Figure 1 A flowchart according to an embodiment of this application is shown; Figure 2 A system block diagram according to an embodiment of this application is shown; Figure 3 A structural block diagram of a visual designer according to an embodiment of this application is shown. Detailed Implementation

[0023] To make the objectives, technical solutions, and advantages of the embodiments of this application clearer, the technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.

[0024] In existing technologies, low-code / no-code platforms typically build applications by integrating business process engines, form engines, and rule engines through built-in fixed methods or hard-coded methods. The engines in these solutions are too tightly coupled with the platform or business code, resulting in a rigid technology stack. Replacing or upgrading any engine requires modifying a large amount of underlying adaptation code, which is costly and risky. Secondly, the collaborative logic between processes, forms, and rules must be manually coded by developers, and business personnel cannot directly participate or understand it, making it difficult to respond quickly to business changes and resulting in obvious bottlenecks in development efficiency. Furthermore, when errors occur in the configured business logic, the troubleshooting process relies heavily on technical personnel to view isolated logs from different engines. There is a lack of unified debugging tools from a business perspective, leading to low efficiency in problem localization and high communication costs. In addition, traditional platforms often struggle to balance ease of use and scalability. No-code configuration modes are difficult to handle complex customization requirements, while open coding entry points increase system complexity and the barrier to entry.

[0025] To address the aforementioned issues, this application introduces a unified metadata model as the core hub, achieving complete decoupling between business logic and specific engine technologies. This allows the three engines to be flexibly replaced in a pluggable manner, significantly reducing system maintenance and technology evolution costs. Through a visual collaborative rule generator, cross-engine execution logic can be automatically generated based on intuitive association operations by business personnel, completely eliminating the era of manually writing collaborative code and improving the agility of business response. Simultaneously, by providing a full-link visual debugger based on a unified timeline, the runtime status of multiple engines is aggregated and presented, making the execution trajectory and fault points of business logic clear at a glance. This allows business personnel to participate in troubleshooting independently, revolutionizing the system operation and maintenance experience. Finally, through a layered and modular architecture, this solution provides powerful no-code configuration capabilities while reserving interfaces for standardized code extensions, achieving a perfect balance between ease of use and professional flexibility.

[0026] This application provides a business building method based on a low-code no-code platform. The core of this method is to use a unified, structured data model (unified metadata model) as the hub of the entire system to decouple and coordinate the visual design intentions of business personnel with the underlying heterogeneous, pluggable business execution engine.

[0027] Please see Figure 2 Specifically, the low-code no-code platform used in this application to implement the above method includes a model management layer, a visualization interaction layer, a deployment execution layer, and a pluggable engine layer.

[0028] The model management layer is the data hub of the platform, responsible for the generation, persistence management and version control of unified metadata models. Its role is to precipitate all business designs and technical configurations into a standardized and reusable digital asset.

[0029] The visual interaction layer is the main working interface for business personnel. It includes a visual designer, a collaboration logic builder, a runtime status diagnostic tool, and a deployment execution layer. The visual designer provides a drag-and-drop configuration environment, allowing users to intuitively define business component instances and their relationships. The collaboration logic builder automatically transforms user-defined relationships into executable collaboration rules. The runtime status diagnostic tool provides the aforementioned unified timeline debugging interface, converting the complex runtime status of the underlying engine into visual information understandable to business personnel. For details, please refer to [link to relevant documentation]. Figure 3 The visual designer may include a rule designer for defining business decision logic, a form designer for building user interaction interfaces, a process designer for orchestrating workflow steps, and a model designer for configuring system-level parameters. All user operations at this layer are designed to define business components and their relationships.

[0030] The deployment and execution layer, through its internal adaptation and conversion module, converts the unified metadata model in the model management layer into deployment configuration information for specific engines based on syntax mapping rules. Then, through the rule integration and distribution module, it merges the collaborative rules generated by the visualization interaction layer with the deployment configuration information to generate the final execution instruction set, which is then accurately distributed to the corresponding engine instances in the lower layer. Specifically, engine instances may include authentication models, storage models, configuration models, plugin models, cluster models, network models, and layout models. The existence of this layer ensures that the upper-layer abstract model can drive the lower-layer specific technical components without loss and with high efficiency.

[0031] The pluggable engine layer consists of a business process engine, a form engine, and a rules engine that can be independently deployed, upgraded, and replaced. These engines interface with the deployment execution layer through standardized interfaces, allowing the platform to flexibly select or replace applicable technical components without refactoring the upper-layer business logic.

[0032] Those skilled in the art will understand that before business personnel begin building the application, the platform can be in a ready state. This state can be achieved through an optional platform initialization step, such as having operations and maintenance personnel configure basic capabilities like database connections, network policies, and cluster parameters through a separate management interface and complete instantiation. This step provides a stable operating environment for subsequent business construction, but it is not a necessary technical feature for implementing the core business construction method of this invention.

[0033] Please see Figure 1 Based on the aforementioned platform, the method steps of this application are as follows: S1. Generate a unified metadata model through visual configuration.

[0034] Business personnel operate through the platform's top-level low-code configuration layer, which provides visual tools such as rule designers, form designers, process designers, and model designers. Users can use these designers to drag and drop, connect lines, and configure parameters to define specific business processes, form interfaces, business rules, and system-level basic capability models.

[0035] All design operations do not directly generate code or engine configurations, but are submitted in real time and integrated into the system's unified metadata center. This center generates and persists a unified metadata model, which fully defines various business component instances (including at least one business process instance, one form instance, and one business rule instance) and their logical relationships in a structured data format. It also includes the configuration of basic capability models such as authentication, storage, and network, achieving source decoupling between business logic and technical implementation.

[0036] In addition, this unified metadata model can also be extended to define the basic capability configuration required for the entire platform to run, such as an authentication model for permission management, a storage model for defining data storage strategies, a configuration model for managing system parameters, a plug-in model that supports hot-swappable functions, a cluster model that ensures high availability, a network model for managing communication, and a layout model for customizing the interface, thereby achieving unified and visual configuration of the system's non-functional requirements.

[0037] S2. Parse the unified metadata model and convert it into engine-specific deployment configuration information.

[0038] like Figure 1 As shown, the lower layer of the unified metadata center is the adapter plug-in bus, which is the core scheduling and translation hub of the platform.

[0039] The bus retrieves a unified metadata model from a unified metadata center and performs two key functions: First, the parts of the model concerning the system's basic capabilities are distributed and instantiated into specific authentication models, storage models, configuration models, plug-in models, cluster models, network models, and layout models, thereby building the technical foundation required for the platform's operation.

[0040] Secondly, based on preset syntax mapping rules corresponding to the target engine type, the instances of each business component defined in the model are translated into deployment configuration information that can be loaded and executed by the underlying specific engines. For example, process instances are converted into BPMN files, and rule instances are converted into specific scripts. This process is completed through standardized interfaces on the bus, which is the key to achieving pluggable engines, allowing any engine with a compatible interface to connect.

[0041] This conversion, along with the driver layer's built-in version and canary release management mechanism, supports second-level switching of engine configurations. Engine instances are hot-swapped through dynamic package loading and reflection instantiation, enabling algorithm or engine replacement without downtime.

[0042] S3. Generate and integrate cross-engine collaborative rules based on model relationships.

[0043] The collaborative logic builder proactively analyzes the relationships between defined business component instances in the unified metadata model and automatically generates collaborative rules to coordinate the execution order and data interfaces between the business process engine, form engine, and rule engine. These rules specify refined collaborative logic such as triggering process instance creation when a form submission event occurs, calling a rule to perform calculations when the process reaches a specific gateway node and determining the flow direction based on the result, and automatically mapping the value of a field in the form to a process variable. After generating the rules, the rule integration and distribution module intelligently associates and packages the above collaborative rule engine deployment configuration information to form a complete and deliverable business deployment package.

[0044] This step transforms the complex and error-prone cross-engine call and data transfer logic, which traditionally required developers to manually write code, into standard components automatically generated by the system based on visual design. This eliminates coding bottlenecks in business collaboration and ensures that business intent is accurately implemented at the technical execution layer.

[0045] S4 drives the pluggable engine layer to execute business logic.

[0046] The deployment execution layer precisely distributes the final integrated business deployment package from the S3 steps to the corresponding pluggable engine containers in the lower layers. Upon receiving their respective configuration instructions and collaboration rules, the business process engine, form engine, and rule engine are initialized and started sequentially, coordinating to execute business processes. When a user fills out and submits a form on the front end, the form engine processes the data and triggers the process engine to create a new instance based on the collaboration rules. During the workflow process, the process engine calls the rule engine to make decisions at preset nodes. The rule engine returns results, guiding the process engine to the next hop. The entire execution process is uniformly scheduled and monitored by the platform, ensuring the orderly and reliable operation of cross-engine business flows. This architecture allows any engine to be replaced by other implementations with compatible interfaces without affecting the upper-layer business model, giving the system extremely strong technical evolution flexibility and vendor selection freedom.

[0047] S5 enables visual debugging and problem localization of cross-engine execution logic.

[0048] During business operations, the runtime status diagnostic tool collects runtime status events in real time from the business process engine, form engine, and rule engine, which are typically in various formats, such as process node arrival, rule trigger hit, and form field validation failure.

[0049] Subsequently, the diagnostic tool normalizes the timestamps carried by the above events and aggregates all events on a visual timeline based on a unified time base, enabling business personnel or operations personnel to clearly see the complete lifecycle and execution path of a business request across the three engines.

[0050] When process bottlenecks, rules not being triggered, or data transmission errors occur, the problem points can be directly highlighted on the timeline, and the context state snapshots of each engine at that time can be viewed in conjunction with them. This feature reduces the difficulty and cost of cross-system debugging, which originally required searching through countless system logs, and achieves business-level observability.

[0051] This application also provides an electronic device, including at least one processor and at least one memory, the memory storing instructions executable by the at least one processor, the instructions being executed by the at least one processor to enable the at least one processor to perform the business setup method based on a low-code platform as described above.

[0052] This application also provides a computer-readable storage medium storing computer instructions, which, when executed by a processor, specifically perform the steps of the method described in any of the preceding claims.

[0053] This application also provides a computer program product, including computer instructions, which, when executed by a processor, specifically perform the steps of the method described in any of the preceding claims.

[0054] Although this application has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features; and these modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of this application.

Claims

1. A method for building a business application based on a low-code no-code platform, characterized in that, The method includes: The unified metadata model is generated through a visual operation interface. The unified metadata model defines business component instances and the relationships between multiple business component instances in a structured manner. The business component instances include at least business process instances, form instances, and business rule instances. The unified metadata model is parsed, and each business component instance defined in the unified metadata model is converted into deployment configuration information that can be loaded and executed by the business process engine, form engine and rule engine according to the preset syntax mapping rules. Based on the association relationships between business component instances defined in the unified metadata model, collaborative rules are generated to coordinate the execution order and data interfaces between the business process engine, form engine, and rule engine, and these collaborative rules are then associated and integrated with the deployment configuration information. Based on the integrated deployment configuration information and collaborative rules, the corresponding engine is driven to execute business operations. Collect runtime status events output by each engine during business execution, normalize the timestamps carried by each runtime status event, and then aggregate and display them on a unified visual timeline to support problem localization across engine execution logic.

2. The method according to claim 1, characterized in that, The unified metadata model also defines the basic capability configuration of the low-code no-code platform in a structured manner.

3. The method according to claim 2, characterized in that, The basic capability configuration includes at least one of the following models for configuring the non-functional capabilities of the system: authentication model, storage model, configuration model, plug-in model, cluster model, network model, and layout model.

4. The method according to claim 1, characterized in that, The syntax mapping rules are rules corresponding to the engine type, used to translate the logical description of the business component instance into a configuration syntax that the target engine can recognize.

5. The method according to claim 1, characterized in that, Generate coordination rules for coordinating the execution order and data interfaces between engines, including: Based on the relationships between multiple business component instances, generate specified process nodes to trigger rule execution; Configuration files that drive process transitions and / or map relationships between form data and process variables based on rule calculation results.

6. The method according to claim 1, characterized in that, The process of collecting the running status events of each engine and normalizing the timestamps includes: Heterogeneous event streams are collected from the business process engine, form engine, and rule engine, converted into event data in a unified format, and the timestamps of each event are aligned to the same time base based on a logical timing algorithm.

7. A low-code no-code platform for business development, characterized in that, The platform includes a model management layer, a pluggable engine layer, a visualization and interaction layer, and a deployment and execution layer; The model management layer is used to generate a unified metadata model; A pluggable engine layer, including a business process engine, form engine, and rules engine that can be deployed and replaced independently; The visual interaction layer includes a visual designer, a collaborative logic builder, and a runtime status diagnostic tool. The visual designer provides the visual operation interface for users to configure business component instances and the relationships between them. The collaborative logic builder generates the collaborative rules based on the relationships in the unified metadata model. The runtime status diagnosticer collects runtime status events of the pluggable engine layer, performs timestamp normalization processing, and aggregates and displays them on the unified visual timeline. The deployment execution layer, which is connected to the model management layer and the visualization interaction layer, includes an adaptation and conversion module and a rule integration and distribution module; The adaptation and conversion module is used to parse the unified metadata model and convert it into deployment configuration information according to the syntax mapping rules. The rule integration and distribution module is used to associate and integrate the collaborative rules with the deployment configuration information and drive execution.

8. An electronic device, characterized in that, The electronic device includes at least one processor and at least one memory, the memory being data-connected to the processor, wherein the memory stores instructions executable by the at least one processor, the instructions being executed by the at least one processor to enable the at least one processor to perform the method of any one of claims 1-6.

9. A computer-storable medium, characterized in that, The storable medium stores computer instructions, which, when executed by a processor, specifically perform the steps of the method as described in any one of claims 1-6.

10. A computer program product comprising computer instructions, characterized in that, When the computer instructions are executed by the processor, they specifically perform the steps in the method as described in any one of claims 1-6.

Images