Camunda: gli Event Listener

Camunda supporta due diverse tipologie di Event Listener: Task Event Listener e Execution Event Listener. I Task Event Listener permettono di intercettare eventi legati ad un task (creazione, assegnazione, completamento), mentre gli Execution Listener permettono di intercettare eventi relativi all’esecuzione del flusso (avvio di un activity, completamento di un’activity e transizione tra due activity).

Un Event Listener può avere scope locale o globale. Un Event listener di tipo globale è legato alla process application, e quindi sarà attivo su tutte le process definition configurate nel pacchetto di installazione. Un Event listener di tipo locale è legato invece ad un singolo componente della process definition ed è configurabile direttamente da Camunda Modeler.

Dopo aver selezionato un componente del processo, mediante il pannello delle proprietà, è possibile selezionare il tab "Listeners", cliccare su "+" e configurare il proprio listener, selezionando la tipologia e definendo il riferimento all'implementazione (classe Java o bean Spring).

Execution Listener

Mediante un Execution Listener è possibile intercettare i seguenti eventi:

• Inizio e fine di una process instance.
• Transizione da un’activity ad un’altra.
• Inizio e fine di un’activity.
• Inizio e fine di un componente “gateway”.
• Inizio e fine di un “intermediate events”.

Per implementare il proprio Execution Listener è necessario creare una classe Java che implementa la classe org.camunda.bpm.engine.delegate.ExecutionListener di Camunda. Quando l’evento si verifica viene invocato il metodo notify che riceve in ingresso tutte le informazioni sull’execution corrispondente.

Per raffinare il nostro caso di studio, inseriamo i seguenti Execution Listener:

1. Sul nodo di start aggiungiamo un Listener di tipo “start” e linkiamolo alla classe com.lslab.tutorial.camunda.listener.StartListener.
2. Sul nodo di fine aggiungiamo un Listener di tipo “end” per inviare una notifica a tutti i lettori del sito. Creiamo a tale scopo la classe com.lslab.tutorial.camunda.listener.EndListener.

public class StartListener implements ExecutionListener {
	private final Logger LOGGER = LoggerFactory.getLogger(StartListener.class);
	public void notify(DelegateExecution execution) throws Exception {
		LOGGER.info("event name: " + execution.getEventName());
	}
}
public class EndListener implements ExecutionListener {
	private final Logger LOGGER = LoggerFactory.getLogger(EndListener.class);
	public void notify(DelegateExecution execution) throws Exception {
		LOGGER.info("event name: " + execution.getEventName());
	}
}

Task Listener

Mediante un Task Listener è possibile intercettare gli eventi relativi a creazione, assegnazione, completamento ed eliminazione di un task.

Per implementare un Task Listener è necessario creare una classe Java che implementa la classe org.camunda.bpm.engine.delegate.TaskListener di Camunda. Quando l’evento si verifica viene invocato il metodo notify che riceve le informazioni sulla corrispondente execution.

Stando a quanto detto aggiungiamo un Listener di tipo “assignment” sul nodo “Creazione Articolo”. Creiamo a tale scopo la classe com.lslab.tutorial.camunda.listener.AssignmentListener nella quale aggiungiamo un semplice log.

public class AssignmentListener implements TaskListener {
	private final Logger LOGGER = LoggerFactory.getLogger(AssignmentListener.class);
	public void notify(DelegateTask delegateTask) {
		LOGGER.info("task assigned at: " + delegateTask.getAssignee());
	}
}

Event Listener Globale

Un listener di tipo globale può essere definito nella Process Application nel seguente modo:

@ProcessApplication("Pubblicazione Articolo")
public class MyProcessApplication extends ServletProcessApplication {
	private final Logger LOGGER = LoggerFactory.getLogger(MyProcessApplication.class);
	public TaskListener getTaskListener() {
		return new TaskListener() {
			public void notify(DelegateTask delegateTask) {
				LOGGER.info("I'm a global task listener");
			}
		};
	}
	public ExecutionListener getExecutionListener() {
		return new ExecutionListener() {
			public void notify(DelegateExecution execution) throws Exception {
				LOGGER.info("I'm a global execution listener");
			}
		};
	}
}