Activiti教程：入门与实践指南

Activiti教程介绍了这个轻量级的工作流引擎的基本概念和功能，包括其安装、配置、流程设计和API编程等内容。文章详细讲解了Activiti的应用场景和实战案例，帮助读者全面了解如何使用Activiti处理复杂的业务流程，实现企业流程自动化和业务流程管理。

Activiti是一个轻量级的、开源的工作流引擎，它基于Spring框架，支持BPMN 2.0标准。Activiti主要应用于企业流程自动化和业务流程管理，能够帮助企业实现业务流程的自动化处理和优化。

Activiti是什么

Activiti是基于BPMN 2.0的轻量级工作流引擎，它提供了API和工具，用于设计、执行、管理和监控业务流程。其核心功能包括流程定义、流程实例的启动、任务的处理和流程的监控等。相比其他复杂的业务流程引擎，Activiti具有简单易用的特点，同时提供了强大的功能支持。

Activiti的主要特点

1. 轻量级：Activiti在设计和实现上保持简洁，具有高效执行流程的能力。
2. 开源：Activiti是开源的，开源许可证是Apache License 2.0，这意味着你可以自由地使用它，甚至修改其代码。
3. BPMN 2.0支持：Activiti支持BPMN 2.0标准，这是一种用于规范业务流程的国际标准。
4. 易于集成：Activiti可以轻松集成到现有的应用程序中，支持多种编程语言，如Java、Spring等。
5. 易于配置：Activiti的配置十分简单，可以快速上手使用。
6. 执行速度快：Activiti在处理流程时速度很快，而且占用的内存资源较少。
7. 灵活性和可扩展性：Activiti具有高度的灵活性，可以根据需要进行扩展或修改。
8. 强大的查询能力：Activiti提供强大的查询API，可以通过多种方式查询流程实例和任务。

Activiti的应用场景

Activiti适用于以下场景：

1. 复杂的业务流程管理：处理复杂的业务流程，如订单处理、审批流程等。
2. 流程自动化：实现业务流程的自动化，提高工作效率。
3. 流程监控与优化：监控业务流程的执行情况，发现流程中的瓶颈并进行优化。
4. 系统集成：将业务流程集成到现有的IT系统中，简化系统架构。
5. 任务分配与协作：在团队中分配任务，并促进成员之间的协作。

使用场景示例

假设一家公司需要处理大量的订单，从接收订单到发货，涉及多个步骤，如验证订单、支付处理、库存检查等。使用Activiti可以将这些步骤定义为一个流程，自动处理订单的整个生命周期。

准备开发环境

在开始使用Activiti之前，需要准备一个Java开发环境。以下步骤将指导你如何搭建Java开发环境：

1. 安装JDK：确保安装了Java Development Kit (JDK)。推荐使用最新版本的JDK 11或更高版本。
2. 配置环境变量：在操作系统的环境变量中设置JAVA_HOME和PATH。
3. 安装IDE：选择一个Java开发IDE，如Eclipse、IntelliJ IDEA或Spring Tool Suite。
4. 安装Maven：Activiti项目通常使用Maven进行构建管理。确保安装了Maven 3.6或更高版本。

安装Activiti

安装Activiti的步骤如下：

1. 下载Activiti：从Activiti官网下载最新版本的Activiti。也可以通过Maven仓库获取Activiti依赖。

2. 创建Maven项目：在IDE中创建一个新的Maven项目，并在pom.xml文件中添加Activiti依赖。

<dependencies>
    <dependency>
        <groupId>org.activiti</groupId>
        <artifactId>activiti-engine</artifactId>
        <version>6.0.0</version>
    </dependency>
    <dependency>
        <groupId>org.activiti</groupId>
        <artifactId>activiti-spring</artifactId>
        <version>6.0.0</version>
    </dependency>
</dependencies>

1. 初始化Activiti：创建一个Spring配置文件，初始化Activiti引擎。

<bean id="processEngineConfiguration" class="org.activiti.spring.SpringProcessEngineConfiguration">
    <property name="jobExecutorActivate" value="false"/>
    <property name="databaseSchemaUpdate" value="true"/>
    <property name="transactionManager" ref="transactionManager"/>
    <property name="dataSource" ref="dataSource"/>
</bean>

<bean id="processEngine" class="org.activiti.spring.ProcessEngineFactoryBean">
    <property name="processEngineConfiguration" ref="processEngineConfiguration"/>
</bean>

配置数据库

Activiti默认使用H2内存数据库，但通常会将其配置为使用MySQL或PostgreSQL等持久化数据库。以下是配置MySQL数据库的步骤：

1. 安装MySQL：确保本地或云服务器上安装了MySQL服务器。
2. 创建数据库：在MySQL中创建一个新的数据库，例如activiti。
3. 配置数据源：在Spring配置文件中配置数据源以连接到MySQL数据库。

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/activiti"/>
    <property name="username" value="root"/>
    <property name="password" value="password"/>
</bean>

1. 初始化数据库：运行Activiti提供的数据库脚本以创建必要的表结构。

-- Run this SQL script to create the Activiti database tables in MySQL
CREATE DATABASE activiti;
USE activiti;

CREATE TABLE ACT_RE_DEPLOYMENT (
    ID_ VARCHAR(64) NOT NULL,
    NAME_ VARCHAR(255),
    CATEGORY_ VARCHAR(255),
    TENANT_ID_ VARCHAR(255) DEFAULT '',
    DEPLOY_TIME_ datetime,
    PRIMARY KEY (ID_)
);

-- Additional tables...

使用BPMN 2.0设计流程模型

BPMN (Business Process Model and Notation) 是一种图形化建模语言，用于定义业务流程。Activiti支持BPMN 2.0标准，这意味着你可以使用BPMN工具绘制流程图，并将其转换为Activiti可以理解和执行的XML格式。

在Activiti Designer中创建流程图

Activiti提供了一个名为Activiti Designer的工具，用于创建和编辑BPMN 2.0流程图。以下是如何使用Activiti Designer创建一个简单的请假流程：

1. 下载并安装Activiti Designer：从Activiti Designer官网下载并安装Activiti Designer。
2. 创建新流程：在Activiti Designer中创建一个新的BPMN 2.0流程。
3. 绘制流程图：从工具箱中拖动流程元素（如开始事件、任务、用户任务、结束事件等）到画布上，并用连线连接这些元素，形成一个完整的流程。

创建请假流程图的示例

假设你需要创建一个简单的请假流程，如下所示：

• 用户发起请假申请
• 部门经理审批
• HR审核
• 请假申请结束

以下是创建请假流程的步骤：

1. 开始事件：表示流程的开始。
2. 用户任务：用户发起请假申请。
3. 用户任务：部门经理审批。
4. 用户任务：HR审核。
5. 结束事件：流程结束。

在Activiti Designer中绘制流程图后，导出为XML文件，如下所示：

<process id="leaveProcess" name="Leave Process" isExecutable="true">
    <startEvent id="startEvent" />
    <sequenceFlow id="flow1" sourceRef="startEvent" targetRef="applyLeaveTask" />
    <userTask id="applyLeaveTask" name="Apply for Leave" />
    <sequenceFlow id="flow2" sourceRef="applyLeaveTask" targetRef="approveTask" />
    <userTask id="approveTask" name="Approve Leave" />
    <sequenceFlow id="flow3" sourceRef="approveTask" targetRef="hrReviewTask" />
    <userTask id="hrReviewTask" name="HR Review" />
    <sequenceFlow id="flow4" sourceRef="hrReviewTask" targetRef="endEvent" />
    <endEvent id="endEvent" />
</process>

了解常用的工作流元素

以下是常用的工作流元素及其作用：

• 开始事件 (startEvent)：表示流程的开始。
• 结束事件 (endEvent)：表示流程的结束。
• 用户任务 (userTask)：需要用户执行的任务。
• 服务任务 (serviceTask)：执行业务逻辑的任务。
• 并行网关 (parallelGateway)：用于分支流程。
• 排他网关 (exclusiveGateway)：用于决策流程。
• 包含子流程 (subProcess)：包含一个独立的子流程。
• 事件子流程 (eventSubProcess)：由特定事件触发的子流程。
• 定时事件 (timerEvent)：定时触发的事件，如定时任务。

创建与部署流程定义

在Activiti中，流程定义可以由BPMN文件描述，并从文件中加载或从内存中创建。以下是如何部署一个流程定义的示例代码：

1. 创建流程定义文件：如前所述，创建一个BPMN文件。
2. 部署流程定义：使用Activiti API加载并部署流程定义。

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.RepositoryService;
import org.activiti.engine.repository.Deployment;

public class ActivitiExample {
    public static void main(String[] args) {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RepositoryService repositoryService = processEngine.getRepositoryService();

        Deployment deployment = repositoryService.createDeployment()
            .addClasspathResource("leaveProcess.bpmn20.xml")
            .deploy();

        System.out.println("Deployment ID: " + deployment.getId());
    }
}

启动流程实例

启动流程实例是指创建一个新的流程实例并开始执行流程。以下是如何启动流程实例的示例代码：

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.ProcessEngineConfiguration;

public class ActivitiExample {
    public static void main(String[] args) {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RuntimeService runtimeService = processEngine.getRuntimeService();

        String processDefinitionId = "leaveProcess:1:2501";
        String businessKey = "leaveRequest123";

        String processInstanceId = runtimeService.startProcessInstanceById(processDefinitionId, businessKey).getId();

        System.out.println("Process Instance ID: " + processInstanceId);
    }
}

处理任务与事件

在流程执行过程中，可能会遇到任务和事件。以下是如何处理任务和事件的示例代码：

处理任务

获取并完成任务。

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.TaskService;
import org.activiti.engine.task.Task;
import org.activiti.engine.task.TaskQuery;

public class ActivitiExample {
    public static void main(String[] args) {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();

        TaskQuery taskQuery = taskService.createTaskQuery()
            .taskAssignee("john");

        List<Task> tasks = taskQuery.list();

        for (Task task : tasks) {
            System.out.println("Task ID: " + task.getId());
            System.out.println("Task Name: " + task.getName());

            taskService.complete(task.getId());
        }
    }
}

处理事件

事件可以在流程执行中触发，例如定时事件或信号事件。

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.ProcessEngineConfiguration;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.activiti.engine.task.TaskQuery;
import org.activiti.engine.runtime.Execution;

public class ActivitiExample {
    public static void main(String[] args) {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        RuntimeService runtimeService = processEngine.getRuntimeService();

        String processInstanceId = "yourProcessInstanceId";
        Execution execution = runtimeService.createExecutionQuery()
            .processInstanceId(processInstanceId)
            .singleResult();

        runtimeService.signalEventReceived("myCustomSignal", execution);

        TaskQuery taskQuery = taskService.createTaskQuery()
            .processInstanceId(processInstanceId);

        List<Task> tasks = taskQuery.list();

        for (Task task : tasks) {
            System.out.println("Task ID: " + task.getId());
            System.out.println("Task Name: " + task.getName());

            taskService.complete(task.getId());
        }
    }
}

请假流程实战

在这一部分，我们将实现一个完整的请假流程案例，包括流程模型的设计、部署、启动和任务处理。

请假流程模型设计

创建一个简单的请假流程模型，包括以下步骤：

1. 用户发起请假申请
2. 部门经理审批
3. HR审核
4. **请假申请结束

请假流程部署

使用Activiti API将请假流程部署到Activiti引擎中。

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.RepositoryService;
import org.activiti.engine.repository.Deployment;

public class LeaveProcessExample {
    public static void main(String[] args) {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RepositoryService repositoryService = processEngine.getRepositoryService();

        Deployment deployment = repositoryService.createDeployment()
            .addClasspathResource("leaveProcess.bpmn20.xml")
            .deploy();

        System.out.println("Deployment ID: " + deployment.getId());
    }
}

请假流程启动

启动一个新的请假流程实例。

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.ProcessEngineConfiguration;

public class LeaveProcessExample {
    public static void main(String[] args) {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RuntimeService runtimeService = processEngine.getRuntimeService();

        String processDefinitionId = "leaveProcess:1:2501";
        String businessKey = "leaveRequest123";

        String processInstanceId = runtimeService.startProcessInstanceById(processDefinitionId, businessKey).getId();

        System.out.println("Process Instance ID: " + processInstanceId);
    }
}

任务处理

部门经理和HR分别处理审批任务。

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.TaskService;
import org.activiti.engine.task.Task;
import org.activiti.engine.task.TaskQuery;

public class LeaveProcessExample {
    public static void main(String[] args) {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();

        TaskQuery taskQuery = taskService.createTaskQuery()
            .taskAssignee("departmentManager");

        List<Task> tasks = taskQuery.list();

        for (Task task : tasks) {
            System.out.println("Task ID: " + task.getId());
            System.out.println("Task Name: " + task.getName());

            taskService.complete(task.getId());
        }

        taskQuery = taskService.createTaskQuery()
            .taskAssignee("hrManager");

        tasks = taskQuery.list();

        for (Task task : tasks) {
            System.out.println("Task ID: " + task.getId());
            System.out.println("Task Name: " + task.getName());

            taskService.complete(task.getId());
        }
    }
}

审批流程实战

假设需要实现一个审批流程，包括以下步骤：

1. 用户提交审批请求
2. 部门经理审批
3. 财务经理审批
4. **审批请求结束

审批流程模型设计

创建一个简单的审批流程模型，包括以下步骤：

1. 用户提交审批请求
2. 部门经理审批
3. 财务经理审批
4. **审批请求结束

审批流程部署

使用Activiti API将审批流程部署到Activiti引擎中。

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.RepositoryService;
import org.activiti.engine.repository.Deployment;

public class ApprovalProcessExample {
    public static void main(String[] args) {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RepositoryService repositoryService = processEngine.getRepositoryService();

        Deployment deployment = repositoryService.createDeployment()
            .addClasspathResource("approvalProcess.bpmn20.xml")
            .deploy();

        System.out.println("Deployment ID: " + deployment.getId());
    }
}

审批流程启动

启动一个新的审批流程实例。

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.ProcessEngineConfiguration;

public class ApprovalProcessExample {
    public static void main(String[] args) {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RuntimeService runtimeService = processEngine.getRuntimeService();

        String processDefinitionId = "approvalProcess:1:2501";
        String businessKey = "approvalRequest123";

        String processInstanceId = runtimeService.startProcessInstanceById(processDefinitionId, businessKey).getId();

        System.out.println("Process Instance ID: " + processInstanceId);
    }
}

任务处理

部门经理和财务经理分别处理审批任务。

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.TaskService;
import org.activiti.engine.task.Task;
import org.activiti.engine.task.TaskQuery;

public class ApprovalProcessExample {
    public static void main(String[] args) {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();

        TaskQuery taskQuery = taskService.createTaskQuery()
            .taskAssignee("departmentManager");

        List<Task> tasks = taskQuery.list();

        for (Task task : tasks) {
            System.out.println("Task ID: " + task.getId());
            System.out.println("Task Name: " + task.getName());

            taskService.complete(task.getId());
        }

        taskQuery = taskService.createTaskQuery()
            .taskAssignee("financeManager");

        tasks = taskQuery.list();

        for (Task task : tasks) {
            System.out.println("Task ID: " + task.getId());
            System.out.println("Task Name: " + task.getName());

            taskService.complete(task.getId());
        }
    }
}

销售流程实战

假设需要实现一个销售流程，包括以下步骤：

1. 销售员提交销售订单
2. 销售经理审批
3. 财务审核
4. **销售订单结束

销售流程模型设计

创建一个简单的销售流程模型，包括以下步骤：

1. 销售员提交销售订单
2. 销售经理审批
3. 财务审核
4. **销售订单结束

销售流程部署

使用Activiti API将销售流程部署到Activiti引擎中。

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.RepositoryService;
import org.activiti.engine.repository.Deployment;

public class SalesProcessExample {
    public static void main(String[] args) {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RepositoryService repositoryService = processEngine.getRepositoryService();

        Deployment deployment = repositoryService.createDeployment()
            .addClasspathResource("salesProcess.bpmn20.xml")
            .deploy();

        System.out.println("Deployment ID: " + deployment.getId());
    }
}

销售流程启动

启动一个新的销售流程实例。

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.ProcessEngineConfiguration;

public class SalesProcessExample {
    public static void main(String[] args) {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RuntimeService runtimeService = processEngine.getRuntimeService();

        String processDefinitionId = "salesProcess:1:2501";
        String businessKey = "salesOrder123";

        String processInstanceId = runtimeService.startProcessInstanceById(processDefinitionId, businessKey).getId();

        System.out.println("Process Instance ID: " + processInstanceId);
    }
}

任务处理

销售经理和财务人员分别处理审批任务。

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.TaskService;
import org.activiti.engine.task.Task;
import org.activiti.engine.task.TaskQuery;

public class SalesProcessExample {
    public static void main(String[] args) {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();

        TaskQuery taskQuery = taskService.createTaskQuery()
            .taskAssignee("salesManager");

        List<Task> tasks = taskQuery.list();

        for (Task task : tasks) {
            System.out.println("Task ID: " + task.getId());
            System.out.println("Task Name: " + task.getName());

            taskService.complete(task.getId());
        }

        taskQuery = taskService.createTaskQuery()
            .taskAssignee("finance");

        tasks = taskQuery.list();

        for (Task task : tasks) {
            System.out.println("Task ID: " + task.getId());
            System.out.println("Task Name: " + task.getName());

            taskService.complete(task.getId());
        }
    }
}

源码解析

Activiti的源码相对简单，可以方便地进行调试和修改。以下是如何解析和调试Activiti源码的步骤：

1. 下载源码：从GitHub下载Activiti源码。
2. 导入项目：将源码导入到IDE中，如Eclipse或IntelliJ IDEA。
3. 设置断点：在关键位置设置断点，以便在运行时进行调试。
4. 运行调试：通过IDE的调试工具运行Activiti，观察程序的执行过程。

调试示例

以下是一个简单的调试示例，展示如何在任务处理过程中设置断点并运行调试：

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.TaskService;
import org.activiti.engine.task.Task;
import org.activiti.engine.task.TaskQuery;

public class DebugExample {
    public static void main(String[] args) {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();

        TaskQuery taskQuery = taskService.createTaskQuery()
            .taskAssignee("departmentManager");

        List<Task> tasks = taskQuery.list();

        for (Task task : tasks) {
            System.out.println("Task ID: " + task.getId());
            System.out.println("Task Name: " + task.getName());

            taskService.complete(task.getId());
        }
    }
}

在上述代码中，可以在taskService.complete(task.getId());这一行设置断点，以便在任务完成时进行调试，检查任务的状态和执行过程。

1. 减少数据库查询：减少不必要的数据库查询可以提高性能。可以通过缓存数据或减少查询次数来实现。
2. 使用缓存：Activiti提供了一系列缓存机制，可以缓存流程定义、任务、流程实例等信息。
3. 优化数据库配置：优化数据库配置，如增加连接池大小、优化数据库索引等。
4. 异步处理：将耗时任务异步处理，避免阻塞主线程。

缓存示例

以下是一个简单的缓存示例，展示如何使用Activiti的缓存机制来缓存流程定义：

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.ProcessEngineConfiguration;
import org.springframework.cache.CacheManager;
import org.springframework.cache.concurrent.ConcurrentMapCacheManager;

public class CacheExample {
    public static void main(String[] args) {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        ProcessEngineConfiguration configuration = processEngine.getProcessEngineConfiguration();

        CacheManager cacheManager = new ConcurrentMapCacheManager();
        configuration.setCacheManager(cacheManager);

        System.out.println("使用缓存机制");
    }
}

常见错误及解决方法

以下是常见的Activiti错误及其解决方案：

1. 流程定义加载错误：如果流程定义文件加载失败，可能是因为文件路径错误或文件不存在。检查文件路径和文件名是否正确。
2. 数据库连接错误：如果数据库连接失败，检查数据库配置是否正确，包括数据库URL、用户名和密码。
3. 流程实例启动失败：如果流程实例无法启动，检查流程定义是否存在，并确保流程定义的ID正确。
4. 任务处理失败：如果任务处理失败，检查任务ID是否正确，并确保任务的处理人存在。

性能优化技巧

1. 减少数据库查询：减少不必要的数据库查询可以提高性能。可以通过缓存数据或减少查询次数来实现。
2. 使用缓存：Activiti提供了一系列缓存机制，可以缓存流程定义、任务、流程实例等信息。
3. 优化数据库配置：优化数据库配置，如增加连接池大小、优化数据库索引等。
4. 异步处理：将耗时任务异步处理，避免阻塞主线程。

通过本文的介绍，你应该对Activiti有了全面的了解，包括其安装、配置、流程设计、API编程和实战案例。Activiti是一个强大的工作流引擎，可以处理复杂的业务流程。通过实践示例，你可以更好地掌握如何使用Activiti解决实际问题。希望本教程对你有所帮助。