Activiti7
1. Workflow Introduction
1.1 Concept
Workflow (Workflow) consiste à automatiser la gestion des processus métiers via des ordinateurs. Il résout principalement «
le processus de transfert automatique de documents, d'informations ou de tâches entre plusieurs participants selon certaines règles prédéfinies, de manière à atteindre un certain objectif commercial attendu, ou à promouvoir la réalisation de cet objectif ».
1.2 Système de workflow
Un système logiciel a la fonction de workflow. Nous l'appelons un système de workflow. Quelle est la fonction du workflow dans un système ? Il s'agit d'automatiser la gestion du processus métier du système
, de sorte que le flux de travail est basé sur le processus métier, de sorte que le cœur d'un système logiciel est essentiellement le processus métier du système, et le
flux de travail sert uniquement à aider à la gestion. du processus d’affaires. Même s'il n'existe pas de système métier de workflow, il peut être développé et exécuté, mais avec le workflow, les processus métier peuvent être mieux gérés
et l'évolutivité du système peut être améliorée.
1.3 Industries applicables
Industrie des biens de consommation, industrie manufacturière, industrie des services de télécommunications, industrie des services financiers tels que l'assurance des titres bancaires, industrie des services logistiques, industrie des services immobiliers, gestion immobilière, grandes et moyennes sociétés de commerce d'importation et d'exportation, institutions gouvernementales, instituts de
recherche et l'industrie des services d'éducation, etc., en particulier les grandes sociétés multinationales et les sociétés de groupe.
1.4 Applications spécifiques
1. Processus métiers clés : commandes, traitement des devis, revue des contrats, traitement des appels clients, gestion de la chaîne d'approvisionnement, etc. 2.
Gestion administrative : demandes de déplacements professionnels, demandes d'heures supplémentaires, demandes de congés, demandes de voiture, demandes de fournitures de bureau diverses, Les demandes d'achat, les rapports quotidiens et hebdomadaires, etc. sont autant
de formulaires administratifs qui étaient initialement traités manuellement.
3. Gestion du personnel : modalités de formation des employés, évaluation des performances, traitement des changements d'emploi, gestion des informations sur les dossiers des employés, etc.
4. Catégories liées aux finances : demande de paiement, traitement des créances, traitement des remboursements quotidiens, remboursement des déplacements professionnels, demande de budget et de plan, etc.
5. Catégorie service client : gestion des informations clients, réclamations clients, traitement des demandes, gestion du service après-vente, etc.
6. Catégories de services spéciaux : les processus correspondants de la série ISO, les processus correspondants de gestion de la qualité, la gestion des informations sur les données sur les produits, le traitement des déclarations en douane pour les sociétés commerciales, le traitement du suivi des marchandises pour les entreprises de logistique, etc., peuvent être automatiquement régulés par un logiciel de flux de travail pour diverses tâches qui sont complété par un flux manuel à travers des formulaires
progressivement mis en œuvre.
1.5 Méthode de mise en œuvre
Avant qu'il n'y ait un moteur de workflow dédié, afin de réaliser le contrôle du processus, nous utilisions généralement la valeur du champ d'état pour suivre l'évolution du processus
. De cette manière, les utilisateurs qui n'utilisent pas de rôles peuvent déterminer si l'enregistrement est affiché par la valeur du champ d'état.
Pour les enregistrements pouvant être consultés avec autorisation, l'utilisateur actuel décide d'approuver ou non l'opération qualifiée en fonction de son rôle. Si vous êtes qualifié, définissez une
valeur dans le champ d'état pour représenter qualifié ; bien sûr, si vous n'êtes pas qualifié, une valeur doit également être définie pour représenter non qualifié.
C'est la manière la plus primitive. Bien que le contrôle du processus soit réalisé via le champ d'état, lorsque notre processus change,
le code ainsi écrit doit également être ajusté.
Existe-t-il donc un moyen professionnel de gérer les flux de travail ? Et il est possible d'obtenir qu'après le changement des processus d'affaires, notre programme n'ait pas besoin d'être modifié. Si
cet effet peut être obtenu, l'adaptabilité de notre système d'affaires sera grandement améliorée.
2. Présentation d'Activiti7
2.1 Introduction
Le logiciel Alfresco a annoncé le lancement officiel du projet open source de gestion des processus métiers (BPM) Activiti le 17 mai 2010. Son architecte en chef est Tom Baeyens, un expert en gestion des processus métiers BPM
. jbpm Architects original, et jbpm est un moteur de workflow très célèbre, bien sûr,
activiti est également un moteur de workflow.
Activiti est un moteur de workflow. Activiti peut extraire les processus métier complexes dans le système métier et
les définir à l'aide du langage de modélisation spécial BPMN2.0. Les processus métier sont exécutés selon les processus prédéfinis, et les processus système sont réalisés par Activiti réduire
la charge de travail des systèmes d'entreprise pour les mises à niveau du système en raison de changements de processus, améliorant ainsi la robustesse du système et réduisant les coûts de développement et de maintenance du système.
Site officiel : https://www.activiti.org/
Version expérimentée :
La dernière version : Activiti7.0.0.Beta
2.1.1 BPM
Le BPM (Business Process Management), c'est-à-dire la gestion des processus métier, est une structure standardisée de bout en bout. - Processus métier de bout en bout pour améliorer continuellement
l'efficacité de l'organisation. Le BPM est inclus dans les formations courantes en gestion d’entreprise telles que l’EMBA et le MBA.
2.1.2 Logiciel BPM
Le logiciel BPM est un outil informatique qui favorise l'intégration et l'ajustement des
méthodes et solutions commerciales entre les personnes, entre les personnes et les systèmes, et entre les systèmes en fonction des changements dans l'environnement commercial de l'entreprise.
La modélisation, l'automatisation, le suivi de la gestion et l'optimisation de l'ensemble du cycle de vie des processus commerciaux internes et externes de l'entreprise via le logiciel BPM peuvent réduire les coûts de l'entreprise et augmenter considérablement les bénéfices
.
Le logiciel BPM est largement utilisé dans les entreprises. Partout où il existe des processus commerciaux, le logiciel BPM peut être utilisé pour la gestion, comme la gestion du bureau du personnel de l'entreprise, la gestion des processus d'approvisionnement, la gestion du processus d'approbation des documents officiels, la gestion financière,
etc.
2.1.3 BPMN
BPMN (Business Process Model And Notation) - le modèle et la notation de processus métier sont
un ensemble de notations standard de modélisation de processus métier développées par BPMI (BusinessProcess Management Initiative), et les processus métier peuvent être créés à l'aide des notations fournies par BPMN.
La spécification BPMN1.0 a été publiée en mai 2004. BPMI a été incorporée à l'organisation OMG (The Object Management Group) en septembre 2005. OMG
a publié la version finale de BPMN2.0 en janvier 2011.
L'historique de développement spécifique est le suivant :
BPMN est actuellement une norme BPM largement acceptée par les fournisseurs de BPM. Activiti utilise BPMN 2.0 pour la modélisation et la gestion de l'exécution des processus. Il comprend
de nombreux symboles de modélisation, tels que :
L'événement
est représenté par un cercle, ce qui se produit pendant le déroulement du processus.
Les activités sont représentées par des rectangles arrondis. Un processus se compose d'une ou de plusieurs activités.
Les graphiques Bpmn représentent en fait les processus métier au format XML. Le fichier .bpmn ci-dessus est ouvert avec un éditeur de texte :
<?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:activiti="http://activiti.org/bpmn"
xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI"
xmlns:omgdc="http://www.omg.org/spec/DD/20100524/DC"
xmlns:omgdi="http://www.omg.org/spec/DD/20100524/DI"
typeLanguage="http://www.w3.org/2001/XMLSchema"
expressionLanguage="http://www.w3.org/1999/XPath"
targetNamespace="http://www.activiti.org/test">
<process id="myProcess" name="My process" isExecutable="true">
<startEvent id="startevent1" name="Start"></startEvent>
<userTask id="usertask1" name="创建请假单"></userTask>
<sequenceFlow id="flow1" sourceRef="startevent1" targetRef="usertask1"></sequenceFlow>
<userTask id="usertask2" name="部门经理审核"></userTask>
<sequenceFlow id="flow2" sourceRef="usertask1" targetRef="usertask2"></sequenceFlow>
<userTask id="usertask3" name="人事复核"></userTask>
<sequenceFlow id="flow3" sourceRef="usertask2" targetRef="usertask3"></sequenceFlow>
<endEvent id="endevent1" name="End"></endEvent>
<sequenceFlow id="flow4" sourceRef="usertask3" targetRef="endevent1"></sequenceFlow>
</process>
<bpmndi:BPMNDiagram id="BPMNDiagram_myProcess">
<bpmndi:BPMNPlane bpmnElement="myProcess" id="BPMNPlane_myProcess">
<bpmndi:BPMNShape bpmnElement="startevent1" id="BPMNShape_startevent1">
<omgdc:Bounds height="35.0" width="35.0" x="130.0" y="160.0"></omgdc:Bounds>
</bpmndi:BPMNShape>
<bpmndi:BPMNShape bpmnElement="usertask1" id="BPMNShape_usertask1">
<omgdc:Bounds height="55.0" width="105.0" x="210.0" y="150.0"></omgdc:Bounds>
</bpmndi:BPMNShape>
<bpmndi:BPMNShape bpmnElement="usertask2" id="BPMNShape_usertask2">
<omgdc:Bounds height="55.0" width="105.0" x="360.0" y="150.0"></omgdc:Bounds>
</bpmndi:BPMNShape>
<bpmndi:BPMNShape bpmnElement="usertask3" id="BPMNShape_usertask3">
<omgdc:Bounds height="55.0" width="105.0" x="510.0" y="150.0"></omgdc:Bounds>
</bpmndi:BPMNShape>
<bpmndi:BPMNShape bpmnElement="endevent1" id="BPMNShape_endevent1">
<omgdc:Bounds height="35.0" width="35.0" x="660.0" y="160.0"></omgdc:Bounds>
</bpmndi:BPMNShape>
<bpmndi:BPMNEdge bpmnElement="flow1" id="BPMNEdge_flow1">
<omgdi:waypoint x="165.0" y="177.0"></omgdi:waypoint>
<omgdi:waypoint x="210.0" y="177.0"></omgdi:waypoint>
</bpmndi:BPMNEdge>
<bpmndi:BPMNEdge bpmnElement="flow2" id="BPMNEdge_flow2">
<omgdi:waypoint x="315.0" y="177.0"></omgdi:waypoint>
<omgdi:waypoint x="360.0" y="177.0"></omgdi:waypoint>
</bpmndi:BPMNEdge>
<bpmndi:BPMNEdge bpmnElement="flow3" id="BPMNEdge_flow3">
<omgdi:waypoint x="465.0" y="177.0"></omgdi:waypoint>
<omgdi:waypoint x="510.0" y="177.0"></omgdi:waypoint>
</bpmndi:BPMNEdge>
<bpmndi:BPMNEdge bpmnElement="flow4" id="BPMNEdge_flow4">
<omgdi:waypoint x="615.0" y="177.0"></omgdi:waypoint>
<omgdi:waypoint x="660.0" y="177.0"></omgdi:waypoint>
</bpmndi:BPMNEdge>
</bpmndi:BPMNPlane>
</bpmndi:BPMNDiagram>
</definitions>
2.2 Utiliser les étapes
pour déployer activiti
Activiti est un moteur de workflow (en fait un ensemble d'API de package jar), le système d'entreprise peut accéder (exploiter) l'interface d'activiti pour exploiter facilement les données liées au processus
, afin que l'environnement de workflow puisse être intégré à les environnements des systèmes d’entreprise sont intégrés.
Définition des processus
Utilisez l'outil de modélisation des processus d'activité (activity-designer) pour définir les processus métier (fichiers .bpmn).
Le fichier .bpmn est le fichier de définition de processus métier, qui définit le processus métier via XML.
Déploiement de définitions de processus
Activiti déploie des définitions de processus métier (fichiers .bpmn).
Utilisez l'API fournie par Activiti pour stocker le contenu de la définition de processus. Pendant l'exécution d'Activiti, vous pouvez interroger le contenu défini.
Activiti exécute et stocke le contenu de la définition de processus dans la base de données.
Démarrez une
instance de processus. L'instance de processus est également appelée : ProcessInstance
démarre une instance de processus pour démarrer une entreprise. Le fonctionnement du processus.
Une fois le déploiement de la définition du processus de congé des employés terminé, si Zhang San souhaite demander un congé, il peut démarrer une instance de processus, et si Li Si souhaite demander un congé, il peut également démarrer une instance de processus et l'exécution
de les deux processus ne s’influencent pas.
Les utilisateurs interrogent les tâches à effectuer (tâche)
Étant donné que le processus métier du système a été confié aux activités pour la gestion, via les activités, vous pouvez demander où le processus en cours est exécuté et quelles
tâches l'utilisateur actuel doit gérer. aidez-nous à gérer, sans que les développeurs aient besoin d'écrire leurs propres requêtes dans des instructions SQL.
L'utilisateur gère les tâches
Une fois que l'utilisateur s'est renseigné sur les tâches en attente, il peut gérer une certaine tâche. Si la tâche est terminée, d'autres utilisateurs doivent la gérer. Par exemple, une fois la commande d'achat créée, elle sera examinée par le chef de service. Ce processus est également complété par
des activités pour nous.
Fin du processus
Lorsque la tâche est terminée et qu'il n'y a pas de nœud de tâche suivant, l'instance de processus est terminée.
3. Environnement Activiti
3.1 Environnement de développement
Jdk1.8 ou version supérieure
Mysql 5 et version supérieure
Tomcat8.5
IDEA
Remarque : le plug-in de l'outil de définition de processus Activiti peut être installé sous l'outil IDEA ou Eclipse
3.2 Environnement Activiti
Nous utilisons : Activiti7.0.0.Beta1 prend en charge spring5
3.2.1 par défaut Télécharger activiti7
Adresse de téléchargement d'Activiti : http://activiti.org/download.html, les dépendances Maven sont les suivantes :
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.activiti</groupId>
<artifactId>activiti-dependencies</artifactId>
<version>7.0.0.Beta1</version>
<scope>import</scope>
<type>pom</type>
</dependency>
</dependencies>
</dependencyManagement>
- Base de données :
Le fonctionnement des activités nécessite le support de la base de données. Les bases de données supportées sont : h2, mysql, oracle, postgres, mssql, db2.
3.2.2 Installation de Process Designer sous IDEA
Recherchez le sous-menu « Paramètres » dans le menu Fichier d'IDEA, puis sélectionnez le menu « plugins » à gauche, comme le montre la figure ci-dessous : A ce stade, nous pouvons
rechercher le plug actiBPM -in, qui est la version IDEA d'Activiti Designer, nous cliquons sur Installer pour installer.
Après l'installation, la page est la suivante :
Elle vous invite à redémarrer l'idée, cliquez sur Redémarrer.
Une fois le redémarrage terminé, ouvrez à nouveau les plugins (liste des plugins) sous Paramètres, cliquez sur Installé (plugins installés) à droite, et si vous voyez actiBPM dans la liste, cela signifie que l'installation a réussi, comme le montre la figure. ci-dessous : Dans les cours
suivants
, nous utiliserons ce concepteur de processus pour la conception de processus Activiti.
3.3 Prise en charge de la base de données d'Activiti
Activiti a besoin de la prise en charge de la base de données au moment de l'exécution, utilise 25 tables et lit le contenu du nœud de définition de processus dans la table de la base de données pour une utilisation ultérieure.
3.3.1 Bases de données prises en charge par Activiti
Les bases de données et versions prises en charge par Activiti sont les suivantes :
3.3.2 Créer une table dans MySQL
3.3.2.1 Créer une base de données
Créer une activité de base de données MySQL (avec n'importe quel nom) :
CREATE DATABASE activiti DEFAULT CHARACTER SET utf8 ;
3.3.2.2 Utiliser le code java Générer un tableau
1) Créer un projet java
Utilisez idea pour créer un projet java maven, nommé : activiti01.
2) Ajoutez les coordonnées (package jar) dont dépend Maven.
Tout d'abord, vous devez ajouter le package jar requis par ProcessEngine au projet Java, notamment :
- activiti-engine-7.0.0.beta1.jar 2) Les packages jar dont dépend l'activité : mybatis, alf4j, log4j, etc.
- Le forfait printemps dont dépend l'activité
- pilote de base de données mysql
- Pool de connexions de données tiers dbcp 6) Test unitaire Junit-4.12.jar
Nous utilisons maven pour réaliser la construction du projet, les coordonnées correspondant à ces jars doivent donc être importées dans le fichier pom.xml.
Les dépendances complètes sont les suivantes :
<properties>
<slf4j.version>1.6.6</slf4j.version>
<log4j.version>1.2.12</log4j.version>
<activiti.version>7.0.0.Beta1</activiti.version>
</properties>
<dependencies>
<dependency>
<groupId>org.activiti</groupId>
<artifactId>activiti-engine</artifactId>
<version>${
activiti.version}</version>
</dependency>
<dependency>
<groupId>org.activiti</groupId>
<artifactId>activiti-spring</artifactId>
<version>${
activiti.version}</version>
</dependency>
<!-- bpmn 模型处理 -->
<dependency>
<groupId>org.activiti</groupId>
<artifactId>activiti-bpmn-model</artifactId>
<version>${
activiti.version}</version>
</dependency>
<!-- bpmn 转换 -->
<dependency>
<groupId>org.activiti</groupId>
<artifactId>activiti-bpmn-converter</artifactId>
<version>${
activiti.version}</version>
</dependency>
<!-- bpmn json数据转换 -->
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
<dependency>
<groupId>org.activiti</groupId>
<artifactId>activiti-json-converter</artifactId>
<version>${
activiti.version}</version>
</dependency>
<!-- bpmn 布局 -->
<dependency>
<groupId>org.activiti</groupId>
<artifactId>activiti-bpmn-layout</artifactId>
<version>${
activiti.version}</version>
</dependency>
<!-- activiti 云支持 -->
<dependency>
<groupId>org.activiti.cloud</groupId>
<artifactId>activiti-cloud-services-api</artifactId>
<version>${
activiti.version}</version>
</dependency>
<!-- mysql驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.40</version>
</dependency>
<!-- mybatis -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.4.5</version>
</dependency>
<!-- 链接池 -->
<dependency>
<groupId>commons-dbcp</groupId>
<artifactId>commons-dbcp</artifactId>
<version>1.4</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
<!-- log start -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>${
log4j.version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>${
slf4j.version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>${
slf4j.version}</version>
</dependency>
</dependencies>
3) Ajouter la configuration du journal log4j
Nous utilisons le package de journal log4j pour configurer le journal
Créer log4j.properties sous ressources
# Set root category priority to INFO and its only appender to CONSOLE.
#log4j.rootCategory=INFO, CONSOLE debug info warn error fatal
log4j.rootCategory=debug, CONSOLE, LOGFILE
# Set the enterprise logger category to FATAL and its only appender to CONSOLE.
log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE
# CONSOLE is set to be a ConsoleAppender using a PatternLayout.
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{
ISO8601} %-6r[%15.15t] %-5p %30.30c %x -
%m\n
# LOGFILE is set to be a File appender using a PatternLayout.
log4j.appender.LOGFILE=org.apache.log4j.FileAppender
log4j.appender.LOGFILE.File=f:\act\activiti.log
log4j.appender.LOGFILE.Append=true
log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
log4j.appender.LOGFILE.layout.ConversionPattern=%d{
ISO8601} %-6r[%15.15t] %-5p %30.30c %x -
%m\n
4) Ajouter le fichier de configuration d'activiti
Nous utilisons la méthode par défaut fournie par activiti pour créer des tables mysql.
L'exigence de la méthode par défaut est de créer le fichier activiti.cfg.xml sous resources . Remarque : le répertoire et le nom du fichier de la méthode par défaut ne peuvent pas être modifiés, car le
code source de l'activiti a été défini et le fichier avec un nom fixe le nom du fichier est lu dans un répertoire fixe.
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/contex
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
</beans>
5) Configurez dans activiti.cfg.xml.
La méthode par défaut consiste à définir le nom du bean dans activiti.cfg.xml en tant que processEngineConfiguration. Le nom ne peut pas être modifié. Il existe
2 méthodes de configuration ici : l'une consiste à configurer la source de données. séparément, et l'autre est Ne pas configurer les sources de données séparément
1. Configurez directement processEngineConfiguration
processEngineConfiguration est utilisé pour créer ProcessEngine, et les opérations de base de données seront effectuées lors de la création de ProcessEngine.
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/contex
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
<!-- 默认id对应的值 为processEngineConfiguration -->
<!-- processEngine Activiti的流程引擎 -->
<bean id="processEngineConfiguration"
class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
<property name="jdbcDriver" value="com.mysql.jdbc.Driver"/>
<property name="jdbcUrl" value="jdbc:mysql:///activiti"/>
<property name="jdbcUsername" value="root"/>
<property name="jdbcPassword" value="123456"/>
<!-- activiti数据库表处理策略 -->
<property name="databaseSchemaUpdate" value="true"/>
</bean>
</beans>
2. Après avoir configuré la source de données, reportez-vous à processEngineConfiguration et
configurez d'abord la source de données.
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/contex
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
<!-- 这里可以使用 链接池 dbcp-->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver" />
<property name="url" value="jdbc:mysql:///activiti" />
<property name="username" value="root" />
<property name="password" value="123456" />
<property name="maxActive" value="3" />
<property name="maxIdle" value="1" />
</bean>
<bean id="processEngineConfiguration"
class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
<!-- 引用数据源 上面已经设置好了-->
<property name="dataSource" ref="dataSource" />
<!-- activiti数据库表处理策略 -->
<property name="databaseSchemaUpdate" value="true"/>
</bean>
</beans>
6) Programme d'écriture de classe Java pour générer une table
Créez une classe de test, appelez la classe d'outils d'activiti et générez la table de base de données requise par acitivti.
L'utilisation directe de la classe d'outils ProcessEngines fournie par activiti lira le fichier activiti.cfg.xml sous le chemin de classe par défaut, lira la configuration de la base de données qu'il contient
et créera un ProcessEngine. Lors de la création d'un ProcessEngine, une table sera automatiquement créée.
le code s'affiche comme ci-dessous :
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngineConfiguration;
import org.junit.Test;
public class TestDemo {
/**
* 生成 activiti的数据库表
*/
@Test
public void testCreateDbTable() {
//使用classpath下的activiti.cfg.xml中的配置创建processEngine
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
System.out.println(processEngine);
}
}
Instructions : 1. Exécutez le segment de programme ci-dessus pour terminer la création de la table d'activité et implémentez
différentes stratégies de traitement de la table de données en modifiant la valeur du paramètre databaseSchemaUpdate dans activiti.cfg.xml. 2. Lorsque la méthode getDefaultProcessEngine ci-dessus est exécutée, recherchez le nom fixe
processEngineConfiguration dans activiti.cfg.xml.
Lors de l'exécution du programme de test, la console d'idea affichera un journal indiquant que le programme est en train de créer une table de données, similaire à celle-ci, faites attention au contenu de la ligne rouge : une fois l'exécution terminée, nous
vérifions la base de données et créer 25 tables. Les résultats sont les suivants :
ici, nous allons terminer la création de la base de données et des tables nécessaires au fonctionnement de l'activité.
3.4 Introduction à la structure des tables
3.4.1 Règles de dénomination et fonctions des tables
En regardant les tables que nous venons de créer, nous avons constaté que les tables d'Activiti commencent toutes par ACT_.
La deuxième partie est une désignation à deux lettres qui indique le but du tableau. La finalité correspond également à l’API du service. ACT_RE : 'RE' signifie référentiel. Les tables portant ce préfixe
contiennent des définitions de processus et des ressources statiques de processus (images, règles, etc.). ACT_RU : « RU » signifie runtime. Ces tables d'exécution contiennent
des instances de processus, des tâches, des variables, des tâches asynchrones et d'autres données en cours d'exécution. Activiti enregistre ces données uniquement lors de l'exécution de l'instance de processus et
supprime ces enregistrements à la fin du processus. De cette façon, la table d'exécution peut toujours être petite et rapide. ACT_HI : « HI » signifie historique. Ces tableaux contiennent des données historiques telles que
des instances de processus historiques, des variables, des tâches, etc. ACT_GE : GE signifie général. Données communes, utilisées dans différents scénarios
3.4.2 Introduction à la table de données Activiti
4. Diagramme de relation de classe Activiti
Ci-dessus, nous avons terminé la génération de la table de base de données Activiti, nous appelons la classe d'outils Activiti en code Java, comprenons la relation de classe d'Activiti
4.1 Diagramme de relation de classe
Dans la nouvelle version, nous avons traversé des expériences , on constate que les services d'IdentityService et de FormService ont été supprimés.
Nous n'expliquerons donc pas ces deux Services plus tard, mais il y a toujours ces deux Services dans l'ancienne version.
4.2 activiti.cfg.xml
Le fichier de configuration du moteur d'activiti, comprenant : la définition ProcessEngineConfiguration, la définition de la source de données, le gestionnaire de transactions, etc. Ce fichier est en fait un
fichier de configuration Spring.
4.3 Classe de configuration du moteur de processus
Classe de configuration du moteur de processus (ProcessEngineConfiguration), le moteur de workflow
ProceccEngine peut être créé via ProcessEngineConfiguration, et les deux méthodes couramment utilisées sont les suivantes :
4.3.1 StandaloneProcessEngineConfiguration
peut être exécuté séparément à l'aide de StandaloneProcessEngineConfigurationActiviti pour créer ProcessEngine, et Activiti le fera. gérer les transactions par lui-même.
Méthode du fichier de configuration :
définissez généralement un bean dont l'identifiant est processEngineConfiguration dans le fichier de configuration activiti.cfg.xml.
La méthode est la suivante :
<bean id="processEngineConfiguration"
class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
<!--配置数据库相关的信息-->
<!--数据库驱动-->
<property name="jdbcDriver" value="com.mysql.jdbc.Driver"/>
<!--数据库链接-->
<property name="jdbcUrl" value="jdbc:mysql:///activiti"/>
<!--数据库用户名-->
<property name="jdbcUsername" value="root"/>
<!--数据库密码-->
<property name="jdbcPassword" value="123456"/>
<!--actviti数据库表在生成时的策略 true - 如果数据库中已经存在相应的表，那么直接使用，如果不存
在，那么会创建-->
<property name="databaseSchemaUpdate" value="true"/>
</bean>
Vous pouvez également rejoindre le pool de connexions :
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/contex
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql:///activiti"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
<property name="maxActive" value="3"/>
<property name="maxIdle" value="1"/>
</bean>
<!--在默认方式下 bean的id 固定为 processEngineConfiguration-->
<bean id="processEngineConfiguration"
class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
<!--引入上面配置好的 链接池-->
<property name="dataSource" ref="dataSource"/>
<!--actviti数据库表在生成时的策略 true - 如果数据库中已经存在相应的表，那么直接使用，如果不存
在，那么会创建-->
<property name="databaseSchemaUpdate" value="true"/>
</bean>
</beans>
4.3.2 SpringProcessEngineConfiguration
s'intègre à Spring via org.activiti.spring.SpringProcessEngineConfiguration.
Créez un fichier de configuration intégré pour Spring et Activiti :
Activity-spring.cfg.xml (le nom peut être modifié)
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.1.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.1.xsd ">
<!-- 工作流引擎配置bean -->
<bean id="processEngineConfiguration"
class="org.activiti.spring.SpringProcessEngineConfiguration">
<!-- 数据源 -->
<property name="dataSource" ref="dataSource" />
<!-- 使用spring事务管理器 -->
<property name="transactionManager" ref="transactionManager" />
<!-- 数据库策略 -->
<property name="databaseSchemaUpdate" value="drop-create" />
<!-- activiti的定时任务关闭 -->
<property name="jobExecutorActivate" value="false" />
</bean>
<!-- 流程引擎 -->
<bean id="processEngine" class="org.activiti.spring.ProcessEngineFactoryBean">
<property name="processEngineConfiguration" ref="processEngineConfiguration" />
</bean>
<!-- 资源服务service -->
<bean id="repositoryService" factory-bean="processEngine"
factory-method="getRepositoryService" />
<!-- 流程运行service -->
<bean id="runtimeService" factory-bean="processEngine"
factory-method="getRuntimeService" />
<!-- 任务管理service -->
<bean id="taskService" factory-bean="processEngine"
factory-method="getTaskService" />
<!-- 历史管理service -->
<bean id="historyService" factory-bean="processEngine" factorymethod="getHistoryService" />
<!-- 用户管理service -->
<bean id="identityService" factory-bean="processEngine" factorymethod="getIdentityService" />
<!-- 引擎管理service -->
<bean id="managementService" factory-bean="processEngine" factorymethod="getManagementService" />
<!-- 数据源 -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver" />
<property name="url" value="jdbc:mysql://localhost:3306/activiti" />
<property name="username" value="root" />
<property name="password" value="mysql" />
<property name="maxActive" value="3" />
<property name="maxIdle" value="1" />
</bean>
<!-- 事务管理器 -->
<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource" />
</bean>
<!-- 通知 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes></tx:attributes>
<!-- 传播行为 -->
<tx:method name="save*" propagation="REQUIRED" />
<tx:method name="insert*" propagation="REQUIRED" />
<tx:method name="delete*" propagation="REQUIRED" />
<tx:method name="update*" propagation="REQUIRED" />
<tx:method name="find*" propagation="SUPPORTS" read-only="true" />
<tx:method name="get*" propagation="SUPPORTS" read-only="true" />
</tx:attributes>
</tx:advice>
<!-- 切面，根据具体项目修改切点配置 -->
<aop:config proxy-target-class="true">
<aop:advisor advice-ref="txAdvice" pointcut="execution(*
com.itheima.ihrm.service.impl.*.(..))"* />
</aop:config>
</beans>
Créer un processusEngineConfiguration
ProcessEngineConfiguration configuration =
ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cfg.xml")
Le code ci-dessus nécessite qu'il y ait un bean processEngineConfiguration dans activiti.cfg.xml.
Vous pouvez également utiliser la méthode suivante pour modifier le nom du bean :
ProcessEngineConfiguration.createProcessEngineConfigurationFromResource(String resource,
String beanName);
4.4 Création du moteur de workflow
Le moteur de workflow (ProcessEngine) est équivalent à une interface de façade. ProcessEngine est créé via ProcessEngineConfiguration, et
chaque interface de service est créée via ProcessEngine.
4.4.1 Méthode de création par défaut
Corrigez le nom et le chemin du fichier activiti.cfg.xml, et le fichier activiti.cfg.xml a une configuration processEngineConfiguration, vous pouvez utiliser le code suivant
pour créer processEngine :
//直接使用工具类 ProcessEngines，使用classpath下的activiti.cfg.xml中的配置创建processEngine
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
System.out.println(processEngine);
4.4.2 Méthode générale de création
//先构建ProcessEngineConfiguration
ProcessEngineConfiguration configuration =
ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cfg.xml");
//通过ProcessEngineConfiguration创建ProcessEngine，此时会创建数据库
ProcessEngine processEngine = configuration.buildProcessEngine();
4.5 Interface du service Service
Le service est l'interface de service fournie par le moteur de workflow pour le déploiement, l'exécution et la gestion du workflow. Nous pouvons utiliser ces interfaces pour correspondre à la
table de données du service d'exploitation.
4.5.1 Méthode de création de service La méthode de création de service
via ProcessEngine
est le suivant :
RuntimeService runtimeService = processEngine.getRuntimeService();
RepositoryService repositoryService = processEngine.getRepositoryService();
TaskService taskService = processEngine.getTaskService();
4.5.2 Présentation du service
Brève introduction :
RepositoryService
est la classe d'activités de gestion des ressources, qui fournit des opérations pour gérer et contrôler les packages de versions de processus et les définitions de processus. Un organigramme métier conçu à l'aide d'un outil de modélisation de flux de travail doit
utiliser ce service pour déployer le contenu du fichier de définition de processus sur l'ordinateur.
En plus de déployer des définitions de processus, vous pouvez également : Interroger le package de version et la définition de processus dans le moteur. Classe de gestion des opérations de processus de
RuntimeService Activiti.
Vous pouvez obtenir de nombreuses informations sur l'exécution des processus à partir de la classe de gestion des tâches de cette classe de service
TaskService
Activiti. Les informations sur les tâches peuvent être obtenues à partir de cette classe.
La classe de gestion de l'historique de HistoryService
Activiti peut interroger des informations historiques. Lorsque le processus est exécuté, le moteur enregistre de nombreuses données (selon la configuration), telles que l'
heure de chaque instance de processus , etc. Ce service obtient ces données principalement via la fonction de requête
.
La classe de gestion du moteur de ManagementService
Activiti fournit des fonctions de gestion et de maintenance pour le moteur de processus Activiti. Ces fonctions ne sont pas utilisées dans les applications basées sur le flux de travail et sont
principalement utilisées pour la maintenance quotidienne du système Activiti.
5. Démarrer avec Activiti
Dans ce chapitre, créons un workflow Activiti et démarrons le processus.
La création d'un workflow Activiti comprend principalement les étapes suivantes :
1. Définissez le processus, conformément à la spécification BPMN, utilisez l'outil de définition de processus pour décrire l'ensemble du processus avec des symboles de processus 2.
Déployez le processus, chargez le fichier de définition de processus dessiné dans la base de données et générez des données de table
3. Démarrez le processus , Utilisez du code Java pour manipuler le contenu de la table de base de données
5.1 Notation de processus
BPMN 2.0 est l'abréviation de Business Process Modeling Notation 2.0.
Il a été créé et développé en permanence par la Business Process Management Initiative, une association à but non lucratif. En guise de marque, BPMN 2.0 est
un ensemble de spécifications de notation qui utilisent certains symboles pour clarifier l'organigramme de conception des processus métier, ce qui peut améliorer l'efficacité de la communication dans la modélisation commerciale.
Actuellement, BPMN2.0 est la dernière version utilisée pour la mise en page et la communication visuelle dans le contexte du BPM.
Ensuite, comprenons d'abord les symboles courants dans la conception de processus.
La conformité de base de BPMN2.0 comprend principalement :
Événement Événement
Activité
L'activité est un terme général désignant le travail ou les tâches. Une activité peut être une tâche ou un sous-processus du processus en cours ; deuxièmement, vous
pouvez également spécifier différents types pour l'activité. Les activités courantes sont les suivantes :
Passerelles Les passerelles GateWay
sont utilisées pour traiter les décisions, il existe plusieurs passerelles couramment utilisées à connaître :
passerelle exclusive (x)
- un seul chemin sera sélectionné. Lorsque le processus atteint la passerelle, il sera calculé un par un selon l'ordre des flux de sortie. Lorsque le résultat du calcul de la condition est vrai, le flux de sortie de la
passerelle actuelle continuera à être exécuté ;
si les résultats du calcul de plusieurs lignes sont toutes vraies, la première valeur sera exécutée. Si aucun des résultats de l’évaluation de la passerelle n’est vrai, le moteur lèvera
une exception.
La passerelle exclusive doit être utilisée en combinaison avec le flux de séquence conditionnel. L'attribut par défaut spécifie le flux de séquence par défaut. Lorsque toutes les conditions ne sont pas remplies, le flux de séquence par défaut sera exécuté.
Parallel Gateway (+)
- Tous les chemins seront sélectionnés simultanément.
Split - Exécute tous les flux de séquence sortants en parallèle, créant une ligne d'exécution parallèle pour chaque flux de séquence.
Fusionner——Toutes les lignes séparées de la passerelle parallèle et exécutées attendent ici jusqu'à ce que toutes les lignes soient exécutées avant de continuer à s'exécuter vers le bas.
Passerelle inclusive (+)
- peut exécuter plusieurs lignes en même temps ou définir des conditions sur la passerelle
Diviser - évaluer l'expression sur chaque ligne, lorsque l'expression est évaluée comme vraie, créer une ligne parallèle et poursuivre l'exécution
Fusionner —— Toutes les lignes qui sont séparés de la passerelle parallèle et exécutés attendent ici, jusqu'à ce que toutes les lignes soient exécutées avant de continuer à s'exécuter vers le bas.
Passerelle d'événements (+)
—— Spécialement défini pour les événements de capture intermédiaires, permettant à plusieurs flux de sortie de pointer vers plusieurs événements de capture intermédiaires différents. Lorsque le processus est exécuté sur la passerelle d'événements, le processus
est dans un état d'attente et doit attendre qu'un événement soit déclenché pour convertir l'état d'attente en état actif.
Un flux vers un flux
est une ligne qui relie deux nœuds de processus. Les directions de flux courantes sont les suivantes :
5.2 Concepteur de processus Utilisez
Activiti-Designer pour utiliser
la palette (planche à dessin)
pour installer des plug-ins dans l'idée et l'utiliser. La planche à dessin comprend les nœuds suivants :
Connexion –
Événement de connexion –
Tâche d'événement – Tâche
Passerelle—Gateway
Conteneur —Conteneur
Événement de limite—Événement de limite
Événement intermédiaire- -Événement intermédiaire
Une fois l'organigramme conçu, enregistrez et générez un fichier .bpmn. Pour créer
un nouveau processus (outil IDEA),
sélectionnez d'abord le répertoire dans lequel les graphiques sont stockés. (sélectionnez le répertoire bpmn sous ressources), et cliquez sur le menu : Nouveau -> BpmnFile , comme indiqué dans la figure :
la boîte illustrée dans la figure ci-dessous apparaît, saisissez evection pour indiquer le processus d'approbation du voyage d'affaires :
après le nom evection ( l'extension par défaut est bpmn), vous pouvez voir la page de conception du processus, comme le montre la figure :
la zone de gauche est la zone de dessin, la zone de droite est la zone de la planche à dessin de la palette.
Cliquez sur les éléments de la planche à dessin avec le souris pour dessiner à gauche.
Processus de dessin
Utilisez le skateboard pour dessiner le processus. En faisant glisser l'icône de la droite vers la planche à dessin à gauche, l'effet final est le suivant :
Spécifiez la clé de définition du processus.
La clé de définition du processus est l'identification de la définition du processus. Affichez la clé du processus via la vue des propriétés.
Spécifiez le responsable de la tâche.
Dans la vue des propriétés, spécifiez la personne en charge de chaque nœud de tâche. Pour Par exemple, la personne chargée de remplir la
demande de voyage d'affaires est le directeur de Zhangsan. Jerry
est le directeur général et la personne en charge de l'approbation est Jack.
La personne en charge de l'approbation financière est Rose.
6. Fonctionnement du processus
6.1 Définition du processus
Vue d'ensemble
La définition du processus consiste à décrire le processus métier hors ligne selon la norme bpmn2.0.Habituellement, le plug - in dans l'idée est utilisé pour modéliser le processus métier.
Utilisez le concepteur sous idée pour dessiner le processus et deux fichiers seront générés : les
fichiers .bpmn et .png.bpmn
. Utilisez activiti-desinger pour concevoir les processus métier et les fichiers .bpmn seront générés. Nous avons créé le fichier bpmn
BPMN. Racine 2.0 Le nœud est le nœud des définitions. Dans cet élément, plusieurs définitions de processus peuvent être définies (mais nous recommandons que chaque fichier ne contienne qu'une seule définition de processus
, ce qui peut simplifier la difficulté de maintenance pendant le processus de développement). Notez que l'élément definition doit contenir au moins les déclarations de xmlns et targetNamespace.
targetNamespace peut être n'importe quelle valeur, elle est utilisée pour classer l'instance de processus.
Partie définition du processus : définit la description de chaque nœud du processus et le flux de processus entre les nœuds.
Définition de la disposition du processus : définissez des informations telles que les coordonnées de position de chaque nœud du processus sur l'organigramme.
Comment générer des fichiers image .png
dans l'outil IDEA
1. Modifiez le suffixe du fichier en xml.
Tout d'abord, renommez le fichier evection.bpmn en evection.xml, comme indiqué dans la figure ci-dessous :
Le fichier bpmn avant la modification de evection.xml, l'effet est le suivant :
2. Utilisez le concepteur pour ouvrez le fichier .xml
au-dessus du fichier evection.xml, cliquez avec le bouton droit et sélectionnez le menu Diagrammes, puis sélectionnez Afficher BPMN2.0 Designer...
3. Affichez le fichier ouvert
Après l'ouverture, il y a des caractères tronqués, comme le montre la figure :
4. Résolvez les caractères chinois tronqués
1. Ouvrez Paramètres, recherchez Encodages de fichiers et définissez l'option d'encodage Choisissez UTF-8 pour
les deux. 2. Ouvrez le chemin d'installation d'IDEA et recherchez le répertoire d'installation suivant. Cela
dépend de la version que vous avez installée. . J'utilise idea 64 bits, ajoutez donc une commande à la dernière ligne du fichier idea64.exe.vmoptions :
-Dfile.encoding=UTF-8
est la suivante :
Attention à ne pas avoir d'espaces, sinon il ne s'ouvrira pas quand IDEA est redémarré, puis redémarrez IDEA.
Si la méthode ci-dessus a été effectuée et que des caractères tronqués apparaissent toujours, modifiez un autre fichier et ajoutez : -Dfile.encoding=UTF-8 à la fin du fichier, puis relancez l'
idée, comme indiqué sur la figure :
Enfin, cliquez sur l'évocation .xml à nouveau Cliquez avec le bouton droit et sélectionnez le menu Diagrammes, puis sélectionnez Afficher BPMN2.0 Designer... pour voir l'image générée,
comme indiqué dans la figure :
5. Exporter sous forme de fichier image
Cliquez sur la petite icône de Exporter vers un fichier pour ouvrir la fenêtre suivante, faites attention à remplir le nom et l'extension du fichier, et choisissez l'emplacement pour enregistrer l'image : Ensuite,
nous copions le fichier png dans le répertoire bpmn sous ressources, et renommez evection.xml vers evection.bpmn.
6.2 Présentation du déploiement de la définition de processus
Le déploiement du processus défini ci-dessus dans le concepteur vers la base de données d'activités est un déploiement de définition de processus.
Ajoutez et déployez les fichiers bpmn et png de la définition de processus pour les activer un par un en appelant l'API d'activiti, ou regroupez les deux fichiers dans un package zip
pour le déploiement.
Méthode de déploiement de fichier unique
Déployez les fichiers bpmn et les fichiers image png séparément.
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.RepositoryService;
import org.activiti.engine.repository.Deployment;
import org.junit.Test;
public class ActivitiDemo {
/**
* 部署流程定义
*/
@Test
public void testDeployment(){
// 1、创建ProcessEngine
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// 2、得到RepositoryService实例
RepositoryService repositoryService = processEngine.getRepositoryService();
// 3、使用RepositoryService进行部署
Deployment deployment = repositoryService.createDeployment()
.addClasspathResource("bpmn/evection.bpmn") // 添加bpmn资源
.addClasspathResource("bpmn/evection.png") // 添加png资源
.name("出差申请流程")
.deploy();
// 4、输出部署信息
System.out.println("流程部署id：" + deployment.getId());
System.out.println("流程部署名称：" + deployment.getName());
}
}
Après avoir effectué cette opération, activiti enregistrera le fichier bpm et le fichier image spécifiés dans le code ci-dessus dans la base de données d'activiti.
Méthode de déploiement du package compressé
Compressez event.bpmn et event.png dans un package zip.
@Test
public void deployProcessByZip() {
// 定义zip输入流
InputStream inputStream = this
.getClass()
.getClassLoader()
.getResourceAsStream(
"bpmn/evection.zip");
ZipInputStream zipInputStream = new ZipInputStream(inputStream);
// 获取repositoryService
RepositoryService repositoryService = processEngine
.getRepositoryService();
// 流程部署
Deployment deployment = repositoryService.createDeployment()
.addZipInputStream(zipInputStream)
.deploy();
System.out.println("流程部署id：" + deployment.getId());
System.out.println("流程部署名称：" + deployment.getName());
}
Après avoir effectué cette opération, activiti enregistrera le fichier bpm et le fichier image spécifiés dans le code ci-dessus dans la base de données d'activiti.
Table de données d'opération
Les 3 tables pour les activités d'exploitation après le déploiement de la définition de processus sont les suivantes :
table de déploiement de définition de processus act_re_deployment, ajouter un enregistrement pour chaque déploiement
table de définition de processus act_re_procdef, déployer chaque nouvelle définition de processus ajoutera un enregistrement à cette table
processus act_ge_bytearray table des ressources
Ensuite, regardons quelles données sont écrites :
SELECT * FROM act_re_deployment #流程定义部署表，记录流程部署信息
SELECT * FROM act_re_procdef #流程定义表，记录流程定义信息
Résultat :
Notez que le champ KEY est un mot-clé utilisé pour identifier de manière unique différents processus.
SELECT * FROM act_ge_bytearray #资源表
Résultat :
Notez que le champ KEY est un mot-clé utilisé pour identifier de manière unique différents processus.
SELECT * FROM act_ge_bytearray #资源表
Remarque :
Il existe une relation un-à-plusieurs entre act_re_deployment et act_re_procdef. Un déploiement génère un enregistrement dans la table de déploiement de processus, mais un déploiement peut déployer plusieurs définitions de processus,
et chaque définition de processus génère un enregistrement dans la table de définition de processus. Chaque définition de processus aura deux enregistrements de ressources dans act_ge_bytearray, bpmn
et png.
Suggestion : Déployez un processus à la fois, afin que la table de déploiement et la table de définition de processus aient une relation un-à-un, ce qui est pratique pour lire les informations de déploiement et de définition de processus.
6.3 Démarrer l'instance de processus
Une fois la définition de processus déployée dans Activiti, le processus métier peut être géré via le workflow, c'est-à-dire que le processus de demande de déplacement professionnel déployé ci-dessus peut être utilisé.
1 SELECT * FROM act_re_deployment #Table de déploiement de définition de processus, enregistrer les informations de déploiement de processus
1 SELECT * FROM act_re_procdef #Table de définition de processus, enregistrer les informations de définition de processus
1 SELECT * FROM act_ge_bytearray #Table de ressources
Pour ce processus, démarrer un processus signifie lancer un nouveau voyage d'affaires Formulaire de candidature, qui équivaut à la relation entre une classe Java et un objet Java. Une fois la classe définie, vous devez créer
un objet avec new. Bien sûr, vous pouvez créer plusieurs objets. Pour le processus de demande de voyage d'affaires, Zhang San doit démarrer une
instance de processus lorsqu'il lance un formulaire de demande de voyage d'affaires, et une instance de processus doit être démarrée lorsqu'un formulaire de demande de voyage d'affaires lance une commande de voyage d'affaires.
le code s'affiche comme ci-dessous :
/**
* 启动流程实例
*/
@Test
public void testStartProcess(){
// 1、创建ProcessEngine
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// 2、获取RunTimeService
RuntimeService runtimeService = processEngine.getRuntimeService();
// 3、根据流程定义Id启动流程
ProcessInstance processInstance = runtimeService
.startProcessInstanceByKey("myEvection");
// 输出内容
System.out.println("流程定义id：" + processInstance.getProcessDefinitionId());
System.out.println("流程实例id：" + processInstance.getId());
System.out.println("当前活动Id：" + processInstance.getActivityId());
}
Table de données d'opération
act_hi_actinst historique d'exécution de l'instance
de processus act_hi_identitylink informations historiques sur l'utilisateur participant
au processus act_hi_procinst informations historiques sur l'instance
de processus act_hi_taskint informations historiques sur la tâche
de processus act_ru_execution informations sur l'exécution
du processus act_ru_identitylink informations sur l'utilisateur participant au processus
act_ru_task informations sur la tâche
6.4 Requête de tâche
Une fois le processus démarré, la personne en charge de la tâche peut interroger les tâches qu'il doit traiter actuellement, et les tâches interrogées sont toutes des tâches à effectuer de l'utilisateur.
/**
* 查询当前个人待执行的任务
*/
@Test
public void testFindPersonalTaskList() {
// 任务负责人
String assignee = "zhangsan";
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// 创建TaskService
TaskService taskService = processEngine.getTaskService();
// 根据流程key 和 任务负责人 查询任务
List<Task> list = taskService.createTaskQuery()
.processDefinitionKey("myEvection") //流程Key
.taskAssignee(assignee)//只查询该任务负责人的任务
.list();
for (Task task : list) {
System.out.println("流程实例id：" + task.getProcessInstanceId());
System.out.println("任务id：" + task.getId());
System.out.println("任务负责人：" + task.getAssignee());
System.out.println("任务名称：" + task.getName());
}
}
Le résultat est le suivant :
流程实例id：2501
任务id：2505
任务负责人：zhangsan
任务名称：创建出差申请
6.5 Traitement des tâches de processus
Le responsable de la tâche interroge les tâches en attente, sélectionne les tâches à traiter et termine les tâches.
// 完成任务
@Test
public void completTask(){
// 获取引擎
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// 获取taskService
TaskService taskService = processEngine.getTaskService();
// 根据流程key 和 任务的负责人 查询任务
// 返回一个任务对象
Task task = taskService.createTaskQuery()
.processDefinitionKey("myEvection") //流程Key
.taskAssignee("zhangsan") //要查询的负责人
.singleResult();
// 完成任务,参数：任务id
taskService.complete(task.getId());
}
6.6 Requête d'informations sur la définition du processus
Interroger les informations relatives au processus, y compris la définition du processus, le déploiement du processus et la version de la définition du processus
/**
* 查询流程定义
*/
@Test
public void queryProcessDefinition(){
// 获取引擎
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// repositoryService
RepositoryService repositoryService = processEngine.getRepositoryService();
// 得到ProcessDefinitionQuery 对象
ProcessDefinitionQuery processDefinitionQuery =
repositoryService.createProcessDefinitionQuery();
// 查询出当前所有的流程定义
// 条件：processDefinitionKey =evection
// orderByProcessDefinitionVersion 按照版本排序
// desc倒叙
// list 返回集合
List<ProcessDefinition> definitionList =
processDefinitionQuery.processDefinitionKey("myEvection")
.orderByProcessDefinitionVersion()
.desc()
.list();
// 输出流程定义信息
for (ProcessDefinition processDefinition : definitionList) {
System.out.println("流程定义 id="+processDefinition.getId());
System.out.println("流程定义 name="+processDefinition.getName());
System.out.println("流程定义 key="+processDefinition.getKey());
System.out.println("流程定义 Version="+processDefinition.getVersion());
System.out.println("流程部署ID ="+processDefinition.getDeploymentId());
}
}
Résultat de sortie :
6.7 Suppression du processus
public void deleteDeployment() {
// 流程部署id
String deploymentId = "1";
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// 通过流程引擎获取repositoryService
RepositoryService repositoryService = processEngine
.getRepositoryService();
//删除流程定义，如果该流程定义已有流程实例启动则删除时出错
repositoryService.deleteDeployment(deploymentId);
//设置true 级联删除流程定义，即使该流程有流程实例启动也可以删除，设置为false非级别删除方式，如果流
程
//repositoryService.deleteDeployment(deploymentId, true);
}
illustrer:
- Utilisez le référentielService pour supprimer la définition de processus et les informations de la table d'historique ne seront pas supprimées
- S'il n'y a aucun processus en cours d'exécution sous la définition du processus, il peut être supprimé normalement.
S'il existe un processus déjà en cours d'exécution sous la définition de processus, utilisez la suppression commune pour signaler une erreur et utilisez la méthode de suppression en cascade pour supprimer tous les processus et les enregistrements associés.
Supprimez d'abord les nœuds de processus inachevés, puis supprimez complètement les informations de définition de processus.
L'opération de suppression en cascade dans le développement de projets n'est généralement ouverte qu'aux super-administrateurs.
6.8 Téléchargement des ressources de processus
Maintenant que nos fichiers de ressources de processus ont été téléchargés dans la base de données, si d'autres utilisateurs souhaitent afficher ces fichiers de ressources, ils peuvent télécharger les fichiers de ressources de la base de données vers le
local.
Les solutions sont :
1. jdbc lit les données de type blob et de type clob et les enregistre dans le répertoire de fichiers
2. Utilisez l'API d'activiti pour l'implémenter.
Utilisez commons-io.jar pour résoudre l'opération d'E/S.
Introduisez le package de dépendances commons-io.
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.6</version>
</dependency>
Obtenez des ressources de définition de processus via des objets de définition de processus, obtenez bpmn et png
@Test
public void deleteDeployment(){
// 获取引擎
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// 获取repositoryService
RepositoryService repositoryService = processEngine.getRepositoryService();
// 根据部署id 删除部署信息,如果想要级联删除，可以添加第二个参数，true
repositoryService.deleteDeployment("1");
}
public void queryBpmnFile() throws IOException {
// 1、得到引擎
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// 2、获取repositoryService
RepositoryService repositoryService = processEngine.getRepositoryService();
// 3、得到查询器：ProcessDefinitionQuery，设置查询条件,得到想要的流程定义
ProcessDefinition processDefinition =
repositoryService.createProcessDefinitionQuery()
.processDefinitionKey("myEvection")
.singleResult();
// 4、通过流程定义信息，得到部署ID
String deploymentId = processDefinition.getDeploymentId();
// 5、通过repositoryService的方法，实现读取图片信息和bpmn信息
// png图片的流
InputStream pngInput = repositoryService.getResourceAsStream(deploymentId,
processDefinition.getDiagramResourceName());
// bpmn文件的流
InputStream bpmnInput = repositoryService.getResourceAsStream(deploymentId,
processDefinition.getResourceName());
// 6、构造OutputStream流
File file_png = new File("d:/evectionflow01.png");
File file_bpmn = new File("d:/evectionflow01.bpmn");
FileOutputStream bpmnOut = new FileOutputStream(file_bpmn);
FileOutputStream pngOut = new FileOutputStream(file_png);
// 7、输入流，输出流的转换
IOUtils.copy(pngInput,pngOut);
IOUtils.copy(bpmnInput,bpmnOut);
// 8、关闭流
pngOut.close();
bpmnOut.close();
pngInput.close();
bpmnInput.close();
}
illustrer:
- déploiementId est l'ID de déploiement du processus
- resource_name est la valeur de la colonne NAME_ dans la table act_ge_bytearray
- Utilisez la méthode getDeploymentResourceNames de depositService pour obtenir les noms de tous les fichiers sous le déploiement spécifié
Utilisez la méthode getResourceAsStream de depositService pour transmettre l'ID de déploiement et le nom de l'image de ressource afin d'obtenir le flux d'entrée du fichier portant le nom spécifié sous le déploiement et
enfin afficher la ressource d'image dans le flux d'entrée.
6.9 Afficher les informations de l'historique du processus
Même si la définition du processus a été supprimée, les informations historiques de l'exécution du processus sont toujours stockées dans les tables d'activités associées act_hi_* via l'analyse précédente. Par conséquent, nous
pouvons toujours interroger les informations historiques sur l'exécution du processus et afficher les enregistrements historiques associés via HistoryService.
/**
* 查看历史信息
*/
@Test
public void findHistoryInfo(){
// 获取引擎
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// 获取HistoryService
HistoryService historyService = processEngine.getHistoryService();
// 获取 actinst表的查询对象
HistoricActivityInstanceQuery instanceQuery =
historyService.createHistoricActivityInstanceQuery();
// 查询 actinst表，条件：根据 InstanceId 查询
// instanceQuery.processInstanceId("2501");
// 查询 actinst表，条件：根据 DefinitionId 查询
instanceQuery.processDefinitionId("myEvection:1:4");
// 增加排序操作,orderByHistoricActivityInstanceStartTime 根据开始时间排序 asc 升序
instanceQuery.orderByHistoricActivityInstanceStartTime().asc();
// 查询所有内容
List<HistoricActivityInstance> activityInstanceList = instanceQuery.list();
// 输出
for (HistoricActivityInstance hi : activityInstanceList) {
System.out.println(hi.getActivityId());
System.out.println(hi.getActivityName());
System.out.println(hi.getProcessDefinitionId());
System.out.println(hi.getProcessInstanceId());
System.out.println("<==========================>");
}
}