5:06 a.m.
User development,
A new message was posted in the thread "Problem retrieving running process
instance":
http://community.jboss.org/message/518922#518922
Author : Oliver Schneider
Profile : http://community.jboss.org/people/Masipulami
Message:
--------------------------------------------------------------
With JBPM 3 it worked as shown in the example below. But this way does not work any more
with JBPM 4.
What am I doing wrong?
package org.jbpm.tutorial.db;
import java.util.List;
import junit.framework.TestCase;
import org.jbpm.db.GraphSession;
import org.jbpm.db.JbpmSession;
import org.jbpm.db.JbpmSessionFactory;
import org.jbpm.graph.def.ProcessDefinition;
import org.jbpm.graph.exe.ProcessInstance;
import org.jbpm.graph.exe.Token;
public class HelloWorldDbTest extends TestCase {
// We need one JbpmSessionFactory per application. So we put it in
// a static variable. The JbpmSessionFactory will be used in the
// test methods to create JbpmSession's.
static JbpmSessionFactory jbpmSessionFactory =
JbpmSessionFactory.buildJbpmSessionFactory();
static {
// Since the hypersonic in-memory database is a new, fresh database,
// we need to create the schema at runtime before we start the tests.
// The next line creates the database tables and foreign key
// constraints.
jbpmSessionFactory.getJbpmSchema().createSchema();
}
public void testSimplePersistence() {
// Between the 3 method calls below, all data is passed via the
// database. Here, in this unit test, these 3 methods are executed
// right after each other because we want to test a complete process
// scenario. But in reality, these methods represent different
// requests to a server.
// Since we start with a clean, empty in-memory database, we have to
// deploy the process first. In reality, this is done once by the
// process developer.
deployProcessDefinition();
// Suppose we want to start a process instance (=process execution)
// when a user submits a form in a web application...
processInstanceIsCreatedWhenUserSubmitsWebappForm();
// Then, the arrival of an asynchronous message will continue
// execution.
theProcessInstanceContinuesWhenAnAsyncMessageIsReceived();
}
public void deployProcessDefinition() {
// This test shows a process definition and one execution
// of the process definition. The process definition has
// 3 nodes: an unnamed start-state, a state 's' and an
// end-state named 'end'.
ProcessDefinition processDefinition = ProcessDefinition.parseXmlString(
"<process-definition name='hello world'>" +
" <start-state name='start'>" +
" <transition to='s' />" +
" </start-state>" +
" <state name='s'>" +
" <transition to='end' />" +
" </state>" +
" <end-state name='end' />" +
"</process-definition>"
);
// Let's open a new persistence session
JbpmSession jbpmSession = jbpmSessionFactory.openJbpmSession();
// ... and begin a transaction on the persistence session
jbpmSession.beginTransaction();
// Save the process definition in the database
jbpmSession
.getGraphSession()
.saveProcessDefinition(processDefinition);
// Commit the transaction
jbpmSession.commitTransaction();
// And close the jbpmSession.
jbpmSession.close();
}
public void processInstanceIsCreatedWhenUserSubmitsWebappForm() {
// The code in this method could be inside a struts-action
// or a JSF managed bean.
// Let's open a new persistence session
JbpmSession jbpmSession = jbpmSessionFactory.openJbpmSession();
// ... and begin a transaction on the persistence session.
jbpmSession.beginTransaction();
// Now we can query the database for the process definition that we
// deployed above.
ProcessDefinition processDefinition =
jbpmSession
.getGraphSession()
.findLatestProcessDefinition("hello world");
// With the processDefinition that we retrieved from the database, we
// can create an execution of the process definition just like in the
// hello world example (which was without persistence).
ProcessInstance processInstance =
new ProcessInstance(processDefinition);
Token token = processInstance.getRootToken();
assertEquals("start", token.getNode().getName());
// Let's start the process execution
token.signal();
// Now the process is in the state 's'.
assertEquals("s", token.getNode().getName());
// Now the processInstance is saved in the database. So the
// current state of the execution of the process is stored in the
// database.
jbpmSession
.getGraphSession()
.saveProcessInstance(processInstance);
// The method below will get the process instance back out
// of the database and resume execution by providing another
// external signal.
// At the end of the webapp action, the transaction is committed.
jbpmSession.commitTransaction();
// And close the jbpmSession.
jbpmSession.close();
}
public void theProcessInstanceContinuesWhenAnAsyncMessageIsReceived() {
// The code in this method could be the content of a message driven bean.
// Let's open a new persistence session.
JbpmSession jbpmSession = jbpmSessionFactory.openJbpmSession();
// ... and begin a transaction on the persistence session
// note that it's also possible to use a jdbc connection from a
// DataSource in your application server.
jbpmSession.beginTransaction();
GraphSession graphSession = jbpmSession.getGraphSession();
// First, we need to get the process instance back out of the database.
// There are several options to know what process instance we are dealing
// with here. The easiest in this simple test case is just to look for
// the full list of process instances. That should give us only one
// result. So let's look up the process definition.
ProcessDefinition processDefinition =
graphSession.findLatestProcessDefinition("hello world");
// Now, we search for all process instances of this process definition.
List processInstances =
graphSession.findProcessInstances(processDefinition.getId());
// Because we know that in the context of this unit test, there is
// only one execution. In real life, the processInstanceId can be
// extracted from the content of the message that arrived or from
// the user making a choice.
ProcessInstance processInstance =
(ProcessInstance) processInstances.get(0);
// Now we can continue the execution. Note that the processInstance
// delegates signals to the main path of execution (=the root token).
processInstance.signal();
// After this signal, we know the process execution should have
// arrived in the end-state.
assertTrue(processInstance.hasEnded());
// Now we can update the state of the execution in the database
graphSession.saveProcessInstance(processInstance);
// At the end of the MDB, the transaction is committed.
jbpmSession.commitTransaction();
// And the jbpmSession is closed.
jbpmSession.close();
}
}
--------------------------------------------------------------
To reply to this message visit the message page:
http://community.jboss.org/message/518922#518922