activiti入门和流程的运行过程（附代码）

最新推荐文章于 2024-05-16 09:53:11 发布
最新推荐文章于 2024-05-16 09:53:11 发布
阅读量840 收藏
点赞数 1
分类专栏： java技术 activiti 文章标签： activiti
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Honnyee/article/details/83374057
版权

1.定义bpmn文件，这个文件里是用来定义流程的

2.发布流程

 发布流程，流程的key值相同的情况下每次发布一次，这个流程在数据库的版本会+1

3.查看流程定义

打印的信息

可以看到，我刚才定义的流程已经更新了，现在是版本2了

4.创建流程实例

这里是使用key来创建一个流程

5.查看任务

创建一个实例之后，开始执行流程。一个流程分为很多的节点，每个节点对于不同的人就是不同的任务，所以要运行流程就是从查看自己的任务开始。

在流程定义时我们可以看到 ，start之后，第一个执行事件是提出申请，assignee设定的是 staff

所以查询任务的时候，可以根据staff查看任务

运行代码后，看到了任务相关信息

在数据库中我们可以看到相关信息

6.办理任务

这里的taskId就是上一步查出来的任务id，将任务Id传进taskService.complete的参数中，运行

运行完成后，数据库表中的信息也更新

因为此时流程实例已经走到下一步，此时这个实例的名字是请假审批而不是提出申请了。

然后执行taskId为25002的任务，走到最后一步任务，这个流程实例就完成了。

一定要注意在操作过程中，数据库的变化，这样才能更好更快的理解activiti框架

附代码：

pom.xml引入依赖

    <!--- Activiti依赖导入 -->
    <dependency>
      <groupId>org.activiti</groupId>
      <artifactId>activiti-spring</artifactId>
      <version>5.18.0</version>
      <exclusions>
        <exclusion>
          <groupId>org.activiti</groupId>
          <artifactId>activiti-engine</artifactId>
        </exclusion>
      </exclusions>
    </dependency>


    <!--- Activiti依赖导入 -->
    <dependency>
      <groupId>org.activiti</groupId>
      <artifactId>activiti-spring</artifactId>
      <version>5.18.0</version>
      <exclusions>
        <exclusion>
          <groupId>org.activiti</groupId>
          <artifactId>activiti-engine</artifactId>
        </exclusion>
      </exclusions>
    </dependency>
    <dependency>
      <groupId>org.activiti</groupId>
      <artifactId>activiti-engine</artifactId>
      <version>5.18.0</version>
      <exclusions>
        <exclusion>
          <artifactId>slf4j-api</artifactId>
          <groupId>org.slf4j</groupId>
        </exclusion>
        <exclusion>
          <groupId>org.slf4j</groupId>
          <artifactId>jcl-over-slf4j</artifactId>
        </exclusion>
        <exclusion>
          <artifactId>spring-beans</artifactId>
          <groupId>org.springframework</groupId>
        </exclusion>
        <exclusion>
          <artifactId>jackson-core-asl</artifactId>
          <groupId>org.codehaus.jackson</groupId>
        </exclusion>
        <exclusion>
          <artifactId>commons-lang3</artifactId>
          <groupId>org.apache.commons</groupId>
        </exclusion>
        <exclusion>
          <artifactId>mybatis</artifactId>
          <groupId>org.mybatis</groupId>
        </exclusion>

      </exclusions>

    </dependency>

注意这里的<esclusion> 排除里面相关的依赖

测试类的代码：


public class activitiTest {

    /**
     *  一条语句创建processEngine, 要求:
     * 1、配置文件必须在classpath根目录下
     * 2、配置文件名必须为activiti-context.xml或activiti.cfg.xml
     * 3、工厂对象的id必须为processEngine
     */
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    HistoryService historyService = processEngine.getHistoryService();
    RuntimeService runtimeService = processEngine.getRuntimeService();
    RepositoryService repositoryService = processEngine.getRepositoryService();
    TaskService taskService = processEngine.getTaskService();

     /** 通过zipinputstream完成部署
     * 注意：这个的话，需要将bpmn和png文件进行压缩成zip文件，然后放在项目src目录下即可(当然其他目录也可以)
     */
    @Test
    public void testDeployFromZipinputStream(){
        InputStream in = this.getClass().getClassLoader().getResourceAsStream("shenqing.zip");
        ZipInputStream zipInputStream = new ZipInputStream(in);
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        processEngine.getRepositoryService()
                .createDeployment()
                .addZipInputStream(zipInputStream)
                .deploy();
    }

    /**
     * 创建ActivitiEngine 生成数据库表
     */
    @Test
    public void createActivitiEngine(){

        //取得ProcessEngineConfiguration对象
        ProcessEngineConfiguration engineConfiguration=ProcessEngineConfiguration.
                createStandaloneProcessEngineConfiguration();

        /**2. 通过加载 activiti.cfg.xml 获取 流程引擎 和自动创建数据库及表*/

        // 设置创建表的策略 （当没有表时，自动创建表）
        // = "false";//不会自动创建表，没有表，则抛异常
        // = "create-drop";//先删除，再创建表
        // = "true";//假如没有表，则自动创建
        engineConfiguration.setDatabaseSchemaUpdate("true");
        //通过ProcessEngineConfiguration对象创建 ProcessEngine 对象
        ProcessEngine processEngine = engineConfiguration.buildProcessEngine();
        System.out.println("流程引擎创建成功!");

    }


    /**
     * 查看流程图
     * 根据deploymentId和name(在act_ge_bytearray数据表中)
     */
    @Test
    public void testShowImage() throws Exception{
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        InputStream inputStream = processEngine.getRepositoryService()
                /**
                 * deploymentID
                 * 文件的名称和路径
                 */
                .getResourceAsStream("110003","activiti/weekReport.bpmn");
        OutputStream outputStream3 = new FileOutputStream("e:/weekReport.png");
        int b = -1 ;
        while ((b=inputStream.read())!=-1){
            outputStream3.write(b);
        }
        inputStream.close();
        outputStream3.close();
    }

    /**
     * 根据pdid查看图片(在act_re_procdef数据表中)
     * @throws Exception
     */
    @Test
    public void testShowImage2() throws Exception{
        InputStream inputStream = processEngine.getRepositoryService()
                .getProcessDiagram("leaveProcess:13:120004");
        OutputStream outputStream = new FileOutputStream("e:/leaveProcess.png");
        int b = -1 ;
        while ((b=inputStream.read())!=-1){
            outputStream.write(b);
        }
        inputStream.close();
        outputStream.close();
    }

    /**
     * 部署流程定义
     */
    @Test
    public void deploy() {

        //获取仓库服务 ：管理流程定义
        RepositoryService repositoryService = processEngine.getRepositoryService();
        Deployment deploy = repositoryService.createDeployment()//创建一个部署的构建器
                .addClasspathResource("activiti/weekReport.bpmn")//从类路径中添加资源,一次只能添加一个资源
                .name("周报审批流程")//设置部署的名称
                .category("直销部")//设置部署的类别
                .deploy();

        System.out.println("部署的id"+deploy.getId());
        System.out.println("部署的名称"+deploy.getName());
    }

    /**
     * 创建流程实例
     */
    @Test
    public void startProcessInstance(){
        String leaveId = "007";
        String staffId = "04643";
        HashMap<String,Object> map=new HashMap<>();
        map.put("staffId",staffId);
        // 启动流程
        String processInstanceKey = "weekReportProcess";
//        三个参数分别为(String processDefinitionKey, String businessKey, HashMap<String, Object> variables)
        ProcessInstance pi = processEngine.getRuntimeService()
                .startProcessInstanceByKey(processInstanceKey,leaveId,map);
        System.out.println("创建流程实例成功,流程实例id:"+pi.getId()
                + "  流程定义id:" + pi.getProcessDefinitionId());
        //默认完成第一步申请人的申请步骤
        Task task = processEngine.getTaskService()
                .createTaskQuery()
                .processInstanceId(pi.getId())
                .singleResult();
        String nextStaffId = "04646";
        map.put("staffId",nextStaffId);
        processEngine.getTaskService()
                .complete(task.getId(),map);
    }

    /**
     * 查询所有的正在执行的任务
     */
    @Test
    public void testQueryTask(){
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        List<Task> tasks = processEngine.getTaskService()
                .createTaskQuery()
                .list();
        for (Task task : tasks) {
            System.out.println(task.getName());
        }
    }

    /**
     * 根据piid得到当前正在执行的流程实例的正在活动的节点
     */
    @Test
    public void testActivity(){
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        /**
         * 根据piid得到流程实例
         */
        ProcessInstance pi = processEngine.getRuntimeService()
                .createProcessInstanceQuery()
                .processInstanceId("127501")
                .singleResult();
        String activityId = pi.getActivityId();//当前流程实例正在执行的activityId
        System.out.println(activityId);
    }

    /**
     * 查找个人任务
     */
    @Test
    public void getMyTaskInfo() {
        String staffId = "007";
        List<Task> listTask = processEngine.getTaskService()
                .createTaskQuery()
                .taskAssignee(staffId)
                .list();

        if (listTask != null && listTask.size() > 0) {
            for (Task task : listTask) {
                System.out.println("任务ID："+task.getId());
                System.out.println("任务名称："+task.getName());
                System.out.println("任务时间："+task.getCreateTime());
                System.out.println("任务的办理人："+task.getAssignee());
                System.out.println("任务的实例ID："+task.getProcessDefinitionId());
                System.out.println("#########################################");
            }
        }
    }

    /**
     *  执行任务
     * @return
     */
    @Test
    public void completeMyPersonTask() {
        String taskId = "170002";
        String nextStaffId = "02222";
        HashMap<String,Object> map=new HashMap<>();
        map.put("staffId",nextStaffId);
        processEngine.getTaskService()
                .complete(taskId,map);
        System.out.println("查看当前任务成功"+"完成任务，任务ID：" + taskId);
    }

    /**
     *  终止流程实例
     * @return
     */
    @Test
    public void deleteProcessInstance() {
        String taskId = "135002";
        String reason = "太少了，100个新增！";
        Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
        ProcessInstance processInstance = runtimeService.createProcessInstanceQuery()
                .processInstanceId(task.getProcessInstanceId()).singleResult();
        processEngine.getRuntimeService()
                .deleteProcessInstance(processInstance.getId(),reason);
        System.out.println("停止taskId为：" + taskId+"的任务");
    }

    /**
     * 查询执行对象表,使用流程实例ID和当前活动的名称（receivetask1）
     */
    @Test
    public void queryExecution(){
        ProcessInstance pi = processEngine.getRuntimeService()
                .createProcessInstanceQuery()
                .processDefinitionKey("weekReportProcess")
                .singleResult();
        //3.查询执行对象表,使用流程实例ID和当前活动的名称（receivetask1）
        String processInstanceId = pi.getId();//得到流程实例ID
        Execution execution1 = processEngine.getRuntimeService()
                .createExecutionQuery()
                .processInstanceId(processInstanceId)//流程实例ID
//                .activityId("receivetask1")//当前活动的名称
                .singleResult();
        //5.向后执行一步
        processEngine.getRuntimeService()
                .signal(execution1.getId());

    }

    /**
     *  直接跳过某一个执行步骤
     * @return
     */
    @Test
    public void passTask() {
        String executionId =  "127501";
        processEngine.getRuntimeService().signal(executionId);
        System.out.println("直接执行下一步");
    }

    /**
     * 直接完成执行者为空的步骤，直到有执行者的那一步并设置执行者id
     */
    @Test
    public void passNull(){
        TaskService taskService = processEngine.getTaskService();
        //上一个任务的执行者
        String assignee =  "04646";
        //当前流程实例Id
        String processInstanceId = "165001";

        //整个流程中，所有节点涉及的执行人全部加入到一个数组中
        ArrayList<String>  assignees= new ArrayList<>();
        assignees.add("04643");
        assignees.add("04646");
        assignees.add("");
        assignees.add("007");

        //获得上一个执行者后面的数组
        List<String> subAssigneeList = assignees.subList(assignees.indexOf(assignee)+1, assignees.size());
        //遍历数组 查找下一个执行者是否为空
        //如果为空就默认完成进入下一步，直到第一个不为空的执行者 跳出foreach
        for (String l:subAssigneeList
             ) {
            System.out.println("subList的位置"+subAssigneeList.indexOf(l)+"元素是："+l);

            //如果 下一个任务的执行人为空，直接默认完成这一步，并根据数组将下一个执行人加入下一个任务中
            if (l.equals(null) || l.length() == 0){
                Task task = taskService.createTaskQuery()
                        .processInstanceId(processInstanceId)
                        .singleResult();
                HashMap<String, Object> var = new HashMap<>();
                var.put("staffId",subAssigneeList.get( subAssigneeList.indexOf(l) + 1));
                taskService.complete(task.getId(),var);
                System.out.println("这个位置的执行者是空，直接默认完成这一步");
            }else {
                System.out.println("存在执行者，跳出此循环");
                break;
            }
        }
        System.out.println(subAssigneeList);
    }

    @Test
    public void queryProcessInstanceHistory(){
        List<HistoricActivityInstance> list = historyService.createHistoricActivityInstanceQuery()
                .orderByHistoricActivityInstanceEndTime()
                .desc()
                .processInstanceId("132501")
                .list();
        for (HistoricActivityInstance h:list){
            System.out.println(h.getId());
            System.out.println(h.getActivityId());
            System.out.println(h.getAssignee());
            System.out.println(h.getExecutionId());
            System.out.println(h.getProcessInstanceId());
            System.out.println("##############################");

        }
    }

}

activiti.cfg.xml的配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="processEngineConfiguration" class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">

        <property name="jdbcUrl" value="jdbc:sqlserver://xxxDatabaseName=activititest" />
        <property name="jdbcDriver" value="" />
        <property name="jdbcUsername" value="" />
        <property name="jdbcPassword" value="" />
        <!-- 建表策略 -->
        <!--
            "false";不能自动创建表，需要表存在
            "create-drop";先删除表再创建表
            "true";如果表不存在，自动创建表
            -->
        <property name="databaseSchemaUpdate" value="true" />
    </bean>

</beans>

spring配置文件里可以这么配置

 <!-- 配置activiti -->
        <context:component-scan base-package="com.wolwo.activiti">
                <context:exclude-filter type="annotation"
                                        expression="org.springframework.stereotype.Controller" />
                <context:exclude-filter type="annotation"
                                        expression="org.springframework.web.bind.annotation.ControllerAdvice" />
        </context:component-scan>


        <!-- 配置流程引擎文件 -->
        <bean id="processEngineConfiguration" class="org.activiti.spring.SpringProcessEngineConfiguration">
                <property name="dataSource" ref="dataSource" />
                <property name="transactionManager" ref="transactionManager" />
                <property name="labelFontName" value="宋体"/>
                <property name="activityFontName" value="宋体" />
                <!-- 是否自动创建23张表 -->
                <property name="databaseSchemaUpdate" value="true" />

                <property name="jobExecutorActivate" value="false" />
                <property name="deploymentResources" value="activiti/**/*.bpmn"/>
        </bean>

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

        <bean id="repositoryService" factory-bean="processEngine" factory-method="getRepositoryService" />
        <bean id="runtimeService" factory-bean="processEngine" factory-method="getRuntimeService" />
        <bean id="formService" factory-bean="processEngine" factory-method="getFormService" />
        <bean id="identityService" factory-bean="processEngine" factory-method="getIdentityService" />
        <bean id="taskService" factory-bean="processEngine" factory-method="getTaskService" />
        <bean id="historyService" factory-bean="processEngine" factory-method="getHistoryService" />
        <bean id="managementService" factory-bean="processEngine" factory-method="getManagementService" />

 

Honins
关注
专栏目录
Activiti工作流之流程实例、任务的执行
06-01
NULL 博文链接：https://profound-accumulation.iteye.com/blog/2244881
activiti原型和代码
01-25
7. **流程查询**：查询历史流程实例，获取流程运行数据，进行审计或分析。 8. **服务任务**：在流程中调用自定义服务，实现业务逻辑。 9. **表单集成**：与前端界面（如 HTML 表单）集成，提供用户交互界面。 10....
基于springboot开发的工作流系统，bpmn.js，vue源码及功能分析（activiti）
2301_81867536的博客
01-30 873
本项目拥有用户管理，部门管理，代码生成，系统监管，报表，大屏展示，业务审批等功能。功能太强大，只能粗矿的介绍，所见即所得，体验一下吧。
Activity的执行流程
朱玉强的博客
08-27 874
android手机的横竖屏切换个时，将会调用系统函数onConfigurationChanged()来执行（需要在Manifest中进行配置）             ...             android:configChanges="orientation|screenSize"             ... > 从log的结果中可以看到 1、正常启动act
程序运行流程
hyly_zhard的博客
01-02 274
CSDN-markdown编辑器 使用示例 目录 用 [TOC]来生成目录： 文章目录CSDN-markdown编辑器 使用示例目录快捷键Markdown及扩展表格定义列表代码块自定义字体颜色(github中看不到颜色):删除线数学公式UML 图:离线写博客浏览器兼容在csdn Markdown模式下的显示效果: 本Markdown编辑器使用StackEdit修改而来，用它写博客，将会带来全新的体...
Apache ODE 流程运行过程解析
iteye_20333的博客
03-11 216
流程运行概述 流程运行需要引擎首先创建该流程的实例，当然实例的创建也是以接收用户发送的调用消息起始的，然后根据该流程对象的定义按顺序执行一个个活动，像赋值操作、等待操作等，当然最重要的还有调用外部服务的操作，同时还要负责接收发送回来的响应消息，根据响应消息的内容再执行后续的流程，最后流程终止后，销毁该实例。  SOAP消息的接收与传递  在本系统中与外界的所有通信都由AXIS2来负责，通...
SpringBoot集成工作流Activiti（前后端代码+数据库）
最新发布
2301_81867536的博客
05-16 1073
activiti工作流引擎项目，企业erp、oa、hr、crm等企事业办公系统轻松落地，一套完整并且实际运用在多套项目中的案例，满足日常业务流程审批需求。
Activiti快速入门
01-27
6. **整合Spring**：Activiti可与Spring框架深度集成，通过Spring的依赖注入机制简化代码和提高灵活性。 综上所述，Activiti是一个功能丰富的工具，适用于企业级的业务流程自动化，它提供了灵活的流程定义、管理和...
springboot+activiti7 入门小demo
11-02
首先，让我们从标题"springboot+activiti7 入门小demo"开始，这个标题暗示了这是一个基于Spring Boot的小型项目，旨在帮助初学者理解如何集成和使用Activiti 7。Spring Boot以其"开箱即用"的特性，简化了Java应用的...
activiti入门demo
09-09
3. **任务分配**：在流程运行过程中，会生成一系列的任务（Task）。Activiti可以根据预先定义的规则（如用户组、角色等）分配这些任务给相应的人员。 4. **任务处理**：任务接收者可以通过API完成任务，或者在...
Activiti-5.23.0-release源代码
04-02
Activiti项目是一项新的基于Apache许可的开源BPM平台，从基础开始构建，旨在提供支持新的BPMN 2.0标准，包括支持对象管理组（OMG），面对新技术的机遇，诸如互操作性和云架构，提供技术实现。 创始人Tom Baeyens是JBoss jBPM的项目架构师，以及另一位架构师Joram Barrez，一起加入到创建Alfresco这项首次实现Apache开源许可的BPMN 2.0引擎开发中来。 Activiti是一个独立运作和经营的开源项目品牌，并将独立于Alfresco开源ECM系统运行。 Activiti将是一种轻量级，可嵌入的BPM引擎，而且还设计适用于可扩展的云架构。 Activiti将提供宽松的Apache许可2.0，以便这个项目可以广泛被使用，同时促进Activiti BPM引擎和BPMN 2.0的匹配，该项目现正由OMG通过标准审定。 加入Alfresco Activiti项目的是VMware的SpringSource分支，Alfresco的计划把该项目提交给Apache基础架构，希望吸引更多方面的BPM专家和促进BPM的创新。
Activiti框架与spring整合web网页端实现流程设计器
11-13
终于将Activiti的流程设计器分离出来，与SpringMVC,spring整合了起来，先把工程分享出来，等有时间了在慢慢讲解具体的整合步骤。工程下载之后直接可以运行，只需要改一下数据库连接。访问http://localhost:8080/demo/model/create?name=模型名称&key;=模型标示符&description;=模型描述
Activiti入门篇之二 Spring 与Activiti的入门整合
08-05
"Activiti入门篇之二 Spring 与Activiti的入门整合" 这个标题表明我们将会探讨如何在Spring框架中集成Activiti，一个流行的工作流引擎。这通常涉及设置Activiti的依赖，配置Spring上下文，以及如何在Spring环境中...
程序的运行过程
了不起的盖茨比的博客
07-13 2347
你是否对操作系统一无所知，你是否对线程 进程 IO等等这些基础的东西感到非常的吃力，同时碰到一些问题的时候，无从下手，今天就跟着我一起来学习操作系统这个体系的课程吧！一切要从牛人做的牛逼的事说起第一位牛人，是世界级计算机大佬的传奇——Unix 之父 Ken Thompson。在上世纪 60 年代的一个夏天，Ken Thompson 的妻子要回娘家一个月。呆在贝尔实验室的他，竟然利用这极为孤独的一个月，开发出了 UNiplexed Information and Computing System（UNICS）
工作流之流程运行服务
Richard_666的博客
08-14 285
package com.imooc.activiti.coreapi; import com.google.common.collect.Maps; import org.activiti.engine.RepositoryService; import org.activiti.engine.RuntimeService; import org.activiti.engine.reposit...
activiti前端画图转化_Activiti开发案例之代码生成工作流图片
weixin_39738380的博客
12-20 420
图例环境软件版本SpringBoot1.5.10activiti-spring-boot-starter-basic6.0生成代码以下是简化代码：/*** 查看实例流程图，根据流程实例ID获取流程图*/@RequestMapping(value="traceprocess/{instanceId}",method=RequestMethod.GET)public void traceprocess...
二、activiti流程运行原理
Coding fly的博客
11-08 2139
activiti核心处理类 RepositoryService:处理流程发布，流程定义等 RuntimeService:运行时处理类，提供开启流程、获取流程相关的参数，获取流程监听等数据 FormService:流程自定义表单处理类 IdentityService:用户权限处理类 TaskService:任务处理类 HistoryService:历史数据处理类 ManagementService:定时任务处理类 启动流程原理 启动流程入口 ProcessInstance processInsta
Activiti流程实例，任务，执行对象控制流程的执行
汉南最後の読書人
07-07 903
代码:package com.ytdx.processInstance; import java.io.InputStream; import java.util.List; import java.util.zip.ZipInputStream; import org.activiti.engine.ProcessEngine; import org.activiti.engine.Proc...
activiti的工作原理
asdfghjky的博客
03-18 1485
工作流是将一组任务组织起来以完成某个经营过程：定义了任务的触发顺序和触发条件，每个任务可以由一个或多个软件系统完成，也可以由一个或一组人完成，还可以由一个或多个人与软件系统协作完 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值