L'exposition des grains de configuration dans les expressions et les scripts
Configuration publique de haricots dans les expressions et les scripts
Par défaut, tous les haricots que vous spécifiez dans la configuration activiti.cfg.xml ou dans votre propre fichier de configuration Spring sont disponibles aux expressions et dans les scripts. Si vous voulez limiter la visibilité des haricots dans votre fichier de configuration, vous pouvez configurer une propriété appelée haricots dans la configuration de votre moteur de processus. La propriété des haricots dans ProcessEngineConfiguration est une carte. Lorsque vous spécifiez cette propriété, seuls les haricots spécifiés dans cette carte seront visibles à des expressions et des scripts. Les haricots exposés seront exposés avec les noms que vous indiquez dans cette carte.
Par défaut, la configuration ou votre propre fichier de configuration Spring spécifié dans la fève activiti.cfg.xml toutes les expressions et les scripts sont disponibles. Si vous voulez limiter la visibilité du fichier de configuration de haricot, vous pouvez configurer une propriété appelée haricots dans la configuration du moteur de processus. ProcessEngineConfiguration propriété haricots est une carte. Lorsque vous spécifiez cette propriété, l'expression de haricots et de poissons spécifié dans le script est visible sur la carte. Le haricot vous ouvrira spécifier le nom de la cartographie en public.
la configuration du cache de déploiement (configuration du cache de déploiement)
Toutes définition de processus sont mis en mémoire cache (après leur parsés) pour éviter de frapper la base de données à chaque fois une définition de processus est nécessaire et parce que les données de définition de processus ne change pas. Par défaut, il n'y a pas de limite à ce cache. Pour limiter le cache de définition de processus, ajouter la propriété suivante
Toutes définition de processus aura rencontré la base de données de cache (après l'analyse syntaxique), afin d'éviter la nécessité pour chaque définition de processus, la définition de processus, car les données ne change pas. Par défaut, cette cache est illimitée. Pour limiter la définition de processus de mise en cache, ajoutez le propertyexpose de haricot de configuration suivante dans les expressions et les scripts
<property name="processDefinitionCacheLimit" value="10" />
La définition de cette propriété échangera le cache de hashmap par défaut avec un cache LRU qui a la limite dure prévue. Bien sûr, la meilleure valeur de cette propriété dépend du montant total des définitions de processus stockées et le nombre de définitions de processus effectivement utilisés lors de l'exécution par toutes les instances de processus d'exécution.
Vous pouvez également injecter votre propre implémentation de cache. Cela doit être un haricot qui implémente l'interface org.activiti.engine.impl.persistence.deploy.DeploymentCache:
<property name="processDefinitionCache">
Il existe une propriété similaire appelé knowledgeBaseCacheLimit et knowledgeBaseCache pour la configuration du cache des règles. Ceci est nécessaire uniquement lorsque vous utilisez la tâche de règles dans vos processus.
Hashmap le mode de cache par défaut, la taille du cache dépend de la configuration et le nombre de processus et le nombre du nombre total de processus matériels effectivement utilisés sur mesure.
Nous pouvons également injecter leur propre implémentation de cache, il faut implémenter l'interface org.activiti.engine.impl.persistence.deploy.DeploymentCache
une propriété similaire appelée knowledgeBaseCacheLimit et knowledgeBaseCache, utilisé pour configurer la règle de cache. Seulement lorsque vous utilisez une tâche de règle dans le processus de le faire.
Enregistrement
Tous les journaux sont acheminés à travers SLF4J, et vous permet de sélectionner le journal que nous avons choisi de réaliser.
Par défaut, il n'y a pas de liaison pot SFL4J dans les dépendances Activiti-moteur afin d'utiliser le cadre de journal que vous choisissez, vous devez l' ajouter à votre projet. Si vous n'ajoutez pas de pot de mise en œuvre, SLF4J utilisera un NOP-enregistreur, n'a pas enregistré de journal, juste un avertissement enregistré aucun journal.
activiti-ui et webapps activiti-repos est configuré pour utiliser Log4j de liaison. Lorsque tous les tests activiti- modules * exécution, utilisez également Log4j.
Les gestionnaires d'événements (gestionnaire d'événement)
Le mécanisme d'événement dans le moteur Activiti vous permet d'être averti lorsque plusieurs événements se produisent dans le moteur. Jetez un oeil à tous les types d'événements pris en charge pour un aperçu des événements disponibles.
mécanisme d'événement moteur tiviti vous permet d'être averti lorsque divers événements se produisent dans le moteur. Voir tous les types d'événements pris en charge, afin d'obtenir un aperçu des événements disponibles.
Tous les événements sont envoyés un sous-type de org.activiti.engine.delegate.event.ActivitiEvent. Les événements (expose de si disponible) le type, ExecutionID, processInstanceId et processDefinitionId
Tous les événements sont réalisés sous-types de org.activiti.engine.delegate.event.ActivitiEvent. Cet événement est ouvert (le cas échéant) Type ExecutionID, processInstanceId et processDefinitionId
Un écouteur d'événement exemple
public class MyEventListener implements ActivitiEventListener {
@Override
public void onEvent(ActivitiEvent event) {
switch (event.getType()) {
case JOB_EXECUTION_SUCCESS:
System.out.println("A job well done!");
break;
case JOB_EXECUTION_FAILURE:
System.out.println("A job has failed...");
break;
default:
System.out.println("Event received: " + event.getType());
}
}
@Override
public boolean isFailOnException() {
// The logic in the onEvent method of this listener is not critical, exceptions
// can be ignored if logging fails...
return false;
}
}
Il y a quelques implémentations de base fournies par Activiti pour faciliter les cas d'utilisation commune des événements-auditeurs. Ceux - ci peuvent être utilisés comme classe de base ou à titre d'exemple la mise en œuvre de l' auditeur:
org.activiti.engine.delegate.event.BaseEntityEventListener: Une classe de base-écouteur d'événement qui peut être utilisé pour écouter les événements liés aux entités pour un type spécifique de entité ou pour toutes les entités. Il se cache le type de vérification et propose 4 méthodes qui devrait être surchargée: onCreate (...), onUpdate (...) et onDelete (...) lorsqu'une entité est créée, mise à jour ou supprimé. Pour tous les autres événements liés à l' entité, l'onEntityEvent (...) est appelée.
Activiti fournit certains cas d'utilisation commune de base pour réaliser la promotion de l'écouteur d'événement. Ces exemples peuvent être utilisés comme base ou les auditeurs réalisent:
org.activiti.engine.delegate.event.BaseEntityEventListenerr: un écouteur d'événement de classe de base peut écouter un type particulier d'entité ou des entités toutes les entités événements liés. Il cache la vérification de type, et propose quatre méthodes devraient être couvertes: onCreate (...), onUpdate ( ...) et onDelete (...) lorsqu'une entité est créée, mise à jour ou supprimé. Pour tous les autres événements liés à l'entité seront appelés onEntityEvent (...).
Configurer écouteur d'événement comme suit:
<bean id="processEngineConfiguration" class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
...
<property name="eventListeners">
<list>
<bean class="org.activiti.engine.example.MyEventListener" />
</list>
</property>
</bean>
Vous pouvez également être configuré pour exécuter un type d'écouteurs d'événements:
<bean id="processEngineConfiguration" class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
...
<property name="typedEventListeners">
<map>
<entry key="JOB_EXECUTION_SUCCESS,JOB_EXECUTION_FAILURE" >
<list>
<bean class="org.activiti.engine.example.MyJobEventListener" />
</list>
</entry>
</map>
</property>
</bean>
Le code peut être ajouté par le moniteur en cours d'exécution, les interfaces API comme suit:
/**
* Adds an event-listener which will be notified of ALL events by the dispatcher.
* @param listenerToAdd the listener to add
*/
void addEventListener(ActivitiEventListener listenerToAdd);
/**
* Adds an event-listener which will only be notified when an event occurs, which type is in the given types.
* @param listenerToAdd the listener to add
* @param types types of events the listener should be notified for
*/
void addEventListener(ActivitiEventListener listenerToAdd, ActivitiEventType... types);
/**
* Removes the given listener from this dispatcher. The listener will no longer be notified,
* regardless of the type(s) it was registered for in the first place.
* @param listenerToRemove listener to remove
*/
void removeEventListener(ActivitiEventListener listenerToRemove);
Vous pouvez être ajouté à l'écran de définition de processus, la configuration XML est suit comme:
<process id="testEventListeners">
<extensionElements>
<activiti:eventListener class="org.activiti.engine.test.MyEventListener" entityType="task" />
<activiti:eventListener delegateExpression="${testEventListener}" events="ENTITY_CREATED" entityType="task" />
</extensionElements>
...
</process>
Les valeurs de EntityType peuvent être: pièce jointe, commentaire, exécution, identité lien, travail, instance de processus, processus définition, tâche.
Une autre façon de traiter les événements planifiés sont jetés événement BPMN 1 . Rappelez - vous, utilisez uniquement un type spécifique de types d'événements lancés Activiti BPMN événements sens. Par exemple, lors de la suppression d' une instance de processus BPMN lance l' événement se traduira par une erreur. Le fragment de code suivant montre comment lancer dans une instance de traitement de signal, plaids un signal au flux externe (global), lance un message d' événement instance de processus, un événement d'erreur est renvoyée dans l'instance de processus. Propriétés throwEvent utilisation avec un ensemble immobilier supplémentaire, plutôt que d' utiliser la classe ou delegateExpression, spécifique au type d'événement à être jeté.
<process id="testEventListeners">
<extensionElements>
<activiti:eventListener throwEvent="signal" signalName="My signal" events="TASK_ASSIGNED" />
</extensionElements>
</process>
<process id="testEventListeners">
<extensionElements>
<activiti:eventListener throwEvent="globalSignal" signalName="My signal" events="TASK_ASSIGNED" />
</extensionElements>
</process>
<process id="testEventListeners">
<extensionElements>
<activiti:eventListener throwEvent="message" messageName="My message" events="TASK_ASSIGNED" />
</extensionElements>
</process>
<process id="testEventListeners">
<extensionElements>
<activiti:eventListener throwEvent="error" errorCode="123" events="TASK_ASSIGNED" />
</extensionElements>
</process>
Notes sur les auditeurs sur un processus définition (défini à l'auditeur décrit de processus)
1, l'événement-auditeurs ne peuvent être déclarés sur l'élément de processus, comme un enfant-élément des extensionElements. Les auditeurs ne peuvent pas être définies sur les activités individuelles dans le processus.
2, Les expressions utilisées dans le delegateExpression n'ont pas accès à l'exécution contexte, que d'autres expressions (par exemple dans les passerelles) ont. Ils ne peuvent faire référence à des haricots définis dans la propriété de haricots de la configuration du moteur de processus ou pour l'utilisation de ressorts (et la propriété de haricots est absent) à un haricot de ressort qui implémente l'interface auditeur.
3, Lorsque vous utilisez l'attribut de classe d'un auditeur, il n'y aura qu'une seule instance de cette classe créée. Assurez-vous que les implémentations d'écoute ne reposent pas sur des champs ou membres d'assurer l'utilisation en toute sécurité à partir de plusieurs threads / contextes.
4, Lorsqu'un type d'événement illégal est utilisé dans l'attribut d'événements ou de la valeur de throwEvent illégale est utilisée, une exception sera lancé lors du déploiement du processus définition (efficace à défaut du déploiement). Lorsqu'une valeur illégale pour la classe ou delegateExecution est fourni (soit une classe inexistante, une référence de haricot inexistant ou un délégué n'implémentant l'interface d'écoute), une exception sera levée lorsque le processus est démarré (ou lorsque le premier événement valide pour cette Process- définition est envoyé à l'auditeur). Assurez-vous que les classes référencées sont sur le chemin de classe et que les expressions détermination à une instance valide.
1, l'écouteur d'événement seulement comme une déclaration d'élément enfant extensionElement sur les éléments du processus. Vous ne pouvez pas être défini dans un seul événement processus d'écoute.
2, et d'autres expressions (par exemple, dans une passerelle) est différente expressions utilisés dans le contexte d'exécution delegateExpression pas accès. Ils ne peuvent être définies dans les propriétés d'écoulement des grains dans la configuration du moteur de haricot, ou dans l'utilisation d'un ressort de fèves de ressort (haricots et l'attribut est absent), une référence aux modes de réalisation de l'écouteur.
3, lorsque l'attribut de classe d'écoute, crée une instance de la classe uniquement. Assurez-vous que la mise en œuvre ne dépend pas de l'auditeur ou veiller à ce que les membres du champ de plusieurs threads / sécurité de contexte à l'utilisation.
4, lors de l'utilisation des événements de type d'événement illégal dans la propriété ou utiliser la valeur throwEvent illégale, jetteront une exception (échec fait Deploy) dans le processus de déploiement définition. Lorsqu'une classe ou delegateExecution de valeur illégale fournissent (une catégorie qui n'existe pas, il n'y a pas de commission de référence ou haricot n'implémenter l'interface d'écoute) lancera une exception lorsque ce processus commence (ou lorsque le premier processus d'événement valide définition attribué à l'auditeur). Assurez-vous que la classe référencée sur le chemin de classe, et décide d'expression à une instance valide.
Ceci est une caractéristique expérimentale ↩︎
