flowable流程结束事件响应监听器

有两种方案，一种不用监听器：

1、获取下一个任务节点是不是结束事件

/**
 * 获取任务节点
 *
 * @param node   查询节点选择
 * @param taskId 任务id
 */
public void nextFlowNode(String node, String taskId) {
    Task task = processEngine().getTaskService().createTaskQuery().taskId(taskId).singleResult();
    ExecutionEntity ee = (ExecutionEntity) processEngine().getRuntimeService().createExecutionQuery()
            .executionId(task.getExecutionId()).singleResult();
    // 当前审批节点
    String crruentActivityId = ee.getActivityId();
    BpmnModel bpmnModel = processEngine().getRepositoryService().getBpmnModel(task.getProcessDefinitionId());
    FlowNode flowNode = (FlowNode) bpmnModel.getFlowElement(crruentActivityId);
    // 输出连线
    List<SequenceFlow> outFlows = flowNode.getOutgoingFlows();
    for (SequenceFlow sequenceFlow : outFlows) {
        //当前审批节点
        if ("now".equals(node)) {
            FlowElement sourceFlowElement = sequenceFlow.getSourceFlowElement();
            System.out.println("当前节点: id=" + sourceFlowElement.getId() + ",name=" + sourceFlowElement.getName());
        } else if ("next".equals(node)) {
            // 下一个审批节点
            FlowElement targetFlow = sequenceFlow.getTargetFlowElement();
            if (targetFlow instanceof UserTask) {
                System.out.println("下一节点: id=" + targetFlow.getId() + ",name=" + targetFlow.getName());
            }
            // 如果下个审批节点为结束节点
            if (targetFlow instanceof EndEvent) {
                System.out.println("下一节点为结束节点：id=" + targetFlow.getId() + ",name=" + targetFlow.getName());
            }
        }


    }
}
--------------------- 
版权声明：本文为CSDN博主「FYRT」的原创文章，遵循CC 4.0 by-sa版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_36760953/article/details/91410038

2、第二种方法：实现监听器，生成监听器的bean类，写在model生成的xml文件中

监听器类：

@Component(value = "myListener")
public class TaskBusinessCallListener extends BusinessCallListener implements TaskListener {
    /**
     * dubbo的类名
     */
    private FixedValue clazzName;
    /**
     * 方法名
     */
    private FixedValue method;
    /**
     * 版本号
     */
    private FixedValue version;
    /**
     * 参数 多个的话用分号隔开 实例 userCode:00004737;status:1
     */
    private FixedValue params;

    @Override
    public void notify(DelegateTask delegateTask) {
        String processInstanceId = delegateTask.getProcessInstanceId();
        //执行回调
        this.callBack(processInstanceId, clazzName.getExpressionText(), method.getExpressionText(), version.getExpressionText(), params.getExpressionText());
    }
}

在xml文件中使用delegateExpression表达式

<userTask id="test" name="测试" flowable:assignee="${applyUserId}" flowable:formKey="testForm">
      <extensionElements>
        <!-- <flowable:taskListener event="create" class="cn.flowable.listener.MyListener"></flowable:taskListener> -->
        <flowable:taskListener event="create" delegateExpression="${myListener}"></flowable:taskListener>
        <modeler:initiator-can-complete xmlns:modeler="http://flowable.org/modeler"><![CDATA[false]]></modeler:initiator-can-complete>
      </extensionElements>
    </userTask>
--------------------- 
版权声明：本文为CSDN博主「仰望星空的女孩」的原创文章，遵循CC 4.0 by-sa版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/u011396199/article/details/76174466

上述方法实际上不能实现流程结束后进行响应操作，这里的监听器应该加在结束事件上

3、那么有没有方法可以实现直接在bpmnModel上添加全局的结束事件监听器呢？

思路是创建一个自定义的全局监听器，添加进flowable的监听器序列中去，然后在这个自定义的全局监听器的方法中判断当前的Event是不是EndEvent，如果是才进行相应的操作。
自定义全局监听器：

/**
 * 任务节点前置监听处理类
 * @author: Lu Yang
 * @create: 2019-05-04 20:51
 **/
@Component
public class TaskBeforeListener implements FlowableEventListener {

    @Override
    public void onEvent(FlowableEvent event) {

        // 当前节点任务实体
        TaskEntity taskEntity = (TaskEntity) ((FlowableEntityEventImpl) event).getEntity();
        // TODO 获取到了taskEntity 自己做每个节点的前置操作

    }

    @Override
    public boolean isFailOnException() {
        return false;
    }

    @Override
    public boolean isFireOnTransactionLifecycleEvent() {
        return false;
    }

    @Override
    public String getOnTransaction() {
        return null;
    }
}
//引自：[https://www.jianshu.com/p/5d673e767356](https://www.jianshu.com/p/5d673e767356)

需要对这个全局监听器进行配置，纳入flowable监听

/**
 * flowable 全局监听器配置类
 * @author: Lu Yang
 */
@Configuration
public class FlowableListenerConfig {

    // flowable监听级别参照 {@link FlowableEngineEventType} org.flowable.common.engine.api.delegate.event
    /**
     * 任务节点前置监听
     */
    private static final String FLOWABLE_TASK_NODE_REAR_LISTENER = "TASK_COMPLETED";

    // 自己建立监听类实现FlowableEventListener接口
    /**
     * 任务节点前置监听
     */
    private final TaskBeforeListener taskBeforeListener;


    @Autowired
    public FlowableListenerConfig(TaskBeforeListener taskBeforeListener) {
        this.taskBeforeListener = taskBeforeListener;
    }

    /**
     * 将自定义监听器纳入flowable监听
     * @author: Lu Yang
     * @date: 2019/5/4 21:05
     * @param
     * @return org.flowable.spring.boot.EngineConfigurationConfigurer<org.flowable.spring.SpringProcessEngineConfiguration>
     */
    @Bean
    public EngineConfigurationConfigurer<SpringProcessEngineConfiguration> globalListenerConfigurer () {
        return engineConfiguration -> {
            engineConfiguration.setTypedEventListeners(this.customFlowableListeners());
        };
    }

    /**
     * 监听类配置 {@link FlowableEngineEventType} flowable监听器级别
     * @author: Lu Yang
     * @date: 2019/5/4 20:58
     * @param
     * @return java.util.Map<java.lang.String,java.util.List<org.flowable.common.engine.api.delegate.event.FlowableEventListener>>
     */
    private Map<String, List<FlowableEventListener>> customFlowableListeners () {
        Map<String, List<FlowableEventListener>> listenerMap = Maps.newHashMap();
        listenerMap.put(FLOWABLE_TASK_NODE_BEFORE_LISTENER, new ArrayList<>(Collections.singletonList(getTaskBeforeListener())));
    }

    public TaskBeforeListener getTaskBeforeListener() {
        return taskBeforeListener;
    }
}
//引自：[https://www.jianshu.com/p/5d673e767356](https://www.jianshu.com/p/5d673e767356)

但是上述这个方法其实是有问题的，结束事件“执行”时，是不会调用这里的onEvent方法的！最后一个userEvent执行完毕之后，这个流程就相当于自动结束了！
所以得在执行最后一个userEvent的时候就要进行处理，所以综合方法1和方法3，最终的全局监听器这么写：

/**
 * 全局监听器，判断流程是不是运行到了最后一个EndEvent
 * @author: YBY
 * @create: 2019-05-04 20:51
 **/
@Component
public class ProcessEndListener implements FlowableEventListener {

    @Autowired
    FlowableService flowableService;

    @Override
    public void onEvent(FlowableEvent event) {
        // 当前节点任务实体,
        TaskEntity taskEntity = (TaskEntity) ((FlowableEntityEventImpl) event).getEntity();
        String taskId = taskEntity.getId();
        String curActId = flowableService.getNodeId(taskId);
        String procDefId = ProcUtils.getProcessDefinitionByTaskId(taskEntity.getId()).getId();
        Process process = ProcessDefinitionUtil.getProcess(procDefId);
        //遍历整个process,找到endEventId是什么，与当前taskId作对比
        List<FlowElement> flowElements = (List<FlowElement>) process.getFlowElements();
        for (FlowElement flowElement : flowElements) {
            if (flowElement instanceof SequenceFlow) {
                SequenceFlow flow = (SequenceFlow) flowElement;
                FlowElement sourceFlowElement = flow.getSourceFlowElement();
                FlowElement targetFlowElement = flow.getTargetFlowElement();
                //如果当前边的下一个节点是endEvent，那么获取当前边
                if(targetFlowElement instanceof EndEvent && sourceFlowElement.getId().equals(curActId))
                {
                    System.out.println("下一个是结束节点！！");
                }
            }
        }
    }

    @Override
    public boolean isFailOnException() {
        return false;
    }

    @Override
    public boolean isFireOnTransactionLifecycleEvent() {
        return false;
    }

    @Override
    public String getOnTransaction() {
        return null;
    }
}