org.activiti.engine.delegate.event.ActivitiEventListener Java Examples

@Override
public void onEvent(ActivitiEvent event) {
  if (isValidEvent(event)) {
    Object delegate = DelegateExpressionUtil.resolveDelegateExpression(expression, new NoExecutionVariableScope());
    if (delegate instanceof ActivitiEventListener) {
      // Cache result of isFailOnException() from delegate-instance
      // until next event is received. This prevents us from having to resolve
      // the expression twice when an error occurs.
      failOnException = ((ActivitiEventListener) delegate).isFailOnException();

      // Call the delegate
      ((ActivitiEventListener) delegate).onEvent(event);
    } else {

      // Force failing, since the exception we're about to throw
      // cannot be ignored, because it did not originate from the listener itself
      failOnException = true;
      throw new ActivitiIllegalArgumentException("Delegate expression " + expression + " did not resolve to an implementation of " + ActivitiEventListener.class.getName());
    }
  }
}
 

@Override
public ActivitiEventListener createEventThrowingEventListener(EventListener eventListener) {
  BaseDelegateEventListener result = null;
  if (ImplementationType.IMPLEMENTATION_TYPE_THROW_SIGNAL_EVENT.equals(eventListener.getImplementationType())) {
    result = new SignalThrowingEventListener();
    ((SignalThrowingEventListener) result).setSignalName(eventListener.getImplementation());
    ((SignalThrowingEventListener) result).setProcessInstanceScope(true);
  } else if (ImplementationType.IMPLEMENTATION_TYPE_THROW_GLOBAL_SIGNAL_EVENT.equals(eventListener.getImplementationType())) {
    result = new SignalThrowingEventListener();
    ((SignalThrowingEventListener) result).setSignalName(eventListener.getImplementation());
    ((SignalThrowingEventListener) result).setProcessInstanceScope(false);
  } else if (ImplementationType.IMPLEMENTATION_TYPE_THROW_MESSAGE_EVENT.equals(eventListener.getImplementationType())) {
    result = new MessageThrowingEventListener();
    ((MessageThrowingEventListener) result).setMessageName(eventListener.getImplementation());
  } else if (ImplementationType.IMPLEMENTATION_TYPE_THROW_ERROR_EVENT.equals(eventListener.getImplementationType())) {
    result = new ErrorThrowingEventListener();
    ((ErrorThrowingEventListener) result).setErrorCode(eventListener.getImplementation());
  }

  if (result == null) {
    throw new ActivitiIllegalArgumentException("Cannot create an event-throwing event-listener, unknown implementation type: " + eventListener.getImplementationType());
  }

  result.setEntityClass(getEntityType(eventListener.getEntityType()));
  return result;
}
 

@Override
public void onEvent(ActivitiEvent event) {
	if(isValidEvent(event)) {
	  Object delegate = DelegateExpressionUtil.resolveDelegateExpression(expression, new NoExecutionVariableScope());
		if (delegate instanceof ActivitiEventListener) {
			// Cache result of isFailOnException() from delegate-instance until next
			// event is received. This prevents us from having to resolve the expression twice when
			// an error occurs.
			failOnException = ((ActivitiEventListener) delegate).isFailOnException();
			
			// Call the delegate
			((ActivitiEventListener) delegate).onEvent(event);
		} else {
			
			// Force failing, since the exception we're about to throw cannot be ignored, because it
			// did not originate from the listener itself
			failOnException = true;
			throw new ActivitiIllegalArgumentException("Delegate expression " + expression
					+ " did not resolve to an implementation of " + ActivitiEventListener.class.getName());
		}
	}
}
 

@Bean
public SpringProcessEngineConfiguration springProcessEngineConfiguration(DataSource dataSource, PlatformTransactionManager transactionManager,
                                                                         SpringAsyncExecutor springAsyncExecutor
) throws IOException {
    SpringProcessEngineConfiguration engineConfiguration = baseSpringProcessEngineConfiguration(
            dataSource,
            transactionManager,
            springAsyncExecutor);
    Map<String, List<ActivitiEventListener>> typedListeners = new HashMap<>();
    typedListeners.put("TASK_CREATED", Collections.singletonList(taskCreatedListener()));
    typedListeners.put("TASK_COMPLETED", Collections.singletonList(taskCompletedListener()));
    engineConfiguration.setTypedEventListeners(typedListeners);
    return engineConfiguration;
}
 

protected synchronized void addTypedEventListener(ActivitiEventListener listener, ActivitiEventType type) {
  List<ActivitiEventListener> listeners = typedListeners.get(type);
  if (listeners == null) {
    // Add an empty list of listeners for this type
    listeners = new CopyOnWriteArrayList<ActivitiEventListener>();
    typedListeners.put(type, listeners);
  }

  if (!listeners.contains(listener)) {
    listeners.add(listener);
  }
}
 

protected void dispatchEvent(ActivitiEvent event, ActivitiEventListener listener) {
  try {
    listener.onEvent(event);
  } catch (Throwable t) {
    if (listener.isFailOnException()) {
      throw new ActivitiException("Exception while executing event-listener", t);
    } else {
      // Ignore the exception and continue notifying remaining listeners. The listener
      // explicitly states that the exception should not bubble up
      LOG.warn("Exception while executing event-listener, which was ignored", t);
    }
  }
}
 

public void removeEventListener(ActivitiEventListener listenerToRemove) {
  eventListeners.remove(listenerToRemove);

  for (List<ActivitiEventListener> listeners : typedListeners.values()) {
    listeners.remove(listenerToRemove);
  }
}
 

public synchronized void addEventListener(ActivitiEventListener listenerToAdd, ActivitiEventType... types) {
  if (listenerToAdd == null) {
    throw new ActivitiIllegalArgumentException("Listener cannot be null.");
  }

  if (types == null || types.length == 0) {
    addEventListener(listenerToAdd);

  } else {
    for (ActivitiEventType type : types) {
      addTypedEventListener(listenerToAdd, type);
    }
  }
}
 

public synchronized void addEventListener(ActivitiEventListener listenerToAdd) {
  if (listenerToAdd == null) {
    throw new ActivitiIllegalArgumentException("Listener cannot be null.");
  }
  if (!eventListeners.contains(listenerToAdd)) {
    eventListeners.add(listenerToAdd);
  }
}
 

public static void closeProcessEngine(ProcessEngine processEngine, ActivitiEventListener listener) {
  if (listener != null) {
    final ProcessEngineConfigurationImpl processEngineConfiguration = ((ProcessEngineImpl) processEngine).getProcessEngineConfiguration();
    processEngineConfiguration.getEventDispatcher().removeEventListener(listener);
  }
  processEngine.close();
}
 

private ProcessEngineConfigurationImpl getProcessEngineConfiguration() {
  ProcessEngineConfigurationImpl configuration = new org.activiti.engine.impl.cfg.StandaloneInMemProcessEngineConfiguration();
  configuration.
    setHistory("full").
    setDatabaseSchemaUpdate("drop-create");
  configuration.setCustomDefaultBpmnParseHandlers(
      Arrays.<BpmnParseHandler>asList(
          new AddListenerUserTaskParseHandler(TaskListener.EVENTNAME_CREATE,
          new UserTaskExecutionListener(USER_TASK_COMPLETED_EVENT_TYPE, USER_TASK_COMPLETED_EVENT_TYPE, listener.getSimulationEvents()))
      ));
  configuration.setEventListeners(Arrays.<ActivitiEventListener>asList(listener));
  return configuration;
}
 

@Override
public ActivitiEventListener createEventThrowingEventListener(EventListener eventListener) {
	BaseDelegateEventListener result = null;
	if (ImplementationType.IMPLEMENTATION_TYPE_THROW_SIGNAL_EVENT.equals(eventListener.getImplementationType())) {
		result = new SignalThrowingEventListener();
		((SignalThrowingEventListener) result).setSignalName(eventListener.getImplementation());
		((SignalThrowingEventListener) result).setProcessInstanceScope(true);
	} else if (ImplementationType.IMPLEMENTATION_TYPE_THROW_GLOBAL_SIGNAL_EVENT.equals(eventListener.getImplementationType())) {
		result = new SignalThrowingEventListener();
		((SignalThrowingEventListener) result).setSignalName(eventListener.getImplementation());
		((SignalThrowingEventListener) result).setProcessInstanceScope(false);
	} else if (ImplementationType.IMPLEMENTATION_TYPE_THROW_MESSAGE_EVENT.equals(eventListener.getImplementationType())) {
		result = new MessageThrowingEventListener();
		((MessageThrowingEventListener) result).setMessageName(eventListener.getImplementation());
	} else if (ImplementationType.IMPLEMENTATION_TYPE_THROW_ERROR_EVENT.equals(eventListener.getImplementationType())) {
		result = new ErrorThrowingEventListener();
		((ErrorThrowingEventListener) result).setErrorCode(eventListener.getImplementation());
	}

	if (result == null) {
		throw new ActivitiIllegalArgumentException("Cannot create an event-throwing event-listener, unknown implementation type: "
		        + eventListener.getImplementationType());
	}

	result.setEntityClass(getEntityType(eventListener.getEntityType()));
	return result;
}
 

public ProcessEngineConfigurationImpl setEventListeners(List<ActivitiEventListener> eventListeners) {
  this.eventListeners = eventListeners;
  return this;
}
 

@Override
public void removeEventListener(ActivitiEventListener listenerToRemove) {
  eventSupport.removeEventListener(listenerToRemove);
}
 

public ProcessEngineConfigurationImpl setTypedEventListeners(Map<String, List<ActivitiEventListener>> typedListeners) {
  this.typedEventListeners = typedListeners;
  return this;
}
 

public List<ActivitiEventListener> getEventListeners() {
  return eventListeners;
}
 

public void setListeners(List<ActivitiEventListener> listeners) {
    this.listeners = listeners;
}
 

public void onEvent(ActivitiEvent event) {
    for (ActivitiEventListener listener : listeners) {
        listener.onEvent(event);
    }
}
 

@Override
public ActivitiEventListener createDelegateExpressionEventListener(EventListener eventListener) {
  return new DelegateExpressionActivitiEventListener(expressionManager.createExpression(eventListener.getImplementation()), getEntityType(eventListener.getEntityType()));
}
 

@Override
public void addEventListener(ActivitiEventListener listenerToAdd) {
  commandExecutor.execute(new AddEventListenerCommand(listenerToAdd));
}
 

@Override
public void addEventListener(ActivitiEventListener listenerToAdd, ActivitiEventType... types) {
  commandExecutor.execute(new AddEventListenerCommand(listenerToAdd, types));
}
 

@Override
public void removeEventListener(ActivitiEventListener listenerToRemove) {
  commandExecutor.execute(new RemoveEventListenerCommand(listenerToRemove));
}
 

@Override
public ActivitiEventListener createClassDelegateEventListener(EventListener eventListener) {
  return new DelegateActivitiEventListener(eventListener.getImplementation(), getEntityType(eventListener.getEntityType()));
}
 

public RemoveEventListenerCommand(ActivitiEventListener listener) {
  super();
  this.listener = listener;
}
 

public AddEventListenerCommand(ActivitiEventListener listener, ActivitiEventType[] types) {
  this.listener = listener;
  this.types = types;
}
 

public AddEventListenerCommand(ActivitiEventListener listener) {
  super();
  this.listener = listener;
}
 

public AddEventListenerCommand(ActivitiEventListener listener) {
 super();
 this.listener = listener;
}
 

@Override
public void addEventListener(ActivitiEventListener listenerToAdd) {
commandExecutor.execute(new AddEventListenerCommand(listenerToAdd));
}
 

@Override
public void addEventListener(ActivitiEventListener listenerToAdd, ActivitiEventType... types) {
commandExecutor.execute(new AddEventListenerCommand(listenerToAdd, types));
}
 

@Override
public void removeEventListener(ActivitiEventListener listenerToRemove) {
commandExecutor.execute(new RemoveEventListenerCommand(listenerToRemove));
}