A method and system for assembling a visual assembly business functional unit

Abstract

The present invention belongs to the technical field of software data processing, and discloses a method and system for assembling a visual assembly business function unit. The method includes: process design, interface command arrangement, view binding, and completing the assembly of a visual assembly business function unit system. The present invention directly completes the assembly and management of business units through a graphical interface, which greatly reduces the difficulty of understanding and operation. With the help of this intuitive design, even business personnel with non-technical backgrounds can easily participate in the customization and adjustment of business units. In the present invention, the technical architecture and implementation mechanism of the tool are deeply analyzed, and it is explained that by simplifying the assembly process of business units, the maintainability and scalability of the software system are effectively improved.

Description

Technical Field

[0001] The invention belongs to the technical field of software data processing, and in particular relates to an assembly method and system for a visual assembly business functional unit. Background Art

[0002] In digital transformation, software systems have become an important force driving enterprise development. These systems are often composed of many business functional units, each of which carries a specific business process or function, and together builds a complex and sophisticated business network. In the traditional software development process, the customization and adjustment of business functional units usually require highly professional coding skills, which not only limits the direct participation of business personnel, but also increases the maintenance cost and response cycle of the system. Especially when the business logic is frequently adjusted, the scalability and maintainability of the system become bottlenecks.

[0003] Through the above analysis, the problems and defects of the existing technology are as follows: the traditional software development process has high technical barriers, which limits the participation of non-technical personnel; the development cycle is long, and manual coding makes the entire process from demand analysis to online launch time-consuming; the error rate is high, and complex logic is prone to errors and difficult to debug; maintenance is complex, and modifying one part of the system after it is huge may affect the overall situation; poor flexibility makes it difficult to quickly respond to changes in market demand. Summary of the invention

[0004] In order to overcome the problems existing in the related art, the disclosed embodiment of the present invention provides an assembly method and system for visually assembling a business functional unit, and specifically relates to a tool for visually assembling a functional module.

[0005] The technical solution is as follows: A method for assembling a visual assembly business function unit comprises:

[0006] S1, process design: Provides a process design environment through a graphical interface divided into three areas, and completes the dynamic construction and management of process definitions through the front-end and back-end interaction mechanism; the three areas include: process node area, node attribute bar, and process canvas;

[0007] S2, interface command arrangement: all interface commands are displayed in a list format in the interface command assembly component library display area, and each list item includes the name, description, dependency, configuration, and usage status information of the interface command; the interface command selected by the user is displayed in the selected area of ​​the interface command assembly page, and an editing function is provided to modify the relevant properties of the interface command;

[0008] S3, view binding: List all available nodes through the view node area contained in the view binding page, and build the interface layout through the view canvas; display and allow editing of detailed properties of a node on the selected canvas through the node property bar;

[0009] S4, complete the visual assembly of business function units.

[0010] In step S1, the process node area is used to display various types of process nodes in the form of icons;

[0011] The node property bar is used to edit the properties of the selected node and store the properties in a JSON object;

[0012] The process canvas is used to place and connect various process nodes.

[0013] Further, the process nodes include:

[0014] Start node: used to start the entire process instance. The attribute information of the start node includes: the custom business logic triggered by the start of the process, the start node code, and the node set that triggers the start node;

[0015] Task node: Execute different tasks according to specific needs. The attribute information of the task node includes: custom business logic, permission values ​​that need to be matched, target activity list, waiting task conditions, task start automatic command, task end automatic command, and runtime parameters;

[0016] Activity node: implements the process control flow function according to the BPMN2 standard. The attribute information of the activity node includes: implementation method, custom business rules, interface parameter converter, business rule script file, parameter conversion script, runtime parameters, and target task set;

[0017] End node: represents the completion of the process. The attribute information of the end node includes: the business logic executed at the end of the process and the process end code.

[0018] In step S1, the process design includes:

[0019] Step 1, initialize the interface and data model: use the front-end framework to create a blank canvas area for users to operate; initialize an empty data model to save all status information of the process;

[0020] Step 2, Interaction monitoring: Use the event system to monitor the user's interaction events. When dragging a node onto the canvas, the position information is captured by monitoring the event, and the node information in the data model is updated. When clicking a node to edit the node properties, the data two-way binding function is used to monitor the changes in the property form, and the user input information is synchronously updated to the node object.

[0021] Step 3, process definition construction: After completing the process design, traverse the entire canvas content information and extract all node and line information; extract the attribute information in the corresponding nodes and lines, and use JSON to build a structured process definition; extract the coordinate information of the elements in the entire canvas and store it in the process definition;

[0022] Step 4, serialize the process definition: convert the constructed process definition into a JSON string for storage or transmission. The JSON string contains complete process configuration information and process view information. The process configuration is loaded, parsed and run, including:

[0023] 1) Configuration loading: The self-developed framework deserializes the process configuration file, converts the configuration information in JSON format into an operable data model object, and verifies the format and structure of the process definition;

[0024] 2) Configuration parsing: Based on the loaded data model objects, the self-developed framework continues to build the internal model of the process, including identifying and defining the start node, activity node, task node, end node and the connection relationship between nodes in the process, and determining the execution path and flow conditions of the entire process;

[0025] 3) Process execution: Based on the constructed process model, the self-developed framework creates a specific process instance and starts the execution process from the starting node of the instance; according to the characteristics and type of each node, the system executes the corresponding business logic. When encountering a task node that requires human intervention, the system assigns the task to the designated participant and prompts him to process it; the self-developed framework continuously monitors various events and automatically triggers related process progress when these events are detected.

[0026] In step S2, the interface command arrangement includes:

[0027] Step 2.1, interface command selection: select the required interface command from the list in the component library;

[0028] Step 2.2, interface command editing: In the selected area, edit the selected interface command, request the interface according to the selected interface command, pull detailed information and convert it into JSON data format, and display it in the form item; use the data two-way binding function of the VUE.JS framework to monitor form changes and synchronize to the backend in real time for data update; the interface command information includes basic interface information, permission information, data model information, business logic plug-in information, and process interaction information;

[0029] Among them, interface command editing includes:

[0030] Step 2.2.1, interface command basic information defines the implementation class, execution parameters, interface set configuration, and data model information of the interface command;

[0031] Step 2.2.2, verify the permission configuration information of the interface command execution through the permission information;

[0032] Step 2.2.3, define the input and output parameter information of the function and the business logic execution content through the business logic aspect information;

[0033] Step 2.2.4, process interaction binding: In the selected area, select the specified interface command to bind with the previously defined process node. The process binding information includes: business unit code, business unit version, task code, activity code, source activity code, and source activity target task.

[0034] In step 2.2, after the interface command is edited, the loading and running of the interface command includes:

[0035] 1) Logical plug-in execution: The self-developed framework obtains the plug-in instance in the Spring container according to the plug-in or execution class information in the interface command configuration, and uses dynamic proxy technology to load and execute these plug-ins;

[0036] 2) Dynamic script execution: The self-developed framework integrates Groovy and JavaScript dynamic script engines; the framework will load the script content in the interface command configuration and let the script engine execute it dynamically;

[0037] 3) Drive process execution: When the self-developed framework loads and executes the interface command, if there is process binding information in the command interface configuration, the framework passes the process binding information to the process engine; the process engine then loads the process configuration information related to the business unit, and locates the corresponding node in the process configuration according to the passed-in process binding parameters, thereby executing the flow and processing of the process.

[0038] In step S3, view binding includes:

[0039] Step 3.1, view node selection: When you select a node that meets the business requirements from the view node area on the left and drag and drop it onto the canvas, an empty data model is created for the selected node, and the data model contains basic attribute information of the node. The selected nodes include: scene nodes, view nodes, and command nodes;

[0040] Step 3.2, node attribute editing: When editing node attributes through nodes, use the data two-way binding function of the VUE.JS framework to monitor changes in the attribute form and synchronously update the input information to the node object, including setting the node's appearance, behavior, and data binding;

[0041] Step 3.3, interface command binding;

[0042] Step 3.4, through the visual binding interface, complete the integration of the interface and the backend logic, and automatically generate the view binding data format required by the program; the data is handed over to the view rendering engine of the custom framework for loading and parsing, and the view rendering engine determines the view rendering file and rendering type based on the viewFileCode and renderPositionType fields; according to the information in the scenarios field, the specific view page is rendered according to the specific scene, the view contained in the scene, and the command configuration information contained in the view.

[0043] In step 3.3, the interface command binding includes: selecting a command node on the canvas, each command node corresponds to a button in the front-end interface, sending a request to the back-end to load the interface command list information configured in the previous step 3.2, and displaying this information in the property panel on the right in the form of a drop-down list; specifying the interface command to be executed for the selected command node by means of a drop-down selection; after selecting an interface command from the drop-down list, synchronously updating the relevant information of the selected interface command to the property information of the command node; in the process of view rendering, parsing the configuration of the command node, and automatically generating a method for requesting the back-end according to cmdCode, and binding the method for requesting the back-end in the onclick event of the front-end button to execute the interface command selected by the drop-down list.

[0044] In step S4, the visual assembly of the business function unit is completed, including: after the assembly of the business unit is completed through the visual interface, all user inputs are collected and verified, and then organized into a JSON format data object; the front end sends the data to the back end server through a request; after the back end receives the request, it parses the data therein and further verifies the validity; after the verification is passed, the back end stores the data in the database, creates a new data record and two key program configuration files;

[0045] When you need to deploy and run the program, select a specific business unit through the interface; then, pass the dependency configuration file of the business unit to MAVEN to automatically resolve its required dependencies, and place the running configuration file of the business unit in the resource folder, and finally package it into an executable JAR file; start the JAR file by using the java command, and provide the user interface and service interface according to the process configuration, interface instruction configuration and view binding configuration information in the running configuration file.

[0046] Another object of the present invention is to provide an assembly system of a visualized assembly business functional unit, the system implementing the assembly method of the visualized assembly business functional unit, the system comprising:

[0047] Business unit programs, including business processes, interface commands and display views, work together to build complete business functions;

[0048] Visual assembly tool, using an intuitive graphical interface and wizard-style process, completes business process design, interface command definition and view binding operations; after completing the assembly operation, a data record and two key program configuration files are generated instantly;

[0049] The business system consists of multiple business units, each of which is responsible for different business processes; these units collaborate with each other and interact to ensure that the entire system can provide comprehensive functional services.

[0050] In combination with all the above-mentioned technical solutions, the beneficial effects of the present invention are as follows: the present invention proposes a tool for visually assembling business function units, which directly completes the assembly and management of business units through a graphical interface, greatly reducing the difficulty of understanding and operation. With the help of this intuitive design, even business personnel with non-technical backgrounds can easily participate in the customization and adjustment of business function units. In the present invention, the technical architecture and implementation mechanism of the tool are deeply analyzed, explaining that by simplifying the assembly process of business units, the maintainability and scalability of the software system are effectively improved.

[0051] The visual business function unit assembly tool of the present invention is expected to significantly reduce development costs and time, reduce error rates, and enable non-technical personnel to participate in it. This will accelerate the iteration and update of software products, enhance the market competitiveness of enterprises, and increase customer satisfaction. BRIEF DESCRIPTION OF THE DRAWINGS

[0052] The accompanying drawings herein are incorporated in and constitute a part of the specification, illustrate embodiments consistent with the present disclosure, and together with the description, serve to explain the principles of the present disclosure;

[0053] Figure 1 It is a flow chart of an assembly method of a visual assembly business functional unit provided by an embodiment of the present invention;

[0054] Figure 2 It is a schematic diagram of a visual assembly business function unit system provided by an embodiment of the present invention;

[0055] Figure 3 It is a schematic diagram of the process design provided by an embodiment of the present invention;

[0056] Figure 4 It is a schematic diagram of the interface command assembly provided by an embodiment of the present invention;

[0057] Figure 5 It is a view binding principle diagram provided by an embodiment of the present invention; DETAILED DESCRIPTION

[0058] In order to make the above-mentioned objects, features and advantages of the present invention more obvious and easy to understand, the specific embodiments of the present invention are described in detail below in conjunction with the accompanying drawings. In the following description, many specific details are set forth to facilitate a full understanding of the present invention. However, the present invention can be implemented in many other ways different from those described herein, and those skilled in the art can make similar improvements without violating the connotation of the present invention, so the present invention is not limited by the specific implementation disclosed below.

[0059] The innovation of the present invention lies in: the graphical user interface adopts drag-and-drop operation so that non-technical personnel can easily configure business functions; the business logic is abstracted into independent modules and combined like building blocks, achieving high configurability and meeting diverse needs without coding; the system supports plug-and-play business components, and users can flexibly choose predefined or customized components to quickly build and adjust business processes, greatly improving work efficiency and system flexibility.

[0060] The present invention proposes a method for visually assembling business function units, aiming to simplify the software development process by decomposing the software system into reusable, visual components / members (business units). The core of this method is to use a graphical interface to assemble and manage business function units, which not only lowers the threshold for understanding and operation, allowing business personnel with non-technical backgrounds to easily participate in the customization and adjustment of business units, but also greatly improves the maintainability and scalability of the software system and shortens the business response cycle. Specifically, the method of the present invention provides the following solutions:

[0061] First, through modular design, each business function unit is encapsulated as an independent component, which not only reduces the complexity of the overall system but also promotes the reuse of components.

[0062] Secondly, visual assembly tools support rapid prototyping, allowing users to build business processes through simple drag-and-drop operations, greatly shortening the time from concept to implementation.

[0063] Finally, the solution of the present invention strengthens change management and version control, ensures the consistency and traceability of business units, and provides a solid foundation for continuous integration and continuous delivery (CI / CD).

[0064] Embodiment 1:

[0065] Business unit: A basic component in a software system, usually an independent, reusable business function or module unit used to implement specific business processes or functions.

[0066] Component: Reusable, independent software modules that provide specific functions through clear interfaces and can be integrated into different software systems to build complex applications.

[0067] JSON: A lightweight data exchange format that uses a text format that is completely independent of programming languages ​​to store and represent data. The simplicity and clear hierarchical structure make JSON an ideal data exchange language. It is easy for humans to read and write, and easy for machines to parse and generate, and effectively improves network transmission efficiency.

[0068] Maven: A project management and integration tool, primarily used for Java projects, that helps developers automate the build, dependency management, and project information management processes by providing a project object model (POM) and a set of standard build rules.

[0069] like Figure 1 As shown, the assembly method of the visual assembly business function unit provided by the embodiment of the present invention includes:

[0070] S1, process design: Provides a process design environment through a graphical interface divided into three areas, and completes the dynamic construction and management of process definitions through the front-end and back-end interaction mechanism; the three areas include: process node area, node attribute bar, and process canvas;

[0071] S2, interface command arrangement: all interface commands are displayed in a list format in the interface command assembly component library display area, and each list item includes the name, description, dependency, configuration, and usage status information of the interface command; the interface command selected by the user is displayed in the selected area of ​​the interface command assembly page, and an editing function is provided to modify the relevant properties of the interface command;

[0072] S3, view binding: List all available nodes through the view node area contained in the view binding page, and build the interface layout through the view canvas; display and allow editing of detailed properties of a node on the selected canvas through the node property bar;

[0073] S4, complete the visual assembly of business function units.

[0074] Example 2, as a specific implementation scheme of the present invention, is specifically analyzed as follows:

[0075] The overall architecture of the visual assembly business functional unit system provided by the embodiment of the present invention is as follows: Figure 2 As shown,

[0076] Based on the principle of modular development, a visual assembly business functional unit system architecture is proposed, including:

[0077] The functions of a complete business unit program are abstracted into three core components: business process, interface command and display view. These three parts work together to build a complete business function.

[0078] (1) Business process: defines the sequence and logical decision path of business operations to ensure that each operation can be correctly executed according to the established order and rules. This paper draws on the BPMN 2.0 standard and develops a set of configuration rules covering process startup, task execution, decision flow and process termination.

[0079] (2) Interface commands: define the interaction mechanism between different business units in the business system and external systems or users, including input data, output results, and specific processing logic. The present invention defines the interface commands in the form of configuration files, which contain information such as functional logic code implementation, process control logic, and operating parameters.

[0080] (3) Display view: responsible for displaying the execution status and results of different business units in the business system, and providing an interface for users to interact with business units. The present invention also uses a configuration file to define the operation buttons on the user interface and the binding relationship between them and the corresponding interface commands. Finally, by integrating the process configuration, interface command configuration, and view binding configuration, a unified configuration file is formed, which is loaded and executed by the self-developed operating framework of the present invention, thereby realizing the dynamic construction and flexible deployment of business function units.

[0081] The visual assembly tool (visual assembly business unit tool) uses an intuitive graphical interface and wizard-style process to guide users to gradually complete business process design, interface command definition, view binding and other operations. After the user completes the assembly operation, the tool will instantly generate a data record and two key program configuration files. Specifically including:

[0082] Data records: It records in detail important metadata such as the business unit's version information, applicable scenarios, and change history, making it easier to manage and track the iterative development of the business unit.

[0083] Operation configuration file: This configuration file describes in detail the various parameters and configuration information required by the business unit during operation. It is parsed and run through the operation framework independently developed by the present invention to ensure stable and efficient operation of business functions.

[0084] Program dependency file: This file is parsed by the Maven project management tool, which automatically handles all dependencies of the business unit and ensures that all necessary libraries and resources are correctly packaged to generate an application package that can be deployed and executed immediately.

[0085] The business system consists of multiple business units, each of which is responsible for different business processes; these units collaborate with each other and interact to ensure that the entire system can provide comprehensive functional services.

[0086] The present invention uses a visual assembly tool, and users can assemble complex business units with simple drag-and-drop operations. The tool converts the user's creative ideas into actual software components, greatly reducing the technical threshold and improving development efficiency.

[0087] Embodiment 3, exemplary, the assembly method of the visual assembly tool comprises:

[0088] Step 1, process design;

[0089] The visual assembly tool provides users with a flexible and efficient process design environment through an intuitive graphical interface, and realizes the dynamic construction and management of process definitions through a series of front-end and back-end interaction mechanisms. The process design interface is divided into three areas: the process node area on the left, which displays various types of process nodes in the form of icons. The node property bar on the right: users can edit the properties of the selected node through this area, and these properties are stored in a JSON object. The middle process canvas: This area is the main place for user operations and is used to place and connect various process nodes.

[0090] The process nodes and attribute information are as follows: Start node: responsible for starting the entire process instance, its main attribute information is:

[0091] {

[0092] "clazz": "Custom business logic triggered by the start of the process",

[0093] "code": "Start node code",

[0094] "startNodeNodes": "The node collection that triggers the start node"

[0095] }.

[0096] Task node: Execute different tasks according to specific needs, such as automatic processing or manual approval. Its main attribute information is:

[0097] {

[0098] "clazz": "Custom business logic",

[0099] "matchPermissions": "Permission values ​​that need to be matched",

[0100] "activities": "Target activity list",

[0101] "wait": "Wait for task conditions",

[0102] "startAutoCmd": "Task start automatic command",

[0103] "endAutoCmd": "Task end automatic command",

[0104] "rtParamSet": "Runtime parameters"

[0105] }.

[0106] Activity node: Implements the process control flow functions according to the BPMN2 standard, such as branching, merging, synchronization, etc. Its main attribute information is:

[0107] "achieveType": "Achievement method",

[0108] "ruleClazz": "Custom business rules",

[0109] "argsConvertClazz": "Interface Parameter Converter",

[0110] "filterScript": "Business rule script file",

[0111] "argConvertScript": "Parameter conversion script",

[0112] "rtParamSet": "Runtime parameters",

[0113] "target": "target task set"

[0114] }.

[0115] End node: represents the completion of the process, and its main attribute information is:

[0116] {

[0117] "clazz": "Business logic executed at the end of the process",

[0118] "code": "Process end code"

[0119] }.

[0120] like Figure 3 As shown, the process design steps include:

[0121] Step 1: Initialize the interface and data model: Use the ANTV / X6 front-end framework to create a blank canvas area for user operation; at the same time, initialize an empty data model, which will be used to save all status information of the process. The main attribute information of the data model is as follows:

[0122] {

[0123] "tasks": "Task list",

[0124] "activities": "Activity list",

[0125] "description": 'Description information',

[0126] "startConfig": "Start node configuration",

[0127] "endConfig": "End node configuration",

[0128] "view": "Process view"

[0129] }.

[0130] Step 2: Interaction monitoring: Use the event system of the ANTV / X6 framework to monitor user interaction events, such as click, drag, release, etc. When the user drags a node to the canvas, the position information is captured by monitoring the event, and the node information in the data model is updated. When the user edits the node properties by clicking on the node, the data two-way binding function of the VUE.JS framework is used to monitor the changes in the attribute form and synchronize the user input information to the node object.

[0131] Step 3: Process definition construction: After the user completes the process design, the entire canvas content information is traversed to extract all node and line information. The corresponding attribute information in the nodes and lines is extracted, and a structured process definition is constructed using JSON. At the same time, the coordinate information of the elements in the entire canvas is extracted through the ANTV / X6 framework and stored in the process definition.

[0132] Step 4: Serialize the process definition: Convert the constructed process definition into a JSON string for easy storage or transmission. The JSON string contains complete process configuration information and process view information. The process configuration information will eventually be loaded, parsed, and executed by the self-developed framework.

[0133] Step 2: Interface command arrangement.

[0134] like Figure 4As shown in the figure, the interface command assembly page in the visual assembly tool is mainly composed of two parts: the component library display area on the left and the selected area on the right. The component library display area on the left: displays all available interface commands in a list format. Each list item includes information such as the name, description, dependency, configuration, and usage status of the interface command. The selected area on the right: displays the interface command selected by the user and provides editing functions. Users can modify the relevant properties of the interface command in this area.

[0135] Exemplary interface command arrangement steps:

[0136] Step 2.1: Interface command selection: Users can select the required interface command from the list in the component library on the left by simply clicking or dragging. Multiple selection is supported.

[0137] Step 2.2: Interface command editing: In the selected area, users can click the Edit button to edit the selected interface command. The tool will request the interface according to the selected interface command, pull detailed information and convert it into JSON data format, and display it in the form item. At the same time, with the help of the data two-way binding function of the VUE.JS framework, the form changes are monitored and synchronized to the backend in real time for data update. The interface command information includes basic interface information, permission information, data model information, business logic plug-in information, process interaction information, etc. The main data formats are as follows:

[0138] {

[0139] "baseInfo": "Basic interface information",

[0140] "accessControl": "Access control information",

[0141] "aspect": "Business logic aspect information",

[0142] "processControl": "Process binding information"

[0143] }.

[0144] Step 2.2 specifically includes:

[0145] Step 2.2.1: The basic information of the interface command defines the implementation class, execution parameters, interface set configuration, data model and other information of the interface command. The main attributes are:

[0146] {

[0147] "cmdDataConfig": "Data model configuration",

[0148] "clazz": "the class corresponding to the command execution",

[0149] "cmdResult": "Command result set configuration",

[0150] "excRequestPosition": "Method processing type",

[0151] "argsConvertClazz": "Interface Parameter Converter",

[0152] "execScript": "Execute script",

[0153] "argConvertScript": "Parameter conversion script object",

[0154] "rtParamSet": "Runtime parameters"

[0155] }.

[0156] Step 2.2.2: Permission information is mainly used to verify the permission configuration information for the execution of interface commands. The main attributes are:

[0157] {

[0158] "direction": "Forward / Reverse Match",

[0159] "type": "Authorization type",

[0160] "value": "Authorization verification value",

[0161] "match": "Authorization verification method"

[0162] }.

[0163] Step 2.2.3: Business logic aspect information defines the input and output parameter information of the function and the business logic execution. It mainly includes the following attributes:

[0164] {

[0165] "func": "Function set",

[0166] "caption": "Node description",

[0167] "paramSet": "General parameter set",

[0168] "filterClazz": "Filter",

[0169] "argsConvertClazz": "Interface Parameter Converter",

[0170] "filterScript": "Filter script",

[0171] "argConvertScript": "Parameter conversion script"

[0172] }.

[0173] Step 2.2.4: Process interaction binding: In the selected area, the user clicks to select the specified interface command to bind with the previously defined process node. The main information of process binding is:

[0174] "unitCode": "Business unit code",

[0175] "unitVersion": "Business unit version",

[0176] "taskCode": "Task Code",

[0177] "activityCode": "Activity Code",

[0178] "sourceActivityCode": "Source activity code",

[0179] "sourceActivityTargetCode": "Source activity target task"

[0180] }.

[0181] It can be seen that the visual assembly tool supports two ways to execute interface commands: 1) Select an existing logic plug-in or execution class: The self-developed framework obtains the plug-in instance in the Spring container through configuration information, and loads and executes it through dynamic proxy. 2) Dynamic script method: The self-developed framework integrates multiple dynamic script engines such as Groovy and JavaScript. By loading the script information in the interface command information and letting the script engine execute dynamically, the high flexibility of business logic is achieved.

[0182] When the self-developed framework loads and executes the interface command, if there is process binding information in the command configuration, it will pass this configuration information to the process engine. The process engine will then load the process configuration information related to the business unit and locate the corresponding node in the process configuration based on the passed-in configuration parameters (such as UnitCode, unitVersion, taskCode, activityCode, etc.), thereby executing the flow and processing of the process.

[0183] Step 3, view binding.

[0184] The view binding page in the visual assembly tool consists of three parts: the view node area, located on the left side of the interface, lists all available nodes, such as menus for scene nodes, pages for view nodes, and function buttons for command nodes; the view canvas, which occupies the center of the interface. This is a visual workspace where users can drag and drop nodes to build the interface layout; the node property bar, located on the right side of the interface, which displays and allows users to edit the detailed properties of a node on the canvas selected by the user.

[0185] like Figure 5 As shown, the view binding steps are:

[0186] Step 3.1: View node selection: When the user selects a node that meets their business needs from the view node area on the left side of the tool and drags it onto the canvas, the tool will create an empty data model for the selected node, which contains the basic attribute information of the node. The main attribute information of the scene node is:

[0187] {

[0188] "id": "Scene code",

[0189] "name": "Scene name",

[0190] "caption": "Scene description",

[0191] "defaultViewId": "Default view ID"

[0192] }.

[0193] The main attribute information of the view node is:

[0194] {

[0195] "id": "View ID",

[0196] "name": "View name",

[0197] "order": "View display order",

[0198] "caption": "View description",

[0199] "defaultCmdRefId": "View default command ID",

[0200] "viewFileCode": "View file code",

[0201] "viewRenderClazz": "view rendering class"

[0202] }.

[0203] The main attribute information of the command node is:

[0204] {

[0205] "id": "command code",

[0206] "name": "Command name",

[0207] "order": "Show order",

[0208] "caption": "Description information",

[0209] "cmdCode": "The command code of the reference"

[0210] }.

[0211] Step 3.2: Node property editing: When users edit node properties by clicking on a node, the data two-way binding function of the VUE.JS framework is used to monitor changes in the property form and synchronize the user input information to the node object. This includes setting the node's appearance, behavior, and data binding to ensure that the view can correctly display data and respond to user operations.

[0212] Step 3.3: Interface command binding: The user selects a command node on the canvas, and each command node corresponds to a button in the front-end interface. The tool sends a request to the back-end to load the interface command list information configured in the previous step, and displays this information in the property panel on the right in the form of a drop-down list. The user can specify the interface command to be executed for the selected command node by means of a drop-down selection. When the user selects an interface command from the drop-down list, the tool will synchronously update the relevant information of the selected interface command (i.e. "cmdCode") to the attribute information of the command node. During the view rendering process, the tool will parse the configuration of the command node and automatically generate a method for requesting the back-end based on "cmdCode". In addition, the tool will bind this automatically generated method in the onclick event of the front-end button. This means that whenever the user clicks the corresponding front-end button, the corresponding back-end request will be triggered to execute the interface command previously selected through the drop-down list.

[0213] Step 3.4, through the visual binding interface, users can easily integrate the interface with the backend logic without writing complex code. The assembly tool will automatically generate the view binding data format required by the program. The generated data structure is as follows:

[0214] {

[0215] "scencs": "Scene list",

[0216] "type": "View business type",

[0217] "requestDataLoaderClazz": "Business data processing class",

[0218] "accessControl": "Access Control",

[0219] "viewFileCode": "View file code",

[0220] "dtoLoadServiceClazz": "Load the service implementation class",

[0221] "renderPositionType": "render position type",

[0222] "description": "Description node string"

[0223] }.

[0224] The data will be handed over to the view rendering engine of the custom framework for loading and parsing. The view rendering engine will determine the view rendering file and rendering type based on fields such as viewFileCode and renderPositionType. Then, based on the information in the scenarios field, the specific scene, the view contained in the scene, the command configuration contained in the view, and other information will be used to render the specific view page.

[0225] Step 4, complete the assembly.

[0226] After the user completes the assembly of the business unit through the visual interface, the visual assembly tool will collect and verify all the user's input, and then organize it into a JSON format data object. Then, the front end sends the data to the back-end server through a request. After receiving the request, the back end parses the data and further verifies its validity. Once the verification is passed, the back end will store the data in the database, create a new data record and two key program configuration files. The main data results of the data record are as follows:

[0227] {

[0228] "code": "Unique code",

[0229] "name": "Business unit name",

[0230] "version": version information,

[0231] "author": "Author",

[0232] "description": "Description information",

[0233] "businessArea": ​​"Applicable fields",

[0234] "labels": "Function labels",

[0235] "mvnCoordinate": "Maven warehouse coordinates",

[0236] "runConfig": "Run configuration file",

[0237] "dependencyConfig": "Program dependency configuration"

[0238] }.

[0239] Run configuration file structure:

[0240] {

[0241] "id": unique identifier,

[0242] "version": version information,

[0243] "describeString": description information,

[0244] "scenes": view binding configuration,

[0245] "commands": command arrangement configuration,

[0246] "process": process configuration,

[0247] "appends": additional data (flowchart)

[0248] }.

[0249] Program dependency configuration file structure:

[0250] [{

[0251] "groudId": "Group ID",

[0252] "artifactId": "module / project ID",

[0253] "version": "Version information",

[0254] "description": "Description information"

[0255] }].

[0256] When you need to deploy and run the program, the user can select a specific business unit through the interface. The tool will then pass the dependency configuration file of the business unit to MAVEN to automatically resolve the required dependencies, and place the running configuration file of the business unit in the resource folder, and finally package it into an executable JAR file. By using the java command to start this JAR file, the program can provide a user interface and service interface based on the process configuration, interface instruction configuration, and view binding configuration in the running configuration file.

[0257] To further illustrate the effects of the embodiments of the present invention, the following test was conducted, and the test results are shown in Table 1.

[0258] Experimental background: The development of the quality control module of the MES system includes three functional modules: inspection planning, inspection execution, and inspection record.

[0259] Control group: 1 business analyst and 3 development engineers.

[0260] Experimental group: 1 business analyst and 1 technical support engineer.

[0261] Table 1 Test results

[0262]

[0263] The test results show that the experimental group using the present invention significantly improved development efficiency when developing the MES system quality control module, and the demand analysis and development time were shortened to 10 working days and 25 working days respectively; the number of problems found in the testing phase was also reduced from 107 to 31, indicating that the error rate was significantly reduced, verifying the advantages of the tool in improving efficiency and reducing errors.

[0264] The tool for visually assembling business units of the present invention successfully realizes the visual assembly and configuration of business units through steps such as process design, interface command arrangement and view binding, and significantly improves the scalability and maintainability of the software. This method not only solves the problem of excessive reliance on coding in the development and assembly of traditional business units, but also enhances the reusability and maintainability of business units.

[0265] In the process of developing and implementing the MES product of the present invention, the method of the present invention can effectively support the rapid generation and flexible configuration of business units, meeting the changes in different business requirements. At the same time, the method also provides a more intuitive and easy-to-use interface, allowing developers, implementers and business personnel to more easily understand and operate business units.

[0266] The above description is only a preferred specific implementation manner of the present invention, but the protection scope of the present invention is not limited thereto. Any modifications, equivalent substitutions and improvements made by any technician familiar with the technical field within the technical scope disclosed by the present invention and within the spirit and principles of the present invention should be covered within the protection scope of the present invention.

Claims

1. A method for assembling a visual assembly business functional unit, characterized in that: The method includes: S1, process design: Provides a process design environment through a graphical interface divided into three areas, and completes the dynamic construction and management of process definitions through the front-end and back-end interaction mechanism; the three areas include: process node area, node attribute bar, and process canvas; S2, interface command arrangement: all interface commands are displayed in a list format in the interface command assembly component library display area, and each list item includes the name, description, dependency, configuration, and usage status information of the interface command; the interface command selected by the user is displayed in the selected area of ​​the interface command assembly page, and an editing function is provided to modify the relevant properties of the interface command; S3, view binding: List all available nodes through the view node area contained in the view binding page, and build the interface layout through the view canvas; display and allow editing of detailed properties of a node on the selected canvas through the node property bar; S4, complete the visual assembly of business function units; In step S3, view binding includes: Step 3.1, view node selection: When you select a node that meets the business requirements from the view node area on the left and drag and drop it onto the canvas, an empty data model is created for the selected node, and the data model contains basic attribute information of the node. The selected nodes include: scene nodes, view nodes, and command nodes; Step 3.2, node attribute editing: When editing node attributes through nodes, use the data two-way binding function of the VUE.JS framework to monitor changes in the attribute form and synchronously update the input information to the node object, including setting the node's appearance, behavior, and data binding; Step 3.3, interface command binding; Step 3.4, through the visual binding interface, complete the integration of the interface and the backend logic, and automatically generate the view binding data format required by the program; the data is handed over to the view rendering engine of the custom framework for loading and parsing, and the view rendering engine determines the view rendering file and rendering type according to the viewFileCode and renderPositionType fields; according to the information in the scenarios field, the specific view page is rendered according to the specific scene, the view contained in the scene, and the command configuration information contained in the view; In step 3.3, the interface command binding includes: selecting a command node on the canvas, each command node corresponds to a button in the front-end interface, sending a request to the back-end to load the interface command list information configured in the previous step 3.2, and displaying this information in the property panel on the right in the form of a drop-down list; specifying the interface command to be executed for the selected command node by means of a drop-down selection; after selecting an interface command from the drop-down list, synchronously updating the relevant information of the selected interface command to the property information of the command node; in the process of view rendering, parsing the configuration of the command node, and automatically generating a method for requesting the back-end according to cmdCode, and binding the method for requesting the back-end in the onclick event of the front-end button to execute the interface command selected by the drop-down list.

2. The assembly method of the visual assembly business functional unit according to claim 1, characterized in that: In step S1, the process node area is used to display various types of process nodes in the form of icons; The node property bar is used to edit the properties of the selected node and store the properties in a JSON object; The process canvas is used to place and connect various process nodes.

3. The assembly method of the visual assembly business functional unit according to claim 2, characterized in that: Process nodes, including: Start node: used to start the entire process instance. The attribute information of the start node includes: the custom business logic triggered by the start of the process, the start node code, and the node set that triggers the start node; Task node: Execute different tasks according to specific needs. The attribute information of the task node includes: custom business logic, permission values ​​that need to be matched, target activity list, waiting task conditions, task start automatic command, task end automatic command, and runtime parameters; Activity node: implements the process control flow function according to the BPMN2 standard. The attribute information of the activity node includes: implementation method, custom business rules, interface parameter converter, business rule script file, parameter conversion script, runtime parameters, and target task set; End node: represents the completion of the process. The attribute information of the end node includes: the business logic executed at the end of the process and the process end code.

4. The assembly method of the visual assembly business functional unit according to claim 1, characterized in that: In step S1, the process design includes: Step 1, initialize the interface and data model: use the front-end framework to create a blank canvas area for users to operate; initialize an empty data model to save all status information of the process; Step 2, Interaction monitoring: Use the event system to monitor the user's interaction events. When dragging a node onto the canvas, the position information is captured by monitoring the event, and the node information in the data model is updated. When clicking a node to edit the node properties, the data two-way binding function is used to monitor the changes in the property form, and the user input information is synchronously updated to the node object. Step 3, process definition construction: After completing the process design, traverse the entire canvas content information and extract all node and line information; extract the attribute information in the corresponding nodes and lines, and use JSON to build a structured process definition; extract the coordinate information of the elements in the entire canvas and store it in the process definition; Step 4, serialize the process definition: convert the constructed process definition into a JSON string for storage or transmission. The JSON string contains complete process configuration information and process view information. The process configuration is loaded, parsed and run, including: 1) Configuration loading: A self-developed framework that integrates Groovy and JavaScript dynamic scripting engines deserializes the process configuration files, converts the configuration information in JSON format into an operable data model object, and verifies the format and structure of the process definition; 2) Configuration parsing: Based on the loaded data model objects, the self-developed framework integrating Groovy and JavaScript dynamic scripting engines continues to build the internal model of the process; including identifying and defining the start node, activity node, task node, end node and the connection relationship between nodes in the process, and determining the execution path and flow conditions of the entire process; 3) Process execution: Based on the constructed process model, the self-developed framework that integrates Groovy and JavaScript dynamic scripting engines creates a specific process instance and starts the execution process from the starting node of the instance; according to the characteristics and type of each node, the system executes the corresponding business logic. When encountering a task node that requires human intervention, the system assigns the task to the designated participant and prompts him to process it; the self-developed framework continuously monitors various events and automatically triggers related process progress when these events are detected.

5. The assembly method of the visual assembly business functional unit according to claim 1, characterized in that: In step S2, the interface command arrangement includes: Step 2.1, interface command selection: select the required interface command from the list in the component library; Step 2.2, interface command editing: In the selected area, edit the selected interface command, request the interface according to the selected interface command, pull detailed information and convert it into JSON data format, and display it in the form item; use the data two-way binding function of the VUE.JS framework to monitor form changes and synchronize to the backend in real time for data update; the interface command information includes basic interface information, permission information, data model information, business logic plug-in information, and process interaction information; Among them, interface command editing includes: Step 2.2.1, interface command basic information defines the implementation class, execution parameters, interface set configuration, and data model information of the interface command; Step 2.2.2, verify the permission configuration information of the interface command execution through the permission information; Step 2.2.3, define the input and output parameter information of the function and the business logic execution content through the business logic aspect information; Step 2.2.4, process interaction binding: In the selected area, select the specified interface command to bind with the previously defined process node. The process binding information includes: business unit code, business unit version, task code, activity code, source activity code, and source activity target task.

6. The assembly method of the visual assembly business functional unit according to claim 5, characterized in that: In step 2.2, after the interface command is edited, the loading and running of the interface command includes: 1) Logical plug-in execution: The self-developed framework integrated with Groovy and JavaScript dynamic scripting engines obtains the plug-in instance in the Spring container according to the plug-in or execution class information in the interface command configuration, and uses dynamic proxy technology to load and execute these plug-ins; 2) Dynamic script execution: The self-developed framework that integrates Groovy and JavaScript dynamic script engines will load the script content in the interface command configuration and let the script engine execute it dynamically; 3) Drive process execution: When the self-developed framework that integrates Groovy and JavaScript dynamic scripting engines loads and executes interface commands, if there is process binding information in the command interface configuration, the self-developed framework that integrates Groovy and JavaScript dynamic scripting engines passes the process binding information to the process engine; the process engine then loads the process configuration information related to the business unit, and locates the corresponding node in the process configuration according to the passed-in process binding parameters, thereby executing the flow and processing of the process.

7. The assembly method of the visual assembly business functional unit according to claim 1, characterized in that: In step S4, the visual assembly of the business function unit is completed, including: after the assembly of the business unit is completed through the visual interface, all user inputs are collected and verified, and then organized into a JSON format data object; the front end sends the data to the back end server through a request; after the back end receives the request, it parses the data therein and further verifies the validity; after the verification is passed, the back end stores the data in the database, creates a new data record and two key program configuration files; When you need to deploy and run the program, select a specific business unit through the interface; then, pass the dependency configuration file of the business unit to MAVEN to automatically resolve its required dependencies, and place the running configuration file of the business unit in the resource folder, and finally package it into an executable JAR file; start the JAR file by using the java command, and provide the user interface and service interface according to the process configuration, interface instruction configuration and view binding configuration information in the running configuration file.

8. An assembly system for a visual assembly business functional unit, characterized in that: The system implements the assembly method of the visual assembly business functional unit according to any one of claims 1 to 7, and the system includes: Business unit programs, including business processes, interface commands and display views, work together to build complete business functions; Visual assembly tool, using an intuitive graphical interface and wizard-style process, completes business process design, interface command definition and view binding operations; after completing the assembly operation, a data record and two key program configuration files are generated instantly; The business system consists of multiple business units, each of which is responsible for different business processes; these units collaborate with each other and interact to ensure that the entire system can provide comprehensive functional services.

Images