Jbpm 流程节点

最新推荐文章于 2021-02-12 22:36:39 发布
最新推荐文章于 2021-02-12 22:36:39 发布 · 126 阅读 · 0
文章标签：

#java #数据库

1、Node节点
Node节点是一个自动完成节点，如果没有在Node节点上定义Action，流程达到Node节点后不会停留，而是继续往下执行到Node节点的下一个节点。利用之前的Helloworld例子，我们在Node节点上加上一个Action(Action的执行是在node-enter之后node-leave之前)
Xml代码 复制代码 收藏代码
  1. <nodename="node1">
  2. <actionclass="com.royzhou.action.NodeAction"></action>
  3. <transitionto="state1"></transition>
  4. </node> 
	<node name="node1">
		<action class="com.royzhou.action.NodeAction"></action>
		<transition to="state1"></transition>
	</node>

Action类如下：
Java代码 复制代码 收藏代码
  1. packagecom.royzhou.action;
  3. importorg.jbpm.graph.def.ActionHandler;
  4. importorg.jbpm.graph.exe.ExecutionContext;
  6. publicclassNodeActionimplementsActionHandler{
  7. publicvoidexecute(ExecutionContextexecutionContext)throwsException{
  8. System.out.println("nodeaction……………………");
  9. }
  10. }
package com.royzhou.action;

import org.jbpm.graph.def.ActionHandler;
import org.jbpm.graph.exe.ExecutionContext;

public class NodeAction implements ActionHandler {
	public void execute(ExecutionContext executionContext) throws Exception {
		System.out.println("node action……………………");
	}
}

测试类如下：
Java代码 复制代码 收藏代码
  1. packagecom.royzhou.test;
  3. importjava.io.FileInputStream;
  4. importjava.io.FileNotFoundException;
  5. importjava.util.zip.ZipInputStream;
  7. importorg.jbpm.JbpmConfiguration;
  8. importorg.jbpm.JbpmContext;
  9. importorg.jbpm.graph.def.ProcessDefinition;
  10. importorg.jbpm.graph.exe.ProcessInstance;
  11. importorg.jbpm.graph.exe.Token;
  13. publicclassHelloWorldDB{
  14. publicstaticvoiddeploy()throwsFileNotFoundException{
  15. JbpmConfigurationjbpmConfiguration=JbpmConfiguration.getInstance();
  16. JbpmContextjbpmContext=jbpmConfiguration.createJbpmContext();
  17. try{
  18. FileInputStreamfis=newFileInputStream("F:/workspace/jbpm-test/src/main/jpdl/helloworld/helloworld.zip");
  19. ZipInputStreamzis=newZipInputStream(fis);
  20. ProcessDefinitionprocessDefinition=ProcessDefinition.parseParZipInputStream(zis);
  21. jbpmContext.deployProcessDefinition(processDefinition);
  22. fis.close();
  23. zis.close();
  24. }catch(Exceptione){
  25. e.printStackTrace();
  26. }finally{
  27. jbpmContext.close();
  28. }
  29. }
  31. publicstaticvoidmain(String[]args)throwsFileNotFoundException{
  32. HelloWorldDB.deploy();
  33. JbpmConfigurationjbpmConfiguration=JbpmConfiguration.getInstance();
  34. JbpmContextjbpmContext=jbpmConfiguration.createJbpmContext();
  35. jbpmContext.setActorId("royzhou");
  36. //获取最新版本的流程定义对象
  37. ProcessDefinitionprocessDefinition=jbpmContext.getGraphSession().findLatestProcessDefinition("helloworld");
  38. ProcessInstanceprocessInstance=newProcessInstance(processDefinition);
  39. //得到流程令牌
  40. Tokentoken=processInstance.getRootToken();
  42. //打印流程当前所处节点
  43. System.out.println("1:流程现在所处节点："+token.getNode().getName());
  45. //触发流程流转到下一个节点Node
  46. token.signal();
  48. /**
  49. *注意因为Node节点设置Action
  50. *所以流程会停留在Node节点
  51. */
  52. System.out.println("2:流程现在所处节点："+token.getNode().getName());
  54. //触发流程流转到下一个节点State
  55. token.signal();
  56. System.out.println("3:流程现在所处节点："+token.getNode().getName());
  57. token.signal();
  58. System.out.println("4:流程现在所处节点："+token.getNode().getName());
  59. System.out.println("流程状态是否结束："+token.getProcessInstance().hasEnded());
  60. jbpmContext.close();
  61. }
  62. }
package com.royzhou.test;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.zip.ZipInputStream;

import org.jbpm.JbpmConfiguration;
import org.jbpm.JbpmContext;
import org.jbpm.graph.def.ProcessDefinition;
import org.jbpm.graph.exe.ProcessInstance;
import org.jbpm.graph.exe.Token;

public class HelloWorldDB {
	public static void deploy() throws FileNotFoundException {
		JbpmConfiguration jbpmConfiguration = JbpmConfiguration.getInstance();
		JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();
		try {
			FileInputStream fis = new FileInputStream("F:/workspace/jbpm-test/src/main/jpdl/helloworld/helloworld.zip ");
			ZipInputStream zis = new ZipInputStream(fis);
			ProcessDefinition processDefinition = ProcessDefinition.parseParZipInputStream(zis);
			jbpmContext.deployProcessDefinition(processDefinition);
			fis.close();
			zis.close();
		} catch(Exception e) {
			e.printStackTrace();
		} finally {
			jbpmContext.close();
		}
	}
	
	public static void main(String[] args) throws FileNotFoundException {
		HelloWorldDB.deploy();
		JbpmConfiguration jbpmConfiguration = JbpmConfiguration.getInstance();
		JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();
		jbpmContext.setActorId("royzhou");
		//获取最新版本的流程定义对象
		ProcessDefinition processDefinition = jbpmContext.getGraphSession().findLatestProcessDefinition("helloworld");
		ProcessInstance processInstance = new ProcessInstance(processDefinition);
		//得到流程令牌
		Token token = processInstance.getRootToken();
		
		//打印流程当前所处节点
		System.out.println("1:流程现在所处节点：" + token.getNode().getName());
		
		//触发流程流转到下一个节点Node
		token.signal();
		
		/**
		 * 注意因为Node节点设置Action
		 * 所以流程会停留在Node节点
		 */
		System.out.println("2:流程现在所处节点：" + token.getNode().getName());
		
		//触发流程流转到下一个节点State
		token.signal();
		System.out.println("3:流程现在所处节点：" + token.getNode().getName());
token.signal();
		System.out.println("4:流程现在所处节点：" + token.getNode().getName());
		System.out.println("流程状态是否结束：" + token.getProcessInstance().hasEnded());
		jbpmContext.close();
	}
}

测试结果如下：（验证了在Node上设置Action的时候,流程处于等待状态）
1:流程现在所处节点：start-state1
node action……………………
2:流程现在所处节点：node1
3:流程现在所处节点：state1
4:流程现在所处节点：end-state1
流程状态是否结束：true

2、State节点
State节点属性类似Node，不过当流程流转到State节点时就会停下来，直到外部向其发送流转的命令，如signal().

3、Task-Node
Task Node节点在Jbpm中是很重要的一个节点，可以用来添加任务，产生任务实例。一个Task Node 可以定义多个Task，为Task分配执行人等等。下面我们通过一个例子来解释Task Node。
Xml代码 复制代码 收藏代码
  1. <?xmlversion="1.0"encoding="UTF-8"?>
  3. <process-definitionxmlns="urn:jbpm.org:jpdl-3.2"name="tasknode">
  4. <start-statename="start-state1">
  5. <transitionto="task-node1"></transition>
  6. </start-state>
  7. <task-nodename="task-node1">
  8. <taskname="mytask">
  9. <assignmentactor-id="royzhou"></assignment>
  10. </task>
  11. <transitionto="end-state1"></transition>
  12. </task-node>
  13. <end-statename="end-state1"></end-state>
  14. </process-definition> 
	<?xml version="1.0" encoding="UTF-8"?>

<process-definition  xmlns="urn:jbpm.org:jpdl-3.2"  name="tasknode">
	<start-state name="start-state1">
		<transition to="task-node1"></transition>
	</start-state>
	<task-node name="task-node1">
		<task name="mytask">
			<assignment actor-id="royzhou"></assignment>
		</task>
		<transition to="end-state1"></transition>
	</task-node>
	<end-state name="end-state1"></end-state>
</process-definition>

上面流程文件定义了一个Task Node ，在Task Node下面定义了一个Task节点，分配给了royzhou这个人（实际开发中的任务分配会更加复杂）
接下来我们开始写测试类：
Java代码 复制代码 收藏代码
  1. packagecom.royzhou.test;
  3. importjava.io.FileInputStream;
  4. importjava.io.FileNotFoundException;
  5. importjava.util.zip.ZipInputStream;
  7. importorg.jbpm.JbpmConfiguration;
  8. importorg.jbpm.JbpmContext;
  9. importorg.jbpm.graph.def.ProcessDefinition;
  10. importorg.jbpm.graph.exe.ProcessInstance;
  11. importorg.jbpm.graph.exe.Token;
  13. publicclassTaskNode{
  15. publicstaticvoiddeploy()throwsFileNotFoundException{
  16. JbpmConfigurationjbpmConfiguration=JbpmConfiguration.getInstance();
  17. JbpmContextjbpmContext=jbpmConfiguration.createJbpmContext();
  18. try{
  19. FileInputStreamfis=newFileInputStream("F:/workspace/jbpm-test/src/main/jpdl/tasknode/tasknode.zip");
  20. ZipInputStreamzis=newZipInputStream(fis);
  21. ProcessDefinitionprocessDefinition=ProcessDefinition.parseParZipInputStream(zis);
  22. jbpmContext.deployProcessDefinition(processDefinition);
  23. fis.close();
  24. zis.close();
  25. }catch(Exceptione){
  26. e.printStackTrace();
  27. }finally{
  28. jbpmContext.close();
  29. }
  30. }
  32. publicstaticvoidmain(String[]args)throwsFileNotFoundException{
  33. TaskNode.deploy();
  34. JbpmConfigurationjbpmConfiguration=JbpmConfiguration.getInstance();
  35. JbpmContextjbpmContext=jbpmConfiguration.createJbpmContext();
  36. ProcessDefinitionprocessDefinition=jbpmContext.getGraphSession().findLatestProcessDefinition("tasknode");
  37. ProcessInstanceprocessInstance=newProcessInstance(processDefinition);
  38. Tokentoken=processInstance.getRootToken();
  39. token.signal();
  40. System.out.println("流程现在所处节点："+token.getNode().getName());
  41. jbpmContext.close();
  42. }
  43. }
	package com.royzhou.test;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.zip.ZipInputStream;

import org.jbpm.JbpmConfiguration;
import org.jbpm.JbpmContext;
import org.jbpm.graph.def.ProcessDefinition;
import org.jbpm.graph.exe.ProcessInstance;
import org.jbpm.graph.exe.Token;

public class TaskNode {
	
	public static void deploy() throws FileNotFoundException {
		JbpmConfiguration jbpmConfiguration = JbpmConfiguration.getInstance();
		JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();
		try {
			FileInputStream fis = new FileInputStream("F:/workspace/jbpm-test/src/main/jpdl/tasknode/tasknode.zip");
			ZipInputStream zis = new ZipInputStream(fis);
			ProcessDefinition processDefinition = ProcessDefinition.parseParZipInputStream(zis);
			jbpmContext.deployProcessDefinition(processDefinition);
			fis.close();
			zis.close();
		} catch(Exception e) {
			e.printStackTrace();
		} finally {
			jbpmContext.close();
		}
	}
	
	public static void main(String[] args) throws FileNotFoundException {
		TaskNode.deploy();
		JbpmConfiguration jbpmConfiguration = JbpmConfiguration.getInstance();
		JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();
		ProcessDefinition processDefinition = jbpmContext.getGraphSession().findLatestProcessDefinition("tasknode");
		ProcessInstance processInstance = new ProcessInstance(processDefinition);
		Token token = processInstance.getRootToken();
		token.signal();
		System.out.println("流程现在所处节点：" + token.getNode().getName());
		jbpmContext.close();
	}
}

后台打印结果：
流程现在所处节点：task-node1
查看jbpm_taskinstance表看到一个名叫mytask的任务，指定给了royzhou说明我们的任务创建成功了。
Task Node有几个比较重要的属性：
Signal：
last：最后一个完成之后继续往下流转，如果没有任务被创建直接流转到下一节点
last-wait：最后一个完成之后继续往下流转，如果没有任务被创建处于等待状态
first：只要有一个完成就继续往下流转，如果没有任务被创建直接流转下一个节点
first-wait：只要一个完成就继续往下流转，如果没有任务被创建则处于等待状态
never：必须显示调用processInstance.signal()才继续流转
unsynchronized：不停留，直接流转到下个节点

task-creates：流程流转到这个节点上时是不是自动创建任务，默认是true。通过设置为false，配合其他事件我们可以实现会签的功能。

4、Start节点
Start节点在每个流程中有且只能有一个。Start中可以配置Task，但是 配置在Start节点中的task不会调用任务分配机制。这点是不同于Task Node的。。。。

5、fork和join节点
二者是成对出现的。Fork节点可以将流程拆分成多条并行也就是将Token拆分成多个子Token，到join节点的时候再汇聚成一个Token继续往下执行
一般来说，在经过fork节点之后，必须等待每个子token都走完才会通过join节点继续往下走，但是我们可以通过修改join节点的discriminator属性来，设置为true之后只要有一个子token到达join节点，就会往下流转。不过这样做产生的一个影响就是其他没有结束的子token上的任务实例依然存在且处于等待状态，任务参与者仍然可以处理这些任务。因此，在设置join节点的discriminator为true时，我们还需要手动结束掉其他分支上的任务实例。
在fork节点中，我们可以设定条件来选择只走满足条件的分支。主要是通过之前提到的beanshell脚本来实现。举例说明一下这个实现：
流程定义由一个start节点，一个end节点，一对fork/join节点以及分支中的四个node节点组成，流程定义的xml文件如下：
Xml代码 复制代码 收藏代码
  1. <?xmlversion="1.0"encoding="UTF-8"?>
  2. <process-definitionxmlns="urn:jbpm.org:jpdl-3.2"name="forkjoin">
  3. <start-statename="start-state1">
  4. <transitionto="fork1"></transition>
  5. </start-state>
  6. <forkname="fork1">
  7. <script>
  8. <variablename="forkTransition"access="write"></variable>
  9. <expression>
  10. forkTransition=newArrayList();
  11. if(param&gt;1000){
  12. forkTransition.add("tonode1");
  13. forkTransition.add("tonode2");
  14. }else{
  15. forkTransition.add("tonode3");
  16. forkTransition.add("tonode4");
  17. }
  18. </expression>
  19. </script>
  20. <transitionto="node1"name="tonode1"></transition>
  21. <transitionto="node2"name="tonode2"></transition>
  22. <transitionto="node3"name="tonode3"></transition>
  23. <transitionto="node4"name="tonode4"></transition>
  24. </fork>
  25. <joinname="join1">
  26. <transitionto="end-state1"></transition>
  27. </join>
  28. <nodename="node1">
  29. <eventtype="node-enter">
  30. <script>
  31. print(&quot;node1enter&quot;);
  32. </script>
  33. </event>
  34. <transitionto="join1"></transition>
  35. </node>
  36. <nodename="node2">
  37. <eventtype="node-enter">
  38. <script>
  39. print(&quot;node2enter&quot;);
  40. </script>
  41. </event>
  42. <transitionto="join1"></transition>
  43. </node>
  44. <nodename="node3">
  45. <eventtype="node-enter">
  46. <script>
  47. print(&quot;node3enter&quot;);
  48. </script>
  49. </event>
  50. <transitionto="join1"></transition>
  51. </node>
  52. <nodename="node4">
  53. <eventtype="node-enter">
  54. <script>
  55. print(&quot;node4enter&quot;);
  56. </script>
  57. </event>
  58. <transitionto="join1"></transition>
  59. </node>
  60. <end-statename="end-state1"></end-state>
  61. </process-definition> 
<?xml version="1.0" encoding="UTF-8"?>
<process-definition  xmlns="urn:jbpm.org:jpdl-3.2"  name="forkjoin">
	<start-state name="start-state1">
		<transition to="fork1"></transition>
	</start-state>
	<fork name="fork1">
		<script>
			<variable name="forkTransition" access="write"></variable>
			<expression>
				forkTransition = new ArrayList();
				if(param &gt; 1000) {
					forkTransition.add("to node1");
					forkTransition.add("to node2");
				} else {
					forkTransition.add("to node3");
					forkTransition.add("to node4");
				}
			</expression>
		</script>
		<transition to="node1" name="to node1"></transition>
		<transition to="node2" name="to node2"></transition>
		<transition to="node3" name="to node3"></transition>
		<transition to="node4" name="to node4"></transition>
	</fork>
	<join name="join1">
		<transition to="end-state1"></transition>
	</join>
	<node name="node1">
		<event type="node-enter">
			<script>
				print(&quot;node1 enter&quot;);
			</script>
		</event>
		<transition to="join1"></transition>
	</node>
	<node name="node2">
		<event type="node-enter">
			<script>
				print(&quot;node2 enter&quot;);
			</script>
		</event>
		<transition to="join1"></transition>
	</node>
	<node name="node3">
		<event type="node-enter">
			<script>
				print(&quot;node3 enter&quot;);
			</script>
		</event>
		<transition to="join1"></transition>
	</node>
	<node name="node4">
		<event type="node-enter">
			<script>
				print(&quot;node4 enter&quot;);
			</script>
		</event>
		<transition to="join1"></transition>
	</node>
	<end-state name="end-state1"></end-state>
</process-definition>

默认情况下，当流程进入fork节点之后会分成四个分支，分别经过Node节点。在上面定义文件中我们在fork节点下做了判断，如果流程变量param>1000的时候走分支1和分支2，如果小于则走分支3和分支4。
Xml代码 复制代码 收藏代码
  1. <script>
  2. <variablename="forkTransition"access="write"></variable>
  3. <expression>
  4. forkTransition=newArrayList();
  5. if(param&gt;1000){
  6. forkTransition.add("tonode1");
  7. forkTransition.add("tonode2");
  8. }else{
  9. forkTransition.add("tonode3");
  10. forkTransition.add("tonode4");
  11. }
  12. </expression>
  13. </script> 
<script>
			<variable name="forkTransition" access="write"></variable>
			<expression>
				forkTransition = new ArrayList();
				if(param &gt; 1000) {
					forkTransition.add("to node1");
					forkTransition.add("to node2");
				} else {
					forkTransition.add("to node3");
					forkTransition.add("to node4");
				}
			</expression>
		</script>

注意这里的forkTransition必须是集合类型，它存放的是流程经过fork之后生成的分支名称。access属性设置为write表示是写入流程实例对应的Fork节点，才能生成我们指定的分支。在Expression标签下是我们做的逻辑处理，通过流程变量param来判断Fork节点具体要生成那些分支。
默认我们不为Fork节点添加script，流程到Fork节点时将生成所有transition。一旦设置了script，还必须设置一个变量，如上面的forkTransition写回流程变量中生成具体的分支。

测试类如下：（为方便测试没有将流程发布到数据库，下面测试例子也是采用相同做法）
Java代码 复制代码 收藏代码
  1. packagecom.royzhou.test;
  3. importorg.jbpm.graph.def.ProcessDefinition;
  4. importorg.jbpm.graph.exe.ProcessInstance;
  5. importorg.jbpm.graph.exe.Token;
  7. publicclassForkJoin{
  9. publicstaticvoidmain(String[]args){
  10. ProcessDefinitionprocessDefinition=ProcessDefinition.parseXmlResource("forkjoin/processDefinition.xml");
  11. ProcessInstanceprocessInstance=newProcessInstance(processDefinition);
  12. processInstance.getContextInstance().setVariable("param",10);
  13. Tokentoken=processInstance.getRootToken();
  14. token.signal();
  15. }
  16. }
package com.royzhou.test;

import org.jbpm.graph.def.ProcessDefinition;
import org.jbpm.graph.exe.ProcessInstance;
import org.jbpm.graph.exe.Token;

public class ForkJoin {
	
	public static void main(String[] args) {
		ProcessDefinition processDefinition = ProcessDefinition.parseXmlResource("forkjoin/processDefinition.xml");
		ProcessInstance processInstance = new ProcessInstance(processDefinition);
		processInstance.getContextInstance().setVariable("param", 10);
		Token token = processInstance.getRootToken();
		token.signal();
	}
}

执行成功之后后台输出：
node3 enter
node4 enter

修改我们的param改为2000再次执行，后台变为：
node1 enter
node2 enter

6、Decision节点
Decision节点是判断节点，当流程到达decision节点之后会有多个路由选择，我们可以在这个节点上定义handler或者是使用脚本等等来决定流程走向。Decision节点不同于Fork节点，它只能选择多个Transition中的其中一个，而Fork节点是并行的。
举例说明一下：
流程定义由一个start节点，一个end节点，一个Decision节点以及分支中的3个node节点组成，在Decision我们设置了delegation，使用实现DecisionHandler接口的类SelectNode来判断流程走向，它返回的结果是其中分支的名称，流程定义的xml文件如下：
Xml代码 复制代码 收藏代码
  1. <?xmlversion="1.0"encoding="UTF-8"?>
  2. <process-definitionxmlns="urn:jbpm.org:jpdl-3.2"name="decision">
  3. <start-statename="start-state1">
  4. <transitionto="decision1"></transition>
  5. </start-state>
  6. <decisionname="decision1">
  7. <handlerclass="com.royzhou.action.SelectNode"></handler>
  8. <transitionto="node1"name="tonode1"></transition>
  9. <transitionto="node2"name="tonode2"></transition>
  10. <transitionto="node3"name="tonode3"></transition>
  11. </decision>
  12. <nodename="node1">
  13. <script>
  14. print(&quot;node1enter&quot;)
  15. </script>
  16. </node>
  17. <nodename="node2">
  18. <script>
  19. print(&quot;node2enter&quot;)
  20. </script>
  21. <transitionto="end-state1"></transition>
  22. </node>
  23. <nodename="node3">
  24. <script>
  25. print(&quot;node3enter&quot;)
  26. </script>
  27. </node>
  28. <end-statename="end-state1"></end-state>
  29. </process-definition> 
	<?xml version="1.0" encoding="UTF-8"?>
<process-definition  xmlns="urn:jbpm.org:jpdl-3.2"  name="decision">
	<start-state name="start-state1">
		<transition to="decision1"></transition>
	</start-state>
	<decision name="decision1">
		<handler class="com.royzhou.action.SelectNode"></handler>
		<transition to="node1" name="to node1"></transition>
		<transition to="node2" name="to node2"></transition>
		<transition to="node3" name="to node3"></transition>
	</decision>
	<node name="node1">
		<script>
			print(&quot;node1 enter&quot;)
		</script>
	</node>
	<node name="node2">
		<script>
			print(&quot;node2 enter&quot;)
		</script>
		<transition to="end-state1"></transition>
	</node>
	<node name="node3">
		<script>
			print(&quot;node3 enter&quot;)
		</script>
	</node>
	<end-state name="end-state1"></end-state>
</process-definition>

SelectNode类：(必须实现DecisionHandler接口并重写decide方法，返回值是要走的transition的名称)
Java代码 复制代码 收藏代码
  1. packagecom.royzhou.action;
  3. importorg.jbpm.graph.exe.ExecutionContext;
  4. importorg.jbpm.graph.node.DecisionHandler;
  5. //实现DecisionHandler接口
  6. publicclassSelectNodeimplementsDecisionHandler{
  7. publicStringdecide(ExecutionContextexecutionContext)throwsException{
  8. //通过流程变量来判断要走哪个transition
  9. StringwhichWay=executionContext.getVariable("whichWay").toString();
  10. returnwhichWay;
  11. }
  12. }
package com.royzhou.action;

import org.jbpm.graph.exe.ExecutionContext;
import org.jbpm.graph.node.DecisionHandler;
//实现DecisionHandler接口
public class SelectNode implements DecisionHandler {
	public String decide(ExecutionContext executionContext) throws Exception {
		//通过流程变量来判断要走哪个transition
		String whichWay = executionContext.getVariable("whichWay").toString();
		return whichWay;
	}
}

测试类：
Java代码 复制代码 收藏代码
  1. packagecom.royzhou.test;
  3. importorg.jbpm.graph.def.ProcessDefinition;
  4. importorg.jbpm.graph.exe.ProcessInstance;
  5. importorg.jbpm.graph.exe.Token;
  7. publicclassDecision{
  9. publicstaticvoidmain(String[]args){
  10. ProcessDefinitionprocessDefinition=ProcessDefinition.parseXmlResource("decision/processDefinition.xml");
  11. ProcessInstanceprocessInstance=newProcessInstance(processDefinition);
  12. processInstance.getContextInstance().setVariable("whichWay","tonode2");
  13. Tokentoken=processInstance.getRootToken();
  14. token.signal();
  15. }
  16. }
package com.royzhou.test;

import org.jbpm.graph.def.ProcessDefinition;
import org.jbpm.graph.exe.ProcessInstance;
import org.jbpm.graph.exe.Token;

public class Decision {
	
	public static void main(String[] args) {
		ProcessDefinition processDefinition = ProcessDefinition.parseXmlResource("decision/processDefinition.xml");
		ProcessInstance processInstance = new ProcessInstance(processDefinition);
		processInstance.getContextInstance().setVariable("whichWay", "to node2");
		Token token = processInstance.getRootToken();
		token.signal();
	}
}

运行测试类，后台打印出 ：
node2 enter
修改流程变量whichWay为to node1 重新运行，后台打印出：
node1 enter
说明我们的decision节点正确处理了其走向。

除了使用delegation，我们也可以在流程文件中直接定义decision节点的expression属性，如下所示：
Xml代码 复制代码 收藏代码
  1. <decisionname="decision1"expression="#{whichWay}">
  2. <!--
  3. <handlerclass="com.royzhou.action.SelectNode"></handler>
  4. -->
  5. <transitionto="node1"name="tonode1"></transition>
  6. <transitionto="node2"name="tonode2"></transition>
  7. <transitionto="node3"name="tonode3"></transition>
  8. </decision> 
	<decision name="decision1" expression="#{whichWay}">
		<!-- 
		<handler class="com.royzhou.action.SelectNode"></handler>
		 -->
		<transition to="node1" name="to node1"></transition>
		<transition to="node2" name="to node2"></transition>
		<transition to="node3" name="to node3"></transition>
	</decision>

这里采用的是JPDL表达式来指定流程走向，JPDL表达式是一种类似EL表达式的语言。
上面expression表示从流程变量中获取whichWay这个变量作为我们流程走向的选择。

重新运行我们的测试类。发现结果与上面一种做法相同。

此外我们还可以直接在transition节点下定义condition标签，配合JPDL表达式来作为我们的判断依据
Xml代码 复制代码 收藏代码
  1. <decisionname="decision1">
  2. <transitionto="node1"name="tonode1">
  3. <conditionexpression="#{whichWay=='tonode1'}"></condition>
  4. </transition>
  5. <transitionto="node2"name="tonode2">
  6. <conditionexpression="#{whichWay=='tonode2'}"></condition>
  7. </transition>
  8. <transitionto="node3"name="tonode3">
  9. <conditionexpression="#{whichWay=='tonode3'}"></condition>
  10. </transition>
  11. </decision> 
<decision name="decision1">
		<transition to="node1" name="to node1">
			<condition expression="#{whichWay == 'to node1'}"></condition>
		</transition>
		<transition to="node2" name="to node2">
			<condition expression="#{whichWay == 'to node2'}"></condition>
		</transition>
		<transition to="node3" name="to node3">
			<condition expression="#{whichWay == 'to node3'}"></condition>
		</transition>
	</decision>

再次运行测试程序发现结果仍然一致。

由此可见 Decision节点支持我们使用delegation、condition以及expression三种方式来指定流程走向。

7、Process State节点
子流程节点可以简化我们的复杂流程。主流程与子流程之间可以共享变量。如果使用子流程，在主流程发布之前必须先发布子流程。
举例说明一下主流程与子流程及其变量共享：
主流程定义文件mainprocess/processdefinition.xml
Xml代码 复制代码 收藏代码
  1. <?xmlversion="1.0"encoding="UTF-8"?>
  2. <process-definitionxmlns="urn:jbpm.org:jpdl-3.2"name="mainprocess">
  3. <start-statename="start-state1">
  4. <transitionto="task-node1"></transition>
  5. </start-state>
  6. <task-nodename="task-node1">
  7. <eventtype="node-enter">
  8. <script>
  9. print(&quot;maintasknode1enter&quot;)
  10. </script>
  11. </event>
  12. <taskname="maintask1">
  13. <assignmentactor-id="maintask1"></assignment>
  14. </task>
  15. <transitionto="process-state1"></transition>
  16. </task-node>
  17. <process-statename="process-state1">
  18. <sub-processname="subprocess"/>
  19. <variablename="mainParam"access="read"></variable>
  20. <variablename="subParam"access="write"></variable>
  21. <transitionto="task-node2"></transition>
  22. </process-state>
  23. <task-nodename="task-node2">
  24. <eventtype="node-enter">
  25. <script>
  26. print(&quot;maintasknode2enter&quot;)
  27. </script>
  28. </event>
  29. <taskname="maintask2">
  30. <assignmentactor-id="maintask2"></assignment>
  31. </task>
  32. <transitionto="end-state1"></transition>
  33. </task-node>
  34. <end-statename="end-state1"></end-state>
  35. </process-definition> 
<?xml version="1.0" encoding="UTF-8"?>
<process-definition  xmlns="urn:jbpm.org:jpdl-3.2"  name="mainprocess">
	<start-state name="start-state1">
		<transition to="task-node1"></transition>
	</start-state>
	<task-node name="task-node1">
		<event type="node-enter">
			<script>
				print(&quot;main task node1 enter&quot;)
			</script>
		</event>
		<task name="maintask1">
			<assignment actor-id="maintask1"></assignment>
		</task>
		<transition to="process-state1"></transition>
	</task-node>
	<process-state name="process-state1">
		<sub-process name="subprocess"/>
		<variable name="mainParam" access="read"></variable>
		<variable name="subParam" access="write"></variable>
		<transition to="task-node2"></transition>
	</process-state>
	<task-node name="task-node2">
		<event type="node-enter">
			<script>
				print(&quot;main task node2 enter&quot;)
			</script>
		</event>
		<task name="maintask2">
			<assignment actor-id="maintask2"></assignment>
		</task>
		<transition to="end-state1"></transition>
	</task-node>
	<end-state name="end-state1"></end-state>
</process-definition>

主流程中设置了process-state节点，其sub-process 的name属性表示子流程的名称，
<variable name="mainParam" access="read"></variable>表示从主流程读取mainParam变量
<variable name="subParam" access="write"></variable>表示子流程将变量subParam写回主流程中。

子流程定义文件：subprocess/processdefinition.xml
Xml代码 复制代码 收藏代码
  1. <?xmlversion="1.0"encoding="UTF-8"?>
  2. <process-definitionxmlns="urn:jbpm.org:jpdl-3.2"name="subprocess">
  3. <start-statename="start-state1">
  4. <transitionto="task-node1"></transition>
  5. </start-state>
  6. <task-nodename="task-node1">
  7. <eventtype="node-enter">
  8. <script>
  9. print(&quot;subtasknode1enter&quot;)
  10. </script>
  11. </event>
  12. <taskname="subtask1">
  13. <assignmentactor-id="subtask1"></assignment>
  14. </task>
  15. <eventtype="node-enter">
  16. <script>
  17. print(&quot;subtasknode1enter&quot;)
  18. </script>
  19. </event>
  20. <transitionto="end-state1"></transition>
  21. </task-node>
  22. <end-statename="end-state1"></end-state>
  23. </process-definition> 
<?xml version="1.0" encoding="UTF-8"?>
<process-definition  xmlns="urn:jbpm.org:jpdl-3.2"  name="subprocess">
	<start-state name="start-state1">
		<transition to="task-node1"></transition>
	</start-state>
	<task-node name="task-node1">
		<event type="node-enter">
			<script>
				print(&quot;sub task node1 enter&quot;)
			</script>
		</event>
		<task name="subtask1">
			<assignment actor-id="subtask1"></assignment>
		</task>
		<event type="node-enter">
			<script>
				print(&quot;sub task node1 enter&quot;)
			</script>
		</event>
		<transition to="end-state1"></transition>
	</task-node>
	<end-state name="end-state1"></end-state>
</process-definition>

测试类：
Java代码 复制代码 收藏代码
  1. packagecom.royzhou.test;
  3. importjava.io.FileNotFoundException;
  5. importorg.jbpm.JbpmConfiguration;
  6. importorg.jbpm.JbpmContext;
  7. importorg.jbpm.graph.def.ProcessDefinition;
  8. importorg.jbpm.graph.exe.ProcessInstance;
  9. importorg.jbpm.graph.exe.Token;
  10. importorg.jbpm.taskmgmt.exe.TaskInstance;
  12. publicclassSubProcess{
  14. publicstaticvoidinit(){
  15. JbpmConfigurationjbpmConfiguration=JbpmConfiguration.getInstance();
  16. jbpmConfiguration.createSchema();
  17. }
  19. publicstaticvoiddeploySub()throwsFileNotFoundException{
  20. JbpmConfigurationjbpmConfiguration=JbpmConfiguration.getInstance();
  21. JbpmContextjbpmContext=jbpmConfiguration.createJbpmContext();
  22. try{
  23. ProcessDefinitionsubProcessDefinition=ProcessDefinition.parseXmlResource("subprocess/processDefinition.xml");
  24. jbpmContext.deployProcessDefinition(subProcessDefinition);
  25. }catch(Exceptione){
  26. e.printStackTrace();
  27. }finally{
  28. jbpmContext.close();
  29. }
  30. }
  32. publicstaticvoiddeployMain()throwsFileNotFoundException{
  33. JbpmConfigurationjbpmConfiguration=JbpmConfiguration.getInstance();
  34. JbpmContextjbpmContext=jbpmConfiguration.createJbpmContext();
  35. try{
  36. ProcessDefinitionmainProcessDefinition=ProcessDefinition.parseXmlResource("mainprocess/processDefinition.xml");
  37. jbpmContext.deployProcessDefinition(mainProcessDefinition);
  38. }catch(Exceptione){
  39. e.printStackTrace();
  40. }finally{
  41. jbpmContext.close();
  42. }
  43. }
  45. publicstaticvoidstartProcess(){
  46. JbpmConfigurationjbpmConfiguration=JbpmConfiguration.getInstance();
  47. JbpmContextjbpmContext=jbpmConfiguration.createJbpmContext();
  48. try{
  49. ProcessDefinitionprocessDefinition=jbpmContext.getGraphSession().findLatestProcessDefinition("mainprocess");
  50. ProcessInstanceprocessInstance=newProcessInstance(processDefinition);
  51. Tokentoken=processInstance.getRootToken();
  52. token.signal();
  53. }catch(Exceptione){
  54. e.printStackTrace();
  55. }finally{
  56. jbpmContext.close();
  57. }
  58. }
  60. publicstaticvoidstartMainTask1(){
  61. JbpmConfigurationjbpmConfiguration=JbpmConfiguration.getInstance();
  62. JbpmContextjbpmContext=jbpmConfiguration.createJbpmContext();
  63. try{
  64. //主流程maintask1
  65. TaskInstancemainTaskInstance1=jbpmContext.loadTaskInstance(1L);
  66. //设置主流程变量
  67. mainTaskInstance1.getContextInstance().setVariable("mainParam","主流程设置的变量");
  68. mainTaskInstance1.end();
  69. }catch(Exceptione){
  70. e.printStackTrace();
  71. }finally{
  72. jbpmContext.close();
  73. }
  74. }
  76. publicstaticvoidstartSubTask1(){
  77. JbpmConfigurationjbpmConfiguration=JbpmConfiguration.getInstance();
  78. JbpmContextjbpmContext=jbpmConfiguration.createJbpmContext();
  79. try{
  80. //子流程subtask1
  81. TaskInstancesubTaskInstance1=jbpmContext.loadTaskInstance(2L);
  82. //获取主流程变量
  83. System.out.println(subTaskInstance1.getName()+"子流程读取主流程变量，mainParam的值是："+subTaskInstance1.getContextInstance().getVariable("mainParam").toString());
  84. //设置子流程变量
  85. subTaskInstance1.getContextInstance().setVariable("subParam","子流程设置的变量");
  86. subTaskInstance1.end();
  87. }catch(Exceptione){
  88. e.printStackTrace();
  89. }finally{
  90. jbpmContext.close();
  91. }
  92. }
  94. publicstaticvoidstartMainTask2(){
  95. JbpmConfigurationjbpmConfiguration=JbpmConfiguration.getInstance();
  96. JbpmContextjbpmContext=jbpmConfiguration.createJbpmContext();
  97. try{
  98. TaskInstancemainTaskInstance2=jbpmContext.loadTaskInstance(3L);
  99. //读取子流程变量
  100. System.out.println(mainTaskInstance2.getName()+"主流程读取子流程变量，subParam的值是:"+mainTaskInstance2.getContextInstance().getVariable("subParam").toString());
  101. mainTaskInstance2.end();
  102. }catch(Exceptione){
  103. e.printStackTrace();
  104. }finally{
  105. jbpmContext.close();
  106. }
  107. }
  109. publicstaticvoidmain(String[]args)throwsFileNotFoundException{
  110. //数据库清理
  111. SubProcess.init();
  112. //发布流程,必须先发布子流程再发布主流程
  113. SubProcess.deploySub();
  114. SubProcess.deployMain();
  115. SubProcess.startProcess();
  116. SubProcess.startMainTask1();
  117. SubProcess.startSubTask1();
  118. SubProcess.startMainTask2();
  119. }
  120. }
package com.royzhou.test;

import java.io.FileNotFoundException;

import org.jbpm.JbpmConfiguration;
import org.jbpm.JbpmContext;
import org.jbpm.graph.def.ProcessDefinition;
import org.jbpm.graph.exe.ProcessInstance;
import org.jbpm.graph.exe.Token;
import org.jbpm.taskmgmt.exe.TaskInstance;

public class SubProcess {
	
	public static void init() {
		JbpmConfiguration jbpmConfiguration = JbpmConfiguration.getInstance();
		jbpmConfiguration.createSchema();
	}
	
	public static void deploySub() throws FileNotFoundException {
		JbpmConfiguration jbpmConfiguration = JbpmConfiguration.getInstance();
		JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();
		try {
			ProcessDefinition subProcessDefinition = ProcessDefinition.parseXmlResource("subprocess/processDefinition.xml");
			jbpmContext.deployProcessDefinition(subProcessDefinition);
		} catch(Exception e) {
			e.printStackTrace();
		} finally {
			jbpmContext.close();
		}
	}
	
	public static void deployMain() throws FileNotFoundException {
		JbpmConfiguration jbpmConfiguration = JbpmConfiguration.getInstance();
		JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();
		try {
			ProcessDefinition mainProcessDefinition = ProcessDefinition.parseXmlResource("mainprocess/processDefinition.xml");
			jbpmContext.deployProcessDefinition(mainProcessDefinition);
		} catch(Exception e) {
			e.printStackTrace();
		} finally {
			jbpmContext.close();
		}
	}
	
	public static void startProcess() {
		JbpmConfiguration jbpmConfiguration = JbpmConfiguration.getInstance();
		JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();
		try {
			ProcessDefinition processDefinition = jbpmContext.getGraphSession().findLatestProcessDefinition("mainprocess");
			ProcessInstance processInstance = new ProcessInstance(processDefinition);
			Token token = processInstance.getRootToken();
			token.signal();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			jbpmContext.close();
		}
	}
	
	public static void startMainTask1() {
		JbpmConfiguration jbpmConfiguration = JbpmConfiguration.getInstance();
		JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();
		try {
			//主流程maintask1
			TaskInstance mainTaskInstance1 = jbpmContext.loadTaskInstance(1L);
			//设置主流程变量
			mainTaskInstance1.getContextInstance().setVariable("mainParam", "主流程设置的变量");
			mainTaskInstance1.end();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			jbpmContext.close();
		}
	}
	
	public static void startSubTask1() {
		JbpmConfiguration jbpmConfiguration = JbpmConfiguration.getInstance();
		JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();
		try {
			//子流程subtask1
			TaskInstance subTaskInstance1 = jbpmContext.loadTaskInstance(2L);
			//获取主流程变量
			System.out.println(subTaskInstance1.getName() + "子流程读取主流程变量，mainParam的值是：" + subTaskInstance1.getContextInstance().getVariable("mainParam").toString());
			//设置子流程变量
			subTaskInstance1.getContextInstance().setVariable("subParam", "子流程设置的变量");
			subTaskInstance1.end();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			jbpmContext.close();
		}
	}
	
	public static void startMainTask2() {
		JbpmConfiguration jbpmConfiguration = JbpmConfiguration.getInstance();
		JbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();
		try {
			TaskInstance mainTaskInstance2 = jbpmContext.loadTaskInstance(3L);
			//读取子流程变量
			System.out.println(mainTaskInstance2.getName()+"主流程读取子流程变量，subParam的值是:" + mainTaskInstance2.getContextInstance().getVariable("subParam").toString());
			mainTaskInstance2.end();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			jbpmContext.close();
		}
	} 
	
	public static void main(String[] args) throws FileNotFoundException {
		//数据库清理
		SubProcess.init();
		//发布流程,必须先发布子流程再发布主流程
		SubProcess.deploySub();
		SubProcess.deployMain();
		SubProcess.startProcess();
		SubProcess.startMainTask1();
		SubProcess.startSubTask1();
		SubProcess.startMainTask2();
	}
}

运行上面程序，成功执行之后结果为：
main task node1 enter
sub task node1 enter
sub task node1 enter
subtask1子流程读取主流程变量，mainParam的值是：主流程设置的变量
main task node2 enter
maintask2主流程读取子流程变量，subParam的值是:子流程设置的变量

8、Mail Node 节点
该节点可以实现邮件的发送，具有通知提醒功能。
具体有两种配置方式：
通过mail node节点的template属性设置，采用此种方式需要修改jbpm.mail.template.xml文件里的模版，加上我们需要的模版，具体模版设置可参照里面已有模版。举例说明下：
流程模版文件：start -> mail node ->end
Xml代码 复制代码 收藏代码
  1. <?xmlversion="1.0"encoding="UTF-8"?>
  2. <process-definitionxmlns="urn:jbpm.org:jpdl-3.2"name="mail">
  3. <start-statename="start-state1">
  4. <transitionto="mail-node1"></transition>
  5. </start-state>
  6. <mail-nodename="mail-node1"template="test">
  7. <eventtype="node-enter">
  8. <script>
  9. print(&quot;entermailnode&quot;)
  10. </script>
  11. </event>
  12. <eventtype="node-leave">
  13. <script>
  14. print(&quot;leavemailnode&quot;)
  15. </script>
  16. </event>
  17. <transitionto="end-state1"></transition>
  18. </mail-node>
  19. <end-statename="end-state1"></end-state>
  20. </process-definition> 
<?xml version="1.0" encoding="UTF-8"?>
<process-definition  xmlns="urn:jbpm.org:jpdl-3.2"  name="mail">
	<start-state name="start-state1">
		<transition to="mail-node1"></transition>
	</start-state>
	<mail-node name="mail-node1" template="test">
		<event type="node-enter">
			<script>
				print(&quot;enter mail node&quot;)
			</script>
		</event>
		<event type="node-leave">
			<script>
				print(&quot;leave mail node&quot;)
			</script>
		</event>
		<transition to="end-state1"></transition>
	</mail-node>
	<end-state name="end-state1"></end-state>
</process-definition>

我们使用的模版是test，但是jbpm.mail.template.xml没有，所以需要我们自己加：
Xml代码 复制代码 收藏代码
  1. <mail-templatename="test">
  2. <actors>#{actorId}</actors>
  3. <subject>mailnode节点测试</subject>
  4. <text><![CDATA[Hi#{actorId},
  5. 这是mailnode节点的测试内容。
  6. ]]></text>
  7. </mail-template> 
<mail-template name="test">
		<actors>#{actorId}</actors>
		<subject>mail node 节点测试</subject>
		<text><![CDATA[Hi #{actorId},
		这是mail node节点的测试内容。
		]]></text>
	</mail-template>

这个是我们自己定义的模版，其中actors标签表示的是收件人的地址，需要使用邮件解析类解析，邮件解析类是一个实现AddressResolver接口的类。并且需要在jbpm.cfg.xml中配置，告诉jbpm要使用这个类去解析获取发送邮件的地址。
Java代码 复制代码 收藏代码
  1. packagecom.royzhou.util;
  3. importorg.jbpm.mail.AddressResolver;
  5. publicclassMailAddressResolverimplementsAddressResolver{
  7. publicObjectresolveAddress(StringactorId){
  8. return"royzhou1985@foxmail.com";
  9. }
  10. }
package com.royzhou.util;

import org.jbpm.mail.AddressResolver;

public class MailAddressResolver implements AddressResolver {

	public Object resolveAddress(String actorId) {
		return "royzhou1985@foxmail.com";
	}
}

下面是jbpm.cfg.xml的配置内容。
Xml代码 复制代码 收藏代码
  1. <jbpm-configuration>
  2. <!--邮件解析类-->
  3. <beanname="jbpm.mail.address.resolver"
  4. class="com.royzhou.util.MailAddressResolver"singleton="true"/>
  5. <!--邮箱配置信息-->
  6. <stringname="resource.mail.properties"value="jbpm.mail.properties"/>
  7. <!--处理邮件发送的类-->
  8. <stringname="mail.class.name"value="com.royzhou.util.Mail"/>
  9. <!--发送人地址-->
  10. <stringname="jbpm.mail.from.address"value="test@163.com"></string>
  11. </jbpm-configuration> 
<jbpm-configuration>
	<!-- 邮件解析类 -->
	<bean name="jbpm.mail.address.resolver"
		class="com.royzhou.util.MailAddressResolver" singleton="true" />
	<!-- 邮箱配置信息 -->
	<string name="resource.mail.properties" value="jbpm.mail.properties" />
	<!-- 处理邮件发送的类 -->
	<string name="mail.class.name" value="com.royzhou.util.Mail" />
	<!-- 发送人地址 -->
	<string name="jbpm.mail.from.address" value="test@163.com"></string>
</jbpm-configuration>


邮箱配置信息如下：
mail.smtp.host=smtp.163.com
mail.smtp.user=test
mail.smtp.password=test
mail.smtp.auth=true

配置中我们使用的是自己的邮件发送类，这是因为jbpm自己提供的邮件发送类没有提供身份认证，直接使用会报异常。
修改之后的邮件发送类如下：
Java代码 复制代码 收藏代码
  1. packagecom.royzhou.util;
  3. importjava.io.InputStream;
  4. importjava.io.Serializable;
  5. importjava.util.ArrayList;
  6. importjava.util.Arrays;
  7. importjava.util.Collection;
  8. importjava.util.Date;
  9. importjava.util.HashMap;
  10. importjava.util.Iterator;
  11. importjava.util.List;
  12. importjava.util.Map;
  13. importjava.util.Properties;
  14. importjava.util.StringTokenizer;
  16. importjavax.mail.Message;
  17. importjavax.mail.PasswordAuthentication;
  18. importjavax.mail.Session;
  19. importjavax.mail.Transport;
  20. importjavax.mail.internet.InternetAddress;
  21. importjavax.mail.internet.MimeMessage;
  22. importjavax.mail.Authenticator;
  24. importorg.apache.commons.logging.Log;
  25. importorg.apache.commons.logging.LogFactory;
  26. importorg.jbpm.JbpmConfiguration;
  27. importorg.jbpm.JbpmException;
  28. importorg.jbpm.graph.def.ActionHandler;
  29. importorg.jbpm.graph.exe.ExecutionContext;
  30. importorg.jbpm.jpdl.el.ELException;
  31. importorg.jbpm.jpdl.el.VariableResolver;
  32. importorg.jbpm.jpdl.el.impl.JbpmExpressionEvaluator;
  33. importorg.jbpm.mail.AddressResolver;
  34. importorg.jbpm.util.ClassLoaderUtil;
  35. importorg.jbpm.util.XmlUtil;
  37. publicclassMailimplementsActionHandler{
  39. privatestaticfinallongserialVersionUID=1L;
  41. Stringtemplate=null;
  42. Stringactors=null;
  43. Stringto=null;
  44. Stringbcc=null;
  45. StringbccActors=null;
  46. Stringsubject=null;
  47. Stringtext=null;
  49. ExecutionContextexecutionContext=null;
  51. publicMail(){
  52. }
  54. publicMail(Stringtemplate,
  55. Stringactors,
  56. Stringto,
  57. Stringsubject,
  58. Stringtext){
  59. this.template=template;
  60. this.actors=actors;
  61. this.to=to;
  62. this.subject=subject;
  63. this.text=text;
  64. }
  66. publicMail(Stringtemplate,
  67. Stringactors,
  68. Stringto,
  69. StringbccActors,
  70. Stringbcc,
  71. Stringsubject,
  72. Stringtext){
  73. this.template=template;
  74. this.actors=actors;
  75. this.to=to;
  76. this.bccActors=bccActors;
  77. this.bcc=bcc;
  78. this.subject=subject;
  79. this.text=text;
  80. }
  82. publicvoidexecute(ExecutionContextexecutionContext){
  83. this.executionContext=executionContext;
  84. send();
  85. }
  87. publicListgetRecipients(){
  88. Listrecipients=newArrayList();
  89. if(actors!=null){
  90. StringevaluatedActors=evaluate(actors);
  91. ListtokenizedActors=tokenize(evaluatedActors);
  92. if(tokenizedActors!=null){
  93. recipients.addAll(resolveAddresses(tokenizedActors));
  94. }
  95. }
  96. if(to!=null){
  97. StringresolvedTo=evaluate(to);
  98. recipients.addAll(tokenize(resolvedTo));
  99. }
  100. returnrecipients;
  101. }
  103. publicListgetBccRecipients(){
  104. Listrecipients=newArrayList();
  105. if(bccActors!=null){
  106. StringevaluatedActors=evaluate(bccActors);
  107. ListtokenizedActors=tokenize(evaluatedActors);
  108. if(tokenizedActors!=null){
  109. recipients.addAll(resolveAddresses(tokenizedActors));
  110. }
  111. }
  112. if(bcc!=null){
  113. StringresolvedTo=evaluate(to);
  114. recipients.addAll(tokenize(resolvedTo));
  115. }
  116. if(JbpmConfiguration.Configs.hasObject("jbpm.mail.bcc.address")){
  117. recipients.addAll(tokenize(
  118. JbpmConfiguration.Configs.getString("jbpm.mail.bcc.address")));
  119. }
  120. returnrecipients;
  121. }
  123. publicStringgetSubject(){
  124. if(subject==null)returnnull;
  125. returnevaluate(subject);
  126. }
  128. publicStringgetText(){
  129. if(text==null)returnnull;
  130. returnevaluate(text);
  131. }
  133. publicStringgetFromAddress(){
  134. if(JbpmConfiguration.Configs.hasObject("jbpm.mail.from.address")){
  135. returnJbpmConfiguration.Configs.getString("jbpm.mail.from.address");
  136. }
  137. return"jbpm@noreply";
  138. }
  140. publicvoidsend(){
  141. if(template!=null){
  142. Propertiesproperties=getMailTemplateProperties(template);
  143. if(actors==null){
  144. actors=properties.getProperty("actors");
  145. }
  146. if(to==null){
  147. to=properties.getProperty("to");
  148. }
  149. if(subject==null){
  150. subject=properties.getProperty("subject");
  151. }
  152. if(text==null){
  153. text=properties.getProperty("text");
  154. }
  155. if(bcc==null){
  156. bcc=properties.getProperty("bcc");
  157. }
  158. if(bccActors==null){
  159. bccActors=properties.getProperty("bccActors");
  160. }
  161. }
  163. send(getMailServerProperties(),
  164. getFromAddress(),
  165. getRecipients(),
  166. getBccRecipients(),
  167. getSubject(),
  168. getText());
  169. }
  171. publicstaticvoidsend(PropertiesmailServerProperties,StringfromAddress,Listrecipients,Stringsubject,Stringtext){
  172. send(mailServerProperties,fromAddress,recipients,null,subject,text);
  173. }
  175. publicstaticvoidsend(PropertiesmailServerProperties,StringfromAddress,Listrecipients,ListbccRecipients,Stringsubject,Stringtext){
  176. if((recipients==null)
  177. ||(recipients.isEmpty())
  178. ){
  179. log.debug("skippingmailbecausetherearenorecipients");
  180. return;
  181. }
  182. mailServerProperties.put("mail.smtp.auth","true");
  183. log.debug("sendingemailto'"+recipients+"'about'"+subject+"'");
  185. /**
  186. *添加认证类
  187. *royzhou2009.07.21
  188. */
  189. StringuserName=mailServerProperties.getProperty("mail.smtp.user").toString();
  190. Stringpassword=mailServerProperties.getProperty("mail.smtp.password").toString();
  191. MyAuthenticationmyAuthentication=newMyAuthentication(userName,password);
  192. Sessionsession=Session.getDefaultInstance(mailServerProperties,myAuthentication);
  193. MimeMessagemessage=newMimeMessage(session);
  194. try{
  195. if(fromAddress!=null){
  196. message.setFrom(newInternetAddress(fromAddress));
  197. }
  198. Iteratoriter=recipients.iterator();
  199. while(iter.hasNext()){
  200. InternetAddressrecipient=newInternetAddress((String)iter.next());
  201. message.addRecipient(Message.RecipientType.TO,recipient);
  202. }
  203. if(bccRecipients!=null){
  204. iter=bccRecipients.iterator();
  205. while(iter.hasNext()){
  206. InternetAddressrecipient=newInternetAddress((String)iter.next());
  207. message.addRecipient(Message.RecipientType.BCC,recipient);
  208. }
  209. }
  210. if(subject!=null){
  211. message.setSubject(subject);
  212. }
  213. if(text!=null){
  214. message.setText(text);
  215. }
  216. message.setSentDate(newDate());
  218. Transport.send(message);
  219. }catch(Exceptione){
  220. thrownewJbpmException("couldn'tsendemail",e);
  221. }
  222. }
  224. protectedListtokenize(Stringtext){
  225. if(text==null){
  226. returnnull;
  227. }
  228. Listlist=newArrayList();
  229. StringTokenizertokenizer=newStringTokenizer(text,";:");
  230. while(tokenizer.hasMoreTokens()){
  231. list.add(tokenizer.nextToken());
  232. }
  233. returnlist;
  234. }
  236. protectedCollectionresolveAddresses(ListactorIds){
  237. ListemailAddresses=newArrayList();
  238. Iteratoriter=actorIds.iterator();
  239. while(iter.hasNext()){
  240. StringactorId=(String)iter.next();
  241. AddressResolveraddressResolver=(AddressResolver)JbpmConfiguration.Configs.getObject("jbpm.mail.address.resolver");
  242. ObjectresolvedAddresses=addressResolver.resolveAddress(actorId);
  243. if(resolvedAddresses!=null){
  244. if(resolvedAddressesinstanceofString){
  245. emailAddresses.add((String)resolvedAddresses);
  246. }elseif(resolvedAddressesinstanceofCollection){
  247. emailAddresses.addAll((Collection)resolvedAddresses);
  248. }elseif(resolvedAddressesinstanceofString[]){
  249. emailAddresses.addAll(Arrays.asList((String[])resolvedAddresses));
  250. }else{
  251. thrownewJbpmException("Addressresolver'"+addressResolver+"'returned'"+resolvedAddresses.getClass().getName()+"'insteadofaString,CollectionorString-array:"+resolvedAddresses);
  252. }
  253. }
  254. }
  255. returnemailAddresses;
  256. }
  258. PropertiesgetMailServerProperties(){
  259. PropertiesmailServerProperties=newProperties();
  261. if(JbpmConfiguration.Configs.hasObject("resource.mail.properties")){
  262. StringmailServerPropertiesResource=JbpmConfiguration.Configs.getString("resource.mail.properties");
  263. try{
  264. InputStreammailServerStream=ClassLoaderUtil.getStream(mailServerPropertiesResource);
  265. mailServerProperties.load(mailServerStream);
  266. }catch(Exceptione){
  267. thrownewJbpmException("couldn'tgetconfigurationpropertiesforjbpmmailserverfromresource'"+mailServerPropertiesResource+"'",e);
  268. }
  270. }elseif(JbpmConfiguration.Configs.hasObject("jbpm.mail.smtp.host")){
  271. StringsmtpServer=JbpmConfiguration.Configs.getString("jbpm.mail.smtp.host");
  272. mailServerProperties.put("mail.smtp.host",smtpServer);
  274. }else{
  276. log.error("couldn'tgetmailproperties");
  277. }
  279. returnmailServerProperties;
  280. }
  282. staticMaptemplates=null;
  283. staticMaptemplateVariables=null;
  284. synchronizedPropertiesgetMailTemplateProperties(StringtemplateName){
  285. if(templates==null){
  286. templates=newHashMap();
  287. StringmailTemplatesResource=JbpmConfiguration.Configs.getString("resource.mail.templates");
  288. org.w3c.dom.ElementmailTemplatesElement=XmlUtil.parseXmlResource(mailTemplatesResource).getDocumentElement();
  289. ListmailTemplateElements=XmlUtil.elements(mailTemplatesElement,"mail-template");
  290. Iteratoriter=mailTemplateElements.iterator();
  291. while(iter.hasNext()){
  292. org.w3c.dom.ElementmailTemplateElement=(org.w3c.dom.Element)iter.next();
  294. PropertiestemplateProperties=newProperties();
  295. addTemplateProperty(mailTemplateElement,"actors",templateProperties);
  296. addTemplateProperty(mailTemplateElement,"to",templateProperties);
  297. addTemplateProperty(mailTemplateElement,"subject",templateProperties);
  298. addTemplateProperty(mailTemplateElement,"text",templateProperties);
  299. addTemplateProperty(mailTemplateElement,"bcc",templateProperties);
  300. addTemplateProperty(mailTemplateElement,"bccActors",templateProperties);
  302. templates.put(mailTemplateElement.getAttribute("name"),templateProperties);
  303. }
  305. templateVariables=newHashMap();
  306. ListvariableElements=XmlUtil.elements(mailTemplatesElement,"variable");
  307. iter=variableElements.iterator();
  308. while(iter.hasNext()){
  309. org.w3c.dom.ElementvariableElement=(org.w3c.dom.Element)iter.next();
  310. templateVariables.put(variableElement.getAttribute("name"),variableElement.getAttribute("value"));
  311. }
  312. }
  313. return(Properties)templates.get(templateName);
  314. }
  316. voidaddTemplateProperty(org.w3c.dom.ElementmailTemplateElement,Stringproperty,PropertiestemplateProperties){
  317. org.w3c.dom.Elementelement=XmlUtil.element(mailTemplateElement,property);
  318. if(element!=null){
  319. templateProperties.put(property,XmlUtil.getContentText(element));
  320. }
  321. }
  323. Stringevaluate(Stringexpression){
  324. if(expression==null){
  325. returnnull;
  326. }
  327. VariableResolvervariableResolver=JbpmExpressionEvaluator.getUsedVariableResolver();
  328. if(variableResolver!=null){
  329. variableResolver=newMailVariableResolver(templateVariables,variableResolver);
  330. }
  331. return(String)JbpmExpressionEvaluator.evaluate(expression,executionContext,variableResolver,null);
  332. }
  334. classMailVariableResolverimplementsVariableResolver,Serializable{
  335. privatestaticfinallongserialVersionUID=1L;
  336. MaptemplateVariables=null;
  337. VariableResolvervariableResolver=null;
  339. publicMailVariableResolver(MaptemplateVariables,VariableResolvervariableResolver){
  340. this.templateVariables=templateVariables;
  341. this.variableResolver=variableResolver;
  342. }
  344. publicObjectresolveVariable(StringpName)throwsELException{
  345. if((templateVariables!=null)
  346. &&(templateVariables.containsKey(pName))
  347. ){
  348. returntemplateVariables.get(pName);
  349. }
  350. returnvariableResolver.resolveVariable(pName);
  351. }
  352. }
  354. privatestaticLoglog=LogFactory.getLog(Mail.class);
  355. }
  357. /**
  358. *邮箱认证类
  359. *@authorroyzhou
  360. *2009.07.21
  361. */
  362. classMyAuthenticationextendsAuthenticator{
  363. privateStringuserName;
  364. privateStringpassword;
  365. publicMyAuthentication(StringuserName,Stringpassword){
  366. this.userName=userName;
  367. this.password=password;
  368. }
  369. protectedPasswordAuthenticationgetPasswordAuthentication(){
  370. returnnewPasswordAuthentication(userName,password);
  371. }
  372. }
package com.royzhou.util;

import java.io.InputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.StringTokenizer;

import javax.mail.Message;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
import javax.mail.Authenticator;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.jbpm.JbpmConfiguration;
import org.jbpm.JbpmException;
import org.jbpm.graph.def.ActionHandler;
import org.jbpm.graph.exe.ExecutionContext;
import org.jbpm.jpdl.el.ELException;
import org.jbpm.jpdl.el.VariableResolver;
import org.jbpm.jpdl.el.impl.JbpmExpressionEvaluator;
import org.jbpm.mail.AddressResolver;
import org.jbpm.util.ClassLoaderUtil;
import org.jbpm.util.XmlUtil;

public class Mail implements ActionHandler {

  private static final long serialVersionUID = 1L;
  
  String template = null;
  String actors = null;
  String to = null;
  String bcc = null;
  String bccActors = null;
  String subject = null;
  String text = null;
  
  ExecutionContext executionContext = null;
  
  public Mail() {
  }

  public Mail(String template,
              String actors,
              String to,
              String subject,
              String text) {
    this.template = template;
    this.actors = actors;
    this.to = to;
    this.subject = subject;
    this.text = text;
  }
  
  public Mail(String template,
      String actors,
      String to,
      String bccActors,
      String bcc,
      String subject,
      String text) {
    this.template = template;
    this.actors = actors;
    this.to = to;
    this.bccActors = bccActors;
    this.bcc = bcc;
    this.subject = subject;
    this.text = text;
  }  
  
  public void execute(ExecutionContext executionContext) {
    this.executionContext = executionContext;
    send();
  }

  public List getRecipients() {
    List recipients = new ArrayList();
    if (actors!=null) {
      String evaluatedActors = evaluate(actors);
      List tokenizedActors = tokenize(evaluatedActors);
      if (tokenizedActors!=null) {
        recipients.addAll(resolveAddresses(tokenizedActors));
      }
    }
    if (to!=null) {
      String resolvedTo = evaluate(to);
      recipients.addAll(tokenize(resolvedTo));
    }
    return recipients;
  }

  public List getBccRecipients() {
    List recipients = new ArrayList();
    if (bccActors!=null) {
      String evaluatedActors = evaluate(bccActors);
      List tokenizedActors = tokenize(evaluatedActors);
      if (tokenizedActors!=null) {
        recipients.addAll(resolveAddresses(tokenizedActors));
      }
    }
    if (bcc!=null) {
      String resolvedTo = evaluate(to);
      recipients.addAll(tokenize(resolvedTo));
    }
    if (JbpmConfiguration.Configs.hasObject("jbpm.mail.bcc.address")) {
      recipients.addAll(tokenize(
          JbpmConfiguration.Configs.getString("jbpm.mail.bcc.address")));
    }
    return recipients;
  }
  
  public String getSubject() {
    if (subject==null) return null;
    return evaluate(subject);
  }

  public String getText() {
    if (text==null) return null;
    return evaluate(text);
  }

  public String getFromAddress() {
    if (JbpmConfiguration.Configs.hasObject("jbpm.mail.from.address")) {
      return JbpmConfiguration.Configs.getString("jbpm.mail.from.address");
    } 
    return "jbpm@noreply";
  }

  public void send() {
    if (template!=null) {
      Properties properties = getMailTemplateProperties(template);
      if (actors==null) {
        actors = properties.getProperty("actors");
      }
      if (to==null) {
        to = properties.getProperty("to");
      }
      if (subject==null) {
        subject = properties.getProperty("subject");
      }
      if (text==null) {
        text = properties.getProperty("text");
      }
      if (bcc==null) {
        bcc = properties.getProperty("bcc");
      }
      if (bccActors==null) {
        bccActors = properties.getProperty("bccActors");
      }
    }
    
    send(getMailServerProperties(), 
            getFromAddress(), 
            getRecipients(), 
            getBccRecipients(),
            getSubject(), 
            getText());
  }
  
  public static void send(Properties mailServerProperties, String fromAddress, List recipients, String subject, String text) {
    send(mailServerProperties, fromAddress, recipients, null, subject, text);
  }
  
  public static void send(Properties mailServerProperties, String fromAddress, List recipients, List bccRecipients, String subject, String text) {
    if ( (recipients==null)
         || (recipients.isEmpty())
       ) {
      log.debug("skipping mail because there are no recipients");
      return;
    }
    mailServerProperties.put("mail.smtp.auth", "true");
    log.debug("sending email to '"+recipients+"' about '"+subject+"'");
    
    /**
     * 添加认证类
     * royzhou 2009.07.21
     */
    String userName = mailServerProperties.getProperty("mail.smtp.user").toString();
    String password = mailServerProperties.getProperty("mail.smtp.password").toString();
    MyAuthentication myAuthentication = new MyAuthentication(userName,password);
    Session session = Session.getDefaultInstance(mailServerProperties, myAuthentication);
    MimeMessage message = new MimeMessage(session);
    try {
      if (fromAddress!=null) {
        message.setFrom(new InternetAddress(fromAddress));
      }
      Iterator iter = recipients.iterator();
      while (iter.hasNext()) {
        InternetAddress recipient = new InternetAddress((String) iter.next());
        message.addRecipient(Message.RecipientType.TO, recipient);
      }
      if (bccRecipients!=null) {
        iter = bccRecipients.iterator();
        while (iter.hasNext()) {
          InternetAddress recipient = new InternetAddress((String) iter.next());
          message.addRecipient(Message.RecipientType.BCC, recipient);
        }        
      }
      if (subject!=null) {
        message.setSubject(subject);
      }
      if (text!=null) {
        message.setText(text);
      }
      message.setSentDate(new Date());
      
      Transport.send(message);
    } catch (Exception e) {
      throw new JbpmException("couldn't send email", e);
    }
  }

  protected List tokenize(String text) {
    if (text==null) {
      return null;
    }
    List list = new ArrayList();
    StringTokenizer tokenizer = new StringTokenizer(text, ";:");
    while (tokenizer.hasMoreTokens()) {
      list.add(tokenizer.nextToken());
    }
    return list;
  }

  protected Collection resolveAddresses(List actorIds) {
    List emailAddresses = new ArrayList();
    Iterator iter = actorIds.iterator();
    while (iter.hasNext()) {
      String actorId = (String) iter.next();
      AddressResolver addressResolver = (AddressResolver) JbpmConfiguration.Configs.getObject("jbpm.mail.address.resolver");
      Object resolvedAddresses = addressResolver.resolveAddress(actorId);
      if (resolvedAddresses!=null) {
        if (resolvedAddresses instanceof String) {
          emailAddresses.add((String)resolvedAddresses);
        } else if (resolvedAddresses instanceof Collection) {
          emailAddresses.addAll((Collection)resolvedAddresses);
        } else if (resolvedAddresses instanceof String[]) {
          emailAddresses.addAll(Arrays.asList((String[])resolvedAddresses));
        } else {
          throw new JbpmException("Address resolver '"+addressResolver+"' returned '"+resolvedAddresses.getClass().getName()+"' instead of a String, Collection or String-array: "+resolvedAddresses);
        }
      }
    }
    return emailAddresses;
  }

  Properties getMailServerProperties() {
    Properties mailServerProperties = new Properties();

    if (JbpmConfiguration.Configs.hasObject("resource.mail.properties")) {
      String mailServerPropertiesResource = JbpmConfiguration.Configs.getString("resource.mail.properties");
      try {
        InputStream mailServerStream = ClassLoaderUtil.getStream(mailServerPropertiesResource);
        mailServerProperties.load(mailServerStream);
      } catch (Exception e) {
        throw new JbpmException("couldn't get configuration properties for jbpm mail server from resource '"+mailServerPropertiesResource+"'", e);
      }
    
    } else if (JbpmConfiguration.Configs.hasObject("jbpm.mail.smtp.host")) {
      String smtpServer = JbpmConfiguration.Configs.getString("jbpm.mail.smtp.host");
      mailServerProperties.put("mail.smtp.host", smtpServer);
      
    } else {
      
      log.error("couldn't get mail properties");
    }

    return mailServerProperties;
  }

  static Map templates = null;
  static Map templateVariables = null;
  synchronized Properties getMailTemplateProperties(String templateName) {
    if (templates==null) {
      templates = new HashMap();
      String mailTemplatesResource = JbpmConfiguration.Configs.getString("resource.mail.templates");
      org.w3c.dom.Element mailTemplatesElement = XmlUtil.parseXmlResource(mailTemplatesResource).getDocumentElement();
      List mailTemplateElements = XmlUtil.elements(mailTemplatesElement, "mail-template");
      Iterator iter = mailTemplateElements.iterator();
      while (iter.hasNext()) {
        org.w3c.dom.Element mailTemplateElement = (org.w3c.dom.Element) iter.next();

        Properties templateProperties = new Properties();
        addTemplateProperty(mailTemplateElement, "actors", templateProperties);
        addTemplateProperty(mailTemplateElement, "to", templateProperties);
        addTemplateProperty(mailTemplateElement, "subject", templateProperties);
        addTemplateProperty(mailTemplateElement, "text", templateProperties);
        addTemplateProperty(mailTemplateElement, "bcc", templateProperties);
        addTemplateProperty(mailTemplateElement, "bccActors", templateProperties);

        templates.put(mailTemplateElement.getAttribute("name"), templateProperties);
      }

      templateVariables = new HashMap();
      List variableElements = XmlUtil.elements(mailTemplatesElement, "variable");
      iter = variableElements.iterator();
      while (iter.hasNext()) {
        org.w3c.dom.Element variableElement = (org.w3c.dom.Element) iter.next();
        templateVariables.put(variableElement.getAttribute("name"), variableElement.getAttribute("value"));
      }
    }
    return (Properties) templates.get(templateName);
  }

  void addTemplateProperty(org.w3c.dom.Element mailTemplateElement, String property, Properties templateProperties) {
    org.w3c.dom.Element element = XmlUtil.element(mailTemplateElement, property);
    if (element!=null) {
      templateProperties.put(property, XmlUtil.getContentText(element));
    }
  }
  
  String evaluate(String expression) {
    if (expression==null) {
      return null;
    }
    VariableResolver variableResolver = JbpmExpressionEvaluator.getUsedVariableResolver();
    if (variableResolver!=null) {
      variableResolver = new MailVariableResolver(templateVariables, variableResolver);
    }
    return (String) JbpmExpressionEvaluator.evaluate(expression, executionContext, variableResolver, null);
  }

  class MailVariableResolver implements VariableResolver, Serializable {
    private static final long serialVersionUID = 1L;
    Map templateVariables = null;
    VariableResolver variableResolver = null;

    public MailVariableResolver(Map templateVariables, VariableResolver variableResolver) {
      this.templateVariables = templateVariables;
      this.variableResolver = variableResolver;
    }

    public Object resolveVariable(String pName) throws ELException {
      if ( (templateVariables!=null)
           && (templateVariables.containsKey(pName))
         ){
        return templateVariables.get(pName);
      }
      return variableResolver.resolveVariable(pName);
    }
  }

  private static Log log = LogFactory.getLog(Mail.class);
}

/**
 * 邮箱认证类
 * @author royzhou
 * 2009.07.21
 */
class MyAuthentication extends Authenticator {
	private String userName;
	private String password;
	public MyAuthentication(String userName, String password) {
		this.userName = userName;
		this.password = password;
	}
	protected PasswordAuthentication getPasswordAuthentication() {
		return new PasswordAuthentication(userName,password);
	}
}


下面我们开始写我们的测试类：MailNode
Java代码 复制代码 收藏代码
  1. packagecom.royzhou.test;
  3. importorg.jbpm.graph.def.ProcessDefinition;
  4. importorg.jbpm.graph.exe.ProcessInstance;
  5. importorg.jbpm.graph.exe.Token;
  7. publicclassMailNode{
  9. publicstaticvoidmain(String[]args){
  10. ProcessDefinitionprocessDefinition=ProcessDefinition.parseXmlResource("mail/processDefinition.xml");
  11. ProcessInstanceprocessInstance=newProcessInstance(processDefinition);
  12. processInstance.getContextInstance().setVariable("actorId","royzhou");
  13. Tokentoken=processInstance.getRootToken();
  14. token.signal();
  15. System.out.println("end^^^^^^^^^^^^");
  16. }
  17. }
package com.royzhou.test;

import org.jbpm.graph.def.ProcessDefinition;
import org.jbpm.graph.exe.ProcessInstance;
import org.jbpm.graph.exe.Token;

public class MailNode {
	
	public static void main(String[] args) {
		ProcessDefinition processDefinition = ProcessDefinition.parseXmlResource("mail/processDefinition.xml");
		ProcessInstance processInstance = new ProcessInstance(processDefinition);
		processInstance.getContextInstance().setVariable("actorId", "royzhou");
		Token token = processInstance.getRootToken();
		token.signal();
		System.out.println("end^^^^^^^^^^^^");
	}
}

运行测试程序，后台打印：
enter mail node
test====test
leave mail node
end^^^^^^^^^^^^

打开你的收件箱发现邮件发送成功并且信息都是根据模版生成的。。


至此，我们将流程的节点基本上都过了一遍。。。。 笔记终于写完。。。累就一个字

明天出差。。。。
回来继续。。。。。

iteye_14984
关注
JBPM4.4节点详解（常用）
xiatian_sun的博客
07-05 4649
启动节点start 每个流程里面至少有一个开始节点（到目前为止一个流程只能有一个开始节点），开始节点必须有一个向外的流向，这个流向会在流程启动时执行。 状态节点state State是一个等待状态节点，流程实例执行到state节点后，会一直处于等待状态，直到外部触发器调用API。State节点和其他的节点不同，它没有任何属性或元素。 让我们看一个用序列连接状态 和转移的例子。 <pr
JBPM节点
q123inhao的博客
12-19 281
1、Node节点 Node节点是一个自动完成节点，如果没有在Node节点上定义Action，流程达到Node节点后不会停留，而是继续往下执行到Node节点的下一个节点。利用之前的Helloworld例子，我们在Node节点上加上一个Action(Action的执行是在node-enter之后node-leave之前) Xml代码 ...
jbpm节点介绍
c1052981766的专栏
02-22 532
JBPM(java业务流程管理)等待节点：              state节点、task节点自动执行节点：            start节点、end节点、decision节点、java、hql、sql、script节点、task节点、fork节点、join节点...
JBPM知识点------node
荒山隐士
03-28 1535
node节点类型适用于当你想要在节点中编写自己的代码的情形。通过设置action来帮定我们自己的商业逻辑。                    HELLO               ------------------------------------ package com.jeffentest;import org.jbpm.graph.def.ActionHandler
jbpm知识点——node
weixin_34033624的博客
06-30 106
node节点类型适用于当你想要在节点中编写自己的代码的情形。通过设置action来帮定我们自己的商业逻辑。 <start-state name="start"> <transition name="tr1" to="node1"></transition> </start-state> <node na...
JBPM采购申请系统——08_JBPM流程节点.7z
04-17
JBPM采购申请系统——08_JBPM流程节点.7z JBPM采购申请系统——08_JBPM流程节点.7z JBPM采购申请系统——08_JBPM流程节点.7z JBPM采购申请系统——08_JBPM流程节点.7z JBPM采购申请系统——08_JBPM流程节点.7z JBPM...
08_JBPM流程节点.exe
最新发布
05-27
08_JBPM流程节点.exe
JBPM流程引擎资料
01-23
文档《JBPM流程引擎资料》详细介绍了如何利用JBPM开发流程应用，涵盖了从框架构造到节点处理的方方面面。 首先，文档提到了jBPM的基本概念。jBPM是一个轻量级流程引擎，它允许开发者以模块化的方式管理业务流程。...
揭秘jbpm流程引擎内核设计思想及构架
02-04
　4引擎内核所关注的四个主要问题　4.1模型与定义对象　4.2调度机制与算法　4.3执行机制与状态　4.4实例对象与执行环境　5jbpm，“精简”的开源流程引擎　6jBpm流程模型与定义对象　6.1首先解决如何形式化描述一个...
jbpmhelper mysql_jbpm工作流
weixin_35391232的博客
01-27 183
一．开发环境的搭建1.下载Jbpm4.41.1下载地址：1.2解压后的目录2.安装GPD插件(eclipse图形化流程设计器)2.1打开eclipse--------选择help--------选择install new software2.2选择add添加插件：点击Archive选择插件目录：插件目录所在位置就是下载的解压后的路径中找jbpm-4.4\install\src\gpd2.3选择插件...
【jBPM】jbpm怎么获取下一个节点的任务定义，注意不是任务实例。
cfy_zybing的专栏
08-27 237
http://jbpm.group.iteye.com/group/topic/5890     jbpm怎么获取下一个节点的任务定义，注意不是任务实例。 已知下一个节点是任务节点，从当前任务实例中如何获取下一个节点，如何获取下一个节点定义的任务   public void getNextTasksByNode(Node node,JbpmContext context){ L...
jbpm java节点_Jbpm 流程节点
weixin_36162235的博客
02-12 494
1、Node节点Node节点是一个自动完成节点，如果没有在Node节点上定义Action，流程达到Node节点后不会停留，而是继续往下执行到Node节点的下一个节点。利用之前的Helloworld例子，我们在Node节点上加上一个Action(Action的执行是在node-enter之后node-leave之前)Action类如下：package com.royzhou.action;impor...
JBPM流节点详解
wwwlike
08-24 323
常用节点介绍 Start 节点  可以配置一个Task（人工任务）。同时还可以指定相关Event(事件)   State 节点 是一个等待节点，流程到这里后不会自动向下流转，同事也不会产生task 不需调用相关API才能实现流程的向下流转。 End 节点   Fork 和 Join 节点 是用来拆分和聚合流程的流向的   Decision 节点 是用来判断流程的流转线路的。 在这个...
JBPM-其他节点
球球之家
04-24 562
（一） decision
JBPM4.4 使用泳道动态指定下一个任务节点任务人的两种方式之一 （assignment-handler）
veverrr的专栏
01-18 6383
近期在学习  JBPM  工作流，上一篇博文描述了实现一个简单请假工作流的过程之后花了好几天的时间来实现一个基于泳道的任务发布工作流：简要流程如下：某级部门（暂定为A级部门）manager 启动一个新任务发布工作流通过泳道将该任务发布给A级部门的子部门（B）和孙子部门(C）B和C部门的所有成员都能够看到该任务，并可以点击链接查看该任务的详细信息一旦有成员apply 该任务，则其他人都不能再次apply该任务如果该成员只是C级部门的成员，不具有manager 的角色，则该次申请还需要提交给C级部门的经理进行审
JBPM工作流介绍
WEBCODE
10-10 528
JBOSS jBPM工作流管理系统简介 jBPM，全称是Java Business Process Management，是一种基于J2EE的轻量级工作流管理系统。jBPM是公开源代码项目，它使用要遵循Apache License。jBPM在2004年10月18日，发布了2.0版本，并在同一天加入了JBoss，成为了JBoss企业中间件平台的一个组成部分，它的名称也改成JBoss ...
深入浅出JBPM读书笔记(六)_流程节点详解2_Node节点详解
naxsu的专栏
04-04 215
1.为该Node节点添加Action 选中Node节点，通过Properties窗口切换到Action标签页，action的实现方式有两种，一种是Expression,输入JPDL表达式来定义具体的Action;另一种是Handler,选择一个具体的Java类来处理Action.这里选择Handler方式，设置如下： [img]http://dl.iteye.com/upload/atta...
JBPM流程实例详解：任意节点退回与权限控制
在JBPM中，由于不允许直接从其他节点向起点（StartState）绘制连接线，我们需要将“第一个节点”理解为流程的第一个任务节点，而不是真正的StartState。这样，我们可以直接从当前节点通过绘制线回到这个任务节点来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值