Activiti5

1、生成25张表
2、eclipse安装activiti插件
3、初识Activiti流程设计工具
4、部署流程定义
5、删除流程定义、查询流程定义
6、查询部署对应的流程定义文件名称和输入流
7、启动流程实例、查询流程实例、删除流程实例
8、查询个人任务、完成(办理)个人任务
9、设置和获取流程变量
10、组任务操作（候选人组任务）
11、组任务操作（候选组组任务）
12、Activiti之个人任务分配
13、Activiti之多用户任务分配
14、Activiti之组任务分配
15、Activiti之排他网关
16、Activiti之并行网关

1、生成25张表 <--返回目录

　　参考：Activiti的25张表

　　Activiti的运行支持，必须要有Activiti的25张表，主要是在流程运行过程中，记录存储一些参与流程的用户主体，

组，以及流程定义的存储，流程执行时候的一些信息，以及流程的历史信息等（后面我们会详细介绍这些表作用）

　　方式1：可以直接使用下载的avtiviti中的建表sql来生成表：

　　方式2：也可以写程序，让 activiti 的 ProcessEngine 对象帮我们创建表：

　　我们先建一个Maven项目 ActivitiDemo1

　　pom.xml里加上 Activiti支持，以及mysql驱动包。

<dependencies>
     <dependency>
        <groupId>org.activiti</groupId>
        <artifactId>activiti-engine</artifactId>
        <version>5.19.0.2</version>
    </dependency>
    <dependency>
        <groupId>org.activiti</groupId>
        <artifactId>activiti-spring</artifactId>
        <version>5.19.0.2</version>
    </dependency>
    <dependency>
        <groupId>org.activiti</groupId>
        <artifactId>activiti-bpmn-model</artifactId>
        <version>5.19.0.2</version>
    </dependency>
     
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.38</version>
    </dependency>
</dependencies>

　　创建后的项目结构如下：

然后我们写一个测试方法，testCreateTable

并且在创建db_activiti数据库；

我们要先来获取流程引擎配置，然后来配置流程引擎，要配置驱动包，url，数据库用户名，密码；

还要设置schema，这里的schema要设置成update。这样可以自动更新

配置后，我们通过配置来获取流程引擎。创建实例的时候我们就可以自动生成需要的25张表。

public class ActivitiTest01 {
 
    /**
     * 生成25张Activiti表
     */
    @Test
    public void testCreateTable() {
        // 引擎配置
        ProcessEngineConfiguration pec=ProcessEngineConfiguration.createStandaloneProcessEngineConfiguration();
        pec.setJdbcDriver("com.mysql.jdbc.Driver");
        pec.setJdbcUrl("jdbc:mysql://localhost:3306/db_activiti");
        pec.setJdbcUsername("root");
        pec.setJdbcPassword("123456");
         
        /**
         * false 不能自动创建表
         * create-drop 先删除表再创建表
         * true 自动创建和更新表  
         */
        pec.setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);
         
        // 获取流程引擎对象
        ProcessEngine processEngine=pec.buildProcessEngine();
    }
 
}

　　运行测试类，运行完我们刷新数据库，即可看到25张表：

ACT_RE_*: 'RE'表示repository。 这个前缀的表包含了流程定义和流程静态资源 （图片，规则，等等）。

ACT_RU_*: 'RU'表示runtime。 这些运行时的表，包含流程实例，任务，变量，异步任务，等运行中的数据。 Activiti只在流程实例执行过程中保存这些数据，
　　　　　　 在流程结束时就会删除这些记录。 这样运行时表可以一直很小速度很快。

ACT_ID_*: 'ID'表示identity。 这些表包含身份信息，比如用户，组等等。

ACT_HI_*: 'HI'表示history。 这些表包含历史数据，比如历史流程实例， 变量，任务等等。

ACT_GE_*: 'GE'表示general。通用数据， 用于不同场景下，如存放资源文件。

这些表结构，还有一些辅助表。我们后续会详细解释，这里大家先大体了解即可；

　　方式3：引入Activiti配置文件activiti.cfg.xml

我们先在src/test/resources下创建一个xml文件名字是：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:mysql://localhost:3306/db_activiti" />
    <property name="jdbcDriver" value="com.mysql.jdbc.Driver" />
    <property name="jdbcUsername" value="root" />
    <property name="jdbcPassword" value="123456" />
 
    <property name="databaseSchemaUpdate" value="true" />
  </bean>

</beans>

　　接下来我们就是要通过代码来读取配置文件，然后获取工作流引擎实例：

@Test
public void testCreateTableWithXml(){
    // 引擎配置
    ProcessEngineConfiguration pec=ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cfg.xml");
    // 获取流程引擎对象
    ProcessEngine processEngine=pec.buildProcessEngine();
}

　　然后运行上面的测试类，我们会发现表自动生成了。

2、eclipse安装activiti插件 <--返回目录

　　参考：在Eclipse上安装Activiti插件

在Eclipse上安装Activiti插件，以后我们要用这个插件来画流程设计图；

这个插件名字是：Activiti BPMN 2.0 designer

具体使用，可以参考官方用户指南，地址：http://activiti.org/userguide/index.html#eclipseDesignerInstallation

The following installation instructions are verified on Eclipse Kepler and Indigo. Note that Eclipse Helios is NOT supported.

Go to Help → Install New Software. In the following panel, click on Add button and fill in the following fields:

*Name:*Activiti BPMN 2.0 designer
*Location:*

http://activiti.org/designer/update/

这里我们在自己的eclipse来装下这个牛逼轰轰的插件：

首先打开Eclipse(J2ee版本的，最好用新的版本，Maven啥的都支持，不要搞个老古董)

然后点击help -> Install new Software

然后点击 Add

我们在Name上写上 Activiti BPMN 2.0 designer

Location上写上 http://activiti.org/designer/update/ （插件更新地址）

然后点击 OK 按钮

勾选下，然后next:

继续next:

点下接受，然后 Finish

然后等待下载安装，可以去上个厕所，或者拉个屎。回来差不多就装好了。

中间可能会一些安全提示，点 OK 即可；

这里我们点Yes，重启下Eclipse；才会生效；

为了验证我们是否成功安装插件，我们点击File -> New -> Others

我们如果看到这个，说明就已经安装成功了。后面我们会具体讲这东西怎么用；

这里我们有个地方要设置下，点下Window - > Preferences

这里我先大体解释下。后面学习的时候会创建图表，以及生成一张图片。我们这里打上勾。

保存图表的时候，就创建图片。我们开发的时候必须这么配置；（后面大家会明白的，先这样设置）

OK到这里的话，插件已经安装和设置完毕了。

3、初识Activiti流程设计工具 <--返回目录

　　参考：初识Activiti流程设计工具

　　eclipse配置：bpmn流程设计完后，保存时自动生成png图片。

　　任何流程，都必须有一个开始事件节点和结束事件节点

4、部署流程定义 <--返回目录

/**
 * 部署流程定义 方式一：加载单个的流程定义文件 方式二：加载zip文件
 * 操作的数据表：act_re_deployment(部署表)、act_re_procdef(流程定义表)、act_ge_bytearray(二进制表)
 */
@Test
public void test1() throws FileNotFoundException {
    DeploymentBuilder deploymentBuilder = processEngine.getRepositoryService().createDeployment();

    // 方式一：加载单个的流程定义文件
    // deploymentBuilder.addClasspathResource("MyProcess1.bpmn");
    // deploymentBuilder.addClasspathResource("MyProcess1.png");
    // Deployment deployment = deploymentBuilder.deploy();

    //ZipInputStream zipInputStream = new ZipInputStream(this.getClass()
            //.getClassLoader().getResourceAsStream("process.zip"));
    
    // 方式二：加载zip文件
    ZipInputStream zipInputStream = new ZipInputStream(new FileInputStream(new File("d:\\MyProcess1.zip")));
    deploymentBuilder.addZipInputStream(zipInputStream );
    deploymentBuilder.deploy();
}

　　act_re_deployment(部署表)：部署id=1

　　act_re_procdef(流程定义表)：

　　流程定义的key：

　　act_ge_bytearray(二进制表)

　　act_ge_property(系统属性表)：next.dbid初始为1，下一次为2501，再下一次为5001。

　　next.dbid为全局的id，每次调用activiti api后，可能会操作多张表，插入多条记录。比如上面部署一个流程后，首先查询act_ge_property表的next.dbid=1。取到这个值后，当插入一条部署记录时主键取1；当向act_ge_bytearray(二进制表)插入两条记录时，主键取2、3；当向act_re_procdef(流程定义表)插入一条记录时，取编号4，主键=流程key:version:4。

5、删除流程定义、查询流程定义 <--返回目录

/**
 * 删除流程定义
 */
@Test
public void test2(){
    String deploymentId = "1";//部署id
    boolean cascade = true;//级联删除
    processEngine.getRepositoryService().deleteDeployment(deploymentId, cascade);
}

/**
 * 查询流程定义, 操作数据表：act_re_procdef
 */
@Test
public void test3(){
    ProcessDefinitionQuery query = processEngine.getRepositoryService().createProcessDefinitionQuery();
    query.processDefinitionKey("myProcess");//根据key过滤
    query.orderByProcessDefinitionVersion().asc();
    List<ProcessDefinition> list = query.listPage(0, 10);
    for (ProcessDefinition processDefinition : list) {
        System.out.println(processDefinition.getId());
    }
}

　　删除流程定义与部署流程定义涉及的表一样。

6、查询部署对应的流程定义文件名称和输入流 <--返回目录

/**
 * 查询部署对应的流程定义文件名称和输入流（通过部署id）
 */
@Test
public void test4() throws Exception{
    String deploymentId = "1";//部署id
    List<String> names = processEngine.getRepositoryService().getDeploymentResourceNames(deploymentId);
    System.out.println(names); // [MyProcess1/MyProcess1.bpmn, MyProcess1/MyProcess1.png]
    for (String name : names) {
        InputStream in = processEngine.getRepositoryService().getResourceAsStream(deploymentId, name);
        FileUtils.copyInputStreamToFile(in, new File("d:\\"+name));
        in.close();
    }
}

/**
 * 查询部署对应的流程定义输入流（通过流程定义id只能查询出流程定义的png文件）
 * @throws FileNotFoundException 
 */
@Test
public void test5() throws Exception{
    String processDefinitionId = "myProcess:1:4";//流程定义id
    InputStream pngStream = processEngine.getRepositoryService().getProcessDiagram(processDefinitionId);
    FileUtils.copyInputStreamToFile(pngStream, new File("d:\\abc.png"));
}

7、启动流程实例、查询流程实例、删除流程实例 <--返回目录

/**
 * 根据流程定义启动流程实例, 操作的数据表：act_ru_execution(流程实例表)、act_ru_task(任务表)
 * 方式一：根据流程定义id启动流程实例
 * 方式二：根据流程定义key启动流程实例（建议）-----可以根据当前最新版本的流程定义启动流程实例
 */
@Test
public void test6() throws Exception{
    //方式一：根据流程定义id启动流程实例
    //String processDefinitionId = "";//流程定义id
    //processEngine.getRuntimeService().startProcessInstanceById(processDefinitionId);
    
    String processDefinitionKey = "myProcess";
    //方式二：根据流程定义key启动流程实例
    ProcessInstance processInstance = processEngine.getRuntimeService().startProcessInstanceByKey(processDefinitionKey);
    System.out.println(processInstance.getId() + " " + processInstance.getProcessDefinitionId());
}

/**
 * 查询流程实例 
 */
@Test
public void test7() throws Exception{
    List<ProcessInstance> list = processEngine.getRuntimeService().createProcessInstanceQuery().list();
    for (ProcessInstance processInstance : list) {
        System.out.println("流程实例id: " + processInstance.getId());
    }
}

/**
 * 删除流程实例
 */
@Test
public void test8() throws Exception{
    String processInstanceId = "5001";
    String deleteReason = "不请假了";
    processEngine.getRuntimeService().deleteProcessInstance(processInstanceId , deleteReason );
}

8、查询个人任务、完成(办理)个人任务 <--返回目录

/**
 * 查询个人任务, 操作的数据表：act_ru_task(任务表)
 */
@Test
public void test9() throws Exception {
    // 任务查询对象
    TaskQuery query = processEngine.getTaskService().createTaskQuery();
    query.taskAssignee("张三");// 根据办理人过滤
    query.orderByTaskCreateTime().desc();
    List<Task> list = query.listPage(0, 10);
    for (Task task : list) {
        System.out.println("id = " + task.getId() + " name = " + task.getName() + " processInstanceId = "
                + task.getProcessInstanceId());
    }
}

/**
 * 办理个人任务,操作的数据表：act_ru_execution(流程实例表)、act_ru_task(任务表)
 */
@Test
public void test10() {
    String taskId = "602";//任务id
    processEngine.getTaskService().complete(taskId);
}

9、设置和获取流程变量 <--返回目录

public class VariableTest {
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

    /**
     * 部署流程定义
     */
    @Test
    public void test1() {
        DeploymentBuilder deploymentBuilder = processEngine
                .getRepositoryService().createDeployment();
        deploymentBuilder
                .addClasspathResource("com/itheima/activiti/variable/bxlc.bpmn");
        deploymentBuilder
                .addClasspathResource("com/itheima/activiti/variable/bxlc.png");
        deploymentBuilder.deploy();
    }

    /**
     * 启动流程实例时设置流程变量
     */
    @Test
    public void test2() {
        String processDefinitionKey = "bxlc";// 流程定义key
        Map<String, Object> variables = new HashMap<String, Object>();
        variables.put("key1", "value1");
        variables.put("loginUser", "小王");
        ProcessInstance pi = processEngine.getRuntimeService()
                .startProcessInstanceByKey(processDefinitionKey, variables);
        System.out.println(pi.getId());
    }
    
    /**
     * 办理任务时设置流程变量
     */
    @Test
    public void test3() {
        String taskId = "206";//任务id
        Map<String, Object> variables = new HashMap<>();
        variables.put("qjyy", "不想上班");
        variables.put("qjts", 365);
        processEngine.getTaskService().complete(taskId, variables);
    }
    
    /**
     * 使用RuntimeService的set方法设置流程变量
     */
    @Test
    public void test4() {
        String executionId = "201";//流程实例id
        Map<String, Object> variables = new HashMap<>();
        variables.put("审批意见", "以后注意");
        variables.put("user", new User(10,20,"北京"));
        processEngine.getRuntimeService().setVariables(executionId, variables);
        //processEngine.getRuntimeService().setVariable(executionId, variableName, value);
    }
    
    /**
     * 使用TaskService的set方法设置流程变量
     */
    @Test
    public void test5() {
        String taskId = "304";
        String key = "审批意见";
        Object value = "不批";
        processEngine.getTaskService().setVariable(taskId , key, value);
    }
    
    
    /////////////////////////////////////////////////////////////////
    /**
     * 使用RuntimeService的get方法获取流程变量
     */
    @Test
    public void test6() {
        String executionId = "201";
        Map<String, Object> variables = processEngine.getRuntimeService().getVariables(executionId);
        Set<String> keySet = variables.keySet();
        for (String key : keySet) {
            Object value = variables.get(key);
            System.out.println(key + " = " + value);
        }
    }
    
    /**
     * 使用TaskService的get方法获取流程变量
     */
    @Test
    public void test7() {
        String taskId = "304";
        Object value = processEngine.getTaskService().getVariable(taskId , "user");
        System.out.println(value);
    }
}

10、组任务操作（候选人组任务） <--返回目录

/**
 * 查询组任务
 */
@Test
public void test4() {
    TaskQuery query = processEngine.getTaskService().createTaskQuery();
    String candidateUser = "财务三";
    query.taskCandidateUser(candidateUser);//使用候选人过滤
    List<Task> list = query.list();
    for (Task task : list) {
        System.out.println(task.getId());
    }
}

/**
 * 拾取组任务,将组任务变为个人任务
 */
@Test
public void test5() {
    String taskId = "1102";
    processEngine.getTaskService().claim(taskId , "财务二");
}

11、组任务操作（候选组组任务） <--返回目录

/**
 * 创建组
 */
@Test
public void test2() {
    Group group = new GroupEntity();
    group.setId("财务组");
    group.setName("财务组");
    processEngine.getIdentityService().saveGroup(group );
}

/**
 * 创建用户
 */
@Test
public void test3() {
    User user = new UserEntity();
    user.setId("2");
    processEngine.getIdentityService().saveUser(user);
}

/**
 * 建立用户和组的关系
 */
@Test
public void test4() {
    processEngine.getIdentityService().createMembership("2", "财务组");
}

/**
 * 查询组任务
 */
@Test
public void test7() {
    TaskQuery query = processEngine.getTaskService().createTaskQuery();
    //String candidateUser = "2";
    //query.taskCandidateUser(candidateUser);//使用候选人过滤
    query.taskCandidateGroup("财务组");
    List<Task> list = query.list();
    for (Task task : list) {
        System.out.println(task.getId());
    }
}

/**
 * 拾取组任务,将组任务变为个人任务
 */
@Test
public void test8() {
    String taskId = "1902";
    processEngine.getTaskService().claim(taskId , "1");
}

12、Activiti之个人任务分配 <--返回目录

　　参考：Activiti之个人任务分配

13、Activiti之多用户任务分配 <--返回目录

　　参考：Activiti之多用户任务分配

14、Activiti之组任务分配 <--返回目录

　　参考：Activiti之组任务分配

用户表：

角色表：

用户和角色关系表：

15、Activiti之排他网关 <--返回目录

　　参考：Activiti之排他网关

所谓排他网关顾名思义执行到该网关，根据条件只能走一条执行线路；

在右侧 palette中的Gateway 有个 ExclusiveGateway 即为默认网关；

我们绘制新的流程定义图标：

这里我们规定根据请假天数，来具体让谁来审批，

请假天数小于3天，班长审批；

请假天数小于7天，大于等于3天，班主任审批；

请假天数大于等于7天，校长审批；

这里我们依然用表达式来实现；

班长审批连线表达式；

班主任审批连线表达式；

至于校长审批，我们不需要再设置表达式了，排他网关可以指定默认的执行线路；

我们找到校长审批的id；

是flow11；

然后我们选中排他网关，设置默认执行的线路；

代码：

package com.java1234.gateway;
 
 
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.repository.Deployment;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.junit.Test;
 
public class ExclusiveGatewayTest {
 
    /**
     * 获取默认流程引擎实例，会自动读取activiti.cfg.xml文件
     */
    private ProcessEngine processEngine=ProcessEngines.getDefaultProcessEngine();
     
    /**
     * 部署流程定义
     */
    @Test
    public void deploy(){
        Deployment deployment=processEngine.getRepositoryService() // 获取部署相关Service
                .createDeployment() // 创建部署
                .addClasspathResource("diagrams/StudentLeaveProcess3.bpmn") // 加载资源文件
                .addClasspathResource("diagrams/StudentLeaveProcess3.png") // 加载资源文件
                .name("学生请假流程3") // 流程名称
                .deploy(); // 部署
        System.out.println("流程部署ID:"+deployment.getId()); 
        System.out.println("流程部署Name:"+deployment.getName());
    }
     
    /**
     * 启动流程实例
     */
    @Test
    public void start(){
        ProcessInstance pi=processEngine.getRuntimeService() // 运行时Service
            .startProcessInstanceByKey("studentLevaeProcess3"); // 流程定义表的KEY字段值
        System.out.println("流程实例ID:"+pi.getId());
        System.out.println("流程定义ID:"+pi.getProcessDefinitionId()); 
    }
     
     
    /**
     * 查看任务
     */
    @Test
    public void findTask(){
        List<Task> taskList=processEngine.getTaskService() // 任务相关Service
            .createTaskQuery() // 创建任务查询
            .taskAssignee("赵六") // 指定某个人
            .list();
        for(Task task:taskList){
            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());
        }
    }
     
     
    /**
     * 完成任务
     */
    @Test
    public void completeTask(){
        processEngine.getTaskService() // 任务相关Service
            .complete("237504");
    }
     
    @Test
    public void completeTask2(){
 
        Map<String, Object> variables=new HashMap<String,Object>();
        variables.put("days", 8);
        processEngine.getTaskService() // 任务相关Service
            .complete("235004", variables); //完成任务的时候，设置流程变量
    }
     
 
}

16、Activiti之并行网关 <--返回目录

　　参考：Activiti之并行网关

所谓排他网关顾名思义执行到该网关，会有多条线路同时并行执行，当都执行完才继续执行后面的；

我们先上图：

右侧 ParallelGateway就是并行网关；

我们修改后的业务是学生请假审批提交，班长和班主任审批，当他们都审批完才最终让校长审批。

测试代码：

package com.java1234.gateway;
 
import java.util.List;
 
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.repository.Deployment;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.junit.Test;
 
public class ParallelGatewayTest {
 
    /**
     * 获取默认流程引擎实例，会自动读取activiti.cfg.xml文件
     */
    private ProcessEngine processEngine=ProcessEngines.getDefaultProcessEngine();
     
    /**
     * 部署流程定义
     */
    @Test
    public void deploy(){
        Deployment deployment=processEngine.getRepositoryService() // 获取部署相关Service
                .createDeployment() // 创建部署
                .addClasspathResource("diagrams/StudentLeaveProcess4.bpmn") // 加载资源文件
                .addClasspathResource("diagrams/StudentLeaveProcess4.png") // 加载资源文件
                .name("学生请假流程4") // 流程名称
                .deploy(); // 部署
        System.out.println("流程部署ID:"+deployment.getId()); 
        System.out.println("流程部署Name:"+deployment.getName());
    }
     
    /**
     * 启动流程实例
     */
    @Test
    public void start(){
        ProcessInstance pi=processEngine.getRuntimeService() // 运行时Service
            .startProcessInstanceByKey("studentLevaeProcess4"); // 流程定义表的KEY字段值
        System.out.println("流程实例ID:"+pi.getId());
        System.out.println("流程定义ID:"+pi.getProcessDefinitionId()); 
    }
     
     
    /**
     * 查看任务
     */
    @Test
    public void findTask(){
        List<Task> taskList=processEngine.getTaskService() // 任务相关Service
            .createTaskQuery() // 创建任务查询
            .taskAssignee("张三") // 指定某个人
            .list();
        for(Task task:taskList){
            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());
        }
    }
     
    /**
     * 完成任务
     */
    @Test
    public void completeTask(){
        processEngine.getTaskService() // 任务相关Service
            .complete("265003");
    }
     
}

注：如果是使用自己实现的用户表和角色表，需要将自己用户表和角色表（包括用户角色关系表）同步到activiti的act_id_user等表中。

其他参考：

　　1) http://blog.java1234.com/index.html?page=3&typeId=13&

　　2) 一头扎进activiti视频教程 http://www.java1234.com/a/yuanchuang/activiti5/

posted on 2021-02-03 22:43 wenbin_ouyang 阅读(475) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

木心

导航

公告