import org.activiti.engine.impl.jobexecutor.AsyncContinuationJobHandler; //导入依赖的package包/类
@Override
protected void initJobExecutor() 
{
    super.initJobExecutor();

    // Wrap timer-job handler to handle authentication
    JobHandler timerJobHandler = jobHandlers.get(TimerExecuteNestedActivityJobHandler.TYPE);
    JobHandler wrappingTimerJobHandler = new AuthenticatedTimerJobHandler(timerJobHandler, unprotectedNodeService);
    jobHandlers.put(TimerExecuteNestedActivityJobHandler.TYPE, wrappingTimerJobHandler);
    
    // Wrap async-job handler to handle authentication
    JobHandler asyncJobHandler = jobHandlers.get(AsyncContinuationJobHandler.TYPE);
    JobHandler wrappingAsyncJobHandler = new AuthenticatedAsyncJobHandler(asyncJobHandler);
    jobHandlers.put(AsyncContinuationJobHandler.TYPE, wrappingAsyncJobHandler);
    
    // Wrap intermediate-timer-job handler to handle authentication
    JobHandler intermediateJobHandler = jobHandlers.get(TimerCatchIntermediateEventJobHandler.TYPE);
    JobHandler wrappingIntermediateJobHandler = new AuthenticatedAsyncJobHandler(intermediateJobHandler);
    jobHandlers.put(TimerCatchIntermediateEventJobHandler.TYPE, wrappingIntermediateJobHandler);
    
}
 

import org.activiti.engine.impl.jobexecutor.AsyncContinuationJobHandler; //导入依赖的package包/类
protected void initJobHandlers() {
    jobHandlers = new HashMap<>();
    TimerExecuteNestedActivityJobHandler timerExecuteNestedActivityJobHandler = new TimerExecuteNestedActivityJobHandler();
    jobHandlers.put(timerExecuteNestedActivityJobHandler.getType(), timerExecuteNestedActivityJobHandler);

    TimerCatchIntermediateEventJobHandler timerCatchIntermediateEvent = new TimerCatchIntermediateEventJobHandler();
    jobHandlers.put(timerCatchIntermediateEvent.getType(), timerCatchIntermediateEvent);

    TimerStartEventJobHandler timerStartEvent = new TimerStartEventJobHandler();
    jobHandlers.put(timerStartEvent.getType(), timerStartEvent);

    AsyncContinuationJobHandler asyncContinuationJobHandler = new AsyncContinuationJobHandler();
    jobHandlers.put(asyncContinuationJobHandler.getType(), asyncContinuationJobHandler);

    ProcessEventJobHandler processEventJobHandler = new ProcessEventJobHandler();
    jobHandlers.put(processEventJobHandler.getType(), processEventJobHandler);

    TimerSuspendProcessDefinitionHandler suspendProcessDefinitionHandler = new TimerSuspendProcessDefinitionHandler();
    jobHandlers.put(suspendProcessDefinitionHandler.getType(), suspendProcessDefinitionHandler);

    TimerActivateProcessDefinitionHandler activateProcessDefinitionHandler = new TimerActivateProcessDefinitionHandler();
    jobHandlers.put(activateProcessDefinitionHandler.getType(), activateProcessDefinitionHandler);

    // if we have custom job handlers, register them
    if (getCustomJobHandlers() != null) {
        for (JobHandler customJobHandler : getCustomJobHandlers()) {
            jobHandlers.put(customJobHandler.getType(), customJobHandler);
        }
    }
}
 

import org.activiti.engine.impl.jobexecutor.AsyncContinuationJobHandler; //导入依赖的package包/类
protected void scheduleAtomicOperationAsync(AtomicOperation executionOperation) {
    JobEntity message = new JobEntity();
    message.setJobType(Job.JOB_TYPE_MESSAGE);
    message.setRevision(1);
    message.setExecution(this);
    message.setExclusive(getActivity().isExclusive());
    message.setJobHandlerType(AsyncContinuationJobHandler.TYPE);
    // At the moment, only AtomicOperationTransitionCreateScope can be performed asynchronously,
    // so there is no need to pass it to the handler

    ProcessEngineConfiguration processEngineConfig = Context.getCommandContext().getProcessEngineConfiguration();

    if (processEngineConfig.getAsyncExecutor().isActive()) {
        GregorianCalendar expireCal = new GregorianCalendar();
        expireCal.setTime(processEngineConfig.getClock().getCurrentTime());
        expireCal.add(Calendar.SECOND, processEngineConfig.getLockTimeAsyncJobWaitTime());
        message.setLockExpirationTime(expireCal.getTime());
    }

    // Inherit tenant id (if applicable)
    if (getTenantId() != null) {
        message.setTenantId(getTenantId());
    }

    callJobProcessors(JobProcessorContext.Phase.BEFORE_CREATE, message, Context.getProcessEngineConfiguration());
    Context.getCommandContext().getJobEntityManager().send(message);
}
 

import org.activiti.engine.impl.jobexecutor.AsyncContinuationJobHandler; //导入依赖的package包/类
protected void scheduleAtomicOperationAsync(AtomicOperation executionOperation) {
  MessageEntity message = new MessageEntity();
  message.setExecution(this);
  message.setJobHandlerType(AsyncContinuationJobHandler.TYPE);
  // At the moment, only AtomicOperationTransitionCreateScope can be performed asynchronously,
  // so there is no need to pass it to the handler

  Context
    .getCommandContext()
    .getJobManager()
    .send(message);
}
 

import org.activiti.engine.impl.jobexecutor.AsyncContinuationJobHandler; //导入依赖的package包/类
protected void scheduleAtomicOperationAsync(AtomicOperation executionOperation) {
  MessageEntity message = new MessageEntity();
  message.setExecution(this);
  message.setExclusive(getActivity().isExclusive());
  message.setJobHandlerType(AsyncContinuationJobHandler.TYPE);
  // At the moment, only AtomicOperationTransitionCreateScope can be performed asynchronously,
  // so there is no need to pass it to the handler

  Context
    .getCommandContext()
    .getJobManager()
    .send(message);
}
 

import org.activiti.engine.impl.jobexecutor.AsyncContinuationJobHandler; //导入依赖的package包/类
protected void scheduleAtomicOperationAsync(AtomicOperation executionOperation) {
  MessageEntity message = new MessageEntity();
  message.setExecution(this);
  message.setExclusive(getActivity().isExclusive());
  message.setJobHandlerType(AsyncContinuationJobHandler.TYPE);
  // At the moment, only AtomicOperationTransitionCreateScope can be performed asynchronously,
  // so there is no need to pass it to the handler

  Context
    .getCommandContext()
    .getJobEntityManager()
    .send(message);
}