Activiti5 基础学习

概述
    工作流(workflow)
    为了完成一项任务或事情,需要多个参与者同时或流水式共同完成。
    目前应用比较广泛的行业：物流，办公管理系统
    是一个半成品项目,需要做二次开发
解决的问题
    为了实现某个业务目标，利用计算机在多个参与者之间按某种预定规则自动传递文档、信息或者任务，从而提高业务目标效率。
发展史
    jbpm(jboss公司)
    BPM：Business Process Management 业务流程管理
    BPMN：Business Process Modeling and Notation 业务流程建模与标注规范
下载
    官网：http://www.activiti.org
文件夹说明
    database
        操作数据库sql脚本
    docs
        api文档与用户指南
    xsd
        xml约束文件
    libs
        jar包
    wars
        web应用
安装
    流程设计器离线安装(整合到eclipse中)
        把activiti-plugin拷贝到eclipse\dropins中
    流程设计器在线安装
        eclipse --> help --> install new software
        Activiti BPMN 2.0 Designer
        http://activiti.org/designer/update
    需要创建数据库表(24张)
        activiti.mysql55.create.engine.sql
        activiti.mysql55.create.history.sql
        activiti.mysql.create.identity.sql
        直接运行sql文件中的sql即可。
24张表介绍
    ACT_RE_*(3张表)
        仓储数据
        act_re_deployment
            部署的流程
        act_re_procdef
            流程定义
    ACT_RU_*
        运行过程中的流程数据
        act_ru_variable
            运行中的变量存储位置
    ACT_ID_*
        权限管理数据
    ACT_HI_*
        历史的数据
    ACT_GE_*
        公共数据
        act_ge_bytearray 
            部署的流程图
    ACT_EVT_LOG
        事件日志
项目中引入jar包
    第一种方式
        拷贝jar包
    第二种方式
        maven方式
核心类
    ProcessEngineConfiguration
        流程引擎配置信息对象
    ProcessEngine
        流程引擎
    RepositoryService 
        仓储服务
    RuntimeService
        运行时服务
    TaskService
        任务服务
    IdentityService
        身份管理服务
    HistoryService 
        历史服务
    FormService
        表单数据服务
    ManagementService
        管理服务
ProcessEngineConfiguration(流程引擎配置信息对象)创建方式
    第一种
        createProcessEngineConfigurationFromResourceDefault()
            需要加载src/activiti.cfg.xml
            bean的id名称一定为：processEngineConfiguration
    第二种
        createProcessEngineConfigurationFromResource(String resource)
            需要加载src/activiti.cfg.xml(配置文件可以改名)
            bean的id名称一定为：processEngineConfiguration
    第三种
        createProcessEngineConfigurationFromResource(String resource, String beanName)
            需要加载src/activiti.cfg.xml(配置文件可以改名)
            bean的id名：processEngineConfiguration(可以自己给名字)
    第四种
        createProcessEngineConfigurationFromInputStream(InputStream inputStream)
            需要加载src/activiti.cfg.xml(配置文件可以改名)
            bean的id名称一定为：processEngineConfiguration
    第五种
        createProcessEngineConfigurationFromInputStream(InputStream inputStream, String beanName)
            需要加载src/activiti.cfg.xml(配置文件可以改名)
            bean的id名：processEngineConfiguration(可以自己给名字)
    第六种
        createStandaloneProcessEngineConfiguration().
说明
    流程：指完成某件事情需要的过程.
    流程定义：具体的流程.把具体流程定义在bpmn文件中.
    流程部署：把流程定义文件保存到数据库.
Activiti5:工作流
1. RepositoryService仓储服务：
   -- act_ge_bytearray
   -- act_re_deployment
   -- act_re_procdef
   -- act_ge_property

   完成的功能：
   -- 流程部署
   -- 流程部署查询
   -- 删除流程部署
   -- 流程定义查询
   -- 查询流程定义资源文件(BpmnModel)
   -- 查询流程定义资源图片(InputStream)

2. RuntimeService运行时服务:
   -- act_ru_execution
   -- act_ru_event_subscr
   -- act_ru_job
   -- act_ru_task
   -- act_ru_variable

   完成的功能：
   -- 开启流程实例.
   -- 查询流程实例.
   -- 删除流程实例.
   -- 触发走一步.signal
   -- 获取当前活动的节点.

3. TaskService任务服务:
   -- act_ru_task
   完成的功能:
   -- 查询任务.
   -- 完成任务.
  
4. HistoryService历史服务:
   -- act_hi_procinst
   -- act_hi_taskinst

   完成的功能：
   -- 查询历史流程实例
   -- 查询历史任务实例

新增流程部署

使用
    RepositoryService服务
    获取方式：
        ProcessEngine.getRepositoryService()获取仓储服务对象
    步骤
        获取部署构建对象
            DeploymentBuilder deploymentBuilder = RepositoryService.createDeployment()
        添加流程定义资源文件
            deploymentBuilder.addInputStream(String resourceName, InputStream inputStream) 
            addZipInputStream(ZipInputStream zipInputStream)
        部署流程定义
            deploymentBuilder.deploy();
刚刚部署的流程在这三张表中有数据
    act_re_deployment 部署表
        NAME_ 文件名字
        CATEGORY_ 添加种类
        DEPLOY_TIME_ 部署时间
    act_ge_bytearray
        
    act_re_procdef
        myProcess_1:3:2508
        act_re_procdef表的KEY_:act_re_procdef表的VERSION_:act_ge_bytearray表的自增长id最大值+1
    

查询所有部署的流程(流程部署)

使用
    RepositoryService服务
    获取方式：
        ProcessEngine.getRepositoryService()获取仓储服务对象
    查询方式:
        查询对象:
            DeploymentQuery deploymentQuery = repositoryService.createDeploymentQuery();
        api:
            orderByDeploymenTime()
                根据部署时间排序
            orderByDeploymentId()
                根据部署id排序
            orderByDeploymentName()
                根据部署名称排序
            orderByTenantId()
                
            desc()
                降序
            asc()
                升序
            list()
                全部查询
        说明
            List<Deployment> deploymentLists = repositoryService.createDeploymentQuery().orderByDeploymenTime().desc().list();
详细说明
    编号 d.id
    名称 d.name
    种类 d.category
    部署时间 d.deploymentTime

删除部署的流程(流程部署)

使用
    RepositoryService服务
    获取方式：
        ProcessEngine.getRepositoryService()获取仓储服务对象
    删除方式:
        RepositoryService.deleteDeployment(编号, true);
            编号是 act_re_deployment表中的ID_ 
            repositoryService.deleteDeployment(deploymentId, true);

查看所有的流程定义

是部署的所有流程的详细信息,根据流程定义来启动流程
使用
    RepositoryService服务
    获取方式：
        ProcessEngine.getRepositoryService()获取仓储服务对象
    api
        查询对象:
            ProcessDefinitionQuery processDefinitionQuery = repositoryService.createProcessDefinitionQuery();
        latestVersion()
            每个流程定义的最后版本(最新版本)
        orderByProcessDefinitionVersion()
            根据流程定义的版本号排序
        desc()
            降序
        list()
            全部查询
        说明
            List<ProcessDefinition> processDefinitionLists = repositoryService.createProcessDefinitionQuery().latestVersion().orderByProcessDefinitionVersion().desc().list();
详细说明
    流程定义ID  p.id
    名称  p.name
    部署ID  p.deploymentId
    key  p.key
    资源文件名称  p.resourceName
    资源图片名称  p.diagramResourceName
    版本号  p.version

根据流程定义开启流程实例

概述
    比如开启一个请假流程
使用
    根据流程定义的ID开启
        RuntimeService runtimeService = pe.getRuntimeService();
        runtimeService.startProcessInstanceById(pdId);
        注意:
            是根据act_re_procdef表中的ID_开启
    根据流程定义的Key开启
        RuntimeService runtimeService = pe.getRuntimeService();
        runtimeService.startProcessInstanceByKey(pdKey);
        注意:
            是根据act_re_procdef表中的KEY_开启
开启一个流程实例表中数据说明
    act_ru_execution 
        流程实例表
        PROC_INST_ID_
            流程定义act_re_procdef表的id
        ACT_ID_
            当前接收要处理任务节点
    act_hi_actinst
        ？？
    act_hi_procinst
        ？？

查看某个流程定义的所有流程实例

概述
    比如查询技术部所有正在请假的流程
使用
    查询方式
        RuntimeService runtimeService = pe.getRuntimeService();
        ProcessInstanceQuery piq = runtimeService.createProcessInstanceQuery();
        List<ProcessInstance> piLists = piq.processDefinitionId(pdId).orderByProcessInstanceId().asc().list();
    说明
        根据act_re_procdef表的ID_来查询
详细说明
    流程实例ID  p.id
    流程实例ID  p.processInstanceId
    名称  p.processDefinitionName
    流程定义ID  p.processDefinitionId
    流程定义版本号  p.processDefinitionVersion
    活动的节点ID  p.activityId

删除某个流程定义的某个流程实例

概述
    例如把老王的请假流程删除
使用
    删除方式
        RuntimeService runtimeService = pe.getRuntimeService();
        runtimeService.deleteProcessInstance(piId, "删除");
    说明
        根据act_ru_execution表的ID_去删除
        删除后在act_hi_procinst表中可以看到删除的原因

查看某个流程定义的某个流程实例的流程图

概述
    例如把老王的请假流程走到哪一步了.
使用
    查看方式
        RepositoryService repositoryService = pe.getRepositoryService();
        RuntimeService runtimeService = pe.getRuntimeService();
        ProcessInstance pi = runtimeService.createProcessInstanceQuery().processInstanceId(piId).singleResult();
        InputStream inputStream = repositoryService.getProcessDiagram(pi.getProcessDefinitionId());
        BufferedImage image = ImageIO.read(inputStream);
        Graphics2D graphics = (Graphics2D)image.getGraphics();
        graphics.setColor(Color.RED);
        graphics.setStroke(new BasicStroke(3.0f));
        graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        List<String> activityIds = runtimeService.getActiveActivityIds(piId);
        BpmnModel bpmnModel = repositoryService.getBpmnModel(pi.getProcessDefinitionId());
        for (String activityId : activityIds){
            GraphicInfo gi = bpmnModel.getGraphicInfo(activityId);
            graphics.drawRoundRect((int)gi.getX(), (int)gi.getY(),(int)gi.getWidth(), (int)gi.getHeight(), 10, 10);
        }
        response.setContentType("images/png");
        ImageIO.write(image, "png", response.getOutputStream());
    说明
        根据act_ru_execution表的ID_去查询  

触发流程实例进行下一步

概述
    例如:领导同意老王请假,请下一个领导批准
使用
    触发方式
        RuntimeService runtimeService = pe.getRuntimeService();
        runtimeService.signal(piId);
    说明
        根据根据act_ru_execution表的ID_去触发

画流程图

说明
    BPMN的6大部分
        Event事件
            Start Event开始事件
            End Event结束事件
            Boundary Event边界事件
            Intermediate Event中间捕获事件
        Tasks任务
            UserTask用户任务(人机交互)
        Gateways网关
            ParallelGateway并行网关(多人必须同时审批)
        Container容器
        Connection连接
        Artifacts说明
Task任务节点
    UserTask用户任务
        General
            id 唯一标志
            name 起一个名称
        Main Config
            Assignee 任务处理人  
                admin 这种写法是指定具体的用户
                ${user} 这种写法是给一个流程变量
            Candidate users(comma separated) 任务候选人(可以写很多,用逗号隔开)
            Candidate group(comma separated) 任务候选人组
            Form key 表单的key - 用的少 
            Due date(Variable) 过期时间 - 用的少
                P:代表一段时间(年月日)Y年M月D日
                T:代表后面为(时分秒)H时M分S秒
                例如PT10H10M10S(代表10小时10分10秒)
            priority 优先级
            Category 种类,说明
            Skip expression 跳过模式(当达到条件就跳过去)
        Documentation
            Documentation 任务的描述信息
        Form 
            表单
        Listeners
            监听器
        Multi instance
            多实例
            Sequential 是否有顺序 false表示无序,true表示有序.
    在act_ru_task表中会有每个人的任务
Connection连接线
    SequenceFlow 任务连接线

查看自己任务

说明
    用户要登录后查看自己要处理的任务
    例如:领导要看自己待处理的任务
使用
    查询方式
        TaskService taskService = pe.getTaskService();
        TaskQuery taskQuery = taskService.createTaskQuery();
        HttpSession session = request.getSession();
        taskQuery.taskAssignee(userid);//用户的id
        List<Task> tasklist = taskQuery.list();
    注意：
        在画流程图中在任务节点上写明这点.(Main Config的Assignee)
详细说明
    任务ID  t.id
    任务名称  t.name
    任务处理人  t.assignee
    任务创建时间  t.createTime
    流程实例ID  t.processInstanceId

处理自己的任务

说明
    用户必须要先领取任务,才能处理
使用
    执行任务
        TaskService taskService = pe.getTaskService();
        taskService.complete(taskId);//任务的id
    说明
        是act_ru_task表中的ID_

根据流程实例id查询流程实例

说明
    管理员处理其他用户的流程
使用
    查询id查询
        TaskService taskService = pe.getTaskService();
        TaskQuery tq = taskService.createTaskQuery();
        List<Task> taskLists = tq.processInstanceId(piId).list();
详细说明
    任务ID  t.id
    任务名称  t.name
    任务处理人  t.assignee
    任务创建时间  t.createTime
    流程实例ID  t.processInstanceId

查看历史流程实例

说明
    查看所有提过哪些流程
使用
    HistoryService historyService = pe.getHistoryService();
    HistoricProcessInstanceQuery hpiq = historyService.createHistoricProcessInstanceQuery();
    List<HistoricProcessInstance> hpiLists = hpiq.orderByProcessInstanceId().asc().list();
详细说明
    历史流程实例ID p.id
    开始时间 p.startTime
    结束时间 p.endTime
    完成的总时间 p.durationInMillis
    开启流程实例用户 p.startUserId
    删除原因 p.deleteReason

查看历史流程实例中的所有任务

说明
    查看某个流程实例中的所有任务
使用
    HistoryService historyService = pe.getHistoryService();
    HistoricTaskInstanceQuery htiq = historyService.createHistoricTaskInstanceQuery();
    List<HistoricTaskInstance> htiLists = htiq.processInstanceId(hpiId).orderByHistoricTaskInstanceEndTime().asc().list();
详细
    任务ID   p.id
    任务名称  p.name
    任务处理人  p.assignee
    任务开始时间 p.startTime
    任务结束时间  p.endTime
    任务完成的时间 p.durationInMillis
    任务分派时间 p.claimTime
    任务工作总时间 p.workTimeInMillis

查看自己的任务(任务候选人中有自己)

概述
    请假由三个领导谁批都可以,那么谁先登录谁批准.
    拉模式
使用
    TaskService taskService = pe.getTaskService();
    TaskQuery tq = taskService.createTaskQuery();
    List<Task> candidateUserTaskLists = tq.taskCandidateUser(userId).list();//根据候选人查询
    for (Task task : candidateUserTaskLists){
        taskService.claim(task.getId(), userId);//领取任务
    }
    List<Task> taskLists = taskService.createTaskQuery().taskAssignee(userId).list();
详细说明
    任务ID  t.id
    任务名称  t.name
    任务处理人  t.assignee
    任务创建时间  t.createTime
    流程实例ID  t.processInstanceId

查看自己的任务(任务组中有自己)

概述
    请假由三个领导谁批都可以,那么谁先登录谁批准.
    拉模式
使用
    Map<String, List<String>> maps = new HashMap<>();
    List<String> users = new ArrayList<>();
    users.add("test1");
    users.add("test2");
    maps.put("role1", users);
    for (Map.Entry<String, List<String>> entry : maps.entrySet()){
        if (entry.getValue().contains(userId)){
            List<Task> candidateGroupTaskLists = tq.taskCandidateGroup(entry.getKey()).list();
            for (Task task : candidateGroupTaskLists){
                taskService.claim(task.getId(), userId);// 领取任务
            }
        }
    }
    List<Task> taskLists = taskService.createTaskQuery().taskAssignee(userId).list();

启动流程实例设置变量

概述
    在任务启动或者流转过程中会添加一些变量,这些变量用于辨别不同的用户处理流程,或者记录一些信息
使用
    RuntimeService runtimeService = pe.getRuntimeService();
    Map<String, Object> params = new HashMap<>();
    params.put("user", "lee2");
    params.put("age", 18);
    params.put("u", new User());
    runtimeService.startProcessInstanceById(pdId, params);

任务监听器

概述
    UserTask 中设置Listeners中的Task listeners.
设置说明
    Task Listener 有四种事件
        create 创建的时候(任务在创建的时候)
        assignment 分配用户的时候
        complete 完成任务的时候
        all 全部情况
        使用
            Java类的方式 
                Task Listener监听器类必须要实现TaskListener接口
                public class CreateTaskListener implements TaskListener {}
                public class AssignmentTaskListener implements TaskListener {}
                public class CompleteTaskListener implements TaskListener {}
            Expression表达式的方式
                #{user.test()}  这个是在调用user对象的test方法。这个user是流程变量。#{user.test(100,'定州')}
    Execution listener 执行监听器
        start 任务开始
        end 任务结束
        使用
            Java类的方式
                Execution listener 监听器必须要实现ExecutionListener接口
                public class StartListener implements ExecutionListener {}
                public class EndListener implements ExecutionListener {}
使用
    在监听器中获取实例中的变量
    public class CreateTaskListener implements TaskListener {
        private Expression name;
        public void notify(DelegateTask task) {
            //表达式的文本 name.getExpressionText()
            //name的值 name.getValue(task)
            //System.out.println(task.getVariables());// 获取所有的流程变量
            //System.out.println("CreateTaskListener事件名：" + task.getEventName());// create
            String userId = (String)task.getVariable("user");// 获取指定的流程变量
            task.setAssignee(userId);// 分配任务处理人
            //还可以添加任务候选人(task.addCandidateUser),用户组(task.addCandidateGroup).用于动态的分配任务
        }
    }
    public class AssignmentTaskListener implements TaskListener {
        public void notify(DelegateTask task) {
            System.out.println(task.getVariables());// 获取所有的流程变量
            System.out.println(task.getAssignee());// 获取任务处理人
            System.out.println("AssignmentTaskListener事件名：" + task.getEventName());// assignment
        }
    }
    public class CompleteTaskListener implements TaskListener {
        public void notify(DelegateTask task) {
            System.out.println(task.getVariables());// 获取所有的流程变量
            System.out.println("CompleteTaskListener事件名：" + task.getEventName());// create
            System.out.println(task.getAssignee());// 任务处理人
        }
    }
    public class StartListener implements ExecutionListener {
        private Expression id;
        public void notify(DelegateExecution execution) throws Exception {
            System.out.println(id.getValue(execution));
            System.out.println(execution.getVariables());
            System.out.println("StartListener事件名" + execution.getEventName());
            execution.setVariable("admin", "aaaa");//设置 流程变量
        }
    }

表单数据服务

说明
    在任务中设置表单字段与数据,在监听器中获取表单数据
使用
    获取表单数据
        public class CreateTaskListener implements TaskListener {
            public void notify(DelegateTask task) {
                FormService fs = task.getExecution().getEngineServices().getFormService();
                List<FormProperty> lists = fs.getTaskFormData(task.getId()).getFormProperties();
                for (FormProperty fp : lists){
                    System.out.println(fp.getId() + "==" + fp.getName() + "==" + fp.getValue());
                }
            }
        }
    启动流程实例时设置表单数据
        RuntimeService runtimeService = pe.getRuntimeService();
        Map<String, Object> params = new HashMap<>();
        params.put("name", "lee2");
        params.put("sex", 1);
        untimeService.startProcessInstanceById(pdId, params);
定义表单属性
    id 字段id
    name 字段名称
    type 字段类型
    expression 字段表达式${name}
    variable 变量名
    default 默认值
    date pattern 日期格式化
    readable 可读
    writeable 可写
    required 必须要传
    

多实例

multi instance
    sequential true代表有序,false代表无序
        无序：表示有多个用户,一次创建全部任务显示.用的比较多.
        true有序: 需要一个一个的签到,而且有序.一个都不能少
    loop cardinality  循环次数
    collection 用户的集合,要放到流程变量中.例如是userList
    element variable 变量,会放到流程变量中.类似于遍历时的别名
    completion condition 完成条件, ${nrOfCompletedInstances / nrOfInstances >= 0.6 }
        nrOfCompletedInstances是已经完成的个数
        nrOfInstances是总个数
使用
    启动此类流程定义,一定要在启动的时候,给一个userList的流程变量
        RuntimeService runtimeService = pe.getRuntimeService();
        Map<String, Object> params = new HashMap<>();
        List<String> userLists = new ArrayList<>();
        userLists.add("admin1");
        userLists.add("admin2");
        params.put("userLists", userLists);
        runtimeService.startProcessInstanceById(pdId, params);
有序时
    需要四个条件都要给
无序时
    循环次数不需要给了
重点动态分配用户集合:
    添加create监听器
    public class CreateTaskListener implements TaskListener {
        private String[] users = {"test1", "test2", "test3", "test4", "test5"};//定义用户数组
        public void notify(DelegateTask task) {
            int i = task.getVariable("loopCounter", Integer.class);// 获取循环计数器
            task.setAssignee(users[i]);// 分配任务处理人
        }
    }

脚本任务(自动触发)

概述
    ScriptTask
    自己触发,自己完成
    写JavaScript代码
说明
    General
        name 任务名称
    MainConfig
        可以写两种语言,我们写js代码
        测试代码
            var sum = 0;
            for (var i = 0; i <= 100; i++){
                sum += i;
            }
            execution.setVariable("sum", sum);//设置变量
        

服务任务(自动触发)

概述
    ServiceTask
    自己触发,自己完成
    配置java类进行后台任务处理
说明
    General
        name 任务名称
    MainConfig
        必须要指定一个服务的java类,这个java类必须实现JavaDelegate接口.
        可以在Documentation中设置变量,这个变量就可以在服务类中获取到.
        表达式类型就是指定调用某个对象中的方法
    测试
        public class ServiceTaskDelegate implements JavaDelegate {}

手工任务(自动触发)

概述
    ManualTask
    自己触发,自己完成
说明
    General
        name 任务名称

接收任务(自动触发)

概述
    ReceiveTask
    自己触发,自己完成
说明
    General
        name 任务名称
注意:
    需要用信号的方式触发.

邮件任务(自动触发)

概述
    MailTask
    自己触发,自己完成
    要作用是用来发邮件
jar包
    依赖jar: (mail.jar、activation.jar、common-mail.xx.jar)
说明
    General
        name 任务名称
    MainConfig
        to 邮件发送给谁 ${to}
        from 谁发送的邮件 ${from}
        subject 邮件主题 ${subject}
        Cc 抄送给谁 ${to}
        Bcc 秘抄送 ${to}
        Charset 邮件编码 utf-8
        html html邮件 ${to},你的订单已审核！
        non html 文本邮件 ${to},你的订单已审核！
使用
    在创建流程引擎配置(ProcessEngineConfiguration)的时候设置用户名和密码
        ProcessEngineConfiguration pec = ProcessEngineConfiguration.createStandaloneProcessEngineConfiguration();
        pec.setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE)
       .setDatabaseType("mysql") // 数据库的类型
       .setJdbcDriver("com.mysql.jdbc.Driver") // 连接数据库驱动
       .setJdbcUrl("jdbc:mysql://localhost:3306/activiti") // 连接数据库的URL
       .setJdbcUsername("root") // 连接数据库的用户名
       .setJdbcPassword("root") // 连接数据库的密码
       .setActivityFontName("宋体") // 设置活动节点上的字体
       .setLabelFontName("宋体")// 设置连接线上的字体
       .setXmlEncoding("utf-8") // 设置流程定义文件的编码
       .setMailServerDefaultFrom("476570365@qq.com") // 设置发送人
       .setMailServerHost("smtp.qq.com") // 设置邮件服务器 
       .setMailServerUsername("476570365@qq.com") // 设置用户名
       .setMailServerPassword("xxxxxx"); // 设置密码
    启动流程定义的时候,设置发给谁
        RuntimeService runtimeService = pe.getRuntimeService();
        Map<String, Object> params = new HashMap<>();
        params.put("to", "476570365@qq.com");
        params.put("from", "476570365@qq.com");
        params.put("subject", "订单审批信息");
        runtimeService.startProcessInstanceById(pdId, params);

开始事件

说明
    Start Event开始事件
分类
    StartEvent正常开始事件
    TimerStartEvent定时开始事件
        不需要用户启动
    MessageStartEvent消息开始事件
    SignalStartEvent信号开始事件
StartEvent正常开始事件
    General
        name 名称
    MainConfig
        initiator 事件是由谁来启动
    Form
        表单数据
    里面的流程变量给的时候要在启动的时候给
        RuntimeService runtimeService = pe.getRuntimeService();
        pe.getIdentityService().setAuthenticatedUserId("test888");//设置鉴权用户(开启流程实例用户)
        List<FormProperty> lists =pe.getFormService().getStartFormData(pdId).getFormProperties();// 获取开始事件中的表单数据
        for (FormProperty fp : lists){
            System.out.println(fp.getId() + "==" + fp.getName() + "==" + fp.getValue());
        }
        runtimeService.startProcessInstanceById(pdId);
TimerStartEvent定时开始事件
    General
        name 名称
    MainConfig 启动时间,写一个就可以
        time duration 程序启动后延迟多长时间启动
            PT10H10M10S(代表10小时10分10秒)
        time date 指定一个时间
            2017-11-5T10:05:05
        time cycle 可以循环多少次,可以开启多个流程实例
            R4/PT10S 每个10秒启动一次
            R4/2016-01-23T17:07:00/PT10S 在一个时间后延迟10秒
            R4代表启动4次,
    使用
        需要在创建流程引擎配置(ProcessEngineConfiguration)的时候设置开启
        ProcessEngineConfiguration pec = ProcessEngineConfiguration.createStandaloneProcessEngineConfiguration();
        pec.setJobExecutorActivate(true); // 设置激活任务调度
MessageStartEvent消息开始事件
    General
        name 名称
    MainConfig
        Message ref 引用一个流程定义已经设置好的消息
        特别注意：需要自己去写消息的引用
            <startEvent id="messagestartevent1" name="Message start">
                <messageEventDefinition messageRef="myMsg"></messageEventDefinition>
            </startEvent>
    注意:
        一定要指定是一个什么样的消息.
        在流程定义的图中设置消息类型.
            Messages
                Message definitions 中定义消息的id和name名称
    使用
        启动方式
            RuntimeService runtimeService = pe.getRuntimeService();
            runtimeService.startProcessInstanceByMessage("myMsg2");//根据消息id来启动
SignalStartEvent信号开始事件
    General
        name 名称
    MainConfig
        Signal ref 引用一个流程定义已经设置好的信号
    注意:
        一定要指定全局的信号
        在流程定义的图中设置消息类型.
            Signals
                Signal definitions 中定义信号的id和name名称  
    使用
        启动方式
            RuntimeService runtimeService = pe.getRuntimeService();
            runtimeService.signalEventReceived("mySignal");// 信号事件接收启动流程实例

结束事件

说明
    End Event结束事件
分类
    EndEvent结束事件
    TerminateEndEvent终止结束事件
    ErrorEndEvent错误结束事件(会引发错误码)子流程
EndEvent结束事件
    自动就会结束,正常结束
TerminateEndEvent终止结束事件
    标记一下不是正常结束,是被终止的
ErrorEndEvent错误结束事件(会引发错误码)子流程
    在子流程中使用

边界事件

说明
    Boundary Event边界事件
分类
    TimerBoundaryEvent定时边界事件
    MessageBoundaryEvent消息边界事件
    SignalBoundaryEvent信号边界事件
    ErrorBoundaryEvent错误边界事件(接收错误码)子流程
TimerBoundaryEvent定时边界事件
    把这个事件放到某个任务上即可.
    例如:用户不收货,就定时7日后自动收货结束流程。
    MainConfig
        Cancle activity 
        time duration 
        time date 指定一个时间
        time cycle 可以循环多少次
MessageBoundaryEvent消息边界事件
    把这个事件放到某个任务上即可.
    注意:
        需要定义一个全局的消息.
        然后在消息事件中引用这个消息.MainConfig(Message ref)
            <boundaryEvent id="boundarymessage1" name="Message" attachedToRef="usertask3" cancelActivity="true">
                <messageEventDefinition messageRef="myMsg"></messageEventDefinition>
            </boundaryEvent>
    使用
        RuntimeService runtimeService = pe.getRuntimeService();
        Execution execution = runtimeService.createExecutionQuery().messageEventSubscriptionName("myMsg").singleResult();//根据消息名查询执行事件id
        runtimeService.messageEventReceived("myMsg", execution.getId());//消息事件接收完成当前边界消息事件
SignalBoundaryEvent信号边界事件
    把这个事件放到某个任务上即可.
    注意:
        需要定义一个全局的信号.
    使用
        RuntimeService runtimeService = pe.getRuntimeService();
        Execution execution = runtimeService.createExecutionQuery().signalEventSubscriptionName("mySignal").singleResult();//根据信号名查询执行对象
        runtimeService.signalEventReceived("mySignal", execution.getId());//信号事件接收完成当前信号边界事件
ErrorBoundaryEvent错误边界事件(接收错误码)子流程
    把这个事件放到子流程中使用

中间捕获事件

说明
    Intermediate Event中间捕获事件
分类
    TimerCatchingEvent定时捕获事件
    MessageCatchingEvent消息捕获事件
    SignalCatchingEvent信号捕获事件
    NoneThrowingEvent空引发事件
TimerCatchingEvent定时捕获事件
    定时触发,进入下一环节.
    MainConfig
        time duration 延迟多少秒
        time date 指定一个时间
        time cycle 可以循环多少次
MessageCatchingEvent消息捕获事件
    定义一个全局消息
    使用
        RuntimeService runtimeService = pe.getRuntimeService();
        Execution execution = runtimeService.createExecutionQuery().messageEventSubscriptionName("myMsg").singleResult();
        runtimeService.messageEventReceived("myMsg", execution.getId());
SignalCatchingEvent信号捕获事件
    定义一个全局信号
    使用
        RuntimeService runtimeService = pe.getRuntimeService();
        Execution execution = runtimeService.createExecutionQuery().signalEventSubscriptionName("mySignal").singleResult();
        runtimeService.signalEventReceived("mySignal", execution.getId());
NoneThrowingEvent空引发事件
    自动触发,直接进入下一个流程

网关

概述
    比较常用
分类
    ParallelGateway并行网关(多人必须同时审批)
    ExclusiveGateway排他网关(多人只能选择一人审批)
    InclusiveGateway包含网关(集成了并行与排他网关)
    EventGateway事件网关(只能连接中间捕获事件)
ParallelGateway并行网关(多人必须同时审批)
    注意
        多个人任务之前和之后都要有一个并行网关.
        不需要加条件
    说明
        也就是两个人必须同时完成任务,流程才能继续进行
ExclusiveGateway排他网关(多人只能选择一人审批)
    例如:请假1天,请假两天,请假三天以上等等的流程情况
    注意
        需要在流程线上加条件
        MainConfig(Condition  ${leaveDay <= 2})
    使用:
        启动时需要加上流程变量
        RuntimeService runtimeService = pe.getRuntimeService();
        Map<String, Object> params = new HashMap<String, Object>();
        params.put("leaveDay", 4);
        runtimeService.startProcessInstanceById(pdId, params);
InclusiveGateway包含网关(集成了并行与排他网关)
    在某条线上加条件,就是排他网管,不加条件的就是并行网关
EventGateway事件网关(只能连接中间捕获事件)
    只能连接边界事件

容器

说明
    Container容器
内容
    SubProcess子流程
    Call Activity调用活动(子流程)
    Pool池 | Lane小巷
SubProcess子流程
    例如
        过年买票
        1.发起流程
        2.买票
        3.子流程(交给黄牛去买票)SubProcess
            3.1发起流程
            3.2黄牛买票
            3.3排他网管
            3.4买到票正常结束EndEvent
            3.5没买到票错误结束事件ErrorEndEvent
        4.子流程的错误边界事件ErrorBoundaryEvent
            4.1做汽车回家
        5.子流程正常结束
            5.1坐火车回家
    这两个节点必须要在子流程中
        ErrorEndEvent错误结束事件(会引发错误码)子流程
        ErrorBoundaryEvent错误边界事件(接收错误码)子流程
Call Activity调用活动(子流程)
    Task任务中有一个CallActivity调用活动节点
    使用
        1.准备两个流程文件
        2.配置CallActivity
            MainConfig
                Called element 设置另外一个流程文件的id
        3.都部署就可以了。
Pool池和Lane小巷
    Lane小巷要放在Pool池中。
    可以让人看得比较清晰
    例如:请假流程
        技术部小巷
            1.发起流程
            2.主管审批
            3.经理审批
        总经办
            4.总经理审批
        人事部
            5.审批
            6.结束流程

ZIP部署

使用
    ProcessEngine pe = ProcessEngineUtils.getProcessEngine();
    RepositoryService repositoryService = pe.getRepositoryService();
    DeploymentBuilder builder = repositoryService.createDeployment();
    if (fileName.endsWith(".bpmn")){
        builder.addInputStream(fileName, inputStream);
    }else if (fileName.endsWith(".zip")){
        builder.addZipInputStream(new ZipInputStream(inputStream));
    }
    builder.name(fileName);
    builder.category("帅哥的公司");
    builder.deploy();