activiti_activities - CSDN
activiti 订阅
Activiti是一个项目的名称,Alfresco软件在2010年5月17日宣布Activiti业务流程管理(BPM)开源项目的正式启动,其首席架构师由业务流程管理BPM的专家 Tom Baeyens担任。 展开全文
Activiti是一个项目的名称,Alfresco软件在2010年5月17日宣布Activiti业务流程管理(BPM)开源项目的正式启动,其首席架构师由业务流程管理BPM的专家 Tom Baeyens担任。
信息
时    间
2010年5月17日
基    于
开源BPM平台
作    用
业务流程管理
中文名
activiti
公    司
Alfresco软件
外文名
activiti
activiti简介
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入门到精通(项目实战)

    千人学习 2018-12-06 18:05:35
    熟练掌握Activiti工作流框架的使用,25个数据表的结构,联系及数据变化,设计器安装,环境搭建,API使用,详细讲解了流程部署管理(发布流程,查看流程,删除流程,查看流程图,下载流程图),流程实例管理(启动流程,...
  • Activiti最全入门教程

    万次阅读 多人点赞 2017-09-28 11:23:21
    1:工作流的概念   说明: ...1) 假设:这两张图就是华谊兄弟的请假流程图  ...A....B....工作流(Workflow),就是“业务过程的部分或整体在计算机应用环境下的自动化”,它主要解决的是“使在多个参与者之间按照某种...

    1:工作流的概念

    这里写图片描述 
    这里写图片描述

    说明:
    

    1) 假设:这两张图就是华谊兄弟的请假流程图 
    2) 图的组成部分: 
    A. 人物:范冰冰 冯小刚 王中军 
    B. 事件(动作):请假、批准、不批准

    这里写图片描述 
    这里写图片描述 
    工作流(Workflow),就是“业务过程的部分或整体在计算机应用环境下的自动化”,它主要解决的是“使在多个参与者之间按照某种预定义的规则传递文档、信息或任务的过程自动进行,从而实现某个预期的业务目标,或者促使此目标的实现”。 
    工作流管理系统(Workflow Management System, WfMS)是一个软件系统,它完成工作量的定义和管理,并按照在系统中预先定义好的工作流规则进行工作流实例的执行。工作流管理系统不是企业的业务系统,而是为企业的业务系统的运行提供了一个软件的支撑环境。 
    工作流管理联盟(WfMC,Workflow Management Coalition)给出的关于工作流管理系统的定义是:工作流管理系统是一个软件系统,它通过执行经过计算的流程定义去支持一批专门设定的业务流程。工作流管理系统被用来定义、管理、和执行工作流程。 
    工作流管理系统的目标:管理工作的流程以确保工作在正确的时间被期望的人员所执行——在自动化进行的业务过程中插入人工的执行和干预。 
    3:Activiti介绍 
    Activiti5是由Alfresco软件在2010年5月17日发布的业务流程管理(BPM)框架,它是覆盖了业务流程管理、工作流、服务协作等领域的一个开源的、灵活的、易扩展的可执行流程语言框架。Activiti基于Apache许可的开源BPM平台,创始人Tom Baeyens是JBoss jBPM的项目架构师,它特色是提供了eclipse插件,开发人员可以通过插件直接绘画出业务 
    流程图。 
    这里写图片描述

    3.1:工作流引擎 
    ProcessEngine对象,这是Activiti工作的核心。负责生成流程运行时的各种实例及数据、监控和管理流程的运行。 
    3.2:BPMN 
    业务流程建模与标注(Business Process Model and Notation,BPMN) ,描述流程的基本符号,包括这些图元如何组合成一个业务流程图(Business Process Diagram)

    3.3:数据库(先了解后看) 
    Activiti数据库支持: 
    Activiti的后台是有数据库的支持,所有的表都以ACT_开头。 第二部分是表示表的用途的两个字母标识。 用途也和服务的API对应。 
    ACT_RE_*: ‘RE’表示repository。 这个前缀的表包含了流程定义和流程静态资源 (图片,规则,等等)。 
    ACT_RU_*: ‘RU’表示runtime。 这些运行时的表,包含流程实例,任务,变量,异步任务,等运行中的数据。 Activiti只在流程实例执行过程中保存这些数据, 在流程结束时就会删除这些记录。 这样运行时表可以一直很小速度很快。 
    ACT_ID_*: ‘ID’表示identity。 这些表包含身份信息,比如用户,组等等。 
    ACT_HI_*: ‘HI’表示history。 这些表包含历史数据,比如历史流程实例, 变量,任务等等。 
    ACT_GE_*: 通用数据, 用于不同场景下,如存放资源文件。

    表结构操作: 
    3.3.1:资源库流程规则表 
    1) act_re_deployment 部署信息表 
    2) act_re_model 流程设计模型部署表 
    3) act_re_procdef 流程定义数据表 
    3.3.2:运行时数据库表 
    1) act_ru_execution 运行时流程执行实例表 
    2) act_ru_identitylink 运行时流程人员表,主要存储任务节点与参与者的相关信息 
    3) act_ru_task 运行时任务节点表 
    4) act_ru_variable 运行时流程变量数据表 
    3.3.3:历史数据库表 
    1) act_hi_actinst 历史节点表 
    2) act_hi_attachment 历史附件表 
    3) act_ih_comment 历史意见表 
    4) act_hi_identitylink 历史流程人员表 
    5) act_hi_detail 历史详情表,提供历史变量的查询 
    6) act_hi_procinst 历史流程实例表 
    7) act_hi_taskinst 历史任务实例表 
    8) act_hi_varinst 历史变量表 
    3.3.4:组织机构表 
    1) act_id_group 用户组信息表 
    2) act_id_info 用户扩展信息表 
    3) act_id_membership 用户与用户组对应信息表 
    4) act_id_user 用户信息表 
    这四张表很常见,基本的组织机构管理,关于用户认证方面建议还是自己开发一套,组件自带的功能太简单,使用中有很多需求难以满足 
    3.3.5:通用数据表 
    1) act_ge_bytearray 二进制数据表 
    2) act_ge_property 属性数据表存储整个流程引擎级别的数据,初始化表结构时,会默认插入三条记录, 
    3.4:activiti.cfg.xml(activiti的配置文件) 
    Activiti核心配置文件,配置流程引擎创建工具的基本参数和数据库连接池参数。 
    定义数据库配置参数: 
     jdbcUrl: 数据库的JDBC URL。 
     jdbcDriver: 对应不同数据库类型的驱动。 
     jdbcUsername: 连接数据库的用户名。 
     jdbcPassword: 连接数据库的密码。 
    基于JDBC参数配置的数据库连接 会使用默认的MyBatis连接池。 下面的参数可以用来配置连接池(来自MyBatis参数): 
     jdbcMaxActiveConnections: 连接池中处于被使用状态的连接的最大值。默认为10。 
     jdbcMaxIdleConnections: 连接池中处于空闲状态的连接的最大值。 
     jdbcMaxCheckoutTime: 连接被取出使用的最长时间,超过时间会被强制回收。 默认为20000(20秒)。 
     jdbcMaxWaitTime: 这是一个底层配置,让连接池可以在长时间无法获得连接时, 打印一条日志,并重新尝试获取一个连接。(避免因为错误配置导致沉默的操作失败)。 默认为20000(20秒)。 
    示例数据库配置: 
    这里写图片描述

    也可以使用javax.sql.DataSource。 (比如,Apache Commons的DBCP): 
    这里写图片描述 
    3.5:logging.properties(日志处理) 
    日志的配置文件,Activiti操作数据库的时候,整合的日志文件 
    4:准备环境 
    4.1:activiti5 软件环境 
    1) JDK1.6或者更高版本 
    2) 支持的数据库有:h2, mysql, oracle, postgres, mssql, db2等。 
    3) 支持activiti5运行的jar包 
    4) 开发环境为Eclipse3.7或者以上版本,myeclipse为8.6版本 
    4.2:相关资源下载 
    1) JDK可以到sun的官网下载 
    http://www.oracle.com/technetwork/java/javase/downloads/index.html 
    2) 数据库,例如:mysql可以在官网上下载。 
    http://www.mysql.com 
    3) activiti也可以到Activiti官方网站下载得到。 
    http://activiti.org/download.html 
    4) Eclipse3.7或者MyEclipse8.6也可以到相应的网站上获得下载。 
    4.3:安装流程设计器(eclipse插件) 
    4.3.1:安装方式一 
    在有网络的情况下,安装流程设计器步骤如下: 
    1) 打开 Help -> Install New Software. 在如下面板中: 
    这里写图片描述
    2) 在如下Install界面板中,点击Add按钮: 
    这里写图片描述 
    配置新装插件的地址和名称

    3) 然后填入下列字段 
    Name: Activiti BPMN 2.0 designer 
    Location: http://activiti.org/designer/update/ 
    这里写图片描述 
    4) 回到Install界面,在面板正中列表中把所有展示出来的项目都勾上: 
    这里写图片描述 
    5) 点击复选框 
    在Detail部分记得选中 “Contact all updates sites..” , 因为它会检查所有当前安装所需要的插件并可以被Eclipse下载.

    6) 安装完以后,点击新建工程new->Other…打开面板,如果看到下图内容: 
    这里写图片描述 
    说明安装成功了。 
    4.3.2:安装方式二 
    在没有网络的情况下,安装流程设计器步骤如下: 
    1) 解压老师发给大家的 压缩包 
    2) 把压缩包中的内容放入eclipse根目录的dropins文件夹下 
    3) 重启eclipse,点击新建工程new->Other…打开面板,如果看到下图内容: 
    这里写图片描述 
    说明安装成功了 
    4.4:对流程设计器的使用说明 
    打开菜单Windows->Preferences->Activiti->Save下流程流程图片的生成方式: 
    这里写图片描述 
    虽然流程引擎在单独部署bpmn文件时会自动生成图片,但在实际开发过程中,自动生成的图片会导致和BPMN中的坐标有出入,在实际项目中展示流程当前位置图会有问题。 
    所在完成以上配置后,会由我们自己来管理流程图片。在发布流程时把流程规则文件和流程图片一起上传就行了。 
    4.5:准备Activiti5开发环境 
    4.5.1:添加Activiti5的jar包 
    在activiti-5.13->wars目录下是一些示例项目,解压activiti-rest项目,导入activiti-rest目录中WEB-INF\lib下所有包。添加到classpath中。 
    由于我们使用的是Mysql数据库,Mysql数据库的链接驱动Activiti官方包中并没有提供,需要我们自己导入。手动导入mysql-connector-java.jar,添加到classpath下。 
    4.5.2:初始化数据库 
    这里写图片描述
    在Activiti中,在创建核心的流程引擎对象时会自动建表。如果程序正常执行,mysql会自动建库,然后创建23张表。

    4.5.3:添加并制定配置文件 
    在Actiiti5中定制流程必定会操作到数据库,如果都像上面那样写一大段代码会非常麻烦,所以我们可以把数据库连接配置写入配置文件。 
    在Activiti5的官方示例中并没有现成的配置文件,所以先得找到activiti-rest\WEB-INF\classes下有:

    4.5.3.1:activiti-context.xml : 
    一个类似spring结构的配置文件,清空内容后改名为activiti.cfg.xml,用来做流程引擎的相关配置。 
    按照上面代码配置ProcessEngineConfiguration对象,主要定义数据库的连接配置和建表策略,配置文件代码如下: 
    这里写图片描述
    Java代码如下: 
    这里写图片描述
    createProcessEngineConfigurationFromResource的参数值为我们添加的配置文件activiti.cfg.xml的名称,执行java代码,流程引擎对象创建成功运行后数据库会自动建表。

    /**使用代码创建工作流需要的23张表*/
        @Test
        public void createTable(){
            ProcessEngineConfiguration processEngineConfiguration = ProcessEngineConfiguration.createStandaloneProcessEngineConfiguration();
            //连接数据库的配置
            processEngineConfiguration.setJdbcDriver("com.mysql.jdbc.Driver");
            processEngineConfiguration.setJdbcUrl("jdbc:mysql://localhost:3306/shareniu?useUnicode=true&characterEncoding=utf8");
            processEngineConfiguration.setJdbcUsername("root");
            processEngineConfiguration.setJdbcPassword("root");
    
            /**
                public static final String DB_SCHEMA_UPDATE_FALSE = "false";不能自动创建表,需要表存在
                public static final String DB_SCHEMA_UPDATE_CREATE_DROP = "create-drop";先删除表再创建表
                public static final String DB_SCHEMA_UPDATE_TRUE = "true";如果表不存在,自动创建表
             */
            processEngineConfiguration.setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);
            //工作流的核心对象,ProcessEnginee对象
            ProcessEngine processEngine = processEngineConfiguration.buildProcessEngine();
            System.out.println("processEngine:"+processEngine);
        }
    
        /**使用配置文件创建工作流需要的23张表*/
        @Test
        public void createTable_2(){
    //      ProcessEngineConfiguration processEngineConfiguration = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cfg.xml");
    //      //工作流的核心对象,ProcessEnginee对象
    //      ProcessEngine processEngine = processEngineConfiguration.buildProcessEngine();
    
            ProcessEngine processEngine = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cfg.xml")   //
                                        .buildProcessEngine();
            System.out.println("processEngine:"+processEngine);
        }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32

    4.5.3.2:log4j.properties 日志配置文件 
    把两个文件放入resource目录下即可。

    5:核心API 
    5.1:ProcessEngine 
    说明: 
    1) 在Activiti中最核心的类,其他的类都是由他而来。 
    2) 产生方式:

    在前面看到了两种创建ProcessEngine(流程引擎)的方式,而这里要简化很多,调用ProcessEngines的getDefaultProceeEngine方法时会自动加载classpath下名为activiti.cfg.xml文件。 
    3) 可以产生RepositoryService

    4) 可以产生RuntimeService

    5) 可以产生TaskService

    各个Service的作用: 
    RepositoryService 管理流程定义 
    RuntimeService 执行管理,包括启动、推进、删除流程实例等操作 
    TaskService 任务管理 
    HistoryService 历史管理(执行完的数据的管理) 
    IdentityService 组织机构管理 
    FormService 一个可选服务,任务表单管理 
    ManagerService

    5.2:RepositoryService 
    是Activiti的仓库服务类。所谓的仓库指流程定义文档的两个文件:bpmn文件和流程图片。 
    1) 产生方式

    2) 可以产生DeploymentBuilder,用来定义流程部署的相关参数

    3) 删除流程定义

    5.3:RuntimeService 
    是activiti的流程执行服务类。可以从这个服务类中获取很多关于流程执行相关的信息。 
    5.4:TaskService 
    是activiti的任务服务类。可以从这个类中获取任务的信息。 
    5.5:HistoryService 
    是activiti的查询历史信息的类。在一个流程执行完成后,这个对象为我们提供查询历史信息。 
    5.6:ProcessDefinition 
    流程定义类。可以从这里获得资源文件等。 
    5.7:ProcessInstance 
    代表流程定义的执行实例。如范冰冰请了一天的假,她就必须发出一个流程实例的申请。一个流程实例包括了所有的运行节点。我们可以利用这个对象来了解当前流程实例的进度等信息。流程实例就表示一个流程从开始到结束的最大的流程分支,即一个流程中流程实例只有一个。 
    5.8:Execution 
    Activiti用这个对象去描述流程执行的每一个节点。在没有并发的情况下,Execution就是同ProcessInstance。流程按照流程定义的规则执行一次的过程,就可以表示执行对象Execution。 
    如图为ProcessInstance的源代码: 
    这里写图片描述
    从源代码中可以看出ProcessInstance就是Execution。但在现实意义上有所区别: 
    这里写图片描述 
    在单线流程中,如上图的贷款流程,ProcessInstance与Execution是一致的。 
    这里写图片描述 
    这个例子有一个特点:wire money(汇钱)和archive(存档)是并发执行的。 这个时候,总线路代表ProcessInstance,而分线路中每个活动代表Execution。 
    总结: 
    * 一个流程中,执行对象可以存在多个,但是流程实例只能有一个。 
    * 当流程按照规则只执行一次的时候,那么流程实例就是执行对象。

    6:HelloWorld程序(模拟流程的执行) 
    6.1:流程图:

    这里写图片描述 
    6.2:部署流程定义 
    这里写图片描述 
    这里使用RepositoryService部署流程定义 
    addClasspathResource表示从类路径下加载资源文件,一次只能加载一个文件 
    6.3:启动流程实例 
    这里写图片描述 
    这里使用RuntimeService启动流程实例 
    6.4:查看我的个人任务 
    这里写图片描述 
    这里使用TaskService完成任务的查询 
    6.5:完成我的个人任务 
    这里写图片描述 
    这里使用TaskService完成任务的办理

    7:管理流程定义 
    7.1:设计流程定义文档 
    7.1.1:流程图 
    这里写图片描述 
    7.1.2:bpmn文件 
    BPMN 2.0根节点是definitions节点。 这个元素中,可以定义多个流程定义(不过我们建议每个文件只包含一个流程定义, 可以简化开发过程中的维护难度)。 一个空的流程定义看起来像下面这样。注意,definitions元素 最少也要包含xmlns 和 targetNamespace的声明。 targetNamespace可以是任意值,它用来对流程实例进行分类。 
    这里写图片描述 
    说明:流程定义文档有两部分组成: 
    1) bpmn文件 
    流程规则文件。在部署后,每次系统启动时都会被解析,把内容封装成流程定义放入项目缓存中。Activiti框架结合这个xml文件自动管理流程,流程的执行就是按照bpmn文件定义的规则执行的,bpmn文件是给计算机执行用的。 
    2) 展示流程图的图片 
    在系统里需要展示流程的进展图片,图片是给用户看的。

    7.2:部署流程定义(classpath路径加载文件) 
    这里写图片描述 
    说明: 
    1) 先获取流程引擎对象:在创建时会自动加载classpath下的activiti.cfg.xml

    2) 首先获得默认的流程引擎,通过流程引擎获取了一个RepositoryService对象(仓库对象) 
    3) 由仓库的服务对象产生一个部署对象配置对象,用来封装部署操作的相关配置。 
    4) 这是一个链式编程,在部署配置对象中设置显示名,上传流程定义规则文件 
    5) 向数据库表中存放流程定义的规则信息。 
    6) 这一步在数据库中将操作三张表: 
    a) act_re_deployment(部署对象表) 
    存放流程定义的显示名和部署时间,每部署一次增加一条记录。 
    这里写图片描述 
    这里写图片描述
    Deployment deployment = processEngine.getRepositoryService()// 
    .createDeployment().name(“入门程序”)// 
    .addClasspathResource(“hello/helloworld.bpmn”)// 从classpath的资源中加载,一次只能加载一个文件 
    // .addClasspathResource(“diagrams/helloworld.png”)// 
    // 从classpath的资源中加载,一次只能加载一个文件 
    .deploy(); 
    b) act_re_procdef(流程定义表) 
    存放流程定义的属性信息,部署每个新的流程定义都会在这张表中增加一条记录。 
    注意:当流程定义的key相同的情况下,使用的是版本升级 
    这里写图片描述 
    这里写图片描述
    对应的封装类:

    public interface ProcessDefinition {
    
      String getId();
      String getCategory();
      String getName();
      String getKey();
      String getDescription();
      int getVersion();
      String getResourceName();
      String getDeploymentId();
      String getDiagramResourceName();
      boolean hasStartFormKey();
      boolean isSuspended();
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    代码的操作: 
    /* 查询流程定义 /

        @Test
        public void findProcessDefinition() {
            List<ProcessDefinition> list = processEngine.getRepositoryService()// 与流程定义和部署对象相关的Service
                    .createProcessDefinitionQuery()// 创建一个流程定义的查询
                    /** 指定查询条件,where条件 */
                    // .deploymentId(deploymentId)//使用部署对象ID查询
                    // .processDefinitionId(processDefinitionId)//使用流程定义ID查询
                    // .processDefinitionKey(processDefinitionKey)//使用流程定义的key查询
                    // .processDefinitionNameLike(processDefinitionNameLike)//使用流程定义的名称模糊查询
    
                    /** 排序 */
                    .orderByProcessDefinitionVersion().asc()// 按照版本的升序排列
                    // .orderByProcessDefinitionName().desc()//按照流程定义的名称降序排列
    
                    /** 返回的结果集 */
                    .list();// 返回一个集合列表,封装流程定义
            // .singleResult();//返回惟一结果集
            // .count();//返回结果集数量
            // .listPage(firstResult, maxResults);//分页查询
            if (list != null && list.size() > 0) {
                for (ProcessDefinition pd : list) {
                    System.out.println("流程定义ID:" + pd.getId());// 流程定义的key+版本+随机生成数
                    System.out.println("流程定义的名称:" + pd.getName());// 对应helloworld.bpmn文件中的name属性值
                    System.out.println("流程定义的key:" + pd.getKey());// 对应helloworld.bpmn文件中的id属性值
                    System.out.println("流程定义的版本:" + pd.getVersion());// 当流程定义的key值相同的相同下,版本升级,默认1
                    System.out.println("资源名称bpmn文件:" + pd.getResourceName());
                    System.out.println("资源名称png文件:" + pd.getDiagramResourceName());
                    System.out.println("部署对象ID:" + pd.getDeploymentId());
                    System.out
                            .println("#########################################################");
                }
            }
        }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33

    程序的输出: 
    流程定义ID:helloworld:1:4 
    流程定义的名称:helloworldProcess 
    流程定义的key:helloworld 
    流程定义的版本:1 
    资源名称bpmn文件:hello/helloworld.bpmn 
    资源名称png文件:hello/helloworld.helloworld.png 
    部署对象ID:1 
    c) act_ge_bytearray(资源文件表) 
    存储流程定义相关的部署信息。即流程定义文档的存放地。每部署一次就会增加两条记录,一条是关于bpmn规则文件的,一条是图片的(如果部署时只指定了bpmn一个文件,activiti会在部署时解析bpmn文件内容自动生成流程图)。两个文件不是很大,都是以二进制形式存储在数据库中。 
    这里写图片描述
    7.3:部署流程定义(zip格式文件) 
    这里写图片描述 
    这里写图片描述 
    将 
    压缩成zip格式的文件,使用zip的输入流用作部署流程定义

    7.4:查看流程定义 
    查询流程定义的信息 
    这里写图片描述 
    结果: 
    这里写图片描述 
    再部署一次运行结果为: 
    这里写图片描述 
    可以看到流程定义的key值相同的情况下,版本是从1开始逐次升级的 
    流程定义的Id是【key:版本:生成ID】 
    说明: 
    1) 流程定义和部署对象相关的Service都是RepositoryService。 
    2) 创建流程定义查询对象,可以在ProcessDefinitionQuery上设置查询的相关参数 
    3) 调用ProcessDefinitionQuery对象的list方法,执行查询,获得符合条件的流程定义列表 
    4) 由运行结果可以看出: 
    Key和Name的值为:bpmn文件process节点的id和name的属性值 
    这里写图片描述 
    5) key属性被用来区别不同的流程定义。 
    6) 带有特定key的流程定义第一次部署时,version为1。之后每次部署都会在当前最高版本号上加1 
    7) Id的值的生成规则为:{processDefinitionKey}:{processDefinitionVersion}:{generated-id}, 这里的generated-id是一个自动生成的唯一的数字 
    8) 重复部署一次,deploymentId的值以一定的形式变化 
    规则act_ge_property表生成 
    这里写图片描述 
    7.5:删除流程定义 
    删除部署到activiti中的流程定义。 
    这里写图片描述 
    说明: 
    1) 因为删除的是流程定义,而流程定义的部署是属于仓库服务的,所以应该先得到RepositoryService 
    2) 如果该流程定义下没有正在运行的流程,则可以用普通删除。如果是有关联的信息,用级联删除。项目开发中使用级联删除的情况比较多,删除操作一般只开放给超级管理员使用。 
    7.6:获取流程定义文档的资源(查看流程图附件) 
    查询出流程定义文档。主要查的是图片,用于显示流程用。 
    这里写图片描述 
    说明: 
    1) deploymentId为流程部署ID 
    2) resourceName为act_ge_bytearray表中NAME_列的值 
    3) 使用repositoryService的getDeploymentResourceNames方法可以获取指定部署下得所有文件的名称 
    4) 使用repositoryService的getResourceAsStream方法传入部署ID和资源图片名称可以获取部署下指定名称文件的输入流 
    5) 最后的有关IO流的操作,使用FileUtils工具的copyInputStreamToFile方法完成流程流程到文件的拷贝,将资源文件以流的形式输出到指定文件夹下 
    7.7:附加功能:查询最新版本的流程定义 
    这里写图片描述 
    Key value保存 key 为key value为流程定义 
    代码: 
    /*附加功能:查询最新版本的流程定义*/

    @Test
        public void findLastVersionProcessDefinition(){
            List<ProcessDefinition> list = processEngine.getRepositoryService()//
                            .createProcessDefinitionQuery()//
                            .orderByProcessDefinitionVersion().asc()//使用流程定义的版本升序排列
                            .list();
            /**
             * Map<String,ProcessDefinition>
      map集合的key:流程定义的key
      map集合的value:流程定义的对象
      map集合的特点:当map集合key值相同的情况下,后一次的值将替换前一次的值
             */
            Map<String, ProcessDefinition> map = new LinkedHashMap<String, ProcessDefinition>();
            if(list!=null && list.size()>0){
                for(ProcessDefinition pd:list){
                    map.put(pd.getKey(), pd);
                }
            }
            List<ProcessDefinition> pdList = new ArrayList<ProcessDefinition>(map.values());
            if(pdList!=null && pdList.size()>0){
                for(ProcessDefinition pd:pdList){
                    System.out.println("流程定义ID:"+pd.getId());//流程定义的key+版本+随机生成数
                    System.out.println("流程定义的名称:"+pd.getName());//对应helloworld.bpmn文件中的name属性值
                    System.out.println("流程定义的key:"+pd.getKey());//对应helloworld.bpmn文件中的id属性值
                    System.out.println("流程定义的版本:"+pd.getVersion());//当流程定义的key值相同的相同下,版本升级,默认1
                    System.out.println("资源名称bpmn文件:"+pd.getResourceName());
                    System.out.println("资源名称png文件:"+pd.getDiagramResourceName());
                    System.out.println("部署对象ID:"+pd.getDeploymentId());
                    System.out.println("#########################################################");
                }
            }   
        }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32

    7.8:附加功能:删除流程定义(删除key相同的所有不同版本的流程定义) 
    这里写图片描述

    @Test
        public void deleteProcessDefinitionByKey() {
            // 流程定义的key
            String processDefinitionKey = "helloworld";
            // 先使用流程定义的key查询流程定义,查询出所有的版本
            List<ProcessDefinition> list = processEngine.getRepositoryService()//
                    .createProcessDefinitionQuery()//
                    .processDefinitionKey(processDefinitionKey).list();//
            // 遍历,获取每个流程定义的部署ID
            if (list != null && list.size() > 0) {
                for(ProcessDefinition pd:list){
                    //获取部署ID
                    String deploymentId = pd.getDeploymentId();
                    processEngine.getRepositoryService()//
                                .deleteDeployment(deploymentId, true); 
                }
            }
        }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    7.9:总结 
    Deployment 部署对象 
    1、一次部署的多个文件的信息。对于不需要的流程可以删除和修改。 
    2、对应的表: 
    act_re_deployment:部署对象表 
    act_re_procdef:流程定义表 
    act_ge_bytearray:资源文件表 
    act_ge_property:主键生成策略表

    ProcessDefinition 流程定义 
    1、解析.bpmn后得到的流程定义规则的信息,工作流系统就是按照流程定义的规则执行的。

    8:流程实例、任务的执行 
    8.1:流程图 
    这里写图片描述 
    8.2:部署流程定义 
    这里写图片描述 
    8.3:启动流程实例 
    这里写图片描述
    说明: 
    1) 操作数据库的act_ru_execution表,如果是用户任务节点,同时也会在act_ru_task添加一条记录 
    act_ru_execution表,#正在执行的执行对象表 任务结束的之前只有 一个 变化的字段是act_id 
    这里写图片描述
    这里写图片描述

    8.4:查询我的个人任务 
    这里写图片描述

    @Test
        public void findMyPersonalTask(){
            String assignee = "王五";
            List<Task> list = processEngine.getTaskService()//与正在执行的任务管理相关的Service
                            .createTaskQuery()//创建任务查询对象
                            /**查询条件(where部分)*/
                            .taskAssignee(assignee)//指定个人任务查询,指定办理人
    //                      .taskCandidateUser(candidateUser)//组任务的办理人查询
    //                      .processDefinitionId(processDefinitionId)//使用流程定义ID查询
    //                      .processInstanceId(processInstanceId)//使用流程实例ID查询
    //                      .executionId(executionId)//使用执行对象ID查询
                            /**排序*/
                            .orderByTaskCreateTime().asc()//使用创建时间的升序排列
                            /**返回结果集*/
    //                      .singleResult()//返回惟一结果集
    //                      .count()//返回结果集的数量
    //                      .listPage(firstResult, maxResults);//分页查询
                            .list();//返回列表
            if(list!=null && list.size()>0){
                for(Task task:list){
                    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.getProcessInstanceId());
                    System.out.println("执行对象ID:"+task.getExecutionId());
                    System.out.println("流程定义ID:"+task.getProcessDefinitionId());
                    System.out.println("########################################################");
                }
            }
        }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31

    输出: 
    任务ID:504 
    任务名称:提交申请 
    任务的创建时间:Sat Aug 09 08:50:20 CST 2014 
    任务的办理人:张三 
    流程实例ID:501 
    执行对象ID:501 
    流程定义ID:helloworld:1:404 
    接口:

    public interface Task {
      int DEFAULT_PRIORITY = 50;
        String getId(); String getName();
        void setName(String name);
        String getDescription();
        void setDescription(String description);
        int getPriority();
        void setPriority(int priority);
      String getOwner();
      void setOwner(String owner);
        String getAssignee();
        void setAssignee(String assignee);  DelegationState getDelegationState();
      void setDelegationState(DelegationState delegationState);
        String getProcessInstanceId();
        String getExecutionId();
        String getProcessDefinitionId();
        Date getCreateTime();
        String getTaskDefinitionKey();
        Date getDueDate();
        void setDueDate(Date dueDate);
      void delegate(String userId);
      void setParentTaskId(String parentTaskId);
      String getParentTaskId();
      boolean isSuspended();
      Map<String, Object> getTaskLocalVariables();
      Map<String, Object> getProcessVariables();
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27

    说明: 
    1) 因为是任务查询,所以从processEngine中应该得到TaskService 
    2) 使用TaskService获取到任务查询对象TaskQuery 
    3) 为查询对象添加查询过滤条件,使用taskAssignee指定任务的办理者(即查询指定用户的代办任务),同时可以添加分页排序等过滤条件 
    4) 调用list方法执行查询,返回办理者为指定用户的任务列表 
    5) 任务ID、名称、办理人、创建时间可以从act_ru_task表中查到。 
    6) Execution与ProcessInstance见5.6和5.7章节的介绍。在这种情况下,ProcessInstance相当于Execution 
    7) 如果assignee属性为部门经理,结果为空。因为现在流程只到了”填写请假申请”阶段,后面的任务还没有执行,即在数据库中没有部门经理可以办理的任务,所以查询不到。 
    8) 一个Task节点和Execution节点是1对1的情况,在task对象中使用Execution_来表示他们之间的关系 
    9) 任务ID在数据库表act_ru_task中对应“ID_”列

    附加: 
    在activiti任务中,主要分为两大类查询任务(个人任务和组任务): 
    1.确切指定了办理者的任务,这个任务将成为指定者的私有任务,即个人任务。 
    2.无法指定具体的某一个人来办理的任务,可以把任务分配给几个人或者一到 多个小组,让这个范围内的用户可以选择性(如有空余时间时)来办理这类任务,即组任务。 
    先知道个人任务的查询和办理,组任务的操作后面讲

    8.5:办理任务 
    这里写图片描述

    说明: 
    1) 是办理任务,所以从ProcessEngine得到的是TaskService。 
    2) 当执行完这段代码,再以员工的身份去执行查询的时候,会发现这个时候已经没有数据了,因为正在执行的任务中没有数据。 
    3) 对于执行完的任务,activiti将从act_ru_task表中删除该任务,下一个任务会被插入进来。 
    4) 以”部门经理”的身份进行查询,可以查到结果。因为流程执行到部门经理审批这个节点了。 
    5) 再执行办理任务代码,执行完以后以”部门经理”身份进行查询,没有结果。 
    6) 重复第3和4步直到流程执行完。 
    act_ru_task表: 
    这里写图片描述

    8.6:查询流程状态(判断流程正在执行,还是结束) 
    这里写图片描述 
    /* 查询流程状态(判断流程正在执行,还是结束) /

    @Test
        public void isProcessEnd() {
            String processInstanceId = "501";
            ProcessInstance pi = processEngine.getRuntimeService()// 表示正在执行的流程实例和执行对象
                    .createProcessInstanceQuery()// 创建流程实例查询
                    .processInstanceId(processInstanceId)// 使用流程实例ID查询
                    .singleResult();
            if (pi == null) {
                System.out.println("流程已经结束");
            } else {
                System.out.println("流程没有结束");
            }
        }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    在流程执行的过程中,创建的流程实例ID在整个过程中都不会变,当流程结束后,流程实例将会在正在执行的执行对象表中(act_ru_execution)被删除
    说明:
    

    1) 因为是查询流程实例,所以先获取runtimeService 
    2) 创建流程实例查询对象,设置实例ID过滤参数 
    3) 由于一个流程实例ID只对应一个实例,使用singleResult执行查询返回一个唯一的结果,如果结果数量大于1,则抛出异常 
    4) 判断指定ID的实例是否存在,如果结果为空,则代表流程结束,实例在正在执行的执行对象表中已被删除,转换成历史数据。 
    8.7:附加功能:查询历史任务(后面讲) 
    这里写图片描述 
    /*查询历史任务(后面讲)/

    @Test
        public void findHistoryTask(){
            String taskAssignee = "张三";
            List<HistoricTaskInstance> list = processEngine.getHistoryService()//与历史数据(历史表)相关的Service
                            .createHistoricTaskInstanceQuery()//创建历史任务实例查询
                            .taskAssignee(taskAssignee)//指定历史任务的办理人
                            .list();
            if(list!=null && list.size()>0){
                for(HistoricTaskInstance hti:list){
                    System.out.println(hti.getId()+"    "+hti.getName()+"    "+hti.getProcessInstanceId()+"   "+hti.getStartTime()+"   "+hti.getEndTime()+"   "+hti.getDurationInMillis());
                    System.out.println("################################");
                }
            }
        }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    表《HistoricTaskInstance》 
    8.8:附加功能:查询历史流程实例(后面讲)

    这里写图片描述 
    8.9:总结 
    Execution 执行对象 
    按流程定义的规则执行一次的过程. 
    对应的表: 
    act_ru_execution: 正在执行的信息 
    act_hi_procinst:已经执行完的历史流程实例信息 
    act_hi_actinst:存放历史所有完成的活动 
    ProcessInstance 流程实例 
    特指流程从开始到结束的那个最大的执行分支,一个执行的流程中,流程实例只有1个。

    注意 
    (1)如果是单例流程,执行对象ID就是流程实例ID 
    (2)如果一个流程有分支和聚合,那么执行对象ID和流程实例ID就不相同 
    (3)一个流程中,流程实例只有1个,执行对象可以存在多个。

    Task 任务 
    执行到某任务环节时生成的任务信息。 
    对应的表: 
    act_ru_task:正在执行的任务信息 
    act_hi_taskinst:已经执行完的历史任务信息

    9:流程变量 
    9.1:流程图 
    这里写图片描述 
    流程变量在整个工作流中扮演很重要的作用。例如:请假流程中有请假天数、请假原因等一些参数都为流程变量的范围。流程变量的作用域范围是只对应一个流程实例。也就是说各个流程实例的流程变量是不相互影响的。流程实例结束完成以后流程变量还保存在数据库中。 
    例如: 
    这里写图片描述
    即:

    9.2:部署流程定义 
    这里写图片描述 
    说明: 
    • 输入流加载资源文件的3种方式 
    这里写图片描述 
    这里写图片描述

    9.3:启动流程实例 
    这里写图片描述 
    9.4:设置流程变量 
    这里写图片描述
    说明: 
    1) 流程变量的作用域就是流程实例,所以只要设置就行了,不用管在哪个阶段设置 
    2) 基本类型设置流程变量,在taskService中使用任务ID,定义流程变量的名称,设置流程变量的值。 
    3) Javabean类型设置流程变量,需要这个javabean实现了Serializable接口 
    4) 设置流程变量的时候,向act_ru_variable这个表添加数据

    9.5:获取流程变量 
    这里写图片描述

    说明: 
    1) 流程变量的获取针对流程实例(即1个流程),每个流程实例获取的流程变量时不同的 
    2) 使用基本类型获取流程变量,在taskService中使用任务ID,流程变量的名称,获取流程变量的值。 
    3) Javabean类型设置获取流程变量,除了需要这个javabean实现了Serializable接口外,还要求流程变量对象的属性不能发生变化,否则抛出异常。 
    解决方案,在javabean对象中添加: 
    private static final long serialVersionUID = 6757393795687480331L; 
    9.6:模拟流程变量的设置和获取的场景 
    这里写图片描述 
    说明: 
    1) RuntimeService对象可以设置流程变量和获取流程变量 
    2) TaskService对象可以设置流程变量和获取流程变量 
    3) 流程实例启动的时候可以设置流程变量 
    4) 任务办理完成的时候可以设置流程变量 
    5) 流程变量可以通过名称/值的形式设置单个流程变量 
    6) 流程变量可以通过Map集合,同时设置多个流程变量 
    Map集合的key表示流程变量的名称 
    Map集合的value表示流程变量的值

    9.7:查询历史的流程变量 
    这里写图片描述 
    说明: 
    1)历史的流程变量查询,指定流程变量的名称,查询act_hi_varinst表(也可以针对,流程实例ID,执行对象ID,任务ID查询)

    9.8:流程变量的支持的类型 
    如图是从官网列出来的流程变量的类型: 
    这里写图片描述 
    从图中可以看出包括了大部分封装类型和Date、String和实现了Serializable接口的类的类型。 
    9.9:总结 
    • 1:流程变量 
    在流程执行或者任务执行的过程中,用于设置和获取变量,使用流程变量在流程传递的过程中传递业务参数。 
    对应的表: 
    act_ru_variable:正在执行的流程变量表 
    act_hi_varinst:流程变量历史表

    • 2:扩展知识:setVariable和setVariableLocal的区别 
    setVariable:设置流程变量的时候,流程变量名称相同的时候,后一次的值替换前一次的值,而且可以看到TASK_ID的字段不会存放任务ID的值 
    setVariableLocal: 
    1:设置流程变量的时候,针对当前活动的节点设置流程变量,如果一个流程中存在2个活动节点,对每个活动节点都设置流程变量,即使流程变量的名称相同,后一次的版本的值也不会替换前一次版本的值,它会使用不同的任务ID作为标识,存放2个流程变量值,而且可以看到TASK_ID的字段会存放任务ID的值 
    例如act_hi_varinst 表的数据:不同的任务节点,即使流程变量名称相同,存放的值也是不同的。 
    如图: 
    这里写图片描述
    2:还有,使用setVariableLocal说明流程变量绑定了当前的任务,当流程继续执行时,下个任务获取不到这个流程变量(因为正在执行的流程变量中没有这个数据),所有查询正在执行的任务时不能查询到我们需要的数据,此时需要查询历史的流程变量。

    10:流程执行历史记录 
    10.1:查询历史流程实例 
    查找按照某个流程定义的规则一共执行了多少次流程 
    这里写图片描述 
    10.2:查询历史活动 
    某一次流程的执行一共经历了多少个活动 
    这里写图片描述 
    10.3:查询历史任务 
    某一次流程的执行一共经历了多少个任务 
    这里写图片描述 
    10.4:查询历史流程变量 
    某一次流程的执行一共设置的流程变量 
    这里写图片描述 
    10.5:总结 
    由于数据库中保存着历史信息以及正在运行的流程实例信息,在实际项目中对已完成任务的查看频率远不及对代办和可接任务的查看,所以在activiti采用分开管理,把正在运行的交给RuntimeService、TaskService管理,而历史数据交给HistoryService来管理。 
    这样做的好处在于,加快流程执行的速度,因为正在执行的流程的表中数据不会很大。

    展开全文
  • Activiti 工作流入门到大神

    万人学习 2018-10-22 21:38:05
    什么是流程、工作流作用、Activiti背景简介、Activiti流程设计器安装、Activity环境搭建、通过HelloWorld掌握 Activiti操作流程的步奏、常见API使用、流程部署管理(发布流程、查看流程定义、删除流程、查看流程附件)...
  • activiti6.0从入门到精通

    千人学习 2019-04-28 10:30:43
    Activiti项目是一项新的基于Apache许可的开源BPM平台,从基础开始构建,旨在提供支持新的BPMN 2.0标准,包括支持对象管理组(OMG),面对新技术的机遇,诸如互操作性和云架构,提供技术实现。  工作流是什么:...
  • Activiti6详细教程

    万次阅读 2020-07-13 15:14:04
    一、为什么选择Activiti activiti介绍 Activiti是由Alfresco软件在2010年5月17日发布的业务流程管理(BPM)框架,它是覆盖了业务流程管理,工作流,服务协作等领域的一个开源,灵活的,易扩展的可执行流程语言框架。 ...

    一、为什么选择Activiti

    activiti介绍 Activiti是由Alfresco软件在2010年5月17日发布的业务流程管理(BPM)框架,它是覆盖了业务流程管理,工作流,服务协作等领域的一个开源,灵活的,易扩展的可执行流程语言框架。

      解决方案 优点 缺点 选型结果 选型原因
    开源

    Activiti

    JBPM 

    Flowable

    开源

    免费

    开发工作量大

    开发难度大

    中文支持不好

    Activiti

    相对JBPM上手容易

    原生支持Spring

    与 Spring boot 集成较好

     

    Flowable新出的,使用人数少教程资源少

    商用

    炎黄盈动

    普元

    慧正

    天翎

    宏天

    开发工作量小

    开发难度小

    符合中国国情

    闭源

    价格高

       

    二、核心7大接口、28张表

    (一)7大接口

    • RepositoryService:提供一系列管理流程部署和流程定义的API。
    • RuntimeService:在流程运行时对流程实例进行管理与控制。
    • TaskService:对流程任务进行管理,例如任务提醒、任务完成和创建任务等。
    • IdentityService:提供对流程角色数据进行管理的API,这些角色数据包括用户组、用户及它们之间的关系。
    • ManagementService:提供对流程引擎进行管理和维护的服务。
    • HistoryService:对流程的历史数据进行操作,包括查询、删除这些历史数据。
    • FormService:表单服务。

    (二)28张表

    1. act_ge_ 通用数据表,ge是general的缩写
    2. act_hi_ 历史数据表,hi是history的缩写,对应HistoryService接口
    3. act_id_ 身份数据表,id是identity的缩写,对应IdentityService接口
    4. act_re_ 流程存储表,re是repository的缩写,对应RepositoryService接口,存储流程部署和流程定义等静态数据
    5. act_ru_ 运行时数据表,ru是runtime的缩写,对应RuntimeService接口和TaskService接口,存储流程实例和用户任务等动态数据

    表结构操作: 
    3.3.1:资源库流程规则表 

    • 1) act_re_deployment 部署信息表 
    • 2) act_re_model 流程设计模型部署表 
    • 3) act_re_procdef 流程定义数据表 

    3.3.2:运行时数据库表 

    • 1) act_ru_execution 运行时流程执行实例表 
    • 2) act_ru_identitylink 运行时流程人员表,主要存储任务节点与参与者的相关信息 
    • 3) act_ru_task 运行时任务节点表 
    • 4) act_ru_variable 运行时流程变量数据表 

    3.3.3:历史数据库表 

    • 1) act_hi_actinst 历史节点表 
    • 2) act_hi_attachment 历史附件表 
    • 3) act_ih_comment 历史意见表 
    • 4) act_hi_identitylink 历史流程人员表 
    • 5) act_hi_detail 历史详情表,提供历史变量的查询 
    • 6) act_hi_procinst 历史流程实例表 
    • 7) act_hi_taskinst 历史任务实例表 
    • 8) act_hi_varinst 历史变量表 

    3.3.4:组织机构表 

    • 1) act_id_group 用户组信息表 
    • 2) act_id_info 用户扩展信息表 
    • 3) act_id_membership 用户与用户组对应信息表 
    • 4) act_id_user 用户信息表 

    这四张表很常见,基本的组织机构管理,关于用户认证方面建议还是自己开发一套,组件自带的功能太简单,使用中有很多需求难以满足 
    3.3.5:通用数据表 

    • 1) act_ge_bytearray 二进制数据表 
    • 2) act_ge_property 属性数据表存储整个流程引擎级别的数据,初始化表结构时,会默认插入三条记录, 
    • 3.4:activiti.cfg.xml(activiti的配置文件) 

    Activiti核心配置文件,配置流程引擎创建工具的基本参数和数据库连接池参数。 
    定义数据库配置参数: 

    • jdbcUrl: 数据库的JDBC URL。 
    • jdbcDriver: 对应不同数据库类型的驱动。 
    • jdbcUsername: 连接数据库的用户名。 
    • jdbcPassword: 连接数据库的密码。 

    基于JDBC参数配置的数据库连接 会使用默认的MyBatis连接池。 下面的参数可以用来配置连接池(来自MyBatis参数): 

    • jdbcMaxActiveConnections: 连接池中处于被使用状态的连接的最大值。默认为10。 
    • jdbcMaxIdleConnections: 连接池中处于空闲状态的连接的最大值。 
    • jdbcMaxCheckoutTime: 连接被取出使用的最长时间,超过时间会被强制回收。 默认为20000(20秒)。 
    • jdbcMaxWaitTime: 这是一个底层配置,让连接池可以在长时间无法获得连接时, 打印一条日志,并重新尝试获取一个连接。(避免因为错误配置导致沉默的操作失败)。 默认为20000(20秒)。

     

     流程部署相关表 

    • act_re_deployement 部署对象表 
    • act_rep_procdef  流程定义表 
    • act_ge_bytearray 资源文件表 
    • act_ge_prperty  主键生成策略表(对于部署对象表的主键ID)

     流程实例相关表

    •  act_ru_execution 正在执行的执行对象表(包含执行对象ID和流程实例ID,如果有多个线程可能流程实例ID不一样)
    •  act_hi_procinst 流程实例历史表
    •  act_hi_actinst 存放历史所有完成的任务

     Task 任务相关表

    •  act_ru_task 代办任务表 (只对应节点是UserTask的)
    •  act_hi_taskinst 代办任务历史表 (只对应节点是UserTask的) 
    •  act_hi_actinst  所有节点活动历史表 (对应流程的所有节点的活动历史,从开始节点一直到结束节点中间的所有节点的活动都会被记录)

    流程变量表

    •  act_ru_variable 正在执行的流程变量表
    •  act_hi_variable 流程变量历史表

     三、创建BPMN业务流程模型

    1.将Activiti提供的流程设计器应用activiti-app.war部署到Tomcat的webapps目录。
    2.创建新的MySql数据库。修改activiti-app\WEB-INF\classes\META-INF\activiti-app目录下的activiti-app.properties配置文件,默认使用H2内存数据库,创建的模型重启后会丢失,改成使用MySql数据库。
    3.浏览器访问http://localhost:8080/activiti-app,登录账户:admin:test
    4.创建一个请假审批流程图

     

    给每个用户任务指派候选组(有权限执行当前任务的角色)


    指派候选组

     

    排他网关设置条件分支表达式


    5.导出流程图为.bpmn20.xml文件


    导出xml文件

    四、Spring Boot与Activiti 6.0整合

    1.在POM文件中添加依赖

    <dependency>
        <groupId>org.activiti</groupId>
        <artifactId>activiti-spring-boot-starter-basic</artifactId>
        <version>6.0.0</version>
    </dependency>

    2.将导出的.bpmn20.xml文件拷贝到项目文件夹/resources/processes下
    3.application.properties文件添加配置项

    spring.activiti.database-schema-update=true

    databaseSchemaUpdate配置项可以设置流程引擎启动和关闭时数据库执行的策略。 databaseSchemaUpdate有以下四个值:

    • false:false为默认值,设置为该值后,Activiti在启动时,会对比数据库表中保存的版本,如果没有表或者版本不匹配时,将在启动时抛出异常。
    • true:设置为该值后,Activiti会对数据库中所有的表进行更新,如果表不存在,则Activiti会自动创建。
    • create-drop:Activiti启动时,会执行数据库表的创建操作,在Activiti关闭时,执行数据库表的删除操作。
    • drop-create:Activiti启动时,执行数据库表的删除操作在Activiti关闭时,会执行数据库表的创建操作。

    4.启动应用,会在数据库里创建28张表,表创建好之后停止应用。application.properties文件修改配置项

    #每次应用启动不检查Activiti数据表是否存在及版本号是否匹配,提升应用启动速度
    spring.activiti.database-schema-update=false

    5.application.properties文件增加配置项

    #保存历史数据级别设置为full最高级别,便于历史数据的追溯
    spring.activiti.history-level=full

    对于历史数据,保存到何种粒度,Activiti提供了history-level属性对其进行配置。history-level属性有点像log4j的日志输出级别,该属性有以下四个值:

    • none:不保存任何的历史数据,因此,在流程执行过程中,这是最高效的。
    • activity:级别高于none,保存流程实例与流程行为,其他数据不保存。
    • audit:除activity级别会保存的数据外,还会保存全部的流程任务及其属性。audit为history的默认值。
    • full:保存历史数据的最高级别,除了会保存audit级别的数据外,还会保存其他全部流程相关的细节数据,包括一些流程参数等。

    6.完成以上步骤,就可以在程序中使用自动注入的方式,使用Activiti的7大接口。

    @Autowired
    private RuntimeService runtimeService;
     
    @Autowired
    private TaskService taskService;
     
    @Autowired
    private IdentityService identityService;
     
    @Autowired
    private RepositoryService repositoryService;
     
    @Autowired
    private ProcessEngine processEngine;
     
    @Autowired
    private HistoryService historyService;

     

    5:核心API 
    5.1:ProcessEngine 
    说明: 
    1) 在Activiti中最核心的类,其他的类都是由他而来。 
    2) 产生方式:
     
    在前面看到了两种创建ProcessEngine(流程引擎)的方式,而这里要简化很多,调用ProcessEngines的getDefaultProceeEngine方法时会自动加载classpath下名为activiti.cfg.xml文件。 
    3) 可以产生RepositoryService
     
    4) 可以产生RuntimeService
     
    5) 可以产生TaskService
     
    各个Service的作用: 
    RepositoryService 管理流程定义 
    RuntimeService 执行管理,包括启动、推进、删除流程实例等操作 
    TaskService 任务管理 
    HistoryService 历史管理(执行完的数据的管理) 
    IdentityService 组织机构管理 
    FormService 一个可选服务,任务表单管理 
    ManagerService
     
    5.2:RepositoryService 
    是Activiti的仓库服务类。所谓的仓库指流程定义文档的两个文件:bpmn文件和流程图片。 
    1) 产生方式
     
    2) 可以产生DeploymentBuilder,用来定义流程部署的相关参数
     
    3) 删除流程定义
     
    5.3:RuntimeService 
    是activiti的流程执行服务类。可以从这个服务类中获取很多关于流程执行相关的信息。 
    5.4:TaskService 
    是activiti的任务服务类。可以从这个类中获取任务的信息。 
    5.5:HistoryService 
    是activiti的查询历史信息的类。在一个流程执行完成后,这个对象为我们提供查询历史信息。 
    5.6:ProcessDefinition 
    流程定义类。可以从这里获得资源文件等。 
    5.7:ProcessInstance 
    代表流程定义的执行实例。如范冰冰请了一天的假,她就必须发出一个流程实例的申请。一个流程实例包括了所有的运行节点。我们可以利用这个对象来了解当前流程实例的进度等信息。流程实例就表示一个流程从开始到结束的最大的流程分支,即一个流程中流程实例只有一个。 
    5.8:Execution 
    Activiti用这个对象去描述流程执行的每一个节点。在没有并发的情况下,Execution就是同ProcessInstance。流程按照流程定义的规则执行一次的过程,就可以表示执行对象Execution。 

     

    RepositoryService:管理流程定义
     
    RuntimeService:执行管理,包括启动、推进、删除流程实例等操作
     
    TaskService:任务管理
     
    HistoryService:历史管理(执行完的数据的管理)
     
    IdentityService:组织机构管理
     
    FormService:一个可选服务,任务表单管理
     
    ManagerService
     
    5.2:RepositoryService
    是Activiti的仓库服务类。所谓的仓库指流程定义文档的两个文件:bpmn文件和流程图片。
     
    1) 产生方式
      
    2) 可以产生DeploymentBuilder,用来定义流程部署的相关参数
       
    3) 删除流程定义
      
    5.3:RuntimeService
    是activiti的流程执行服务类。可以从这个服务类中获取很多关于流程执行相关的信息。
      
    5.4:TaskService
    是activiti的任务服务类。可以从这个类中获取任务的信息。
     
    5.5:HistoryService
    是activiti的查询历史信息的类。在一个流程执行完成后,这个对象为我们提供查询历史信息。
     
    5.6:ProcessDefinition
    流程定义类。可以从这里获得资源文件等。
     
    5.7:ProcessInstance
    代表流程定义的执行实例。如范冰冰请了一天的假,她就必须发出一个流程实例的申请。一个流程实例包括了所有的运行节点。我们可以利用这个对象来了解当前流程实例的进度等信息。流程实例就表示一个流程从开始到结束的最大的流程分支,即一个流程中流程实例只有一个。
     
    5.8:Execution
    Activiti用这个对象去描述流程执行的每一个节点。在没有并发的情况下,Execution就是同ProcessInstance。流程按照流程定义的规则执行一次的过程,就可以表示执行对象Execution。

     
    五、项目中的用户、角色与Activiti中的用户、用户组整合

    每个项目都有自己的用户、角色表,Activiti也有自己的用户、用户组表。因此项目中的用户、角色与Activiti中的用户、用户组要做整合。

    //项目中每创建一个新用户,对应的要创建一个Activiti用户
    //两者的userId和userName一致
    User admin=identityService.newUser("1");
    admin.setLastName("admin");
    identityService.saveUser(admin);
     
    //项目中每创建一个角色,对应的要创建一个Activiti用户组
    Group adminGroup=identityService.newGroup("1");
    adminGroup.setName("admin");
    identityService.saveGroup(adminGroup);
     
    //用户与用户组关系绑定
    identityService.createMembership("1","1");

    六、请假审批流程

    1.请假申请和请假审批数据库表设计
    表设计原则:流程数据和业务数据相分离。Activiti相关表只负责流程的跳转、走向等。流程中产生的业务表单数据、审批意见、附件等存储在开发人员定义的业务表中。流程数据和业务数据之间通过processInstanceId(流程实例ID)和业务数据主键相互关联。

    为什么不使用Activiti相关表来存储表单数据和附件?

    activiti参数表

    Activiti为了应用的灵活性和通用性采用了纵表的方式存储表单数据。假设一条请假申请表单数据有10个字段,那就需要10条记录存储原本横表只需要一条记录存储的数据。采用纵表的方式会有如下问题:

    会有大量的冗余数据并且数据量会急剧的增长
    查询语句复杂,查询效率低
    尤其不适合做后期的统计报表分析


    activiti附件表

    Activiti存储附件使用Blob数据格式,文件存储在数据库里,数据库的数据文件会变得超大,不利于数据库备份和迁移。
    请假申请表结构

    请假申请表

    请假审批表结构

    请假审批表


    2.填写请假申请表单,启动流程实例

    填写请假申请

    //启动流程实例,字符串"vacation"是BPMN模型文件里process元素的id
    ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("vacation");
    //流程实例启动后,流程会跳转到请假申请节点
    Task vacationApply = taskService.createTaskQuery().processInstanceId(processInstance.getId()).singleResult();
    //设置请假申请任务的执行人
    taskService.setAssignee(vacationApply.getId(), req.getUserId().toString());
     
    //设置流程参数:请假天数和表单ID
    //流程引擎会根据请假天数days>3判断流程走向
    //formId是用来将流程数据和表单数据关联起来
    Map<String, Object> args = new HashMap<>();
    args.put("days", req.getDays());
    args.put("formId", formId);
     
    //完成请假申请任务
    taskService.complete(vacationApply.getId(), args);


    3.待审批列表

     

    //查出当前登录用户所在的用户组
    List<Group> groups = identityService.createGroupQuery()
            .groupMember(String.valueOf(userId)).list();
    List<String> groupNames = groups.stream()
            .map(group -> group.getName()).collect(Collectors.toList());
     
    //查询用户组的待审批请假流程列表
    List<Task> tasks = taskService.createTaskQuery()
            .processDefinitionKey("vacation")
            .taskCandidateGroupIn(groupNames)
            .listPage(pageNum - 1, pageSize);
     
    //根据流程实例ID查询请假申请表单数据
    List<String> processInstanceIds = tasks.stream()
            .map(task -> task.getProcessInstanceId())
            .collect(Collectors.toList());
    List<VacationApplyBasicPO> vacationApplyList = 
            vacationRepository.getVacationApplyList(processInstanceIds);


    4.请假审批功能

     

    //查询当前审批节点
    Task vacationAudit = taskService.createTaskQuery()
            .taskId(req.getTaskId()).singleResult();
     
    if (req.getAuditResult() == 1) {//审批通过
        //设置流程参数:审批ID
        Map<String, Object> args = new HashMap<>();
        args.put("auditId", auditId);
     
        //设置审批任务的执行人
        taskService.claim(vacationAudit.getId(), req.getUserId().toString());
        //完成审批任务
        taskService.complete(vacationAudit.getId(), args);
    } else {
        //审批不通过,结束流程
        runtimeService.deleteProcessInstance(vacationAudit.getProcessInstanceId(), auditId);
    }


    5.查看流程图功能

     

    //controller层代码
    @RequestMapping(value = "/image", method = RequestMethod.GET)
    public void image(HttpServletResponse response,
     @RequestParam String processInstanceId) {
        try {
            InputStream is = vacationService.getDiagram(processInstanceId);
            if (is == null)
                return;
     
            response.setContentType("image/png");
     
            BufferedImage image = ImageIO.read(is);
            OutputStream out = response.getOutputStream();
            ImageIO.write(image, "png", out);
     
            is.close();
            out.close();
        } catch (Exception ex) {
            logger.error("查看流程图失败", ex);
        }
    }
     
    //service层代码
    @Override
    public InputStream getDiagram(String processInstanceId) {
        //获得流程实例
        ProcessInstance processInstance = runtimeService.createProcessInstanceQuery()
                .processInstanceId(processInstanceId).singleResult();
        String processDefinitionId = StringUtils.EMPTY;
        if (processInstance == null) {
            //查询已经结束的流程实例
            HistoricProcessInstance processInstanceHistory =
                    historyService.createHistoricProcessInstanceQuery()
                            .processInstanceId(processInstanceId).singleResult();
            if (processInstanceHistory == null)
                return null;
            else
                processDefinitionId = processInstanceHistory.getProcessDefinitionId();
        } else {
            processDefinitionId = processInstance.getProcessDefinitionId();
        }
     
        //使用宋体
        String fontName = "宋体";
        //获取BPMN模型对象
        BpmnModel model = repositoryService.getBpmnModel(processDefinitionId);
        //获取流程实例当前的节点,需要高亮显示
        List<String> currentActs = Collections.EMPTY_LIST;
        if (processInstance != null)
            currentActs = runtimeService.getActiveActivityIds(processInstance.getId());
     
        return processEngine.getProcessEngineConfiguration()
                .getProcessDiagramGenerator()
                .generateDiagram(model, "png", currentActs, new ArrayList<String>(),
                        fontName, fontName, fontName, null, 1.0);
    }


     参照教程:https://blog.csdn.net/qq877507054/article/details/60143099

     

    展开全文
  • Activiti7初探

    万次阅读 2019-05-18 19:50:56
    activiti 7.0.0.SR1+springboot 2.0.4.RELEASE 1、idea中安装activiti的插件 2、引入依赖 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-par.....

    activiti 7.0.0.SR1+springboot 2.0.4.RELEASE

    1、 idea中安装activiti的插件

    在这里插入图片描述

    2、引入依赖

    <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.0.4.RELEASE</version>
            <relativePath/> <!-- lookup parent from repository -->
        </parent>
    
        <properties>
            <activiti.version>7.0.0.SR1</activiti.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatisplus-spring-boot-starter</artifactId>
                <version>1.0.5</version>
            </dependency>
    
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus</artifactId>
                <version>3.1.0</version>
            </dependency>
    
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.1.16</version>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.35</version>
            </dependency>
    
            <dependency>
                <groupId>org.activiti</groupId>
                <artifactId>activiti-spring-boot-starter</artifactId>
                <version>${activiti.version}</version>
                <exclusions>
                    <exclusion>
                        <groupId>org.activiti.core.common</groupId>
                        <artifactId>activiti-spring-identity</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
        </dependencies>
    

    application.properties中增加配置

    #表示启动时检查数据库表,不存在则创建
    spring.activiti.database-schema-update=true
    #表示哪种情况下使用历史表,这里配置为full表示全部记录历史,方便绘制流程图
    spring.activiti.history-level=full
    #true表示使用历史表,如果不配置,则工程启动后可以检查数据库,只建立了17张表
    spring.activiti.db-history-used=true
    

    3、画流程的bpmn图,其实就是设计中的活动图

    在这里插入图片描述

    4、25张表

    在这里插入图片描述

    5、核心service

    RuntimeService
    TaskService
    HistoryService
    RepositoryService

    6、启动流程并自动完成第一步

    public String startProcess(ProcessDealDto processDealDto) {
    
            ProcessInstance instance = runtimeService.startProcessInstanceByKey(WorkFlowConstant.PROCESS_WORKTICKET_ID);
            //验证是否启动成功
            //通过查询正在运行的流程实例来判断
            ProcessInstanceQuery processInstanceQuery = runtimeService.createProcessInstanceQuery();
            //根据流程实例ID来查询
            List<ProcessInstance> runningList = processInstanceQuery.processInstanceId(instance.getProcessInstanceId()).list();
            logger.debug(LogFormatter.toMsg("start process", "instance"), runningList);
    
            String instanceId = instance.getId();
    
            //设置处理人
            Task task = taskService.createTaskQuery().processInstanceId(instanceId).singleResult();
            if (task != null) {
                //自动完成第一步
    
                Map<String, Object> map = new HashMap<String, Object>(2);
                map.put("check", 1);
                map.put("personId", processDealDto.getPersonId());
                taskService.setAssignee(task.getId(), processDealDto.getCurrentPersonId());
                taskService.complete(task.getId(), map);
    
                task = taskService.createTaskQuery().processInstanceId(instanceId).singleResult();
                taskService.setAssignee(task.getId(), processDealDto.getPersonId());
            } else {
                throw new BusinessException(WorkTaskErrorCode.WORK_TASK_START_PROCESS_ERROR);
            }
    
            // 返回流程ID
            return instanceId;
        }
    

    7、节点处理

    public void auditProcess(ProcessDealDto processDealDto) {
            Task task = null;
            if (ObjectUtils.isNotEmpty(processDealDto.getInstanceId())) {
                task = taskService.createTaskQuery().processInstanceId(processDealDto.getInstanceId()).singleResult();
            } else if (ObjectUtils.isNotEmpty(processDealDto.getTaskId())) {
                task = taskService.createTaskQuery().taskId(processDealDto.getTaskId()).singleResult();
            }
    
            if (task == null) {
                throw new BusinessException(WorkTaskErrorCode.WORK_TASK_BACK_PROCESS_EMPTY_ERROR);
            }
            if (WorkFlowConstant.AUDIT_PASS.equals(processDealDto.getCheck())) {
                dealProcess(task, processDealDto);
            } else {
                backProcess(task, processDealDto);
            }
        }
    
    /**
         * 退回到上一节点
         *
         * @param task
         * @param processDealDto
         */
        private void backProcess(Task task, ProcessDealDto processDealDto) {
    
            List<HistoricTaskInstance> htiList = historyService.createHistoricTaskInstanceQuery()
                    .processInstanceId(processDealDto.getInstanceId())
                    .orderByTaskCreateTime()
                    .desc()
                    .list();
    
            if (ObjectUtils.isEmpty(htiList) || htiList.size() < 2) {
                return;
            }
    
            HistoricTaskInstance myTask = htiList.get(1);
            String myTaskId = myTask.getId();
    
            if (null == myTaskId) {
                throw new BusinessException(WorkTaskErrorCode.WORK_TASK_BACK_PROCESS_USER_ERROR);
            }
    
            String processDefinitionId = myTask.getProcessDefinitionId();
            ProcessDefinitionEntity processDefinitionEntity = (ProcessDefinitionEntity) repositoryService.createProcessDefinitionQuery().processDefinitionId(processDefinitionId).singleResult();
            BpmnModel bpmnModel = repositoryService.getBpmnModel(processDefinitionId);
    
            //变量
    //		Map<String, VariableInstance> variables = runtimeService.getVariableInstances(currentTask.getExecutionId());
            String myActivityId = null;
            List<HistoricActivityInstance> haiList = historyService.createHistoricActivityInstanceQuery()
                    .executionId(myTask.getExecutionId()).finished().list();
            for (HistoricActivityInstance hai : haiList) {
                if (myTaskId.equals(hai.getTaskId())) {
                    myActivityId = hai.getActivityId();
                    break;
                }
            }
            FlowNode myFlowNode = (FlowNode) bpmnModel.getMainProcess().getFlowElement(myActivityId);
    
    
            Execution execution = runtimeService.createExecutionQuery().executionId(task.getExecutionId()).singleResult();
            String activityId = execution.getActivityId();
    //        logger.warn("------->> activityId:" + activityId);
            FlowNode flowNode = (FlowNode) bpmnModel.getMainProcess().getFlowElement(activityId);
    
            //记录原活动方向
            List<SequenceFlow> oriSequenceFlows = new ArrayList<SequenceFlow>();
            oriSequenceFlows.addAll(flowNode.getOutgoingFlows());
    
            //清理活动方向
            flowNode.getOutgoingFlows().clear();
            //建立新方向
            List<SequenceFlow> newSequenceFlowList = new ArrayList<SequenceFlow>();
            SequenceFlow newSequenceFlow = new SequenceFlow();
            newSequenceFlow.setId("newSequenceFlowId");
            newSequenceFlow.setSourceFlowElement(flowNode);
            newSequenceFlow.setTargetFlowElement(myFlowNode);
            newSequenceFlowList.add(newSequenceFlow);
            flowNode.setOutgoingFlows(newSequenceFlowList);
    
            Map<String, Object> currentVariables = new HashMap<String, Object>();
            currentVariables.put("check", 0);
            currentVariables.put("dealMsg", processDealDto.getDealMsg());
            currentVariables.put("personId", processDealDto.getPersonId());
            taskService.createAttachment("", task.getId(), processDealDto.getInstanceId(), "dealMsg", processDealDto.getDealMsg(), "");
            //完成任务
            taskService.complete(task.getId(), currentVariables);
            //恢复原方向
            flowNode.setOutgoingFlows(oriSequenceFlows);
    
            Task nextTask = taskService.createTaskQuery().processInstanceId(processDealDto.getInstanceId()).singleResult();
            if(nextTask!=null) {
                taskService.setAssignee(nextTask.getId(), myTask.getAssignee());
            }
        }
    
        /**
         * 正向流程
         *
         * @param task
         * @param processDealDto
         */
        private void dealProcess(Task task, ProcessDealDto processDealDto) {
    
            Map<String, Object> map = new HashMap<String, Object>(2);
            map.put("check", processDealDto.getCheck());
            map.put("personId", processDealDto.getPersonId());
            map.put("dealMsg", processDealDto.getDealMsg());
    
            task.setDescription(WorkFlowStatus.getDescriptionByIndex(processDealDto.getNodeType()));
    
            String taskId = task.getId();
            taskService.createAttachment("", taskId, processDealDto.getInstanceId(), "dealMsg", processDealDto.getDealMsg(), "");
            taskService.complete(taskId, map);
    
            //设置处理人,将流程流转到下一个人
            Task nextTask = taskService.createTaskQuery().processInstanceId(processDealDto.getInstanceId()).singleResult();
    
            if(nextTask!=null) {
                taskService.setAssignee(nextTask.getId(), processDealDto.getPersonId());
            }
        }
    

    8、历史查询

    不显示起始节点和排他网关

    public List<ProcessHistoryDto> getHistoryByInstance(String instanceId) {
    
            HistoricActivityInstanceQuery historyInstanceQuery = historyService.createHistoricActivityInstanceQuery().processInstanceId(instanceId);
            // 查询历史节点
            List<HistoricActivityInstance> historicActivityInstanceList = historyInstanceQuery.orderByHistoricActivityInstanceStartTime().asc().list();
            if (ObjectUtils.isNotEmpty(historicActivityInstanceList)) {
                List<ProcessHistoryDto> historyDtos = new ArrayList<>();
    
                Integer lastNodeId = null;
    
                ProcessHistoryDto lastHistoryNode = null;
    
                for (HistoricActivityInstance activityInstance : historicActivityInstanceList) {
                    if(activityInstance.getActivityName().equals("StartEvent") || activityInstance.getActivityName().equals("ExclusiveGateway")){
                        continue;
                    }
    
                    ProcessHistoryDto historyDto = new ProcessHistoryDto();
                    historyDto.setActivitId(activityInstance.getActivityId());
                    historyDto.setDealPersonID(activityInstance.getAssignee());
                    historyDto.setDealTime(activityInstance.getEndTime());
    
                    Integer nowNodeId = WorkFlowNodeEnum.getIndexByName(activityInstance.getActivityId());
                    historyDto.setNodeId(nowNodeId);
                    historyDto.setCheck(true);
                    //判断是否为驳回
                    if(lastNodeId != null && nowNodeId < lastNodeId){
                        lastHistoryNode.setCheck(false);
                    }else if(lastNodeId != null && WorkFlowNodeEnum.WORK_PERMITER_CHECK.getIndex().equals(lastNodeId)
                            && WorkFlowNodeEnum.FINISH.getIndex().equals(nowNodeId)){
                        //从许可人直接驳回
                        lastHistoryNode.setCheck(false);
                    }
    
                    if(!"EndEvent".equals(activityInstance.getActivityName())) {
                        List<Attachment> attachmentList = taskService.getTaskAttachments(activityInstance.getTaskId());
                        if (ObjectUtils.isNotEmpty(attachmentList)) {
                            historyDto.setAttachment(attachmentList.get(0).getDescription());
                        }
    
                        historyDto.setDealPersonName(getPersonNameAndNoById(activityInstance.getAssignee()));
                    }
    
                    lastNodeId = nowNodeId;
                    lastHistoryNode = historyDto;
    
                    //没有结束时间,表示当前正处于该节点,历史中不展示,但是要用这个节点来判断是否是驳回
                    if(ObjectUtils.isEmpty(activityInstance.getEndTime())){
                        continue;
                    }
    
                    historyDtos.add(historyDto);
                }
                return historyDtos;
            }
            return null;
        }
    

    9、代办

    public List<PersonToDoDto> getToDoList(String personId) {
    
            List<Task> list = taskService.createTaskQuery().taskCandidateOrAssigned(personId).list();
            if(ObjectUtils.isNotEmpty(list)){
                List<PersonToDoDto> personToDoDtos = new ArrayList<>();
                for(Task task : list){
                    PersonToDoDto personToDoDto = new PersonToDoDto();
                    personToDoDto.setInstanceId(task.getProcessInstanceId());
                    personToDoDto.setTaskId(task.getId());
                    personToDoDtos.add(personToDoDto);
                }
                return personToDoDtos;
            }
            return null;
        }
    

    10、重写用户权限

    @Service
    public class CustomUserGroupManagerImpl implements UserGroupManager{
    
        public static List<String> roles = new ArrayList<>();
        public static List<String> groups = new ArrayList<>();
        public static List<String> users = new ArrayList<>();
        public static Map<String,String> userRoleMap = new HashMap<>();
        static {
            roles.add("workCreate");
            roles.add("workPermit");
            roles.add("workLeader");
    
            groups.add("workGroupA");
    
            users.add("admin");
            users.add("laowang");
            users.add("xiaofang");
    
            userRoleMap.put("admin", "workCreate");
            userRoleMap.put("laowang", "workPermit");
            userRoleMap.put("xiaofang", "workLeader");
        }
    
        @Override
        public List<String> getUserGroups(String s) {
    
            return groups;
        }
    
        @Override
        public List<String> getUserRoles(String s) {
            String role = userRoleMap.get(s);
            List<String> list = new ArrayList<>();
            list.add(role);
            return list;
        }
    
        @Override
        public List<String> getGroups() {
            return groups;
        }
    
        @Override
        public List<String> getUsers() {
            return users;
        }
    }
    

    11、关闭activiti默认的安全校验

    启动类上添加注解

    @EnableAutoConfiguration(exclude = {org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration.class})
    
    @Configuration
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
    
        @Override
        protected void configure(HttpSecurity http) throws Exception {
            http.authorizeRequests().anyRequest().permitAll().and().logout().permitAll();
        }
    }
    

    12、配置activiti的数据源和线程池

    @Configuration
    public class WorkFlowConfiguration{
    
    @Autowired
    private UserGroupManager userGroupManager;
    
        @Autowired
        private DataSource dataSource;
    
        private int corePoolSize = 10;
        private int maxPoolSize = 30;
        private int keepAliveSeconds = 300;
        private int queueCapacity = 300;
    
        @Bean
        public SpringProcessEngineConfiguration springProcessEngineConfiguration(
                PlatformTransactionManager transactionManager) throws IOException {
    
            SpringProcessEngineConfiguration configuration = new SpringProcessEngineConfiguration();
            configuration.setDataSource(dataSource);
            configuration.setTransactionManager(transactionManager);
            SpringAsyncExecutor asyncExecutor = new SpringAsyncExecutor();
            asyncExecutor.setTaskExecutor(workFlowAsync());
            configuration.setAsyncExecutor(asyncExecutor);
    
            configuration.setDatabaseSchemaUpdate("true");
            configuration.setUserGroupManager(userGroupManager);
            configuration.setHistoryLevel(HistoryLevel.FULL);
            configuration.setDbHistoryUsed(true);
            return configuration;
        }
    
        @Primary
        @Bean("workFlowTaskExecutor")
        public ThreadPoolTaskExecutor workFlowAsync() {
            ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
            executor.setCorePoolSize(corePoolSize);
            executor.setMaxPoolSize(maxPoolSize);
            executor.setKeepAliveSeconds(keepAliveSeconds);
            executor.setQueueCapacity(queueCapacity);
            executor.setThreadNamePrefix("workFlowTaskExecutor-");
            executor.initialize();
            return executor;
        }
    
    
    }
    
    

    13、其他问题

    有时候发现application.properties中的配置不起作用

    @Configuration
    public class InitConfigTest implements CommandLineRunner {
    
        @Autowired
        private ProcessEngine processEngine;
    
        @Override
        public void run(String... args) throws Exception {
            Deployment deployment = processEngine.getRepositoryService()
                    .createDeployment()
                    .name("workTask")
                    .addClasspathResource("processes/workTask.bpmn")
    //                .addClasspathResource("repository/TestProcess.png")
                    .deploy();
        }
    }
    
    展开全文
  • Activiti的基本介绍

    万次阅读 2018-09-06 22:57:19
    Activiti简介 Activiti 是由 jBPM 的创建者 Tom Baeyens 离开 JBoss 之后建立的项目,构建在开发 jBPM 版本 1 到 4 时积累的多年经验的基础之上,旨在创建下一代的 BPM 解决方案。 Activiti是一个开源的工作流引擎...

    Activiti简介

    Activiti 是由 jBPM 的创建者 Tom Baeyens 离开 JBoss 之后建立的项目,构建在开发 jBPM 版本 1 到 4 时积累的多年经验的基础之上,旨在创建下一代的 BPM 解决方案。

    Activiti是一个开源的工作流引擎,它实现了BPMN 2.0规范,可以发布设计好的流程定义,并通过api进行流程调度。

    Activiti 作为一个遵从 Apache 许可的工作流和业务流程管理开源平台,其核心是基于Java的超快速、超稳定的 BPMN2.0 流程引擎,强调流程服务的可嵌入性和可扩展性,同时更加强调面向业务人员。

    Activiti 流程引擎重点关注在系统开发的易用性和轻量性上。每一项 BPM 业务功能 Activiti 流程引擎都以服务的形式提供给开发人员。通过使用这些服务,开发人员能够构建出功能丰富、轻便且高效的 BPM 应用程序。

    Activiti是一个针对企业用户、开发人员、系统管理员的轻量级工作流业务管理平台,其核心是使用Java开发的快速、稳定的BPMN e 2.0流程引擎。Activiti是在ApacheV2许可下发布的,可以运行在任何类型的Java程序中,例如服务器、集群、云服务等。Activiti可以完美地与Spring集成。同时,基于简约思想的设计使Activiti非常轻量级。

     

    Activiti的特点

    1)数据持久化

    Activiti的设计思想是简洁、快速。有过应用开发经验的开发人员都知道应用的瓶颈体现在和数据库交换数据的过程中,针对这一点Activiti选择了使MyBatis,从而可以通过最优的SQL语句执行Command,仅凭如此就能让引擎在速度上保持最高的性能。

    2)引擎service接口 

    Activiti 流程引擎重点关注在系统开发的易用性和轻量性上。每一项 BPM 业务功能 Activiti 流程引擎都以服务的形式提供给开发人员。通过使用这些服务,开发人员能够构建出功能丰富、轻便且高效的 BPM 应用程序。

    ctiviti.cfg.xml文件为核心配置文件,该配置文件集成在Spring的IOC容器当中,可以产生ProcessEngineConfiguration对象,这个对象就是流程引擎的配置对象,ProcessEngine对象则为流程引擎对象,该对象是工作流业务系统的核心,所有的业务操作都是由这个对象所派生出来的对象实现。

    Activiti引擎提供了七大Service接口,均通过ProcessEngine获取,并且支持链式API编程风格。

    3)流程设计器

    在jBPM4时代有专门的Eclipse插件可以用来设计jPDL,同样Activiti团队也专门设计了用来设计BPMN 2.0规范的流程谩计器-Eclipse Designer。此外还有Signavio公司为Activiti定制的基于Web的Activiti Modeler流程设计器。喜欢用IDEA的,IDEA也有actiBPM插件支持。

    4)原生支持Spring

    Activiti原生支持Spring,这一点对企业应用来说尤为重要:可以很轻松地进行Spring集成,非常方便管理事务和解析表达式( Expression)。

    5)分离运行时与历史数据

    Activiti继承自jBPM4,在表结构设计方面也遵循运行时与历史数据的分离,这样的设计可以快速读取运行时数据,仅当需要查询历史数据时再从专门的历史数据表中读取。这种设计方式可以大幅提高数据的存取效率,尤其是当数据日积月累时依然能够快速反应。

     

    Activiti架构与组件

    Activiti Engine

    作为最核心的模块,提供针对BPMN 2.0规范的解析、执行、创建、管理(任务、流程实例)、查询历史记录并根据结果生成报表。

    Activiti Modeler

    是模型设计器,其并非由Activiti公司所开发,而是由业界认可的Signavio公司赠送的(Signavio e原本是收费的产品,现在被免费授权给Activiti用户使用)。适用于业务人员把需求转换为规范流程定义。

    Activiti Designer

    功能和Activiti Modeler类似,同样提供了基于BPMN 2.0规范的可视化设计功能,但是目前还没有完全支持BPMN规范的定义。适用于开发人员,可以把业务需求人员用Signavio设计的流程定义(XML格式)导入到Designer中,从而让开发人员将其进一步加工成为可以运行的流程定义。

    Activiti Explorer

    可以用来管理仓库、用户、组,启动流程、任务办理等。此组件使用REST风格API,提供一个基础的设计模型。如果业务简单,也可以直接使用无需开发。还可以作为后台管理员的流程、任务管理系统使用。

    Activiti REST

    提供Restful风格的服务,允许客户端以JSON的方式与引擎的REST API交互,通用的协议具有跨平台、跨语言的特性。

     

    Activiti与jBPM5的对比

    jBPM5 和 Activiti 同样支持 BPMN2.0 规范,但是实际上jBPM5 已经推翻了 jBPM3 和 jBPM4 的架构,使用了 Drools Flow 作为工作流架构,这对于原来使用 jBPM3 和 jBPM4 的用户来说是非常郁闷的一件事(从零开始重新学习 jBPM5),而 Activiti 更像是原来 jBPM4 的延续,因此对于原来使用 jBPM3 和 jBPM4 的用户来说,更推荐使用 Activiti,但是由于 JBoss 中有一些优秀的项目(例如规则引擎 Drools、Seam 等),jBPM5 与这些项目进行整合具有先天的优势,因此如何进行选择还需要进行权衡。

    从技术组成来看,Activiti最大的优势是采用了PVM(流程虚拟机),支持除了BPMN2.0规范之外的流程格式,与外部服务有良好的集成能力,延续了jBPM3、jBPM4良好的社区支持,服务接口清晰,链式API更为优雅;劣势是持久化层没有遵循JPA规范。jBPM最大的优势是采用了Apache Mina异步通信技术,采用JPA/JTA持久化方面的标准,以功能齐全的Guvnor作为流程仓库,有RedHat(jBoss.org被红帽收购)的专业化支持;但其劣势也很明显,对自身技术依赖过紧且目前仅支持BPMN2。

    序号

    技术组成 Activiti jBPM5

    1

    数据库持久层ORM MyBatis3 Hibernate3

    2

    持久化标准

    EJB JPA规范

    3

    事务管理

    MyBatis机制/Spring事务控制

    Bitronix,基于JTA事务管理

    4

    数据库连接方式

    Jdbc/DataSource

    Jdbc/DataSource

    5

    支持数据库

    Oracle、SQL Server、MySQL、H2、内存数据库等

    Oracle、SQL Server、MySQL、内存数据库等

    6

    设计模式

    命令(Command)模式、观察者模式等

    7

    内部服务通讯

    Service间通过API调用

    基于Apache Mina异步通讯

    8

    集成接口

    SOAP、Mule、RESTful

    消息通讯

    9

    支持的流程格式

    BPMN2、xPDL、jPDL等(由PVM实现)

    目前仅只支持BPMN2 xml

    10

    引擎核心

    PVM(流程虚拟机)

    Drools

    11

    技术前身

    jBPM3、jBPM4

    Drools Flow

    12

    所属公司

    Alfresco

    jBoss.org

    jBPM5 和 Activiti的主要相似之处:

    1)都是BPMN2过程建模和执行环境。

    2)都是BPM系统(符合BPM规范)。

    3)都是开源项目-遵循ASL协议( Apache的 软件许可)。

    4)都源自JBoss(Activiti5是jBPM4的衍生,jBPM5则基于Drools Flow)。

    5)都很成熟,从无到有,双方开始约始于2年半前。

    6)都有对人工任务的生命周期管理。 Activiti5和jBPM5唯一的区别是jBPM5基于WebService - HumanTask标准来描述人工任务和管理生命周期。 如有兴趣了解这方面的标准及其优点,可参阅WS - HT规范介绍 。

    7)都使用了不同风格的 Oryx 流程编辑器对BPMN2建模。 jBPM5采用的是 Intalio 维护的开源项目分支。 Activiti5则使用了Signavio维护的分支。

    展开全文
  • activiti6官方版本

    2020-07-30 23:30:12
    官方版本的activiti6,走过路过不要错过!!!!!!!!!
  • activiti工作流-概述

    万次阅读 热门讨论 2018-06-12 10:57:23
    1 应用场景1.1 业务流程采购系统完成了企业的日常采购管理,包括采购单管理、采购单审核、入库、结算等模块。 用户角色包括:员工、部门经理、总经理、财务。 基本业务流程如下:1.2 业务的概念 什么是业务?...
  • flowable官方文档汉化版V6.2,内容比较详细。可以进行参考。
  • 2019最新Activiti6.0模块介绍

    千次阅读 2019-01-16 11:33:34
    基于源码运行activiti-app  启动activiti-app  cd modules/activiti-ui/activiti-app  mvn clean tomcat8:run  open http://ip地址:9999/activiti-app  剖析Activiti-App  activiti-ui  activiti-app ...
  • activitiDemo+项目实战

    2020-07-30 23:32:02
    根据传智播客activiti视频 整理的Demo+ 以及activiti项目实战完整版+excel笔记
  • activiti-5.17.0.zip activiti下载
  • Activiti6.x中文版用户指南
  • Activiti官方工作流全文档。包括如何配置,快速入门,由浅入深,非常好。
  • Activiti下载地址

    千次阅读 2018-03-05 15:14:11
    https://github.com/Activiti/Activiti/releases
  • activiti-6.0.0.zip百度网盘下载

    千次阅读 2018-11-15 12:55:09
    activiti-6.0.0.zip百度网盘下载 https://pan.baidu.com/s/1-LKNb9wAGPFnW3VxWsJjcQ
  • Activiti5.22.0开发指南

    2020-07-30 23:33:23
    Activiti5.22.0开发指南,高清版。工作流开发的基础知识和Activiti开发都有讲解到。
  • activiti5.20与6.0版本数据库变化。activiti6.0版本比较5版本有很多地方都有了优化,整理了数据库相关的变化,如有问题,请联系!
  • activiti-designer-5.18.0

    2020-03-11 23:33:56
    在myEclipse2014下集成Activiti插件
1 2 3 4 5 ... 20
收藏数 21,329
精华内容 8,531
关键字:

activiti