activiti 使用（任务委派、转办、会签、挂起与激活，（反）签收与委托，回退上一步）

最新推荐文章于 2024-02-05 21:09:09 发布
最新推荐文章于 2024-02-05 21:09:09 发布
阅读量4.2k 收藏 23
点赞数
分类专栏： activiti 文章标签： activiti
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39750658/article/details/103243676
版权

任务委派

任务委派只是任务人将当前的任务交给接收人进行审批，完成任务后又重新回到任务人身上。委派人查询任务与完成任务与正常的有区别。

 /**
     * 指定代办人
     */
    @Test
    public void delegateTask() {
        String taskId = "2511";
        String loginName = "0003";
        activitiService.delegateTask(taskId, loginName);
    }

    /**
     * 正在运行的任务表中被委派人办理任务后任务会回到委派人 ，历史任务表中也一样,只是多了一个人进行审批
     */
    @Test
    public void resolveTask() {
        String taskId = "2511";
        Map<String,Object> map = new HashMap<>();
        activitiService.resolveTask(taskId ,map);
    }

    @Test
    public void getTaskByOwner() {
        String processDefinitionKey = "delegateTask";
        String owner = "0003";
        activitiService.getTaskByOwner(processDefinitionKey, owner);
    }


 /**
     * 根据任务拥有者查询任务
     * 
     * @param processDefinitionKey
     * @param owner
     * @return
     */
    boolean getTaskByOwner(String processDefinitionKey, String owner);

    /**
     * 委派人完成任务
     * 
     * @param taskId
     * @param map
     * @return
     */
    boolean resolveTask(String taskId, Map<String, Object> map);

 @Override
    public boolean delegateTask(String taskId, String loginName) {
        taskService.delegateTask(taskId, loginName);
        return true;
    }

    @Override
    public boolean getTaskByOwner(String processDefinitionKey, String owner) {
        TaskQuery taskQuery = taskService.createTaskQuery();
        // 任务列表
        List<Task> list = taskQuery.processDefinitionKey(processDefinitionKey).taskOwner(owner).list();// 指定办理人
        for (Task task : list) {
            LOGGER.info("任务处理人【{}】", task.getAssignee());
            LOGGER.info("流程名称【{}】", task.getName());
            LOGGER.info("任务id【{}】", task.getId());
            LOGGER.info("流程定义id【{}】", task.getProcessDefinitionId());
            LOGGER.info("执行对象id【{}】", task.getExecutionId());
            LOGGER.info("任务拥有者【{}】", task.getOwner());
        }
        return true;
    }

    @Override
    public boolean resolveTask(String taskId, Map<String, Object> map) {
        taskService.resolveTask(taskId, map);
        return true;
    }

任务转办

任务转办是把任务交给别人进行处理

 /**
     * 任务转办,将任务交给其他人处理
     */
    @Test
    public void turnTask() {
        String taskId =  "7511";
        String assignee = "0003";
        activitiService.trunTask(taskId,assignee);
    }

 @Override
    public boolean trunTask(String taskId, String assignee) {
        taskService.setAssignee(taskId, assignee);
        return true;
    }

会签

**会签：**当任务有多人审批，但只要部分人审批就可以通过，类似于投票，十个人中五个人投票通过即可通过，那么久需要使用会签
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

 @Test
    public void startActiviti() {
        String processDefinitionKey = "counterSign";
        String orgCode = "070067801";
        String[] assigneeList = {"0001","0002","0003"};
        // 设置变量
        HashMap<String, Object> map = new HashMap<>();
        map.put("createLoginName", "0003");
        map.put("orgCode", orgCode);
      //必须是List
        map.put("assigneeList", Arrays.asList(assigneeList));
        //map.put("signCount", 0);
        activitiService.startActivitiAndFinsh(processDefinitionKey, map);

    }
  @Test
    public void getValaier() {
        String taskId = "35044";
        Map<String, Object> variable = activitiService.getVariableByTaskId(taskId , false);
        System.out.println("nrOfInstances 实例总数："+variable.get("nrOfInstances"));
        System.out.println("nrOfActiveInstances  当前还没有完成的实例个数："+variable.get("nrOfActiveInstances"));
        System.out.println("nrOfCompletedInstances 当前完成的实例个数数：："+variable.get("nrOfCompletedInstances"));
    }

流程挂起与激活

 /**
     * 挂起流程实例
     *
     * @param processInstanceId
     * @return
     */
    boolean suspendProcessInstanceById(String processInstanceId);

    /**
     * 删除流程实例
     *
     * @param processInstanceId
     * @param reason
     * @return
     */
    boolean deleteProcessInstance(String processInstanceId, String reason);

    /**
     * 激活流程实例（激活挂起的流程实例）
     *
     * @param processInstanceId
     * @return
     */
    boolean activateProcessInstanceById(String processInstanceId);

    /**
     * 挂起流程定义
     *
     * @param processDefineKey
     * @param cascade
     * @return
     */
    boolean suspendProcessDefineKey(String processDefineKey, boolean cascade);

    /**
     * 激活流程定义
     *
     * @param processDefineKey
     * @param cascade
     * @return
     */
    boolean activateProcessDefinitionByKey(String processDefineKey, boolean cascade);

 @Override
    public boolean suspendProcessInstanceById(String processInstanceId) {
        runtimeService.suspendProcessInstanceById(processInstanceId);
        return true;
    }

    @Override
    public boolean activateProcessInstanceById(String processInstanceId) {
        runtimeService.activateProcessInstanceById(processInstanceId);
        return true;
    }

    @Override
    public boolean suspendProcessDefineKey(String processDefineKey, boolean cascade) {
        repositoryService.suspendProcessDefinitionByKey(processDefineKey,cascade,new Date());
        return true;
    }

    @Override
    public boolean activateProcessDefinitionByKey(String processDefineKey,boolean cascade){
        repositoryService.activateProcessDefinitionByKey(processDefineKey,cascade,new Date());
        return true;

    }

github地址(转载)
转自： https://blog.csdn.net/qq_32759985/article/details/80721130

activiti 中的签收与委托

activiti中关于TASK的数据库表
在这里插入图片描述
其中有两个字段：OWNER_，ASSIGNEE_

这两个字段的意义是：

  1. ASSIGNEE_（受理人）：task任务的受理人，就是执行TASK的人，这个又分两种情况（有值，NULL）

    1）. 有值的情况：XML流程里面定义的受理人，TASK会直接填入这个人；

    2）. NULL：XML没有指定受理人或者只指定了候选组；

没有值的时候，可以使用签收功能去指定受理人，就是候选组里面谁签收谁就成了受理人：

Task task=taskService.createTaskQuery().singleResult();
//签收
taskService.claim(task.getId(), "billy");
logger.info(taskService.createTaskQuery().singleResult().getAssignee());
//结果：billy

/*反签收*/
taskService.claim(task.getId(), null);
// 或者
taskService.unclaim(task.getId());
/*反签收*/
  1. OWNER_（委托人）：受理人委托其他人操作该TASK的时候，受理人就成了委托人OWNER_，其他人就成了受理人ASSIGNEE_
Task task=taskService.createTaskQuery().singleResult();
//委托
taskService.delegateTask(task.getId(), "cc");
logger.info(taskService.createTaskQuery().singleResult().getOwner());
logger.info(taskService.createTaskQuery().singleResult().getAssignee());
//结果：owner是Billy，assignee是cc

任务回退到上一步

package com.studio.util;
 
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
 
import org.activiti.engine.HistoryService;
import org.activiti.engine.IdentityService;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.RepositoryService;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.activiti.engine.history.HistoricTaskInstance;
import org.activiti.engine.identity.Group;
import org.activiti.engine.identity.User;
import org.activiti.engine.impl.persistence.entity.ProcessDefinitionEntity;
import org.activiti.engine.impl.pvm.PvmActivity;
import org.activiti.engine.impl.pvm.PvmTransition;
import org.activiti.engine.impl.pvm.process.ActivityImpl;
import org.activiti.engine.impl.pvm.process.ProcessDefinitionImpl;
import org.activiti.engine.impl.pvm.process.TransitionImpl;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
 
public class ActivitiUtil {
	private static ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
	private static  IdentityService  identityService = processEngine.getIdentityService();
	private static RuntimeService runtimeService = processEngine.getRuntimeService();
        private static TaskService taskService = processEngine.getTaskService();
        private static RepositoryService repositoryService = processEngine.getRepositoryService();
        private static HistoryService historyService = processEngine.getHistoryService();
	public static void TaskRollBack(String taskId){
	    try {
            Map<String, Object> variables;
            // 取得当前任务
            HistoricTaskInstance currTask = historyService
                    .createHistoricTaskInstanceQuery().taskId(taskId)
                    .singleResult();
            // 取得流程实例
            ProcessInstance instance = runtimeService
                    .createProcessInstanceQuery()
                    .processInstanceId(currTask.getProcessInstanceId())
                    .singleResult();
            if (instance == null) {
               
                //流程结束
            }
            variables = instance.getProcessVariables();
            // 取得流程定义
            ProcessDefinitionEntity definition = (ProcessDefinitionEntity) (processEngine.getRepositoryService().getProcessDefinition(currTask
                            .getProcessDefinitionId()));
           
            if (definition == null) {
               
                //log.error("流程定义未找到");
                return ;
            }
            // 取得上一步活动
            ActivityImpl currActivity = ((ProcessDefinitionImpl) definition)
                    .findActivity(currTask.getTaskDefinitionKey());
            List<PvmTransition> nextTransitionList = currActivity
                    .getIncomingTransitions();
            // 清除当前活动的出口
            List<PvmTransition> oriPvmTransitionList = new ArrayList<PvmTransition>();
            List<PvmTransition> pvmTransitionList = currActivity
                    .getOutgoingTransitions();
            for (PvmTransition pvmTransition : pvmTransitionList) {
                oriPvmTransitionList.add(pvmTransition);
            }
            pvmTransitionList.clear();
 
            // 建立新出口
            List<TransitionImpl> newTransitions = new ArrayList<TransitionImpl>();
            for (PvmTransition nextTransition : nextTransitionList) {
                PvmActivity nextActivity = nextTransition.getSource();
                ActivityImpl nextActivityImpl = ((ProcessDefinitionImpl) definition)
                        .findActivity(nextActivity.getId());
                TransitionImpl newTransition = currActivity
                        .createOutgoingTransition();
                newTransition.setDestination(nextActivityImpl);
                newTransitions.add(newTransition);
            }
            // 完成任务
            List<Task> tasks = taskService.createTaskQuery()
                    .processInstanceId(instance.getId())
                    .taskDefinitionKey(currTask.getTaskDefinitionKey()).list();
            for (Task task : tasks) {
                taskService.complete(task.getId(), variables);
                historyService.deleteHistoricTaskInstance(task.getId());
            }
            // 恢复方向
            for (TransitionImpl transitionImpl : newTransitions) {
                currActivity.getOutgoingTransitions().remove(transitionImpl);
            }
            for (PvmTransition pvmTransition : oriPvmTransitionList) {
                pvmTransitionList.add(pvmTransition);
            }
 
          
            return ;
        } catch (Exception e) {
           
            return ;
        }
	}
}
路过了全世界
关注
  • 0
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Activiti多实例任务实现会签
12-09
Activiti多实例任务实现会签.
activiti7(四)：activiti开发之实用的功能
no problem的博客
04-27 4594
在helloworld的基础上，拓展了activiti7的一些实用功能和技巧，一些能在实际生产中使用的技巧。。。
【问题篇】activiti工作流转办并处理备注问题
weixin_56995925的博客
02-05 433
activiti工作流转办并处理备注问题
Activiti工作流的流程通过、驳回、转办、中止、挂起等核心操作封装
玄冰修的博客
05-25 1万+
package com.manager.base.utils; import com.manager.base.exceptions.AppException; import org.activiti.engine.*; import org.activiti.engine.history.HistoricActivityInstance; import org.activiti.engine...
Activiti之流程通过、驳回、会签、转办、中止、挂起等核心操作封装(Activiti5.9) ...
10-25 2558
转：http://blog.csdn.net/rosten/article/details/38300267   package com.famousPro.process.service.impl; import java.util.ArrayList; import java.util.HashMap; import ...
Activiti审批流
weixin_44383484的博客
10-27 2856
Activiti审批流
activiti 委派和转办
热门推荐
qi95719的博客
03-26 1万+
委派 委派：是将任务节点分给其他人处理，等其他人处理好之后，委派任务会自动回到委派人的任务中  将hr的任务进行委派： taskService.delegateTask(taskId, userId); // taskId 任务id; userId:被委派人id 被委派人办理任务后： taskService.resolveTask(taskId,vari
activiti6 转办
weixin_45818332的博客
01-16 334
【代码】activiti6 转办。
Activiti7 任务办理人、委派、转办、持有人、候选人、候选人组、审批意见【十三】
做Java整整10年，目前是教别人写代码，嘿嘿
07-28 2196
Assignee指定办理人模式：即设置办理人，就是设置Assignee。在ACT_HI_TASKINST和ACT_RU_TASK会产生数据，这两个表里面的Assignee_字段就是设置的办理人姓名或者对象的ID。当任务可以被多人处理的时候，可能会发生并发，所以添加候选人，让候选人去获取任务，之后就变成这个候选人的任务了。当发起人zs完成自己的审批后到底下一个任务节点经理审批时，此时的ASSIGNEE_字段是空的。：指当前任务的执行人，他此时持有该任务。：代表有权限对任务进行操作的人。
Activiti实战(六)：回退与转办
qq_33589648的博客
11-26 1221
本文就水一水了，谁让人家写的好，哈哈，勿喷 回退可以参考这位大佬的文章 ativiti6.0 流程节点自由跳转实现、拒绝/不同意/返回上一节点、流程撤回、跳转、回退等操作（通用实现，亲测可用） - 掘金 亲测可用 转办：a用户转办给b用户后assignee变成了b，a相关数据就无法查询到了 //需要转办的用户 taskService.setAssignee(taskId,"xc"); ...
Activiti（新手）工作流对用户任务签收办理操作
yuanliang4521的专栏
03-30 2563
首先是我们已经对Activiti流程的开启有了了解之后，在进行下文 流程中用到最多的就是用户任务了，包括谁办理，什么时候办理，办理结果是什么，办理历史等等   下文先介绍下用户任务的办理相关操作   用户任务分类： 分为4中状态：未签收/待办理、已签收/办理中、运行中/办理中、已完成/已办结   首先，我们要了解下 TaskService 这个服务的作用： 1、查询分配给用户...
activiti学习-使用activiti多实例任务实现会签
06-23
activiti学习-使用activiti多实例任务实现会签
activiti取会签人员
11-02
在用activiti的时候经常遇到取会签人员的问题，这个文档解决怎么获取会签人员。
activiti 会签投票统计
03-01
activiti会签投票统计；用来统计会签过程中各个参与人的投票结果，以及设置会签任务的结束条件；
特别响、非常近——BPMN2新规范与Activiti5
03-02
上世纪九十年代以后，随着WfMC联盟的成立，BPM市场群雄逐鹿如火如荼，工作流技术得到了突飞猛进的发展，其中IBM、Oracle等大型软件厂商在工作流领域各扯大旗割据一方。2011年BPMN2.0新规范的发布为各工作流产品互容...
node-v10.22.0-darwin-x64.tar.xz
最新发布
05-03
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
基于JAVA的物流管理系统的源码设计与实现.zip
05-03
毕业设计-->物流管理系统的设计与实现（Java版本） 采用Struts2+hibernate+Oracle10g+Tomcat 涉及车辆管理，配送点管理，运输方式管理，订单管理，员工管理，用户管理，部门管理，权限管理，角色管理等基础管理功能。
基于VB+access实现的成绩分析统计系统(论文+源代码).zip
05-03
基于VB+access实现的成绩分析统计系统(论文+源代码) 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
node-v10.14.2-linux-x64.tar.xz
05-03
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
activiti回退
07-27
在Activiti中，可以通过使用历史任务查询来实现任务的回退操作。以下是一种可能的实现方式： 1. 首先，使用历史任务查询来获取当前任务的历史记录。你可以使用`HistoricTaskInstanceQuery`类的方法来查询特定任务的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值