Activiti 拓展用户行为类实现人员节点多元化

最新推荐文章于 2023-04-03 16:44:01 发布
最新推荐文章于 2023-04-03 16:44:01 发布
阅读量1k 收藏 1
点赞数
分类专栏： activiti 文章标签： activiti人员节点
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/isyoungboy/article/details/89211252
版权

用户行为类做了些什么？

Activiti 用户行为类支持使用用户id，组织id和表达式指定任务节点的处理人员，使用表达式可以指定调用Spring容器中某个对象的某一个方法指定人员，有跳过设置还可以跳过任务节点

用户行为类拓展点

  • 添加更加强大的groovy脚本支持
  • 添加处理人员信息拓展，使其支持动态脚本指定，方便接入自己的用户系统
  • 添加候选人处理逻辑在候选人丢失的情况下指定给管理员

流程执行顺序

流程启动 -> 执行开始节点行为类 -> 执行第一个任务行为类 -> 完成节点

用户任务的三种监听器

  • TASK_ASSIGNED 任务被指派 发生在TaskEntityManagerImpl中，此时任务已经入库
  • TASK_CREATED 任务被创建 发生在UserTaskActivityBehavior中，此时任务人员节点已经设置完毕
  • TASK_COMPLETED 任务被完成 TaskService.complete() 方法触发，此时会进入下一个节点，执行下一个节点的行为类

用户行为类源码

public class UserTaskActivityBehavior extends TaskActivityBehavior {
    private static final long serialVersionUID = 1L;
    private static final Logger LOGGER = LoggerFactory.getLogger(UserTaskActivityBehavior.class);
    protected UserTask userTask; //这个userTask 对应的是流程文档的用户节点，可通过此对象获取拓展元素

    public UserTaskActivityBehavior(UserTask userTask) {
        this.userTask = userTask;
    }

    public void execute(DelegateExecution execution) {
        CommandContext commandContext = Context.getCommandContext();
        TaskEntityManager taskEntityManager = commandContext.getTaskEntityManager();
        TaskEntity task = (TaskEntity)taskEntityManager.create();
        task.setExecution((ExecutionEntity)execution);
        task.setTaskDefinitionKey(this.userTask.getId());
        String activeTaskName = null;
        String activeTaskDescription = null;
        String activeTaskDueDate = null;
        String activeTaskPriority = null;
        String activeTaskCategory = null;
        String activeTaskFormKey = null;
        String activeTaskSkipExpression = null;
        String activeTaskAssignee = null;
        String activeTaskOwner = null;
        List<String> activeTaskCandidateUsers = null;
        List<String> activeTaskCandidateGroups = null;
        ProcessEngineConfigurationImpl processEngineConfiguration = Context.getProcessEngineConfiguration();
        //获取表达式管理器
        ExpressionManager expressionManager = processEngineConfiguration.getExpressionManager();
        ObjectNode taskElementProperties;
        if (Context.getProcessEngineConfiguration().isEnableProcessDefinitionInfoCache()) {
            taskElementProperties = Context.getBpmnOverrideElementProperties(this.userTask.getId(), execution.getProcessDefinitionId());
            activeTaskName = this.getActiveValue(this.userTask.getName(), "userTaskName", taskElementProperties);
            activeTaskDescription = this.getActiveValue(this.userTask.getDocumentation(), "userTaskDescription", taskElementProperties);
            activeTaskDueDate = this.getActiveValue(this.userTask.getDueDate(), "userTaskDueDate", taskElementProperties);
            activeTaskPriority = this.getActiveValue(this.userTask.getPriority(), "userTaskPriority", taskElementProperties);
            activeTaskCategory = this.getActiveValue(this.userTask.getCategory(), "userTaskCategory", taskElementProperties);
            activeTaskFormKey = this.getActiveValue(this.userTask.getFormKey(), "userTaskFormKey", taskElementProperties);
            activeTaskSkipExpression = this.getActiveValue(this.userTask.getSkipExpression(), "taskSkipExpression", taskElementProperties);
            activeTaskAssignee = this.getActiveValue(this.userTask.getAssignee(), "userTaskAssignee", taskElementProperties);
            activeTaskOwner = this.getActiveValue(this.userTask.getOwner(), "userTaskOwner", taskElementProperties);
            activeTaskCandidateUsers = this.getActiveValueList(this.userTask.getCandidateUsers(), "userTaskCandidateUsers", taskElementProperties);
            activeTaskCandidateGroups = this.getActiveValueList(this.userTask.getCandidateGroups(), "userTaskCandidateGroups", taskElementProperties);
        } else {
            activeTaskName = this.userTask.getName();
            activeTaskDescription = this.userTask.getDocumentation();
            activeTaskDueDate = this.userTask.getDueDate();
            activeTaskPriority = this.userTask.getPriority();
            activeTaskCategory = this.userTask.getCategory();
            activeTaskFormKey = this.userTask.getFormKey();
            activeTaskSkipExpression = this.userTask.getSkipExpression();
            activeTaskAssignee = this.userTask.getAssignee();
            activeTaskOwner = this.userTask.getOwner();
            activeTaskCandidateUsers = this.userTask.getCandidateUsers();
            activeTaskCandidateGroups = this.userTask.getCandidateGroups();
        }

        String description;
        if (StringUtils.isNotEmpty(activeTaskName)) {
            taskElementProperties = null;

            try {
                description = (String)expressionManager.createExpression(activeTaskName).getValue(execution);
            } catch (ActivitiException var23) {
                description = activeTaskName;
                LOGGER.warn("property not found in task name expression " + var23.getMessage());
            }

            task.setName(description);
        }

        if (StringUtils.isNotEmpty(activeTaskDescription)) {
            taskElementProperties = null;

            try {
                description = (String)expressionManager.createExpression(activeTaskDescription).getValue(execution);
            } catch (ActivitiException var22) {
                description = activeTaskDescription;
                LOGGER.warn("property not found in task description expression " + var22.getMessage());
            }

            task.setDescription(description);
        }

        Object formKey;
        if (StringUtils.isNotEmpty(activeTaskDueDate)) {
            formKey = expressionManager.createExpression(activeTaskDueDate).getValue(execution);
            if (formKey != null) {
                if (formKey instanceof Date) {
                    task.setDueDate((Date)formKey);
                } else {
                    if (!(formKey instanceof String)) {
                        throw new ActivitiIllegalArgumentException("Due date expression does not resolve to a Date or Date string: " + activeTaskDueDate);
                    }

                    String businessCalendarName = null;
                    if (StringUtils.isNotEmpty(this.userTask.getBusinessCalendarName())) {
                        businessCalendarName = expressionManager.createExpression(this.userTask.getBusinessCalendarName()).getValue(execution).toString();
                    } else {
                        businessCalendarName = "dueDate";
                    }

                    BusinessCalendar businessCalendar = Context.getProcessEngineConfiguration().getBusinessCalendarManager().getBusinessCalendar(businessCalendarName);
                    task.setDueDate(businessCalendar.resolveDuedate((String)formKey));
                }
            }
        }

        if (StringUtils.isNotEmpty(activeTaskPriority)) {
            formKey = expressionManager.createExpression(activeTaskPriority).getValue(execution);
            if (formKey != null) {
                if (formKey instanceof String) {
                    try {
                        task.setPriority(Integer.valueOf((String)formKey));
                    } catch (NumberFormatException var21) {
                        throw new ActivitiIllegalArgumentException("Priority does not resolve to a number: " + formKey, var21);
                    }
                } else {
                    if (!(formKey instanceof Number)) {
                        throw new ActivitiIllegalArgumentException("Priority expression does not resolve to a number: " + activeTaskPriority);
                    }

                    task.setPriority(((Number)formKey).intValue());
                }
            }
        }

        if (StringUtils.isNotEmpty(activeTaskCategory)) {
            formKey = expressionManager.createExpression(activeTaskCategory).getValue(execution);
            if (formKey != null) {
                if (!(formKey instanceof String)) {
                    throw new ActivitiIllegalArgumentException("Category expression does not resolve to a string: " + activeTaskCategory);
                }

                task.setCategory((String)formKey);
            }
        }

        if (StringUtils.isNotEmpty(activeTaskFormKey)) {
            formKey = expressionManager.createExpression(activeTaskFormKey).getValue(execution);
            if (formKey != null) {
                if (!(formKey instanceof String)) {
                    throw new ActivitiIllegalArgumentException("FormKey expression does not resolve to a string: " + activeTaskFormKey);
                }

                task.setFormKey((String)formKey);
            }
        }

        taskEntityManager.insert(task, (ExecutionEntity)execution);
        //是否跳过此节点标记
        boolean skipUserTask = false;
        if (StringUtils.isNotEmpty(activeTaskSkipExpression)) {
            Expression skipExpression = expressionManager.createExpression(activeTaskSkipExpression);
            skipUserTask = SkipExpressionUtil.isSkipExpressionEnabled(execution, skipExpression) && SkipExpressionUtil.shouldSkipFlowElement(execution, skipExpression);
        }

        if (!skipUserTask) {
        	// 计算并设置任务节点的候选人
            this.handleAssignments(taskEntityManager, activeTaskAssignee, activeTaskOwner, activeTaskCandidateUsers, activeTaskCandidateGroups, task, expressionManager, execution);
        }

		//广播 task create 事件
        processEngineConfiguration.getListenerNotificationHelper().executeTaskListeners(task, "create");
        if (Context.getProcessEngineConfiguration().getEventDispatcher().isEnabled()) {
          Context.getProcessEngineConfiguration().getEventDispatcher().dispatchEvent(ActivitiEventBuilder.createEntityEvent(ActivitiEventType.TASK_CREATED, task));
        }

        if (skipUserTask) {
        	//如果选择跳过这个任务就会删除这个任务节点并执行level()方法进入下一个节点
            taskEntityManager.deleteTask(task, (String)null, false, false);
            //调用父类的leave方法 有两种情况一种是普通节点 和 多实例节点跳转
            this.leave(execution);
        }

    }

    //设置任务的处理人，候选人，候选组等信息
    protected void handleAssignments(TaskEntityManager taskEntityManager, String assignee, String owner, List<String> candidateUsers, List<String> candidateGroups, TaskEntity task, ExpressionManager expressionManager, DelegateExecution execution) {
        Object ownerExpressionValue;
        String customGroupIdentityLinkType;
        if (StringUtils.isNotEmpty(assignee)) {
            ownerExpressionValue = expressionManager.createExpression(assignee).getValue(execution);
            customGroupIdentityLinkType = null;
            if (ownerExpressionValue != null) {
                customGroupIdentityLinkType = ownerExpressionValue.toString();
            }

            taskEntityManager.changeTaskAssignee(task, customGroupIdentityLinkType);
        }

        if (StringUtils.isNotEmpty(owner)) {
            ownerExpressionValue = expressionManager.createExpression(owner).getValue(execution);
            customGroupIdentityLinkType = null;
            if (ownerExpressionValue != null) {
                customGroupIdentityLinkType = ownerExpressionValue.toString();
            }

            taskEntityManager.changeTaskOwner(task, customGroupIdentityLinkType);
        }

        Expression userIdExpr;
        Object value;
        List candidates;
        Iterator var18;
        if (candidateGroups != null && !candidateGroups.isEmpty()) {
            var18 = candidateGroups.iterator();

            while(var18.hasNext()) {
                customGroupIdentityLinkType = (String)var18.next();
                userIdExpr = expressionManager.createExpression(customGroupIdentityLinkType);
                value = userIdExpr.getValue(execution);
                if (value instanceof String) {
                    candidates = this.extractCandidates((String)value);
                    task.addCandidateGroups(candidates);
                } else {
                    if (!(value instanceof Collection)) {
                        throw new ActivitiIllegalArgumentException("Expression did not resolve to a string or collection of strings");
                    }

                    task.addCandidateGroups((Collection)value);
                }
            }
        }

        if (candidateUsers != null && !candidateUsers.isEmpty()) {
            var18 = candidateUsers.iterator();

            while(var18.hasNext()) {
                customGroupIdentityLinkType = (String)var18.next();
                userIdExpr = expressionManager.createExpression(customGroupIdentityLinkType);
                value = userIdExpr.getValue(execution);
                if (value instanceof String) {
                    candidates = this.extractCandidates((String)value);
                    task.addCandidateUsers(candidates);
                } else {
                    if (!(value instanceof Collection)) {
                        throw new ActivitiException("Expression did not resolve to a string or collection of strings");
                    }

                    task.addCandidateUsers((Collection)value);
                }
            }
        }

        Object value;
        Iterator groupIdSet;
        Iterator var16;
        String groupId;
        Iterator var19;
        String groupIdentityLink;
        Expression idExpression;
        List groupIds;
        if (this.userTask.getCustomUserIdentityLinks() != null && !this.userTask.getCustomUserIdentityLinks().isEmpty()) {
            var18 = this.userTask.getCustomUserIdentityLinks().keySet().iterator();

            label135:
            while(var18.hasNext()) {
                customGroupIdentityLinkType = (String)var18.next();
                var19 = ((Set)this.userTask.getCustomUserIdentityLinks().get(customGroupIdentityLinkType)).iterator();

                while(true) {
                    while(true) {
                        if (!var19.hasNext()) {
                            continue label135;
                        }

                        groupIdentityLink = (String)var19.next();
                        idExpression = expressionManager.createExpression(groupIdentityLink);
                        value = idExpression.getValue(execution);
                        if (value instanceof String) {
                            groupIds = this.extractCandidates((String)value);
                            var16 = groupIds.iterator();

                            while(var16.hasNext()) {
                                groupId = (String)var16.next();
                                task.addUserIdentityLink(groupId, customGroupIdentityLinkType);
                            }
                        } else {
                            if (!(value instanceof Collection)) {
                                throw new ActivitiException("Expression did not resolve to a string or collection of strings");
                            }

                            groupIdSet = ((Collection)value).iterator();

                            while(groupIdSet.hasNext()) {
                                task.addUserIdentityLink((String)groupIdSet.next(), customGroupIdentityLinkType);
                            }
                        }
                    }
                }
            }
        }

        if (this.userTask.getCustomGroupIdentityLinks() != null && !this.userTask.getCustomGroupIdentityLinks().isEmpty()) {
            var18 = this.userTask.getCustomGroupIdentityLinks().keySet().iterator();

            label108:
            while(var18.hasNext()) {
                customGroupIdentityLinkType = (String)var18.next();
                var19 = ((Set)this.userTask.getCustomGroupIdentityLinks().get(customGroupIdentityLinkType)).iterator();

                while(true) {
                    while(true) {
                        if (!var19.hasNext()) {
                            continue label108;
                        }

                        groupIdentityLink = (String)var19.next();
                        idExpression = expressionManager.createExpression(groupIdentityLink);
                        value = idExpression.getValue(execution);
                        if (value instanceof String) {
                            groupIds = this.extractCandidates((String)value);
                            var16 = groupIds.iterator();

                            while(var16.hasNext()) {
                                groupId = (String)var16.next();
                                task.addGroupIdentityLink(groupId, customGroupIdentityLinkType);
                            }
                        } else {
                            if (!(value instanceof Collection)) {
                                throw new ActivitiException("Expression did not resolve to a string or collection of strings");
                            }

                            groupIdSet = ((Collection)value).iterator();

                            while(groupIdSet.hasNext()) {
                                task.addGroupIdentityLink((String)groupIdSet.next(), customGroupIdentityLinkType);
                            }
                        }
                    }
                }
            }
        }

    }

    protected List<String> extractCandidates(String str) {
        return Arrays.asList(str.split("[\\s]*,[\\s]*"));
    }
}

整合Groovy脚本

实现ExpressionManager

isyoungboy
关注
专栏目录
springboot+Activiti7整合实践 (七) 自定义用户任务行为
刘一线的博客
01-10 2783
自定义UserTaskActivityBehavior用户任务活动行为类，设置工作流代办人
Flowable源码注释（六十九）任务、用户任务活动行为
jinyangjie的博客
03-25 1309
Flowable-6.7.2 源码注释地址：https://github.com/solojin/flowable-6.7.2-annotated TaskActivityBehavior 任务活动行为类 /** * 任务活动行为类 * * 所有BPMN 2.0任务类型（如ServiceTask、ScriptTask、UserTask等）的父类。 * * 单独使用时，它的行为就像一个传递活动。 * * @author Joram Barrez */ public class TaskAc
Activiti UserTask节点扩展 实现自定义节点属性
wangmingyue123456的专栏
06-16 4727
因为在项目中需要自定义UserTask属性。而且还需要能够在后台得到这个属性值。所以本人查阅了一些资料。咨询了临远大神。才实现。在这里把要修改的文件列出。 引擎版本Activiti5.14 activiti-bpmn-converter包 Semantic.xsd BpmnXMLConstants //设置属性常量值 UserTaskXMLConverter activiti-...
activiti学习（二十四）——自定义行为类
sadoshi的专栏
06-23 3543
前言 前面几篇文章，我们知道每个活动节点，都有对应的行为类。activiti的扩展性极好，我们当然也可以自定义自己的行为类。
activiti6+springboot学习（一）——自定义行为类
EthanWinnie的博客
07-06 1548
UserTaskActivityBehavior扩展，DefaultActivityBehaviorFactory扩展 流程引擎配置行为工厂为我们自定义的ActivityBehaviorFactory
Activiti 学习笔记十：开始活动节点（判断流程是否结束及查询历史）
09-11
通过这个工具，我们可以直观地添加开始活动节点，配置其行为，并导出为 XML 文件，供 Activiti 引擎运行。 总结，Activiti 的开始活动节点是流程的起点，而流程是否结束则需要通过查询流程实例和历史流程实例的状态...
Android开发之activiti节点跳转
09-02
总之，通过理解Activiti的工作原理，结合Java Delegate、自定义服务任务、流程变量和事件，可以有效地实现Android开发中的节点跳转，以适应不断变化的业务需求，避免流程设计的过度复杂化。这种灵活性是现代企业级...
ACTIVITI如何获取下一步节点
08-09
本文将深入探讨如何在ACTIVITI中获取活动实例的下一步节点，以便于开发人员更好地理解和控制业务流程。 ACTIVITI是一个基于Java的流程自动化框架，它实现了BPMN 2.0标准，提供了丰富的API和可视化的流程设计工具，...
JAVA SSM+Activiti实现用户信息管理、权限管理、OA审批流程统一操作系统
03-14
系统模块 1、机构管理 2、部门管理 3、角色管理 4、用户管理 5、权限管理 6、菜单管理7、消息管理 8、登录记录9、操作日志管理 1、请假申请2、物资采购3、报销申请1人员所属部门调动1、发布招聘信息1、问题发布 2、...
Activiti 5.13 用户手册(中文版)
03-30
4. **事件和监听器**：Activiti 中的事件机制允许在特定流程节点触发自定义行为。例如，当流程实例创建或结束时，可以定义监听器来执行额外的业务逻辑。这增强了流程的灵活性和扩展性。 5. **服务调用**：Activiti ...
activiti modeler 任务节点自定义属性扩展
weixin_30553777的博客
11-03 1794
　　在工作中使用Activiti modeler时难免会遇到局限，如usertask中的属性，完全不够用，这时需要我们去扩展。 　　activiti modeler通过读取stencilset.json生成编辑器UI，在界面上的扩展需要了解stencilset.json配置文件，它定义元素的属性，规则的配置文件，页面的展示就是根据这个配置文件生成的。 配置文件说明： --属性的定义 "pr...
Activiti人员分配问题
liufangzhaoly的博客
12-07 583
或者映射到监听的类上 这是在activit官网文档上写的 用于人员的绑定 [code="java"] public class TestTask implements TaskListener { ProcessEngine ps = ProcessEngineConfiguration.createProcessEngineConfigurationFromReso...
activiti，根据流程实例id，获取下一个userTask节点的配置信息
热门推荐
qq_25927437的博客
09-06 1万+
activiti，根据流程实例id，获取下个userTask节点的配置信息，需要在每个节点都添加complete的监听器   public class Competeistener implements TaskListener {       private ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngi...
java编写节点自定义属性,Activiti 任务节点自定义扩展属性
weixin_39884144的博客
03-11 800
很多时候因为自己的业务需求需要修改节点的属性例如需要在用户任务节点添加部门与岗位属性首先修改stencilset.json在propertyPackages下添加岗位与部门 {"name" : "responsiblepostpackage","properties" : [{"id" :"responsiblepost","type" : "responsiblepostcomplex","t...
Activiti子流程扩展标签
白猿的博客
04-16 1823
子流程（Sub-process）是一个包含其他节点，网关，事件等等的节点。 它自己就是一个流程，同时是更大流程的一部分。 子流程只能包含一个空开始事件， 不能使用其他类型的开始事件。 图形标记 子流程显示为标准的节点，圆角矩形。 这时子流程是折叠的，只显示名称和一个加号标记， 展示了高级别的流程总览： • 内嵌子流程：定义在主流程内部 • 事务子流程：事件子流程是由事件触发的子流程。 事件子流程...
剖析Activiti源码扩展元素属性
qq277165811的专栏
01-08 2785
这里写自定义目录标题扩展的目标解析扩展属性底层源码元素属性的设计图解析自定义属性，存入业务系统表 扩展的目标 扩展activiti modeler 的元素属性,activiti modeler读取stencilset.json可动态自定义元素属性. 例如需要扩展状态码属性 { &amp;quot;name&amp;quot; : &amp;quot;stateCode&amp;quot;, &amp;quot;proper
java编写节点自定义属性,扩展Activiti流程定义文件，实现自定义节点属性
weixin_32002829的博客
03-11 715
为了满足业务需要，流程设计阶段需对设计产物流程定义文件中节点属性进行扩展，譬如：任务是否支持退回、退回方式、退回的节点，任务转派人、任务可跳转的节点范围等属性信息。为了保证扩展后的流程定义文件能够正常解析，我们采用类似元素的方式，模式如下： 流程定义文件扩展之后，扩展的属性如何存储呢？我们知道在Activiti中ActivitiImpl对象存储的是活动节点的定义，那么我们即可在流程文件解析时将扩展...
Activiti任务增加属性
最新发布
nly19900820的博客
04-03 1115
4.TaskEntity增加taskType属性 包路径：org.activiti.engine.impl.persistence.entity.TaskEntity 5.DelegateTask借口增加 getTaskType 和 setTaskType 包路径：org.activiti.engine.delegate.DelegateTask。3.Task接口增加setTaskType方法 包路径：org.activiti.engine.task.Task。
activiti 自定义函数解析juel表达式
weixin_34226706的博客
03-19 5011
activiti是支持juel表达式的，这个也很好用，但实际过程中需要支持类方法及变量。　　　 原来项目中解析juel,这边有自定义一个方法的 代码如下： public String getStringByELAndFormData(String el, Map formData) throws Except...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值