DeveloperLife: Extending the Task Service in Activiti Engine

As we described in our latest post, we have been trying out Activiti lately. A challenge we came across was to create our own Human Task Service of some sort, as we had used our own Identity Management. In a typical BPM system the Process Engine and Human Task Service are decoupled from one another. Moreover, a standard called WS-HumanTask Service exists for establishing a protocol between the last two. However, in Activiti's case the Human Task Service is embedded inside the engine.

So we took a different approach as we wanted to use our own human task server. We thought that if we will be notified about changes occurring inside Activiti's engine concerning user tasks (e.g. create task event), we could propagate those notifications to our Human Task Service. Unfortunately, we found out that Activiti's engine does not have a notification mechanism as we hoped (at least in 5.8 - there are talking about an event bus in future releases), so we had to use another mechanism to achieve this task.

Apparently Activiti does have a notification mechanism while parsing a BPMN process definition XML. It allows one to plug in a listener which will be notified in several events. One of those events is when a user task is being parsed. This was exactly what we needed. We plugged our own listener implementation and every time a user task was parsed we added a TaskListenr to the user task in the process definition. This listener was invoked by the engine when this task was created. Obviously the listener impl is to simply send a notification as "Task Created" to our own Human Task Service. Note: you will also have to manage the task life-cycle and update Activiti's engine using its services.

Now for the technical details. As in our latest post, this requires:

adding a Java class implementing BpmnParseListener. This is the interface you want to implement to plug in your own listener.
injecting the Java class using the Spring xml config file.

BpmnParseListener Class
We implement a TaskListener for each of the events we are interested in:

CompleteTaskListenerImpl
AssigneTaskListenerImpl
CreateTaskListenerImpl

We Override the parseUserTask method so that in each time a parse event occurs our TaskListeners will add some logic on our WS-HumanTask Service/Task Service. The rest of the parse events will be ignored.

package my.great.company.com.businessprocessengine.listeners;
import java.util.ArrayList;
  
  
public class MyBpmnParseListener implements BpmnParseListener
{   
    
    private final class CompleteTaskListenerImpl implements TaskListener {
        @Override
        public void notify(DelegateTask delegateTask) {  
                //TODO: this is where your logic should be added
                logger.info("TASK COMPLETE from Activiti " + delegateTask.toString());
        }
    }
  
    private final class AssigneTaskListenerImpl implements TaskListener {
        @Override
        public void notify(DelegateTask delegateTask) {
                //TODO: this is where your logic should be added 
                logger.info("TASK ASSIGN from Activiti " + delegateTask.toString());
        }
    }
  
    private final class CreateTaskListenerImpl implements TaskListener {
        @Override
        public void notify(DelegateTask delegateTask) {
                //TODO: this is where your logic should be added 
               logger.info("TASK CREATE from Activiti " + taskEntity.toString());
        }
    }
    
    private TaskListener            createTaskListener         = new CreateTaskListenerImpl();
    private TaskListener            assigneTaskListener        = new AssigneTaskListenerImpl();
    private TaskListener            completeTaskListener       = new CompleteTaskListenerImpl(); 
    private static final Logger     logger                     = Logger.getLogger(MyBpmnParseListener.class);
    
  
    public MyBpmnParseListener(){}
    
    @Override
    public void parseUserTask(Element userTaskElement, ScopeImpl scope, ActivityImpl activity)
    {
        ActivityBehavior activitybehaviour = activity.getActivityBehavior();
        if (activitybehaviour instanceof UserTaskActivityBehavior)
        {
            UserTaskActivityBehavior userTaskActivity = (UserTaskActivityBehavior) activitybehaviour;
            if (createTaskListener != null)
            {
                userTaskActivity.getTaskDefinition().addTaskListener(TaskListener.EVENTNAME_CREATE, createTaskListener);
            }
            if (assigneTaskListener != null)
            {
                userTaskActivity.getTaskDefinition().addTaskListener(TaskListener.EVENTNAME_ASSIGNMENT,assigneTaskListener);
            }
            if (completeTaskListener != null)
            {
                userTaskActivity.sgetTaskDefinition().addTaskListener(TaskListener.EVENTNAME_COMPLETE,completeTaskListener);
            }
        }
    }
    
    @Override
    public void parseRootElement(Element arg0, List<ProcessDefinitionEntity> arg1)
    {
        // Nothing to do here
    }
  
    @Override
    public void parseProcess(Element processElement, ProcessDefinitionEntity processDefinition)
    {
        // Nothing to do here
    }
  
    @Override
    public void parseStartEvent(Element startEventElement, ScopeImpl scope, ActivityImpl startEventActivity)
    {
        // Nothing to do here
    }
  
    @Override
    public void parseExclusiveGateway(Element exclusiveGwElement, ScopeImpl scope, ActivityImpl activity)
    {
        // Nothing to do here
    }
  
    @Override
    public void parseParallelGateway(Element parallelGwElement, ScopeImpl scope, ActivityImpl activity)
    {
        // Nothing to do here
    }
  
    @Override
    public void parseScriptTask(Element scriptTaskElement, ScopeImpl scope, ActivityImpl activity)
    {
        // Nothing to do here
    }
  
    @Override
    public void parseServiceTask(Element serviceTaskElement, ScopeImpl scope, ActivityImpl activity)
    {
        // Nothing to do here
    }
  
    @Override
    public void parseTask(Element taskElement, ScopeImpl scope, ActivityImpl activity)
    {
        // Nothing to do here
    }
  
    @Override
    public void parseManualTask(Element manualTaskElement, ScopeImpl scope, ActivityImpl activity)
    {
        // Nothing to do here
    }
  
    @Override
    public void parseEndEvent(Element endEventElement, ScopeImpl scope, ActivityImpl activity)
    {
        // Nothing to do here
    }
  
    @Override
    public void parseBoundaryTimerEventDefinition(Element timerEventDefinition, boolean interrupting,
            ActivityImpl timerActivity)
    {
        // Nothing to do here
    }
  
    @Override
    public void parseSubProcess(Element subProcessElement, ScopeImpl scope, ActivityImpl activity)
    {
        // Nothing to do here
    }
  
    @Override
    public void parseCallActivity(Element callActivityElement, ScopeImpl scope, ActivityImpl activity)
    {
        // Nothing to do here
    }
  
    @Override
    public void parseProperty(Element propertyElement, VariableDeclaration variableDeclaration, ActivityImpl activity)
    {
        // Nothing to do here
    }
  
    @Override
    public void parseSequenceFlow(Element sequenceFlowElement, ScopeImpl scopeElement, TransitionImpl transition)
    {
        // Nothing to do here
    }
  
    @Override
    public void parseSendTask(Element sendTaskElement, ScopeImpl scope, ActivityImpl activity)
    {
        // Nothing to do here
    }
  
    @Override
    public void parseBusinessRuleTask(Element businessRuleTaskElement, ScopeImpl scope, ActivityImpl activity)
    {
        // Nothing to do here
    }
  
    @Override
    public void parseBoundaryErrorEventDefinition(Element errorEventDefinition, boolean interrupting,
            ActivityImpl activity, ActivityImpl nestedErrorEventActivity)
    {
        // Nothing to do here
    }
  
    @Override
    public void parseIntermediateTimerEventDefinition(Element timerEventDefinition, ActivityImpl timerActivity)
    {
        // Nothing to do here
    }
    
    @Override
    public void parseMultiInstanceLoopCharacteristics(Element activityElement, 
            Element multiInstanceLoopCharacteristicsElement, ActivityImpl activity)
    {
        // Nothing to do here
    }
  
    @Override
    public void parseInclusiveGateway(Element arg0, ScopeImpl arg1, ActivityImpl arg2) {
        // Nothing to do here
        
    }
}

Spring configuration

The Spring file change will be done in our context XML file:

... 
<bean id="processEngineConfiguration" class="org.activiti.spring.SpringProcessEngineConfiguration"> 
        ...
        <property name="preParseListeners">
            <list>
                <bean class="my.great.company.com.businessprocessengine.listeners.MyBpmnParseListener"></bean>
            </list>
        </property>
 ...
 </bean>...
 

That's it. You are good to go and handle tasks on your own. Good luck.

DeveloperLife

Wednesday, February 22, 2012

Extending the Task Service in Activiti Engine

1 comment:

Followers