spring + jbpm工作流

1.先修改jbpm-human-task/src/man/resources/META-INF/persistence.xml文件，将其修改成要链接的数据库，内容如下：

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<persistence version="1.0"
 xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
                                 http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd
                                 http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_1_0.xsd"
 xmlns:orm="http://java.sun.com/xml/ns/persistence/orm" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns="http://java.sun.com/xml/ns/persistence">
 <persistence-unit name="org.jbpm.task">
  <provider>org.hibernate.ejb.HibernatePersistence</provider>
  <class>org.jbpm.task.Attachment</class>
  <class>org.jbpm.task.Content</class>
  <class>org.jbpm.task.BooleanExpression</class>
  <class>org.jbpm.task.Comment</class>
  <class>org.jbpm.task.Deadline</class>
  <class>org.jbpm.task.Comment</class>
  <class>org.jbpm.task.Deadline</class>
  <class>org.jbpm.task.Delegation</class>
  <class>org.jbpm.task.Escalation</class>
  <class>org.jbpm.task.Group</class>
  <class>org.jbpm.task.I18NText</class>
  <class>org.jbpm.task.Notification</class>
  <class>org.jbpm.task.EmailNotification</class>
  <class>org.jbpm.task.EmailNotificationHeader</class>
  <class>org.jbpm.task.PeopleAssignments</class>
  <class>org.jbpm.task.Reassignment</class>
  <class>org.jbpm.task.Status</class>
  <class>org.jbpm.task.Task</class>
  <class>org.jbpm.task.TaskData</class>
  <class>org.jbpm.task.SubTasksStrategy</class>
  <class>org.jbpm.task.OnParentAbortAllSubTasksEndStrategy</class>
  <class>org.jbpm.task.OnAllSubTasksEndParentEndStrategy</class>
  <class>org.jbpm.task.User</class>
  <properties>
   <property name="hibernate.dialect" value="org.hibernate.dialect.OracleDialect" />
   <property name="hibernate.connection.driver_class" value="oracle.jdbc.driver.OracleDriver" />
   <property name="hibernate.connection.url" value="jdbc:oracle:thin:@192.168.1.101:1521:XE" />
   <property name="hibernate.connection.username" value="kevin" />
   <property name="hibernate.connection.password" value="asdfff" />
   <property name="hibernate.connection.autocommit" value="false" />
   <property name="hibernate.max_fetch_depth" value="3" />
   <property name="hibernate.show_sql" value="true" />
  </properties>
 </persistence-unit>
</persistence>

２.修改完成后可用一个写好的类启动mina,起动mina的类内容如下：

package com.kevin;

import java.io.IOException;
import java.io.Reader;
import java.util.Map;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import org.drools.SystemEventListenerFactory;
import org.jbpm.task.AccessType;
import org.jbpm.task.AllowedToDelegate;
import org.jbpm.task.Attachment;
import org.jbpm.task.BooleanExpression;
import org.jbpm.task.Comment;
import org.jbpm.task.Deadline;
import org.jbpm.task.Deadlines;
import org.jbpm.task.Delegation;
import org.jbpm.task.Escalation;
import org.jbpm.task.Group;
import org.jbpm.task.I18NText;
import org.jbpm.task.Notification;
import org.jbpm.task.OrganizationalEntity;
import org.jbpm.task.PeopleAssignments;
import org.jbpm.task.Reassignment;
import org.jbpm.task.Status;
import org.jbpm.task.Task;
import org.jbpm.task.TaskData;
import org.jbpm.task.User;
import org.jbpm.task.query.TaskSummary;
import org.jbpm.task.service.TaskService;
import org.jbpm.task.service.TaskServiceSession;
import org.jbpm.task.service.mina.MinaTaskServer;
import org.mvel2.MVEL;
import org.mvel2.ParserContext;
import org.mvel2.compiler.ExpressionCompiler;

public class MinaServer {

 public static void main(String[] args) {
  EntityManagerFactory emf = Persistence
    .createEntityManagerFactory("org.jbpm.task");
  TaskService taskService = new TaskService(emf,
    SystemEventListenerFactory.getSystemEventListener());
  TaskServiceSession taskSession = taskService.createSession();
  // Add users
  // Map vars = new HashMap();
  // Reader reader = new InputStreamReader(
  // BaseTest.class.getResourceAsStream( "LoadUsers.mvel" ) );
  // Map<String, User> users = ( Map<String, User> ) eval( reader, vars );
  // for ( User user : users.values() ) {
  // taskSession.addUser( user );
  // }

//   增加ActionId, by Kevin.
//   taskSession.addUser(new User("register"));
//   taskSession.addUser(new User("divert"));
//   taskSession.addUser(new User("deal"));
//   taskSession.addUser(new User("finish"));
  //
  // reader = new InputStreamReader( BaseTest.class.getResourceAsStream(
  // "LoadGroups.mvel" ) );
  // Map<String, Group> groups = ( Map<String, Group> ) eval( reader, vars
  // );
  // for ( Group group : groups.values() ) {
  // taskSession.addGroup( group );
  // }
  // start server
  MinaTaskServer server = new MinaTaskServer(taskService);
  Thread thread = new Thread(server);
  thread.start();
  System.out.println("Mina has stated.");
  taskSession.dispose();
 }

 @SuppressWarnings({ "rawtypes" })
 public static Object eval(Reader reader, Map vars) {
  try {
   return eval(toString(reader), vars);
  } catch (IOException e) {
   throw new RuntimeException("Exception Thrown", e);
  }
 }

 public static String toString(Reader reader) throws IOException {
  int charValue = 0;
  StringBuffer sb = new StringBuffer(1024);
  while ((charValue = reader.read()) != -1) {
   // result = result + (char) charValue;
   sb.append((char) charValue);
  }
  return sb.toString();
 }

 @SuppressWarnings({ "deprecation", "rawtypes" })
 public static Object eval(String str, Map vars) {
  ExpressionCompiler compiler = new ExpressionCompiler(str.trim());

  ParserContext context = new ParserContext();
  context.addPackageImport("org.drools.task");
  context.addPackageImport("java.util");

  context.addImport("AccessType", AccessType.class);
  context.addImport("AllowedToDelegate", AllowedToDelegate.class);
  context.addImport("Attachment", Attachment.class);
  context.addImport("BooleanExpression", BooleanExpression.class);
  context.addImport("Comment", Comment.class);
  context.addImport("Deadline", Deadline.class);
  context.addImport("Deadlines", Deadlines.class);
  context.addImport("Delegation", Delegation.class);
  context.addImport("Escalation", Escalation.class);
  context.addImport("Group", Group.class);
  context.addImport("I18NText", I18NText.class);
  context.addImport("Notification", Notification.class);
  context.addImport("OrganizationalEntity", OrganizationalEntity.class);
  context.addImport("PeopleAssignments", PeopleAssignments.class);
  context.addImport("Reassignment", Reassignment.class);
  context.addImport("Status", Status.class);
  context.addImport("Task", Task.class);
  context.addImport("TaskData", TaskData.class);
  context.addImport("TaskSummary", TaskSummary.class);
  context.addImport("User", User.class);

  return MVEL.executeExpression(compiler.compile(context), vars);
 }
}

３.对spring进行配置，配置文件内容如下：

<?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:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
 xmlns:aop="http://www.springframework.org/schema/aop" xmlns:task="http://www.springframework.org/schema/task"
 xsi:schemaLocation="
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd
   http://www.springframework.org/schema/jee
   http://www.springframework.org/schema/jee/spring-jee-3.0.xsd
   http://www.springframework.org/schema/tx
   http://www.springframework.org/schema/tx/spring-tx-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/task
   http://www.springframework.org/schema/task/spring-task-3.0.xsd">

 <context:component-scan base-package="*" />
 <context:annotation-config />
 <aop:aspectj-autoproxy />

 <tx:annotation-driven transaction-manager="txManager"
  proxy-target-class="true" />

 <bean id="txManager"
  class="org.springframework.transaction.jta.JtaTransactionManager" />

 <jee:jndi-lookup id="datasource" jndi-name="jdbc/mvnstruts2" />

 <bean id="sessionFactory"
  class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
  <property name="dataSource" ref="datasource" />
  <property name="packagesToScan" value="com.kevin.entity" />
 </bean>
 <bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
  <property name="sessionFactory" ref="sessionFactory" />
 </bean>

 <!-- 启动 Mina 供工作流用. -->
 <bean id="myemf"
  class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
  <property name="dataSource" ref="datasource" />
  <property name="persistenceUnitName" value="org.jbpm.mvnstruts2" />
  <property name="loadTimeWeaver">
   <bean
    class="org.springframework.instrument.classloading.InstrumentationLoadTimeWeaver" />
  </property>
 </bean>
 <bean
  class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor" />

 <bean id="minaClient" class="com.kevin.workflow.MinaClient" />
 <bean id="taskClient" factory-bean="minaClient" factory-method="getTaskClient" />
 <bean id="ksession" class="com.kevin.workflow.Ksession"
  init-method="start" />
</beans>

 

3.1 tomcat中server.xml的context内容如下：

  <Context docBase="jbpm_ssh" path="/jbpm_ssh" reloadable="true"
     source="org.eclipse.jst.jee.server:jbpm_ssh">
     <Resource name="jdbc/mvnstruts2" auth="Container"
      type="javax.sql.DataSource" factory="org.objectweb.jotm.datasource.DataSourceFactory"
      driverClassName="oracle.jdbc.driver.OracleDriver" username="kevin"
      password="asdfff" url="jdbc:oracle:thin:@192.168.1.101:1521:XE" />
     <Resource name="UserTransaction" auth="Container"
      type="javax.transaction.UserTransaction" />
     <Transaction factory="org.objectweb.jotm.UserTransactionFactory"
      jotm.timeout="60" />
    </Context>

 

４.spring.xml配置中，Ksession的内容如下：

package com.kevin.workflow;

import java.util.Map;
import javax.persistence.EntityManagerFactory;
import javax.persistence.PersistenceUnit;
import org.drools.KnowledgeBase;
import org.drools.KnowledgeBaseFactory;
import org.drools.builder.KnowledgeBuilder;
import org.drools.builder.KnowledgeBuilderFactory;
import org.drools.builder.ResourceType;
import org.drools.io.ResourceFactory;
import org.drools.logger.KnowledgeRuntimeLogger;
import org.drools.logger.KnowledgeRuntimeLoggerFactory;
import org.drools.persistence.jpa.JPAKnowledgeService;
import org.drools.runtime.Environment;
import org.drools.runtime.EnvironmentName;
import org.drools.runtime.StatefulKnowledgeSession;
import org.drools.runtime.process.ProcessInstance;
import org.jbpm.process.workitem.wsht.WSHumanTaskHandler;

public class Ksession {
 private StatefulKnowledgeSession ksession;
 private EntityManagerFactory emf;

 @PersistenceUnit(name = "org.jbpm.mvnstruts2")
 public void setEntityManagerFactory(EntityManagerFactory emf) {
  this.emf = emf;
 }

 public void start() {
  KnowledgeBase kbase;
  try {
   Environment env = KnowledgeBaseFactory.newEnvironment();
   env.set(EnvironmentName.ENTITY_MANAGER_FACTORY, emf);

   kbase = readKnowledgeBase();
   ksession = JPAKnowledgeService.newStatefulKnowledgeSession(kbase,
     null, env);
   KnowledgeRuntimeLogger logger = KnowledgeRuntimeLoggerFactory
     .newThreadedFileLogger(ksession, "test", 1000);
   ksession.getWorkItemManager().registerWorkItemHandler("Human Task",
     new WSHumanTaskHandler());
  } catch (Exception e) {
   e.printStackTrace();
  }
 }

 private KnowledgeBase readKnowledgeBase() throws Exception {
  KnowledgeBuilder kbuilder = KnowledgeBuilderFactory
    .newKnowledgeBuilder();
  kbuilder.add(ResourceFactory.newClassPathResource("eventProcess.bpmn"),
    ResourceType.BPMN2);
  return kbuilder.newKnowledgeBase();
 }

 public ProcessInstance startProcess(Map<String, Object> parameters) {
  ProcessInstance processInstance = ksession.startProcess(
    "com.kevin.eventProcess", parameters);
  return processInstance;
 }
}

５.spring配置中minaclient的内容如下：

package com.kevin.workflow;

import org.drools.SystemEventListenerFactory;
import org.jbpm.task.service.TaskClient;
import org.jbpm.task.service.mina.MinaTaskClientConnector;
import org.jbpm.task.service.mina.MinaTaskClientHandler;

public class MinaClient {
 private TaskClient taskClient;

 public MinaClient() {
  SystemEventListenerFactory
    .setSystemEventListener(new SystemEventListener());
  taskClient = new TaskClient(new MinaTaskClientConnector(
    "MinaConnector", new MinaTaskClientHandler(
      SystemEventListenerFactory.getSystemEventListener())));
  taskClient.connect("127.0.0.1", 9123);
 }

 public TaskClient getTaskClient() {
  return taskClient;
 }

 private static class SystemEventListener implements
   org.drools.SystemEventListener {
  public void debug(String arg0) {
  }

  public void debug(String arg0, Object arg1) {
  }

  public void exception(Throwable arg0) {
  }

  public void exception(String arg0, Throwable arg1) {
  }

  public void info(String arg0) {
  }

  public void info(String arg0, Object arg1) {
  }

  public void warning(String arg0) {
  }

  public void warning(String arg0, Object arg1) {
  }
 }
}

 

６.处理过程可参考jbpm-example中humantask的例子。