Activiti基础入门

Activiti项目搭建

引用依赖项

		<activiti.version>7.0.0.Beta1</activiti.version>
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-engine</artifactId>
            <version>${activiti.version}</version>
        </dependency>
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-spring</artifactId>
            <version>${activiti.version}</version>
        </dependency>
        <!-- bpmn 模型处理 -->
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-bpmn-model</artifactId>
            <version>${activiti.version}</version>
        </dependency>
        <!-- bpmn 转换 -->
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-bpmn-converter</artifactId>
            <version>${activiti.version}</version>
        </dependency>
        <!-- bpmn json数据转换 -->
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-json-converter</artifactId>
            <version>${activiti.version}</version>
        </dependency>
        <!-- bpmn 布局 -->
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-bpmn-layout</artifactId>
            <version>${activiti.version}</version>
        </dependency>
        <!-- activiti 云支持 -->
        <dependency>
            <groupId>org.activiti.cloud</groupId>
            <artifactId>activiti-cloud-services-api</artifactId>
            <version>${activiti.version}</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>1.4</version>
        </dependency>

Activiti服务初始化

@Configuration
public class ActivitiConfiguration {
    
    

    @Autowired
    @Qualifier("dataSource")
    private BasicDataSource DataSource;

    @Autowired
    private PlatformTransactionManager platformTransactionManager;


    /**
     * 注册 activiti的配置信息
     */
    @Bean("processEngineConfiguration")
    public SpringProcessEngineConfiguration getProcessEngineConfiguration(){
    
    
        SpringProcessEngineConfiguration configuration
                = new SpringProcessEngineConfiguration();
        configuration.setDataSource(DataSource);       // 添加数据源
        configuration.setTransactionManager(platformTransactionManager);    // 添加事务
        configuration.setDatabaseSchemaUpdate("true");  // 如果有表则不创建
        configuration.setDbHistoryUsed(true);   // 允许查看历史信息
        configuration.buildProcessEngine();  //执行创建25张表，如果已经创建就不再创建了
        // 自动部署 bpmn文件
        Resource[] resources = null;
        try {
    
    
            resources= new PathMatchingResourcePatternResolver().getResources("classpath*:bpmn/*.bpmn20.xml");
        } catch (IOException e) {
    
    
            e.printStackTrace();
        }
        configuration.setDeploymentResources(resources);
        return configuration;
    }


    /**
     * 注册 ProcessEngineFactoryBean
     */
    @Bean
    public ProcessEngineFactoryBean processEngine(){
    
    
        ProcessEngineFactoryBean factoryBean = new ProcessEngineFactoryBean();
        factoryBean.setProcessEngineConfiguration(getProcessEngineConfiguration());

        return factoryBean;
    }

    /**
     * 注册 RepositoryService
     */
    @Bean
    public RepositoryService repositoryService() throws Exception{
    
    
        return processEngine().getObject().getRepositoryService();
    }

    /**
     * 注册 RuntimeService
     */
    @Bean
    public RuntimeService runtimeService() throws Exception{
    
    
        return processEngine().getObject().getRuntimeService();
    }

    /**
     * 注册 TaskService
     */
    @Bean
    public TaskService taskService() throws Exception{
    
    
        return processEngine().getObject().getTaskService();
    }

    /**
     * 注册 HistoryService
     */
    @Bean
    public HistoryService historyService() throws Exception{
    
    
        return processEngine().getObject().getHistoryService();
    }
}

数据库配置

@Configuration
public class DataSourceConfiguration {
    
    

    @Bean("dataSource")
    public BasicDataSource getDruidDataSource(
            @Value("${spring.datasource.driver-class-name}")
                    String driverClassName, // 数据库驱动程序
            @Value("${spring.datasource.url}")
                    String url, // 数据库连接地址
            @Value("${spring.datasource.username}")
                    String username, // 数据库的用户名
            @Value("${spring.datasource.password}")
                    String password, // 数据库的用户名
            @Value("${spring.datasource.tomcat.min-idle}")
                    int minIdle, // 最小维持连接数
            @Value("${spring.datasource.tomcat.max-active}")
                    int maxActive // 最大连接数
    ) {
    
    
        BasicDataSource dataSource = new BasicDataSource(); // 实例化DataSource子类对象
        dataSource.setDriverClassName(driverClassName); // 数据库驱动程序
        dataSource.setUrl(url); // 数据库的连接地址
        dataSource.setUsername(username); // 数据库用户名
        dataSource.setPassword(password); // 数据库密码
        dataSource.setMinIdle(minIdle); // 最小维持的连接数量
        dataSource.setMaxActive(maxActive); // 最大的连接数量
        return dataSource;
    }

}

配置文件

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql:///activiti_dev?nullCatalogMeansCurrent=true
    username: root
    password: 123456
    tomcat:
      max-active: 3
      min-idle: 1

测试demo

这是使用springboot项目创建的测试用例

import org.activiti.engine.RepositoryService;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.activiti.engine.impl.persistence.entity.HistoricFormPropertyEntity;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

@SpringBootTest
class BpmDemoApplicationTests {
    
    
    @Autowired
    private RuntimeService runtimeService;
    @Autowired
    private TaskService taskService;
    @Autowired
    private RepositoryService repositoryService;
    @Test
    void contextLoads() {
    
    
    }
    /**
     * @description: 创建审批
     * @author: gepengjun
     * @date: 2023/9/3 17:31
     * @param: []
     * @return: void
     **/
    @Test
    public void testCreateProcessInstance(){
    
    
        ProcessInstance test1 = runtimeService.startProcessInstanceByKey("test1");
        System.out.println("流程示例id："+test1.getId());

    }

    /**
     * @description: 完成任务
     * @author: gepengjun
     * @date: 2023/9/3 17:31
     * @param:
     * @return: void
     **/
    @Test
    public void testComplete(){
    
    
        taskService.setVariable("37505","variable",true);
        taskService.complete("37505");
    }


    /**
     * @description: 设置流程实例变量
     * @author: gepengjun
     * @date: 2023/9/3 18:34
     * @param: []
     * @return: void
     **/
    @Test
    public void testProcessInstanceVariable(){
    
    
        runtimeService.setVariable("12506","taskTest","任务完成没有");
    }

    /**
     * @description: 获取流程实例变量
     * @author: gepengjun
     * @date: 2023/9/3 18:34
     * @param: []
     * @return: void
     **/
    @Test
    public void testGetProcessInstanceVariable(){
    
    
        Object taskTest = runtimeService.getVariable("30001", "taskTest");
        System.out.println("这是流程实例变量："+taskTest.toString());
    }

    /**
     * @description: 在使用task服务获取流程实例变量
     * @author: gepengjun
     * @date: 2023/9/3 18:34
     * @param: []
     * @return: void
     **/
    @Test
    public void testTaskGetProcessInstanceVariable(){
    
    
        Object taskTest = taskService.getVariable("30005", "taskTest");
        System.out.println("使用Task服务获取流程实例变量："+taskTest.toString());
    }

    /**
     * @description: 查询对应节点任务
     * @author: gepengjun
     * @date: 2023/9/3 17:31
     * @param: []
     * @return: void
     **/
    @Test
    public void testByUserName(){
    
    
        //根据节点名称获取指定流程实例的任务
        //List<Task> tasks = taskService.createTaskQuery().processInstanceId("37501").taskName("科长").list();
        //获取所有节点名称为“科长”的任务
        List<Task> tasks = taskService.createTaskQuery().taskName("高经理").list();
        for (Task task : tasks) {
    
    
            System.out.println("任务名称："+task.getName());
            System.out.println("任务ID："+task.getId());
            System.out.println("_______________________________");
        }

    }
    /**
     * @description: 删除流程模板
     * @author: gepengjun
     * @date: 2023/9/3 18:35
     * @param: []
     * @return: void
     **/
    @Test
    public void testRepositoryService(){
    
    
        repositoryService.deleteDeployment("1");
    }

}

Activiti功能服务

RepositoryService：

RepositoryService 是 Activiti 中的一个服务接口，用于管理流程定义和部署的操作。通过 RepositoryService，可以执行以下一些常见的操作：

1. 部署流程定义：使用 createDeployment() 方法创建一个新的部署对象，并通过 addInputStream()、addClasspathResource() 等方法添加流程定义的资源文件，在最后使用 deploy() 方法将流程定义部署到引擎中进行使用。

2. 查询流程定义：使用 createProcessDefinitionQuery() 方法创建一个查询对象，然后可以根据不同的条件进行过滤和排序，例如根据流程定义的名称、版本号等进行查询。

3. 获取流程定义资源：使用 getResourceAsStream() 方法可以获取流程定义的资源文件，例如获取流程图、流程定义的 XML 文件等。

4. 删除流程定义：使用 deleteDeployment() 方法可以删除已部署的流程定义及其相关资源。

RuntimeService：

RuntimeService 是 Activiti 中的一个服务接口，用于管理流程实例的操作。通过 RuntimeService，可以执行以下一些常见的操作：

1. 启动流程实例：使用 startProcessInstanceByKey() 方法根据流程定义的键启动一个新的流程实例，或者使用 startProcessInstanceById() 方法根据流程定义的ID启动流程实例。

2. 查询流程实例：使用 createProcessInstanceQuery() 方法创建一个查询对象，然后可以根据不同的条件进行过滤和排序，例如根据流程实例的ID、流程定义的Key等进行查询。

3. 暂停和恢复流程实例：使用 suspendProcessInstanceById() 方法暂停指定ID的流程实例，使用 activateProcessInstanceById() 方法恢复暂停的流程实例。

4. 查询任务：使用 createTaskQuery() 方法创建一个查询对象，然后可以根据不同的条件进行过滤和排序，例如根据任务的ID、任务的负责人等进行查询。

5. 设置和获取流程实例变量：使用 setVariable() 方法设置流程实例的变量，使用 getVariable() 方法获取流程实例的变量。

TaskService：

TaskService 是 Activiti 中的一个服务接口，用于管理任务的操作。通过 TaskService，您可以执行以下一些常见的任务相关的操作：

1. 查询任务：使用 createTaskQuery() 方法创建一个查询对象，然后可以根据不同的条件进行过滤和排序，例如根据任务的ID、负责人、所属流程实例等进行查询。

2. 完成任务：使用 complete() 方法完成指定ID的任务，可以同时设置任务的执行人、变量等信息。

3. 指派任务：使用 setAssignee() 方法将任务指派给指定的用户或组。

4. 委派任务：使用 delegateTask() 方法将任务委派给其他人处理。

5. 签收任务：使用 claim() 方法将任务签收，将当前用户设置为任务的负责人。

6. 设置和获取任务变量：使用 setVariable() 方法设置任务的变量，使用 getVariable() 方法获取任务的变量。

7. 创建附件和评论：使用 createAttachment() 方法创建任务的附件，使用 addComment() 方法添加任务的评论。

HistoryService：

HistoryService 是 Activiti 中的一个服务接口，用于管理历史数据的操作。通过 HistoryService，您可以执行以下一些常见的历史数据相关的操作：

1. 查询历史流程实例：使用 createHistoricProcessInstanceQuery() 方法创建一个查询对象，然后可以根据不同的条件进行过滤和排序，例如根据流程实例的ID、流程定义的Key等进行查询。

2. 查询历史任务：使用 createHistoricTaskInstanceQuery() 方法创建一个查询对象，然后可以根据不同的条件进行过滤和排序，例如根据任务的ID、所属流程实例、负责人等进行查询。

3. 查询历史活动：使用 createHistoricActivityInstanceQuery() 方法创建一个查询对象，然后可以根据不同的条件进行过滤和排序，例如根据活动的ID、所属流程实例、活动类型等进行查询。

4. 查询历史变量：使用 createHistoricVariableInstanceQuery() 方法创建一个查询对象，然后可以根据不同的条件进行过滤和排序，例如根据变量的名称、所属流程实例等进行查询。

5. 查询历史表单数据：使用 createHistoricFormDataQuery() 方法创建一个查询对象，然后可以根据不同的条件进行过滤和排序，例如根据表单的ID、所属流程实例等进行查询。

ManagementService：

ManagementService 是 Activiti 中的一个服务接口，用于管理引擎相关的操作。通过 ManagementService，您可以执行以下一些常见的引擎管理操作：

1. 执行作业：使用 executeJob() 方法手动触发执行作业，例如定时任务、异步任务等。

2. 暂停和恢复作业：使用 suspendJobById() 方法暂停指定ID的作业，使用 activateJobById() 方法恢复暂停的作业。

3. 查询作业：使用 createJobQuery() 方法创建一个查询对象，然后可以根据不同的条件进行过滤和排序，例如根据作业的ID、作业的状态、作业的类型等进行查询。

4. 查询引擎表：使用 getTableName() 方法获取指定实体类对应的数据库表名，使用 getTableCount() 方法获取指定表的记录数量。

5. 强制执行数据库操作：使用 executeCommand() 方法执行自定义的数据库操作命令，例如 SQL 查询、SQL 更新等。

6. 获取引擎配置信息：使用 getProcessEngineConfiguration() 方法获取当前引擎的配置信息，包括数据库连接信息、流程定义解析器等。

DynamicBpmnService：

DynamicBpmnService 是 Activiti 中的一个服务接口，用于动态修改流程定义和流程实例的相关内容。通过 DynamicBpmnService，您可以执行以下一些常见的动态流程操作：

1. 动态修改流程定义：使用 changeDeploymentProcessDefinitionKey() 方法修改指定部署ID下流程定义的Key。

2. 动态修改流程实例：使用 moveActivityIdTo() 方法将当前活动节点移动到指定的目标节点。

3. 动态添加用户任务节点：使用 addUserTask() 方法在流程定义中动态添加用户任务节点。

4. 动态删除节点：使用 deleteActivity() 方法删除指定节点及其关联的全部流转信息。

5. 动态设置节点属性：使用 setActivityProperties() 方法设置指定节点的属性，如节点名称、节点描述等。

6. 动态设置流程变量：使用 setProcessInstanceVariable() 方法设置流程实例的变量值。

Activiti表分类

在 Activiti 中，表用于存储与流程相关的数据和元数据。Activiti 从逻辑上将其分为五个类别。

1. ACT_RE_*：包含“RE”表示 Repository，这些表存储了所有与 Activiti 流程定义和流程资源相关的数据和元数据。例如，这些表包括：

MN 流程

• 定义的数据。
• ACT_RE_DEPLOYMENT：保存 BPMN 文件和流程图等资源文件的数据。

2. ACT_RU_*：包含“RU”表示 Runtime，这些表存储了流程运行期间产生的运行时数据。例如，这些表包括：

   • ACT_RU_TASK：保存当前待处理任务的数据。
   • ACT_RU_EXECUTION：保存流程实例和执行数据。

3. ACT_ID_*：包含“ID”表示 Identity，这些表存储了用户、组和权限等身份验证相关的数据。例如，这些表包括：

   • ACT_ID_USER：保存用户的数据。
   • ACT_ID_GROUP：保存用户组的数据。

4. ACT_HI_*：包含“HI”表示 History，这些表存储了流程实例的历史记录和统计数据。例如，这些表包括：

   • ACT_HI_PROCINST：保存流程实例的历史数据。
   • ACT_HI_TASKINST：保存任务实例的历史数据。

5. ACT_GE_*：包含“GE”表示 Generic，这些表存储 Activiti 应用程序和一般工具使用的各种配置数据。例如，这些表包括：

   • ACT_GE_PROPERTY：保存 Activiti 数据和配置的属性数据。