jbpm4.4在线设计分支跳转

最新推荐文章于 2021-02-23 09:17:23 发布
置顶 最新推荐文章于 2021-02-23 09:17:23 发布
阅读量724 收藏 1
点赞数
  • 博客分类：
  • JBPM
JBPM UP Workflow XML Apache

 

 我们知道jbpm4.4提供了三种比较方便的分支跳转方式，如下所示：

1.通过expression

 

Java代码 复制代码  收藏代码
  1. <?xml version="1.0" encoding="UTF-8"?>   
  2.   
  3. <process name="DecisionExpression" xmlns="http://jbpm.org/4.4/jpdl">   
  4.   
  5.   <start g="16,102,48,48">   
  6.     <transition to="evaluate document"/>   
  7.   </start>   
  8.   
  9.   <decision name="evaluate document" expr="#{content}" g="96,102,48,48">   
  10.     <transition name="good" to="submit document" g="120,60:-36,23" />   
  11.     <transition name="bad"  to="try again" g=":-15,-21" />   
  12.     <transition name="ugly" to="give up" g="120,189:-35,-41" />   
  13.   </decision>   
  14.   
  15.   <state name="submit document" g="175,35,122,52" />   
  16.   <state name="try again" g="176,100,122,52" />   
  17.   <state name="give up" g="177,164,122,52" />   
  18.   
  19. </process>  
<?xml version="1.0" encoding="UTF-8"?>

<process name="DecisionExpression" xmlns="http://jbpm.org/4.4/jpdl">

  <start g="16,102,48,48">
    <transition to="evaluate document"/>
  </start>

  <decision name="evaluate document" expr="#{content}" g="96,102,48,48">
    <transition name="good" to="submit document" g="120,60:-36,23" />
    <transition name="bad"  to="try again" g=":-15,-21" />
    <transition name="ugly" to="give up" g="120,189:-35,-41" />
  </decision>

  <state name="submit document" g="175,35,122,52" />
  <state name="try again" g="176,100,122,52" />
  <state name="give up" g="177,164,122,52" />

</process>
 

2.通过handler

Java代码 复制代码  收藏代码
  1. <?xml version="1.0" encoding="UTF-8"?>   
  2.   
  3. <process name="DecisionHandler" xmlns="http://jbpm.org/4.4/jpdl">   
  4.   
  5.   <start g="16,102,48,48">   
  6.     <transition to="evaluate document" name=""/>   
  7.   </start>   
  8.   
  9.   <decision name="evaluate document" g="96,102,48,48">   
  10.     <handler class="org.jbpm.examples.decision.handler.ContentEvaluation"/>   
  11.     <transition name="good" to="submit document" g="120,60:-37,22" />   
  12.     <transition name="bad" to="try again" g=":-19,-22" />   
  13.     <transition name="ugly" to="give up" g="120,189:-33,-39" />   
  14.   </decision>   
  15.   
  16.   <state name="submit document" g="175,35,122,52" />   
  17.   <state name="try again" g="176,100,122,52" />   
  18.   <state name="give up" g="177,164,122,52" />   
  19.   
  20. </process>  
<?xml version="1.0" encoding="UTF-8"?>

<process name="DecisionHandler" xmlns="http://jbpm.org/4.4/jpdl">

  <start g="16,102,48,48">
    <transition to="evaluate document" name=""/>
  </start>

  <decision name="evaluate document" g="96,102,48,48">
    <handler class="org.jbpm.examples.decision.handler.ContentEvaluation"/>
    <transition name="good" to="submit document" g="120,60:-37,22" />
    <transition name="bad" to="try again" g=":-19,-22" />
    <transition name="ugly" to="give up" g="120,189:-33,-39" />
  </decision>

  <state name="submit document" g="175,35,122,52" />
  <state name="try again" g="176,100,122,52" />
  <state name="give up" g="177,164,122,52" />

</process>
 

3.通过condition

Java代码 复制代码  收藏代码
  1. <?xml version="1.0" encoding="UTF-8"?>   
  2.   
  3. <process name="DecisionConditions" xmlns="http://jbpm.org/4.4/jpdl">   
  4.   
  5.   <start g="16,102,48,48">   
  6.     <transition to="evaluate document" />   
  7.   </start>   
  8.   
  9.   <decision name="evaluate document" g="96,102,48,48">   
  10.     <transition to="submit document" g="120,60:">   
  11.       <condition expr="#{content==&quot;good&quot;}" />   
  12.     </transition>   
  13.     <transition to="try again">   
  14.       <condition expr="#{content==&quot;bad&quot;}" />   
  15.     </transition>   
  16.     <transition to="give up" g="120,189:" />   
  17.   </decision>   
  18.   
  19.   <state name="submit document" g="175,35,122,52"/>   
  20.   <state name="try again" g="176,100,122,52"/>   
  21.   <state name="give up" g="177,164,122,52"/>   
  22.   
  23. </process>  
<?xml version="1.0" encoding="UTF-8"?>

<process name="DecisionConditions" xmlns="http://jbpm.org/4.4/jpdl">

  <start g="16,102,48,48">
    <transition to="evaluate document" />
  </start>

  <decision name="evaluate document" g="96,102,48,48">
    <transition to="submit document" g="120,60:">
      <condition expr="#{content==&quot;good&quot;}" />
    </transition>
    <transition to="try again">
      <condition expr="#{content==&quot;bad&quot;}" />
    </transition>
    <transition to="give up" g="120,189:" />
  </decision>

  <state name="submit document" g="175,35,122,52"/>
  <state name="try again" g="176,100,122,52"/>
  <state name="give up" g="177,164,122,52"/>

</process>
 

我们发现这种方式，若一旦我们的流程定义完成后，再想在运行中动态改变这种分支条件的设计就很难了，但是我们知道可以在流程定义发布到后台后，我们可以提供动态修改xml的方式，用handler的方式加上我们的分支决定的decision（需要实现jpbm的decision接口即可），通过handler来实现分支有一个比较大的优点就是我们可以在handler动态去执行我们需要工作流额外执行的代码，并且可以通过这个判断来决定其跳转的路径。

 

但我们不可能为所有的有分支决定的流程都加一个decision handler，并且在里面进行动态的分支判断。那样的工作很大，并且不灵活。

 

我们看一下第二种handler的接口：

Java代码 复制代码  收藏代码
  1. package org.jbpm.examples.decision.handler;   
  2.   
  3. import org.jbpm.api.jpdl.DecisionHandler;   
  4. import org.jbpm.api.model.OpenExecution;   
  5.   
  6. public class ContentEvaluation implements DecisionHandler {   
  7.   
  8.   private static final long serialVersionUID = 1L;   
  9.   
  10.   public String decide(OpenExecution execution) {   
  11.     String content = (String) execution.getVariable("content");   
  12.     if (content.equals("you're great")) {   
  13.       return "good";   
  14.     }   
  15.     if (content.equals("you gotta improve")) {   
  16.       return "bad";   
  17.     }   
  18.     return "ugly";   
  19.   }   
  20. }  
package org.jbpm.examples.decision.handler;

import org.jbpm.api.jpdl.DecisionHandler;
import org.jbpm.api.model.OpenExecution;

public class ContentEvaluation implements DecisionHandler {

  private static final long serialVersionUID = 1L;

  public String decide(OpenExecution execution) {
    String content = (String) execution.getVariable("content");
    if (content.equals("you're great")) {
      return "good";
    }
    if (content.equals("you gotta improve")) {
      return "bad";
    }
    return "ugly";
  }
}

 在这里我们可以看到，可以通过动态返回跳转路径则可。在上面我说过了，不能把这个返回值交给具体的decisionHandler来决定，这个决定应该由流程运行来动态决定，我们需要告诉这个handler，你需要按我的规则来运行计算，得到一个运行跳转的路径。于是我想到能不能用bsh有脚本来动态返回告诉这个handler如何执行。

 

以下我们以一个简单的订单流程来说明如何实现这个动态设计分支跳转。

 

首先我在线设计了一个流程，如下所示：

jbpm4在线流程设计

 

发布后，设计其分支条件，如下所示：

jbpm4分支条件设计

 

我们在条件那里加入流程干预：

Java代码 复制代码  收藏代码
  1. String tranTo="金额小于2000元";   
  2. if(price*quantity>=2000){   
  3.        tranTo="金额大于等于2000";   
  4. }  
String tranTo="金额小于2000元";
if(price*quantity>=2000){
       tranTo="金额大于等于2000";
}

 这个tranTo则是由我们系统的管理员来控制，大家发现其本身就是java代码来的，熟悉一些简单的java语法均可以。当然若我们在这里还可以做一些更复杂的操作，如执行调用第三方系统的接口等。

那么以上的price与quantity变量来自哪里呢？它们是流程表单里的字段，于是我们为这个流程动态绑定一个流程表单。

 

首先我们设计一个流程表单：

在线表单设计

 

其对应的字段映射为：

在线表单设计-表单字段

在后台绑定该表单：

绑定表单

启动流程：

绑定流程表单-启动

执行后，可以看到流程自动判断跳转：

 

我们看一下本身我们的handler如何写：

 

Java代码 复制代码  收藏代码
  1. package com.htsoft.oa.workflow.handler;   
  2.   
  3. import java.util.Iterator;   
  4. import java.util.List;   
  5. import java.util.Map;   
  6. import java.util.Map.Entry;   
  7.   
  8. import org.apache.commons.logging.Log;   
  9. import org.apache.commons.logging.LogFactory;   
  10. import org.jbpm.api.ProcessDefinition;   
  11. import org.jbpm.api.ProcessEngine;   
  12. import org.jbpm.api.jpdl.DecisionHandler;   
  13. import org.jbpm.api.model.Activity;   
  14. import org.jbpm.api.model.OpenExecution;   
  15.   
  16. import bsh.EvalError;   
  17. import bsh.Interpreter;   
  18.   
  19. import com.htsoft.core.util.AppUtil;   
  20. import com.htsoft.oa.model.flow.ProHandleComp;   
  21. import com.htsoft.oa.service.flow.ProHandleCompService;   
  22. /**  
  23.  * 实现分支决定，可以在这里根据业务逻辑计算，决定分支的跳转  
  24.  * @author   
  25.  *  
  26.  */  
  27. public class DecisionHandlerImpl implements DecisionHandler{   
  28.        
  29.     private static final Log logger=LogFactory.getLog(DecisionHandlerImpl.class);   
  30.        
  31.     @Override  
  32.     public String decide(OpenExecution execution) {   
  33.         logger.debug("enter decision handler....");   
  34.            
  35.         ProcessEngine processEngine=(ProcessEngine)AppUtil.getBean("processEngine");   
  36.            
  37.         ProHandleCompService proHandleCompService=(ProHandleCompService)AppUtil.getBean("proHandleCompService");   
  38.            
  39.         String pdId=execution.getProcessDefinitionId();   
  40.            
  41.         ProcessDefinition processDefinition= processEngine.getRepositoryService().createProcessDefinitionQuery().processDefinitionId(pdId).uniqueResult();   
  42.            
  43.         String deployId=processDefinition.getDeploymentId();   
  44.            
  45.         Activity curActivity=execution.getActivity();   
  46.            
  47.         List<ProHandleComp> list=proHandleCompService.getByDeployIdActivityNameHandleType(deployId, curActivity.getName(), ProHandleComp.HANDLE_TYPE_HANDLER);   
  48.            
  49.         if(list.size()>0){   
  50.             ProHandleComp proHandleComp=list.get(0);   
  51.             logger.info("exeCode:" + proHandleComp.getExeCode());   
  52.             //执行动态   
  53.             Interpreter it=new Interpreter();   
  54.                    
  55.             try {   
  56.                 //取得所有流程变量，放于bsh环境，方便在bsh脚本环境中运行以方便决定流程跳转   
  57.                 Map<String,Object> vars=(Map<String,Object>)execution.getVariables();   
  58.                 Iterator<Entry<String, Object>> iterator= vars.entrySet().iterator();   
  59.                 while(iterator.hasNext()){   
  60.                     Entry<String, Object> entry=iterator.next();   
  61.                     String key=entry.getKey();   
  62.                     Object val=entry.getValue();   
  63.                     it.set(key.replace(".", "_"), val);   
  64.                 }   
  65.                 logger.info("dynamic execution code tranTo:"+proHandleComp.getExeCode());   
  66.                 it.eval(proHandleComp.getExeCode());   
  67.                 String tran=(String)it.get("tranTo");   
  68.                 logger.info("return tranTo:"+tran);   
  69.                 return tran;   
  70.             } catch (EvalError e) {   
  71.                 e.printStackTrace();   
  72.             }   
  73.         }   
  74.            
  75.         return null;   
  76.     }   
  77. }  
package com.htsoft.oa.workflow.handler;

import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.jbpm.api.ProcessDefinition;
import org.jbpm.api.ProcessEngine;
import org.jbpm.api.jpdl.DecisionHandler;
import org.jbpm.api.model.Activity;
import org.jbpm.api.model.OpenExecution;

import bsh.EvalError;
import bsh.Interpreter;

import com.htsoft.core.util.AppUtil;
import com.htsoft.oa.model.flow.ProHandleComp;
import com.htsoft.oa.service.flow.ProHandleCompService;
/**
 * 实现分支决定，可以在这里根据业务逻辑计算，决定分支的跳转
 * @author 
 *
 */
public class DecisionHandlerImpl implements DecisionHandler{
	
	private static final Log logger=LogFactory.getLog(DecisionHandlerImpl.class);
	
	@Override
	public String decide(OpenExecution execution) {
		logger.debug("enter decision handler....");
		
		ProcessEngine processEngine=(ProcessEngine)AppUtil.getBean("processEngine");
		
		ProHandleCompService proHandleCompService=(ProHandleCompService)AppUtil.getBean("proHandleCompService");
		
		String pdId=execution.getProcessDefinitionId();
		
		ProcessDefinition processDefinition= processEngine.getRepositoryService().createProcessDefinitionQuery().processDefinitionId(pdId).uniqueResult();
		
		String deployId=processDefinition.getDeploymentId();
		
		Activity curActivity=execution.getActivity();
		
		List<ProHandleComp> list=proHandleCompService.getByDeployIdActivityNameHandleType(deployId, curActivity.getName(), ProHandleComp.HANDLE_TYPE_HANDLER);
		
		if(list.size()>0){
			ProHandleComp proHandleComp=list.get(0);
			logger.info("exeCode:" + proHandleComp.getExeCode());
			//执行动态
			Interpreter it=new Interpreter();
				
			try {
				//取得所有流程变量，放于bsh环境，方便在bsh脚本环境中运行以方便决定流程跳转
				Map<String,Object> vars=(Map<String,Object>)execution.getVariables();
				Iterator<Entry<String, Object>> iterator= vars.entrySet().iterator();
				while(iterator.hasNext()){
					Entry<String, Object> entry=iterator.next();
					String key=entry.getKey();
					Object val=entry.getValue();
					it.set(key.replace(".", "_"), val);
				}
				logger.info("dynamic execution code tranTo:"+proHandleComp.getExeCode());
				it.eval(proHandleComp.getExeCode());
				String tran=(String)it.get("tranTo");
				logger.info("return tranTo:"+tran);
				return tran;
			} catch (EvalError e) {
				e.printStackTrace();
			}
		}
		
		return null;
	}
}
 

 

里面其实比较简单，就是通过动态执行那个给用户开放的代码片段，并且根据其tranTo变量的值来决定其如何跳转，在上面的例子就是流程表单中的金额是否大于2000元来跳转。

 

同样，我们知道jbpm4_lob中存着jbpm4的流程定义的xml文件，只要把动态修改jbpm4的流程定义，可以为我们的作何节点加上我们需要流程动态执行的事件及代码。请关注后续的文章，有介绍如何扩展jbpm4的流程事件。

 

 

在线看预览情况：

 

http://bbs.jee-soft.cn/swf/design_decision.html

 

http://bbs.jee-soft.cn/posts/list/285.page#384

在线测试地址：

网通：

http://oa.jee-soft.cn:8080/index.jsp

电信：

http://office.jee-soft.cn:8080/index.jsp

 

用户：admin,密码：1

 

qq:1848175569

nyuxia
关注
jbpm4.4 在线流程设计器，前端+java后台
11-14
jpdl的web流程编辑器的前后端实现 前端：使用myflow.js实现，点击保存将把流程图转换成一个json格式的数据； 后台：使用java实现了，json转成jpdl要求的xml，根据xml生成png流程图片，将xml文件和png图片打包成zip；
jbpm4.4 在线设计流程图 ext + raphael
09-11
本教程将深入探讨jbpm4.4的在线设计流程图特性，以及如何利用ext（一个JavaScript UI库）和raphael（一个矢量图形库）进行流程图的绘制与交互。 首先，jbpm4.4中的在线设计流程图功能依赖于ext库，它提供了丰富的...
jbpm4 foreach 实现动态分支
mallven.com
11-15 205
foreach 活动允许通过一条单独的流程路径 开始执行多条流程分支。 它的属性描述见下表。 [table] |属性|类型|默认值|是否必须?|描述| |in|表达式或字符串||必须|将被迭代的集合。集合中的每个元素会生成一个新的同步分支 沿着默认的转移向外执行。in 执行任意类型的集合，数组和以逗号分隔的字符串。| |var|表达式或字符串||必须|用来保存集合中当前元素的变量。 这个变...
jbpm4 foreach 实现动态分支
Java 是用来喝的
08-18 3215
foreach 活动允许通过一条单独的流程路径 开始执行多条流程分支。 它的属性描述见下表。foreach 属性：属性类型默认值是否必须?描述in表达式或字符串 必须将被迭代的集合。集合中的每个元素会生成一个新的同步分支 沿着默认的转移向外执行。in 执行任意类型的集合，数组和以逗号分隔的字符串。var字符串 必须用来保存集合中当前元素的变量。 这个变量会设置到同步流程分支中， 并且只对这个流程分支可见。在这个例子中，我们需要收集 不同部门的考勤表。同一个任务可以被不同的组织执行。 使用foreach就很容
jbpm4.4 foreach 实现动态分支
iteye_6382的博客
05-06 243
foreach 活动允许通过一条单独的流程路径开始执行多条流程分支，一般与join活动成对使用。 foreach活动的属性如下： 属性 类型 默认值 是否必须? 描述 in 表达式或字符串 　 必须 将被迭代的集合。集合中的每个元素会生成一个新的同步分支沿着默认的转移向外执行。in 执行任意类...
jBPM4.4.rar_jbpm4.4_jbpm4.4 PDF
09-19
在《jBPM4.4开发指南》中，开发者可以了解到jBPM4.4的核心功能和设计原理。该指南通常涵盖以下几个关键知识点： 1. **系统架构**：jBPM4.4基于Eclipse Persistence API（JPA）和Hibernate ORM，提供了持久化服务，...
jBPM4.4.rar_jbpm4_jbpm4.4
09-22
"jBPM4.4.docx" 文件可能是关于 jbPM 4.4 示例的详细文档，它可能包含如何安装、配置、创建和运行流程实例的步骤，以及可能遇到的问题和解决办法，对于学习和使用 jbPM 4.4 是非常有价值的参考资料。 总结，jbPM ...
jbpm4.4spring.rar_jbpm4_jbpm4.4
09-21
【标题】"jbpm4.4spring.rar_jbpm4_jbpm4.4" 提供的是一个关于JBPM4.4与Spring框架整合的实际应用案例。JBPM（Java Business Process Management）是一款开源的工作流管理系统，它允许开发者设计、执行、管理和监控...
jbpm4.4(chinese).rar_jbpm4.4
09-24
**jbpm4.4简介** jbpm4.4是一款基于Java的企业级工作流管理系统，它提供了业务...通过深入学习这份中文文档，开发者可以全面掌握jbpm4.4的核心功能和使用技巧，有效地进行业务流程的设计和管理，提升企业的业务效率。
JBPM4.4实现一种无需指定上一节点(previous activity)的流程驳回(回退)
07-30
NULL 博文链接：https://eminemning.iteye.com/blog/875250
JBPM在线流程设计器的分析与实现部分构想
man1900
03-10 249
在发表文章之前，先写一下博客声明，由于JE限制了本人的发贴功能，所以大家回复的内容本人现在没有办法在线回复各位，望见谅。需要技术交流的请加我Q：1165655130。        最近JBPM比较火，很多同行也跟我探讨如何使用这个东西完成企业应用中的流程问题，本人也谈谈对Jbpm4的理解，JBPM在实现流程上应该没有什么问题，但是由于其客户端的可视化相对薄弱，如设计器不够人性化，流程...
jbpm源代码研究(五)-------流程跳转
浮白
10-18 3027
JBPM流程会在执行过程中间，在节点之间跳转并且转换状态； （１）顺序执行的流程：   当执行到某个状态节点位置如：wait for response 这个时候在JBPM4_EXECUTION中，有这个节点的记录，并且Parent为空，这表明这个Exec
【JBPM4】流程分支fork - join
weixin_30485799的博客
03-03 91
流程分支、聚合。流程每个分支节点都全部处理完成后，聚合到下一个节点。 JPDL <?xml version="1.0" encoding="UTF-8"?> <process key="fork" name="fork" xmlns="http://jbpm.org/4.4/jpdl"> <start g="56,154,48,48" name="start...
JBPM4 Fork-join（分支/聚合活动）
weixin_44462773的博客
02-23 601
Fork-join（分支/聚合活动）1、JBPM4 Fork-join（分支/聚合活动）2、fork \ join \ state \ task 节点的使用2.1 流程图示例2.2 xml文件2.3 运行过程分析3.实现 1、JBPM4 Fork-join（分支/聚合活动）   当我们需要流程并发处理、执行的时候就需要分支、聚合。当出现fork的时候，流程实例不是仅仅进入其中一个分支，而是所有分支都会被激活，直到外界接口执行此分支才会往下走，所有的分支节点都聚合到join的时候，整个分支才会继续往下面
JBPM4学习总结之5——Fork-join（分支/聚合活动）
suhuanzheng7784877的专栏
03-05 438
当我们需要流程并发处理、执行的时候就需要分支、聚合。当出现fork的时候，流程实例不是仅仅进入其中一个分支，而是所有分支都会被激活，直到外界接口执行此分支才会往下走，所有的分支节点都聚合到join的时候，整个分支才会继续往下面走，否则，最先到达join分支的节点会一直等待在join那里等待其他。 流程图如下：  流程描述如下：   &lt;?xml version="1.0" enc...
JBPM中采用el表达式动态分配任务
致力于顶级java全栈工程师
02-21 858
工作流中非常重要的一个就是任务的分配，这里我们采用assignee的分配方式，对于其他的几种方式我们在后面的博客中详细介绍。任务的分配分为动态和静态两种，我们之前对jbpm的讲解都采用的是静态的分配方式，也就是对于任务分配给了谁，我们都会写死在jpdl文件中，例如科长审批分配给了张三我们会这样写：              采用这种方式分配任务，使程序不灵活，如果我们想要更改任务分配
09-jbpm工作流之"分支聚合Join-Fork"
全力付出
07-11 2705
工作流的分支与聚合:       这是多个分支并行(同时)执行，并且所有的分支Execution都到Join活动聚合后才向后执行; 1.工作流图:test.png 工作流配置文件:test.jpdl.xml:
jBPM4的高级图形执行 流程构建（转）
a651944226的专栏
08-16 610
                                                           jBPM4的高级图形执行 流程构建导读：本文讲述了jBPM4的高级图形执行。对于开发者，第一个任务是分析什么是流程控制的线程中需要执行的，什么是外部的。查找外部触发器是寻找一个流程中的等待状态的很好的开始。　活动可以实现循环，基于转移或活动组合。 循环可以包含等待状态。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值