If I want to add the create event Listener and end event Listener for all UserTask,but I just want to coding once and configure once,The effect I want to achieve is similar to if I manually configure these two listeners to the userTask in the bpmn

Camunda 7 Topics
,
1

I find the way like this, but it is not work , when the flow start, no request input into this listener:

package com.haijiaonet.flow.flow.listener;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.haijiaonet.flow.flow.entity.DbCirculationRecord;
import com.haijiaonet.flow.flow.mapper.DbCirculationRecordMapper;
import com.nbzlth.utils.util.RedisUtil;
import org.camunda.bpm.engine.delegate.DelegateExecution;
import org.camunda.bpm.engine.delegate.DelegateTask;
import org.camunda.bpm.engine.delegate.ExecutionListener;
import org.camunda.bpm.engine.delegate.TaskListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Date;

/**
 **global listener
 ***
 **/

@Component
public class CamundaGlobalListenerDelegate  implements ExecutionListener, TaskListener {
	@Autowired
	private RedisUtil redisUtil;
	@Autowired
	private DbCirculationRecordMapper dbCirculationRecordMapper;

	@Override
	public void notify(DelegateTask delegateTask) {
		// event is create
		if (TaskListener.EVENTNAME_CREATE.equals(delegateTask.getEventName())){
			DbCirculationRecord recordNext = new DbCirculationRecord();
			String userName = redisUtil.hget("id_label_user", delegateTask.getAssignee()+"") + "";
			recordNext.setUserName(userName);
			recordNext.setStartTime(new Date());
			recordNext.setPriority(delegateTask.getPriority());
			recordNext.setType("flow");
			recordNext.setProcessDefinitionId(delegateTask.getProcessDefinitionId());
			recordNext.setProcessInstanceId(delegateTask.getProcessInstanceId());
			recordNext.setTaskName(delegateTask.getName());
			recordNext.setFormId(Integer.parseInt(delegateTask.getVariable("formId")+""));
			recordNext.setBusinessKey(delegateTask.getVariable("businessKey")+"");
			dbCirculationRecordMapper.insert(recordNext);
			// event is complete
		}else if(TaskListener.EVENTNAME_COMPLETE.equals(delegateTask.getEventName())){
			String userName = redisUtil.hget("id_label_user", delegateTask.getAssignee()+"") + "";
			DbCirculationRecord record = dbCirculationRecordMapper.selectOne(new QueryWrapper<DbCirculationRecord>().eq("user_name", userName).eq("task_name", delegateTask.getName()).eq("process_instance_id", delegateTask.getProcessInstanceId()));
			record.setComments(delegateTask.getVariable("comments")+"");
			if ("1".equals(delegateTask.getVariable("isPass")+"")){
				record.setResult("pass！");
			}else {
				record.setResult("reject！");
			}
			record.setEndTime(new Date());
			dbCirculationRecordMapper.updateById(record);
		}
	}
 
 
	@Override
	public void notify(DelegateExecution execution) throws Exception {

	}
 
}





package com.haijiaonet.flow.flow.listener;

import com.haijiaonet.flow.flow.mapper.DbCirculationRecordMapper;
import com.nbzlth.utils.util.RedisUtil;
import org.camunda.bpm.engine.delegate.DelegateTask;
import org.camunda.bpm.engine.delegate.ExecutionListener;
import org.camunda.bpm.engine.delegate.TaskListener;
import org.camunda.bpm.engine.impl.bpmn.behavior.UserTaskActivityBehavior;
import org.camunda.bpm.engine.impl.bpmn.parser.AbstractBpmnParseListener;
import org.camunda.bpm.engine.impl.persistence.entity.ProcessDefinitionEntity;
import org.camunda.bpm.engine.impl.pvm.process.ActivityImpl;
import org.camunda.bpm.engine.impl.pvm.process.ScopeImpl;
import org.camunda.bpm.engine.impl.pvm.process.TransitionImpl;
import org.camunda.bpm.engine.impl.task.TaskDefinition;
import org.camunda.bpm.engine.impl.util.xml.Element;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;



/**
 * @ClassName UserTaskCreateListener
 * @Description 用于用户节点开启时执行逻辑
 * @Author Administrator
 * @Date 2023/12/5 20:01
 * @Version 1.0
 **/
@Component
public class UserTaskTestCreateListener extends AbstractBpmnParseListener {
    @Autowired
    private RedisUtil redisUtil;
    @Autowired
    private DbCirculationRecordMapper dbCirculationRecordMapper;
    private DelegateTask delegateTask;


    public final static ExecutionListener EXECUTION_LISTENER = new CamundaGlobalListenerDelegate();
    public final static TaskListener TASK_LISTENER = new CamundaGlobalListenerDelegate();

    public DelegateTask getDelegateTask() {
        return delegateTask;
    }

    public void setDelegateTask(DelegateTask delegateTask) {
        this.delegateTask = delegateTask;
    }

    public UserTaskTestCreateListener() {
    }

    public UserTaskTestCreateListener(DelegateTask delegateTask) {
        this.delegateTask = delegateTask;
    }

    public UserTaskTestCreateListener(RedisUtil redisUtil, DbCirculationRecordMapper dbCirculationRecordMapper, DelegateTask delegateTask) {
        this.redisUtil = redisUtil;
        this.dbCirculationRecordMapper = dbCirculationRecordMapper;
        this.delegateTask = delegateTask;
    }


    protected void addEndEventListener(ScopeImpl activity) {
        //activity.addExecutionListener(ExecutionListener.EVENTNAME_END, EXECUTION_LISTENER);
        activity.addListener(ExecutionListener.EVENTNAME_END, EXECUTION_LISTENER);
    }

    protected void addStartEventListener(ScopeImpl activity) {
        //activity.addExecutionListener(ExecutionListener.EVENTNAME_START, EXECUTION_LISTENER);
        activity.addListener(ExecutionListener.EVENTNAME_START, EXECUTION_LISTENER);
    }

    protected void addTakeEventListener(TransitionImpl transition) {
        //transition.addExecutionListener(EXECUTION_LISTENER);
        transition.addListener(ExecutionListener.EVENTNAME_TAKE, EXECUTION_LISTENER);

    }

    protected void addTaskAssignmentListeners(TaskDefinition taskDefinition) {
        taskDefinition.addTaskListener(TaskListener.EVENTNAME_ASSIGNMENT, TASK_LISTENER);
    }

    protected void addTaskCreateListeners(TaskDefinition taskDefinition) {
        taskDefinition.addTaskListener(TaskListener.EVENTNAME_CREATE, TASK_LISTENER);
    }

    protected void addTaskCompleteListeners(TaskDefinition taskDefinition) {
        taskDefinition.addTaskListener(TaskListener.EVENTNAME_COMPLETE, TASK_LISTENER);
    }

    protected void addTaskUpdateListeners(TaskDefinition taskDefinition) {
        taskDefinition.addTaskListener(TaskListener.EVENTNAME_UPDATE, TASK_LISTENER);
    }

    protected void addTaskDeleteListeners(TaskDefinition taskDefinition) {
        taskDefinition.addTaskListener(TaskListener.EVENTNAME_DELETE, TASK_LISTENER);
    }

    // BpmnParseListener implementation
    // /

    @Override
    public void parseProcess(Element processElement, ProcessDefinitionEntity processDefinition) {
        addStartEventListener(processDefinition);
        addEndEventListener(processDefinition);
    }

    @Override
    public void parseStartEvent(Element startEventElement, ScopeImpl scope, ActivityImpl startEventActivity) {
        addStartEventListener(startEventActivity);
        addEndEventListener(startEventActivity);
    }

    @Override
    public void parseExclusiveGateway(Element exclusiveGwElement, ScopeImpl scope, ActivityImpl activity) {
        addStartEventListener(activity);
        addEndEventListener(activity);
    }

    @Override
    public void parseInclusiveGateway(Element inclusiveGwElement, ScopeImpl scope, ActivityImpl activity) {
        addStartEventListener(activity);
        addEndEventListener(activity);
    }

    @Override
    public void parseParallelGateway(Element parallelGwElement, ScopeImpl scope, ActivityImpl activity) {
        addStartEventListener(activity);
        addEndEventListener(activity);
    }

    @Override
    public void parseScriptTask(Element scriptTaskElement, ScopeImpl scope, ActivityImpl activity) {
        addStartEventListener(activity);
        addEndEventListener(activity);
    }

    @Override
    public void parseServiceTask(Element serviceTaskElement, ScopeImpl scope, ActivityImpl activity) {
        addStartEventListener(activity);
        addEndEventListener(activity);
    }

    @Override
    public void parseBusinessRuleTask(Element businessRuleTaskElement, ScopeImpl scope, ActivityImpl activity) {
        addStartEventListener(activity);
        addEndEventListener(activity);
    }

    @Override
    public void parseTask(Element taskElement, ScopeImpl scope, ActivityImpl activity) {
        addStartEventListener(activity);
        addEndEventListener(activity);
    }

    @Override
    public void parseManualTask(Element manualTaskElement, ScopeImpl scope, ActivityImpl activity) {
        addStartEventListener(activity);
        addEndEventListener(activity);
    }

    @Override
    public void parseUserTask(Element userTaskElement, ScopeImpl scope, ActivityImpl activity) {
        addStartEventListener(activity);
        addEndEventListener(activity);
        UserTaskActivityBehavior activityBehavior = (UserTaskActivityBehavior) activity.getActivityBehavior();
        TaskDefinition taskDefinition = activityBehavior.getTaskDefinition();
        addTaskCreateListeners(taskDefinition);
        addTaskAssignmentListeners(taskDefinition);
        addTaskCompleteListeners(taskDefinition);
        addTaskUpdateListeners(taskDefinition);
        addTaskDeleteListeners(taskDefinition);
    }

    @Override
    public void parseEndEvent(Element endEventElement, ScopeImpl scope, ActivityImpl activity) {
        addStartEventListener(activity);
        addEndEventListener(activity);
    }

    @Override
    public void parseSubProcess(Element subProcessElement, ScopeImpl scope, ActivityImpl activity) {
        addStartEventListener(activity);
        addEndEventListener(activity);
    }

    @Override
    public void parseCallActivity(Element callActivityElement, ScopeImpl scope, ActivityImpl activity) {
        addStartEventListener(activity);
        addEndEventListener(activity);
    }


    @Override
    public void parseSequenceFlow(Element sequenceFlowElement, ScopeImpl scopeElement, TransitionImpl transition) {
        addTakeEventListener(transition);
    }

    @Override
    public void parseSendTask(Element sendTaskElement, ScopeImpl scope, ActivityImpl activity) {
        addStartEventListener(activity);
        addEndEventListener(activity);
    }

    @Override
    public void parseMultiInstanceLoopCharacteristics(Element activityElement,
                                                      Element multiInstanceLoopCharacteristicsElement, ActivityImpl activity) {
        addStartEventListener(activity);
        addEndEventListener(activity);
    }


    @Override
    public void parseReceiveTask(Element receiveTaskElement, ScopeImpl scope, ActivityImpl activity) {
        addStartEventListener(activity);
        addEndEventListener(activity);
    }

    @Override
    public void parseEventBasedGateway(Element eventBasedGwElement, ScopeImpl scope, ActivityImpl activity) {
        addStartEventListener(activity);
        addEndEventListener(activity);
    }

    @Override
    public void parseTransaction(Element transactionElement, ScopeImpl scope, ActivityImpl activity) {
        addStartEventListener(activity);
        addEndEventListener(activity);
    }

    @Override
    public void parseIntermediateThrowEvent(Element intermediateEventElement, ScopeImpl scope, ActivityImpl activity) {
        addStartEventListener(activity);
        addEndEventListener(activity);
    }

    @Override
    public void parseIntermediateCatchEvent(Element intermediateEventElement, ScopeImpl scope, ActivityImpl activity) {
        addStartEventListener(activity);
        addEndEventListener(activity);
    }

    @Override
    public void parseBoundaryEvent(Element boundaryEventElement, ScopeImpl scopeElement, ActivityImpl activity) {
        addStartEventListener(activity);
        addEndEventListener(activity);
    }

}
2

I think you can explicitly will you join the CustomPreBPMNParseListeners custom UserTaskTestCreateListener program.

public class UserTaskTestCreateListenerPlugin extends AbstractProcessEnginePlugin {

    private static final Logger logger = LoggerFactory.getLogger(UserTaskTestCreateListenerPlugin.class);
    @Override
    public void preInit(ProcessEngineConfigurationImpl processEngineConfiguration) {
        logger.debug("UserTaskTestCreateListenerPlugin For Extension initiating");
        List<BpmnParseListener> preParseListeners = processEngineConfiguration.getCustomPreBPMNParseListeners();
        if(preParseListeners == null) {
            preParseListeners = new ArrayList<>();
            processEngineConfiguration.setCustomPreBPMNParseListeners(preParseListeners);
        }
        preParseListeners.add(new CamundaGlobalListenerDelegate());

    }
}