Activiti日志文档

工作流 专栏收录该内容
1 篇文章 0 订阅

1

知识点1-获取processEngine

学习了工作流的基础,processEngine,这个类是工作流的核心

产生方法:

  1. ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    
  2.        ProcessEngineConfiguration configuration =              ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cfg.xml");
       	   ProcessEngine processEngine = configuration.buildProcessEngine();
    

第一种是便捷方式,但是要确保

  1. activiti配置文件名:activiti.cfg.xml
  2. bean的id为processEngineConfiguration

第二种是基本方式,其中createProcessEngineConfigurationFromResource中的参数名可以更改,后面还可以加参数,参数值为bean的类型为processEngineConfiguration的id

知识点2-常见问题

在运行项目的过程中产生的问题

  1. bpmn产生乱码的问题
  2. 无法显示BPMN Editor工具栏
  3. 数据库连接失败

解决方法

  1. IDEA2020版本以前,可以在IDEA的bin目录下的idea64.exe.vmopition文件里添加

    -Dfile.encoding=UTF-8
    

    2020版本需要在help栏目下的edit custom vm options里加入上一段代码

  2. 需要将IDEA的主题设置为默认颜色

  3. 首先确保数据库连接url正确,其次要导入版本匹配的数据库连接依赖,最后就是要加入时区的参数

        <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
            <property name="driverClassName" value="com.mysql.cj.jdbc.Driver" />
            <property name="url" value="jdbc:mysql://localhost:3306/activiti?useUnicode=true&amp;characterEncoding=utf8&amp;serverTimezone=UTC" />
            <property name="username" value="root" />
            <property name="password" value="root" />
        </bean>
    

知识点3-流程部署以及流程实例化

流程的部署

/*
* 流程定义部署
* act_re_deployment 部署信息
* act_re_proadef  流程定义的信息
* act_ge_bytearray 流程定义的bpmn文件和png文件
* */
public class ActivitiDeployment {
    public static void main(String[] args) {
        //1.创建ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //2得到RepositoryService
        RepositoryService repositoryService = processEngine.getRepositoryService();
        //3.进行部署
        Deployment deployment = repositoryService.createDeployment()
                .addClasspathResource("diagram/holiday.bpmn")//添加资源
                .addClasspathResource("diagram/holiday.png")
                .name("请假申请流程")
                .deploy();
        //4.输出部署的信息
        System.out.println(deployment.getName());
        System.out.println(deployment.getId());
    }
}

流程的实例化启动

/*
* 流程实例的启动
* */
public class ActivitiStartInstance {
    public static void main(String[] args) {
        //1.得到processengin对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //2.得到runtimeService对象
        RuntimeService runtimeService = processEngine.getRuntimeService();
        //3.创建实例流程,流程定义的key需要提前知道
        ProcessInstance instance = runtimeService.startProcessInstanceByKey("holiday");
        //4.输出实例的相关信息
        System.out.println("流程部署id"+instance.getDeploymentId());
        System.out.println("流程实例id"+instance.getId());
        System.out.println("活动id"+instance.getActivityId());
    }
}

2

知识点1-常用接口

常用的接口

RepositoryServiceActiviti的资源管理类
RuntimeServiceActiviti的流程运行管理类
TaskServiceActiviti的任务管理类
HistoryServiceActiviti的历史管理类
ManagerServiceActiviti的引擎管理类

知识点2-部署方式

  1. 使用bpmn文件和png文件
  2. 现将两个文件压缩成zip文件,然后使用zipinputstream读取
       Deployment deployment = repositoryService.createDeployment()
               	.addClasspathResource("diagram/holiday.bpmn")//添加资源
                .addClasspathResource("diagram/holiday.png")
                .name("请假申请流程")
                .deploy();

知识点3-查询任务

使用taskService创建createTaskQuery查询器,给入ProcessD的key或者value,或者指定Assignee

        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //得到taskservice对象
        TaskService taskService = processEngine.getTaskService();
        //根据流程定义的key负责人assignee来实现当前用户的任务列表查询
        Task task = taskService.createTaskQuery()
                .processDefinitionKey("holiday")
                .taskAssignee("lisi")
//                .list();
                .singleResult();
        //任务列表的展示
            System.out.println("流程实例id"+task.getProcessInstanceId());
            System.out.println("任务id"+task.getId());
            System.out.println("任务负责人"+task.getAssignee());
            System.out.println("任务名称"+task.getName());

知识点4-完成任务

taskService的complete方法

        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        //处理任务,结合当前用户列表的查询操作,id 2505
        List<Task> list = taskService.createTaskQuery()
                .processDefinitionKey("holiday")
                .taskAssignee("wangwu")
                .list();
        for (Task task : list) {
            taskService.complete(task.getId());
        }

知识点5-查询流程信息

需要获取一个查询器,设定查询条件

        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //获取repositoryService对象
        RepositoryService repositoryService = processEngine.getRepositoryService();
        //得到ProcessDefinitionQuery对象,该对象相当于查询器
        ProcessDefinitionQuery processDefinitionQuery = repositoryService.createProcessDefinitionQuery();
        //设置条件,并查询出当前的所有流程的定义 查询条件:流程定义的key
        List<ProcessDefinition> holiday = processDefinitionQuery.processDefinitionKey("holiday")
                .orderByProcessDefinitionVersion()//设置排序方式.根据流程定义的版本号进行排序
                .desc()
                .list();
        //输出流程定义信息
        for (ProcessDefinition processDefinition : holiday) {
            System.out.println("流程定义的id"+processDefinition.getId());
            System.out.println("流程定义的名称"+processDefinition.getName());
            System.out.println("流程定义的key"+processDefinition.getKey());
            System.out.println("流程定义的版本号"+processDefinition.getVersion());
            System.out.println("流程部署的id"+processDefinition.getDeploymentId());
        }
    }

知识点6-删除流程定义

注意事项

  1. 背后影响的表re开头的三张表bytearray,deployment,procdef
  2. 当我们正在执行的流程未完全审批结束时,此时如果要删除流程定义信息会失败
  3. 此时可以考虑使用级联删除,会先删除没有完成的节点,再删除流程,方法为设置deleteDeployment方法的第二个参数true,默认不写为false
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //创建RepositoryService对象
        RepositoryService repositoryService = processEngine.getRepositoryService();
        //执行删除流程定义,需要传入部署id
        ProcessDefinitionQuery processDefinitionQuery = repositoryService.createProcessDefinitionQuery();
        //设置条件,并查询出当前的所有流程的定义 查询条件:流程定义的key
        List<ProcessDefinition> holiday = processDefinitionQuery.processDefinitionKey("holiday")
                .orderByProcessDefinitionVersion()//设置排序方式.根据流程定义的版本号进行排序
                .desc()
                .list();
        repositoryService.deleteDeployment(holiday.get(0).getDeploymentId());

知识点7-读取部署文件

作用:当用户想查询这个请假流程的步骤

方法:1.使用Activiti的API实现

​ 2.使用jdbc操作

​ 3.io流操作,使用commmons-io.jar包可以解决

使用io流

核心是读取文件并对接到输出流,读取文件的方法是

repositoryService .getResourceAsStream(deploymentId, processDefinition.getDiagramResourceName())

processDefinition.getDiagramResourceName()代表获取图片资源,processDefinition.getResourceName()代表获取bpmn资源

        //1.得到processengin对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //2.得到部署相关的service
        RepositoryService repositoryService = processEngine.getRepositoryService();
        //3.查询表中的查询器processDefinitionQuery对象
        ProcessDefinitionQuery processDefinitionQuery = repositoryService.createProcessDefinitionQuery();
        //4.设置查询条件
        processDefinitionQuery.processDefinitionKey("holiday");
        //5.执行查询操作,查询想要的流程定义
        ProcessDefinition processDefinition = processDefinitionQuery.singleResult();
        //6通过流程定义信息得到部署ID
        String deploymentId = processDefinition.getDeploymentId();
        //7.通过repositoryService的方法实现读取文件功能,第一个参数代表部署id,第二个参数代表资源名称
        //processDefinition.getDiagramResourceName()代表获取图片资源,processDefinition.getResourceName()代表获取bpmn资源
        InputStream pngIs = repositoryService
                .getResourceAsStream(deploymentId, processDefinition.getDiagramResourceName());
        InputStream bpmnIS = repositoryService
                .getResourceAsStream(deploymentId, processDefinition.getResourceName());
        //8.构造出outputstream流
        OutputStream pngOs=new FileOutputStream("E:/test/"+processDefinition.getDiagramResourceName());
        OutputStream bpmnOs=new FileOutputStream("E:/test/"+processDefinition.getResourceName());
        //9.使用common-io流
        IOUtils.copy(pngIs,pngOs);
        IOUtils.copy(bpmnIS,bpmnOs);
        //10.关闭流
        pngOs.close();
        bpmnOs.close();
        pngIs.close();
        bpmnIS.close();

知识点8-查询一个流程实例

若想要查询到一个流程实例,首先要知道流程部署ID或者流程部署key,通过这个信息查询到这个部署所包含的正在运行的流程实例

//通过key查询
		//获取ProcessEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //获取当前部署key下的instance
        RuntimeService runtimeService = processEngine.getRuntimeService();
        ProcessInstance processInstance = runtimeService.createProcessInstanceQuery()
                .processDefinitionKey("holiday4")
                .singleResult();
        //拿到实例id
        String processInstanceId = processInstance.getId();

3

知识点1-历史数据查询

使用historyService对象,创建HistoricActivityInstanceQuery查询器,给定查询条件然后执行

        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //得到historyService
        HistoryService historyService = processEngine.getHistoryService();
        //得到HistoryActivitiInstanceQuery对象
        HistoricActivityInstanceQuery historicActivityInstanceQuery = historyService.createHistoricActivityInstanceQuery();
        historicActivityInstanceQuery.processInstanceId("2501");
        //执行查询
        List<HistoricActivityInstance> list = historicActivityInstanceQuery
                .orderByHistoricActivityInstanceStartTime()
                .asc()
                .list();
        //遍历查询结果
        for (HistoricActivityInstance instance : list) {
            System.out.println(instance.getActivityId());
            System.out.println(instance.getActivityName());
            System.out.println(instance.getProcessInstanceId());
            System.out.println(instance.getProcessDefinitionId());
            System.out.println("=====================");
        }

查询的表为act_hi_actinst,查询流程实例id为2501的数据.在historyService下,需要查询什么表就创建对应表的查询器

知识点2-给流程实例添加businesskey

调用runtimeService下的startProcessInstanceByKey方法,第二个参数传入businesskey

        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RuntimeService runtimeService = processEngine.getRuntimeService();
        //通过runtimeService启动流程实例,指定业务标识businesskey,也就是请假单id
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("holiday", "1001");
        //输出processinstance相关属性
        System.out.println(processInstance.getBusinessKey());

知识点3-挂起操作

挂起状态:该流程定义下的所有流程实例全部暂停,将不允许启动新的流程实例

整个流程的挂起

获取ProcessDefinition对象,进行挂起操作

        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RepositoryService repositoryService = processEngine.getRepositoryService();
        //拿到query对象,进而拿到流程定义对象
        ProcessDefinition holiday = repositoryService.createProcessDefinitionQuery()
                .processDefinitionKey("holiday")
                .singleResult();
        //得到当前流程定义实例,判断是否都为暂停状态
        boolean b = holiday.isSuspended();
        String id = holiday.getId();
        if (b){
            //说明是暂停,可以激活操作
            repositoryService.activateProcessDefinitionById(id,true,null);
            System.out.println("实例"+id+"激活");
        }else {
            repositoryService.suspendProcessDefinitionById(id,true,null);
            System.out.println("实例"+id+"挂起");
        }

流程的某个实例挂起

获取processInstance对象,进行挂起操作

        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RuntimeService runtimeService = processEngine.getRuntimeService();
        //查询流程实例对象
        ProcessInstance processInstance = runtimeService.createProcessInstanceQuery()
                .processInstanceId("15001")
                .singleResult();
        //得到当前流程定义实例,判断是否都为暂停状态
        boolean suspended = processInstance.isSuspended();
        String id = processInstance.getId();
        if (suspended){
            //说明是暂停,可以激活操作
            runtimeService.activateProcessInstanceById(id);
            System.out.println("流程"+id+"激活");
        }else {
            runtimeService.suspendProcessInstanceById(id);
            System.out.println("流程"+id+"挂起");
        }

知识点4-分配任务责任人

方式一:表达式分配

使用UEL-value表达式,将assignee字段设置为可变参数,例如${assignee0}

或者使用UEL-method表达式,例如${user.assignee}

过程:

  1. 在bpmn文件中,设置assignee属性

  2. 重新部署

  3. 创建实例

        public static void main(String[] args) {
            ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
            RuntimeService runtimeService = processEngine.getRuntimeService();
            //设置assignee取值,用户可以在界面上设置流程的执行人
            Map<String,Object> map=new HashMap<String, Object>();
            map.put("assignee0","zhangs");
            map.put("assignee1","lis");
            map.put("assignee2","wangw");
            //启动流程实例,同时设置流程定义的assignee值
            ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("holiday2", map);
            System.out.println(processInstance.getName());
        }
    

方式二:监听器分配

任务监听器是发生对应的任务相关事件时执行自定义 java 逻辑或表达式。

设置类型

Create任务创建后触发
Assignment任务分配后触发
Delete任务完成后触发
All所有事件发生都触发

我们需要设置类型为create,即任务创建后触发

        public class MyTaskListener implements TaskListener {
            @Override
            public void notify(DelegateTask delegateTask) {
                //这里指定任务负责人
                delegateTask.setAssignee("张三");
            }
        }

注意事项:

  1. 该类必须实现org.activiti.engine.delegate.TaskListener接口
  2. 使用监听器分配方式,按照监听器事件去执行监听类的notify方法,方法如果不能正常执行也会影响任务的执行

知识点5-查询关联businesskey

当用户处理任务时,有时需要知道流程的信息,比如通过请假单前需要知道请假单的一些信息,这个时候就需要查询任务关联的businesskey来获取请假单信息

步骤:

  1. 通过taskService的createTaskQuery方法,查询到具体用户在具体流程定义下的任务
  2. 通过任务调用获取流程实例id的方法getProcessInstanceId拿到流程实例id
  3. 通过runtimeService的createProcessInstanceQuery查询器,给入流程实例id查询到具体的流程实例
  4. 通过流程实例的getBusinessKey方法拿到businesskey
    public static void main(String[] args) {
        //获取processEngin
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //创建runtimeService以及taskService
        RuntimeService runtimeService = processEngine.getRuntimeService();
        TaskService taskService = processEngine.getTaskService();
        //使用taskService通过用户名查询到task,并查询到流程实例id
        Task task = taskService.createTaskQuery()
                .processDefinitionKey("holiday")
                .taskAssignee("zhangsan")
                .singleResult();
        String processInstanceId = task.getProcessInstanceId();
        //使用该id通过runtimeService查询到流程实例
        ProcessInstance processInstance = runtimeService.createProcessInstanceQuery()
                .processInstanceId(processInstanceId).singleResult();
        //查询流程实例关联的businesskey
        String businessKey = processInstance.getBusinessKey();
    }

4

知识点1-流程变量

流程变量:流程运转有时候需要流程变量,业务系统与Activiti结合时也需要用到,为了使流程更好的执行而需要

流程变量类型:

在这里插入图片描述

注意:如果将pojo对象存储到流程变量中,需要使对象实现序列化接口,为了防止由于新增字段无法反序列化,需要生成相应的SerialVersionUID

流程变量工作域:

流程变量的默认作用域是流程实例(processInstance),也可以是一个任务(task)或者一个执行实例(execution).

流程实例范围最大被称为global变量,另外两个被称为local变量

global变量不允许存在同名的,如果存在会覆盖掉前面的,local变量由于作用域互不影响,因此可以重名

使用方法:

  1. 设置流程变量
  2. 通过UEL表达式使用流程变量
    1. 可以在assignee处设置UEL表达式,表达式的值为任务负责人
    2. 连线上设置UEL表达式,决定流程的走向,如果UEL表达式为true,则会执行流程

BPMN图制作

在这里插入图片描述

在condition属性设置{holiday.num>3}

注意事项:流程变量在设置时,特别是变量是一个对象时,不要用大写变量,因为定义属性的时候也需要用大写,在使用lombok插件时,会转成小写

知识点2-Global变量设置方式

1.启动流程时设置

        //得到processEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //得到RuntimeService
        RuntimeService runtimeService = processEngine.getRuntimeService();
        //定义流程的key
        String key="holiday4";
        Map<String,Object> map=new HashMap<String, Object>();
        Holiday holiday=new Holiday();
        holiday.setNum(2F);
        map.put("assignee0","zs");
        map.put("assignee1","ls");
        map.put("assignee2","ww");
        map.put("assignee3","zl");
        map.put("holiday",holiday);
        //启动流程实例
        runtimeService.startProcessInstanceByKey(key,map);

2.任务办理时设置

bpmn图中的连线,属性判断条件,可以在任务实现后再设置变量,但是至少要在判断前的一个任务传入参数

        //1.得到ProcessEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //得到TaskService
        TaskService taskService = processEngine.getTaskService();
        String processKey="holiday4";
        //查询当前用户是否有任务
        Task task = taskService.createTaskQuery().processDefinitionKey(processKey)
                .taskAssignee("zs").singleResult();
        Map<String,Object> map=new HashMap<String, Object>();
        Holiday holiday=new Holiday();
        holiday.setNum(2F);
        map.put("holiday",holiday);
        //判断task是否为空
        if (task!=null){
            taskService.complete(task.getId(),map);
            System.out.println("任务"+task.getName()+"执行完毕");
        }

3.通过当前流程实例设置

核心方法是setVariable方法

参数:

  1. 流程实例id
  2. 流程变量名
  3. 流程变量名对应的值

或者SerVariables方法,参数一个是流程实例id,一个是map容器

        //获取ProcessEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //获取当前部署key下的instance
        RuntimeService runtimeService = processEngine.getRuntimeService();
        ProcessInstance processInstance = runtimeService.createProcessInstanceQuery()
                .processDefinitionKey("holiday4")
                .singleResult();
        //拿到实例id
        String processInstanceId = processInstance.getId();
        Holiday holiday=new Holiday();
        holiday.setNum(2F);
        //通过实例id,来设置流程变量
        //第一个参数:流程实例id
        //第二个参数:流程变量名
        //第三个参数:流程变量名所对应的值
        runtimeService.setVariable(processInstanceId,"holiday",holiday);

4.通过当前任务设置

注意:任务id必须是当前代办任务的id

使用TaskServicesetVariable方法,使用方法与方法三相同,给入taskid,给入参数名和参数值

知识点3-ProcessInstance和ProcessDefinition区别

定义:

ProcessInstance是流程的实例,在一个流程部署后,可以通过流程部署key或者id生成多个流程实例

ProcessDefinition是流程部署的信息,从这个信息可以得到流程部署的相关信息比如流程定义的id,流程部署的id,流程定义的key,流程名称等信息

ProcessDefinition指向的是流程的部署,ProcessInstance指向的是具体的流程实例

特点:

拿到ProcessDefinition的方式:我们可以通过RepositoryService创建ProcessDefinition的查询器,然后通过流程key或者id查询到ProcessDefinition

拿到ProcessInstance方法:我们需要通过RuntimeService创建ProcessInstance查询器,然后给入流程key或者id查询到

因此两个无论哪一个都需要一个流程部署的id或者key

知识点4-Local流程变量设置

1.任务办理时设置

任务办理时设置的流程变量,当前运行的流程实例只能在该任务结束前使用,任务结束后无法使用

1

知识点1-候选人

需求:当我们在设置任务流程时,在任务节点assignee固定设置任务负责人,在流程定义时将参与者固定设置在bpmn文件中,如果临时更改任务负责人则需要修改流程定义,导致系统可扩展性变差,这个时候就可以给任务设置多个候选人,可以从候选人中选择参与者来完成任务.

设置任务候选人

需要在任务的candidate-users栏进行设置,多个候选人之间可以用逗号隔开.

组任务办理流程

  1. 查询组任务,
    1. 指定候选人,查询该候选人当前的待办任务
    2. 候选人不能办理业务
  2. 拾取任务
    1. 该组任务所有候选人都能拾取,即使不是候选人也能拾取,因此拾取之前要先判断是否是有资格拾取
    2. 将候选人的组任务,变成个人任务,原来的候选人就变成了任务负责人
    3. 如果不想办理可以将任务归还到组,个人任务就变了了组任务
  3. 查询个人任务
    1. 方法同个人任务部分,根据assignee查询用户负责的个人任务
  4. 办理个人任务

知识点2-组任务查询

根据候选人查询组任务,使用taskService的createTaskQuery方法

        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        List<Task> taskList = taskService.createTaskQuery()
            //设置候选用户
                .taskCandidateUser("zhangsan")
                .processDefinitionKey("holiday5")
                .list();

注意:设置完候选用户后,查询任务的信息,Assignee属性是为空的,因为并没有设置负责人

知识点3-组任务拾取

拾取前注意:由于拾取只需要taskid,和user的id,所以即使不是候选人也可以拾取任务,因此使用拾取功能前一定要先判断该user是否为该任务的候选人

使用方法:

taskService.claim(task.getId(),"lisi");
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        Task task = taskService.createTaskQuery()
                .processDefinitionKey("holiday5")
                .taskCandidateUser("lisi")
                .singleResult();
        if (task!=null){
            taskService.claim(task.getId(),"lisi");
            System.out.println("任务拾取成功");
        }

本质:将任务候选人转化为任务负责人

知识点4-归还组任务

注意:归还前需要先校验该用户是否是任务的负责人

使用的是TaskService的setAssignee方法,方法需要两个参数,第一个参数是任务id,第二个参数是null,表示没有负责人

        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        Task task = taskService.createTaskQuery()
                .processDefinitionKey("holiday5")
                .taskAssignee("lisi")
                .singleResult();
		//先校验是否是负责人
        if (task!=null){
            taskService.setAssignee(task.getId(),null);
            System.out.println("任务归还成功");
        }

知识点5-交接任务

任务负责人将任务交给其它候选人办理该任务

交接任务实际就是候选人拾取任务的过程

        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        Task task = taskService.createTaskQuery()
                .processDefinitionKey("holiday5")
                .taskAssignee("lisi")
                .singleResult();
		//先校验当前用户是否是用户的负责人
        if (task!=null){
            taskService.setAssignee(task.getId(),"zhangsan");
            System.out.println("任务交接成功");
        }

知识点6-排他网关

排他网关也叫异或网关,用来在流程中实现决策,当流程执行到这个网关时,所有分支都会判断条件是否为true,如果为true则执行

注意:排他网关只会选择一个分支执行,即使有多个true,这就是之前与设置流程变量来进行判断的不同之处,

当存在两个分支为true,默认走id值小的分支

如果都不满足,则抛出异常

在这里插入图片描述

具体的执行流程与之前设置流程变量进行判断时一致

知识点7-删除流程实例

删除流程实例体现在两个地方

  1. 删除run表下的流程实例,删除后无法通过runtimeService查询到该实例,但是仍然存在于history中
  2. 删除hi表下的流程实例

删除ru表下的

runtimeService.deleteProcessInstance("5001","删除原因");

参数一代表流程实例ID,参数2表示删除原因

删除hi表下的

historyService.deleteHistoricProcessInstance(processInstanceId);

参数是流程实例ID

知识点8-并行网关

实现任务的多分支,需要两个并行网关,一个fork分支,一个join汇聚

当一个分支完成,会达到join网关,并等待,直到所有的分支汇聚完成后才能进入下一流程

在这里插入图片描述

与其他网关的主要区别是,并行网关不会解析条件。 即使顺序流中定义了条件,也会被忽略。

知识点9-包含网关

特点:

  1. 具有排他网关和并行网关的共同点
  2. 可以在网关后的多个流程设置流程变量,只要符合的都可以执行
  3. 最后汇聚,条件为true的流程全部执行完才能进入下一个流程

在这里插入图片描述

2

知识点1-spring整合

配置

pom文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.sun</groupId>
    <artifactId>activiti-spring</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <slf4j.version>1.6.6</slf4j.version>
        <log4j.version>1.2.12</log4j.version>
    </properties>

    <dependencies>

        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-engine</artifactId>
            <version>7.0.0.Beta1</version>
        </dependency>

        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-spring</artifactId>
            <version>7.0.0.Beta1</version>
        </dependency>

        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-bpmn-model</artifactId>
            <version>7.0.0.Beta1</version>
        </dependency>

        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-bpmn-converter</artifactId>
            <version>7.0.0.Beta1</version>
        </dependency>

        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-json-converter</artifactId>
            <version>7.0.0.Beta1</version>
        </dependency>

        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-bpmn-layout</artifactId>
            <version>7.0.0.Beta1</version>
        </dependency>

        <dependency>
            <groupId>org.activiti.cloud</groupId>
            <artifactId>activiti-cloud-services-api</artifactId>
            <version>7.0.0.Beta1</version>
        </dependency>
        <dependency>
            <groupId>aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.5.4</version>
        </dependency>


        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.17</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.0.7.RELEASE</version>
        </dependency>


        <!-- log start -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-nop</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <!-- log end -->

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
        </dependency>

        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>1.4</version>
        </dependency>
        <!--文件读写操作-->
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.0</version>
        </dependency>

    </dependencies>


    <repositories>
        <repository>
            <id>alfresco</id>
            <name>Activiti Releases</name>
            <url>https://artifacts.alfresco.com/nexus/content/repositories/activiti-releases/</url>
            <releases>
                <enabled>true</enabled>
            </releases>
        </repository>
    </repositories>

</project>

xml配置文件-activiti-spring.xml

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/tx
    http://www.springframework.org/schema/tx/spring-tx.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop.xsd
    ">

    <!-- 数据源 -->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/activiti"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
        <property name="maxActive" value="3"/>
        <property name="maxIdle" value="1"/>
    </bean>

    <!-- 工作流引擎配置bean -->
    <bean id="processEngineConfiguration" class="org.activiti.spring.SpringProcessEngineConfiguration">
        <!-- 数据源 -->
        <property name="dataSource" ref="dataSource"/>
        <!-- 使用spring事务管理器 -->
        <property name="transactionManager" ref="transactionManager"/>
        <!-- 数据库策略 -->
        <property name="databaseSchemaUpdate" value="drop-create"/>
    </bean>


    <!-- 流程引擎 -->
    <bean id="processEngine" class="org.activiti.spring.ProcessEngineFactoryBean">
        <property name="processEngineConfiguration" ref="processEngineConfiguration"/>
    </bean>
    <!-- 资源服务service -->
    <bean id="repositoryService" factory-bean="processEngine"
          factory-method="getRepositoryService"/>
    <!-- 流程运行service -->
    <bean id="runtimeService" factory-bean="processEngine"
          factory-method="getRuntimeService"/>
    <!-- 任务管理service -->
    <bean id="taskService" factory-bean="processEngine"
          factory-method="getTaskService"/>
    <!-- 历史管理service -->
    <bean id="historyService" factory-bean="processEngine"
          factory-method="getHistoryService"/>

    <!-- 事务管理器 -->
    <bean id="transactionManager"
          class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!-- 通知 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <!-- 传播行为 -->
            <tx:method name="save*" propagation="REQUIRED"/>
            <tx:method name="insert*" propagation="REQUIRED"/>
            <tx:method name="delete*" propagation="REQUIRED"/>
            <tx:method name="update*" propagation="REQUIRED"/>
            <tx:method name="find*" propagation="SUPPORTS" read-only="true"/>
            <tx:method name="get*" propagation="SUPPORTS" read-only="true"/>
        </tx:attributes>
    </tx:advice>

    <!-- 切面,根据具体项目修改切点配置 -->
    <aop:config proxy-target-class="true">
        <aop:advisor advice-ref="txAdvice"
                     pointcut="execution(* com.sun.service.impl.*.*(..))"/>
    </aop:config>
</beans>

核心为

    <!-- 流程引擎 -->
    <bean id="processEngine" class="org.activiti.spring.ProcessEngineFactoryBean">
        <property name="processEngineConfiguration" ref="processEngineConfiguration"/>
    </bean>

这一段是获取流程引擎的配置,这个配置需要注入processEngineConfiguration,所以又需要配置

<!-- 工作流引擎配置bean -->
<bean id="processEngineConfiguration" class="org.activiti.spring.SpringProcessEngineConfiguration">
    <!-- 数据源 -->
    <property name="dataSource" ref="dataSource"/>
    <!-- 使用spring事务管理器 -->
    <property name="transactionManager" ref="transactionManager"/>
    <!-- 数据库策略 -->
    <property name="databaseSchemaUpdate" value="drop-create"/>
</bean>

这个需要注入DataSource和transactionManager,以及配置数据库策略,前面两项都在xml文件里有配置,这样一个完整的ProcessEngine就配置好了

:attributes>
</tx:advice>

<!-- 切面,根据具体项目修改切点配置 -->
<aop:config proxy-target-class="true">
    <aop:advisor advice-ref="txAdvice"
                 pointcut="execution(* com.sun.service.impl.*.*(..))"/>
</aop:config>

核心为

```xml
    <!-- 流程引擎 -->
    <bean id="processEngine" class="org.activiti.spring.ProcessEngineFactoryBean">
        <property name="processEngineConfiguration" ref="processEngineConfiguration"/>
    </bean>

这一段是获取流程引擎的配置,这个配置需要注入processEngineConfiguration,所以又需要配置

<!-- 工作流引擎配置bean -->
<bean id="processEngineConfiguration" class="org.activiti.spring.SpringProcessEngineConfiguration">
    <!-- 数据源 -->
    <property name="dataSource" ref="dataSource"/>
    <!-- 使用spring事务管理器 -->
    <property name="transactionManager" ref="transactionManager"/>
    <!-- 数据库策略 -->
    <property name="databaseSchemaUpdate" value="drop-create"/>
</bean>

这个需要注入DataSource和transactionManager,以及配置数据库策略,前面两项都在xml文件里有配置,这样一个完整的ProcessEngine就配置好了

有了这个流程引擎后就可以使用这个引擎创建各种Service.

  • 0
    点赞
  • 0
    评论
  • 0
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

©️2021 CSDN 皮肤主题: 游动-白 设计师:白松林 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值