JBPM4.3总结五
-
博客分类：
- Jbpm4.3
4 合同审批实例
1.画流程
代码：
<?xml version="1.0" encoding="UTF-8"?>
<process name="contract" xmlns="http://jbpm.org/4.3/jpdl">
<start g="11,241,48,48" name="start1">
<transition g="-66,-18" name="to 填写合同" to="填写合同"/>
</start>
<task candidate-groups="user_dept" form="contract.jsp" g="88,241,92,52" name="填写合同">
<transition g="-43,-18" name="to fork1" to="fork1"/>
<transition g="-72,-18" name="to 用户1审批" to="用户1审批"/>
<transition g="-72,-18" name="to 用户2审批" to="用户2审批"/>
</task>
<task assignee="test1" form="audit.jsp" g="175,158,92,52" name="用户1审批">
<transition g="431,115:-43,-18" name="批准" to="财务部"/>
<transition g="135,181:-21,-17" name="驳回" to="填写合同"/>
</task>
<task assignee="test2" form="audit.jsp" g="183,310,92,52" name="用户2审批">
<transition g="439,385:-43,-18" name="批准" to="财务部"/>
<transition g="89,339:-21,-17" name="驳回" to="填写合同"/>
</task>
<fork g="276,239,48,48" name="fork1">
<transition g="-54,-18" name="to 计划部" to="计划部"/>
<transition g="-54,-18" name="to 法务部" to="法务部"/>
<transition g="-64,-18" name="to IT规划部" to="IT规划部"/>
</fork>
<task candidate-groups="plan_dept" form="audit.jsp" g="359,301,92,52" name="计划部">
<transition g="-41,-18" name="批准" to="join1"/>
<transition name="驳回" to="填写合同" g="302,314:-66,-18"/>
</task>
<task candidate-groups="justice_dept" form="audit.jsp" g="356,232,92,52" name="法务部">
<transition g="-41,-18" name="批准" to="join1"/>
<transition name="驳回" to="填写合同" g="300,288:-2,-2"/>
</task>
<task candidate-groups="it_dept" form="audit.jsp" g="350,143,92,52" name="IT规划部">
<transition g="-41,-18" name="批准" to="join1"/>
<transition name="驳回" to="填写合同" g="298,200:-31,-11"/>
</task>
<join g="478,242,92,52" multiplicity="3" name="join1">
<transition g="-54,-18" name="to 财务部" to="财务部"/>
</join>
<task candidate-groups="finance_dept" form="money_audit.jsp" g="613,243,92,52" name="财务部">
<transition g="-42,-18" name="to end1" to="end1"/>
<transition g="658,432;405,436;135,435:-66,-18" name="to 填写合同" to="填写合同"/>
</task>
<end g="750,259,48,48" name="end1"/>
</process>
2.流程说明
1.填写合同 分配给 user_dept
2.填写完后，选择流向 2.1 会签（计划部 法务部 IT规划部） 2.2 人员审核（test1，test2）
3.如果2.2 ，退回时，合同直接退回给填写部门，批准后 到财务部再审批，
4.如果2.1 ，退回时，合同直接退回给填写部门，当会签所有的部门全部批准时，才会join，合同 才会到财务部
5.财务部批准后，流程结束，退回，打回填写部门。
流程开始：
3.执行流程
3.1首先发布流程，启动流程实例
发布：
repositoryService.createDeployment().addResourceFromClasspath("com/contract/contract.jpdl.xml").deploy();
启动：
executionSee.startProcessInstanceById(request.getParameter("id"));
1.User_dept部门成员登陆，填写合同，登陆后看到待办任务
taskService.getGroupTasks(username); 得到部门任务
点击查看，将打开这个任务所对应的form，可以选择审批流向。
选择会签。提交。
执行代码：
taskService.completeTask(taskId,outcome, map);
首页看到自己的执行情况。
会签过程中，所有的部门成员登陆，然后审批，登陆后，看到需要审批的任务
驳回，合同将回到最初的填写部门，填写部门再进行修改，然后再次提交。
提交，此部门审批通过。
当会签中所有的部门都审批通过时，财务部会接到需要审核的任务。
在首页能看到整个任务的审核情况
4.主要代码
流程实例：
List<ProcessDefinition> pdList = repositoryService
.createProcessDefinitionQuery().list();
得到任务：
List<Task> taskList = taskService.findGroupTasks(username);
List<Task> taskList2 = taskService.findPersonalTasks(username);
执行任务：
taskService.completeTask(taskId,outcome, map);
转交任务：
taskService.assignTask(taskId,“用户id”);
加签：
taskService.addTaskParticipatingUser(taskId,"用户
ID",Participation.CANDIDATE
============
对于加签应该没有达到用户的要求。。
如果能够自定义用户任务表的话，应该会简单点（临远提议），我之后也实现了大部分。。但是加签非常麻烦。
2010-06-21缩略显示JBPM4.3总结四
-
博客分类：
- Jbpm4.3
2.9任务管理
2.9.1 分配任务
流程定义时，分配任务有多种方法：
1. 直接分配给成员：assignee="user1" 可以同时分配多人：candidate-users（"user1","user2","user3"）
2. 分配给组：candidate-groups="it_dept" 分配给多个组：用逗号隔开部门id组列表。
3. 利用任务泳道进行分配：
1.任务泳道分配的特点：一个单子可以有多个人填写，一旦A填写了，别人就不能填写。而且当A提交的单子被退回的时候还应该有A来继续。
2.泳道定义：<swimlane candidate-groups="it_dept" name="test"/>，也可以为 candidate-users.
3.使用泳道：在task定义时 swimlane="test" 使用泳道，任务分配给it_dept部 门
4.使用任务分配器assignment-handler标签 使用方法：<assignment-handler class = "">
<field name="test"><string value="ttttttt"/></field>
</assignment-handler>
在class里面动态分配assignable.setAssignee(test);
通过传参数，设置 test的值。实现动态分配
2.9.2 成员任务列表
List<Task> taskList = taskService.findPersonalTasks(username);
2.9.3 组成员任务列表
List<Task> taskList = taskService.findGroupTasks(username);
由于任务有转交，加签等功能，所以一个人想要得到自己的任务就包括 组成员任务和成员任务两部分组成。
2.9.4 执行任务
得到任务列表后，如果任务有对应的表单，就先跳到表单，填写，然后执行。表单的绑定：在task标签中使用 form = "xxxx.jsp"，执行语句：
taskService.completeTask(taskId,"toFork1",map);
taskId 是任务id
toFork1 是outcome，即任务的出口
Map 是 传递的任务参数，通过任务就可以得到这些参数:
得到指定的参数值：taskService.getVariable(taskId, "user")
得到所有的参数：taskService.getvariableNames(java.lang.String.taskId);
2.9.5 转交任务
taskService.assignTask(taskId,"用户Id");
2.9.6 任务加签
taskService.addTaskParticipatingUser(taskId,"用户Id",Participation.CANDIDATE);
2.9.7 fork join 异步分支
<fork g="276,239,48,48" name="fork1">
<transition g="-54,-18" name="to 计划部" to="计划部"/>
<transition g="-54,-18" name="to 法务部" to="法务部"/>
<transition g="-64,-18" name="to IT规划部" to="IT规划部"/>
</fork>
Fork join 处理并发的情况，分配给的三个部门当执行完后，都流入到join标签。
Join标签属性： multiplicity="3" multiplicity 的意思是当有几个执行到了join时，流程继续。
2.9.8 decision 决定条件
decision中会运行并判断每一个transition 里的判断条件。 当遇到一个嵌套条件是true 或者没有
设置判断条件的转移，那么转移就会被运行。
例子：当天数大于3天，总经理审批 否则 结束
<decision expr="#{day > 3 ? 'to 总经理' : 'to 结束}" g="361,280,48,48" name="exclusive1">
<transition g="-42,-18" name="to end1" to="end1"/>
<transition g="-44,-18" name="to task2" to="总经理审核"/>
</decision>
Decision属性： expr 表达式 必填
2.9.9 Events 事件
当一个流程通过这一点时，事件监听器就会被提醒。
用法：在流程的任何地方都可以加入监听
<on event="start">
<event-listener class="org.jbpm.examples.eventlistener.LogListener">
// 参数
<field name="msg"><string value="start on process definition"/></field>
</event-listener>
2.9.10 JPDL简 介
1. Start state
开始节点 流程开始，每个流程定义文件 只能有一个开始节点。
2. Task node
任务节点 人工参与，调用processEngine.getTaskService().complete()完 成任务
3.State node
状态节点
需要使用execution.signalExcution()触发流程流转
4. Descision Node
流程流向判断节点
指定condition条件或者DesisionHandler
5. Fork node
分支节点,任务并行处理
6.Join node
任务聚合节点
7. End State
任务结束节点 可以有多个结束节点
8. Transition
控制任务流向
9. Event
事件触发 可以在任何节点加事件触发处理
具体参看${JPBM.HOME}/doc/userguide文档 关于JPDL的描述
3数据库表说明
（1）JBPM4_DEPLOYMENT、
（2）JBPM4_DEPLOYPROP
（3）JBPM4_LOB：
存储 上传一个包含png和jpdl.xml的zip包 的相关数据
jbpm4_deployment表多了一条记录
jbpm4_deployprop表多了四条记录,对应langid,pdid,pdkey,pdversion
jbpm4_lob 表多了二条记录,保存流程图png图片和jpdl.xml
（4）JBPM4_HIST_PROCINST与（5）JBPM4_HIST_ACTINST
分别存放的是Process Instance、Activity Instance的历史记录。
（6）JBPM4_EXECUTION
主要是存放JBPM4的执行信息，Execution机制代替了JBPM3的Token机制
（7）JBPM4_TASK
存放需要人来完成的Activities，需要人来参与完成的Activity被称为Task。
（8）JBPM4_PARTICIPATION
存放Participation的信息，Participation的种类有Candidate、 Client、Owner、Replaced Assignee和Viewer。而具体的Participation既可以是单一用户，也可以是用户组。
（9）JBPM4_SWIMLANE
Swim Lane是一种Runtime Process Role。通过Swim Lane，多个Task可以一次分配到同一Actor身上。
（10）JBPM4_VARIABLE
存的是进行时的临时变量。
（11）JBPM4_HIST_DETAIL
保存Variable的变更记录。
（12）JBPM4_HIST_VAR
保存历史的变量。
（13）JBPM4_HIST_TASK
Task的历史信息。
（14）JBPM4_ID_GROUP（15）JBPM_ID_MEMBERSHIP（16）JBPM4_ID_USER
这三张表很常见了，基本的权限控制，关于用户认证方面建议还是自己开发一套，JBPM4的功能太简单了，使用中有很多需要难以满足。
（17）JBPM4_JOB
存放的是Timer的定义。
（18）JBPM4_PROPERTY
JBPM4.3总结三
-
博客分类：
- Jbpm4.3
2.5集成自定义用户表
2.5.1 Jbpm4提供了实现接口
1.interface User
2.Interface Group
3.Interface GroupMember
4.Interface IdentitySession
想要集成自己的表，首先需要实现jbpm提供的接口，然后再进行配置。
2.5.2 User 用户表
import java.io.Serializable;
import java.sql.Blob;
import org.jbpm.api.identity.User;
/**
* 用户表 MesUser
*
* @version 1.0
*
*/
public class MesUser implements Serializable, User {
private static final long serialVersionUID = 1L;
private String id;
private String userNo;// 员工工号
private String userName;// 员工姓名
private String userSex;// 性别
private String userPassword;// 密码
private String userType;// 类型
private String userMail;// 电子邮件
private String isValid;// 是否有效Y/N
private Blob signaturePic;// 电子签名
private String remarks;// 备注
protected long dbid; // 数据库内部自生成的ID
protected int dbversion;
public int getDbversion() {
return dbversion;
}
public MesUser() {
}
public MesUser(String id, String userName, String userMail) {
this.id = id;
this.userName = userName;
this.userMail = userMail;
}
public void setDbversion(int dbversion) {
this.dbversion = dbversion;
}
public long getDbid() {
return dbid;
}
public void setDbid(long dbid) {
this.dbid = dbid;
}
public void setId(String id) {
this.id = id;
}
public String getUserNo() {
return userNo;
}
public void setUserNo(String userNo) {
this.userNo = userNo;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getUserSex() {
return userSex;
}
public void setUserSex(String userSex) {
this.userSex = userSex;
}
public String getUserPassword() {
return userPassword;
}
public void setUserPassword(String userPassword) {
this.userPassword = userPassword;
}
public String getUserType() {
return userType;
}
public void setUserType(String userType) {
this.userType = userType;
}
public String getUserMail() {
return userMail;
}
public void setUserMail(String userMail) {
this.userMail = userMail;
}
public String getIsValid() {
return isValid;
}
public void setIsValid(String isValid) {
this.isValid = isValid;
}
public Blob getSignaturePic() {
return signaturePic;
}
public void setSignaturePic(Blob signaturePic) {
this.signaturePic = signaturePic;
}
public String getRemarks() {
return remarks;
}
public void setRemarks(String remarks) {
this.remarks = remarks;
}
/**
* 显示用户姓名+工号
*
* @return
*/
public String getDisplayName() {
return userName + "(" + id + ")";
}
// 实现User接口所必须实现的几个方法
public String getId() {
return this.id;
}
public String getGivenName() {
return null;
}
public String getFamilyName() {
return null;
}
public String getBusinessEmail() {
return this.userMail;
}
}
2.5.3 Group部门表
import java.io.Serializable;
import org.jbpm.api.identity.Group;
public class MesGroup implements Serializable,Group {
private static final long serialVersionUID = 1L;
private String id;
private String groupName;//组织名称
private String groupType;//组织类型
private MesGroup parentGroup;//父组织
private String remarks;//备注
protected long dbid;
protected int dbversion;
public int getDbversion() {
return dbversion;
}
public void setDbversion(int dbversion) {
this.dbversion = dbversion;
}
public long getDbid() {
return dbid;
}
public void setDbid(long dbid) {
this.dbid = dbid;
}
public String getParentGroupID() {
return parentGroup!=null?parentGroup.getId():null;
}
public String getParentGroupName() {
return parentGroup==null ? "xxx" : parentGroup.getGroupName();
}
public void setId(String id) {
this.id = id;
}
public String getGroupName() {
return groupName;
}
public void setGroupName(String groupName) {
this.groupName = groupName;
}
public String getGroupType() {
return groupType;
}
public void setGroupType(String groupType) {
this.groupType = groupType;
}
public MesGroup getParentGroup() {
return parentGroup;
}
public void setParentGroup(MesGroup parentGroup) {
this.parentGroup = parentGroup;
}
public String getRemarks() {
return remarks;
}
public void setRemarks(String remarks) {
this.remarks = remarks;
}
//实现Group接口必须的几个方法
public String getName(){
return this.groupName;
}
public String getType(){
return this.groupType;
}
public String getId() {
return id;
}
}
2.5.4 GroupMember 用户部门关系表
import java.io.Serializable;
public class MesGroupMember implements Serializable {
private static final long serialVersionUID = 1L;
protected long dbid;
protected int dbversion;
private MesUser user;
private MesGroup group;
protected String role;
public int getDbversion() {
return dbversion;
}
public void setDbversion(int dbversion) {
this.dbversion = dbversion;
}
public long getDbid() {
return dbid;
}
public String getRole() {
return role;
}
public void setRole(String role) {
this.role = role;
}
public void setDbid(long dbid) {
this.dbid = dbid;
}
public MesGroup getGroup() {
return group;
}
public void setGroup(MesGroup group) {
this.group = group;
}
public String getUserNo() {
return user.getUserNo();
}
public String getUserID() {
return user.getId();
}
public String getUserName() {
return user.getUserName();
}
public MesUser getUser() {
return user;
}
public void setUser(MesUser user) {
this.user = user;
}
}
2.5.5 IdentitySession 实现类
import java.util.Arrays;
import java.util.List;
import org.hibernate.Session;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.jbpm.api.JbpmException;
import org.jbpm.api.identity.Group;
import org.jbpm.api.identity.User;
import org.jbpm.pvm.internal.env.BasicEnvironment;
import org.jbpm.pvm.internal.env.EnvironmentImpl;
import org.jbpm.pvm.internal.id.DbidGenerator;
import org.jbpm.pvm.internal.identity.spi.IdentitySession;
/**
* @author zhangkai
* @version 1.0
*
*/
@SuppressWarnings("unchecked")
public class MesIdentitySessionImpl implements IdentitySession {
protected Session session;
public MesIdentitySessionImpl() {
this.session = BasicEnvironment.getFromCurrent(Session.class);
}
public String createH() {
Test t = new Test();
long dbid = EnvironmentImpl.getFromCurrent(DbidGenerator.class)
.getNextId();
t.setDbid(dbid);
t.setId("abc");
return null;
}
public String createUser(String id, String userName,
String businessEmail, String familName) {
MesUser user = new MesUser(id, userName, businessEmail);
long dbid = EnvironmentImpl.getFromCurrent(DbidGenerator.class)
.getNextId();
user.setDbid(dbid);
session.save(user);
return user.getId();
}
public MesUser findUserById(String userId) {
return (MesUser) session.createCriteria(MesUser.class).add(
Restrictions.eq("id", userId)).uniqueResult();
}
public List<User> findUsersById(String... userIds) {
List<User> users = session.createCriteria(MesUser.class).add(
Restrictions.in("id", userIds)).list();
if (userIds.length != users.size()) {
throw new JbpmException("not all users were found: "
+ Arrays.toString(userIds));
}
return users;
}
public List<User> findUsers() {
return session.createCriteria(MesUser.class).list();
}
public void deleteUser(String userId) {
// lookup the user
MesUser user = findUserById(userId);
// cascade the deletion to the memberships
List<MesGroupMember> memberships = session.createCriteria(
MesGroupMember.class).add(Restrictions.eq("user", user)).list();
// delete the related memberships
for (MesGroupMember membership : memberships) {
session.delete(membership);
}
// delete the user
session.delete(user);
}
public String createGroup(String groupName, String groupType,
String parentGroupId) {
MesGroup group = new MesGroup();
String groupId = groupType != null ? groupType + "." + groupName
: groupName;
group.setId(groupId);
long dbid = EnvironmentImpl.getFromCurrent(DbidGenerator.class)
.getNextId();
group.setDbid(dbid);
group.setGroupName(groupName);
group.setGroupType(groupType);
if (parentGroupId != null) {
MesGroup parentGroup = findGroupById(parentGroupId);
group.setParentGroup(parentGroup);
}
session.save(group);
return group.getId();
}
public List<User> findUsersByGroup(String groupId) {
return session.createCriteria(MesGroupMember.class).createAlias(
"group", "g").add(Restrictions.eq("g.id", groupId))
.setProjection(Projections.property("user")).list();
}
public MesGroup findGroupById(String groupId) {
return (MesGroup) session.createCriteria(MesGroup.class).add(
Restrictions.eq("id", groupId)).uniqueResult();
}
public List<Group> findGroupsByUserAndGroupType(String userId,
String groupType) {
return session.createQuery(
"select distinct m.group" + " from "
+ MesGroupMember.class.getName()
+ " as m where m.user.id = :userId"
+ " and m.group.type = :groupType").setString("userId",
userId).setString("groupType", groupType).list();
}
public List<Group> findGroupsByUser(String userId) {
List<Group> gList = session.createQuery(
"select distinct m.group" + " from "
+ MesGroupMember.class.getName()
+ " as m where m.user.id = :userId").setString(
"userId", userId).list();
return gList;
}
public List<Group> findGroups() {
return session.createCriteria(MesGroup.class).list();
}
public void deleteGroup(String groupId) {
// look up the group
MesGroup group = findGroupById(groupId);
// cascade the deletion to the memberships
List<MesGroupMember> memberships = session.createCriteria(
MesGroupMember.class).add(Restrictions.eq("group", group))
.list();
// delete the related memberships
for (MesGroupMember membership : memberships) {
session.delete(membership);
}
// delete the group
session.delete(group);
}
public void createMembership(String userId, String groupId, String role) {
MesUser user = findUserById(userId);
if (user == null) {
throw new JbpmException("user " + userId + " doesn't exist");
}
MesGroup group = findGroupById(groupId);
if (group == null) {
throw new JbpmException("group " + groupId + " doesn't exist");
}
MesGroupMember membership = new MesGroupMember();
membership.setUser(user);
membership.setGroup(group);
membership.setRole(role);
long dbid = EnvironmentImpl.getFromCurrent(DbidGenerator.class)
.getNextId();
membership.setDbid(dbid);
session.save(membership);
}
public void deleteMembership(String userId, String groupId, String role) {
MesGroupMember membership = (MesGroupMember) session.createCriteria(
MesGroupMember.class).createAlias("user", "u").createAlias(
"group", "g").add(Restrictions.eq("u.id", userId)).add(
Restrictions.eq("g.id", groupId)).uniqueResult();
session.delete(membership);
}
}
2.5.6配置 jbpm.cfg.xml
使用自己的SessionImpl，在文件后面加上
<transaction-context>
<hibernate-session current="true"/>
<object class="xxx . Xxx . xxx . MesIdentitySessionImpl">
</object>
</transaction-context>
1.注释掉jbpm4自己的hbm.xml文件
<!--
<import resource="jbpm.identity.cfg.xml" />
-->
在jbpm.hibernate.cfg.xml 注入自己的
<mapping resource="customize.hbm.xml" />
2.5.7自定义hibernate映射文件
新建 customize.hbm.xml,内容如下
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="org.jbpm.pvm.internal.identity.impl" default-access="field">
<!-- ### USER ########################################################### -->
<class name="com.t.MesUser" table="JBPM4_CUSTOMIZE_USER">
<id name="dbid" column="DBID_">
<generator class="assigned" />
</id>
<version name="dbversion" column="DBVERSION_" />
<property name="id" column="USERID_" /> <!-- 登陆ID -->
<property name="userNo" column="USERNO_" /> <!-- 员工工号 -->
<property name="userName" column="USERNAME_" /> <!-- 姓名 -->
<property name="userSex" column="USERSEX_" /> <!-- 性别 -->
<property name="userPassword" column="USERPASSWORD_" /> <!-- 密码 -->
<property name="userType" column="USERTYPE_" /> <!-- 类型 -->
<property name="userMail" column="USERMAIL_" /> <!-- 电子邮件 -->
<property name="signaturePic" column="SIGNATUREPIC_" /> <!-- 电子签名 -->
<property name="remarks" column="REMARKS_" /> <!-- 备注 -->
</class>
<!-- ### MEMBERSHIP ##################################################### -->
<class name="com.t.MesGroupMember" table="JBPM4_CUSTOMIZE_MEMBERSHIP">
<id name="dbid" column="DBID_">
<generator class="assigned" />
</id>
<version name="dbversion" column="DBVERSION_" />
<many-to-one name="user"
column="USER_"
class="com.t.MesUser"
foreign-key="FK_MEM_USER"
index="IDX_MEM_USER"/>
<many-to-one name="group"
column="GROUP_"
class="com.t.MesGroup"
foreign-key="FK_MEM_GROUP"
index="IDX_MEM_GROUP"/>
<property name="role" column="NAME_" />
</class>
<!-- ### GROUP ########################################################### -->
<class name="com.t.MesGroup" table="JBPM4_CUSTOMIZE_GROUP">
<id name="dbid" column="DBID_">
<generator class="assigned" />
</id>
<version name="dbversion" column="DBVERSION_" />
<!--
private String groupID;//数据库内部ID号
private String groupName;//组织名称
private String groupType;//组织类型
private MesGroup parentGroup;//父组织
private String remarks;//备注
-->
<property name="id" column="ID_" />
<property name="groupName" column="NAME_" />
<property name="groupType" column="TYPE_" />
<property name="remarks" column="REMARKS_" />
<many-to-one name="parentGroup"
column="PARENT_"
class="com.t.MesGroup"
foreign-key="FK_GROUP_PARENT"
index="IDX_GROUP_PARENT"/>
</class>
</hibernate-mapping>
集成自己的表就完成了。当你调用 identityService.createUser()方法时，就往你自定义的user表里插入了一条记录。
2.6新建用户和组
identityService.createGroup("user_dept"); // 部门
identityService.createUser("user1", "test1", "test1"); // 新建用户1
identityService.createUser("user2", "test2", "test2"); /./新建用户2
identityService.createMembership("user1", "user_dept"); // 绑定用户和部门的关系
identityService.createMembership("user2", "user_dept");
2.7发布流程
发布流程：
ProcessEngine processEngine = Configuration.getProcessEngine();
RepositoryService repositoryService = processEngine
.getRepositoryService();
String deployId = repositoryService.createDeployment().addResourceFromClasspath("com/contract/contract.jpdl.xml").deploy();
删除流程:repositoryService.deleteDeploymentCascade(deployId));
2.8开始流程实例
executionService.startProcessInstanceById(request.getParameter("id"));
JBPM4.3总结二
-
博客分类：
- Jbpm4.3
Jbpm4.3使用文档
1.介绍
jBPM是一个可扩展、灵活的流程引擎， 它可以运行在独立的服务器上或者嵌入任何Java应用中。
类介绍：1.流程引擎 ProcessEngine processEngine = Configuration.getProcessEngine();
2.流程定义管理RepositoryService repositoryService = processEngine
.getRepositoryService();
3.执行管理ExecutionService executionService = processEngine
.getExecutionService();
4.任务管理TaskService taskService = processEngine.getTaskService();
5.历史管理HistoryService historyService = processEngine.getHistoryService();
6.用户管理IdentityService identityService= processEngine.getIdentityService();
使用步骤
下载
Jbpm4.3应用包：http://sourceforge.net/projects/jbpm/files/，解压。
源码下载：可以从jBPM的SVN仓库里下载源代码。
https://anonsvn.jboss.org/repos/jbpm/jbpm4/
2集成jbpm4.3
2.1 配置jbpm
首先到jbpm安装目录，复制 examples\src下的xml文件到你的项目src下。然后修改jbpm.hibernate.cfg.xml <!-- 改成自己的数据库链接 默认是hsql，可以直接运行examples-->
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name="hibernate.dialect">org.hibernate.dialect.HSQLDialect</property>
<property name="hibernate.connection.driver_class">org.hsqldb.jdbcDriver</property>
<property name="hibernate.connection.url">jdbc:hsqldb:mem:.</property>
<property name="hibernate.connection.username">sa</property>
<property name="hibernate.connection.password"></property>
<property name="hibernate.hbm2ddl.auto">create-drop</property>
<property name="hibernate.format_sql">false</property>
<mapping resource="jbpm.repository.hbm.xml" />
<mapping resource="jbpm.execution.hbm.xml" />
<mapping resource="jbpm.history.hbm.xml" />
<mapping resource="jbpm.task.hbm.xml" />
<mapping resource="jbpm.identity.hbm.xml" />
</session-factory>
</hibernate-configuration>
2.2 sql脚本
到jbpm4.3安装目录下install\src\db\create找到和自己数据库想对应的sql文件，目前有hsqldb，mysql，oracle，postgresql。
2.3执行脚本建表
Mysql举例：打开 MySQL Command Line Client，然后执行 source ./sql文件
2.4使用步骤实例
ProcessEngine processEngine = Configuration.getProcessEngine();
IdentityService identityService = processEngine.getIdentityService();
RepositoryService repositoryService = processEngine.getRepositoryService();
ExecutionService executionService = processEngine.getExecutionService();
TaskService taskService = processEngine.getTaskService();
HistoryService historyService = processEngine.getHistoryService();
String username = (String) session.getAttribute("username");
//得到流程定义
List<ProcessDefinition> pdL = repositoryService.createProcessDefinitionQuery().list();
//流程实例
List<ProcessInstance> piL = executionService.createProcessInstanceQuery().list();
//当前用户的任务列表
List<Task> tL = taskService.findGroupTasks(username);
List<Task> tLByPerson = taskService.findPersonalTasks(username);
//处理历史列表
List<HistoryActivityInstance> htL = new ArrayList<HistoryActivityInstance>();
待续。。。。。。。。。。。。
2010-06-21缩略显示
JBPM4.3总结一
-
博客分类：
- Jbpm4.3
由于工作需要，利用上班时间在学习JBPM4.3（工作流）。在随后的日子里，将陆续总结。。。、
总结一就不写什么技术性的文字了。
学习感觉：（只谈缺点，既然用了，优点就不说了）
1. 文档比较少 ，官方提供了 测试用例,用户手册 和 开发手册。但是内容极其简单。想深入就这点是不够的。
2. 对于历史数据的管理很浅。只记录了流程中任务的开始结束时间，并且没有对其中用的到参数进行存储。对历史数据有点要求的，都必须自己来实现,而实现起来灵活性又存在问题。。
3.官方提供了自定义用户和组表的方法，其实就写了一句提醒的话。但是现在还没有找到能代替history 和 task操作方法的地方。不知是否可以自定义（已经实现）
4.学起来好费劲。。
5.最后慢慢找到感觉，多亏临远大哥的帮忙。谢谢。