BPMN2 new Norm and Activiti5

After the 90 's, with the establishment of the WFMC Alliance, the BPM market crowded in full swing, the workflow technology has been developed rapidly, including IBM, Oracle and other large software vendors in the field of work flow of the banner of the party. The release of the new BPMN2.0 in 2011 provides a unified standard for interoperability of workflow products, ending the fragmentation of each workflow vendor.

What is BPMN, Workflow?

• BPM (Business process Management)-"to break down cross-departmental cross-system business process dependencies and increase operational efficiency and effectiveness by modeling, automating, managing, and optimizing processes".

• workflow--"All or part of a business process supported or automatically handled by a computer" (a classic definition of workflow concept by the Workflow Management Alliance WFMC Organization)

BPM basic content is the process of managing the established work, through the service orchestration, unified control each business process, to ensure that the work at the right time by the right people to execute, to optimize the overall business process. The implementation of BPM concepts requires a standardized process definition language to support and describe specific business processes using a unified language that follows consistent standards, which are described by proprietary engines to drive execution. The engine is the workflow engine, which acts as the core engine of BPM, provides interpretation, execution, and orchestration for each business process definition, drives the process "moving", and "flows" the work of everyone, providing a basic, core source of power for BPM applications.

In reality, there are unavoidable cross-system cross-business situations, while most enterprises in the process of information construction is phased or sub-sector (subsystem) step, the basis of late implementation may be the output of the early implementation results, in the coupling business implementation phase, the same business process may be reused in different stages of implementation, In the process of process combing, the process description language used in different stages of implementation will be different (service vendors differ), some use WfMC's xpdl, some use BPML, BPEL, WSCI, etc., which results in process management, business integration there is a great consistency, limitations, Increases the cost of enterprise application integration.

Introduction of BPMN2.0 Specification

Workflow products that follow the new specification of BPMN2.0 can solve such problems to a large extent. The biggest difference between BPMN2.0 and the old 1.0 specification and XPDL, BPML, and BPEL is that they define the execution semantics and format of the specification, use standard primitives to describe the real business process, and ensure that the same process is consistent with the execution results of the different process engines. BPMN2.0 defines three basic elements of process execution semantics, which are "kick" for everyday business processes:

• Activities (activity)-all life-cycle states in a workflow can be called "activities", such as atomic-level tasks (Task), flow (Sequence flow), and sub-processes (sub-process), etc.
• Gateways (Gateway)-As the name implies, the so-called "gateway" is used to determine the flow direction of the process, may be used as a conditional branch or aggregation, can also be used as a parallel execution or event-based criteria for the exclusive use of the judgment
• Events-a very important concept in BPMN2.0 execution semantics, such as start, end, boundary conditions, and the creation, start, and flow of each activity are process events, with event mechanisms that can be used to add accessibility to the system through event controllers, such as other business system integrations, Activity alerts, etc.

The definitions of these three types of execution semantics cover the sequence flow (process steering), task (tasks), sub-process (sub-process), Parallel Gateway (parallel execution Gateway) commonly used in business processes, Common primitives such as Exclusivegateway (gateway-type gateways), Inclusivegateway (inclusive gateways), 1:

Figure 1:bpmn2.0 Three types of basic execution semantic elements

All business segments of the real business are inseparable from activities, gateways and events, whether it is a simple conditional approval or a complex parent-child process cycle, in a process definition description, all business segments are inseparable from task, Sequence Flow, Exclusive Gateway, Inclusive Gateway (the element shown in the right green marker in 1), where Task is a powerful element that describes all the behaviors that can occur in a business process, including user task, Manual task, Service task, Script task, etc., can be used to describe human-computer interaction tasks, offline operations tasks, service calls, script computing tasks and other general functions.

User task: The generation of human-computer interaction tasks, mainly used to describe the need for people in the software system such as task detail inspection, fill in the approval comments and other business behavior, the process engine flow to such a node, the system will automatically generate a passive trigger task, must manually respond to continue to flow downward. Commonly used in the definition of approval tasks.

Manual Task: Offline human operations tasks, often used in order to meet the flowchart of the actual business definition of the integrity of the process-driven offline tasks, that is, such tasks do not participate in the actual workflow flow. It is often used for the description of tasks such as loading and transportation in a logistics system.

Service task: Services tasks, which typically involve the invocation of a system service API call with itself or with an external service, which is often assumed by a Java class with a specific business service function, unlike the user task, The process engine flows through this node to automatically invoke the method defined in the Java class, and the method executes automatically down a process node flow. In addition, such tasks can act as conditional routing to automatically determine the optional branch of process flow. Commonly used in calls to business logic APIs.

Script Task: Scripting tasks, which participate in the calculation of process variables with the "script" declaration or syntax during process flow, currently supports three types of scripts: Juel (i.e. JSP EL), groovy, and JavaScript. A shell task has been added to the Activiti5.9 to handle shell script files defined externally by the system, as well as with script Task functions. Often used for processing of process variables.

BPMN2.0 Process Example

BPMN2.0 defines standard symbols for all business elements, different symbols represent different meanings, and in the case of the absence process in the OA application, the standard BPMN2.0 element is used to define the schematic 2:

Figure 2:bpmn2.0 Absence process definition

In the above process, the implementation of the semantic elements involved in the main Table 1 in the 8 categories:

Table 1: Elements used in the leave process

In addition to the BPMN2.0 elements of the start event, User task, Exclusive Gateway, Parallel Gateway, Service task, End event Standard, the above flowchart also uses lane Set (business unit, Human resources department, attendance system), which represents the departments or roles involved in the process activities, the concept of Lane is the same as the concept of "swimlane" in JBPM4, and it is used to denote the attribution of similar tasks in the same category.

One of the most notable features of applying the BPMN2.0 standard is that people at different stages can work on a flowchart to avoid deviations from business understanding, whether they are demand analysis, profile design, detailed design, or specific business implementations. The implementation of a system, Requirements analysts can use the BPMN2.0 standard entity to sketch the collected requirements, and then you can give the designer to discuss the specific business requirements of the functional design, by the designers on the basis of the sketch gradually refinement, and get the approval of the needs of personnel; The designer then gives the detailed flowchart to the developer, lists the function points to be implemented, and points out the flow Process map on the activities of the activity node, designers and developers to reach a consensus on the basis of this figure, into the specific development phase; If the late leave process changes, is still in the existing flowchart changes, as the project progresses, the flowchart is also evolving, but to the end, the project audience use the same flowchart to communicate, Ensuring the consistency of the understanding of demand, to some extent, promotes the agility of the project.

ACTIVITI5 support for the latest BPMN2.0 specification

As an open source workflow engine that supports the latest BPMN2.0 specifications, ACTIVIT5 defines the vast majority of the elements of the specification and can meet the complex applications of enterprise workflows. It is a non-intrusive, embedded and independent deployment of open source workflow engine, is Tom Bayen left JBoss joined alfresco company after the other hill, co-development Activit5 in addition to alfresco and SpringSource, MuleSoft, salves, Fusesource, Signavio and other companies. From Activiti5.0 to the current 5.9 (released this March), the version update iteration is fast, the new version features a stable, well-performing, and provides the open source community with a very competitive alternative to business workflows.

The difference from jBPM5

It is worth mentioning that both ACTIVITI5 and jBPM5 are industry-leading open source workflow engines that support BPMN2.0 's latest specification, based on Apache License, which complies with the Java EE specification, providing workflow modeling, execution, and monitoring of process lifecycle processes. However, the design concepts and technical composition of the two are very different, see table 2 below:

Serial number	Technical composition	Activiti	Jbpm
1	Database Persistence Layer ORM	MyBatis3	Hibernate3
2	Persistence standards	No	JPA specification
3	Transaction management	MyBatis mechanism/spring Transaction control	Bitronix, based on JTA transaction management
4	Database connection mode	Jdbc/datasource	Jdbc/datasource
5	Support Database	Most databases such as Oracle, SQL Server, MySQL, and more	Most databases such as Oracle, SQL Server, MySQL, and more
6	Design Patterns	Command mode, observer mode, etc.
7	Internal service communication	Call between service via API	Based on Apache Mina asynchronous communication
8	Integrated interface	SOAP, Mule, RESTful	Message communication
9	Supported process formats	BPMN2, XPDL, JPDL, etc.	Currently only supports BPMN2 XML
10	Engine Core	PVM (Process virtual machine)	Drools
11	Technology predecessor	JBPM3, JBPM4	Drools Flow
12	Affiliated Companies	Alfresco	jboss.org

Table 2:activiti5 and JBPM5 technology composition

ACTIVITI5 uses spring for engine configuration and individual bean management, using IOC and AOP techniques, using CXF as the basis for Web services implementations, and using MyBatis to manage the underlying database ORM. Pre-provided bundle packages can be easily integrated with OSGi and can be built through integration with mule ESB and interfaces to external services (WEB service, restful, etc.) to build a comprehensive SOA application JBPM5 uses most of the components of the jboss.org community to drools flow as the core component of the process engine, hibernate as a data persistence ORM implementation using JPA/JTA-based pluggable persistence and transaction control specifications, Use Guvnor as a process management warehouse to integrate with seam, Spring, OSGi, and more.

It is necessary to point out that ACTIVITI5 is developed on the basis of jBPM3 and JBPM4, is the continuation of the original JBPM, and jBPM5 is not much related to jBPM3 and jBPM4 before, and abandons the highly respected PVM (process virtual machine) thought, Instead of choosing JBoss's own product drools flow as the core implementation of the process engine, the most important "human-Computer Interaction" task (similar to an approval activity) of the workflow is implemented by a separate piece of "Human task Service" attached to drools flow, the task's query, Processing behavior is accomplished through the Apache Mina asynchronous communication mechanism.

Pros and cons comparison:

From the technical composition, Activiti's biggest advantage is the use of PVM (process virtual machine), support in addition to the BPMN2.0 specification of the process format, and external services have good integration capabilities, continue to jBPM3, jBPM4 good community support, clear service interface, chain API more elegant The disadvantage is that the persistence layer does not follow the JPA specification.

JBPM's biggest advantage is the use of the Apache Mina asynchronous communication technology, the use of JPA/JTA persistence standards, a full-featured Guvnor as a process warehouse, Redhat (jboss.org by Red Hat acquisition) professional support; But its disadvantage is also obvious, Reliance on its own technology is too tight and currently supports only BPMN2.

ACTIVITI5 design mode

The command pattern can separate the issuing and execution of commands, delegate to different objects, each command represents an instruction, and the greatest benefit is that it provides a public interface that allows the user to invoke all transactions in the same way, while also making it easy to add new transactions to extend the system.

ACTIVITI5 has a large number of command modes, all of which are implemented using this pattern during a process run, such as process deployment, process flow, acquisition tasks, etc., involving four important concepts:

The COMMAND:ACTIVITI5 command defines the interface, with only one Execute method, and all the instructions that are executed by the runtime implement the interface, defining the specific behavior to be performed.

Commandcontext: The context in which the command executes, the execution of each command depends on its context, and Commandcontext creates the engine session and the database session during the execution of the command. Each commandcontext is a separate threadlocal that is thread-safe during execution and is not interfered with by other threads.

Commandexecutor: Command executor, responsible for executing all run-time command. The execution of the instructions in the engine (that is, the creator of the command may originate from a variety of objects) is commandexecutor processing with only one interface method: Execute (Command command). Activitybehavior: The activity behavior definition, which defines the behavior of each element of the BPMN2.0 execution semantics layer in the process engine, or is known as the feature of the entity. Similar to the concept of command, it simply describes what the "pending" instructions are and what happens, but the engine is responsible for driving the actual execution.

The human-Computer interaction task is the most common business type in the business process application, and the typical element of "task" defined in BPMN2.0 describes the application of the command pattern in ACTIVITI5:

ACTIVITI5 defines the task interface for the BPMN2.0 task element, According to the semantic.xsd execution semantics, the behavioral characteristics of the related task elements are defined, and this behavior attribute binds the behavior and elements through the Setactivitybehavior method, which will be triggered when the process engine is driven to the active node, by execute (Activityexecution execution) performs the operation specified in the Activitybehavior;

Each activity has a number of command correspondence with it, such as Claimtaskcmd, Completetaskcmd, Delegatetaskcmd, Savetaskcmd, Deletetaskcmd, respectively, indicating the task of the collection, completion, transfer, Save, delete, and so on, the execution results of these operation instructions are obtained through the command execution context (Commandcontext) to the taskmanager of the DAO layer to persist the change of the task object into the database;

The engine does not care what to do, and any class that implements the command interface can be executed through commandexecutor, and in addition to these native task instructions provided by the engine, a set of commands can be customized if the business system has additional attributed operations. In Command.Execute () Free call external services, send SMS messages, additional task properties, call DAO operation database, etc., the package is completed by the engine to execute, you can get the desired results. Similarly, if you need to customize a BPMN element or attribute in a business system, you only need to synchronize the implementation of the Activitybehavior interface to add the custom behavior implementation to the element (attribute) when parsing the process definition file and cache it for automatic execution when the engine driver reaches the node. In Activitybehavior. Execute () can still invoke a variety of APIs that have been implemented for specific business purposes.

It should be noted here that Activiti5 's commandcontext is a transactional one, and commits the transaction every time the context is closed, but in the actual business system, the business transaction, engine transaction, and database transaction should be managed in a single transaction. This requires merging the transactions of the Activiti5 with the transactions of the business system. ACTIVITI5 provides the possibility of this approach through spring injection, where transaction control within the engine can be delegated to the business layer to process, and when the engine configuration is initialized, After the DataSource and TransactionManager defined in the business system are passed to the DataSource, TransactionManager properties of the process configuration, The ACTIVITI5 internally uses the Transactionawaredatasourceproxy provided by spring to encapsulate the incoming datasource and take advantage of the external transaction management to take over the ACTIVITI5 transaction control. Ensures that the database connection obtained from the DataSource is perfectly combined with the transaction defined by Spring to enable integration of business systems and engine system transactions.

ACTIVITI5 parsing of BPMN2.0 execution semantics

Activiti5 the parsing of BPMN2.0 XML process definition files by Bpmnparse using sax, which is the core class of parsing, parsing from the root node, and sequentially on Definitionsattributes, Imports, Itemdefinitions, Messages, Interfaces, and Errors and processdefinitions elements (all of which are standard BPMN2.0 elements), and finally parse the diagraminterchangeelements element responsible for the process visualization definition. Each parsing element will determine the element type, and if it is an "activity" type (including task, gateway, etc.), the corresponding Activitybehavior will be set for the activity, and if additional attributes are defined in the process definition file, Activiti5 will use the reflection mechanism to inject itself into the activitybehavior.

In addition to command and Activitybehavior, ACTIVITI5 also introduced a large number of monitoring mechanisms (interceptor concept), the current engine mainly consists of four types of monitoring:

• BPMN Analytic Monitoring--bpmnparselistener, responsible for the BPMN2.0 specification of the process definition file for parsing control;
• Task monitoring--tasklistener, responsible for the status of all kinds of tasks and task creation, assign responsible person, complete the task three types of events to respond;
• Perform the monitoring--executionlistener, add auxiliary control function to the execution process, and respond to the start, flow and end events occurring in the engine;
• Transaction monitoring--transactionlistener, responsible for transaction control monitoring.

PVM process virtual machine contains three types of events: Start, end, take, respectively, the start, flow and end of the process, after the process starts, the flow engine starts from the start event, through the taken event, the driving process flows to the next link, the "Flow" will be monitored by the atomicoperationtransitionnotifylistenertake of the PVM runtime, and the listener will execute all the execution listeners attached to the flow. There are also three types of events that can be monitored: Create, assignment, complete, and if you want to add additional accessibility features after a task has been created or assigned to a responsible person or task, the implementation class for the Tasklistener interface can be created. and define it in the execution definition element, ACTIVITI5 will handle all this. These listeners are essentially active add-ons, adding an additional management control to the existing operations to achieve a special purpose, activitybehavior from another point of view is also a proxy, is the delegateinvocation responsible for invoking execution, It is primarily used to provide a context for user code invocation and is responsible for controlling the actual invocation, and ACTIVITI5 provides five implementations for it: Activitybehaviorinvocation, Executionlistenerinvocation, Expressioninvocation, Javadelegateinvocation, Tasklistenerinvocation.

ACTIVITI5 provides the command, Activitybehavior, listener and other interfaces to facilitate the expansion of the engine, if the functions of the business system can not be satisfied when the implementation of these interfaces, in a non-intrusive way to expand the Activiti5, With these extension interfaces, many business logic can be accomplished in its execution methods, such as permission checking, interaction with business systems, integration with external systems, and even replacing the original functionality rescue obedient while look.

ACTIVITI5 API App

Processengine is the core interface of the Activiti system, and the seven Class basic service interface is acquired through Processengine, which is intuitive and easy to use by using the chain API approach:

Repositoryservice:

The interface of the process resource service, which is used primarily for deployment, query, and deletion of process definitions. The deployment of the new process uses the Createdeployment (). Addresourcexxx (). Deploy () method, and queries for the deployed process are obtained using createdeploymentquery () additional query criteria Alternatively, you can use the Deletedeployment and Deletedeploymentcascade methods to delete or cascade the process.

Taskservice:

A task service interface that exposes operations such as task picking (claiming), task completion (completing), and task assignment (assigning) that manage human-computer interaction tasks, including creating, querying, saving, deleting, and so on.

Runtimeservice:

The runtime service is primarily used to start or query process instances, as well as process variables, queries for current activation status activities, deletion of process instances, and so on. What the process produces during the process can be handled using that interface.

Historyservice:

Service interface for process history. Provides queries and deletions of historical process instances, historical tasks, and, from the provided API, the query of the historical process that provides queries for the finished and unfinished processes, that is, Historyservice provides the activities of the completed and currently executing processes/ Task query, which seems to have some conflict with the query provided by Runtimeservice, but in fact there is a difference, the runtime information only contains the actual running state information of the activity at any time (from the execution performance of the process), and the historical information is the cured information to do simple query and optimization, The objects they hold are different.

Identityservice:

User, Group Management Service Interface, for managing group, user's additions and deletions, and maintenance of membership, involving the API NewUser, NewGroup, Saveuser, Savegroup, Createmembership and the associated deletexxx method.

Formservice:

The form service is used to access the form data and the rendered form that is required when a new process instance is started or when the task is completed, providing a UI interface to assist users in filling in related values to save to process variables. This service is not commonly used in real business applications and belongs to the non-core services of the engine.

Managementservice:

Interface services that provide process management and control operations are not associated with the operation of the business process, such as querying the contents of the database itself, activiti versions, and sequence generation ID rules, which belong to the engine's non-core services.

ACTIVITI5 Workflow engine applications need to first grasp the configuration and API basic applications, the following BPMN2.0 leave process as an example, the application of ACTIVITI5 in the specific system.

Step1: Drawing a leave flowchart

The leave flowchart uses standard BPMN2.0 elements for process definition, can be written using any XML authoring tool (importing XSD can provide code hints for writing), and is recommended for visualization using Joinwork process Studio, 3:

Figure 3:STEP2 Configuring the ACTIVITI5 environment

The process engine environment mainly involves three aspects: data source, transaction management, and process engine configuration instance. Usually the process engine is only a core module of the business system, its data sources and transactions are delegated to the business platform, in the process engine configuration definition, the business system's DataSource and TransactionManager can be injected to the ACTIVITI5 engine configuration through Ref:

                                        <beanid= "Processengineconfiguration" class= "org.activiti.spring.springprocessengineconfiguration" >                                             <propertyname= "DataSource" ref= "DataSource" >                                             <propertyname= "TransactionManager" ref= " TransactionManager ">                                             <propertyname=" databaseschemaupdate "value=" true ">                                             <propertyname=" Jobexecutoractivate "value=" false ">                                        

If you are applying Activiti5 in an OSGi environment, you also need to introduce the DataSource and TransactionManager registered in the business environment into the current bundle as OSGi service. Then configure the processengineconfiguration:

                                        <osgi:referenceid= "DataSource" interface= "javax.sql.DataSource" >                                        <osgi:referenceid= " TransactionManager "interface=" Org.springframework.transaction.platformtransactionmanager ">

STEP3: Deploy the Leave process definition file to the ACTIVITI5 environment

Implement process deployment with the Repositoryservice interface provided by the process engine:

Get Repositoryservicerepositoryservicerepositoryservice = Processengine.getrepositoryservice () via processengine;// Use Repositoryservice for a new process deployment repositoryservice.createdeployment (). Addclasspathresource ("Absence request-conditional branching and merging process. Bpmn20.xml "). deploy ();

STEP4: Create a Leave list page enter the days of leave and the original, start the process

Write the HTML form input interface and then use AJAX to submit the request, create a new process instance from the servlet based on the request parameters, start the Process interface 4:

Figure 4: The interface after the process is started

Enter the number of days to leave and why, if the number of days is greater than or equal to 3 days, go to the department manager approval Route branch and use jquery to bind the Submit button action:

$ (' #startProcess '). Click (function () {            varURL = '/com.ygsoft.process.demo/processengineservlet?operate=start & ' +$ (' #inputform '). Serialize ();                        Submitted in UTF8:            $.ajax ({                url:url,                type: "POST",                dataType: "JSON",                contentType: "application/ X-www-form-urlencoded;charset=utf-8 ",//This parameter avoids Chinese garbled                success:function (data) {                    if (data.success) {                        alert (' Your document has been submitted, Process ID: ' +data.id ';                        $ (' #inputform '). Hide ();                        $ (' #viewTodo '). Show (+);                    } else{                        alert (' Your document was not submitted successfully ');}})        

The backend end uses the Runtimeservice interface to create a new process instance:

Get Runtimeserviceruntimeserviceruntimeservice = Processengine.getruntimeservice () via processengine;// Make request parameters available from request to construct process startup parameters map                                        <string, object= "" >                                             params = Newhashmap                                             <string, object= "" >           (); String Processkey = Request.getparameter ("Processkey"); int day = Integer.parseint (Request.getparameter ("Day")); String reason = Request.getparameter ("Reason");p arams.put ("Day", day);p arams.put ("user", user);p arams.put ("Reason", Reason); Start the process instance using Runtimeservice (parameters are handled as process variables) processinstanceprocessinstance = Runtimeservice.startprocessinstancebykey ( Processkey,params);                                                  

STEP5: Get approver to-do tasks

Using the Taskservice interface is the implementation of the assigned Self and Candidate tasks://Get taskservicetaskservicetaskservice by Processengine = Processengine.gettaskservice ();//Use Taskservice to get candidate tasks based on User ID list Tasks                                                                                      = Taskservice.createtaskquery (). Taskassignee (user). Orderbytaskcreatetime (). DESC (). list ();                                        

The query to the list is converted to a JSON array via Gson to the front end, which is parsed by jquery and displayed to the interface.

Another scenario is to query for a candidate task assigned to a group or someone:

List                                                                                      tasks = Taskservice.createtaskquery (). Processinstanceid (Processinstance.getid ()). Taskcandidategroup (" Xxxgrp "). List ();//or list                                                        tasks = Taskservice.createtaskquery (). Processinstanceid (Processinstance.getid ()). Taskcandidateuser ("Xxxuser"). List ();                                                  

STEP6: Approver View task details

Task details include information about the task itself, such as its name, description, and process variables, as well as a visual flowchart of the currently active task.

The task information can be obtained from the list, and the visual flowchart can be output to the front end using the following methods:

// 根据当前Task获取流程定义对象 ProcessDefinitionEntityprocessDefinition = (ProcessDefinitionEntity) ((RepositoryServiceImpl) repositoryService) .getDeployedProcessDefinition(task.getProcessDefinitionId()); // 利用ProcessDiagramGenerator生成当前激活任务的图片流 InputStreamdefinitionImageStream = ProcessDiagramGenerator.generateDiagram(processDefinition, "png", runtimeService.getActiveActivityIds(task.getProcessInstanceId())); // 将图片流生成byte[]数组 byte[] diagramBytes = IoUtil.readInputStream(definitionImageStream,null); response.setContentType("image/png");// 设置浏览器响应的ContentType ServletOutputStream out = response.getOutputStream(); out.write(diagramBytes);// 输出至前端 out.close();

STEP7: Completing the approval task

After reviewing the leave requisition, the approver submits the "complete task" request in AJAX form, and the servlet uses Taskservice to submit the task:

Complete the current task first: Map                                        <string, object= "" >                                             params = taskservice.getvariables (taskId); String reviewmessage = Request.getparameter ("msg"); String choice = request.getparameter ("choice"); Params.put ("msg", choice+ "-" +user+ "-" +reviewmessage "); Taskservice.complete (taskId, params);                                         

After the first approval is completed, the process engine generates a task event, which is processed by a parallel gateway, and the system generates the Usertask task and the Servicetask task of "automatic filing", where the Servicetask task will be automatically executed by the system. The Manpower Commissioner confirms that "the task is still completed by STEP5, 6, 7, and when both tasks are completed, the two routing branches are routed from the" merge "route to the" End "node, at which point the process ends.

Through the application analysis of the above API, Activiti5 API is composed of clear, targeted, and different functions are completed by the corresponding service interface, and the interface is more friendly.

Summarize

BPMN2.0 is a workflow industry standard that regulates the implementation of large-scale vendors and open-source workflow products, Activiti5 realizes most of the element definition and execution semantics of the standard, powerful, ACTIVITI5 can work with IBM, The core functionality of large commercial workflow product process engine nodes such as Oracle is comparable, and in order to simplify the application and extend the original functionality, ACTIVITI5 also customizes 6 extension elements and 15 extended attributes, which can be combined with the BPMN specification to achieve more and more practical business functions.

Through the technical composition, the coverage of the BPMN specification, API application friendliness, community support, third-party component dependencies and scalability of six aspects of analysis and comparison, Activiti5 's comprehensive strength. For the selection of workflow products conforming to the BPMN standard, this is a benevolent see problem, on the one hand, relying on the historical accumulation of the workflow technology of each company, on the other hand, the specific situation of the specific project should be treated differently. But if for a brand-new project or to jBPM3, 4 design concept of the company, may wish to consider Activiti5.

BPMN2 new Norm and Activiti5