工作流下篇

最新推荐文章于 2022-12-25 16:20:28 发布

厚学

最新推荐文章于 2022-12-25 16:20:28 发布

阅读量140

点赞数

文章标签： java

本文链接：https://blog.csdn.net/ljs13168734665/article/details/115388351

版权

工作流下篇

1、组任务代码篇
2、用户拾取组任务
3、组任务之：当前个人任务查询并完成
4、归还组任务
5、任务交接
6、网关
7、activiti与spring整合开发
8、activiti与springboot整合
9、activiti+springboot+springmvc

1、组任务代码篇

1、查询组任务

package com.ljs.activity.zurenwu;

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

import java.util.List;

/**
 * 组任务办理
 */
public class GroupTest {
    public static void main(String[] args) {
        // 1、获取processEngine
        ProcessEngine defaultProcessEngine = ProcessEngines.getDefaultProcessEngine();
        // 2、获取TaskSerivce
        TaskService taskService = defaultProcessEngine.getTaskService();
        // 3、设置参数。流程定义key和候选用户
        String key = "holiday";
        String user = "zhangsan";
        List<Task> list = taskService.createTaskQuery()
                .processDefinitionKey(key)
                .taskCandidateUser(user).list();
        // 4、遍历任务
        for(Task task:list){
            System.out.println(task.getProcessDefinitionId());
            System.out.println(task.getId());
            System.out.println(task.getName());
            System.out.println(task.getAssignee());// 主要看是否为null，如果是null则表示。当前zhangsan是候选人。并不是执行人
        }
    }

}

在这里插入图片描述
说明zhangsan是候选人

2、用户拾取组任务

package com.ljs.activity.zurenwu;

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.TaskService;
import org.activiti.engine.task.Task;
import org.springframework.util.ObjectUtils;

import java.util.List;

/**
 * 拾取组任务
 */
public class ClaimGroup {
    public static void main(String[] args) {
        // 1、获取processEngine
        ProcessEngine defaultProcessEngine = ProcessEngines.getDefaultProcessEngine();
        // 2、获取TaskSerivce
        TaskService taskService = defaultProcessEngine.getTaskService();
        // 3、设置参数。流程定义key和候选用户
        String key = "holiday";
        String user = "zhangsan";
        Task task = taskService.createTaskQuery()
                .processDefinitionKey(key)
                .taskCandidateUser(user).singleResult();
        System.out.println(task.getProcessDefinitionId());
        System.out.println(task.getId());
        System.out.println(task.getName());
        System.out.println(task.getAssignee());// 主要看是否为null，如果是null则表示。当前zhangsan是候选人。并不是执行人

        // 查询到组任务之后，可以拾取组任务
        if (!ObjectUtils.isEmpty(task)) {
            taskService.claim(task.getId(), user);
            System.out.println("任务拾取完成");
        }
    }
}

在这里插入图片描述
数据库变化

执行拾取的过程就是将候选用户。直接转换为任务的负责人

3、组任务之：当前个人任务查询并完成

  public static void main(String[] args) {
        // 查询当前组任务的个人任务。
        // 1、获取processEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

        // 2、获取TaskService对象
        TaskService taskService = processEngine.getTaskService();

        // 3、根据key和当前用户筛选list列表
        Task task = taskService.createTaskQuery()
                .processDefinitionKey("holiday")
                .taskAssignee("zhangsan")
                .singleResult();

        // 4、遍历输出list列表展示
        System.out.println("流程实例id:"+task.getProcessInstanceId());
        System.out.println("任务名称:"+task.getName());
        System.out.println("任务id:"+task.getId());
        System.out.println("任务负责人:"+task.getAssignee());

        // 5、完成当前任务
        if (!ObjectUtils.isEmpty(task)){
            taskService.complete(task.getId());
            System.out.println("当前用户任务完成");
        }
    }

在这里插入图片描述

4、归还组任务

1、删库，建库
2、部署流程定义
3、启动流程实例
4、完成第一个流程实例。到部门经理审批节点
在这里插入图片描述
5、设置候选人

6、拾取任务

###7、归还组任务
归还前需先校验当前用户是否为任务负责人

 public static void main(String[] args) {
        ProcessEngine defaultProcessEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = defaultProcessEngine.getTaskService();
        // 6、归还组任务
        // 查询当前用户是否是任务的执行人
        Task task = taskService.createTaskQuery()
                .taskAssignee("zhangsan")
                .singleResult();
        if (!ObjectUtils.isEmpty(task)){
            taskService.setAssignee(task.getId(),null);
        }
    }

在这里插入图片描述

5、任务交接

任务的执行人将工作交给其他候选人。
保证当前用户是任务的负责人

 public static void main(String[] args) {
        // 1、zhangsan重新拾取组任务
       /* ProcessEngine defaultProcessEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = defaultProcessEngine.getTaskService();
        Task task = taskService.createTaskQuery()
                .taskCandidateUser("zhangsan")
                .singleResult();
        if (!ObjectUtils.isEmpty(task)){
            taskService.claim(task.getId(),"zhangsan");
            System.out.println("任务拾取成功");
        }*/

        // 2、判断当前用户是否为任务负责人。如果是则交接任务给lisi
        ProcessEngine defaultProcessEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = defaultProcessEngine.getTaskService();
        Task task1 = taskService.createTaskQuery()
                .taskAssignee("zhangsan")
                .singleResult();
        if (!ObjectUtils.isEmpty(task1)){
            taskService.setAssignee(task1.getId(),"lisi");
            System.out.println("任务交接完毕");
        }
    }

在这里插入图片描述

李四可以完成自己的任务

    // 3、lisi完成任务
        // 先看自己是不是任务负责人。如果是才可以完成
        ProcessEngine defaultProcessEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = defaultProcessEngine.getTaskService();
        Task task = taskService.createTaskQuery()
                .taskAssignee("lisi")
                .singleResult();
        if (!ObjectUtils.isEmpty(task)){
            taskService.complete(task.getId());
            System.out.println("lisi完成任务");
        }

在这里插入图片描述

####组任务影响的表
主要是
在这里插入图片描述

6、网关

6.1、排他网关

${holiday.num}=null的时候既不小于等于3也不大于3.
这时候我们流程分支走哪里？这里会用到网关的概念。

网关的三种：排他网关、并行网关、包含网关

#排他网关（异或网关）：即使有两个true的分支。但是排他网关只会选择一个为true的分支执行

如果我们将bpmn图修改
将原来的
在这里插入图片描述

改为
在这里插入图片描述

编码（不带网关的condition测试）

package com.ljs.activity.gateway;

import com.ljs.activity.UEL.Holiday;
import org.activiti.engine.*;
import org.activiti.engine.repository.Deployment;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.springframework.util.ObjectUtils;

import java.util.HashMap;
import java.util.Map;

/**
 * 测试排他网关
 */
public class TestpaitaGateway {
    public static void main1(String[] args) {
        // 测试没有网关的情况
        // 1、创建ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

        // 2、得到RepositoryService实例
        RepositoryService repositoryService = processEngine.getRepositoryService();

        // 3、进行部署
        Deployment deployment = repositoryService.createDeployment()
                .addClasspathResource("holiday2.bpmn") // 添加bpmn资源
                .addClasspathResource("holiday2.png")  // 添加png资源
                .name("请假流程申请") // 流程名
                .deploy();//部署

        // 4、输出部署信息
        System.out.println(deployment.getName());
        System.out.println(deployment.getId());

        // 5、创建流程实例时设置全局流程变量(必须提前得知key是什么这里是：holiday)
        Holiday holiday = new Holiday();
        holiday.setNum(5f);
        Map<String,Object>map = new HashMap<String, Object>();
        map.put("holiday",holiday);
        RuntimeService runtimeService = processEngine.getRuntimeService();
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("holiday",map);
        // 6、输出id
        System.out.println("流程部署id:"+processInstance.getDeploymentId());
        System.out.println("流程定义id:"+processInstance.getProcessDefinitionId());
        System.out.println("流程实例id:"+processInstance.getId());
        System.out.println("活动id:"+processInstance.getActivityId());
    }

    public static void main(String[] args) {
        // 完成当前任务
        ProcessEngine defaultProcessEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = defaultProcessEngine.getTaskService();
        Task task = taskService.createTaskQuery()
                .taskAssignee("lisi")
                .singleResult();
        if (!ObjectUtils.isEmpty(task)){
            taskService.complete(task.getId());
            System.out.println("任务完成");
        }
    }
}

在这里插入图片描述
这时候执完部门经理审批。就有了两个task显然有问题
流程出现了问题

这时候就得设置排他网关
在这里插入图片描述
idea设计流程定义图

加入排他网关后的bpmn文件

在这里插入图片描述
有了排他网关

package com.ljs.activity.gateway;

import com.ljs.activity.UEL.Holiday;
import org.activiti.engine.*;
import org.activiti.engine.repository.Deployment;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.springframework.util.ObjectUtils;

import java.util.HashMap;
import java.util.Map;

/**
 * 测试排他网关
 */
public class TestpaitaGateway {
    public static void main1(String[] args) {
        // 1、创建ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

        // 2、得到RepositoryService实例
        RepositoryService repositoryService = processEngine.getRepositoryService();

        // 3、进行部署
        Deployment deployment = repositoryService.createDeployment()
                .addClasspathResource("holiday4.bpmn") // 添加bpmn资源
                .name("请假流程申请") // 流程名
                .deploy();//部署

        // 4、输出部署信息
        System.out.println(deployment.getName());
        System.out.println(deployment.getId());

        // 5、创建流程实例时设置全局流程变量(必须提前得知key是什么这里是：holiday)
        Holiday holiday = new Holiday();
        holiday.setNum(5f);
        Map<String,Object>map = new HashMap<String, Object>();
        map.put("holiday",holiday);
        RuntimeService runtimeService = processEngine.getRuntimeService();
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("holiday",map);
        // 6、输出id
        System.out.println("流程部署id:"+processInstance.getDeploymentId());
        System.out.println("流程定义id:"+processInstance.getProcessDefinitionId());
        System.out.println("流程实例id:"+processInstance.getId());
        System.out.println("活动id:"+processInstance.getActivityId());
    }

    public static void main(String[] args) {
        // 完成当前任务
        ProcessEngine defaultProcessEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = defaultProcessEngine.getTaskService();
        Task task = taskService.createTaskQuery()
                .taskAssignee("lisi")
                .singleResult();
        if (!ObjectUtils.isEmpty(task)){
            taskService.complete(task.getId());
            System.out.println("任务完成");
        }
    }
}

在这里插入图片描述
有了排他网关则可以控制流程
###为什么两个条件都满足的情况下。排他网关会让流程走总经理审批，而不是人事存档？
因为两根线都为true的情况。默认走id更小的

如果两条线都为false，会抛异常
在这里插入图片描述

6.2、并行网关

并行网关：将流程分成多条分支，可以把多条分支汇聚到一起。并行网关的功能基于进入，外出顺序流

在这里插入图片描述

编码

package com.ljs.activity.gateway;

import com.ljs.activity.UEL.Holiday;
import org.activiti.engine.*;
import org.activiti.engine.repository.Deployment;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.springframework.util.ObjectUtils;

import java.util.HashMap;
import java.util.Map;

/**
 * 测试并行网关
 */
public class TestpallentGateway {
    public static void main1(String[] args) {
        // 1、创建ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

        // 2、得到RepositoryService实例
        RepositoryService repositoryService = processEngine.getRepositoryService();

        // 3、进行部署
        Deployment deployment = repositoryService.createDeployment()
                .addClasspathResource("holiday5.bpmn") // 添加bpmn资源
                .addClasspathResource("holiday5.png")
                .name("请假流程申请") // 流程名
                .deploy();//部署

        // 4、输出部署信息
        System.out.println(deployment.getName());
        System.out.println(deployment.getId());

        // 5、创建流程实例时设置全局流程变量(必须提前得知key是什么这里是：holiday)
        Holiday holiday = new Holiday();
        holiday.setNum(5f);
        Map<String,Object> map = new HashMap<String, Object>();
        map.put("holiday",holiday);
        RuntimeService runtimeService = processEngine.getRuntimeService();
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("myProcess_1",map);
        // 6、输出id
        System.out.println("流程部署id:"+processInstance.getDeploymentId());
        System.out.println("流程定义id:"+processInstance.getProcessDefinitionId());
        System.out.println("流程实例id:"+processInstance.getId());
        System.out.println("活动id:"+processInstance.getActivityId());
    }

    public static void main(String[] args) {
        // 完成当前任务
        ProcessEngine defaultProcessEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = defaultProcessEngine.getTaskService();
        Task task = taskService.createTaskQuery()
                .taskAssignee("zhaoliu")
                .singleResult();
        if (!ObjectUtils.isEmpty(task)){
            taskService.complete(task.getId());
            System.out.println("任务完成");
        }
    }
}

zhaoliu人事存档也完成以后。会不会生成两条task？会！
在这里插入图片描述
如果这时候ljs执行。则会少一条记录。到lichen那里

在这里插入图片描述

并行网关执行后。一旦一个财务或行政任意一个节点完成。则并行网关end_time就都有了

当lichen执行完毕则整个任务结束
并且插入最后汇聚时间。
在这里插入图片描述

在这里插入图片描述
#####所有分支到达汇聚节点。并行网关才算执行完成

6.3、包含网关

包含网关：就是并行网关和排他网关的结合体。可以设置多个分支。比如5个分支：3个分支满足条件。则这3个就走。另外2个就留
然后有聚合点。2个聚合点。当这3个最终汇合到最后聚合点上时。判定当前包含网关执行结束。推到下一节点

比如体检流程
在这里插入图片描述

需求：公司体检项目。普通员工，常规体检和抽血化验。高管全部都做。
在这里插入图片描述
像常规体检，抽血化验项目：userType=1||userType=2
附加项目就userType=2

package com.ljs.activity.gateway;

import com.ljs.activity.UEL.Holiday;
import org.activiti.engine.*;
import org.activiti.engine.repository.Deployment;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.springframework.util.ObjectUtils;

import java.util.HashMap;
import java.util.Map;

/**
 * 包含网关测试
 */
public class TestIncludeGateway {
    // 就是并行网关和排他网关的结合体。可以设置多个分支
    // 当流程变量分支取值都成立时，那多个条件都成立
    public static void main1(String[] args) {
        // 1、创建ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

        // 2、得到RepositoryService实例
        RepositoryService repositoryService = processEngine.getRepositoryService();

        // 3、进行部署
        Deployment deployment = repositoryService.createDeployment()
                .addClasspathResource("example.bpmn") // 添加bpmn资源
                .name("体检流程") // 流程名
                .deploy();//部署

        // 4、输出部署信息
        System.out.println(deployment.getName());
        System.out.println(deployment.getId());


        // 5、创建流程实例时设置全局流程变量(必须提前得知key是什么这里是：holiday)

        Integer userType = 2; //高管
        Map<String,Object>map = new HashMap<String, Object>();
        map.put("userType",userType);
        RuntimeService runtimeService = processEngine.getRuntimeService();
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("myProcess_1",map);
        // 6、输出id
        System.out.println("流程部署id:"+processInstance.getDeploymentId());
        System.out.println("流程定义id:"+processInstance.getProcessDefinitionId());
        System.out.println("流程实例id:"+processInstance.getId());
        System.out.println("活动id:"+processInstance.getActivityId());
    }
    public static void main(String[] args) {
        // 完成当前任务
        ProcessEngine defaultProcessEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = defaultProcessEngine.getTaskService();
        Task task = taskService.createTaskQuery()
                .taskAssignee("zhangsan")
                .singleResult();
        if (!ObjectUtils.isEmpty(task)){
            taskService.complete(task.getId());
            System.out.println("任务完成");
        }
    }
}

这时候完成zhangsan的任务
在这里插入图片描述
因为userType=2是我设置的。都满足

现在是lisi也完成了
在这里插入图片描述

第一个包含网关节点在抽血化验，附加项目，常规体检完成以后。它就完成了。但是包含网关第二节点这时候是没有完成的。只有等待早餐。才算全部完成（这是和并行网关的区别）
zhaoliu完成:
在这里插入图片描述

当ljs完成早餐审批时。则全部包含网关节点完成
在这里插入图片描述

7、activiti与spring整合开发

1、pom.xml
2、activiti-spring.xml(名称不固定)
3、编码实现

1、创建maven工程
引入maven坐标

  <properties>
        <slf4j.version>1.6.6</slf4j.version>
        <log4j.version>1.2.12</log4j.version>
    </properties>

    <dependencies>

        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-engine</artifactId>
            <version>7.0.0.Beta1</version>
        </dependency>

        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-spring</artifactId>
            <version>7.0.0.Beta1</version>
        </dependency>

        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-bpmn-model</artifactId>
            <version>7.0.0.Beta1</version>
        </dependency>

        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-bpmn-converter</artifactId>
            <version>7.0.0.Beta1</version>
        </dependency>

        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-json-converter</artifactId>
            <version>7.0.0.Beta1</version>
        </dependency>

        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-bpmn-layout</artifactId>
            <version>7.0.0.Beta1</version>
        </dependency>

        <dependency>
            <groupId>org.activiti.cloud</groupId>
            <artifactId>activiti-cloud-services-api</artifactId>
            <version>7.0.0.Beta1</version>
        </dependency>
        <dependency>
            <groupId>aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.5.4</version>
        </dependency>


        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.40</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.0.7.RELEASE</version>
        </dependency>


        <!-- log start -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-nop</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <!-- log end -->

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
        </dependency>

        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>1.4</version>
        </dependency>
        <!--文件读写操作-->
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.0</version>
        </dependency>

    </dependencies>


    <repositories>
        <repository>
            <id>alfresco</id>
            <name>Activiti Releases</name>
            <url>https://artifacts.alfresco.com/nexus/content/repositories/activiti-releases/</url>
            <releases>
                <enabled>true</enabled>
            </releases>
        </repository>
    </repositories>

2、使用新的类整合
SpringProcessEngineConfiguration

创建包名
在这里插入图片描述
编码配置

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/tx
    http://www.springframework.org/schema/tx/spring-tx.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop.xsd
    ">

    <!-- 数据源 -->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <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="ljs"/>
        <property name="maxActive" value="3"/>
        <property name="maxIdle" value="1"/>
    </bean>

    <!-- 工作流引擎配置bean -->
    <bean id="processEngineConfiguration" class="org.activiti.spring.SpringProcessEngineConfiguration">
        <!-- 数据源 -->
        <property name="dataSource" ref="dataSource"/>
        <!-- 使用spring事务管理器 -->
        <property name="transactionManager" ref="transactionManager"/>
        <!-- 数据库策略 -->
        <property name="databaseSchemaUpdate" value="drop-create"/>
    </bean>


    <!-- 流程引擎 -->
    <bean id="processEngine" class="org.activiti.spring.ProcessEngineFactoryBean">
        <property name="processEngineConfiguration" ref="processEngineConfiguration"/>
    </bean>
    <!-- 资源服务service -->
    <bean id="repositoryService" factory-bean="processEngine"
          factory-method="getRepositoryService"/>
    <!-- 流程运行service -->
    <bean id="runtimeService" factory-bean="processEngine"
          factory-method="getRuntimeService"/>
    <!-- 任务管理service -->
    <bean id="taskService" factory-bean="processEngine"
          factory-method="getTaskService"/>
    <!-- 历史管理service -->
    <bean id="historyService" factory-bean="processEngine"
          factory-method="getHistoryService"/>

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

    <!-- 通知 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <!-- 传播行为 -->
            <tx:method name="save*" propagation="REQUIRED"/>
            <tx:method name="insert*" propagation="REQUIRED"/>
            <tx:method name="delete*" propagation="REQUIRED"/>
            <tx:method name="update*" propagation="REQUIRED"/>
            <tx:method name="find*" propagation="SUPPORTS" read-only="true"/>
            <tx:method name="get*" propagation="SUPPORTS" read-only="true"/>
        </tx:attributes>
    </tx:advice>

    <!-- 切面，根据具体项目修改切点配置 -->
    <aop:config proxy-target-class="true">
        <aop:advisor advice-ref="txAdvice"
                     pointcut="execution(* com.ljs.activiti.service.impl.*.*(..))"/>
    </aop:config>
</beans>

3、删库。建库

4、

在这里插入图片描述
25张表生成代表成功

1、通过加载activiti-spring.xml配置文件
2、通过引入SpringProcessEngineConfiguration的数据源，事务，数据库策略
3、获取processEngine对象
4、repositoryService依赖processEngine对象

#####activiti5.x和6.x版本是公司经常用的版本
activiti7的api和5,6有些区别
现在原从事开发工程师去开发了flowable，以后可能会火起来

activiti官方文档
在这里插入图片描述
activiti核心介绍

processRuntime
TaskRuntime
api都在这个activiti核心介绍里

8、activiti与springboot整合

1、pom.xml文件

 <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-spring-boot-starter</artifactId>
            <version>7.0.0.Beta2</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.27</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

2、SecurityUtil

package com.example.activiti3;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.context.SecurityContextImpl;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.stereotype.Component;

import java.util.Collection;

@Component
public class SecurityUtil {
    private Logger logger = LoggerFactory.getLogger(SecurityUtil.class);

    @Autowired
    @Qualifier("myUserDetailsService")
    private UserDetailsService userDetailsService;

    public void logInAs(String username) {

        UserDetails user = userDetailsService.loadUserByUsername(username);
        if (user == null) {
            throw new IllegalStateException("User " + username + " doesn't exist, please provide a valid user");
        }
        logger.info("> Logged in as: " + username);
        SecurityContextHolder.setContext(new SecurityContextImpl(new Authentication() {
            @Override
            public Collection<? extends GrantedAuthority> getAuthorities() {
                return user.getAuthorities();
            }

            @Override
            public Object getCredentials() {
                return user.getPassword();
            }

            @Override
            public Object getDetails() {
                return user;
            }

            @Override
            public Object getPrincipal() {
                return user;
            }

            @Override
            public boolean isAuthenticated() {
                return true;
            }

            @Override
            public void setAuthenticated(boolean isAuthenticated) throws IllegalArgumentException {

            }

            @Override
            public String getName() {
                return user.getUsername();
            }
        }));
        org.activiti.engine.impl.identity.Authentication.setAuthenticatedUserId(username);
    }
}

3、DemoApplicationConfiguration

package com.example.activiti3;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

@Configuration
public class DemoApplicationConfiguration {
    private Logger logger = LoggerFactory.getLogger(DemoApplicationConfiguration.class);

    @Bean
    public UserDetailsService myUserDetailsService() {

        InMemoryUserDetailsManager inMemoryUserDetailsManager = new InMemoryUserDetailsManager();

        String[][] usersGroupsAndRoles = {
                {"salaboy", "password", "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"},
                {"ryandawsonuk", "password", "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"},
                {"erdemedeiros", "password", "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"},
                {"other", "password", "ROLE_ACTIVITI_USER", "GROUP_otherTeam"},
                {"system", "password", "ROLE_ACTIVITI_USER"},
                {"admin", "password", "ROLE_ACTIVITI_ADMIN"},
        };

        for (String[] user : usersGroupsAndRoles) {
            List<String> authoritiesStrings = Arrays.asList(Arrays.copyOfRange(user, 2, user.length));
            logger.info("> Registering new user: " + user[0] + " with the following Authorities[" + authoritiesStrings + "]");
            inMemoryUserDetailsManager.createUser(new User(user[0], passwordEncoder().encode(user[1]),
                    authoritiesStrings.stream().map(s -> new SimpleGrantedAuthority(s)).collect(Collectors.toList())));
        }


        return inMemoryUserDetailsManager;
    }


    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

4、application.yml

server:
  port: 8085
spring:
  application:
    name: spring-activiti
  datasource:
    url: jdbc:mysql://localhost:3306/activiti?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT&nullCatalogMeansCurrent=true
    username: root
    password: ljs
    driver-class-name: com.mysql.jdbc.Driver

###整合springboot必须将bpmn文件放在这个目录下
在这里插入图片描述

8.1,8.2 流程定义部署，查询

5、springboot整合junit

package com.example.activiti3;

import org.activiti.api.process.model.ProcessDefinition;
import org.activiti.api.process.runtime.ProcessRuntime;
import org.activiti.api.runtime.shared.query.Page;
import org.activiti.api.runtime.shared.query.Pageable;
import org.activiti.api.task.runtime.TaskRuntime;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@SpringBootTest
@RunWith(SpringRunner.class)
public class Activiti3ApplicationTests {

    @Autowired
    private ProcessRuntime processRuntime; // 流程定义相关操作

    @Autowired
    private TaskRuntime taskRuntime; // 任务相关操作

    @Autowired
    private SecurityUtil securityUtil;

    @Test
    public void contextLoads() {
        // 分页查询流程定义信息（springboot启动时，已经部署了）
        Page<ProcessDefinition> processDefinitionPage = processRuntime.processDefinitions(Pageable.of(0, 10));
        System.out.println(processDefinitionPage.getTotalItems()); // 流程定义个数
        // 得到当前流程定义信息
        for(ProcessDefinition processDefinition :processDefinitionPage.getContent()){
            System.out.println("流程定义"+processDefinition);
        }

    }

}

执行测试类报错
org.springframework.security.authentication.AuthenticationCredentialsNotFoundException: An Authentication object was not found in the SecurityContext

在这里插入图片描述
说明，没有权限
需要设置。SecurityUtil里设置的用户名。才可以登录

在这里插入图片描述

一看，居然没有历史记录表

所以这个问题解决需要在yml里配置这个
在这里插入图片描述
再重新删库，建库

这样就出来了

8.3、流程实例启动

  @Test
    public void startInstance(){
        securityUtil.logInAs("salaboy");
        ProcessInstance instance = processRuntime.start(ProcessPayloadBuilder.start().withProcessDefinitionKey("myProcess_1").build());
        System.out.println("流程定义key："+instance.getProcessDefinitionKey());
    }

在这里插入图片描述

8.4，流程实例任务分页查询

   @Test
    public void completeInstance(){
        securityUtil.logInAs("ryandawsonuk");
        Page<Task> tasks = taskRuntime.tasks(Pageable.of(0, 10));
        if (tasks.getTotalItems()>0){
            // 有任务
            for (Task task:tasks.getContent()){
                System.out.println("任务信息:"+task);
            }
        }
    }

ryandawsonuk是我流程定义bpmn图里first节点指定的执行人

在这里插入图片描述

8.5、流程实例任务拾取，完成

  @Test
    public void completeInstance(){
        securityUtil.logInAs("ryandawsonuk");
        Page<Task> tasks = taskRuntime.tasks(Pageable.of(0, 10));
        if (tasks.getTotalItems()>0){
            // 有任务
            for (Task task:tasks.getContent()){
                System.out.println("任务信息:"+task);

                //如果是组任务。先拾取任务
               // taskRuntime.claim(TaskPayloadBuilder.claim().withTaskId(task.getId()).build());
                taskRuntime.complete(TaskPayloadBuilder.complete().withTaskId(task.getId()).build());
            }
        }

        // 再次查询任务
        tasks = taskRuntime.tasks(Pageable.of(0, 10));
        if (tasks.getTotalItems()>0){
            for (Task task:tasks.getContent()){
                System.out.println("任务信息:"+task);
            }
        }
    }

在这里插入图片描述

9、activiti+springboot+springmvc

1、先启动流程定义。实例

2、完成实例

package com.example.activiti3.controller;

import com.example.activiti3.SecurityUtil;
import org.activiti.api.process.runtime.ProcessRuntime;
import org.activiti.api.runtime.shared.query.Page;
import org.activiti.api.runtime.shared.query.Pageable;
import org.activiti.api.task.model.Task;
import org.activiti.api.task.model.builders.TaskPayloadBuilder;
import org.activiti.api.task.runtime.TaskRuntime;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TestController {
    @Autowired
    private ProcessRuntime processRuntime;

    @Autowired
    private TaskRuntime taskRuntime;

    @Autowired
    private SecurityUtil securityUtil;

    @RequestMapping(value = "/test",method = RequestMethod.GET)
    public void testComplete(){
        securityUtil.logInAs("ryandawsonuk");
        Page<Task> tasks = taskRuntime.tasks(Pageable.of(0, 10));
        if (tasks.getTotalItems()>0){
            // 有任务
            for (Task task:tasks.getContent()){
                System.out.println("任务信息:"+task);

                //如果是组任务。先拾取任务
                // taskRuntime.claim(TaskPayloadBuilder.claim().withTaskId(task.getId()).build());
                taskRuntime.complete(TaskPayloadBuilder.complete().withTaskId(task.getId()).build());
            }
        }

        // 再次查询任务
        tasks = taskRuntime.tasks(Pageable.of(0, 10));
        if (tasks.getTotalItems()>0){
            for (Task task:tasks.getContent()){
                System.out.println("任务信息:"+task);
            }
        }
    }
}

启动以后，会进入security登陆界面
在这里插入图片描述
用ryandawsonuk password登陆即可

再看控制台

第一个任务执行完成。再刷新数据库

到了第二个任务
整个activiti学习结束

厚学

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
工作流下篇

工作流下篇1、组任务代码篇1、组任务代码篇1、查询组任务package com.ljs.activity.zurenwu;import org.activiti.engine.ProcessEngine;import org.activiti.engine.ProcessEngines;import org.activiti.engine.TaskService;import org.activiti.engine.task.Task;import java.util.List;/*
复制链接

扫一扫