精华内容
下载资源
问答
  • Activiti日志文档

    2021-05-11 10:07:51
    Activiti工作流引擎基础知识点

    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.

    展开全文
  • yml 添加下面的配置,显示activiti操作数据库的SQL日志: logging: level: org.activiti.engine.impl.persistence.entity: debug properties 配置: logging.level.org.activiti.engine.impl.persistence....

    yml 添加下面的配置,显示activiti操作数据库的SQL日志: 

    logging:
      level:
        org.activiti.engine.impl.persistence.entity: debug

     

    properties 配置:

    logging.level.org.activiti.engine.impl.persistence.entity=debug

     

    展开全文
  • Activiti不能打印日志问题

    千次阅读 2018-04-10 12:05:34
    分享知识 传递快乐在使用Activiti工作流时不能打印日志问题:引入日志的方式基本上有两种:一种用log4j.properties;另一种用logback.xml配置。引用了log4j.properties式的日志功能,那么当加入activiti工作流时,在...

    分享知识 传递快乐

    在使用Activiti工作流时不能打印日志问题:
    引入日志的方式基本上有两种:一种用log4j.properties;另一种用logback.xml配置。

    引用了log4j.properties式的日志功能,那么当加入activiti工作流时,在发布项目时是不会打印日志的,但在测试下可以打印日志功能。那么在引入Activiti工作流时用log4j.properties不能打印日志是怎么回事呢?

    个人理解:因为Activiti工作流用到的日志是SLF4j,而并非LOG4J。一方面因为Logback-classic非常自然实现了SLF4j,另一方面SLF4j自动重新加载配置文件当配置文件修改了,Logback-classic能自动重新加载配置文件等。(如有新的见解请留言分享)


    使用logback.xml做为日志要引入以下jar:
    slf4j-api.jar
    log4j-over-slf4j.jar
    logback-classic.jar
    logback-core.jar
    在maven中引入log4j-over-slf4j.jar会自动引入slf4j-api.jar
    使用logback日志无须在web.xml中配置。
    logback-classic不能与slf4j-log4j12同引,会导致jar冲突。

    logback日志配置

    <?xml version="1.0" encoding="UTF-8"?>
    <configuration scan="true" scanPeriod="60 seconds" debug="false">
    	<!-- 控制台输出 -->
    	<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
    		<encoder>
    			<pattern>%d{HH:mm:ss} %-5p [%c] - %m%n</pattern>
    		</encoder>
    	</appender>
    
    	<logger name="org.springframework" level="ERROR" />
    	<logger name="org.mybatis" level="ERROR" />
    	<logger name="com.baomidou.mybatisplus" level="ERROR" />
    	<logger name="org.apache" level="ERROR" />
    	
    	<!-- Activiti日志 -->
    	<logger name="org.activiti" level="ERROR" />
    	<logger name="org.activiti.engine.impl.persistence.entity" level="DEBUG" />
    	
    	<!--myibatis log configure -->
    	<logger name="com.ibatis" level="DEBUG" />
    	<logger name="com.ibatis.common.jdbc.SimpleDataSource" level="DEBUG" />
    	<logger name="com.ibatis.common.jdbc.ScriptRunner" level="DEBUG" />
    	<logger name="com.ibatis.sqlmap.engine.impl.SqlMapClientDelegate" level="DEBUG" />
    	<logger name="java.sql.Connection" level="DEBUG" />
    	<logger name="java.sql.Statement" level="DEBUG" />
    	<logger name="java.sql.PreparedStatement" level="DEBUG" />
    
    	<root level="DEBUG">
    		<appender-ref ref="STDOUT" />
    	</root>
    
    </configuration>

    展开全文
  • springboot打印activiti的sql日志

    千次阅读 2018-12-18 14:26:06
    logging: level: ... org.activiti.engine.impl....-- Activiti日志 --> <logger name="org.activiti" level="ERROR" /> <logger name="org.activiti.engine.impl.persistence.entity" level="DEBUG" />
  • Activiti开启打印SQL查询日志

    万次阅读 2018-03-16 18:47:37
    开启activiti sql查询日志 在log4j.properties中加入如下配置 log4j.logger.org.activiti.engine.impl.persistence.entity=trace 重启,显示效果如图:
  • Activiti

    2018-02-09 22:43:10
    Activiti5.12开始,SLF4J被用作日志框架,替换了之前的java.util.logging,所有的日志都转发给SLF4J允许使用你选择的日志实现。  Activiti是基于Apache V2协议发布的。Activiti需要运行在JDK1.6或以上版本。 ...
  • activiti

    2020-01-30 23:39:16
    一、为什么选择Activiti activiti介绍 Activiti是由Alfresco软件在2010年5月17日发布的业务流程管理(BPM)框架,它是覆盖了业务流程管理,工作流,服务协作等领域的一个开源,灵活的,易扩展的可执行流程语言框架。 ...
  • 这里我们介绍日志记录与MDC。 两者息息相关,当我们记录日志的时候,需要记录一些上下文信息。比如线程号与当前线程级别、当前时间。但是如果我们需要记录一些当前登录的用户与正在操作的订单,则是存在MDC中。可以...
  • 文章目录一、事件日志 一、事件日志 配置Event Logging 实验性的事件记录机制,性能影响较大 开启默认记录所有数据的变化过程,表记录快速增长 日志内容json格式,建议存入mongoDB、Elastic Search 具体实现...
  • 首先跟上篇博客一样先创建单元测试类 ConfigEventLogTest。 其中内容修改如下: package com.jjf.activiti.config; ...import org.activiti.engine.event.EventLogEntry;...import org.activiti.e...
  • 工作流学习日志 -(Activiti7进阶) 文章目录工作流学习日志 -(Activiti7进阶)前言一、流程实例1. 添加业务标识(BusinessKey)2. 查询流程实例3. 挂起、激活流程实例①. 全部流程实例挂起、激活②. 单个流程实例...
  • activiti 目录

    2019-10-05 02:08:20
    activiti(一):idea整合spring和avtiviti activiti(二):关于流程部署和删除的一些操作 activiti(三):关于流程实例的一些操作 activiti(四):关于流程任务的一些操作 流程表,activiti日志表: 1) act_evt_log ...
  • 文章目录一、日志配置记录二、MDC具体应用 一、日志配置记录 日志组件 日志门面 日志实现 桥接方式 改变依赖 slf4j Logback slf4j-log4j12 jcl-over-slf4j commons-logging Log4j slf4j-jdk14 log4j-...
  • Activiti配置

    2019-04-14 21:11:47
    于是,我只能重翻Activiti 6的用户手册和API,从头记录并分享一下。 Activiti 6的User Guide目录为https://www.activiti.org/userguide/#configuration。 这一篇先介绍Activiti的基本配置。 ProcessEngine的基本配置...
  • Activiti理解

    2020-03-29 16:30:14
    Activiti学习
  • 运行 Activiti

    2020-07-31 11:47:57
    日志抽象类 import java.util.logging.Handler;import java.util.logging.LogManager; import java.util.logging.Logger;import org.activiti.engine.impl.util.LogUtil; import org.slf4j.bridge.SLF4...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,383
精华内容 1,353
关键字:

activiti日志