Business process arrangement system and method based on optimus platform

Abstract

The invention provides a business process arrangement system and method based on an optimus platform, and relates to the technical field of process management, and the system comprises a front end unit and an optimus data bridging unit. The front-end unit at least comprises a building unit and a code preview unit, the building unit is used for visually dragging a code component to build a business process, and the code preview unit is used for visually displaying a process code; and the optimus data bridging unit is used for generating a process code and a process configuration based on the business process established by the establishment unit, synchronizing the process code and the process configuration to each business service, automatically arranging the business process after the business service is started, and visualizing complex business logic, so that node errors can be avoided to a certain extent.

Description

Technical Field

[0001] This invention relates to the field of process management technology, and in particular to a business process orchestration system and method based on the Optimus platform. Background Technology

[0002] Code is a source file written by a programmer using a language supported by development tools. It is a set of explicit rules that represent information in discrete form using characters, symbols, or signal elements.

[0003] In the process of developing this invention, the inventors discovered that due to the diverse and varied business scenarios in the code, the need for personalization and numerous business terminology requirements—each term potentially corresponding to a large number of fields, logic, and processes—and the long and poorly visualized business processes that are difficult to intuitively represent across systems, errors at any node can cause overall system failures. Therefore, there is an urgent need for a process orchestration system that can visualize complex business logic to prevent node errors. Summary of the Invention

[0004] In view of this, embodiments of this application provide a business process orchestration system and method based on the Optimus platform, which can avoid node errors to a certain extent by visualizing complex business logic.

[0005] The first aspect of this application discloses a business process orchestration system based on the Optimus platform, including: a front-end unit and an Optimus data bridging unit;

[0006] The front-end unit includes at least a building unit and a code preview unit. The building unit is used to visually drag and drop code components to build a business process, and the code preview unit is used to visually display the process code.

[0007] The Optimus data bridging unit is used to generate the process code and process configuration based on the business process built by the building unit, and to synchronize the process code and process configuration to each business service. When the business service starts, it automatically performs business process orchestration.

[0008] Optionally, in the aforementioned business process orchestration system based on the Optimus platform, the front-end unit further includes:

[0009] An isolation unit is used to isolate the business services and business versions.

[0010] Optionally, in the aforementioned business process orchestration system based on the Optimus platform, the isolation unit is connected to the Optimus data bridging unit via a Java-psi interface.

[0011] Optionally, in the aforementioned business process orchestration system based on the Optimus platform, the Optimus data bridging unit is used to generate the process code based on the business process built by the building unit, including:

[0012] The business process built by the aforementioned building unit is converted into XML protocol format;

[0013] The business process in XML protocol format is parsed to obtain the process code, which is Java code.

[0014] Optionally, the above-mentioned business process orchestration system based on the Optimus platform also includes a preloading unit for preloading BPM processes.

[0015] Optionally, the above-mentioned business process orchestration system based on the Optimus platform includes at least: global variable nodes, start nodes, end nodes, Java nodes, Spring nodes, capability nodes, step nodes, decision nodes, script nodes, loop nodes, and concurrency nodes.

[0016] And / or,

[0017] Parameter passing;

[0018] And / or,

[0019] Subprocess;

[0020] And / or,

[0021] Retry process.

[0022] The second aspect of this application discloses a business process orchestration method, applied to a business process orchestration system based on the Optimus platform as described in any of the claims of the first aspect, the method comprising:

[0023] Build business processes in response to user visual actions;

[0024] Generate process code and process configuration based on the established business process;

[0025] The process code is visualized and the process configuration is synchronized to each business service. Once the business service is started, the business process is automatically orchestrated.

[0026] Optionally, in the above business process orchestration method, generating process code based on the constructed business process includes:

[0027] The established business process is converted into XML protocol format;

[0028] The business process in XML protocol format is parsed to obtain the process code, which is Java code.

[0029] Optionally, the above-mentioned business process orchestration method also includes:

[0030] Preload the bpm process.

[0031] Optionally, the above-mentioned business process orchestration method also includes:

[0032] The business services and business versions are isolated.

[0033] Compared with the prior art, this application has the following advantages:

[0034] This application provides a business process orchestration system based on the Optimus platform, including: a front-end unit and an Optimus data bridging unit; the front-end unit includes at least a setup unit and a code preview unit, the setup unit is used to visually drag and drop code components to build a business process, and the code preview unit is used to visually display the process code; the Optimus data bridging unit is used to generate process code and process configuration based on the business process built by the setup unit, and to synchronize the process code and process configuration to various business services. When the business service starts, business process orchestration is performed automatically. By visualizing complex business logic, node errors can be avoided to a certain extent. Attached Figure Description

[0035] To more clearly illustrate the technical solutions in the embodiments of the present invention 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 only embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on the provided drawings without creative effort.

[0036] Figure 1 A schematic diagram of the structure of a business process orchestration system based on the Optimus platform provided in this application embodiment;

[0037] Figure 2 A schematic diagram of the visual operation page corresponding to the global variable node var provided in the embodiments of this application;

[0038] Figure 3 This is a schematic diagram of the visual operation page corresponding to the start node provided in the embodiments of this application;

[0039] Figure 4 This is a schematic diagram of the visual operation page corresponding to the end node provided in the embodiments of this application;

[0040] Figure 5 This is a schematic diagram of the visual operation page corresponding to the Java node provided in the embodiments of this application;

[0041] Figure 6 This is a schematic diagram of the visual operation page corresponding to the Spring node provided in the embodiments of this application;

[0042] Figure 7 This is a schematic diagram of the visual operation page corresponding to the capability node provided in the embodiments of this application;

[0043] Figure 8 A schematic diagram of the visual operation page corresponding to the decision node provided in this application embodiment;

[0044] Figure 9 A schematic diagram of the visual operation page corresponding to the script node scriptTask provided in the embodiments of this application;

[0045] Figure 10 A schematic diagram of the visual operation page corresponding to the concurrent node parallelDecision provided in the embodiments of this application;

[0046] Figure 11 A schematic diagram of the visual operation page corresponding to the custom thread and timeout provided in the embodiments of this application;

[0047] Figure 12 A schematic diagram of the visual operation page corresponding to the sub-process subBpm provided in the embodiments of this application;

[0048] Figure 13 and Figure 14 Schematic diagrams of two other business process orchestration systems based on the Optimus platform provided in this application embodiment;

[0049] Figure 15 A schematic diagram illustrating the specific structure of a business process orchestration system based on the Optimus platform, provided in this application embodiment;

[0050] Figure 16 A flowchart of a business process orchestration method provided in an embodiment of this application. Detailed Implementation

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

[0052] In this application, the terms "comprising," "including," or any other variations thereof are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes said element.

[0053] This application provides a business process orchestration system and method based on the Optimus platform, which can avoid node errors to a certain extent by visualizing complex business logic.

[0054] Please see Figure 1 The business process orchestration system based on the Optimus platform mainly includes: a front-end unit and an Optimus data bridging unit;

[0055] The front-end unit includes at least a setup unit and a code preview unit. The setup unit is used to visually drag and drop code components to build a business process, and the code preview unit is used to visually display the process code.

[0056] In some embodiments, the building unit can be a design process editor, which provides a visual operation platform to designers through the front end, allowing designers to drag and drop code components to build business processes.

[0057] The code components displayed on the visual operation platform can be general code components; of course, they are not limited to these, and can be determined according to the application environment and user needs, all of which are within the protection scope of this application.

[0058] In some embodiments, the code preview unit can display the process code in a visual form; wherein, the code displayed is the process code corresponding to the business process built by the building unit; specifically, it may be the process code generated by the Optimus data bridging unit.

[0059] The Optimus data bridging unit is used to generate process code and process configuration based on the business process built by the building unit, and to synchronize the process code and process configuration to various business services. When the business service starts, it automatically performs business process orchestration.

[0060] Among them, process code is the code corresponding to the business process built by the building unit, and process configuration is the relevant configuration required to execute the process code.

[0061] In some embodiments, the specific process by which the Optimus data bridging unit generates process code based on the business process built by the building unit is as follows:

[0062] Convert the business processes built by the building unit into XML protocol format;

[0063] The business process in XML protocol format is parsed to obtain the process code, which is Java code.

[0064] In practical applications, communication between the setup unit, code preview unit, and Optimus data bridging unit requires process protocol conversion. After the setup unit builds a business process composed of code components, process protocol conversion can be performed to transform the code components in the business process into underlying XML, that is, to convert the business process built by the setup unit into XML protocol format. Then, the framework parses it into A.java code. Ultimately, this achieves automatic generation of Java code.

[0065] In some embodiments, the Optimus data bridging unit includes at least: a global variable node, a start node, an end node, a Java node, a Spring node, a capability node, a step node, a decision node, a script node, a loop node, and a concurrency node; and / or, parameter passing; and / or, a sub-process; and / or, a retry process.

[0066] Global variable nodes can be represented using `var`. When implementing protocols and in visual editing, the corresponding visual operation page for the global variable node `var` is as follows: Figure 2 As shown, the corresponding Java code is as follows:

[0067] <var name="dtmModel" datatype="cn.huolala.homonoia.service.fsm.model.DTMModel" contextvarname="dtmModel" inouttype="param">< / var>

[0068] Among them, those directly under the root node bpm (business process management) are called global variables. `inOutType` indicates the parameter type, with three values: `param`, `inner`, and `return`. `param` represents the input parameter for the corresponding engine's `start` process; when in the `start` process, in addition to setting the `code`, the `context` also needs to be set; it is a MAP, where the key needs to be mapped to the `name` attribute of the `var` node above. `inner` represents intermediate variables after the execution of each node within the internal runtime. `return` represents the returned result variable; after the process execution is complete, a `result` result will be obtained, which is also a MAP. The `var` node specifying the `return` type can retrieve the value from the `result` using `name` as the key. `dataType` indicates the parameter type, supporting Java type notation, such as `java.lang.Integer` as mentioned above. `name` represents the variable name. `description` represents the variable description.

[0069] The start node can be represented by `start`. When implementing protocols and in visual editing, the corresponding visual operation page for the start node is as follows: Figure 3 As shown, the corresponding Java code is as follows:

[0070] <start id="1641383982432" name="开始" location="170,210,70,55">

[0071] <transition downstream="1641383988139">< / transition>

[0072] < / start>

[0073] Here, `transition` indicates pointing to the next node. `downstream` is the ID of the next node. The `id` attribute is a unique identifier for the node; please ensure it is unique. The `tag` attribute contains additional data for the node. The `name` attribute is the node name, which will be displayed on the flowchart. The `g` attribute is currently not relevant; it is useful for drawing the flowchart but does not affect the execution of the process.

[0074] The end node can be represented by `end`. When implementing protocols and visual editing, the corresponding visual operation page for the end node is as follows: Figure 4 As shown, the corresponding Java code is as follows:

[0075] <end id="1642229364875" name="结束" location="870,225,30,30">< / end>

[0076] The `id` attribute is a unique identifier for the node; please ensure it is unique. The `name` attribute is the node name, which will be displayed on the flowchart.

[0077] When implementing protocols and visual editing, the corresponding visual operation pages for Java nodes and Spring nodes are as follows: Figure 5 and Figure 6 As shown, the corresponding Java code is as follows:

[0078] <autotask id="1651067909383" name="自动节点" location="105,320,90,50">

[0079] <action type="spring-bean">

[0080] <spring-beanactionhandle clazz="cn.huolala.homonoia.integration.service.function.AmountDoubleServiceFunction" method="apply">

[0081] <var name="bo" datatype="cn.huolala.homonoia.integration.model.FulfillmentActionRightsEventBo" inouttype="param">< / var>

[0082] <var name="cn.huolala.homonoia.bo.FulfillmentRightsDetailBo" datatype="cn.huolala.homonoia.bo.FulfillmentRightsDetailBo" contextvarname="FulfillmentRightsDetailBo" inouttype="return">< / var>

[0083] < / spring-beanactionhandle>

[0084] < / action>

[0085] < / autotask>

[0086] It's worth noting that Java nodes are the most common type, primarily executing a piece of logic. Currently, it supports configuration for Spring Beans and regular Java Beans. The `action` parameter is the action to be configured. The `actionHandle` parameter configures the input and output parameters for this action. Ultimately, this node will be compiled into Java code as follows:

[0087] result = ((MockJavaClazz)ObjectFactory.getInstance("cn.huolala.optimus.mock.MockJavaClazz")).calPrice(_pContext);

[0088] ((MockSpringBean)BeanProvider.getBean("mockSpringBean")).sing(_pContext);

[0089] Capability nodes can be represented by the ability attribute. When implementing protocols and visual editing, the corresponding visual operation page for capability nodes is as follows: Figure 7 As shown, the corresponding Java code is as follows:

[0090] <ability id="1641383988139" name="正向执行" location="315,215,90,50">

[0091] <transition downstream="1641384059359">< / transition>

[0092] <abilityaction type="ability">

[0093] <abilityactionhandle abilityname="saga正向能力" method="action" classname="cn.huolala.homonoia.service.fsm.ability.SagaActionAbility">

[0094] <var name="dtmModel" datatype="cn.huolala.homonoia.service.fsm.model.DTMModel" contextvarname="dtmModel" inouttype="param">< / var>

[0095] < / abilityactionhandle>

[0096] < / abilityaction>

[0097] < / ability>

[0098] It should be noted that the capability node belongs to the DDD domain framework, where `abilityAction` represents the action that needs to be configured. `abilityActionHandle` configures the input and output parameters of this action. Ultimately, this node will be compiled into Java code as follows:

[0099] ((cn.huolala.homonoia.service.fsm.ability.SagaActionAbility)DDD.findAbility("saga positive ability")).action(dtmModel);

[0100] The step node can be represented by the word "step". In this application implementation, the relevant description of the step node "step" is the same as that of the capability node "ability", and they can be referred to each other. It will not be repeated here.

[0101] Decision nodes can be represented using the concept of "decision". When implementing protocols and visual editing, the corresponding visual operation page for decision nodes is as follows: Figure 8As shown, the corresponding Java code is as follows:

[0102] <decision id="1641384059359" name="判断节点" location="505,215,90,50">

[0103] <transition downstream="1642648069786" name="正向失败" expression="cn.huolala.homonoia.common.enums.DTMStatus.FAILURE.getCode().equals(dtmModel.getTransGlobalBo().getStatus())">< / transition>

[0104] <transition downstream="1642227090837" name="正向成功" expression="cn.huolala.homonoia.common.enums.DTMStatus.SUCCESS.getCode().equals(dtmModel.getTransGlobalBo().getStatus())">< / transition>

[0105] < / decision>

[0106] The `decision` node primarily executes a set of logic. Based on the resulting logical value, it evaluates an expression to determine the next branch in the flow. The engine makes logical selections based on the `expression` of the transition. For example, this node might be compiled into Java code.

[0107] if (cn.huolala.homonoia.common.enums.DTMStatus.FAILURE.getCode().equals(dtmModel.getTransGlobalBo().getStatus())) {

[0108] / / Positive failure

[0109] / / AbilityNode: Update state

[0110] ((cn.huolala.homonoia.service.fsm.ability.DTMStatusOpAbility)DDD.findAbility("DTM Status Update Capability")).updateDtm(dtmModel);

[0111] / / AbilityNode: Job execution

[0112] ((cn.huolala.homonoia.service.fsm.ability.DTMJobExecuteAbility)DDD.findAbility("DTM Job Ability")).execute(dtmModel);

[0113] } else if (cn.huolala.homonoia.common.enums.DTMStatus.SUCCESS.getCode().equals(dtmModel.getTransGlobalBo().getStatus())) {

[0114] / / Positive success

[0115] / / AbilityNode: Update state

[0116] ((cn.huolala.homonoia.service.fsm.ability.DTMStatusOpAbility)DDD.findAbility("DTM Status Update Capability")).updateDtm(dtmModel);

[0117] }

[0118] Script nodes can be represented by scriptTask. When implementing protocols and visual editing, the corresponding visual operation page for scriptTask is as follows: Figure 9 As shown, the corresponding Java code is as follows:

[0119] <scripttask id="9" name="原价" g="132,389,88,48">

[0120] <transition to="12" g=":-15,20">< / transition>

[0121] <action type="ql">

[0122] <actionHandle expression="price 1">

[0123] <var name="price" description="价格" datatype="java.lang.Integer" contextvarname="totalPrice" inouttype="param">< / var>

[0124] <var name="price" description="价格" datatype="java.lang.Integer" contextvarname="price" inouttype="return">< / var>

[0125]

[0126] < / action>

[0127] < / scripttask>

[0128] The `scriptTask` node is similar to the `decision` node, used to execute a piece of logic. However, while a `decision` node can execute a Spring Bean or a Java Bean, a `script` node specifies an expression. Currently, QL representation environment execution is supported. For example, the above will compile into Java code:

[0129] A loop node can be represented by loopProcess. For relevant descriptions of loop nodes, please refer to the prior art, which will not be repeated here.

[0130] Concurrent nodes can be represented using `parallelDecision`. When implementing protocols and visually editing concurrent nodes, the corresponding visual operation page for `parallelDecision` is as follows: Figure 10 As shown, the corresponding Java code is as follows:

[0131] <paralleldecision id="1652368708908" name="并行节点11" threadexecutorname="test" timeout="5000" location="190,185,90,50">

[0132] <transition downstream="1652365648354">< / transition>

[0133] <transition downstream="1652369279041">< / transition>

[0134] <transition downstream="1652369241343">< / transition>

[0135] < / paralleldecision>

[0136] <paralleldecision id="1650357588669" name="并行节点" location="375,220,90,50">

[0137] <transition downstream="1650293721496">< / transition>

[0138] < / paralleldecision>

[0139] It should be noted that two parallel nodes can generate multiple actions in parallel, as shown in the following code:

[0140] / / ParallelDecisionNode: Parallel Node 11

[0141] CompletableFuture <void>cf1652365648354 = CompletableFuture.runAsync(() -> {

[0142] / / AutoTaskNode: spring node

[0143] MockSpringBean bean = (MockSpringBean)cn.huolala.optimus.common.utils.ProxyUtils.getSpringProxy("mockSpringBean", 2, java.lang.RuntimeException.class);

[0144] bean.sing(_pContext);

[0145] }, test);

[0146] CompletableFuture <void>cf1652369279041 = CompletableFuture.runAsync(() -> {

[0147] / / AutoTaskNode: java node

[0148] result = ((MockJavaClazz)ObjectFactory.getInstance("cn.huolala.optimus.mock.MockJavaClazz")).calPrice(_pContext);

[0149] } ,test);

[0150] CompletableFuture <void>cf1652369241343 = CompletableFuture.runAsync(() -> {

[0151] / / AutoTaskNode: spring1 node

[0152] ((MockSpringBean)BeanProvider.getBean("mockSpringBean")).sing(_pContext);

[0153] / / AbilityNode: Ability 1

[0154] resultAbility = ((cn.huolala.optimus.mock.ability.MockAbility)DDD.findAbility("testAbility")).action(_pContext);

[0155] } ,test);

[0156] CompletableFuture.allOf(cf1652365648354,cf1652369279041,cf1652369241343).get(5000,TimeUnit.MILLISECONDS);

[0157] It should be noted that in practical applications, the concurrent node parallelDecision can also customize the thread and timeout, and the corresponding visual operation page is as follows: Figure 11 As shown, the corresponding Java code is as follows:

[0158] <threadexecutor name="test" corepoolsize="1" maximumpoolsize="2" keepalivetime="2000" workqueuecount="2000" namedthreadfactory="testname">< / threadexecutor>

[0159] First, set the thread pool parameters in the global variables, and then match them with the thread pool name of the parallel node. The code will automatically generate and configure the custom thread.

[0160] When setting a timeout on a parallel node, the code will automatically generate the timeout, specifically:

[0161] public static final Executor test = new ThreadPoolExecutor(1,2,2000,TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(2000))

[0162] CompletableFuture <void>cf1652369279041 = CompletableFuture.runAsync(() -> {

[0163] / / AutoTaskNode: Java node

[0164] result = ((MockJavaClazz)ObjectFactory.getInstance("cn.huolala.optimus.mock.MockJavaClazz")).calPrice(_pContext);

[0165] } ,test);

[0166] CompletableFuture.allOf(cf1652365648354,cf1652369279041,cf1652369241343).get(5000,TimeUnit.MILLISECONDS);

[0167] Parameter passing can be represented using ContextUtil, which supports input parameter configuration for each capability point and parameter passing between nodes. In other words, the workflow orchestration system supports input parameter configuration for each capability point and parameter passing between nodes through parameter passing, thereby reducing hard coding. ContextUtil represents the global context. The specific code for retrieving variable values ​​at the workflow dimension is:

[0168] ContextUtil.get(String flowCode, String code) / / flowCode represents the flow code, and code represents the variable name

[0169] Subprocesses can be represented using `subBpm`. When implementing protocols and visual editing, the corresponding visual operation page for `subBpm` is as follows: Figure 12 As shown, the corresponding Java code is as follows:

[0170] <subbpm id="1653455875261" name="子流程" subbpmcode="easy" type="process" waitforcompletion="false" waitfortrigger="false" location="435,355,90,50">

[0171] <transition downstream="1653455963972">< / transition>

[0172] <var name="num" datatype="java.lang.Integer" contextvarname="_pContext.get("result")" inouttype="param">< / var>

[0173] <var name="subresult" datatype="java.lang.String" contextvarname="String subresult" inouttype="return">< / var>

[0174] < / subbpm>

[0175] {

[0176] Map<String, Object> _subBpmContext = new HashMap<>();

[0177] _subBpmContext.put("num", (Integer)DataType.transfer(_pContext.get("result"), Integer.class));

[0178] String subresult = (java.lang.String)(ProcessEngineFactory.getProcessEngine().start("easy", _subBpmContext)).get("subresult");

[0179] _pContext.put("subresult", subresult);

[0180] ContextUtil.put("sub", "subresult", subresult);

[0181] ContextUtil.put("sub", "_subBpmContext", _subBpmContext);

[0182] }

[0183] The retry process can be represented by `retryCount` and `retryCondition`. The corresponding Java code for `retryCount` and `retryCondition` in the protocol implementation and visual editing is as follows:

[0184] <actionhandle bean="mockSpringBean" clazz="cn.huolala.optimus.mock.MockSpringBean" method="sing" retrycount="2" retrycondition="java.lang.RuntimeException">

[0185] It should be noted that retries are performed using retryCount and retryCondition.

[0186] cn.huolala.optimus.mock.MockJavaClazz instance = (cn.huolala.optimus.mock.MockJavaClazz)cn.huolala.optimus.common.utils.ProxyUtils.getJavaProxy("cn.huolala.optimus.mock.MockJavaClazz", 2, java.lang.RuntimeException.class,java.lang.Exception.class);

[0187] result = instance.calPrice(_pContext);

[0188] It's worth noting that Optimus is a very lightweight, high-performance, integrable, and scalable workflow engine. Optimus focuses on pure in-memory execution and is stateless. It allows developers to design their own business processes through a workflow platform, visualizing complex business logic. Optimus supports Data-Driven Design (DDD) concepts in code, lowering the barrier to entry for DDD. It supports visual workflow orchestration with a WYSIWYG interface, serving as a powerful tool for decoupling complex business logic. It provides a unified implementation protocol for all components, converting workflow files into compiled and runnable Java code—simple and efficient. It offers both serial and parallel modes, a node retry mechanism, automatic parameter passing, and configurability. Workflow design is currently done through a visual workflow platform that supports scripting languages.

[0189] Based on the above, the business process orchestration system based on the Optimus platform provided in this embodiment includes: a front-end unit and an Optimus data bridging unit; the front-end unit includes at least a building unit and a code preview unit, the building unit is used to visually drag and drop code components to build a business process, and the code preview unit is used to visually display the process code; the Optimus data bridging unit is used to generate process code and process configuration based on the business process built by the building unit, and to synchronize the process code and process configuration to various business services. When the business service starts, the business process is automatically orchestrated. By visualizing complex business logic, node errors can be avoided to a certain extent.

[0190] Understandably, this application utilizes visual orchestration components, allowing users to quickly assemble a business chain from even the most complex process structures by dragging and dropping nodes. Furthermore, Optimus is a stateless, in-memory execution process engine that converts process files into compiled Java code for execution. Optimus supports Data-Driven Design (DDD) for code implementation. Optimus supports multiple component nodes to accomplish complex business logic.

[0191] Optionally, in another embodiment of the business process orchestration system based on the Optimus platform provided in this application, such as Figure 13 As shown, the front-end unit also includes:

[0192] Isolation units are used to isolate business services and business versions.

[0193] In practical applications, the isolation unit is connected to the Optimus data bridge unit through the Java-psi interface; of course, it is not limited to this, and can be determined according to the application environment and user needs, all of which are within the protection scope of this application.

[0194] In this embodiment, isolating business services and business versions can effectively avoid interference between the two on process orchestration, further improving the convenience of user operation.

[0195] Optionally, in another embodiment of the business process orchestration system based on the Optimus platform provided in this application, such as Figure 14 As shown, it also includes:

[0196] Preload unit, used to preload bpm processes.

[0197] In practical applications, business process orchestration systems based on the Optimus platform can adopt the BPM protocol. Specifically, the Java code corresponding to the BPM protocol is as follows:

[0198] <bpm code="saga" name="saga.bpm" type="process">

[0199] The `code` attribute is the most important attribute in this application. When the engine starts executing the process, it will request the `code` parameter, which is the `code` field in the process file. The `code` attribute is conventionally represented by dots to indicate the directory level where the file is stored. For example, `saga` above indicates that the file is located under `resources`, named `saga.bpm`.

[0200] The code snippet is as follows:

[0201] ProcessEngineFactory.getProcessEngine().execute("saga", context)

[0202] In practice, by preloading the BPM process into memory when the business process orchestration system based on the Optimus platform starts, the time consumed by process initialization during the first call can be prevented. The corresponding Java code is as follows:

[0203] /

[0204] @Component

[0205] @Configuration

[0206] public class BpmInitializer implements InitializingBean,ApplicationContextAware {

[0207] @Override

[0208] public void afterPropertiesSet() throws Exception {

[0209] ProcessEngine processEngine = ProcessEngineFactory.getProcessEngine();

[0210] processEngine.preCompile("one");

[0211] processEngine.preCompile("two");

[0212] }

[0213] @Override

[0214] public void setApplicationContext(ApplicationContextapplicationContext) throws BeansException {

[0215] SpringApplicationContextProvider.applicationContext =applicationContext;

[0216] }

[0217] }

[0218] In this embodiment, the preloading unit for preloading the BPM process can preload the BPM process into memory when the business process orchestration system based on the Optimus platform starts, which can prevent the time spent on initializing the process during the first call.

[0219] Based on the above, in practical applications, the specific structure of this business process orchestration system based on the Optimus platform is as follows: Figure 15 As shown. Combined with Figure 15 This application has the following advantages:

[0220] ① For complex logic refactoring, simply break it down into smaller nodes according to business boundaries. Optimus provides a unified node standard; each component strives to ensure single responsibility.

[0221] ② Visual orchestration: When business functions are broken down into small nodes, they can be arranged arbitrarily. No matter how complex the structure, nodes can be quickly assembled into a business chain by dragging and dropping. It can be learned in just 10 minutes.

[0222] ③ Optimus empowers the system with the ability to adjust business logic in real time, change rules instantly, and hot-refresh the entire business chain. The process is completely smooth. Business logic can even be modified by defining script components.

[0223] ④ Optimus supports scripting languages, allowing users to define their own scripting language nodes for integration with Java components. Combined with hot refresh, this enables dynamic changes to online business logic.

[0224] Importantly, this application enables the implementation of Domain-Driven Design (DDD), based on DDD architectural principles and designed for complex business scenarios. It provides sufficient constraints through a code framework, ensuring DDD goes beyond mere conceptualization; lowers the barrier to entry for DDD, reducing the burden on developers and preventing implementation deviations; reduces complexity, ensuring the sustainable and transferable nature of business assets; abstracts core business processes, outlining the business platform skeleton, adapting to changing circumstances, and facilitating fill-in-the-blank development by developers; comprehensively addresses business uncertainties; expands and polymorphizes business logic, processes, logical models, and data models; the framework itself supports further expansion; it converts process files into compiled and executed Java code, offering simplicity and efficiency; it allows developers to design their own business processes through a process editor, visualizing complex business logic and bridging the gap between business designers and development engineers; and it expands business packages, with the framework's underlying ClassLoader mechanism providing business isolation and supporting hot updates without restarting.

[0225] The business process orchestration system based on the Optimus platform provided in this application can better build software (existing code can be easily addressed if unsatisfactory), reduce the complexity of code management (making the system controllable and avoiding endless scheduling issues and the constant influx of new PRDs), and make code domain knowledge (making code reflect business, supporting different granularities, perspectives, and dimensions to reduce costs in clarifying business, and ensuring consistent deliverables between product and technology teams by reflecting the content of the PRD). It also improves the efficiency of requirement transmission and reduces communication (business requirements lack effective transmission carriers and forms during modeling and decomposition, failing to accurately and seamlessly transmit to development, leading to repeated communication clarification, requirement rework, and repetitive workload; existing system capabilities are all reflected in the code, making PRDs / business process diagrams unreliable); requirement explanations will, as far as possible, involve relevant platform development colleagues, one... (Gathering a large meeting for requirements is extremely inefficient.) This approach aims to make business requirements more defined (how to elegantly address: the expansion of business logic, business models, and business processes; some if conditions and scenarios no longer exist, but we dare not delete them because their logic is scattered everywhere; for a specific business that we've been developing for months, how do we compile the code unique to that business; frequently, special scenarios require me to add fields, even tables, to the point that even the developers don't recognize them; but is it just a matter of one field? It involves a large number of changes, each field has its own background; another new scenario arises, and the process is different from before. I've already used template methods to solidify the process, what should I do?; how to quickly respond to all sorts of unique and personalized requirements while maintaining our own standards); Furthermore, it effectively addresses the pain point of developers not knowing where to write the code when they receive requirements, reducing the problem of constantly creating new concepts.

[0226] Addressing the characteristics of business development—variable, complex, and scattered—while technical development is stable, in-depth, and refined, this application directly tackles the root causes of problems (numerous and diverse business scenarios; numerous personalized requirements; a multitude of business terms, each potentially corresponding to a large number of fields, logic, and processes; long business processes, where errors at any node can cause overall bugs) and secondary causes (lack of top-level design leading to haphazard code; highly individualized coding styles and designs; lack of top-level logic and a lack of core logic; coupling of business and technology, preventing the code from reflecting the essence of the business; poor code quality; poor code interpretability; team size; staff turnover; project turnover; and delivery cycles). This application implements Business Process Orchestration (DDD) through a business process orchestration system based on the Optimus platform.

[0227] Optionally, embodiments of this application also provide a business process orchestration method, which should be the business process orchestration system based on the Optimus platform described in any of the above embodiments, such as... Figure 16 As shown, the method mainly includes steps S101 to S103:

[0228] S101. Respond to user visual operations and build business processes.

[0229] S102. Generate process code and process configuration based on the established business process.

[0230] In some embodiments, the specific process of step S102, generating process code based on the constructed business process, is as follows:

[0231] The established business process is converted into XML protocol format;

[0232] The business process in XML protocol format is parsed to obtain the process code, which is Java code.

[0233] It should be noted that the relevant explanations regarding step S102, generating process code based on the established business process, can be found in the above embodiments, and will not be repeated here.

[0234] S103. Visualize the process code and synchronize the process code and process configuration to each business service. When the business service starts, the business process will be automatically orchestrated.

[0235] The business process orchestration method provided in this embodiment is applied to a business process orchestration system based on the Optimus platform as described in any of the above embodiments. The method includes: responding to user visual operations and building a business process; generating process code and process configuration based on the built business process; visually displaying the process code and synchronizing the process code and process configuration to each business service; automatically performing business process orchestration after the business service starts; and visualizing complex business logic to avoid node errors to a certain extent.

[0236] It should be noted that the relevant explanations of each step in the business process orchestration method can be found in the corresponding embodiments mentioned above, and will not be repeated here.

[0237] Optionally, the business process orchestration method provided in this embodiment further includes step S201:

[0238] S201, Preload the bpm process.

[0239] This embodiment preloads the BPM process into memory when the business process orchestration system based on the Optimus platform starts, which can prevent the time spent on initializing the process during the first call.

[0240] It should be noted that the relevant explanations of each step in the business process orchestration method can be found in the corresponding embodiments mentioned above, and will not be repeated here.

[0241] Optionally, the business process orchestration method provided in this embodiment further includes step S301:

[0242] S301. Isolate business services and business versions.

[0243] In this embodiment, isolating business services and business versions can effectively avoid interference between the two on process orchestration, further improving the convenience of user operation.

[0244] It should be noted that the relevant explanations of each step in the business process orchestration method can be found in the corresponding embodiments mentioned above, and will not be repeated here.

[0245] The specific implementation processes and derivative methods of the above embodiments are all within the protection scope of this invention.

[0246] The various embodiments in this specification are described in a progressive manner. Similar or identical parts between embodiments can be referred to mutually. Each embodiment focuses on describing the differences from other embodiments. In particular, for system or system embodiments, since they are basically similar to method embodiments, the description is relatively simple, and relevant parts can be referred to the descriptions in the method embodiments. The systems and system embodiments described above are merely illustrative. The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the modules can be selected to achieve the purpose of this embodiment according to actual needs. Those skilled in the art can understand and implement this without creative effort.

[0247] Those skilled in the art will further recognize that the units and algorithm steps of the various examples described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, computer software, or a combination of both. To clearly illustrate the interchangeability of hardware and software, the components and steps of the various examples have been generally described in terms of functionality in the foregoing description. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementations should not be considered beyond the scope of this invention.

[0248] The above description of the disclosed embodiments enables those skilled in the art to make or use the invention. Various modifications to these embodiments will be readily apparent to those skilled in the art, and the general principles defined herein may be implemented in other embodiments without departing from the spirit or scope of the invention. Therefore, the invention is not to be limited to the embodiments shown herein, but is to be accorded the widest scope consistent with the principles and novel features disclosed herein.< / bpm> < / actionhandle> < / void> < / void> < / void> < / void>

Claims

1. A business process orchestration system based on the Optimus platform, characterized in that, include: Front-end unit and Optimus data bridge unit; The front-end unit includes at least a building unit and a code preview unit. The building unit is used to visually drag and drop code components to build a business process, and the code preview unit is used to visually display the process code. The Optimus data bridging unit is used to generate the process code and process configuration based on the business process built by the building unit, and to synchronize the process code and process configuration to each business service. When the business service starts, it automatically performs business process orchestration.

2. The business process orchestration system based on the Optimus platform according to claim 1, characterized in that, The front-end unit also includes: An isolation unit is used to isolate the business services and business versions.

3. The business process orchestration system based on the Optimus platform according to claim 2, characterized in that, The isolation unit is connected to the optimus data bridge unit via a Java-psi interface.

4. The business process orchestration system based on the Optimus platform according to claim 1, characterized in that, The Optimus data bridging unit is used to generate the process code based on the business process built by the building unit, including: The business process built by the aforementioned building unit is converted into XML protocol format; The business process in XML protocol format is parsed to obtain the process code, which is Java code.

5. The business process orchestration system based on the Optimus platform according to claim 1, characterized in that, Also includes: Preload unit, used to preload bpm processes.

6. The business process orchestration system based on the Optimus platform according to claim 1, characterized in that, At least including: Global variable node, start node, end node, Java node, Spring node, capability node, step node, condition node, script node, loop node, and concurrency node; And / or, Parameter passing; And / or, Subprocess; And / or, Retry process.

7. A business process orchestration method, characterized in that, The method, applied to the business process orchestration system based on the Optimus platform as described in any one of claims 1-6, comprises: Build business processes in response to user visual actions; Generate process code and process configuration based on the established business process; The process code is visualized and the process configuration is synchronized to each business service. Once the business service is started, the business process is automatically orchestrated.

8. The business process orchestration method according to claim 7, characterized in that, Based on the established business process, process code is generated, including: The established business process is converted into XML protocol format; The business process in XML protocol format is parsed to obtain the process code, which is Java code.

9. The business process orchestration method according to claim 7, characterized in that, Also includes: Preload the bpm process.

10. The business process orchestration method according to claim 7, characterized in that, Also includes: The business services and business versions are isolated.

Images