import org.activiti.engine.impl.pvm.process.TransitionImpl; //导入依赖的package包/类
/**
 * @param fireActivityCompletionEvent This method can be called from other places (like {@link #takeAll(List, List)}), where the event is already fired. In that case, false is passed an no second event is fired.
 */
@Override
public void take(PvmTransition transition, boolean fireActivityCompletionEvent) {

    if (fireActivityCompletionEvent) {
        fireActivityCompletedEvent();
    }

    if (this.transition != null) {
        throw new PvmException("already taking a transition");
    }
    if (transition == null) {
        throw new PvmException("transition is null");
    }
    setActivity((ActivityImpl) transition.getSource());
    setTransition((TransitionImpl) transition);
    performOperation(AtomicOperation.TRANSITION_NOTIFY_LISTENER_END);
}
 

import org.activiti.engine.impl.pvm.process.TransitionImpl; //导入依赖的package包/类
public void turnTransition(String taskId, String activityId,  
        Map<String, Object> variables) throws Exception {  
    // 当前节点  
    ActivityImpl currActivity = findActivitiImpl(taskId, null);  
    // 清空当前流向  
    List<PvmTransition> oriPvmTransitionList = clearTransition(currActivity);  
  
    // 创建新流向  
    TransitionImpl newTransition = currActivity.createOutgoingTransition();  
    // 目标节点  
    ActivityImpl pointActivity = findActivitiImpl(taskId, activityId);  
    // 设置新流向的目标节点  
    newTransition.setDestination(pointActivity);  
  
    // 执行转向任务  
    taskService.complete(taskId, variables);  
    // 删除目标节点新流入  
    pointActivity.getIncomingTransitions().remove(newTransition);  
  
    // 还原以前流向  
    restoreTransition(currActivity, oriPvmTransitionList);  
}
 

import org.activiti.engine.impl.pvm.process.TransitionImpl; //导入依赖的package包/类
@Override
protected void executeParse(BpmnParse bpmnParse, SequenceFlow sequenceFlow) {

    ScopeImpl scope = bpmnParse.getCurrentScope();

    ActivityImpl sourceActivity = scope.findActivity(sequenceFlow.getSourceRef());
    ActivityImpl destinationActivity = scope.findActivity(sequenceFlow.getTargetRef());

    Expression skipExpression;
    if (StringUtils.isNotEmpty(sequenceFlow.getSkipExpression())) {
        ExpressionManager expressionManager = bpmnParse.getExpressionManager();
        skipExpression = expressionManager.createExpression(sequenceFlow.getSkipExpression());
    } else {
        skipExpression = null;
    }

    TransitionImpl transition = sourceActivity.createOutgoingTransition(sequenceFlow.getId(), skipExpression);
    bpmnParse.getSequenceFlows().put(sequenceFlow.getId(), transition);
    transition.setProperty("name", sequenceFlow.getName());
    transition.setProperty("documentation", sequenceFlow.getDocumentation());
    transition.setDestination(destinationActivity);

    if (StringUtils.isNotEmpty(sequenceFlow.getConditionExpression())) {
        Condition expressionCondition = new UelExpressionCondition(sequenceFlow.getConditionExpression());
        transition.setProperty(PROPERTYNAME_CONDITION_TEXT, sequenceFlow.getConditionExpression());
        transition.setProperty(PROPERTYNAME_CONDITION, expressionCondition);
    }

    createExecutionListenersOnTransition(bpmnParse, sequenceFlow.getExecutionListeners(), transition);

}
 

import org.activiti.engine.impl.pvm.process.TransitionImpl; //导入依赖的package包/类
public void createBPMNEdge(String key, List<GraphicInfo> graphicList) {
    FlowElement flowElement = bpmnModel.getFlowElement(key);
    if (flowElement != null && sequenceFlows.containsKey(key)) {
        TransitionImpl sequenceFlow = sequenceFlows.get(key);
        List<Integer> waypoints = new ArrayList<>();
        for (GraphicInfo waypointInfo : graphicList) {
            waypoints.add((int) waypointInfo.getX());
            waypoints.add((int) waypointInfo.getY());
        }
        sequenceFlow.setWaypoints(waypoints);
    } else if (bpmnModel.getArtifact(key) != null) {
        // it's an association, so nothing to do
    } else {
        LOGGER.warn("Invalid reference in 'bpmnElement' attribute, sequenceFlow {} not found", key);
    }
}
 

import org.activiti.engine.impl.pvm.process.TransitionImpl; //导入依赖的package包/类
@Override
protected void eventNotificationsCompleted(InterpretableExecution execution) {
  TransitionImpl transition = execution.getTransition();
  ActivityImpl destination = null;
  if(transition == null) { // this is null after async cont. -> transition is not stored in execution
    destination = (ActivityImpl) execution.getActivity();
  } else {
    destination = transition.getDestination();
  }    
  ActivityImpl activity = (ActivityImpl) execution.getActivity();
  if (activity!=destination) {
    ActivityImpl nextScope = AtomicOperationTransitionNotifyListenerTake.findNextScope(activity, destination);
    execution.setActivity(nextScope);
    execution.performOperation(TRANSITION_CREATE_SCOPE);
  } else {
    execution.setTransition(null);
    execution.setActivity(destination);
    execution.performOperation(ACTIVITY_EXECUTE);
  }
}
 

import org.activiti.engine.impl.pvm.process.TransitionImpl; //导入依赖的package包/类
public void parseBPMNEdge(Element bpmnEdgeElement, ProcessDefinitionEntity processDefinition) {
  String sequenceFlowId = bpmnEdgeElement.attribute("bpmnElement");
  if (sequenceFlowId != null && !"".equals(sequenceFlowId)) {
    TransitionImpl sequenceFlow = sequenceFlows.get(sequenceFlowId);
    if (sequenceFlow != null) {
      List<Element> waypointElements = bpmnEdgeElement.elementsNS(BpmnParser.OMG_DI_NS, "waypoint");
      if (waypointElements.size() >= 2) {
        List<Integer> waypoints = new ArrayList<Integer>();
        for (Element waypointElement : waypointElements) {
          waypoints.add(parseDoubleAttribute(waypointElement, "x", waypointElement.attribute("x"), true).intValue());
          waypoints.add(parseDoubleAttribute(waypointElement, "y", waypointElement.attribute("y"), true).intValue());
        }
        sequenceFlow.setWaypoints(waypoints);
      } else {
        addError("Minimum 2 waypoint elements must be definted for a 'BPMNEdge'", bpmnEdgeElement);
      }
    } else {
      addError("Invalid reference in 'bpmnElement' attribute, sequenceFlow " + sequenceFlowId + "not found", bpmnEdgeElement);
    }
  } else {
    addError("'bpmnElement' attribute is required on BPMNEdge", bpmnEdgeElement);
  }
}
 

import org.activiti.engine.impl.pvm.process.TransitionImpl; //导入依赖的package包/类
public String findParallelGatewayId(ActivityImpl activityImpl) {  
    List<PvmTransition> incomingTransitions = activityImpl  
            .getOutgoingTransitions();  
    for (PvmTransition pvmTransition : incomingTransitions) {  
        TransitionImpl transitionImpl = (TransitionImpl) pvmTransition;  
        activityImpl = transitionImpl.getDestination();  
        String type = (String) activityImpl.getProperty("type");  
        if ("parallelGateway".equals(type)) {// 并行路线  
            String gatewayId = activityImpl.getId();  
            String gatewayType = gatewayId.substring(gatewayId  
                    .lastIndexOf("_") + 1);  
            if ("END".equals(gatewayType.toUpperCase())) {  
                return gatewayId.substring(0, gatewayId.lastIndexOf("_"))  
                        + "_start";  
            }  
        }  
    }  
    return null;  
}
 

import org.activiti.engine.impl.pvm.process.TransitionImpl; //导入依赖的package包/类
/** 
 * 根据当前节点，查询输出流向是否为并行终点，如果为并行终点，则拼装对应的并行起点ID 
 *  
 * @param activityImpl 
 *            当前节点 
 * @return 
 */  
private static String findParallelGatewayId(ActivityImpl activityImpl) {  
    List<PvmTransition> incomingTransitions = activityImpl  
            .getOutgoingTransitions();  
    for (PvmTransition pvmTransition : incomingTransitions) {  
        TransitionImpl transitionImpl = (TransitionImpl) pvmTransition;  
        activityImpl = transitionImpl.getDestination();  
        String type = (String) activityImpl.getProperty("type");  
        if ("parallelGateway".equals(type)) {// 并行路线  
            String gatewayId = activityImpl.getId();  
            String gatewayType = gatewayId.substring(gatewayId  
                    .lastIndexOf("_") + 1);  
            if ("END".equals(gatewayType.toUpperCase())) {  
                return gatewayId.substring(0, gatewayId.lastIndexOf("_"))  
                        + "_start";  
            }  
        }  
    }  
    return null;  
}
 

import org.activiti.engine.impl.pvm.process.TransitionImpl; //导入依赖的package包/类
/** 
 * 流程转向操作 
 *  
 * @param taskId 
 *            当前任务ID 
 * @param activityId 
 *            目标节点任务ID 
 * @param variables 
 *            流程变量 
 * @throws Exception 
 */  
private static void turnTransition(String taskId, String activityId,  
        Map<String, Object> variables) throws Exception {  
    // 当前节点  
    ActivityImpl currActivity = findActivitiImpl(taskId, null);  
    // 清空当前流向  
    List<PvmTransition> oriPvmTransitionList = clearTransition(currActivity);  
  
    // 创建新流向  
    TransitionImpl newTransition = currActivity.createOutgoingTransition();  
    // 目标节点  
    ActivityImpl pointActivity = findActivitiImpl(taskId, activityId);  
    // 设置新流向的目标节点  
    newTransition.setDestination(pointActivity);  
  
    // 执行转向任务  
    taskService.complete(taskId, variables);  
    // 删除目标节点新流入  
    pointActivity.getIncomingTransitions().remove(newTransition);  
  
    // 还原以前流向  
    restoreTransition(currActivity, oriPvmTransitionList);  
}
 

import org.activiti.engine.impl.pvm.process.TransitionImpl; //导入依赖的package包/类
public void parseBPMNEdge(Element bpmnEdgeElement) {
  String bpmnElementId = bpmnEdgeElement.attribute("bpmnElement");
  if (bpmnElementId != null && !"".equals(bpmnElementId)) {
    TransitionImpl sequenceFlow = sequenceFlows.get(bpmnElementId);
    PhysicalAssociation physicalAssociation = physicalAssociations.get(bpmnElementId);
    AbstractDataAssociation dataAssociation = dataAssociations.get(bpmnElementId);
    if (sequenceFlow != null) {
      parseWaypoints(bpmnEdgeElement, sequenceFlow);
    } else if(null != physicalAssociation) {
      parseWaypoints(bpmnEdgeElement, physicalAssociation);
    } else if(null != dataAssociation) {
      parseWaypoints(bpmnEdgeElement, dataAssociation);
    } else if(!elementIds.contains(bpmnElementId)) { // it might not be a sequenceFlow but it might still reference 'something'
      addError("Invalid reference in 'bpmnElement' attribute; SequenceFlow, MessageFlow, or DataAssociation " + bpmnElementId + " not found", bpmnEdgeElement);
    }
  } else {
    addError("'bpmnElement' attribute is required on BPMNEdge", bpmnEdgeElement);
  }
}
 

import org.activiti.engine.impl.pvm.process.TransitionImpl; //导入依赖的package包/类
/**
 * 流程转向操作
 * @param taskId 当前任务ID
 * @param activityId 目标节点任务ID
 * @param variables  流程变量
 * @throws Exception
 */
private void turnTransition(String taskId,String activityId,Map<String,Object> variables)throws Exception{
    //当前节点
    ActivityImpl currActivity = findActivitiImpl(taskId,null);
    //清空当前流向
    List<PvmTransition> oriPvmTransitionList =  clearTransition(currActivity);

    //创建新流向
    TransitionImpl newTransition = currActivity.createOutgoingTransition();

    //目标节点
    ActivityImpl pointActivity = findActivitiImpl(taskId,activityId);

    //设置新流向的目标节点
    newTransition.setDestination(pointActivity);

    //执行转向任务
    taskService.complete(taskId,variables);

    //删除目标节点新流入
    pointActivity.getIncomingTransitions().remove(newTransition);

}
 

import org.activiti.engine.impl.pvm.process.TransitionImpl; //导入依赖的package包/类
/**
 * 根据当前节点，查询输出流向是否为并行终点，如果为并行终点，则拼装对应的并行起点ID
 * @param activityImpl   当前节点
 * @return
 */
private String findParallelGatewayId(ActivityImpl activityImpl){
    List<PvmTransition> incomingTransitions = activityImpl.getOutgoingTransitions();

    for(PvmTransition pvmTransition : incomingTransitions){
        TransitionImpl transitionImpl = (TransitionImpl)pvmTransition;
        activityImpl = transitionImpl.getDestination();
        String type = (String)activityImpl.getProperty("type");
        if("parallelGateway".equals(type)){ //并行路线
            String gatewayId = activityImpl.getId();
            String gettewayType = gatewayId.substring(gatewayId.lastIndexOf("_")+1);
            if("END".equals(gettewayType.toUpperCase())){
                return gatewayId.substring(0, gatewayId.lastIndexOf("_"))+"_start";
            }
        }
    }

    return null;
}
 

import org.activiti.engine.impl.pvm.process.TransitionImpl; //导入依赖的package包/类
public PvmProcessDefinition buildProcessDefinition() {
    for (Object[] unresolvedTransition : unresolvedTransitions) {
        TransitionImpl transition = (TransitionImpl) unresolvedTransition[0];
        String destinationActivityName = (String) unresolvedTransition[1];
        ActivityImpl destination = processDefinition.findActivity(destinationActivityName);
        if (destination == null) {
            throw new ActivitiException("destination '" + destinationActivityName + "' not found.  (referenced from transition in '" + transition.getSource().getId() + "')");
        }
        transition.setDestination(destination);
    }
    return processDefinition;
}
 

import org.activiti.engine.impl.pvm.process.TransitionImpl; //导入依赖的package包/类
@Override
public void take(PvmTransition transition) {
    if (this.transition != null) {
        throw new PvmException("already taking a transition");
    }
    if (transition == null) {
        throw new PvmException("transition is null");
    }
    setTransition((TransitionImpl) transition);
    performOperation(AtomicOperation.TRANSITION_NOTIFY_LISTENER_END);
}
 

import org.activiti.engine.impl.pvm.process.TransitionImpl; //导入依赖的package包/类
@Override
public void setTransition(TransitionImpl transition) {
    this.transition = transition;
    if (replacedBy != null) {
        replacedBy.setTransition(transition);
    }
}
 

import org.activiti.engine.impl.pvm.process.TransitionImpl; //导入依赖的package包/类
public PvmProcessDefinition buildProcessDefinition() {
  for (Object[] unresolvedTransition: unresolvedTransitions) {
    TransitionImpl transition = (TransitionImpl) unresolvedTransition[0];
    String destinationActivityName = (String) unresolvedTransition[1];
    ActivityImpl destination = processDefinition.findActivity(destinationActivityName);
    if (destination == null) {
      throw new RuntimeException("destination '"+destinationActivityName+"' not found.  (referenced from transition in '"+transition.getSource().getId()+"')");
    }
    transition.setDestination(destination);
  }
  return processDefinition;
}
 

import org.activiti.engine.impl.pvm.process.TransitionImpl; //导入依赖的package包/类
public void take(PvmTransition transition) {
  if (this.transition!=null) {
    throw new PvmException("already taking a transition");
  }
  if (transition==null) {
    throw new PvmException("transition is null");
  }
  setTransition((TransitionImpl) transition);
  performOperation(AtomicOperation.TRANSITION_NOTIFY_LISTENER_END);
}
 

import org.activiti.engine.impl.pvm.process.TransitionImpl; //导入依赖的package包/类
public void take(PvmTransition transition) {
  if (this.transition!=null) {
    throw new PvmException("already taking a transition");
  }
  if (transition==null) {
    throw new PvmException("transition is null");
  }
  setActivity((ActivityImpl)transition.getSource());
  setTransition((TransitionImpl) transition);
  performOperation(AtomicOperation.TRANSITION_NOTIFY_LISTENER_END);
}
 

import org.activiti.engine.impl.pvm.process.TransitionImpl; //导入依赖的package包/类
/**
 * Parses one process (ie anything inside a <process> element).
 * 
 * @param processElement
 *          The 'process' element.
 * @return The parsed version of the XML: a {@link ProcessDefinitionImpl}
 *         object.
 */
public ProcessDefinitionEntity parseProcess(Element processElement) {
  // reset all mappings that are related to one process definition
  sequenceFlows = new HashMap<String, TransitionImpl>();

  ProcessDefinitionEntity processDefinition = new ProcessDefinitionEntity();

  /*
   * Mapping object model - bpmn xml: processDefinition.id -> generated by
   * activiti engine processDefinition.key -> bpmn id (required)
   * processDefinition.name -> bpmn name (optional)
   */
  processDefinition.setKey(processElement.attribute("id"));
  processDefinition.setName(processElement.attribute("name"));
  processDefinition.setCategory(rootElement.attribute("targetNamespace"));
  processDefinition.setProperty(PROPERTYNAME_DOCUMENTATION, parseDocumentation(processElement));
  processDefinition.setTaskDefinitions(new HashMap<String, TaskDefinition>());
  processDefinition.setDeploymentId(deployment.getId());

  if (LOGGER.isLoggable(Level.FINE)) {
    LOGGER.fine("Parsing process " + processDefinition.getKey());
  }
  parseScope(processElement, processDefinition);

  for (BpmnParseListener parseListener : parseListeners) {
    parseListener.parseProcess(processElement, processDefinition);
  }

  return processDefinition;
}
 

import org.activiti.engine.impl.pvm.process.TransitionImpl; //导入依赖的package包/类
/**
 * Parses all sequence flow of a scope.
 * 
 * @param processElement
 *          The 'process' element wherein the sequence flow are defined.
 * @param scope
 *          The scope to which the sequence flow must be added.
 */
public void parseSequenceFlow(Element processElement, ScopeImpl scope) {
  for (Element sequenceFlowElement : processElement.elements("sequenceFlow")) {

    String id = sequenceFlowElement.attribute("id");
    String sourceRef = sequenceFlowElement.attribute("sourceRef");
    String destinationRef = sequenceFlowElement.attribute("targetRef");

    // Implicit check: sequence flow cannot cross (sub) process boundaries: we
    // don't do a processDefinition.findActivity here
    ActivityImpl sourceActivity = scope.findActivity(sourceRef);
    ActivityImpl destinationActivity = scope.findActivity(destinationRef);

    if (sourceActivity != null && destinationActivity != null) {

      TransitionImpl transition = sourceActivity.createOutgoingTransition(id);
      sequenceFlows.put(id, transition);
      transition.setProperty("name", sequenceFlowElement.attribute("name"));
      transition.setProperty("documentation", parseDocumentation(sequenceFlowElement));
      transition.setDestination(destinationActivity);
      parseSequenceFlowConditionExpression(sequenceFlowElement, transition);
      parseExecutionListenersOnTransition(sequenceFlowElement, transition);

      for (BpmnParseListener parseListener : parseListeners) {
        parseListener.parseSequenceFlow(sequenceFlowElement, scope, transition);
      }

    } else if (sourceActivity == null) {
      addError("Invalid source '" + sourceRef + "' of sequence flow '" + id + "'", sequenceFlowElement);
    } else if (destinationActivity == null) {
      addError("Invalid destination '" + destinationRef + "' of sequence flow '" + id + "'", sequenceFlowElement);
    }

  }
}