Egov Innovation Center - Veille Technologique : Outils du BPMN 2.0 HEIA-FR 18.05.2016 - eGov Innovation ...
←
→
Transcription du contenu de la page
Si votre navigateur ne rend pas la page correctement, lisez s'il vous plaît le contenu de la page ci-dessous
Egov Innovation Center Veille Technologique : Outils du BPMN 2.0 HEIA-FR 18.05.2016 Ce document présente l’étude qui a été mise en place afin d’évaluer les outils Bonita et jBPM de JBoss. Ces deux plateformes permettent de créer, manipuler et exécuter des Bps au format BPMN 2.0. Les deux outils sont tout d’abord présenté, puis comparé l’un à l’autre. La conclusion de ce document présente l’option retenue ainsi que les choix décidés quant à la réalisation d’un prototype.
Veille Technologique Outils BPMN 2.0
Table des matières
1 Introduction ................................................................................................................ 3
2 Outils et Base de Données Sémantique ....................................................................... 4
2.1 Protégé - Modélisation d’ontologie.........................................................................................4
2.2 Base de données web sémantique ..........................................................................................4
3 Concept BPM ............................................................................................................... 5
3.1 Composants de base d’un BPM ...............................................................................................5
3.2 Acteurs et Messages sur un BPM ............................................................................................6
4 Evaluation de logiciel BPM .......................................................................................... 7
4.1 Présentation de Bonita ............................................................................................................7
4.2 Présentation de jBPM (solution de JBoss) ...............................................................................9
4.3 Comparaison des logiciels .....................................................................................................12
4.4 Choix du logiciel.....................................................................................................................14
5 Conception ................................................................................................................ 14
5.1 Solution A : Modification du moteur jBPM ...........................................................................15
5.2 Solution B : Adaptation du code source de l’application ......................................................15
5.3 Solution C : Gestion des données sur l’application finale .....................................................15
6 Solution Retenue et Conclusion ................................................................................. 16
7 ANNEXE : Problèmes rencontrés avec jBPM ............................................................... 17
7.1 Problèmes d’affichage ...........................................................................................................17
7.2 Problèmes occasionnels lors du déploiement de l’application web .....................................17
7.3 Contradictions entre les validateurs......................................................................................17
7.4 Limitations dans le moteur de workflow ...............................................................................17
7.5 Communauté peu présente ..................................................................................................18
7.6 Le Framework jBPM 6 est une nouvelle release ...................................................................18
7.7 Gestion des messages ...........................................................................................................18
7.8 Génération de formulaires ....................................................................................................18
7.9 Disparition des composants d’un diagramme .......................................................................19
7.10 Traitement des erreurs ..........................................................................................................19
Page 2 on 19
Veille Technologique Outils BPMN 2.0
Veille Technologique
Outils du BPMN 2.0
1 Introduction
Le web sémantique est un mouvement initié par le groupe international World Wide Web Consortium
(W3C) dans le but d’intégrer un contenu sémantique aux pages web. En effet, sur le web actuel, les
données contenues dans une page HTML sont uniquement lisibles par l’utilisateur. C’est donc à
l’utilisateur de faire lui-même le lien entre différentes pages, par la valeur de leur contenu.
Le web sémantique permet d’ajouter des données dans les pages qui rendent compréhensible le
contenu de celles-ci à l’ordinateur. Cela permettrait par exemple de réaliser directement des
traitements sur les données, et non pas sur le texte, ou de faciliter grandement les recherches sur
n’importe quel moteur. Actuellement, lors de requêtes effectuées sur la plupart des moteurs, les liens
proposés manquent souvent de pertinence par rapport à la recherche. Le web sémantique pourrait
avoir un intérêt non négligeable dans ce type de contexte.
De plus en plus de projets utilisant cette technologie se développent. Le site DBPedia1 par exemple,
vise à une sémantisation du contenu du site Wikipédia; ce projet, initié à l’université libre de Berlin, ne
prend en compte que les pages au contenu anglophone. Un projet similaire qui se concentre davantage
sur les pages francophones a été créée en France sous le nom de SemanticPedia2.
L’outil principale du Web Sémantique est l’ontologie. Une ontologie offre une « spécification explicite
de la conceptualisation d’un domaine ». Cela permet, dans un contexte donné, d’organiser des
concepts sous forme de graphe, et ainsi de proposer une modélisation d’un ensemble de
connaissances.
Le site web Schema.org3 propose des modèles d’ontologie, représentant une grande variété d’entités.
Par exemple, une ontologie représentant une personne est proposée ; elle décrit un schéma possible
qui permet de représenter et de lier les informations d’un individu, et propose un exemple
d’implémentation de ce schéma sous un langage lié au web sémantique : le RDFa.
1
http://www.dbpedia.org
2
http://www.semanticpedia.org
3
http://www.schema.org
Page 3 on 19
Veille Technologique Outils BPMN 2.0
2 Outils et Base de Données Sémantique
Ce chapitre présente une liste non-exhaustive d’outils et de bases de données sémantiques pouvant
être utilisées dans le cadre d’un projet sémantique.
2.1 Modélisation d’ontologie - Protégé
Créé par l’Université de Stanford, Protégé4 est un logiciel qui offre à son utilisateur une interface
graphique lui permettant d’établir des ontologies, sans se soucier des détails du langage RDFS/XML
nécessaires pour modéliser l’ontologie. La création automatique des ontologies à partir d’une
description purement graphique est possible mais nécessite des outils supplémentaires qui ne donnent
pas des résultats satisfaisants à l’heure actuelle.
2.2 Base de données sémantiques
RDF (Resource Description Framework5) est une norme fondamentale pour décrire les ressources dans
le web sémantique. Les données peuvent ainsi être stockées dans une base de données de type
triplestore sous forme de triplets. De la même manière qu’une base de données de type relationnel,
on y stocke les ressources et on les récupère avec des requêtes. Le langage de requête SPARQL6 entre
alors en jeu.
2.2.1 OpenRDF (Sesame)
OpenRDF7 est un Framework open-source pour le traitement des données RDF. Il propose une API
simple d’utilisation qui permet d’interagir avec un système de stockage RDF. Il supporte plusieurs
langages liés au RDF, le SPARQL pour les requêtes et pour le format des données : le RDF/XML, RDFS,
le TriG et le TriX entre autre.
En plus de cela, il dispose également d’une intégration web fonctionnant sous Tomcat gérant la
concurrence d’accès aux données.
2.2.2 Jena
Jena8 est un Framework Java open-source. Jena propose en plus nativement un support pour l’OWL
(Ontology Web Language9) que Sesame ne possède pas. Jena offre divers outils annexes comme la
gestion des données sémantiques à l’aide d’une implémentation Java.
Contrairement à OpenRDF, Jena ne propose pas d’intégration web (ou serveur dédié) pour l’accès aux
données. Jenna est aujourd’hui maintenu par la fondation Apache10.
4
http://protege.stanford.edu
5
https://www.w3.org/RDF/
6
https://www.w3.org/TR/rdf-sparql-query/
7
http://rdf4j.org
8
https://jena.apache.org
9
https://www.w3.org/TR/owl-features/
10
http://www.apache.org
Page 4 on 19
Veille Technologique Outils BPMN 2.0
3 Concept BPM
3.1 Composants de base d’un BPM
Le BPM (Business Process Modeling) est une approche consistant à modéliser informatiquement les
processus métiers d’une organisation (entreprise, administration publique, etc.) afin d’améliorer et
automatiser leur gestion. Le BPMN (Business Process Model notation) est une norme de notation pour
la modélisation de processus métiers. La première version BPMN 1.2 était une notation graphique non
exécutable. La nouvelle version BPMN 2.0 a évolué vers une notation basée sur XML permettant
l'échange de modèles exécutables.
Ci-dessous est présentée une partie du diagramme BPMN qui représente la première page du
formulaire à l’aide d’un exemple BPM simple :
Figure 1 - Partie du diagramme représentant la première page du formulaire
Objet rond : représente le point de départ du processus, il ne fournit pas d’information
spécifique (exemple : « Start1 »)
Objet rectangle : représente une page qui peut porter un formulaire ou une interaction avec
l’utilisateur (symbole utilisateur), ou un processus (symbole roues dentées)
o « Identité » contient un formulaire
o « Vérifier Identité » qui porte un service (script GROOVY11, langage qui dérive de Java)
dont le rôle est de vérifier la cohérence des données (nommé connecteurs dans
BonitaSoft12)
Objet losange : représente des conditions logiques permettant de faire évoluer le BPM vers
une étape suivante
o « Gateway7 » ramène l’utilisateur à « Identité » dans le cas où une incohérence a été
détectée, ou l’envoie à « Valider Identité » dans le cas contraire pour afficher au
citoyen les données entrées et demander son consentement.
o Si l’utilisateur consent, il passe à la page « Info partenaire », sinon il revient à
« Identité ». Presque chaque page du formulaire fonctionne de la même manière que
cette première page.
11
http://www.groovy-lang.org
12
http://www.bonitasoft.com
Page 5 on 19
Veille Technologique Outils BPMN 2.0
3.2 Acteurs et messages sur un BPM
Ci-dessous, un exemple contenant des acteurs et des messages :
Figure 2 - Partie du diagramme représentant l’envoie des données
Le Pool sert à fixer l’acteur, soit l’utilisateur qui a le droit de lancer le processus, donc de
remplir le formulaire. Ici l’acteur est donc un citoyen quelconque, soit un utilisateur
appartenant au groupe Citoyen dans la hiérarchie des acteurs qui ont été créés.
o Sur la gauche de la figure, la présence des mots « Citoyen » et « Demande de rente »
qui caractérisent le « Pool » et le « Lane » dans lesquels se trouve le diagramme.
La Lane permet la séparation entre plusieurs diagrammes au sein d’un même BPM
Page 6 on 19
Veille Technologique Outils BPMN 2.0
4 Evaluation des logiciels BPM
L’évaluation des logiciels a consisté à réaliser une implémentation BPMN pour un formulaire de
demande AVS. La prise en main d’un outil BPM n’est pas aisée pour un utilisateur non-expert. Un
temps de formation et d’adaptation est nécessaire pour chacun des logiciels.
Deux logiciels ont été retenu : BonitaSoft ainsi que la solution jBPM de JBoss. Afin d’évaluer au plus
juste, un formulaire de demande AVS13 a été modélisé pour chaque logiciel.
Figure 3 - Logique de BonitaSoft
4.1 Présentation de Bonita
Bonita14 (version 6.0.0) est un logiciel gratuit qui offre une interface graphique pour faciliter la création
des processus BPM suivant la norme BPMN 2.0.
Figure 4 - Création de BPM avec Bonitasoft
13
Le processus de demande de rente AVS a été documenté et modélisé dans le document JBoss jBPM Proof-of-Concept –
Based on the AVS Use Case
14
http://fr.bonitasoft.com
Page 7 on 19
Veille Technologique Outils BPMN 2.0
L’interface présente une palette contenant les différents types d’éléments qui constituent un
diagramme. Une sous-fenêtre au bas de la page montre les onglets d’accès aux propriétés de chaque
élément (les variables définies, les formulaires, les connecteurs, etc.). Les détails seront expliqués
ultérieurement.
4.1.1 La validation des données
Bien que BonitaSoft offre la possibilité de créer un validator, ce dernier est limité aux types primitifs
(entier ou réel dans un TextField) et quelques autres types légèrement plus complexes (format email),
mais il est impossible d’imposer une expression régulière à vérifier. La solution apportée était la
création d’un code Java exécuté par un service (Script dans un Service Task) qui fait lui-même la
validation.
Figure 5 - Création de script Groovy pour la validation et l'adaptation dynamique des formulaires
En présence d’erreurs, un champ apparaît dans la page initiale dans lequel s’affiche le message
d’erreur. Ce problème a largement complexifié le diagramme général.
4.1.2 La création de formulaire
La création d’une page qui puisse admettre plusieurs « instances de classes » : il s’agit par exemple de
la page pour remplir les détails des enfants de l’assuré. Etant donné que l’on peut avoir un nombre
illimité d’enfants, il est possible de créer une page pour remplir les détails d’un seul, puis cocher une
case « Nouvel enfant ? » pour pouvoir revenir à cette même page et remplir les détails d’un autre.
Page 8 on 19
Veille Technologique Outils BPMN 2.0
Figure 6 - Création assistée des formulaires avec Bonitasoft
Cette solution n’était pas très élégante et elle a été remplacée par un tableau (on peut
ajouter/supprimer des lignes) et un script qui vérifie par exemple que la chaîne de caractères entrée
pour la date de naissance de chaque enfant correspond bien à une date (expression régulière).
4.2 Présentation de jBPM (solution de JBoss)
Le Framework jBPM (version 6.0) est basé sur un système de type relationnel. Par défaut, il utilise une
base de données. Le Framework jBPM rend toutefois possible l’utilisation de DB2, Derby, HSQLDB,
MySQL5, MySQL InnoDB, Oracle, PostreSQL, SQL Server et SQL Server 2008.
La totalité du projet utilise la spécification JPA, implémentée par Hibernate 15. Hibernate permet
justement la communication avec les systèmes susmentionnés au travers de ses différents dialectes.
Le Framework jBPM n’est pas directement un programme « tout-en-un » permettant de modéliser
puis d’exécuter des processus métiers décrits avec la norme BPMN 2.0. Ce Framework est composé
d’une multitude de composants modulaires où chacun a un rôle particulier. Afin de comprendre
l’utilité de chacun, ceux-ci sont présenté ci-dessous.
15
http://hibernate.org
Page 9 on 19Veille Technologique Outils BPMN 2.0
4.2.1 Framework jBPM JBoss (Intégration à Eclipse)
La jBPM est une librairie mise en place par JBoss Community. Installée sur Eclipse, elle permet de créer
des processus suivant la norme BPMN 2.0. Les plugins sont à l’origine de l’interface graphique qui
ressemble d’ailleurs à celle de BonitaSoft. Le serveur Tomcat d’Apache supporte l’application « jBPM
Console » à travers laquelle un utilisateur du système se connecte.
Figure 7 - Plugin jBPM pour Eclipse
4.2.2 KIE Workbench
KIE Workbench (jbpm-console-ng) est l’application web qui permet de modéliser des diagrammes, de
lancer des processus et de compléter les tâches y relatives. Elle permet également de gérer les
« repositories » (environnement et groupes de projets BPM). Elle n’est pas encore aboutie et présente
encore quelques bugs.
Figure 8 - Paramétrages du BPM via l'interface web KIE
Cette application web a comme avantage de centraliser tout ce dont le développeur a besoin pour
créer et faire fonctionner un BPM contrairement aux versions précédentes où plusieurs applications
web étaient nécessaires (modélisation, déploiement, ...). KIE Workbench permet de modéliser un
diagramme mais également les formulaires de tâches avec un éditeur de formulaire intégré ou avec
un éditeur de code (format HTML/FTL).
Figure 9 - Création d'un BPM avec l'interface web KIE
Page 10 on 19Veille Technologique Outils BPMN 2.0
4.2.3 API
Il est possible de travailler avec l’API proposée par jBPM. Pour autant que le diagramme comporte
uniquement des éléments pris en charge par le moteur de workflow de jBPM, il est possible, au moyen
de librairies fournies, de le charger dans notre propre application et de travailler les différentes tâches
modélisées.
4.2.4 Repositories
Les projets jBPM sont stockés dans un ou plusieurs « repositories » locaux. Ces derniers sont de type
git2. Ce système est extrêmement pratique si l’on veut travailler, par exemple, autant avec KIE
Workbench qu’avec le plugin Eclipse.
Figure 10 - Intégration de la gestion des repositories dans l’interface web KIE
4.2.5 Intégration de jUnit
Le Framework jBPM offre la possibilité de tester les diagrammes BPM. Bien que ce ne soit pas du code
en soit, les diagrammes ont un cycle de vie. De plus, comme ils peuvent être mis à jour de manière
dynamique, il peut être judicieux de les tester.
Après avoir modélisé un diagramme BPM, il est possible de l’importer dans Eclipse, grâce à git, par
exemple, et de générer une classe de test, que l’on peut modifier puis de la lancer en tant que test
unitaire jUnit.
Page 11 on 19Veille Technologique Outils BPMN 2.0
4.3 Comparaison des logiciels
Lors de la prise en main appliquée à un cas concret, comme attendu, les deux logiciels se sont révélés
équivalents, chacun ayant ses propres caractéristiques. Le Framework jBPM semble être le plus
complet et le plus modulable en comparaison à BonitaSoft mais aussi plus ouvert à l’évolution (jBPM
est OpenSource).
Cette section présente les comparaisons, après utilisation, entre le logiciel BonitaSoft et le Framework
jBPM (JBoss) pouvant-être intégré à Eclipse.
4.3.1 Documentation
En apprenant à utiliser un logiciel ou une librairie, la documentation est une nécessité. Vu que la
technologie BPM est relativement récente et ne cesse d’évoluer, on ne peut pas s’attendre à la
perfection. Mais on peut facilement dire que la documentation de la jBPM est bien meilleure que celle
de BonitaSoft (tutoriels, forums, etc.).
4.3.2 Interfaces graphiques et démarrage
Du point de vue des interfaces graphiques, BonitaSoft est plus facile à apprendre et à utiliser. Un
exemple à l’appui est la création des formulaires illustré ci-dessous. Bonita met à disposition un logiciel
tout-en-un permettant une vue globale de tout le projet. Il est également équipé de nombreux éditeur
graphique (GUI) facilitant la vie de l’utilisateur expert.
L’autre logiciel, jBPM, est quant à lui plus complexe à mettre en place et à utiliser. A l’instar de Bonita,
il s’agit d’un plugin Eclipse nécessitant l’installation de nombreuses dépendances. L’interface
graphique de jBPM est sensiblement celle d’Eclipse. Le plugin étant encore jeune, l’intégration n’est
pas encore parfaite.
Figure 11 – Palette de BonitaSoft facilitant la mise en forme des formulaires
La création et l’édition des variables est aussi plus évidente sur BonitaSoft où il suffit d’accéder à un
onglet pour trouver les boutons d’ajout et de suppression des variables.
La jBPM de son côté requiert une connaissance de la librairie et des composants initialisés afin de
pouvoir coder la manipulation des variables. Il existe d’autres différences et ressemblances (création
des diagrammes) - les spécificités du langage ne sont pas présentées dans ce document.
Page 12 on 19Veille Technologique Outils BPMN 2.0
4.3.3 Création des formulaires
Il est vrai que BonitaSoft facilite la création des formulaires, mais si l’utilisateur (celui qui crée le
processus) connaît déjà le langage HTML, il préférera certainement créer le formulaire exactement
comme il désire sans être restreint aux éléments de la palette
Figure 12 – Connaissances Web (FTL) requises
4.3.4 Définition des acteurs
La librairie jBPM offre un moyen de spécifier dynamiquement les acteurs d’un processus, mais pas
BonitaSoft. Ceci a une importance majeure illustrée dans notre application même. En effet, le
processus modélisant le système de l’AVS fait intervenir différents types d’acteurs : un citoyen, un
employé de la caisse, et éventuellement des personnes spécifiées par le citoyen durant son
remplissage du formulaire, telles que son représentant, ses enfants, etc.
Le problème qui se lève sous BonitaSoft est le suivant : l’acteur du processus de remplissage du
formulaire appartient à un groupe « Citoyens » qui contient tous les citoyens du système. La tâche
« La personne tierce est informée (enfants par exemple) » requiert pour acteurs les enfants du citoyen
en question. La définition des acteurs étant statique, il faudra créer pour chaque citoyen un groupe
qui lui est lié et qui contient ses enfants. Pire, chaque citoyen devra avoir son propre processus et celui
de ses enfants ! Ceci ne constitue pas une solution. La jBPM résout ce problème en acceptant d’avoir
pour acteur du processus l’identificateur (ID) d’un acteur lu à partir d’une variable définie par le
citoyen ou par programmation (un script qui modifie le contenu de la variable à l’ID de l’enfant tiré
d’une base de données ou n’importe quelle autre source).
4.3.5 Création des processus
Tout comme la définition des acteurs, la jBPM permet de créer des processus entiers de manière
dynamique, alors que sous BonitaSoft les processus sont toujours créés de manière statique.
Cependant il n’est pas facile d’établir tout un processus en Java.
4.3.6 Exportation et réutilisabilité
La BPMN n’est en fait qu’un simple schéma XML devant répondre à une spécification établie16.
Contrairement à ce que l’on pourrait croire, tous les éditeurs de BPM ne respectent pas cette norme.
C’est notamment le cas pour la solution BonitaSoft. Plusieurs balises XML utilisée sont spécifiques au
logiciel et sont donc basées sur d’autres schémas.
A contrario, les fichiers XML produits par la jBPM respectent la norme.
16
http://www.omg.org/spec/BPMN/2.0/
Page 13 on 19Veille Technologique Outils BPMN 2.0
4.4 Choix du logiciel
Le logiciel BonitaSoft possède de nombreux avantage. Il s’agit d’un logiciel tout en un (modélisation,
moteur d’exécution, etc.). Son interface graphique permet une utilisation facilitée. De plus, il dispose
d’une communauté grandissante et un forum actif17. Malheureusement, celui-ci est trop fermé et ne
respecte pas entièrement la norme BPMN 2.0 imposée par les standards. Il devient alors inutilisable
si l’on souhaite pouvoir reprendre un BPM ou le faire interagir avec des application tierces.
Ce dernier point suggère l’utilisation de jBPM de JBoss. Bien que plus complexe à prendre en main,
celui-ci s’avère entièrement compatible avec la norme BPMN 2.0.
Après avoir commencé diverses réalisations avec le logiciel BonitaSoft, il a été nécessaire de se
résigner à utiliser le Framework jBPM pour une meilleure intégration. De plus, du point de vue
flexibilité, jBPM s’avère bien plus puissant.
5 Conception
Après le travail d’analyse de la section précédente et dans l’optique d’amener de la sémantique dans
le BPM du point de vue du stockage et de la prise de décision en fonction d’un contexte donné, cette
section présente les alternatives existantes pour une implémentation basée sur la plateforme JBoss.
Pour l’heure, un BPM s’exécute et enregistre ses données le plus souvent dans une base de données
(SGBD) relationnelle. Les interactions BPM/SGBD sont complexes à mettre en place et nécessitent la
création de processus particuliers.
Tout en respectant la norme BPMN 2.0 et en proposant l’intégration d’une communication facilitée
entre formulaires et bases de données, il est proposé ici un système capable d’intercepter les données
saisies par l’utilisateur et de les convertir à la volée dans un format sémantique. Les transformations
à effectuer se font à l’aide de règles définies dans une ontologie, configurables par un utilisateur
expert. Cette interconnexion entre BPM et base de données sémantique, permettra de faire remonter
des informations contextuelles, pouvant permettre l’automatisation de certains choix tout au long du
processus.
Fondamentalement, il y a 3 possibilités qui sont envisageables :
Modifier les sources du moteur jBPM
Gérer les requêtes vers le système triplestore au niveau applicatif
Elaborer un middleware pour traduire les requêtes
Le but étant d’assurer un maximum de transparence pour le développeur et l’utilisateur et d’atteindre
un niveau de généricité adéquat. Il va sans dire que l’intégrité et la cohérence des données doivent
être respectées.
17
http://community.bonitasoft.com
Page 14 on 19Veille Technologique Outils BPMN 2.0
5.1 Solution A : Modification du moteur jBPM
Une première modification consisterait à modifier le moteur jBPM. Le Framework jBPM a l’avantage
d’être open source. Bien que sa communauté soit peu active, ses développeurs proposent une bonne
base pour traiter des processus de complexité moyenne. L’entièreté du projet est basée sur les
technologies qui ne sont pas facilement accessibles :
Structure, découpage et gestion du projet avec Maven
Persistance assurée par Hibernate qui implémente Java Persistance API
Déploiement prévu sur un serveur d’application JBoss
Utilisation courante des EJB4
Utilisation courante des CDI5 (injections)
5.2 Solution B : Adaptation du code source de l’application
Modifier le code source de jBPM semble une option intéressante. Cette alternative permettrait
d’obtenir le résultat escompté.
L’avantage premier est de pouvoir ainsi agir au plus bas niveau et avoir le contrôle sur la manipulation
des données afin d’en garder la cohérence et l’intégrité. Par contre, le Framework jBPM est un projet
qui n’est pas encore abouti, et il ne prend pas actuellement pas en charge la totalité des éléments de
la norme BPMN 2.0. Il a déjà beaucoup évolué et va encore évoluer. Le fait de modifier les sources de
jBPM à ce stade peuvent demander un travail de maintenance assez conséquent lors des mises à jours
futures de ce dernier.
5.3 Solution C : Gestion des données sur l’application finale
Cette solution serait de gérer toutes les requêtes sémantiques sur notre application finale. Ceci signifie
que notre application finale ferait ses requêtes sur jBPM de manière normale et qu’à chaque appel et
réponse, il sera nécessaire de traiter ces derniers, et aller, au besoin, requêter dans le système
triplestore. Cette manière de faire peut fonctionner, mais, forcément, n’est pas la plus efficace dans
le sens où beaucoup de requêtes supplémentaires devront être faites et beaucoup d’entre elles seront
inutiles.
Page 15 on 19Veille Technologique Outils BPMN 2.0
6 Solution retenue et conclusion
L’idée principale du projet est d’allier le moteur BPM aux avantages du web sémantique. Dans notre
cas, l’avantage principal apporté par le web sémantique est le partage d’informations communes aux
différentes applications du projet eGov et de gagner en efficacité en évitant les demandes redondantes
à l’utilisateur final.
Pour les raisons évoquées plus haut, dans la section contributions proposées, le logiciel retenu est
jBPM principalement pour sa flexibilité et son respect de la norme BPMN 2.0.
Il est important de différencier deux types d’éléments au niveau de la persistance des données.
Le Framework jBPM utilise la persistance des données pour sa propre exécution. C’est-à-dire
qu’il va stocker un certain nombre d’informations utiles à son bon fonctionnement et, bien
sûr, à l’exécution des workflows.
D’autre part, il y a les informations recueillies (outputs) ou injectées (inputs) dans les tâches.
C’est sur ce second cas (solution B) que la contribution va-t-être focalisée
Le transfert des données du processus BPM à l’ontologie se fait par programmation, typiquement au
niveau de services (Service Task) ajoutés aux diagrammes BPM. Pour assurer cette communication, il
sera nécessaire d’utiliser la librairie Sesame de OpenRDF pour pouvoir bâtir une base de données
structurée suivant l’ontologie créée sous format RDF/XML. Il faudra ensuite ajouter le fichier RDF qui
contient l’ontologie à un nouveau « Repository » de Sesame. Il sera alors possible d’exécuter des
requêtes dans le langage SPARQL pour lire, insérer et modifier les informations.
Pour mener à bien la suite de ce projet, la contribution B « Adaptation du code source de l’application »
a été retenue. Celle-ci semble être celle offrant le plus de possibilités et extensibilité.
Page 16 on 19Veille Technologique Outils BPMN 2.0
7 ANNEXE : Problèmes rencontrés avec jBPM
Durant l’évaluation du Framework jBPM plusieurs problèmes auxquels il faudra porter une attention
particulière lors du développement sont apparus. A noter que la plupart de ces problèmes sont liés
directement avec l’interface de programmation et non pas dans la logique de l’application BPM ou de
son moteur d’exécution.
Les problèmes suivants ont été rencontrés dans la version 6.0 de jBPM.
7.1 Problèmes d’affichage
La nouvelle application web KIE Workbench est encore remplie de bug, essentiellement graphiques
tels que des boutons qui ne s’affichent pas, des barres qui disparaissent, des calques à moitié visibles.
Changer de page puis revenir sur la page désirée permet bien souvent de résoudre le problème.
7.2 Problèmes occasionnels lors du déploiement de l’application web
KIE Workbench ne se déploie pas toujours, ou avec un certain retard dans le serveur d’application
JBoss lorsqu’on lance l’environnement de démonstration fourni par jBPM. Ceci ne posera pas de
problème dans un environnement de production où l’on aura un contrôle total de nos actions, plutôt
que d’exécuter le script fourni.
7.3 Contradictions entre les validateurs
Le Framework jBPM permet la modélisation de diagrammes par KIE Workbench mais aussi par le plugin
BPMN 2.0 Modeler pour Eclipse. Tous deux utilisent et respectent la norme BPMN 2.0 mais leurs
validateurs respectifs ne sont pas toujours en adéquation. Le validateur du plugin Eclipse relèvera des
erreurs ou avertissements qui ne seront pas donnée par KIE Workbench et vice-versa. Les forums
officiels prétendent que certaines de ces erreurs peuvent être ignorées.
7.4 Limitations dans le moteur de workflow
A l’heure actuelle, jBPM ne couvre pas encore la totalité des éléments de la norme BPMN 2.0. Bien
que les outils permettent de modéliser une large palette d’éléments, le moteur de workflow n’est pas
encore apte à tous les prendre en compte. Ceci pose notamment problème avec les diagrammes de
communication qui mettent en scène différents utilisateurs dans des swimlanes et pools. On ne peut
donc pas décrire l’interaction avec ces derniers. Le support de ce genre de diagramme ne fait pas
encore partie de la roadmap de jBPM. Un des développeurs de jBPM parle de vouloir consolider
davantage l’exécution des tâches avant d’élargir les possibilités et encourage la communauté à
prendre part au projet.
Page 17 on 19Veille Technologique Outils BPMN 2.0
7.5 Communauté peu présente
Certaines réponses à nos questions peuvent être trouvées sur internet, notamment sur les forums
officiels de JBoss7. Cependant ces derniers ne sont que très peu réactifs. Beaucoup de questions,
visualisées des centaines de fois, restent sans réponse. Ce sont surtout les développeurs de jBPM qui
répondent aux questions qui paraissent toutes plus spécifiques les unes que les autres. Ceci donne
l’impression que jBPM n’est pas encore assez répandu et que peu de développeurs sont vraiment à
l’aise avec cette solution.
Les tutoriels sont rares et ne couvrent qu’une mineure partie des éléments BPMN 2.0. Il faut bien
souvent se rabattre sur les tests unitaires fournis pour savoir comment les différentes fonctionnalités
interagissent entre elles.
7.6 Le Framework jBPM 6 est une nouvelle release
La documentation officielle pour jBPM 6 existe mais ne couvre pas encore la totalité du projet. Certains
points sont d’ailleurs mentionnés par des titres mais ne comportent pas de texte. Cependant, ce qui a
déjà été fait est valable.
La version 6 est très différente des versions inférieures au niveau du remaniement des outils. C’est
pourquoi beaucoup de tutoriels trouvés présentent des outils obsolètes pour jBPM 6.
7.7 Gestion des messages
Bien que les diagrammes de collaboration ne soient pas pris en charge, il est tout de même possible
de modéliser des processus qui se lancent en fonction de la réception de messages (Message Start
Event). En utilisant jUnit, on peut coder l’envoi d’un message qui réveille bel et bien le processus. Le
message arrive comme il se doit mais le traitement des paramètres n’est pas aussi simple.
Un exemple officiel est fourni avec jBPM 6 CR2. Ce dernier montre le réveil d’un processus grâce à un
message paramétré d’un String, ce qui fonctionne très bien. Mais la tâche suivante, dont le but est
d’afficher ce String, n’affiche rien.
7.8 Génération de formulaires
KIE Workbench permet de générer les formulaires d’un processus. Lors de l’utilisation de Data Modeler
pour créer une classe Person puis l’utiliser dans un processus, le Form Modeler va créer des champs
pour chacun des attributs de la classe Person. Dans le cas où des données sont déjà connues, les
champs correspondant devraient être déjà renseignés. Cependant, ceci n’est pas fait
systématiquement. Cela se produit au lancement d’un processus. Le système réagi comme si le
formulaire de processus n’était pas enregistré avant de partir sur la première tâche.
Page 18 on 19Veille Technologique Outils BPMN 2.0
7.9 Disparition des composants d’un diagramme
Pour une raison encore indéterminée, la totalité des composants des diagrammes BPM ont disparu,
ne laissant que les connections. À ce stade, Il n’est plus possible d’ajouter aucun élément sur le
diagramme, excepté des connections.
Après quelques jours, plusieurs utilisateurs se sont manifestés avec le même problème. Bien
qu’aucune explication officielle ne soit donnée, cela semble provenir de problèmes d’incompatibilité
(graphique) avec le navigateur Chrome, suite à une de ses dernières mises à jour. Il semblerait que les
navigateurs à favoriser soient Internet Explorer et Firefox.
7.10 Traitement des erreurs
La norme BPMN 2.0 prévoit un élément clé pour le traitement d’erreur. Son but est de « catcher »
l’erreur qui pourrait survenir dans une tâche ou un sous-processus et de rediriger le flux vers un chemin
différent.
Le composant est implémenté et s’active si une exception Java est levée. Cependant, en version 6.0, il
n’est pas prévu de pouvoir récupérer cette exception dans la tâche suivante pour la traiter. Après
discussion avec un développeur jBPM, cette fonctionnalité est prévue pour la version 6.1 de jBPM.
Page 19 on 19Vous pouvez aussi lire
