run example,but got error(at the last processInstance.signal
package com.benjamin.jbpm;
import org.hibernate.cfg.Configuration;
import org.jbpm.db.JbpmSessionFactory;
import org.jbpm.db.JbpmSession;
import org.jbpm.graph.def.ProcessDefinition;
import org.jbpm.graph.exe.ProcessInstance;
import org.jbpm.db.GraphSession;
import org.jbpm.graph.exe.Token;
import org.jbpm.context.exe.ContextInstance;
import java.util.List;
import junit.framework.TestCase;
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'>" +
" " +
" </start-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());
// 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();
}
}
java.lang.IllegalStateException: couldn't signal token : token has ended
at org.jbpm.graph.exe.ProcessInstance.signal(ProcessInstance.java:199)
at com.benjamin.jbpm.HelloWorldDBTest.theProcessInstanceContinuesWhenAnAsyncMessageIsReceived(HelloWorldDBTest.java:159)
at com.benjamin.jbpm.HelloWorldDBTest.testSimplePersistence(HelloWorldDBTest.java:46)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
at java.lang.reflect.Method.invoke(Method.java:585)
at junit.framework.TestCase.runTest(TestCase.java:154)
at junit.framework.TestCase.runBare(TestCase.java:127)
at junit.framework.TestResult$1.protect(TestResult.java:106)
at junit.framework.TestResult.runProtected(TestResult.java:124)
at junit.framework.TestResult.run(TestResult.java:109)
at junit.framework.TestCase.run(TestCase.java:118)
at junit.framework.TestSuite.runTest(TestSuite.java:208)
at junit.framework.TestSuite.run(TestSuite.java:203)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:478)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:344)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:196)
