jBPM4工作流引擎 网络知识点整理汇总 WEB整合spring2.5+hibernate开发及典型业务

一、spring的配置文件applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns=" http://www.springframework.org/schema/beans "
       xmlns:xsi=" http://www.w3.org/2001/XMLSchema-instance "
       xmlns:context=" http://www.springframework.org/schema/context "
       xmlns:aop=" http://www.springframework.org/schema/aop "
       xmlns:tx=" http://www.springframework.org/schema/tx "
       xsi:schemaLocation=" http://www.springframework.org/schema/beans 
           http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
           http://www.springframework.org/schema/context 
           http://www.springframework.org/schema/context/spring-context-3.0.xsd 
           http://www.springframework.org/schema/aop 
           http://www.springframework.org/schema/aop/spring-aop-3.0.xsd 
           http://www.springframework.org/schema/tx 
           http://www.springframework.org/schema/tx/spring-tx-3.0.xsd ">
   
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">

    <property name="driverClass" value="com.mysql.jdbc.Driver"/>
    <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test"/>
    <property name="user" value="root"/>
    <property name="password" value="cqsztt"/>
    <property name="initialPoolSize" value="3" />
    <property name="minPoolSize" value="3" />
    <property name="maxPoolSize" value="50" />
    <property name="maxIdleTime" value="600" />
    <property name="maxStatements" value="100" />
    <property name="acquireIncrement" value="3" />

</bean>

<!--spring的配置文件有两处需要改动的地方，此为1：

     springHelper实现了ApplicationContextAware接口，springHelper可以从spring容器中获得ApplicationContext，

     然后springHelper可以利用ApplicationContext和jbpm.cfg.xml(jbpm的配置文件)一起生成伟大的processEngine。

    配置到这一步的时候，有些人就开始着急测试，多次碰壁后，有的高手居然想到了使用Spring 的IOC功能自己写个processEngin工厂

    ，大家都知道jbpm使用了hibernate，但如何将hibernate的sessionFactory注入给JBPM呢？莫及，继续往下看

-->
<bean id="springHelper" class="org.jbpm.pvm.internal.processengine.SpringHelper" />

<bean id="processEngine" factory-bean="springHelper" factory-method="createProcessEngine" />

<!--Hibernate SessionFatory-->
<bean id="sessionFactory"
   class="com.travelsky.bravo.core.utils.AutoLoadSessionFactoryBean">
   <property name="dataSource" ref="dataSource" />

<property name="mappingResources">
        <list>

            <!--此处为第二处需要修改的地方

               此处千万不要忘记了 ，这5个映射关系会在spring容器初始化的时候persistent到数据库中，如果没有，肯定会报exception

               写到这里我要说明下：看过jbpm有个关于hibernate配置的文件：jbpm.hibernate.cfg.xml,我这种写法就是要去掉这个文件，

               将spring + jbmp都使用一个Hibernate的配置，也就不会出现两个sessionFactory和两个database的情况了。有的同学可 发表不同的意见认为：将hibernate的配置信息写到一个单独的文件里，感觉清爽些。但是，无论如何，你总得在这个文件里配置 sessionFactory吧，所以总得配置hibernate的东东，所以干脆写在一起，将来修改起来也方便，不需要打开两个文件，至于其他细节东西 我就不到啰嗦了，到此，spring的配置文件就结束了。

            -->
            <value>jbpm.repository.hbm.xml</value>
            <value>jbpm.execution.hbm.xml</value>
            <value>jbpm.history.hbm.xml</value>
            <value>jbpm.task.hbm.xml</value>
            <value>jbpm.identity.hbm.xml</value> 
        </list>
    </property>
    <property name="hibernateProperties">
    <props>
     <prop key="hibernate.dialect">
      org.hibernate.dialect.Oracle10gDialect
     </prop>
     <prop key="hibernate.show_sql">true</prop>
     <prop key="hibernate.format_sql">true</prop>
     <prop key="hibernate.cache.provider_class">
      org.hibernate.cache.EhCacheProvider
     </prop>
     <prop key="hibernate.cache.use_query_cache">true</prop>
    </props>
   </property>

</bean>

<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
    <property name="sessionFactory" ref="sessionFactory"/>
</bean>

<!--事务管理的配置，不这么配置不影响ssh+jbpm整合-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
      <tx:attributes>
          <tx:method name="save" propagation="REQUIRED"/>
          <tx:method name="update" propagation="REQUIRED"/>
          <tx:method name="is*" read-only="true"/>
      </tx:attributes>
</tx:advice>
<aop:config>
      <aop:pointcut expression="execution(public * com.cqs.service.impl.*.*(..))" id="userServicePointcut"/>
      <aop:advisor advice-ref="txAdvice" pointcut-ref="userServicePointcut"/>
</aop:config>
<!--不影响ssh+jbpm整合-->
<bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
      <property name="sessionFactory" ref="sessionFactory"></property>
</bean>

</beans>

二、 jbpm的配置文件

1、jbpm.cfg.xml 
< jbpm-configuration > 
< import resource =" jbpm.default.cfg.xml " /> 
< import resource =" jbpm.tx.spring.cfg.xml " /><!--jbpm.tx.hibernate.cfg.xml不用了，无需其他配置-->
< import resource =" jbpm.jpdl.cfg.xml " /> 
< import resource =" jbpm.bpmn.cfg.xml " /> 
< import resource =" jbpm.identity.cfg.xml " /> 
< import resource =" jbpm.businesscalendar.cfg.xml " />

</ jbpm-configuration >

三、 部署到Tomcat 
整合struts2就没什么好讲的了，主要是spring和struts2整合，jbpm部署到tomcat6的时候，主要jar包冲突的问 题，tomcat的lib里面的东西和项目lib里面的jar包版本等不一样的时候容易造成load到内存中的字节码出现乱七八糟的问题。 
需要特别说明的是 
1、WEB-INF/lib下面的三个jar包juel.jar,juel-engine.jar,juel-impl.jar剪切 到tomcat的lib下 
2、在tomcat的lib中新加javaee.jar,重新部署，并启动tomcat，如果成功即可，不成功需要删除tomcat lib下的el-api.jar 
3、有人数tomcat5下不会出现jar包冲突的情况，我不知道，没用过，我就不试了，哈哈

对Tomcat的修改

在将jBPM与web项目结合的时候，需要把jBPM资源包中的juel-engine.jar和juel-impl.jar添加到tomcat/lib下，同时在Web应用的lib下面，把juel-api.jar、juel-engine.jar和juel-impl.jar 删除掉。

注意，以后在建立web工程的时候，需要选择修改后的tomcat。

 

将jPDL的图片发布到jBPM中

1：首先把jpdl和png打到一起，打成zip包。

2：然后修改流程定义的代码，通过读取zip文件的方式来发布：

ProcessEngine processEngine = Configuration.getProcessEngine();
RepositoryService repositoryService = processEngine.getRepositoryService();
//repositoryService.createDeployment().addResourceFromClasspath("leave.jpdl.xml").deploy();
ZipInputStream zis = new ZipInputStream(this.getClass().getResourceAsStream("/doc.zip")); 
repositoryService.createDeployment().addResourcesFromZipInputStream(zis).deploy();
 

 将jPDL的图片发布到jBPM中，页面上的代码示例如下：

<%!
public InputStream showWebPicture(){
ProcessEngine engine = Configuration.getProcessEngine();
RepositoryService rs = engine.getRepositoryService();
ProcessDefinition pd = rs.createProcessDefinitionQuery().processDefinitionId("at-4").uniqueResult();
InputStream in = rs.getResourceAsStream(pd.getDeploymentId(), "at.png");
return in;
}
%><%
InputStream in = showWebPicture();
byte bs[] = new byte[1024];
while(in.read(bs)!=-1){
response.getOutputStream().write(bs);
}
out.clear();
out = pageContext.pushBody();
%>

 

ProcessInstance pi = executionService.findProcessInstanceById("test1.10001");
Set<String> activityNames = pi.findActiveActivityNames();
 
for (String activityName:activityNames){
String pdId = pi.getProcessDefinitionId();
ActivityCoordinates ac = repositoryService.getActivityCoordinates(pdId,activityName);
System.out.println("activityName="+activityName);
System.out.println("x="+ac.getX());
System.out.println("y="+ac.getY());
System.out.println("height="+ac.getHeight());
System.out.println("width="+ac.getWidth());
System.out.println("---------------------");
}

 

<%
ProcessInstance pi = executionService.findProcessInstanceById("test1.10001");
Set<String> activityNames = pi.findActiveActivityNames();
for (String acitiveAcitityName:activityNames){
String pdId = pi.getProcessDefinitionId();
ActivityCoordinates ac = repositoryService.getActivityCoordinates(pdId,acitiveAcitityName);
%>
<div style="position:absolute;border:1px solid red;
left:<%=ac.getX()%>px;top:<%=ac.getY()%>px;
width:<%=ac.getWidth()%>px;height:<%=ac.getHeight()%>px;">
</div>
<%}%>

 

ProcessInstance pi = executionService.findProcessInstanceById("test1.10001");
Set<String> activityNames = pi.findActiveActivityNames();
for (String acitiveAcitityName:activityNames){
String pdId = pi.getProcessDefinitionId();
ActivityCoordinates ac = repositoryService.getActivityCoordinates(pdId,acitiveAcitityName);
%>
<div style="position:absolute;border:1px solid red;
left:<%=ac.getX()%>px;top:<%=ac.getY()%>px;
width:<%=ac.getWidth()%>px;height:<%=ac.getHeight()%>px;">
</div>
<%}%>

 

会签概念

会签，又称会审，也就是流程中某个业务需要经过多人表决，并且根据表决意见的汇总结果，匹配设定的规则，决定流程的走向。

 

请大家回忆一下Task节点的候选人，是一个概念吗？

 

会签示例

会签只是一个概念，并不是说所有的人都必须进行响应。举几个例子：

1：去掉一个最高分、去掉一个最低分。

2：十位领导进行会签，6个同意就算同意。

3：仅仅收集大家的意见，需要所有的人响应。

4：核心领导的一票否决

……

customer节点

在jpdl中，并没有单独的会签活动，需要我们自己写代码去实现，可以使用customer节点，自己实现自定义的功能。

实现注意点

与普通的Task任务相比，流程引擎也会停在会签节点等待人为的响应。但是，会签涉及到多个人，所以，请注意：

1：当流程进入会签节点的时候，需要生成多个任务，分发给会签涉及到的多个人。

2：在某个人响应会签的时候，有可能其他人还没有响应，这时候仍然需要等待其他人的响应；也有可能有足够的人进行了响应，这时候根据大家的意见，选择进入流向下一个活动。

customer节点的实现

写一个类，实现ExternalActivityBehaviour接口，它有两个方法需要实现，分别是execute和signal，定义如下：

public void execute(ActivityExecution aexe) throws Exception

 

public void signal(ActivityExecution aexe, String outComingName,

Map<String, ?> params)throws Exception

 

execute方法

当execution到达这个活动的时候触发，也就是运行到这个活动，创建这个活动的实例的时候就触发这个方法。

signal方法

处理一个外部的signal，也就是处理一次用户的singal请求。

实现会签的execute方法

当流程进入会签节点的时候，需要生成多个任务，分发给会签涉及到的多个人。

实现的基本思路为：

1：为customer节点创建一个task，好让流程停留在customer节点

2：为主task创建多个子task，每个参与会签的人员一个task

3：把当前的HistoryTaskInstanceActivity保存下来，后面恢复用

4：让流程停留在这里，等待外部来signal

实现会签的execute方法

当流程进入会签节点的时候，需要生成多个任务，分发给会签涉及到的多个人。

public void execute(ActivityExecution aexe) throws Exception {

ExecutionImpl exe = (ExecutionImpl)aexe;

DbSession session = EnvironmentImpl.getFromCurrent(DbSession.class);

 

//1：为customer1创建一个task，好让流程停留在customer1

//1.1定义task对象

TaskImpl mainTask = session.createTask();
mainTask.setAssignee(null);
mainTask.setName("HQ");
mainTask.setActivityName(aexe.getActivityName());
mainTask.setExecution(exe);
mainTask.setExecutionDbid(exe.getDbid());
mainTask.setSignalling(false);

 

//把这个task与流程实例关联起来

mainTask.setProcessInstance(exe.getProcessInstance());

//1.2保存这个对象

session.save(mainTask);

//1.3把这个对象和history连接起来

HistoryEvent.fire(new TaskActivityStart(mainTask),exe);

//2：为主task创建多个子task，每个参与会签的人员一个task

String users = (String) exe.getVariable("hqrs");
List<String> hqUsers = new ArrayList<String>();
for(String user : users.split(",")){
hqUsers.add(user);
 
TaskImpl subTask = mainTask.createSubTask();
subTask.setActivityName(aexe.getActivityName());
subTask.setAssignee(user);
//子对象不应该有execution对象，它使用父task的execution对象
// subTask.setExecution(exe);
subTask.setName(mainTask.getName()+"_"+user);
subTask.setSignalling(false);
subTask.setExecutionDbid(exe.getDbid());
 
session.save(subTask);
 
HistoryEvent.fire(new TaskActivityStart(subTask),exe);
}

 

//把应该参与会签的人员保存下来，后面好用到

exe.setVariable("hqUsers", hqUsers);

//4.4相比4.3在Custom节点execution后新加了对((ExecutionImpl) execution).historyAutomatic()的调用,

//这将在HistoryActivityInstance表中加一条自动历史记录,会造成如果Custom节点产生了Task,

//则根据execution取得的HistoryTaskInstanceActivity是错误的,因此先存下来，后面好恢复

exe.setVariable("historyAi", exe.getHistoryActivityInstanceDbid());

 

//3：让流程停留在这里，等待signal

exe.waitForSignal();

}

实现会签的signal方法

在某个人响应会签，在外部调用了singal的时候，会签节点需要做出相应的处理，以响应外部signal。

实现的基本思路为：

1：判断这个人是否应该参与会签

2：判断这个人是否会签过了

3：如果都没有，把这个人的任务结束了

4：把这个人的会签结果保存下来

5：然后根据业务规则进行判断，看是否满足会签结束的条件

6：如果满足

6.1先结束其他还没有完成会签的任务

6.2结束会签主任务

6.3判断应该走哪一条转移

6.4获取转移，然后接收它，从而实现流转

7：如果不满足，那么就继续等待

public void signal(ActivityExecution aexe, String outComingName, Map<String, ?> params)throws Exception {
ProcessEngine engine = Configuration.getProcessEngine();
ExecutionImpl exe =(ExecutionImpl)aexe;
TaskService ts = engine.getTaskService();

 //1：判断这个人是否应该参与会签

List hqUsers= (List<String>) exe.getVariable("hqUsers");
String user = (String)params.get("oper");
if(!hqUsers.contains(user)){
//继续等待
System.out.println("你不能参与会签");
exe.waitForSignal();
return;
}

 

//2：判断这个人是否会签过了

//2.1先找到主task

Task mainTask = ts.createTaskQuery().processInstanceId(exe.getProcessInstance()
.getId()).activityName("custom1").uniqueResult();
//2.2找到所有的子task
List<Task> subTaskList = ts.getSubTasks(mainTask.getId());
boolean hasHQ = true;
for(Task t : subTaskList){

 

//2.3判断这个人是否会签过了

if(user.equals(t.getAssignee())){

//存在就表示还没有会签，就把这个任务终止了

hasHQ = false;
ts.completeTask(t.getId());
break;
}
}

 //2.3如果是以前会签过的，就停止

if(hasHQ){
System.out.println("你已经会签过了");
//继续等待
exe.waitForSignal();
return;
}

 

//3：如果都没有，把这个人的任务结束了，上面已经做了

//4：把这个人的会签结果保存下来

Map<String,String> results = new HashMap<String,String>();
Object tempObject = exe.getVariable("results");
if(tempObject!=null){
results = (Map<String,String>)tempObject;
}
results.put(user, ""+params.get("result"));
exe.setVariable("results", results); 

 //5：然后根据业务规则进行判断，看是否满足会签结束的条件

int ok = 0;
int no = 0;
for(String s : results.values()){
if("yes".equals(s)){
ok++;
}else if("no".equals(s)){
no++;
}
}
if(ok > hqUsers.size()/2){
//说明ok了，转到toT2

 

//6：如果满足

//6.1先结束其他还没有完成会签的任务

//6.2结束会签主任伍

overTasks(exe);

//6.3判断应该走哪一条转移

Transition t = exe.getActivity().getOutgoingTransition("toT2");

//6.4获取转移，然后接收它，从而实现流转

exe.take(t);
}else if(no > hqUsers.size()/2){
//说明no了，转到toT3
overTasks(exe);
Transition t = exe.getActivity().getOutgoingTransition("toT3");
exe.take(t);
}else{

 //7：如果不满足，那么就继续等待

exe.waitForSignal();
}
}
private void overTasks(ExecutionImpl exe){
ProcessEngine engine = Configuration.getProcessEngine();
TaskService ts = engine.getTaskService();
Task mainTask = ts.createTaskQuery().processInstanceId(
exe.getProcessInstance().getId())
.activityName("custom1").uniqueResult();

 //2.2找到所有的子task，然后终止掉

List<Task> subTaskList = ts.getSubTasks(mainTask.getId());
for(Task t : subTaskList){
ts.completeTask(t.getId());
}

 

//2.3终止主task

//2.1先恢复HistoryActivityInstanceDbid

exe.setHistoryActivityInstanceDbid( (Long) exe.getVariable("historyAi"));

ts.completeTask(mainTask.getId());

}

委派介绍

委派，又称代理，是一种很常见的任务再分配机制。

比如，公司所有的个人公积金业务都需要文书小王来处理；但是，如果小王出差了呢？难道要等他回来再处理么？这时候就需要把任务委派给别人。

 

委派的实现

在jPDL里也没有委派这种活动，同样需要由我们自己来实现。

一个很好的思路就是：实现AssignmentHandler接口，在assign方法的实现里面，通过检索数据库，查看每个人的onDuty字段，来判断该工作人员是否在工作状态；如果不再工作状态，那么就去委派表里面检索指定的相应的委派人员，然后将任务分配给他即可。