配置类：

package com.zz.flow.config.myProcessConfig;
import com.zz.flow.config.event.GlobalEventListener;
import org.activiti.engine.delegate.event.ActivitiEventListener;
import org.activiti.spring.SpringProcessEngineConfiguration;
import org.activiti.spring.boot.ProcessEngineConfigurationConfigurer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.List;
/**
* @author lqx
* @date 2020/10/20 16:56
*/
@Component
public class ActivitiConfig implements ProcessEngineConfigurationConfigurer {
@Autowired
private GlobalEventListener globalEventListener;
@Override
public void configure(SpringProcessEngineConfiguration springProcessEngineConfiguration) {
/*springProcessEngineConfiguration.setActivityFontName("宋体");
springProcessEngineConfiguration.setLabelFontName("宋体");
springProcessEngineConfiguration.setAnnotationFontName("宋体");*/
//springProcessEngineConfiguration.setDbIdentityUsed(false);
springProcessEngineConfiguration.setIdGenerator(new MyDbIdGenerator());
List<ActivitiEventListener> eventListeners=new ArrayList<>();
eventListeners.add(globalEventListener);
springProcessEngineConfiguration.setEventListeners(eventListeners);
}
}

事件监听类：

package com.zz.flow.config.event;

import com.zz.common.scan.utils.UserUtil;
import com.zz.flow.constants.ProcessConstants;
import com.zz.flow.service.ZzProcessService;
import com.zz.flow.service.ZzTaskOperateService;
import org.activiti.engine.HistoryService;
import org.activiti.engine.delegate.event.ActivitiEvent;
import org.activiti.engine.delegate.event.ActivitiEventListener;
import org.activiti.engine.delegate.event.impl.ActivitiEntityEventImpl;
import org.activiti.engine.delegate.event.impl.ActivitiProcessCancelledEventImpl;
import org.activiti.engine.history.HistoricProcessInstance;
import org.activiti.engine.history.HistoricTaskInstance;
import org.activiti.engine.impl.persistence.entity.ExecutionEntity;
import org.activiti.engine.impl.persistence.entity.TaskEntity;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

/**
 * @author lqx
 * @date 2021/4/10 15:27
 */
@Component
public class GlobalEventListener implements ActivitiEventListener {
    @Autowired
    @Lazy
    private ZzTaskOperateService taskOperateService;
    @Resource
    @Lazy
    private HistoryService historyService;
    @Autowired
    @Lazy
    private ZzProcessService zzProcessService;
    @Autowired
    private UserUtil userUtil;
    @Override
    public void onEvent(ActivitiEvent event) {
        switch (event.getType()){
            case ENTITY_DELETED:
                entityDeleted(event);
                //System.out.println("删除已存在的实体时触发");
                break;
            case ENTITY_SUSPENDED:
                entitySuspended(event);
                //暂停已存在的实体时触发
                //System.out.println("暂停已存在的实体时触发");
                break;
            case ENTITY_ACTIVATED:
                entityActivated(event);
                //激活已存在的实体时触发
                //System.out.println("激活已存在的实体时触发");
                break;
            case TASK_CREATED:
                taskCreate(event);
                //任务创建时
                //System.out.println("任务创建时");
                break;
            case TASK_COMPLETED:
                taskCompleted(event);
                //任务完成时
                //System.out.println("任务完成事件结束！");
                break;
            case PROCESS_COMPLETED:
                processCompleted(event);
                //流程结束时
                //System.out.println("流程结束时");
                break;
            case PROCESS_CANCELLED:
                processCancelled(event);
                //System.out.println("流程终止");
                break;

        }
    }

    /**
     * 当 listener 抛出一个异常的时候,当前操作时序应该失败(其实就是是否需要吞掉 listener 的异常).
     * 我们可以看看 Activiti 相关的源代码,在 ActivitiEventSupport 中的 dispatchEvent 函数,
     * 我们可以清晰的看到,listener.isFailOnException()为false则会讲异常吞掉,只是打一行日志
     * @return
     */
    @Override
    public boolean isFailOnException() {
        return false;
    }

    /**
     * 删除已存在的实体时触发
     * @param event
     */
    public void entityDeleted(ActivitiEvent event){
        ActivitiEntityEventImpl eventImpl = (ActivitiEntityEventImpl) event;
        if(eventImpl.getEntity() instanceof TaskEntity){//某任务删除时
            TaskEntity entity = (TaskEntity) eventImpl.getEntity();
            HistoricTaskInstance historicTaskInstance = historyService.createHistoricTaskInstanceQuery().taskId(entity.getId()).singleResult();
            if(ProcessConstants.TASK_ROLLBACK_FLAG.equals(historicTaskInstance.getDeleteReason())){//退回时
                String token = userUtil.getToken();
                //判断是否设置了任务完成时发送消息  是否需要发送消息 若需要 则发送消息
                taskOperateService.sendTaskMsg(entity.getTaskDefinitionKey(),entity.getProcessDefinitionId()
                        ,"rollback",entity.getProcessInstanceId(),entity.getId(),token);
            }else if(ProcessConstants.TASK_RECALL_FLAG.equals(historicTaskInstance.getDeleteReason())){//撤回时
                String token = userUtil.getToken();
                //判断是否设置了任务完成时发送消息  是否需要发送消息 若需要 则发送消息
                taskOperateService.sendTaskMsg(entity.getTaskDefinitionKey(),entity.getProcessDefinitionId()
                        ,"recall",entity.getProcessInstanceId(),entity.getId(),token);
            }

        }

    }
    /**
     * 暂停已存在的实体时触发
     * @param event
     */
    public void entitySuspended(ActivitiEvent event){
        ActivitiEntityEventImpl eventImpl = (ActivitiEntityEventImpl) event;
        if(eventImpl.getEntity() instanceof TaskEntity){//某任务挂起时
            String token = userUtil.getToken();
            TaskEntity entity = (TaskEntity) eventImpl.getEntity();
            //判断是否设置了任务完成时发送消息  是否需要发送消息 若需要 则发送消息
            taskOperateService.sendTaskMsg(entity.getTaskDefinitionKey(),entity.getProcessDefinitionId()
                    ,"suspend",entity.getProcessInstanceId(),entity.getId(),token);
        }

    }
    /**
     * 激活已存在的实体时触发
     * @param event
     */
    public void entityActivated(ActivitiEvent event){
        ActivitiEntityEventImpl eventImpl = (ActivitiEntityEventImpl) event;
        if(eventImpl.getEntity() instanceof TaskEntity){//某任务激活时
            String token = userUtil.getToken();
            TaskEntity entity = (TaskEntity) eventImpl.getEntity();
            //判断是否设置了任务完成时发送消息  是否需要发送消息 若需要 则发送消息
            taskOperateService.sendTaskMsg(entity.getTaskDefinitionKey(),entity.getProcessDefinitionId()
                    ,"activate",entity.getProcessInstanceId(),entity.getId(),token);
        }

    }
    /**
     * 任务创建时触发
     * @param event
     */
    public void taskCreate(ActivitiEvent event){
        ActivitiEntityEventImpl eventImpl = (ActivitiEntityEventImpl) event;
        TaskEntity entity = (TaskEntity) eventImpl.getEntity();
        //判断是否设置了任务完成时发送消息  是否需要发送消息 若需要 则发送消息
        String token = userUtil.getToken();
        taskOperateService.sendTaskMsg(entity.getTaskDefinitionKey(),entity.getProcessDefinitionId()
                ,"create",entity.getProcessInstanceId(),entity.getId(),token);
    }


    /**
     * 任务完成时触发
     * @param event
     */
    public void taskCompleted(ActivitiEvent event){
        ActivitiEntityEventImpl eventImpl = (ActivitiEntityEventImpl) event;
        TaskEntity entity = (TaskEntity) eventImpl.getEntity();
        String token = userUtil.getToken();
        //判断是否设置了任务完成时发送消息  是否需要发送消息 若需要 则发送消息
        taskOperateService.sendTaskMsg(entity.getTaskDefinitionKey(),entity.getProcessDefinitionId()
                ,"completed",entity.getProcessInstanceId(),entity.getId(),token);
    }

    /**
     * 流程正常结束时触发
     * @param event
     */
    public void processCompleted(ActivitiEvent event){
        ActivitiEntityEventImpl eventImpl = (ActivitiEntityEventImpl) event;
        ExecutionEntity entity = (ExecutionEntity) eventImpl.getEntity();
        String token = userUtil.getToken();
        zzProcessService.sendProcessMsg(entity.getBusinessKey(),"completed",event.getProcessInstanceId(),token);
    }

    /**
     * 流程终止时触发
     * @param event
     */
    public void processCancelled(ActivitiEvent event){
        ActivitiProcessCancelledEventImpl eventImpl = (ActivitiProcessCancelledEventImpl) event;
        HistoricProcessInstance historicProcessInstance = historyService.createHistoricProcessInstanceQuery().processInstanceId(eventImpl.getProcessInstanceId()).singleResult();
        if(historicProcessInstance!=null){
            //终止流程时采用同步发消息 以免当物理删除运行中流程时 终止运行流程时异步导致获取不到流程信息
            zzProcessService.sendProcessMsgNotAsync(historicProcessInstance.getBusinessKey(),"deleted",event.getProcessInstanceId());
        }

    }
}