activiti入门学习二

二、单机演示Demo

　12、使用UEL表达式动态增加流程处理人

从新创建一个流程，使其Assignee变成表达式的。然后从新创建流程。

* @Description: 启动流程实例，动态设置assignee
 * @date: 2019/6/23 20:28
 */
public class AssigneeUel {
    public static void main(String[] args) {
    //创建ProcessEngine 对象
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
 
    //得到RuntimeService
    RuntimeService runtimeService = processEngine.getRuntimeService();
    Map<String,Object> map =new HashMap<String,Object>();
        map.put("assignee","张三");
        map.put("assignee1","李四");
        map.put("assignee2","王五");
        //启动流程实例，同时定义assignee的值
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("holiday2", map);
        System.out.println(processEngine.getName());
    }
}

然后在执行流程

public class ActivitiCompleteTask {
    public static void main(String[] args) {
        //创建ProcessEngine 对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //获取TaskService对象
        TaskService taskService = processEngine.getTaskService();
 
        Task task = taskService.createTaskQuery()
                .processDefinitionKey("holiday2")
                .taskAssignee("zhangsan")
                .singleResult();
 
        taskService.complete(task.getId());
    }
}

13、流程变量

• 13.1什么是流程变量
  流程变量在 activiti 中是一个非常重要的角色，流程运转有时需要靠流程变量，业务系统和 activiti结合时少不了流程变量，流程变量就是 activiti 在管理工作流时根据管理需要而设置的变量。比如在请假流程流转时如果请假天数大于 3 天则由总经理审核，否则由人事直接审核，请假天数就可以设置为流程变量，在流程流转时使用。
• 13.2流程变量的类型
  

注意：如果使用的是pojo，必须实现serializable，需要生成serialVersionUID。

• 13.3流程变量的作用域
  流程变量的作用域默认是一个流程实例(processInstance)，也可以是一个execution)，这三个作用域流程实例的范围最大，可以称为global变量，任一个任务和一个执行实例范围，范围没有流程实例大，称为local变量。

• 13.4学习使用流程变量

  • 流程绘制
    
    
    
    

• POJO

/**
 *   请假单(zhangsan) 部门经理（lisi），总经理(wanwu) 人事(zhaoliu)
 * 请假实体类:
 *    注意POJO类型，一定要实现Serializable接口，否则在存储这个pojo时就会报异常
 */
public class Holiday implements Serializable {
    private Integer id;
    private String holidayName;//申请人的名字
    private Date beginDate;//开始时间
    private Date endDate;//结束日期
    private Float num;//请假天数
    private String reason;//事由
    private String type;//请假类型

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getHolidayName() {
        return holidayName;
    }

    public void setHolidayName(String holidayName) {
        this.holidayName = holidayName;
    }

    public Date getBeginDate() {
        return beginDate;
    }

    public void setBeginDate(Date beginDate) {
        this.beginDate = beginDate;
    }

    public Date getEndDate() {
        return endDate;
    }

    public void setEndDate(Date endDate) {
        this.endDate = endDate;
    }

    public Float getNum() {
        return num;
    }

    public void setNum(Float num) {
        this.num = num;
    }

    public String getReason() {
        return reason;
    }

    public void setReason(String reason) {
        this.reason = reason;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }
}

• 流程部署

 public static void main1(String[] args) {
        //1.得到ProcessEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

        //2.得到RepositoryService对象
        RepositoryService repositoryService = processEngine.getRepositoryService();

        //3.部署
        Deployment deploy = repositoryService.createDeployment()
                .addClasspathResource("diagram/holiday4.bpmn")
                .addClasspathResource("diagram/holiday4.png")
                .name("请假流程-流程变量")
                .deploy();
        System.out.println(deploy.getId());
        System.out.println(deploy.getName());
    }

• 启动流程，设置流程变量的值

 //启动流程实例，同时还要设置流程变量的值
    // 影响的表 act_ge_bytearray，act_ru_variable
    public static void main(String[] args) {
        //1.得到ProcessEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //2.得到RuntimeService
        RuntimeService runtimeService =  processEngine.getRuntimeService();
        //3.流程定义的key
        String key = "myProcess_1";
        Map<String ,Object> map = new HashMap<>();
        Holiday holiday = new Holiday();
        //定义的变量是holiday.num
        holiday.setNum(1F);
        map.put("holiday",holiday);
        //4.启动流程实例，并且设置流程变量的值
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(key, map);
        //5.输出实例信息
        System.out.println(processInstance.getName());
        System.out.println(processInstance.getProcessDefinitionId());
    }

• 执行流程

//依次执行，当部门经理审批完(lisi)会判断流程的请假天数，1天就是人事经理存档(zhaoliu)
    public static void main3(String[] args) {
        //1.得到ProcessEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //2.得到TaskService
        TaskService taskService = processEngine.getTaskService();
        //3.查询当前用户是否有任务
        String key = "myProcess_1";
        Task task = taskService.createTaskQuery().processDefinitionKey(key)
                .taskAssignee("zhaoliu").singleResult();
        //4.判断task!=null,说明当前用户有任务
        if(task!=null){
            taskService.complete(task.getId());
            System.out.println("任务执行完毕");
        }
    }

• 任务办理的时候设置流程变量

public static void main(String[] args) {
        //1.得到ProcessEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //2.得到TaskService
        TaskService taskService = processEngine.getTaskService();

        //3.查询当前用户是否有任务
        String key = "myProcess_1";
        Task task = taskService.createTaskQuery().processDefinitionKey(key)
                .taskAssignee("zhangsan").singleResult();
        //初始化一些参数
        Map<String ,Object> map = new HashMap<>();
        Holiday holiday = new Holiday();
        holiday.setNum(5F);
        map.put("holiday",holiday);
        //4.判断task!=null,说明当前用户有任务
        if(task!=null){
            //完成任务时，设置流程变量的值
            taskService.complete(task.getId(),map);
            System.out.println("任务执行完毕");
        }
    }

• 通过当前流程实例设置

    public static void main(String[] args) {
        //1.得到ProcessEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //2.得到RuntimeService
        RuntimeService runtimeService =  processEngine.getRuntimeService();
        Holiday holiday = new Holiday();
        holiday.setNum(5F);
        //4.通过实例id,来设置流程变量
        //第一个参数：流程实例的id
        //第二个参数：流程变量名
        //第三个变量：流程变量名，所对应的值
        runtimeService.setVariable("2501","holiday",holiday);
    }

14、组任务
14.1什么是组任务
给任务设置多个候选人，可以从候选人中选择参与者来完成任务。
14.2组任务学习

• 绘制流程
  在上面的基础上修改就OK了
  

• 流程部署，启动实例，填写请假单

//1.流程部署   
public static void main(String[] args) {
        //1.创建ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //2.得到RepositoryService实例
        RepositoryService repositoryService = processEngine.getRepositoryService();
        //3.进行部署
        Deployment deployment = repositoryService.createDeployment()
                .addClasspathResource("diagram/holiday5.bpmn")  //添加bpmn资源
                //这个不是必须的
                // .addClasspathResource("diagram/holiday5.png")
                .name("请假申请单流程")
                .deploy();
        //4.输出部署的一些信息
        System.out.println(deployment.getName());
        System.out.println(deployment.getId());
    }

//2.启动实例
    public static void main(String[] args) {
            //1.得到ProcessEngine对象
            ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
            //2.得到RunService对象
            RuntimeService runtimeService = processEngine.getRuntimeService();
            //3.创建流程实例  流程定义的key需要知道 holiday
            ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("myProcess_1");
            //4.输出实例的相关信息
            System.out.println("流程定义ID"+processInstance.getProcessDefinitionId());//holiday:1:4
            System.out.println("流程实例ID"+processInstance.getId());//2501
    }
       //3.填写请假单的任务要执行完成
 public static void main(String[] args) {
        //1.得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //2.得到TaskService对象
        TaskService taskService = processEngine.getTaskService();
        //3.查询当前用户的任务
        Task task = taskService.createTaskQuery()
                .processDefinitionKey("myProcess_1")
                .taskAssignee("xiaozhang")
                .singleResult();
        //4.处理任务,结合当前用户任务列表的查询操作的话,任务ID:task.getId()
        if(task!=null){
            taskService.complete(task.getId());
            System.out.println("用户任务执行完毕...");
        }
        //5.输出任务的id
        System.out.println(task.getId());
    }

• 查询候用户组任务，将候选者转换成真正任务的负责人

  //4.查询候选用户的组任务
    public static void main(String[] args) {
        //1.得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //2.得到TaskService对象
        TaskService taskService = processEngine.getTaskService();
        //3.设置一些参数，流程定义的key,候选用户
        String key = "myProcess_1";
        String candidate_users="zhangsan";
        //4.执行查询
        List<Task> list = taskService.createTaskQuery()
                .processDefinitionKey(key)
                .taskCandidateUser(candidate_users)//设置候选用户
                .list();
        //5.输出
        for(Task task :list){
            System.out.println(task.getProcessInstanceId());
            System.out.println(task.getId());
            System.out.println(task.getName());
            System.out.println(task.getAssignee());//为null，说明当前的zhangsan只是一个候选人，并不是任务的执行人
        }
    }

    //抽取任务的过程就是将候选用户转化为真正任务的负责人（让任务的assignee有值）
   public static void main(String[] args) {
        //1.得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //2.得到TaskService对象
        TaskService taskService = processEngine.getTaskService();
        //3.设置一些参数，流程定义的key,候选用户
        String key = "myProcess_1";
        String candidate_users="zhangsan";
        //4.执行查询
        Task task = taskService.createTaskQuery()
                .processDefinitionKey(key)
                .taskCandidateUser(candidate_users)//设置候选用户
                .singleResult();
        if(task!=null){
            taskService.claim(task.getId(),candidate_users);//第一个参数任务ID,第二个参数为具体的候选用户名
            System.out.println("任务拾取完毕!");
        }
    }
    //6.当前的用户查询自己的任务
    public static void main(String[] args) {
        //1.得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //2.得到TaskService对象
        TaskService taskService = processEngine.getTaskService();
        //3.设置一些参数，流程定义的key,用户
        String key = "myProcess_1";
        String assignee="zhangsan";
        //4.执行查询
        List<Task> list = taskService.createTaskQuery()
                .processDefinitionKey(key)
                .taskAssignee(assignee)  //设置任务的负责人
                .list();
        //5.输出
        for(Task task :list){
            System.out.println(task.getProcessInstanceId());
            System.out.println(task.getId());
            System.out.println(task.getName());
            System.out.println(task.getAssignee());//任务的执行人
        }
    }
    //7.当前用户完成自己的任务
    public static void main(String[] args) {
        //1.得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //2.得到TaskService对象
        TaskService taskService = processEngine.getTaskService();
        //3.设置一些参数，流程定义的key,用户
        String key = "myProcess_1";
        String assignee="zhangsan";
        //4.执行查询
        Task task = taskService.createTaskQuery()
                .processDefinitionKey(key)
                .taskAssignee(assignee)  //设置任务的负责人
                .singleResult();
        //5.执行当前的任务
        if(task!=null){
            taskService.complete(task.getId());
            System.out.println("任务执行完毕!");
        }
    }

• 任务转交

    //步骤1-2-3-4-5  当前人不想做这个任务转交给别人
    //8.任务交接，前提要保证当前用户是这个任务的负责人，这时候他才可以有权限去将任务交接给其他候选人
    public static void main9(String[] args) {
        //1.得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //2.得到TaskService对象
        TaskService taskService = processEngine.getTaskService();
        //3.设置一些参数，流程定义的key,用户
        String key = "myProcess_1";
        String assignee="zhangsan";
        //4.执行查询
        Task task = taskService.createTaskQuery()
                .processDefinitionKey(key)
                .taskAssignee(assignee)  //设置任务的负责人
                .singleResult();
        //5.判断是否有这个任务
        if(task!=null){
            taskService.setAssignee(task.getId(),"lisi");//交接任务为lisi  ,交接任务就是一个候选人拾取用户的过程
            System.out.println("交接任务完成~!");
        }
    }

• 归还组任务

 public static void main(String[] args) {
        //1.得到ProcessEngine对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //2.得到TaskService对象
        TaskService taskService = processEngine.getTaskService();
        // 当前待办任务
        String taskId = "6004";
        // 任务负责人
        String userId = "zhangsan";
    // 校验userId是否是taskId的负责人，如果是负责人才可以归还组任务
        Task task = taskService.createTaskQuery().taskId(taskId)
                .taskAssignee(userId).singleResult();
        if (task != null) {
    // 如果设置为null，归还组任务,该任务没有负责人
            taskService.setAssignee(taskId, null);
        }
    }