Built-In Beans
- The ProcessEngine as well as the services are available for injection:
@Inject
ProcessEngine, RepositoryService, TaskService, … - A specific named ProcessEngine and its services can be injected by adding the qualifier
@ProcessEngineName('someEngine')
- The current process instance and task can be injected: @Inject ProcessInstance, Task,
- The current business key can be injected: @Inject @BusinessKey String businessKey,
- The current process instance id be injected: @Inject @ProcessInstanceId String pid.
Process variables are available for injection. camunda-engine-cdi supports
- type-safe injection of
@BusinessProcessScoped
beans using@Inject [additional qualifiers] Type fieldName
- unsafe injection of other process variables using the
@ProcessVariable(name?)
qualifier:
@Inject
@ProcessVariable
private Object accountNumber;
@Inject
@ProcessVariable("accountNumber")
private Object account;
In order to reference process variables using EL, we have similar options:
@Named @BusinessProcessScoped
beans can be referenced directly,- other process variables can be referenced using the ProcessVariables-bean:
#{processVariables['accountNumber']}
Inject a Process Engine Based on Contextual Data
While a specific process engine can be accessed by adding the qualifier @ProcessEngineName('name')
to the injection point, this requires that it is known which process engine is used at design time. A more flexible approach is to resolve the process engine at runtime based on contextual information such as the logged in user. In this case, @Inject
can be used without a @ProcessEngineName
annotation.
To implement resolution from contextual data, the producer bean org.camunda.bpm.engine.cdi.impl.ProcessEngineServicesProducer
must be extended. The following code implements a contextual resolution of the engine by the currently authenticated user. Note that which contextual data is used and how it is accessed is entirely up to you.
@Specializes
public class UserAwareEngineServicesProvider extends ProcessEngineServicesProducer {
// User can be any object containing user information from which the tenant can be determined
@Inject
private UserInfo user;
@Specializes @Produces @RequestScoped
public ProcessEngine processEngine() {
// okay, maybe this should involve some more logic ;-)
String engineForUser = user.getTenant();
ProcessEngine processEngine = BpmPlatform.getProcessEngineService().getProcessEngine(engineForUser);
if(processEngine != null) {
return processEngine;
} else {
return ProcessEngines.getProcessEngine(engineForUser, false);
}
}
@Specializes @Produces @RequestScoped
public RuntimeService runtimeService() {
return processEngine().getRuntimeService();
}
@Specializes @Produces @RequestScoped
public TaskService taskService() {
return processEngine().getTaskService();
}
...
}
The above code makes selecting the process engine based on the current user’s tenant completely transparent. For each request, the currently authenticated user is retrieved and the correct process engine is looked up. Note that the class UserInfo
represents any kind of context object that identifies the current tenant. For example, it could be a JAAS principal. The produced engine can be accessed in the following way:
@Inject
private RuntimeService runtimeService;