public class RuntimeServiceImpl extends ServiceImpl implements RuntimeService
commandExecutor| Constructor and Description |
|---|
RuntimeServiceImpl() |
| Modifier and Type | Method and Description |
|---|---|
void |
activateProcessInstanceById(String processInstanceId)
Activates the process instance with the given id.
|
void |
correlateMessage(String messageName)
Correlates a message to either an execution that is waiting for this message or a process definition
that can be started by this message.
|
void |
correlateMessage(String messageName,
Map<String,Object> correlationKeys)
Correlates a message to
an execution that is waiting for this message and can be correlated according
to the given correlation keys.
|
void |
correlateMessage(String messageName,
Map<String,Object> correlationKeys,
Map<String,Object> processVariables)
Correlates a message to
an execution that is waiting for this message and can be correlated according
to the given correlation keys.
|
void |
correlateMessage(String messageName,
String businessKey)
Correlates a message to
an execution that is waiting for this message and belongs to a process instance with the given business key
a process definition that can be started by this message.
|
void |
correlateMessage(String messageName,
String businessKey,
Map<String,Object> processVariables)
Correlates a message to
an execution that is waiting for this message and belongs to a process instance with the given business key
a process definition that can be started by this message.
|
void |
correlateMessage(String messageName,
String businessKey,
Map<String,Object> correlationKeys,
Map<String,Object> processVariables)
Correlates a message to
an execution that is waiting for this message and can be correlated according
to the given correlation keys.
|
EventSubscriptionQuery |
createEventSubscriptionQuery()
Creates a new
EventSubscriptionQuery instance, that can be used to query
event subscriptions. |
ExecutionQuery |
createExecutionQuery()
Creates a new
ExecutionQuery instance,
that can be used to query the executions and process instances. |
IncidentQuery |
createIncidentQuery()
Creates a new
IncidentQuery instance, that can be used
to query incidents. |
NativeExecutionQuery |
createNativeExecutionQuery()
creates a new
NativeExecutionQuery to query Executions
by SQL directly |
NativeProcessInstanceQuery |
createNativeProcessInstanceQuery()
creates a new
NativeProcessInstanceQuery to query ProcessInstances
by SQL directly |
ProcessInstanceQuery |
createProcessInstanceQuery()
Creates a new
ProcessInstanceQuery instance, that can be used
to query process instances. |
VariableInstanceQuery |
createVariableInstanceQuery()
Creates a new
VariableInstanceQuery instance, that can be used to query
variable instances. |
void |
deleteProcessInstance(String processInstanceId,
String deleteReason)
Delete an existing runtime process instance.
|
List<String> |
getActiveActivityIds(String executionId)
Finds the activity ids for all executions that are waiting in activities.
|
ActivityInstance |
getActivityInstance(String processInstanceId)
Allows retrieving the activity instance tree for a given process instance.
|
FormData |
getFormInstanceById(String processDefinitionId) |
Object |
getVariable(String executionId,
String variableName)
The variable value.
|
Object |
getVariableLocal(String executionId,
String variableName)
The variable value for an execution.
|
Map<String,Object> |
getVariables(String executionId)
All variables visible from the given execution scope (including parent scopes).
|
Map<String,Object> |
getVariables(String executionId,
Collection<String> variableNames)
The variable values for all given variableNames, takes all variables into account which are visible from the given execution scope (including parent scopes).
|
Map<String,Object> |
getVariablesLocal(String executionId)
All variable values that are defined in the execution scope, without taking outer scopes into account.
|
Map<String,Object> |
getVariablesLocal(String executionId,
Collection<String> variableNames)
The variable values for the given variableNames only taking the given execution scope into account, not looking in outer scopes.
|
void |
messageEventReceived(String messageName,
String executionId)
Notifies the process engine that a message event with name 'messageName' has
been received and has been correlated to an execution with id 'executionId'.
|
void |
messageEventReceived(String messageName,
String executionId,
Map<String,Object> processVariables)
Notifies the process engine that a message event with the name 'messageName' has
been received and has been correlated to an execution with id 'executionId'.
|
void |
removeVariable(String executionId,
String variableName)
Removes a variable for an execution.
|
void |
removeVariableLocal(String executionId,
String variableName)
Removes a variable for an execution (not considering parent scopes).
|
void |
removeVariables(String executionId,
Collection<String> variableNames)
Removes variables for an execution.
|
void |
removeVariablesLocal(String executionId,
Collection<String> variableNames)
Remove variables for an execution (not considering parent scopes).
|
void |
setVariable(String executionId,
String variableName,
Object value)
Update or create a variable for an execution.
|
void |
setVariableLocal(String executionId,
String variableName,
Object value)
Update or create a variable for an execution (not considering parent scopes).
|
void |
setVariables(String executionId,
Map<String,? extends Object> variables)
Update or create given variables for an execution (including parent scopes).
|
void |
setVariablesLocal(String executionId,
Map<String,? extends Object> variables)
Update or create given variables for an execution (not considering parent scopes).
|
void |
signal(String executionId)
Sends an external trigger to an activity instance that is waiting inside the given execution.
|
void |
signal(String executionId,
Map<String,Object> processVariables)
Sends an external trigger to an activity instance that is waiting inside the given execution.
|
void |
signalEventReceived(String signalName)
Notifies the process engine that a signal event of name 'signalName' has
been received.
|
void |
signalEventReceived(String signalName,
Map<String,Object> processVariables)
Notifies the process engine that a signal event of name 'signalName' has
been received.
|
void |
signalEventReceived(String signalName,
String executionId)
Notifies the process engine that a signal event of name 'signalName' has
been received.
|
void |
signalEventReceived(String signalName,
String executionId,
Map<String,Object> processVariables)
Notifies the process engine that a signal event of name 'signalName' has
been received.
|
ProcessInstance |
startProcessInstanceById(String processDefinitionId)
Starts a new process instance in the exactly specified version of the process definition with the given id.
|
ProcessInstance |
startProcessInstanceById(String processDefinitionId,
Map<String,Object> variables)
Starts a new process instance in the exactly specified version of the process definition with the given id.
|
ProcessInstance |
startProcessInstanceById(String processDefinitionId,
String businessKey)
Starts a new process instance in the exactly specified version of the process definition with the given id.
|
ProcessInstance |
startProcessInstanceById(String processDefinitionId,
String businessKey,
Map<String,Object> variables)
Starts a new process instance in the exactly specified version of the process definition with the given id.
|
ProcessInstance |
startProcessInstanceByKey(String processDefinitionKey)
Starts a new process instance in the latest version of the process definition with the given key.
|
ProcessInstance |
startProcessInstanceByKey(String processDefinitionKey,
Map<String,Object> variables)
Starts a new process instance in the latest version of the process definition with the given key
|
ProcessInstance |
startProcessInstanceByKey(String processDefinitionKey,
String businessKey)
Starts a new process instance in the latest version of the process
definition with the given key.
|
ProcessInstance |
startProcessInstanceByKey(String processDefinitionKey,
String businessKey,
Map<String,Object> variables)
Starts a new process instance in the latest version of the process definition with the given key.
|
ProcessInstance |
startProcessInstanceByMessage(String messageName)
Signals the process engine that a message is received and starts a new
ProcessInstance. |
ProcessInstance |
startProcessInstanceByMessage(String messageName,
Map<String,Object> processVariables)
Signals the process engine that a message is received and starts a new
ProcessInstance. |
ProcessInstance |
startProcessInstanceByMessage(String messageName,
String businessKey)
Signals the process engine that a message is received and starts a new
ProcessInstance. |
ProcessInstance |
startProcessInstanceByMessage(String messageName,
String businessKey,
Map<String,Object> processVariables)
Signals the process engine that a message is received and starts a new
ProcessInstance. |
void |
suspendProcessInstanceById(String processInstanceId)
Suspends the process instance with the given id.
|
void |
updateVariables(String executionId,
Map<String,? extends Object> modifications,
Collection<String> deletions) |
void |
updateVariablesLocal(String executionId,
Map<String,? extends Object> modifications,
Collection<String> deletions) |
getCommandExecutor, setCommandExecutorpublic ProcessInstance startProcessInstanceByKey(String processDefinitionKey)
RuntimeServicestartProcessInstanceByKey in interface RuntimeServiceprocessDefinitionKey - key of process definition, cannot be null.public ProcessInstance startProcessInstanceByKey(String processDefinitionKey, String businessKey)
RuntimeServiceProcessInstanceQuery.processInstanceBusinessKey(String). Providing such a business
key is definitely a best practice.
Note that a business key MUST be unique for the given process definition WHEN you have added
a database constraint for it.
In this case, only Process instance from different process definition are allowed to have the
same business key and the combination of processdefinitionKey-businessKey must be unique.startProcessInstanceByKey in interface RuntimeServiceprocessDefinitionKey - key of process definition, cannot be null.businessKey - a key that uniquely identifies the process instance in the context
of the given process definition.public ProcessInstance startProcessInstanceByKey(String processDefinitionKey, Map<String,Object> variables)
RuntimeServicestartProcessInstanceByKey in interface RuntimeServiceprocessDefinitionKey - key of process definition, cannot be null.variables - the variables to pass, can be null.public ProcessInstance startProcessInstanceByKey(String processDefinitionKey, String businessKey, Map<String,Object> variables)
RuntimeServiceProcessInstanceQuery.processInstanceBusinessKey(String). Providing such a business
key is definitely a best practice.
Note that a business key MUST be unique for the given process definition WHEN you have added a
database constraint for it.
In this case, only Process instance from different process definition are allowed to have the
same business key and the combination of processdefinitionKey-businessKey must be unique.
The combination of processdefinitionKey-businessKey must be unique.startProcessInstanceByKey in interface RuntimeServiceprocessDefinitionKey - key of process definition, cannot be null.businessKey - a key that uniquely identifies the process instance in the context of the
given process definition.variables - the variables to pass, can be null.public ProcessInstance startProcessInstanceById(String processDefinitionId)
RuntimeServicestartProcessInstanceById in interface RuntimeServiceprocessDefinitionId - the id of the process definition, cannot be null.public ProcessInstance startProcessInstanceById(String processDefinitionId, String businessKey)
RuntimeServiceProcessInstanceQuery.processInstanceBusinessKey(String). Providing such a business
key is definitely a best practice.
Note that a business key MUST be unique for the given process definition WHEN you have added
a database constraint for it.
In this case, only Process instance from different process definition are allowed to have the
same business key and the combination of processdefinitionKey-businessKey must be unique.startProcessInstanceById in interface RuntimeServiceprocessDefinitionId - the id of the process definition, cannot be null.businessKey - a key that uniquely identifies the process instance in the context of the
given process definition.public ProcessInstance startProcessInstanceById(String processDefinitionId, Map<String,Object> variables)
RuntimeServicestartProcessInstanceById in interface RuntimeServiceprocessDefinitionId - the id of the process definition, cannot be null.variables - variables to be passed, can be nullpublic ProcessInstance startProcessInstanceById(String processDefinitionId, String businessKey, Map<String,Object> variables)
RuntimeServiceProcessInstanceQuery.processInstanceBusinessKey(String). Providing such a business
key is definitely a best practice.
Note that a business key MUST be unique for the given process definition WHEN you have added
a database constraint for it.
In this case, only Process instance from different process definition are allowed to have the
same business key and the combination of processdefinitionKey-businessKey must be unique.startProcessInstanceById in interface RuntimeServiceprocessDefinitionId - the id of the process definition, cannot be null.businessKey - a key that uniquely identifies the process instance in the context of the
given process definition.variables - variables to be passed, can be nullpublic void deleteProcessInstance(String processInstanceId, String deleteReason)
RuntimeServicedeleteProcessInstance in interface RuntimeServiceprocessInstanceId - id of process instance to delete, cannot be null.deleteReason - reason for deleting, can be null.public ExecutionQuery createExecutionQuery()
RuntimeServiceExecutionQuery instance,
that can be used to query the executions and process instances.createExecutionQuery in interface RuntimeServicepublic NativeExecutionQuery createNativeExecutionQuery()
RuntimeServiceNativeExecutionQuery to query Executions
by SQL directlycreateNativeExecutionQuery in interface RuntimeServicepublic NativeProcessInstanceQuery createNativeProcessInstanceQuery()
RuntimeServiceNativeProcessInstanceQuery to query ProcessInstances
by SQL directlycreateNativeProcessInstanceQuery in interface RuntimeServicepublic IncidentQuery createIncidentQuery()
RuntimeServiceIncidentQuery instance, that can be used
to query incidents.createIncidentQuery in interface RuntimeServicepublic EventSubscriptionQuery createEventSubscriptionQuery()
RuntimeServiceEventSubscriptionQuery instance, that can be used to query
event subscriptions.createEventSubscriptionQuery in interface RuntimeServicepublic VariableInstanceQuery createVariableInstanceQuery()
RuntimeServiceVariableInstanceQuery instance, that can be used to query
variable instances.createVariableInstanceQuery in interface RuntimeServicepublic Map<String,Object> getVariables(String executionId)
RuntimeServicegetVariables in interface RuntimeServiceexecutionId - id of execution, cannot be null.public Map<String,Object> getVariablesLocal(String executionId)
RuntimeServiceRuntimeService.getVariablesLocal(String, Collection)
for better performance.getVariablesLocal in interface RuntimeServiceexecutionId - id of execution, cannot be null.public Map<String,Object> getVariables(String executionId, Collection<String> variableNames)
RuntimeServicegetVariables in interface RuntimeServiceexecutionId - id of execution, cannot be null.variableNames - the collection of variable names that should be retrieved.public Map<String,Object> getVariablesLocal(String executionId, Collection<String> variableNames)
RuntimeServicegetVariablesLocal in interface RuntimeServiceexecutionId - id of execution, cannot be null.variableNames - the collection of variable names that should be retrieved.public Object getVariable(String executionId, String variableName)
RuntimeServicegetVariable in interface RuntimeServiceexecutionId - id of execution, cannot be null.variableName - name of variable, cannot be null.public Object getVariableLocal(String executionId, String variableName)
RuntimeServicegetVariableLocal in interface RuntimeServicepublic void setVariable(String executionId, String variableName, Object value)
RuntimeServicesetVariable in interface RuntimeServiceexecutionId - id of execution to set variable in, cannot be null.variableName - name of variable to set, cannot be null.value - value to set. When null is passed, the variable is not removed,
only it's value will be set to null.public void setVariableLocal(String executionId, String variableName, Object value)
RuntimeServicesetVariableLocal in interface RuntimeServiceexecutionId - id of execution to set variable in, cannot be null.variableName - name of variable to set, cannot be null.value - value to set. When null is passed, the variable is not removed,
only it's value will be set to null.public void setVariables(String executionId, Map<String,? extends Object> variables)
RuntimeServicesetVariables in interface RuntimeServiceexecutionId - id of the execution, cannot be null.variables - map containing name (key) and value of variables, can be null.public void setVariablesLocal(String executionId, Map<String,? extends Object> variables)
RuntimeServicesetVariablesLocal in interface RuntimeServiceexecutionId - id of the execution, cannot be null.variables - map containing name (key) and value of variables, can be null.public void removeVariable(String executionId, String variableName)
RuntimeServiceremoveVariable in interface RuntimeServiceexecutionId - id of execution to remove variable in.variableName - name of variable to remove.public void removeVariableLocal(String executionId, String variableName)
RuntimeServiceremoveVariableLocal in interface RuntimeServiceexecutionId - id of execution to remove variable in.variableName - name of variable to remove.public void removeVariables(String executionId, Collection<String> variableNames)
RuntimeServiceremoveVariables in interface RuntimeServiceexecutionId - id of execution to remove variable in.variableNames - collection containing name of variables to remove.public void removeVariablesLocal(String executionId, Collection<String> variableNames)
RuntimeServiceremoveVariablesLocal in interface RuntimeServiceexecutionId - id of execution to remove variable in.variableNames - collection containing name of variables to remove.public void updateVariables(String executionId, Map<String,? extends Object> modifications, Collection<String> deletions)
public void updateVariablesLocal(String executionId, Map<String,? extends Object> modifications, Collection<String> deletions)
public void signal(String executionId)
RuntimeServicesignal in interface RuntimeServiceexecutionId - id of execution to signal, cannot be null.public void signal(String executionId, Map<String,Object> processVariables)
RuntimeServicesignal in interface RuntimeServiceexecutionId - id of execution to signal, cannot be null.processVariables - a map of process variablespublic ProcessInstanceQuery createProcessInstanceQuery()
RuntimeServiceProcessInstanceQuery instance, that can be used
to query process instances.createProcessInstanceQuery in interface RuntimeServicepublic List<String> getActiveActivityIds(String executionId)
RuntimeServicegetActiveActivityIds in interface RuntimeServiceexecutionId - id of the execution, cannot be null.public ActivityInstance getActivityInstance(String processInstanceId)
RuntimeServiceAllows retrieving the activity instance tree for a given process instance. The activity instance tree is aligned with the concept of scope in the BPMN specification. Activities that are "on the same level of subprocess" (ie. part of the same scope, contained in the same subprocess) will have their activity instances at the same level in the tree.
Each activity instance is assigned a unique Id. The id is persistent, if you invoke this method multiple times, the same activity instance ids will be returned for the same activity instances. (However, there might be different executions assigned, see below)
The Execution concept in the process engine is not completely aligned with the activity
instance concept because the execution tree is in general not aligned with the activity / scope concept in
BPMN. In general, there is a n-1 relationship between Executions and ActivityInstances, ie. at a given
point in time, an activity instance can be linked to multiple executions. In addition, it is not guaranteed
that the same execution that started a given activity instance will also end it. The process engine performs
several internal optimizations concerning the compacting of the execution tree which might lead to executions
being reordered and pruned. This can lead to situations where a given execution starts an activity instance
but another execution ends it. Another special case is the process instance: if the process instance is executing
a non-scope activity (for example a user task) below the process definition scope, it will be referenced
by both the root activity instance and the user task activity instance.
If you need to interpret the state of a process instance in terms of a BPMN process model, it is usually easier to use the activity instance tree as opposed to the execution tree.
getActivityInstance in interface RuntimeServiceprocessInstanceId - the id of the process instance for which the activity instance tree should be constructed.public void suspendProcessInstanceById(String processInstanceId)
RuntimeServiceSuspends the process instance with the given id. This means that the execution is stopped, so the token state will not change. However, actions that do not change token state, like setting/removing variables, etc. will succeed.
Tasks belonging to this process instance will also be suspended. This means that any actions influencing the tasks' lifecycles will fail, such as
If a process instance is in state suspended, the engine will also not execute jobs (timers, messages) associated with this instance.
If you have a process instance hierarchy, suspending one process instance from the hierarchy will not suspend other process instances from that hierarchy.
suspendProcessInstanceById in interface RuntimeServicepublic void activateProcessInstanceById(String processInstanceId)
RuntimeServiceActivates the process instance with the given id.
If you have a process instance hierarchy, activating one process instance from the hierarchy will not activate other process instances from that hierarchy.
activateProcessInstanceById in interface RuntimeServicepublic ProcessInstance startProcessInstanceByMessage(String messageName)
RuntimeServiceSignals the process engine that a message is received and starts a new
ProcessInstance.
Calling this method can have two different outcomes:
ProcessEngineException
is thrownstartProcessInstanceByMessage in interface RuntimeServicemessageName - the 'name' of the message as specified as an attribute on the
bpmn20 <message name="messageName" /> element.ProcessInstance object representing the started process instancepublic ProcessInstance startProcessInstanceByMessage(String messageName, String businessKey)
RuntimeServiceSignals the process engine that a message is received and starts a new
ProcessInstance.
RuntimeService.startProcessInstanceByMessage(String, Map). This method allows
specifying a business key.startProcessInstanceByMessage in interface RuntimeServicemessageName - the 'name' of the message as specified as an attribute on the
bpmn20 <message name="messageName" /> element.businessKey - the business key which is added to the started process instancepublic ProcessInstance startProcessInstanceByMessage(String messageName, Map<String,Object> processVariables)
RuntimeServiceSignals the process engine that a message is received and starts a new
ProcessInstance.
RuntimeService.startProcessInstanceByMessage(String). In addition, this method allows
specifying a the payload of the message as a map of process variables.startProcessInstanceByMessage in interface RuntimeServicemessageName - the 'name' of the message as specified as an attribute on the
bpmn20 <message name="messageName" /> element.processVariables - the 'payload' of the message. The variables are added as processes
variables to the started process instance.ProcessInstance object representing the started process instancepublic ProcessInstance startProcessInstanceByMessage(String messageName, String businessKey, Map<String,Object> processVariables)
RuntimeServiceSignals the process engine that a message is received and starts a new
ProcessInstance.
RuntimeService.startProcessInstanceByMessage(String, Map). In addition, this method allows
specifying a business key.startProcessInstanceByMessage in interface RuntimeServicemessageName - the 'name' of the message as specified as an attribute on the
bpmn20 <message name="messageName" /> element.businessKey - the business key which is added to the started process instanceprocessVariables - the 'payload' of the message. The variables are added as processes
variables to the started process instance.ProcessInstance object representing the started process instancepublic void signalEventReceived(String signalName)
RuntimeServicesignalEventReceived in interface RuntimeServicesignalName - the name of the signal eventpublic void signalEventReceived(String signalName, Map<String,Object> processVariables)
RuntimeServicesignalEventReceived in interface RuntimeServicesignalName - the name of the signal eventprocessVariables - a map of variables added to the execution(s)public void signalEventReceived(String signalName, String executionId)
RuntimeServicesignalEventReceived in interface RuntimeServicesignalName - the name of the signal eventexecutionId - the id of the execution to deliver the signal topublic void signalEventReceived(String signalName, String executionId, Map<String,Object> processVariables)
RuntimeServicesignalEventReceived in interface RuntimeServicesignalName - the name of the signal eventexecutionId - the id of the execution to deliver the signal toprocessVariables - a map of variables added to the execution(s)public void messageEventReceived(String messageName, String executionId)
RuntimeServicemessageEventReceived in interface RuntimeServicemessageName - the name of the message eventexecutionId - the id of the execution to deliver the message topublic void messageEventReceived(String messageName, String executionId, Map<String,Object> processVariables)
RuntimeServicemessageEventReceived in interface RuntimeServicemessageName - the name of the message eventexecutionId - the id of the execution to deliver the message toprocessVariables - a map of variables added to the executionpublic void correlateMessage(String messageName, Map<String,Object> correlationKeys, Map<String,Object> processVariables)
RuntimeServicecorrelateMessage in interface RuntimeServicemessageName - the name of the message eventcorrelationKeys - a map of key value pairs that are used to correlate the message to an executionprocessVariables - a map of variables added to the execution or newly created process instancepublic void correlateMessage(String messageName, String businessKey, Map<String,Object> correlationKeys, Map<String,Object> processVariables)
RuntimeServicecorrelateMessage in interface RuntimeServicemessageName - the name of the message eventbusinessKey - the business key of process instances to correlate againstcorrelationKeys - a map of key value pairs that are used to correlate the message to an executionprocessVariables - a map of variables added to the execution or newly created process instancepublic void correlateMessage(String messageName)
RuntimeServicecorrelateMessage in interface RuntimeServicemessageName - the name of the message eventpublic void correlateMessage(String messageName, String businessKey)
RuntimeServicecorrelateMessage in interface RuntimeServicemessageName - the name of the message eventbusinessKey - the business key of process instances to correlate againstpublic void correlateMessage(String messageName, Map<String,Object> correlationKeys)
RuntimeServicecorrelateMessage in interface RuntimeServicemessageName - the name of the message eventcorrelationKeys - a map of key value pairs that are used to correlate the message to an executionpublic void correlateMessage(String messageName, String businessKey, Map<String,Object> processVariables)
RuntimeServicecorrelateMessage in interface RuntimeServicemessageName - the name of the message eventbusinessKey - the business key of process instances to correlate againstCopyright © 2015. All rights reserved.