写一个简单的工作流(二)

    hoho，今天完成了选择路由的实现，完成了配置文件的读写和解析，流程定义文件还是决定采用xml文件，不过与其他工作流引擎采用的xml完全不同，因为是基于petri网的，因此引入了place的概念，比如下面这个4个节点的顺序路由的流程：

xml 代码

 

1. <workflow maxCases="100">  
2.     <node type="start" name="start" id="0">  
3.         <inputs>  
4.             <place id="1" />  
5.         </inputs>  
6.         <outputs>  
7.             <place id="2" />  
8.         </outputs>  
9.     </node>  
10.     <node name="hello" id="1" resource="user">  
11.         <conditions type="and">  
12.             <condition  
13.                 class="net.rubyeye.insect.workflow.impl.NullHandler" value="false"  
14.                 variable-name="name" />  
15.         </conditions>  
16.         <handler  
17.             class="net.rubyeye.insect.workflow.test.HelloWorldHandler" />  
18.         <inputs>  
19.             <place id="2" />  
20.         </inputs>  
21.         <outputs>  
22.             <place id="3" />  
23.         </outputs>  
24.     </node>  
25.     <node name="calc" id="2" resource="user">  
26.         <conditions type="and">  
27.             <condition variable-name="num">  
28.                 <exp>  
29.                     <![CDATA[num<=1000]]>  
30.                 </exp>  
31.             </condition>  
32.             <conditions type="or">  
33.                 <condition variable-name="num">  
34.                     <exp>  
35.                         <![CDATA[num>=10]]>  
36.                     </exp>  
37.                 </condition>  
38.                 <condition  
39.                     class="net.rubyeye.insect.workflow.impl.NullHandler" value="false"  
40.                     variable-name="name" />  
41.             </conditions>  
42.         </conditions>  
43.         <handler  
44.             class="net.rubyeye.insect.workflow.test.CalculateHandler" />  
45.         <inputs>  
46.             <place id="3" />  
47.         </inputs>  
48.         <outputs>  
49.             <place id="4" />  
50.         </outputs>  
51.     </node>  
52.     <node type="end" name="hello" id="3">  
53.         <inputs>  
54.             <place id="4" />  
55.         </inputs>  
56.         <outputs>  
57.             <place id="5" />  
58.         </outputs>  
59.     </node>  
60. </workflow>  
61.     

 
并行路由和选择路由引入了and-split,and-join,or-split,or-join四种transition，比如and-split，它就有多个输出place：

xml 代码

 

1. <node name="split" type="and-split" id="1" resource="user">  
2.         <inputs>  
3.             <place id="2" />  
4.         </inputs>  
5.         <outputs>  
6.             <place id="3" />  
7.             <place id="4" />  
8.         </outputs>  
9.     </node>  

   Place和Transition都有条件，用于决定操作是否执行，Transition额外指定了驱动的资源，这一点非常重要，资源可能是用户、用户组、某个时间点定时事件、特定消息等等。初步有个想法写一个GUI的流程定义工具，不过我对GUI编程了解有限，先暂时推后了。
   今天额外发现的一个好处就是，引入Place之后，我可以轻易地将不同的流程连接起来组织成一个更复杂的流程，仅仅是需要修改各个流程的开始和结束的节点的输入输出库所,从而实现了层次化的Petri网,，类似代码：

java 代码

 

1. WorkFlow sequence = wm.getWorkFlow("sequence");  
2.         WorkFlow concurrency = wm.getWorkFlow("concurrency");  
3.         WorkFlow choose = wm.getWorkFlow("choose");  
4.   
5.         //组合流程  
6.         composite = new WorkFlow();  
7.         composite.setName("composite");  
8.         composite.setId(100);  
9.           
10.         wm.saveWorkFlow(composite);  
11.   
12.         //修改开始结束节点的输入输出库所  
13.         sequence.getEnd().setType(TransitionType.NORMAL);  
14.         sequence.getEnd().setOutputs(concurrency.getStart().getInputs());  
15.   
16.         concurrency.getEnd().setType(TransitionType.NORMAL);  
17.         concurrency.getEnd().setOutputs(choose.getStart().getInputs());  
18.           
19.         composite.setStart(sequence.getStart());  
20.         composite.setEnd(choose.getEnd());  
21.         List<Transition> transitions = new ArrayList<Transition>();  
22.         transitions.addAll(sequence.getTransitions());  
23.         transitions.addAll(concurrency.getTransitions());  
24.         transitions.addAll(choose.getTransitions());  
25.         composite.setTransitions(transitions);