Activiti工做流基础学习笔记

时间 2019-11-06

标签 activiti 基础学习笔记繁體版

原文原文链接

1、了解工做流

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

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

2、初始化表结构

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

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

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 (名字随意)spring

<!-- 配置流程引擎配置对象 -->
	<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.javasql

@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.javaapache

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

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

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

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

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

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

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

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

4、Activiti框架的基本使用

1.部署流程定义

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

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

@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("办理成功");
    }
复制代码

5、Activiti提供的Service对象

在以上的代码中有不少Servie，接下来讲明一下这些Service的区别。

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

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

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

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

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

8、使用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());
        }
    }
复制代码

9、流程变量

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

对应的表： 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);
    }
复制代码

# 10、任务的类型 ### 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); } ```

11、监听器（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+"]负责办理");
    }
}

复制代码

第二步：注册监听类

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

12、网关

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） > 它容许将流程分红多条分支，也能够把多条分支汇聚成一条。

分支：通过并行网关的全部流，都会并行执行

汇聚：等全部流都到达并行网关以后，流程才会经过并行网关。

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

十3、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