开源工作流Fireflow源码分析之运行流程二

TranstionInstance.java

 /* 触发弧线

     * @see org.fireflow.kernel.IEdgeInstance#take(org.fireflow.kernel.IToken)

     */

    public boolean take(IToken token) throws KernelException {

    	//触发弧线taking事件

        EdgeInstanceEvent e = new EdgeInstanceEvent(this);

        e.setToken(token);

        e.setEventType(EdgeInstanceEvent.ON_TAKING_THE_TOKEN);



        for (int i = 0; this.eventListeners != null && i < this.eventListeners.size(); i++) {

            IEdgeInstanceEventListener listener =  this.eventListeners.get(i);

            //调用TransitionInstanceExtension监听器来计算弧线上的条件表达式,在后面有说明

            listener.onEdgeInstanceEventFired(e); 

        }

        //获取到流向哪个节点     

        INodeInstance nodeInst = this.getLeavingNodeInstance(); 

        //设置弧线上的权值,对于同步器到环节，权值没有什么作用，而对于activity到同步器，权值作用于同步器的汇聚算法

        token.setValue(this.getWeight());

        boolean alive = token.isAlive();

        //下一个节点触发,

//如果是同步器到activity

//详看是开源工作流Fireflow源码分析之ActivityInstance fired

//如果是activity到同步器

//详看是开源工作流Fireflow源码分析之SynchronizerInstance fired

        nodeInst.fire(token);

        return alive;

}

/* 获取转移线上的权值

     * @see org.fireflow.kernel.IEdgeInstance#getWeight()

     */

    public int getWeight() {

        if (weight == 0) {

            if (enteringNodeInstance instanceof StartNodeInstance) {

                weight=1;

                return weight;

                //如果前驱结点是开始节点，那么权值规定为1

            } else if (leavingNodeInstance instanceof EndNodeInstance) {

                weight=1;

                return weight;

                //如果后继结点为结束节点，那么权值规定为1   

            } else if (leavingNodeInstance instanceof ActivityInstance) {

                SynchronizerInstance synchronizerInstance = (SynchronizerInstance) enteringNodeInstance;

                int weight = synchronizerInstance.getVolume() / enteringNodeInstance.getLeavingTransitionInstances().size();

                return weight;//s->t (s)

                //如果弧线的后继结点 是 activity结点，那么弧线的权值=前驱同步器结点的容量/输出弧线的数量

            } else if (leavingNodeInstance instanceof SynchronizerInstance) {

                SynchronizerInstance synchronizerInstance = (SynchronizerInstance) leavingNodeInstance;

                int weight = synchronizerInstance.getVolume() / leavingNodeInstance.getEnteringTransitionInstances().size();

                return weight;

                //如果后继结点是同步器节点，那么权值=同步器的容量/同步器的输入弧线的数量  // t-s

            }

        }



        return weight;

    }

TransitionInstanceExtension.java

 

 /* TransitionInstance的监听器的监听方法

     * @see org.fireflow.kernel.event.IEdgeInstanceEventListener#onEdgeInstanceEventFired(org.fireflow.kernel.event.EdgeInstanceEvent)

     */

    public void onEdgeInstanceEventFired(EdgeInstanceEvent e) throws KernelException {

    	//如果当前事件是taking

        if (e.getEventType() == EdgeInstanceEvent.ON_TAKING_THE_TOKEN) {

            IToken token = e.getToken();

            //取到事件的发生源

            ITransitionInstance transInst = (ITransitionInstance) e.getSource();

            //取到事件的发生条件

            String condition = transInst.getTransition().getCondition();

            //计算条件

            calculateTheAliveValue(token, condition);

            //如果系统设置为允许保存运行轨迹

            if (rtCtx.isEnableTrace() && token.isAlive()) {

                Transition transition = transInst.getTransition();

                IWFElement fromNode = transition.getFromNode();

                int minorNumber = 1;

                //如果是环节到同步器

                if (fromNode instanceof Activity){

                    minorNumber=2;

                }else{

                    minorNumber =1;

                }

                //创建一个运行轨迹实例

                ProcessInstanceTrace trace = new ProcessInstanceTrace();

                //设置流程实例

                trace.setProcessInstanceId(e.getToken().getProcessInstanceId());

                //设置步骤

                trace.setStepNumber(e.getToken().getStepNumber());

                //设置事件的发生类型

                trace.setType(ProcessInstanceTrace.TRANSITION_TYPE);

                //设置from节点

                trace.setFromNodeId(transInst.getTransition().getFromNode().getId());

               //设置to节点

                trace.setToNodeId(transInst.getTransition().getToNode().getId());

                //设置转移张的id

                trace.setEdgeId(transInst.getTransition().getId());

                trace.setMinorNumber(minorNumber);

                rtCtx.getPersistenceService().saveOrUpdateProcessInstanceTrace(trace);

            }

        }



    }

 

  /**

     * 计算value值

     * @param token

     * @param condition

     * @throws EngineException

     */

    public void calculateTheAliveValue(IToken token, String condition)throws EngineException {



        if (!token.isAlive()) {

            return;//如果token是dead状态，表明synchronizer的joinpoint是dead状态，不需要重新计算。

        }



        //1、如果没有转移条件，默认为true

        if (condition == null || condition.trim().equals("")) {

            token.setAlive(true);

            return;

        }

        //2、default类型的不需要计算其alive值，该值由synchronizer决定

        if (condition.trim().equals(ConditionConstant.DEFAULT)) {

            return;

        }



                try{

        //3、计算EL表达式

        //表达式的变量用的是流程变量,表达式是在流程定义的时候就设置好  

	        boolean alive = determineTheAliveOfToken(token.getProcessInstance().getProcessInstanceVariables(), condition);

	        token.setAlive(alive);

        }catch(Exception ex){

        	throw new EngineException(token.getProcessInstanceId(),token.getProcessInstance().getWorkflowProcess(),token.getNodeId(),ex.getMessage());

        }



    }

  /**

     * 执行分支判断策略，即设置token的alive属性 首先，如果this.alive==false,则所有的token的Alive属性皆为false

     * 然后，如果在nexttransitionList中有值，则直接执行列表中的tansition

     * 否则，通过计算Transition的表达式来确定下一个transition,

     * vars:表达式变量

     * condition:表达式

     * @param transInst

     * @return

     */

    private boolean determineTheAliveOfToken(Map<String ,Object> vars, String condition) throws Exception{



        

        //注意这里调用spring中定义的的表达式解析器，

        IConditionResolver elResolver = this.rtCtx.getConditionResolver();

        //通过计算transition上的表达式来确定alive的值

        Boolean b = elResolver.resolveBooleanExpression(vars, condition);



        return b;

    }