JBPM4.4+SSH 整合配置及完整实例

<value>classpath:jbpm.repository.hbm.xml</value>   
<value>classpath:jbpm.execution.hbm.xml</value>   
<value>classpath:jbpm.history.hbm.xml</value>   
<value>classpath:jbpm.task.hbm.xml</value>   
<value>classpath:jbpm.identity.hbm.xml</value>     

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

package com.ht.util;  
  
import java.util.List;  
import java.util.Map;  
import java.util.zip.ZipInputStream;  
import org.jbpm.api.ExecutionService;  
import org.jbpm.api.HistoryService;  
import org.jbpm.api.ManagementService;  
import org.jbpm.api.ProcessDefinition;  
import org.jbpm.api.ProcessEngine;  
import org.jbpm.api.ProcessInstance;  
import org.jbpm.api.RepositoryService;  
import org.jbpm.api.TaskService;  
import org.jbpm.api.task.Task;  
  
/** 
 * jBPM4.4工具类 
 *  
 * @author ht 
 *  
 */  
public class JBPMUtil {  
      
    private ProcessEngine processEngine;  
    private RepositoryService repositoryService = null;  
    private ExecutionService executionService = null;  
    private TaskService taskService = null;  
    private HistoryService historyService = null;  
    private ManagementService managementService = null;  
      
    public JBPMUtil(){  
          
    }  
    public JBPMUtil(ProcessEngine processEngine) {  
        this.processEngine = processEngine;  
        repositoryService = processEngine.getRepositoryService();  
        executionService = processEngine.getExecutionService();  
        taskService = processEngine.getTaskService();  
        historyService = processEngine.getHistoryService();  
        managementService = processEngine.getManagementService();  
    }  
      
    public ProcessEngine getProcessEngine() {  
        return processEngine;  
    }  
  
    public void setProcessEngine(ProcessEngine processEngine) {  
        this.processEngine = processEngine;  
        System.out.println("processEngine="+processEngine);  
        repositoryService = processEngine.getRepositoryService();  
        executionService = processEngine.getExecutionService();  
        taskService = processEngine.getTaskService();  
        historyService = processEngine.getHistoryService();  
        managementService = processEngine.getManagementService();  
    }  
  
    public RepositoryService getRepositoryService() {  
        return repositoryService;  
    }  
  
    public void setRepositoryService(RepositoryService repositoryService) {  
        this.repositoryService = repositoryService;  
    }  
  
    public ExecutionService getExecutionService() {  
        return executionService;  
    }  
  
    public void setExecutionService(ExecutionService executionService) {  
        this.executionService = executionService;  
    }  
  
    public TaskService getTaskService() {  
        return taskService;  
    }  
  
    public void setTaskService(TaskService taskService) {  
        this.taskService = taskService;  
    }  
  
    public HistoryService getHistoryService() {  
        return historyService;  
    }  
  
    public void setHistoryService(HistoryService historyService) {  
        this.historyService = historyService;  
    }  
  
    public ManagementService getManagementService() {  
        return managementService;  
    }  
  
    public void setManagementService(ManagementService managementService) {  
        this.managementService = managementService;  
    }  
      
    /** 
     * 部署新流程定义 
     * @param resourceName 
     * @return 返回流程定义id 
     */  
    public String deployNew(String resourceName) {  
        return repositoryService.createDeployment().addResourceFromClasspath(  
                resourceName).deploy();  
    }  
    
    /** 
     * 部署新流程定义(zip) 
     * @param resourceName 
     * @return 返回流程定义id 
     */  
    public String deployZipNew(String resourceZipName){  
        ZipInputStream zis = new ZipInputStream(this.getClass().getResourceAsStream(resourceZipName));  
        return repositoryService.createDeployment().addResourcesFromZipInputStream(zis).deploy();       
    }   
      
    /** 
     * 开始一个流程实例 
     * @param id 
     * @param map 
     * @return 
     */  
      
    public ProcessInstance startPIById(String id,Map<String,?> map){    
        return executionService.startProcessInstanceById(id, map);           
    }  
      
    /** 
     * 完成任务 
     * @param taskId 
     * @param map 
     */  
      
    public void completeTask(String taskId,Map map){    
        taskService.completeTask(taskId, map);    
    }  
      
    /** 
     * 完成任务 
     * @param taskId 
     */  
    public void completeTask(String taskId){  
        taskService.completeTask(taskId);  
    }  
      
    /** 
     * 将任务流转到指定名字的流程outcome中去 
     * @param taskId 
     * @param outcome 
     */  
    public void completeTask(String taskId,String outcome){  
        taskService.completeTask(taskId, outcome);  
    }  
  
    /** 
     * 获得所有发布了的流程 
     * @return 
     */  
    public List<ProcessDefinition> getAllPdList(){  
        return repositoryService.createProcessDefinitionQuery().list();  
    }  
      
    /** 
     * 获得所有流程实例 
     * @return 
     */  
    public List<ProcessInstance> getAllPiList(){  
        return executionService.createProcessInstanceQuery().list();  
    }  
      
    /** 
     * 根据流程实例Id，即executionId获取指定的变量值 
     * @param executionId 
     * @param variableName 
     * @return 
     */  
    public Object getVariableByexecutionId(String executionId,String variableName){  
        return executionService.getVariable(executionId, variableName);  
    }  
      
    /** 
     * 根据任务id，即taskId获取指定变量值 
     * @param taskId 
     * @param variableName 
     * @return 
     */  
    public Object getVariableByTaskId(String taskId,String variableName){  
        return taskService.getVariable(taskId, variableName);  
    }  
      
    /** 
     * 获取指定用户名字的任务 
     * @param userName 
     * @return 
     */  
    public List<Task> findPersonalTasks(String userName){  
        return taskService.findPersonalTasks(userName);  
    }  
      
    /** 
     * 根据任务id获取任务 
     * @param taskId 
     * @return 
     */  
    public Task getTask(String taskId) {  
        return taskService.getTask(taskId);    
    }    
  
    /** 
     * 级联删除流程定义，直接删除该流程定义下的所有实例 
     *  
     * @param deploymentId  流程定义id 
     */  
    public void deleteDeploymentCascade(String deploymentId) {  
        repositoryService.deleteDeploymentCascade(deploymentId);  
    }        
}  

<?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:p="http://www.springframework.org/schema/p"  
    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-2.5.xsd  
           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd  
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd  
           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">  
  
    <!-- 配置数据源,导入c3p0-0.9.1.2.jar-->  
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"  
        destroy-method="close">  
        <property name="driverClass">  
            <value>net.sourceforge.jtds.jdbc.Driver</value>  
        </property>  
        <property name="jdbcUrl">  
            <value>jdbc:jtds:sqlserver://localhost:1433;DatabaseName=jBPM</value>  
        </property>  
        <property name="user">  
            <value>sa</value>  
        </property>  
        <property name="password">  
            <value>123</value>  
        </property>  
    </bean>  
      
    <bean name="hibernateProperties"  
        class="org.springframework.beans.factory.config.PropertiesFactoryBean">  
        <property name="properties">  
            <props>      
                <prop key="hibernate.dialect">org.hibernate.dialect.SQLServerDialect</prop>  
                <prop key="hibernate.show_sql">true</prop>  
                <prop key="hibernate.hbm2ddl.auto">update</prop>   
  
            </props>  
        </property>  
    </bean>  
      
    <!-- spring集成hibernate配置 -->  
    <bean id="sessionFactory"  
        class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">  
        <property name="dataSource" ref="dataSource" />  
        <property name="hibernateProperties" ref="hibernateProperties" />  
        <property name="mappingLocations">  
            <list>  
                <value>classpath*:com/ht/entity/*.hbm.xml</value>  
                <!-- 以下几个jbpm.*.hbm.xml由jBPM自带 -->  
                <value>classpath:jbpm.repository.hbm.xml</value>     
                <value>classpath:jbpm.execution.hbm.xml</value>     
                <value>classpath:jbpm.history.hbm.xml</value>     
                <value>classpath:jbpm.task.hbm.xml</value>     
                <value>classpath:jbpm.identity.hbm.xml</value>   
            </list>  
        </property>  
    </bean>    
  
    <!-- jbpm配置 -->  
    <bean id="springHelper" class="org.jbpm.pvm.internal.processengine.SpringHelper" />  
    <bean id="processEngine" factory-bean="springHelper" factory-method="createProcessEngine"  />  
      
    <bean id="jBPMUtil" class="com.ht.util.JBPMUtil">  
        <property name="processEngine" ref="processEngine"></property>  
    </bean>  
  
    <!-- 事务配置 -->  
    <bean id="transactionManager"  
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">  
        <property name="sessionFactory" ref="sessionFactory" />  
    </bean>  
</beans>