spring + jbpm工作流

最新推荐文章于 2020-06-02 16:48:38 发布
最新推荐文章于 2020-06-02 16:48:38 发布
阅读量84 收藏
点赞数
文章标签： jbpm spring mina
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iteye_7816/article/details/82214598
版权

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的例子。

iteye_7816
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
javaee_spring_jbpm:Spring mybatis Hibernate jbpm4
07-08
spring mybatis hibernate3 jbpm4 deomo. JBPM 开始一个流程（启动流程） - 完成流程 完成流程操作taskService.completeTask completeTask(taskId) completeTask(taskId, variables) completeTask(taskId, outcome) completeTask(taskId, outcome, variables) 根据指定任务的ID，指定下一步的转移路径， 设入变量，完成操作任务 Process start： 仅有一个transition state(状态活动)： 流程处于中断等待的状态，可以对应多个transaition, signalExecutionXxxx触发流程的执行 decision” 使用decision活动判断流向哪个转移 (decision活动具有更加
spring与JBPM整合ppt
03-15
NULL 博文链接：https://dolphin-ygj.iteye.com/blog/322141
jbpm4.4整合spring2.5(ibatis与hibernate全整合)
pan-zy的专栏
11-07 1232
搞了好几个小时总算运行成功了，记录一下吧。 首先下载jbpm4.4，解压出来备用。然后工程自己导入hibernate和spring的jar包以及配置文件。好了可以开始整合了！ 整合的先后顺序是关键，下面按照顺序一步一步来设置: 1.首先jbpm是依赖数据库的，所以可以先创建数据库，我是mysql数据库，所以到jbpm-4.4\install\s
Spring+jbpm整合包括事务集成
dolphin_ygj
02-02 217
其实很简单，跟着我做吧！ 前提，jbpm的表和业务表都放在一个用户里面，这样可以共用一个sessionFactory，否则要用到分布式事务。 准备工作 0，拷贝jbpm-3.1.4.jar，jbpm-identity-3.1.4.jar, spring-modules-jbpm31.jar 到lib中。    从jbpm-3.1.4.jar 中解开default.jbpm.cfg.xml文件，并修...
[jbpm]一个完整的spring+jbpm+mysql整合例子
10-09 1298
[jbpm]一个完整的spring+jbpm+mysql整合例子 说明：例子jbpm版本为3.1.2。实现完全整合，并且由spring管理jbpmContext的session，此实例运行环境为tomcat 5.5.17。 一、创建MySql数据库： 　　设jbpm3.1.2解压文件夹为jbpm-starters-kit-3.1.2，查看目录\jbpm-db\build\my
struts+hibernate+spring+jbpm智能工作流系统
08-17
Struts、Hibernate、Spring 和 jBPM 是四个在企业级应用开发中广泛使用的开源框架，它们结合在一起可以构建出高效且灵活的智能工作流系统。下面将分别介绍这些技术及其在工作流系统中的作用。 **Struts** Struts 是...
struts2+spring+hibernate+jbpm工作流实例
02-25
在这个“struts2+spring+hibernate+jbpm工作流实例”中，主要展示了如何利用这些技术实现一个公文审批流转的过程。 首先，Struts2是一个基于MVC设计模式的Web应用框架，它负责处理HTTP请求，并将这些请求映射到相应...
spring+struts1+hibernate+jbpm实例
06-10
**JBPM**：JBPM是业务流程管理（BPM）和工作流引擎，用于设计、执行和管理业务流程。它可以定义、执行和监控复杂的业务流程，并且与Spring和其他Java框架有很好的集成。在这个实例中，jbpm-demo可能包含了一个具体的...
struts+hibernte+spring+jbpm 智能工作流系统
08-17
Struts、Hibernate、Spring 和 jBPM 是四个在IT行业中广泛应用的开源框架和技术，它们共同构建了一个智能工作流系统。这个系统集成了多种技术，旨在提供高效、灵活且可扩展的工作流程管理解决方案。 首先，Struts ...
JBPM6.1+Spring+web+mysql 可用的工作流项目例子（自动建表）
06-30
亲测可用，运行有问题，请联系我的邮箱 ohudnre@163.com 其他问题，有时间我会回复。 1 这个项目是maven-web项目 jdk1.6 2 项目有完善的spring和jbpm集成方法，jbpm版本是6，jbpm5和jbpm6版本差异较大，配置差异也很大，切记 3 用的数据库为mysql，在运行的时候，会自动在数据库中建立jbpm工作流的表。 4 可以根据自己的项目自行集成。
JBPM基于Spring系统工作流平台整合1------版本以及系统配置（原创）
wangyisong
03-23 134
JBPM基于Spring系统工作流平台整合1------版本以及系统配置 &nbsp; &nbsp; 声明：该文系作者原创，如您用于商业用途或者论文发表，请您一定要通知作者本人同意方可引用。 jbpm版本3.2.3 http://www.jboss.com/products/jbpm 下载后的文件是jbpm-jpdl-suite-3.2.3.zip，解压缩，可以...
spring+hibernate+jbpm整合成功
小吹的专栏
07-30 1822
最后的配置结果是：   hibernate.cfg.xml、jbpm.cfg.xml在关联spring后保持不变，只需要更改spirng的配置文件就好了。 xml version="1.0" encoding="UTF-8"?>DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN""http://www.springframework.
JBoss 系列五十八：jBPM Human Task 源代码分析 - I
Kylin Soong Blog -> ksoong.org
11-28 3582
概述 本文基于jBPM 5.2.x分析jBPM 5jbpm-human-task 部分源代码，我们之所以选择jBPM 5.2.x是由于jBPM 5.2.x是有对应企业版本的BRMS，该代码是被Red Hat维护更新，经常企业版本BRMS5.3的patch等是基于此进行的。 jBPM 5.2.x代码链接：https://github.com/droolsjbpm/jbpm/tree/5.2.x
activiti 启动报错 [PersistenceUnit: default] Unable to build EntityManagerFactory
ppwwp的专栏
06-02 1214
报错原因是，activiti使用jdk版本比较老 我用的是jdk11 解决方案是 <dependency> <groupId>javax.xml.bind</groupId> <artifactId>jaxb-api</artifactId> <version>2.3.0</version> </dependency> 或者在 tomcat中直接加入 D:\soft\apache-tomcat-9.0.
Drools 规则引擎----向领域驱动进步（三）
Piemon&Anokata的博客
08-09 4942
1.理解KieSession会话 到目前为止，我们已经讨论了KieSession以及如何创建它们并和他们进行交互。在这一章中，我们将深入研究一些在配置一个KieSession时候的高级的配置选项和组件。 1.1 无状态和有状态的KieSession会话 我们早已经知道，KieSession有两种不同的形式：stateless（无状态）和stateful（有状态）.我们所涵盖的大部分例子...
spring jpa 整合hibnate 报[PersistenceUnit: default] Unable to build Hibernate Sessi
heiqibaier的博客
06-14 2421
一直报不能创建hibernate factory工厂之类的错误然后，，，删了hibernate映射的一些代码，，删除所有这种代码@JoinColumn(name = "courseID", referencedColumnName = "courseID")神秘般的好使了，...
Spring+Hibernate+Jbpm 整合指南
此外，如果涉及任务服务和工作流实例的创建、查询等，还需要配置相应的bean，例如`TaskService`和`RuntimeService`。 Spring+Hibernate+jBPM的整合是一个复杂的过程，涉及到多个配置文件和bean的设置。这个成功整合...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值