一、了解工作流

工作流(Workflow)，就是“业务过程的部分或整体在计算机应用环境下的自动化”，它主要解决的是“使在多个参与者之间按照某种预定义的规则传递文档、信息或任务的过程自动进行，从而实现某个预期的业务目标，或者促使此目标的实现”。工作流管理系统(Workflow Management System, WfMS)是一个软件系统，它完成工作量的定义和管理，并按照在系统中预先定义好的工作流逻辑进行工作流实例的执行。工作流管理系统不是企业的业务系统，而是为企业的业务系统的运行提供了一个软件的支撑环境。

常见的工作流框架 Activity5.13、JBPM4.4、OSWorkFlow、WorkFlow 工作流框架底层需要有数据库提供支持，activiti5.13版本，有23张表。JBPM4.4框架底层有数据库支持，18张表。JBPM底层使用hibernate操作数据库。Activiti框架底层使用的mybatis操作数据库。

二、初始化表结构

1.使用Activiti框架提供的建表语句

下载的Activiti框架的包中 /activiti-x.xx/database/ceate/ 目录中提供各种数据库的建表语句。

2.使用Activiti框架自动建表

2.1 不使用配置文件

    @Test
    public void test1() {
        //    创建一个流程引擎配置对象
        ProcessEngineConfiguration configuration = ProcessEngineConfiguration.createStandaloneProcessEngineConfiguration();

        //    设置数据源信息
        configuration.setJdbcDriver("com.mysql.jdbc.Driver");
        configuration.setJdbcUrl("jdbc:mysql://localhost:3306/activiti");
        configuration.setJdbcUsername("root");
        configuration.setJdbcPassword("");

        //    设置自动建表
        configuration.setDatabaseSchemaUpdate("true");

        //    创建一个流程引擎对象，在创建流程引擎对象中会自动建表
        ProcessEngine processEngine = configuration.buildProcessEngine();
    }

2.2 使用自定义配置文件

actitviti-context.xml (名字随意)

	<!-- 配置流程引擎配置对象 -->
	<bean id="processEngineConfiguration"
		class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
		<property name="jdbcDriver" value="com.mysql.jdbc.Driver" />
		<property name="jdbcUrl" value="jdbc:mysql:///activiti" />
		<property name="jdbcUsername" value="root" />
		<property name="jdbcPassword" value="" />
		<property name="databaseSchemaUpdate" value="true" />
	</bean>

Test.java

    @Test
    /**
     * 使用框架提供的自动建表（提供配置文件）
     */
    public void test2() {
        String resource = "actitviti-context.xml";//配置文件名称
        String beanName = "processEngineConfiguration";//配置id值
        //加载配置文件
        ProcessEngineConfiguration configuration = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource(resource, beanName);
       //创建流程引擎对象
        ProcessEngine processEngine = configuration.buildProcessEngine();
    }

3.3 使用Activiti框架提供的默认配置文件

要求配置文件名称必须为activiti-context.xml或者activiti.cfg.xml。
配置流程引擎配置对象的id必须为 processEngineConfiguration 创建流程引擎对象的id必须为processEngine activiti-context.xml

	<!-- 配置流程引擎配置对象 -->
	<bean id="processEngineConfiguration"
		class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
		<property name="jdbcDriver" value="com.mysql.jdbc.Driver" />
		<property name="jdbcUrl" value="jdbc:mysql:///activiti" />
		<!--<property name="jdbcUrl" value="jdbc:mysql:///activiti_web" />-->
		<property name="jdbcUsername" value="root" />
		<property name="jdbcPassword" value="" />
		<property name="databaseSchemaUpdate" value="true" />
	</bean>

	<!-- 配置一个流程引擎工厂bean，用于创建流程引擎对象 -->
	<bean id="processEngine" class="org.activiti.spring.ProcessEngineFactoryBean">
		<!-- 通过set方法注入流程引擎配置对象 -->
		<property name="processEngineConfiguration" ref="processEngineConfiguration" />
	</bean>

Test.java

    @Test
    /**
     * 使用框架提供的自动建表（使用默认配置文件）
     */
    public void test() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    }

三、了解Activiti框架中的二十三张表

Activiti的后台是有数据库的支持，所有的表都以ACT_开头。第二部分是表示表的用途的两个字母标识。用途也和服务的API对应。

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

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

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

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

ACT_GE_*: 通用数据，用于不同场景下。

四、Activiti框架的基本使用

1.部署流程定义

1.1 使用Eclipse或Idea的BPMN编辑插件绘制流程图，并导出 流程图.bpmn和 流程图.png。（插件的安装及使用自行百度）

2.2 使用Java代码部署流程流程定义 Test.java

    @Test
    /**
     * 部署流程定义
     * 操作的数据表：
     *      act_re_deloyment（部署表） 部署一次 插入一条记录
     *      act_re_procdef 可以认为是部署表的扩展表 流程定义表
     *      act_ge_bytearray:流程定义文件被序列化存在数据表中
     */
    public void test() {
        //使用默认配置文件创建流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        // 获得一个部署构建器对象，用于加载流程定义文件（test.bpmn test.png）完成流程定义的部署
        DeploymentBuilder builder = processEngine.getRepositoryService().createDeployment();
        //   加载流程定义文件
        builder.addClasspathResource("/process/test.bpmn");
        builder.addClasspathResource("/process/test.png");
        //    部署流程定义
        Deployment deployment = builder.deploy();
    }

2. 查询流程定义列表

    /**
     * 查询流程定义列表
     */
    @Test
    public void test() {
        //使用默认配置文件创建流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //    流程定义查询对象，用于查询act_re_procdef
        ProcessDefinitionQuery query = processEngine.getRepositoryService().createProcessDefinitionQuery();
        //添加过滤条件
        query.processDefinitionKey("myProcess_1");
        //    添加排序条件
        query.orderByProcessDefinitionVersion().desc();
        //添加分页查询
        query.listPage(0, 10);
        List<ProcessDefinition> list = query.list();
        for (ProcessDefinition pd : list) {
            System.out.println(pd.getId());
        }
    }

3.启动流程实例

流程实例是根据一个流程定义具体的一次执行过程就是一个流程实例,一个流程定义对应多个流程实例(一对多关系)。

    /**
     * 根据流程定义 启动一个流程实例
     * 根据流程定义的一次具体执行过程，就是一个流程实例
     */
    @Test
    public void test() {
        //使用默认配置文件创建流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        String processDefinitionId = "myProcess_1:7:1004";//流程定义id可在act_re_procdef表中查询到
        ProcessInstance processInstance = processEngine.getRuntimeService().startProcessInstanceById(processDefinitionId);
        System.out.println(processInstance.getId());
    }

4.查询个人任务列表

    /**
     * 查询个人任务列表
     */
    @Test
    public void test() {
        //使用默认配置文件创建流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //创建任务查询
        TaskQuery taskQuery = processEngine.getTaskService().createTaskQuery();
      //添加查询条件 办理人为王五
        String assignee = "王五";
        taskQuery.taskAssignee(assignee);
        List<Task> list = taskQuery.list();//查询所有
        for (Task task : list) {
            System.out.println(task.getId() + "——" + task.getName());
        }
    }

5.办理任务

    /**
     * 办理业务
     */
    @Test
    public void test() {
        //使用默认配置文件创建流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        String taskId = "602";//任务id可在act_ru_task表中查询到
        processEngine.getTaskService().complete(taskId);//传入任务id办理业务
        System.out.println("办理成功");
    }

五、Activiti提供的Service对象

在以上的代码中有很多Servie，接下来说明一下这些Service的区别。

RepositoryService----操作静态的资源（流程定义，bpmn、png） RuntimeService-----操作流程实例（启动流程实例、查询流程实例、结束流程实例） TaskService-----操作任务（查询任务、办理任务） HistoryService----操作历史数据

六、Activiti框架提供的对象(和表有对应关系)

Deployment-----act_re_deployment ProcessDefinition----act_re_procdef ProcessInstance-----act_ru_execution Task-----act_ru_task

七、使用Activiti框架提供的网页版流程设计器

1.将Activiti的包中activiti-explorer.war复制到tomcat的/webapps目录中。 2.启动Tomcat，访问 http://lcoalhost:8080/activiti-explorer 3.登录。登录账号和密码为：kermit

八、使用Activiti框架的API操作流程

1.部署流程定义的两种方法

1.1 读取单个的流程定义文件

    @Test
    public void test() {
        //使用默认配置文件创建流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //创建流程部署对象
        DeploymentBuilder deploymentBuilder = processEngine.getRepositoryService().createDeployment();

        //读取单个的流程定义文件
        deploymentBuilder.addClasspathResource("/process/test.bpmn");
        deploymentBuilder.addClasspathResource("/process/test.png");
        Deployment deployment = deploymentBuilder.deploy();//部署流程

1.2 读取ZIP压缩文件将test.bpmn和test.png放到同一个zip压缩包中。

    @Test
    public void test() {
        //使用默认配置文件创建流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //创建流程部署对象
        DeploymentBuilder deploymentBuilder = processEngine.getRepositoryService().createDeployment();

        //读取ZIP压缩文件
        //读取资源文件
        ZipInputStream zipInputStream = new ZipInputStream(this.getClass().getClassLoader().getResourceAsStream("/process/process.zip"));
        deploymentBuilder.addZipInputStream(zipInputStream);
        deploymentBuilder.name("请假流程部署");//设置流程定义名称
        Deployment deployment1 = deploymentBuilder.deploy();//部署流程
    }

2.查询流程部署列表（act_re_deployment表）

    @Test
    public void test() {
        //使用默认配置文件创建流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //部署查询对象，查询act_re_deployment 部署表
        DeploymentQuery deploymentQuery = processEngine.getRepositoryService().createDeploymentQuery();
        List<Deployment> list = deploymentQuery.list();
        for (Deployment deployment : list) {
            String id = deployment.getId();
            System.out.println(id);
        }
    }

3.删除部署信息

    @Test
    public void test() {
        //使用默认配置文件创建流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        String deloymentId = "7504"; //流程部署id  在act_re_deployment表中
        //deleteDeployment有两个参数 第一个删除 部署的内容的id，第二个是否级联删除，默认为false
        processEngine.getRepositoryService().deleteDeployment(deloymentId, true);
    }

4.删除流程定义（通过删除部署信息达到删除流程定义的目的）

    @Test
    public void test() {
        //使用默认配置文件创建流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        String deloymentId = "1001";
        //deleteDeployment有两个参数 第一个删除 部署的内容的id，第二个是否级联删除，默认为false
        processEngine.getRepositoryService().deleteDeployment(deloymentId, true);
    }

5.查询流程定义列表

    @Test
    public void test() {
        //使用默认配置文件创建流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //流程定义查询对象，查询表act_re_procdef
        ProcessDefinitionQuery processDefinitionQuery = processEngine.getRepositoryService().createProcessDefinitionQuery();
        List<ProcessDefinition> list = processDefinitionQuery.list();
        for (ProcessDefinition pd : list) {
            System.out.println(pd.getName() + "———" + pd.getId());
        }
    }

6.查询一次部署对应的流程定义文件和对应的输入流（bpmn，png）

 @Test
    public void test() throws IOException {
        //使用默认配置文件创建流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        String deploymentId = "901";
        List<String> list = processEngine.getRepositoryService().getDeploymentResourceNames(deploymentId);
        for (String name : list) {
            System.out.println(name);
            InputStream inputStream = processEngine.getRepositoryService().getResourceAsStream(deploymentId, name);
            //将文件保存到本地磁盘
         org.apache.commons.io.FileUtils.copyInputStreamToFile(inputStream, new File("d:\\" + name));
            inputStream.close();
        }
    }

7.获得png文件的输入流

    @Test
    public void test() throws IOException {
        //使用默认配置文件创建流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        String processDefinitionId = "myProcess_1:6:904";
        InputStream PngInputStream = processEngine.getRepositoryService().getProcessDiagram(processDefinitionId);
        FileUtils.copyInputStreamToFile(PngInputStream, new File("d:\\my.png"));
    }

8.启动流程实例的两种方法

8.1 方式一：根据流程定义的id启动

@Test
    public void test() {
        //使用默认配置文件创建流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //方式一：根据流程定义的id启动
       String processDefinitionId = "myProcess_1:6:904";
        ProcessInstance processInstance = processEngine.getRuntimeService().startProcessInstanceById(processDefinitionId);
        System.out.println(processInstance.getId());
}

8.2 方式二：根据流程定义的key启动（自动选择最新版本的流程定义启动流程实例）

    @Test
    public void test() {
        //使用默认配置文件创建流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //方式二：根据流程定义的key启动（自动选择最新版本的流程定义启动流程实例）
        String processDefinitionKey = "myProcess_1";
        ProcessInstance processInstance = processEngine.getRuntimeService().startProcessInstanceByKey(processDefinitionKey);
        System.out.println(processInstance.getId());
    }

9.查询流程实例列表，查询act_ru_execution表

    @Test
    public void test() {
        //使用默认配置文件创建流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //流程实例查询对象，查询act_ru_execution表
        ProcessInstanceQuery query = processEngine.getRuntimeService().createProcessInstanceQuery();
        query.processDefinitionKey("myProcess_1");
        query.orderByProcessDefinitionId().desc();
        query.listPage(0, 3);
        List<ProcessInstance> list = query.list();
        for (ProcessInstance pi : list) {
            System.out.println(pi.getId() + "--" + pi.getActivityId());
        }
    }

10.结束流程实例

操作的表：act_re_excution,act_ru_task

    @Test
    public void test() {
        //使用默认配置文件创建流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        String processInstanceId = "1601";
        processEngine.getRuntimeService().deleteProcessInstance(processInstanceId, "不想要了");
    }

11.查询任务列表

    @Test
    public void test() {
        //使用默认配置文件创建流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //任务查询对象，查询任务表 act_ru_task表
        TaskQuery query = processEngine.getTaskService().createTaskQuery();
        //按照办理人进行过滤
        String assignee = "李四";
        query.taskAssignee(assignee);
        query.orderByTaskCreateTime().desc();
        List<Task> list = query.list();
        for (Task task : list) {
            System.out.println(task.getId());
        }
    }

12.办理任务

    @Test
    public void test() {
        //使用默认配置文件创建流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        String taskId = "1404";
        processEngine.getTaskService().complete(taskId);
    }

13.直接将流程向下执行一步

    @Test
    public void test() {
        //使用默认配置文件创建流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        String executionId = "1401"; //流程实例id
        processEngine.getRuntimeService().signal(executionId);
    }

14.查询最新版本的流程定义列表

    @Test
    public void test() {
        //使用默认配置文件创建流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        ProcessDefinitionQuery query = processEngine.getRepositoryService().createProcessDefinitionQuery();
        query.orderByProcessDefinitionVersion().asc();
        List<ProcessDefinition> list = query.list();
        Map<String, ProcessDefinition> map = new HashMap<>();
        for (ProcessDefinition pd : list) {
            map.put(pd.getKey(),pd);
        }
        System.out.println(map);
    }

15.流程的修改

流程的修改：添加新的流程版本，如果已经在执行的流程，按照原来的流程继续执行。新的流程按照最新版本进行执行。

16.历史数据查询

16.1 查询历史流程实例列表查询历史流程实例列表 act_hi_procinst

    @Test
    public void test() {
        //使用默认配置文件创建流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        HistoricProcessInstanceQuery query = processEngine.getHistoryService().createHistoricProcessInstanceQuery();
        List<HistoricProcessInstance> list = query.list();
        for (HistoricProcessInstance hi : list) {
            System.out.println(hi.getId());
        }
    }

16.2 查询历史活动数据查询历史活动数据 act_hi_actinst 包括任务和事件

    @Test
    public void test() {
        //使用默认配置文件创建流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        HistoricActivityInstanceQuery query = processEngine.getHistoryService().createHistoricActivityInstanceQuery();
        //按照流程实例排序
        query.orderByProcessInstanceId().desc();
        query.orderByHistoricActivityInstanceEndTime().asc();
        List<HistoricActivityInstance> list = query.list();
        for (HistoricActivityInstance hi : list) {
            System.out.println(hi.getActivityId() + "——" + hi.getActivityName() + "——" + hi.getActivityType());
        }
    }

16.3 查询历史任务数据查询历史任务数据 act_hi_taskinst 单纯的只有任务

    @Test
    public void test() {
        //使用默认配置文件创建流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        HistoricTaskInstanceQuery query = processEngine.getHistoryService().createHistoricTaskInstanceQuery();
        query.orderByProcessInstanceId().asc();
        query.orderByHistoricTaskInstanceEndTime().asc();
        List<HistoricTaskInstance> list = query.list();
        for (HistoricTaskInstance hi:list){
            System.out.println(hi.getAssignee()+"——"+hi.getName()+"——"+hi.getStartTime());
        }
    }

九、流程变量

在流程执行或者任务执行的过程中，用于设置和获取变量，使用流程变量在流程传递的过程中传递业务参数。

对应的表： act_ru_variable：正在执行的流程变量表 act_hi_varinst：流程变量历史表
流程变量图解

1.设置流程变量

1.1 在启动流程实例时设置

    @Test
    public void test() {
        //使用默认配置文件创建流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        String processDefinitionKey = "variable";
        Map<String, Object> variables = new HashMap<>();
        variables.put("key1", "value1");
        variables.put("key2", 200);
        ProcessInstance processInstance = processEngine.getRuntimeService().startProcessInstanceByKey(processDefinitionKey, variables);
        System.out.println(processInstance.getId());
    }

1.2 在办理任务时设置流程变量

    @Test
    public void test() {
        //使用默认配置文件创建流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        String taskId = "1206";
        Map<String, Object> variables = new HashMap<>();
        variables.put("user", new User(1, "小王"));
        processEngine.getTaskService().complete(taskId, variables);
    }

1.3 使用RuntimeService的方法设置

    @Test
    public void test() {
        //使用默认配置文件创建流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        String excutionId = "601";//流程实例Id
        String variableName = "key3";
        String value = "value3";
        processEngine.getRuntimeService().setVariable(excutionId, variableName, value);
    }

1.4 使用TaskService的方法设置

    @Test
    public void test() {
        //使用默认配置文件创建流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        String taskId = "704";
        Map<String, Object> variables = new HashMap<>();
        variables.put("key4", 400);
        variables.put("k5", "v5");
        processEngine.getTaskService().setVariables(taskId, variables);
    }

### 2.流程变量支持的类型 >Jdk中提供的数据类型（String、Integer、List 、Map…）自定义的实体类（要求实现序列化接口），在variable表中只存bytearray_id 实例化内容存在bytearray表中。

3.获取流程变量

3.1 使用RuntimeService的方法获取

    @Test
    public void test() {
        //使用默认配置文件创建流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        String executionId = "1201";
        Map<String, Object> variables = processEngine.getRuntimeService().getVariables(executionId);
        System.out.println(variables);
        Set<String> set = variables.keySet();//key2 key1 user
        for (String key : set) {
            Object val = variables.get(key);
            System.out.println(key + "=" + val);
        }

        //根据一个key获得一个value
        Object value = processEngine.getRuntimeService().getVariable(executionId, "user");
        System.out.println(value);

        Collection<String> variableNames = new ArrayList<>();
        variableNames.add("key2");
        variableNames.add("user");
        Map<String, Object> map = processEngine.getRuntimeService().getVariables(executionId, variableNames);
        System.out.println(map);

3.2 使用TaskService的方法获取

    @Test
    public void test() {
        //使用默认配置文件创建流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        String taskId = "1305";
        Map<String, Object> variables = processEngine.getTaskService().getVariables(taskId);
    }

# 十、任务的类型 ### 1.个人任务 >由某一个负责办理，在任务表中通过assignee字段记录。

2.公共任务（组任务）

当前的任务可以由多个人其中的某一个人办理，可以在设计流程图时指定多个办理人。Candidate Users 候选用户

2.1 查询公共任务列表

    @Test
    public void test() {
        //使用默认配置文件创建流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskQuery query = processEngine.getTaskService().createTaskQuery();
        //    根据候选人过滤
        String candidateUser = "李四";
        query.taskCandidateUser(candidateUser);
        List<Task> list = query.list();
        for (Task task:list){
            System.out.println(task.getName());
        }
    }

2.2 拾取公共任务（将公共任务变为个人任务）

    @Test
    public void test(){
        //使用默认配置文件创建流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        String taskId="1602";
        String userId="王五";
        processEngine.getTaskService().claim(taskId,userId);
    }

2.3 退回任务（将个人任务重新变为公共任务）

    @Test
    public void test(){
        //使用默认配置文件创建流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        String taskId="1602";
        processEngine.getTaskService().setAssignee(taskId,null);
    }

### 3.接受任务 >接收任务不是由某个人负责办理，通过signal方法让流程执行的![接收任务图示.png](https://upload-images.jianshu.io/upload_images/12984595-184194b84034837a.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240) ``` /** * 处理接收任务 */ @Test public void test() { //使用默认配置文件创建流程引擎 ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine(); String excutionId = "2501"; processEngine.getRuntimeService().signal(excutionId); } ```

十一、监听器（Listener）

1.执行监听器

监听流程实例的事件

第一步：按照框架的规则编写监听器类

import org.activiti.engine.delegate.DelegateExecution;
import org.activiti.engine.delegate.ExecutionListener;

/**
 * @author Hiseico
 * @create 2018-06-07 16:41
 * @desc 自定义执行监听器
 **/
public class MyExcutionListener implements ExecutionListener {
    //当监听事件发生时执行此方法
    @Override
    public void notify(DelegateExecution delegateExecution) throws Exception {
        System.out.println("自定义的监听器执行。。。2");
    }
}

第二步：设计流程图，注册监听器类

第三步：启动流程实例，Activiti框架通过反射调用监听器类

2.任务监听器

监听任务事件

第一步：按照activiti框架的规则编写一个任务监听器类

import org.activiti.engine.delegate.DelegateTask;
import org.activiti.engine.delegate.TaskListener;

import java.util.Set;

/**
 * @author Hiseico
 * @create 2018-06-07 17:10
 * @desc 自定义任务监听器
 **/
public class MyTaskListener implements TaskListener {
    /**
     * 监听任务事件
     *
     * @param delegateTask
     */
    @Override
    public void notify(DelegateTask delegateTask) {
        //任务办理人
        String assignee = delegateTask.getAssignee();
        //任务名称
        String eventName = delegateTask.getEventName();
        //事件名称
        String name = delegateTask.getName();
        //流程实例Id
        String processInstanceId = delegateTask.getProcessInstanceId();
        //获取当前流程实例范围内的所有流程变量的名字
        Set<String> variableNames = delegateTask.getVariableNames();
        for (String key : variableNames) {
            Object value = delegateTask.getVariable(key);
            System.out.println(key + " = " + value);
        }
        System.out.println("一个["+name+"]任务被创建了，由["+assignee+"]负责办理");
    }
}

第二步：注册监听类

第三步：办理任务，由框架通过反射调用监听器类

十二、网关

1.排他网关（ExclusiveGateway）

用来在流程中实现决策。当流程执行到排他网关，所有数据就会被执行一遍，满足条件的就会让流程继续运行。需要注意的是：排他网关只会选择一条满足条件的执行。

第一步：设计流程图，使用排他网关

第二步：执行流程，由框架根据设置的流程变量选择执行其中的一个分支，在分支的线上设置参数：Condition:#{bxje>200}

第三步：办理业务

    /**
     * 办理任务，设置流程变量
     */
    @Test
    public void test() {
        String taskId = "802";
        Map<String, Object> variables = new HashMap<>();
        variables.put("bxje",600);//排他网关会自动判断 bxje 变量的值，选择执行分支
        processEngine.getTaskService().complete(taskId,variables);
    }

### 2.并行网关（ParallelGateway） > 它允许将流程分成多条分支，也可以把多条分支汇聚成一条。

分支：经过并行网关的所有流，都会并行执行

汇聚：等所有流都到达并行网关之后，流程才会通过并行网关。

并行网关，没有条件判断。流程通过网关之后，有几条分支，就会有几个执行对象同时执行。需要注意的是：并行网关一定是成对出现的，有分支也有汇聚。

十三、Spring整合Activiti

第一步：提供spring配置文件，配置数据源、事务管理器、流程引擎配置对象、流程引擎对象 appplicationContext.xml

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
       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
						http://www.springframework.org/schema/context 
						http://www.springframework.org/schema/context/spring-context-2.5.xsd
						http://www.springframework.org/schema/tx 
						http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">
    <!--配置数据源-->
    <bean id="ds" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql:///activiti"/>
        <property name="username" value="root"/>
        <property name="password" value=""/>
    </bean>

    <!--事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="ds"/>
    </bean>

    <!--配置一个Spring提供的对象，用于创建一个流程引擎配置对象-->
    <bean id="processEngineConfiguration" class="org.activiti.spring.SpringProcessEngineConfiguration">
        <property name="transactionManager" ref="transactionManager"/>
        <property name="dataSource" ref="ds"/>
        <!--自动建表的配置-->
        <property name="databaseSchemaUpdate" value="true"/>
    </bean>

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

第二步：在Java程序中读取spring配置文件，创建spring工厂，获取流程引擎对象

public class SpringActivitiTest {
    @Test
    public void test() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring/applicationContext.xml");
       ProcessEngine processEngine = (ProcessEngine) applicationContext.getBean("processEngine");
        DeploymentBuilder deploymentBuilder = processEngine.getRepositoryService().createDeployment();
        deploymentBuilder.addClasspathResource("spring/variable.bpmn");
        Deployment deployment = deploymentBuilder.deploy();
    }
}

到此Activiti框架的基础笔记就先整理到这里，本笔记用作学习完Activiti框架后复习使用，不适用于Activiti框架入门教程，不喜勿喷。

转载请注明出处及作者。

掘金个人主页

Create By Hiseico