工作流flowable框架搭建及剖析

前言

搭建flowable并没有想象中难，我自身纯手动搭建也就花了1个小时整合到spring boot框架中，简单地实现了一些接口，至于要整合到实际项目中要看实际项目的需求，建议是往通用的方向实现，这样可以做到一劳永逸，不至于每个新的流程都要另起一套接口。
点击获取项目demo

准备工作

1. 创建一个maven项目，pom文件如下：

	

    4.0.0

    org.example
    workflow
    1.0-SNAPSHOT

    
        org.springframework.boot
        spring-boot-starter-parent
        2.2.6.RELEASE
         
    

    
        
            org.springframework.boot
            spring-boot-starter
        

        
            org.springframework.boot
            spring-boot-starter-web
        

        
            org.apache.httpcomponents
            httpclient
        
       
        
            org.flowable
            flowable-spring-boot-starter
            6.3.0
        
       
        
            org.flowable
            flowable-cmmn-engine
            6.3.0
        
        
        
            mysql
            mysql-connector-java
        

        
        
            org.mybatis.spring.boot
            mybatis-spring-boot-starter
            1.3.1
        

        
            com.alibaba
            fastjson
        

        
        
            org.slf4j
            slf4j-api
        

        
            org.slf4j
            slf4j-log4j12
        

        
        
            io.springfox
            springfox-swagger2
            2.9.2
        

        
            io.springfox
            springfox-swagger-ui
            2.9.2
        

        
        
            org.springframework.boot
            spring-boot-starter-aop
        

    

    
        
            
                kr.motd.maven
                os-maven-plugin
                1.5.0.Final
            
        

        
            
                org.apache.maven.plugins
                maven-compiler-plugin
                
                    11
                    11
                    UTF-8
                
            

            
                org.springframework.boot
                spring-boot-maven-plugin
                
                    true
                
                
                    
                        
                            repackage
                        
                    
                
            
            
                org.apache.maven.plugins
                maven-resources-plugin
                
                    UTF-8
                
            
           
        
    

2. 创建项目目录结构
   
3. 下载actiBPM插件
   actiBPM插件下载参考
   actiBPM插件是在idea工具上使用的，如果你使用的eclipse开发工具，用flowable designer可视化插件
4. 流程画图
   下面是我画的一个对账单流程图，示例如下：
   
   流程画图分几部分：
   • 流程开始、结束节点
   • 用户任务节点
   • 流程指向箭头（附带流程条件）
   • 网关（控制流程指向哪个节点）
     其实，这个文件生成的是一个xml,有几处参数需要去配置：

整个流程的ID与名称配置

节点配置ID和名称

节点指定用户或用户组可以在文件生成之后在通过文本编辑器上修改，因为这个插件支持activiti,并不完全支持flowable,所以展示不了flowable的标签

流程指向箭头配置流程条件和名称

• approved && !((total_amount - advance_amount) >= 300000000 || adjust_amount >= 20000000 || (adjust_amount * 50) >= total_amount)
  这种就是流程条件，里面的每个变量都是流程变量，后续会通过代码层面将流程变量添加进来。
• 流程条件是支持计算表达式的

基本的流程画图完成之后，我们需要为每个节点指定一个节点权限，因为是flowable的标签在流程设计器上看不到，所以需要打开文本编辑器，这里使用sublime打开。

上图中有两个节点对应两种场景，一种是为节点指定用户，一种是为节点指定用户组。这里为节点指定用户，这个用户是可变的，因为使用的是流程变量，而不是写死的值，当然也可以是写死的值，但是不推荐，这样做的目的是为以后人员变动预留空间。为节点指定用户组，按照上图这种写法即可，在查询待办的时候需要根据这个值进行匹配则可以获取当前的待办信息。

5. 编写流程接口，运行项目

   1.配置application.yml文件，接通mysql数据源。
   application.yml文件

   
   spring:
     profiles:
       active: dev
     aop: # spring aop 开启cglig
       proxy-target-class: true
     jackson:
       property-naming-strategy: CAMEL_CASE_TO_LOWER_CASE_WITH_UNDERSCORES
     jpa:
       database: mysql
       show-sql: true 
       hibernate:
         ddl-auto: update
       properties: 
         hibernate:
           dialect: org.hibernate.dialect.MySQL5Dialect
           format_sql: false
   
   flowable:
   #关闭定时任务JOB
     async-executor-activate: false
     history-level: full
     # FinancialAuditProcess  对账单流程启动key
   
   #mybatis扫描包  
   mybatis:
     mapper-locations: classpath:mapper/*Mapper.xml
     type-handlers-package: guoyu.com.service.workflowsrv.common
   
   
   
   server:
     port: 9090   	
   

   application-dev.yml

   spring:
     datasource:
       driver-class-name: com.mysql.jdbc.Driver
       url: 'jdbc:mysql://localhost/workflow?useUnicode=true&characterEncoding=utf-8&useSSL=true&nullCatalogMeansCurrent=true'
       username: root
       password: 123456789
   
   #日志打印sql
   logging:
     level:
       com:
         example:
           mapper : INFO
   # swagger扫描包
   base:
     package: guoyu.com.controller
     
   # httpclient配置
     
   http:
     maxTotal: 100                       #最大连接数
     defaultMaxPerRoute: 20              #并发数
     connectTimeout: 1000                #创建连接的最长时间
     connectionRequestTimeout: 500       #从连接池中获取到连接的最长时间
     socketTimeout: 10000                #数据传输的最长时间
     staleConnectionCheckEnabled: true   #提交请求前测试连接是否可用
   

   FlowableApplication.java springboot启动入口

      	package guoyu.com;
   
   	import org.mybatis.spring.annotation.MapperScan;
   	import org.springframework.boot.SpringApplication;
   	import org.springframework.boot.autoconfigure.SpringBootApplication;
   	import springfox.documentation.swagger2.annotations.EnableSwagger2;
   	
   	@MapperScan("guoyu.com.service.workflowsrv.mapper")
   	@SpringBootApplication
   	@EnableSwagger2
   	public class FlowableApplication {
   	
   		public static void main(String[] args) {
   			SpringApplication.run(FlowableApplication.class, args);
   		}
   		
   	}
   

   entry目录里的BaseResponse.java,只是用来做一个返回响应的结构体

   package guoyu.com.entry;
   
   import io.swagger.annotations.ApiModel;
   import io.swagger.annotations.ApiModelProperty;
   import liquibase.pro.packaged.E;
   
   import java.io.Serializable;
   
   /**
    * 响应基类
    * @author jack guo
    *
    * @param 
    */
   @ApiModel(value="BaseResponse", description = "响应信息")
   public class BaseResponse implements Serializable{
   	
   	@ApiModelProperty(value = "是否响应成功")
   	private boolean success = false;
   	@ApiModelProperty(value = "响应结果")
   	private T result;
   	@ApiModelProperty(value = "错误处理")
   	private Error error = null;
   
   	public boolean isSuccess() {
   		return success;
   	}
   
   	public void setSuccess(boolean success) {
   		this.success = success;
   	}
   
   	public T getResult() {
   		return result;
   	}
   
   	public void setResult(T result) {
   		this.result = result;
   	}
   
   	public Error getError() {
   		return error;
   	}
   
   	public void setError(Error error) {
   		this.error = error;
   	}
   	@ApiModel(value="Error", description = "错误处理")
   	public static class Error {
   		@ApiModelProperty(value = "错误码")
   		private String code = "";
   		@ApiModelProperty(value = "错误信息")
   		private String message = "";
   
   		public Error(String code, String msg){
   			this.code = code;
   			this.message = msg;
   		}
   		
   
   		public String getCode() {
   			return code;
   		}
   
   		public void setCode(String code) {
   			this.code = code;
   		}
   
   		public String getMessage() {
   			return message;
   		}
   
   		public void setMessage(String message) {
   			this.message = message;
   		}
   
   		@Override
   		public String toString() {
   			return "Error [code=" + code + ", message=" + message + "]";
   		}
   
   	}
   
   
   
   	public BaseResponse(boolean isSuccess, T result, Error error){
   		this.success = isSuccess;
   		this.result = result;
   		this.error = error;
   	}
   
   	public static BaseResponse success(Object result){
   		return new BaseResponse(true, result, null);
   	}
   
   	public static BaseResponse fail(String code, String msg){
   		return new BaseResponse(false, null, new Error(code, msg));
   	}
   
   
   
   	@Override
   	public String toString() {
   		return "BaseResponse [success=" + success + ", result=" + result + ", error=" + error + "]";
   	}
   	
   }
   

   其实我搭建的demo里service都可以不写，直接调用flowable提供的service.所以最主要的还是看controller目录里的核心代码。
   WorkflowController.java，代码块如下：

   package guoyu.com.controller;
   
   import com.mysql.cj.xdevapi.JsonArray;
   import guoyu.com.entry.BaseResponse;
   import io.swagger.annotations.ApiOperation;
   import liquibase.pro.packaged.A;
   import org.flowable.bpmn.model.BpmnModel;
   import org.flowable.engine.*;
   import org.flowable.engine.repository.Deployment;
   import org.flowable.engine.runtime.Execution;
   import org.flowable.engine.runtime.ProcessInstance;
   import org.flowable.image.ProcessDiagramGenerator;
   import org.flowable.task.api.Task;
   import org.flowable.task.api.TaskQuery;
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.stereotype.Controller;
   import org.springframework.web.bind.annotation.RequestMapping;
   import org.springframework.web.bind.annotation.RequestMethod;
   import org.springframework.web.bind.annotation.RequestParam;
   import org.springframework.web.bind.annotation.RestController;
   
   import javax.servlet.http.HttpServletResponse;
   import java.io.InputStream;
   import java.io.OutputStream;
   import java.util.ArrayList;
   import java.util.HashMap;
   import java.util.List;
   import java.util.Map;
   
   /**
    * Created by guoyu on 2020/7/1
    */
   
   @RestController
   @RequestMapping(value = "/workflow")
   public class WorkflowController {
   
       private final Logger logger = LoggerFactory.getLogger(WorkflowController.class);
   
       @Autowired
       private RepositoryService repositoryService;
   
       @Autowired
       private RuntimeService runtimeService;
   
       @Autowired
       private TaskService taskService;
   
       @Autowired
       private ProcessEngine processEngine;
   
       /**
        * 部署流程
        * @param processName 流程定义名
        * @param resourcePath 如flowable/process.bpmn
        * @return
        */
       @RequestMapping(value = "/create/process", method = RequestMethod.GET)
       public BaseResponse createProcess(String processName, String resourcePath){
           Deployment deployment = repositoryService.createDeployment().name(processName).addClasspathResource(resourcePath).deploy();
           return BaseResponse.success("部署流程成功");
       }
   
       /**
        * 发起流程
        * @return
        */
       @RequestMapping(value = "/apply", method = RequestMethod.GET)
       public BaseResponse applyProcess(){
           String processName = "FinancialAuditProcess";
           Map map = new HashMap<>();
           //指定发起人
           map.put("user_account", "guoyu");
           ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(processName, map);
           logger.info("流程实例ID："+processInstance.getProcessInstanceId());
           return BaseResponse.success("发起流程成功");
       }
   
       /**
        * 查询发起人待办列表(针对用户)
        * @return
        */
       @RequestMapping(value = "/user/list", method = RequestMethod.GET)
       public BaseResponse> todoList(){
           String user = "guoyu";
           List tasks = taskService.createTaskQuery().taskCandidateOrAssigned(user).orderByTaskCreateTime().desc().list();
           List