Activiti advanced
1. Prozessinstanz
Was ist eine Prozessinstanz?
Die Prozessinstanz (ProcessInstance) stellt die Ausführungsinstanz der Prozessdefinition dar.
Eine Prozessinstanz umfasst alle laufenden Knoten. Wir können dieses Objekt verwenden, um den Fortschritt der aktuellen Prozessinstanz und andere Informationen zu verstehen.
Beispiel: Ein Benutzer oder ein Programm initiiert einen Prozess gemäß dem Inhalt der Prozessdefinition, bei der es sich um eine Prozessinstanz handelt.
Diagramm der Prozessdefinition und der Prozessinstanz:
Starten Sie die Prozessinstanz, fügen Sie die
Prozessdefinition Businesskey (Geschäftsidentifikation) hinzu und stellen Sie sie in activiti bereit. Sie können die Ausführung des Prozesses über activiti im System verwalten, und der Ausführungsprozess stellt eine Ausführung dar Verfahren.
Wenn beispielsweise nach der Bereitstellung des Geschäftsreiseprozesses des Systems ein Benutzer eine Geschäftsreise beantragen möchte, muss dieser Prozess ausgeführt werden. Wenn ein anderer Benutzer ebenfalls eine Geschäftsreise beantragen möchte,
muss Jede Ausführung beeinflusst sich nicht gegenseitig und jede Ausführung ist unabhängig. Prozessinstanz.
Beim Starten einer Prozessinstanz speichert der angegebene Geschäftsschlüssel den Geschäftsschlüssel in der Ausführungstabelle der act_ru_execution #Prozessinstanz.
Geschäftsschlüssel: Geschäftskennung, normalerweise der Primärschlüssel der Geschäftstabelle, und die Geschäftskennung entspricht nacheinander der Prozessinstanz. Die Geschäftskennung stammt aus dem Geschäftssystem. Durch das Speichern der Geschäftskennung
werden die Daten des Geschäftssystems entsprechend der Geschäftskennung verknüpft und abgefragt.
Wenn beispielsweise der Geschäftsreiseprozess eine Prozessinstanz startet, kann die ID der Geschäftsreise in activiti als Geschäftskennung gespeichert werden. In Zukunft kann die ID der Geschäftsreise durch Abfragen der Prozessinstanzinformationen von activiti gespeichert werden erhalten, und dann kann die Geschäftssystemdatenbank korreliert werden, um die Geschäftsreiseinformationen zu erhalten
.
/**
* 启动流程实例，添加businessKey
*/
@Test
public void addBusinessKey(){
// 1、得到ProcessEngine
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// 2、得到RunTimeService
RuntimeService runtimeService = processEngine.getRuntimeService();
// 3、启动流程实例，同时还要指定业务标识businessKey，也就是出差申请单id，这里是1001
ProcessInstance processInstance = runtimeService.
startProcessInstanceByKey("myEvection","1001");
// 4、输出processInstance相关属性
System.out.println("业务id=="+processInstance.getBusinessKey());
}
Act_ru_execution von Activiti speichert Geschäftskennungen:
Betreiben Sie die Datenbanktabelle,
um die Prozessinstanz zu starten, und bedienen Sie die folgende Datenbanktabelle:
SELECT * FROM act_ru_execution #Prozessinstanzausführungstabelle, die den Ausführungsstatus der aktuellen Prozessinstanz aufzeichnet.
Hinweis:
Wenn die Prozessinstanz vorhanden ist Wird ausgeführt, wenn derzeit nur ein Zweig vorhanden ist. Eine Prozessinstanz hat nur einen Datensatz und die Primärschlüssel-ID der Ausführungstabelle ist mit der Prozessinstanz-ID identisch. Wenn
derzeit , und es gibt Datensätze, deren Primärschlüssel der Ausführungstabelle sich von der Prozessinstanz-ID unterscheidet . Unabhängig davon, wie viele Zweige derzeit vorhanden sind,
wird es immer einen Datensatz geben, dessen Primärschlüssel mit der Prozessinstanz-ID übereinstimmt. Nach der
Ausführung einer Prozessinstanz werden die mit der Prozessinstanz verknüpften Datensätze in dieser Tabelle gelöscht.
SELECT * FROM act_ru_task #Task-Ausführungstabelle, zeichnet die aktuell ausgeführten Aufgaben auf.
Beschreibung: Starten Sie die Prozessinstanz. Der Prozess wird derzeit auf dem ersten Task-Knoten ausgeführt. Diese Tabelle fügt einen Datensatz ein, um die Ausführung der aktuellen Aufgabe anzugeben, wenn die Aufgabe ausgeführt wird
Ist der Vorgang abgeschlossen, wird die Aufzeichnung gelöscht.
SELECT * FROM act_ru_identitylink #Task-Teilnehmer, notieren Sie den Benutzer oder die Gruppe, die derzeit an der Aufgabe teilnimmt.
SELECT * FROM act_hi_procinst #Prozessinstanz-Verlaufstabelle. Wenn die Prozessinstanz
startet, wird ein Datensatz in diese Tabelle eingefügt und der Datensatz der ausgeführten Prozessinstanz Abschluss wird nicht gelöscht.
SELECT * FROM act_hi_taskinst #Aufgabenverlaufstabelle, alle Aufgaben aufzeichnen
Starten Sie eine Aufgabe, fügen Sie nicht nur einen Datensatz in die Tabelle act_ru_task ein, sondern auch einen Datensatz in die historische Aufgabentabelle. Der Primärschlüssel der Aufgabenverlaufstabelle ist die Aufgaben-ID. und der Datensatz in dieser Tabelle wird nicht gelöscht, wenn
die Aufgabe abgeschlossen ist .
SELECT * FROM act_hi_actinst #Aktivitätsverlaufstabelle, in der alle Aktivitäten aufgezeichnet werden. Zu den
Aktivitäten gehören Aufgaben. Daher zeichnet diese Tabelle nicht nur Aufgaben auf, sondern auch andere Aktivitäten während der Prozessausführung, z. B. Startereignisse und Endereignisse.
Prozessinstanz abfragen
Während der Ausführung des Prozesses können Sie den Status der Prozessinstanz, den aktuell ausgeführten Knoten und andere Informationen abfragen.
@Test
public void queryProcessInstance() {
// 流程定义key
String processDefinitionKey = "evection";
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// 获取RunTimeService
RuntimeService runtimeService = processEngine.getRuntimeService();
List<ProcessInstance> list = runtimeService
.createProcessInstanceQuery()
.processDefinitionKey(processDefinitionKey)//
.list();
for (ProcessInstance processInstance : list) {
System.out.println("----------------------------");
System.out.println("流程实例id："
+ processInstance.getProcessInstanceId());
System.out.println("所属流程定义id："
+ processInstance.getProcessDefinitionId());
System.out.println("是否执行完成：" + processInstance.isEnded());
System.out.println("是否暂停：" + processInstance.isSuspended());
System.out.println("当前活动标识：" + processInstance.getActivityId());
}
}
Zugehörige BusinessKey-
Anforderungen:
In der tatsächlichen Anwendung von activiti werden möglicherweise einige relevante Informationen des Geschäftssystems angezeigt, wenn die Liste der Prozessinstanzen abgefragt wird. Beispiel: Bei der Abfrage der Liste der aktuell ausgeführten Geschäftsreiseprozesse muss der Name der Geschäftsreise angezeigt werden , die Anzahl der Geschäftsreisetage und die Anzahl der Geschäftsreisetage.
Solche Informationen sind im Geschäftssystem vorhanden, jedoch nicht in der Aktivitätsdatenbank
. Daher ist es nicht möglich, die Anzahl der Geschäftsreisetage und andere Informationen abzufragen die Activiti-API.
Realisierung:
Bei der Abfrage der Prozessinstanz wird der Geschäftsschlüssel (Geschäftskennung) verwendet, um die Geschäftsreisetabelle des Geschäftssystems zuzuordnen und abzufragen sowie die Anzahl der Geschäftsreisetage und andere Informationen abzufragen.
Der von der entsprechenden Instanz in activiti gespeicherte Geschäftsschlüssel kann über den folgenden Code abgerufen werden. Und dieser Geschäftsschlüssel speichert im Allgemeinen den Primärschlüssel der zugehörigen Geschäftsbetriebstabelle
und fragt dann die Geschäftsinformationen über die Primärschlüssel-ID ab, z. B. um weitere Urlaubsinformationen abzufragen (Geschäftsreisender, Geschäftsreisezeit, Geschäftstage
, Geschäftsreiseziel usw.). .)
String businessKey = processInstance.getBusinessKey();
In der Tabelle act_ru_execution von activiti wird das Feld BUSINESS_KEY zum Speichern des Geschäftsschlüssels verwendet.
Prozessinstanzen anhalten und aktivieren
In manchen Fällen kann es aufgrund von Prozessänderungen erforderlich sein, den aktuell laufenden Prozess anzuhalten, anstatt ihn direkt zu löschen. Nachdem der Prozess angehalten wurde, wird er nicht weiter ausgeführt.
Alle Prozessinstanzen werden angehalten.
Der Betriebsprozess ist als angehaltener Zustand definiert, und alle Prozessinstanzen unter der Prozessdefinition sind angehalten: Die Prozessdefinition ist angehalten
und die Prozessdefinition lässt nicht zu, dass neue Prozessinstanzen gestartet werden Gleichzeitig werden alle Prozesse unter der Prozessdefinition Alle Instanzen werden angehalten, um die Ausführung anzuhalten
.
/**
* 全部流程实例挂起与激活
*/
@Test
public void SuspendAllProcessInstance(){
// 获取processEngine
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// 获取repositoryService
RepositoryService repositoryService = processEngine.getRepositoryService();
// 查询流程定义的对象
ProcessDefinition processDefinition =
repositoryService.createProcessDefinitionQuery().
processDefinitionKey("myEvection").
singleResult();
// 得到当前流程定义的实例是否都为暂停状态
boolean suspended = processDefinition.isSuspended();
// 流程定义id
String processDefinitionId = processDefinition.getId();
// 判断是否为暂停
if(suspended){
// 如果是暂停，可以执行激活操作 ,参数1 ：流程定义id ，参数2：是否激活，参数3：激活时间
repositoryService.activateProcessDefinitionById(processDefinitionId,
true,
null
);
System.out.println("流程定义："+processDefinitionId+",已激活");
}else{
// 如果是激活状态，可以暂停，参数1 ：流程定义id ，参数2：是否暂停，参数3：暂停时间
repositoryService.suspendProcessDefinitionById(processDefinitionId,
true,
null);
System.out.println("流程定义："+processDefinitionId+",已挂起");
}
}
Aussetzung einer einzelnen Prozessinstanz:
Betreiben Sie das Prozessinstanzobjekt, um den Aussetzungsvorgang für einen einzelnen Prozess auszuführen. Wenn eine Prozessinstanz angehalten wird, wird der Prozess nicht weiter ausgeführt und es wird eine
Ausnahme gemeldet, wenn die aktuelle Aufgabe der Prozessinstanz ausgeführt wird abgeschlossen.
/**
* 单个流程实例挂起与激活
*/
@Test
public void SuspendSingleProcessInstance(){
// 获取processEngine
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// RuntimeService
RuntimeService runtimeService = processEngine.getRuntimeService();
// 查询流程定义的对象
ProcessInstance processInstance = runtimeService.
createProcessInstanceQuery().
processInstanceId("15001").
singleResult();
// 得到当前流程定义的实例是否都为暂停状态
boolean suspended = processInstance.isSuspended();
// 流程定义id
String processDefinitionId = processInstance.getId();
// 判断是否为暂停
if(suspended){
// 如果是暂停，可以执行激活操作 ,参数：流程定义id
runtimeService.activateProcessInstanceById(processDefinitionId);
System.out.println("流程定义："+processDefinitionId+",已激活");
}else{
// 如果是激活状态，可以暂停，参数：流程定义id
runtimeService.suspendProcessInstanceById( processDefinitionId);
System.out.println("流程定义："+processDefinitionId+",已挂起");
}
}
/**
* 测试完成个人任务
*/
@Test
public void completTask(){
// 获取引擎
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// 获取操作任务的服务 TaskService
TaskService taskService = processEngine.getTaskService();
// 完成任务,参数：流程实例id,完成zhangsan的任务
Task task = taskService.createTaskQuery()
.processInstanceId("15001")
.taskAssignee("rose")
.singleResult();
System.out.println("流程实例id="+task.getProcessInstanceId());
System.out.println("任务Id="+task.getId());
System.out.println("任务负责人="+task.getAssignee());
System.out.println("任务名称="+task.getName());
taskService.complete(task.getId());
}
2. Persönliche Aufgaben
2.1. Aufgabenleiter zuweisen
2.1.1. Feste Zuweisung
Geben Sie bei der Modellierung des Geschäftsprozesses einen festen Aufgabenleiter an, wie in der Abbildung dargestellt:
und füllen Sie in der Eigenschaftenansicht das Element Beauftragter als Aufgabenleiter aus.
2.1.2 Ausdruckszuweisung
Aufgrund der festen Zuweisungsmethode muss die Aufgabe nur Schritt für Schritt ausgeführt werden. Nach der Ausführung jeder Aufgabe wird der Aufgabenleiter gemäß der BPMN-Konfiguration zugewiesen.
2.1.2.1, UEL-Ausdruck
Activiti verwendet den UEL-Ausdruck, UEL ist Teil der Java EE6-Spezifikation, UEL (Unified Expression Language) ist eine einheitliche Ausdruckssprache,
Activiti unterstützt zwei UEL-Ausdrücke: UEL-Wert und UEL-Methode.
1) Definition des UEL-Werts Wie
in der Abbildung gezeigt: „
assignee“ ist eine Prozessvariable von activiti
oder auf diese Weise definiert:
Wie in der Abbildung gezeigt: „
user“ ist auch eine Prozessvariable von activiti, „user.assignee“ bedeutet, den Wert von zu erhalten Aufruf der Getter-Methode des Benutzers.
2) UEL-Methodenmethode
Wie in der Abbildung gezeigt:
userBean ist eine Bean im Spring-Container, was bedeutet, dass die getUserId()-Methode der Bean aufgerufen wird.
3) Kombination aus UEL-Methode und UEL-Wert
Ein weiteres Beispiel: ${ldapService.findManagerForEmployee(emp)} ldapService ist eine Bean des Spring-Containers,
findManagerForEmployee ist eine Methode der Bean, emp ist die Aktivierungsprozessvariable und emp wird als Parameter an
die Methode ldapService.findManagerForEmployee übergeben.
4) Sonstiges
Ausdrücke unterstützen das Parsen von Basistypen, Beans, Listen, Arrays und Karten und können auch als bedingte Beurteilungen verwendet werden. Wie folgt: ${order.price > 100 &&
order.price < 250}
2.1.2.2. Schreiben Sie den Code und konfigurieren Sie die verantwortliche Person
1) Definieren Sie die Prozessvariable für die Aufgabenzuweisung.
Wie in der Abbildung gezeigt:
2) Legen Sie die Prozessvariable fest
Legen Sie die Prozessvariable beim Starten der Prozessinstanz wie folgt fest:
/**
* 设置流程负责人
*/
@Test
public void assigneeUEL(){
// 获取流程引擎
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// 获取 RuntimeService
RuntimeService runtimeService = processEngine.getRuntimeService();
// 设置assignee的取值，用户可以在界面上设置流程的执行
Map<String,Object> assigneeMap = new HashMap<>();
assigneeMap.put("assignee0","张三");
assigneeMap.put("assignee1","李经理");
assigneeMap.put("assignee2","王总经理");
assigneeMap.put("assignee3","赵财务");
// 启动流程实例，同时还要设置流程定义的assignee的值
runtimeService.startProcessInstanceByKey("myEvection1",assigneeMap);
// 输出
System.out.println(processEngine.getName());
}
Nach erfolgreicher Ausführung können Sie die Daten in der Karte gerade in der Tabelle act_ru_variable
2.1.2.3 sehen. Vorsichtsmaßnahmen
Aufgrund der Verwendung der Ausdruckszuordnung muss sichergestellt werden, dass der Ausdruck während der Aufgabenausführung erfolgreich ausgeführt wird. Beispiel: Eine bestimmte Aufgabe verwendet den Ausdruck $ {order.price > 100
&& order.price < 250}. Wenn Sie diese Aufgabe ausführen, müssen Sie sicherstellen, dass order in der Prozessvariablen vorhanden ist, da sonst die Aktivität abnormal ist.
2.1.3. Listener-Zuweisung
Listener können zum Abschließen vieler Activiti-Prozesse verwendet werden.
In diesem Kapitel verwenden wir die Listener-Methode, um die verantwortliche Person anzugeben, sodass beim Entwerfen des Prozesses keine Angabe des Beauftragten erforderlich ist.
Der Task-Listener dient dazu, benutzerdefinierte Java-Logik oder -Ausdrücke auszuführen, wenn entsprechende aufgabenbezogene Ereignisse auftreten. Zu den aufgabenbezogenen Ereignissen gehören: Zu
den Ereignisoptionen gehören:
Erstellen: Wird nach der Aufgabenerstellung ausgelöst.
Zuweisung: Wird nach der Aufgabenzuweisung ausgelöst.
Löschen: Wird nach dem Abschluss der Aufgabe ausgelöst.
Alle: Wird ausgelöst, wenn alle Ereignisse eintreten
Definieren Sie die Task-Listener-Klasse. Die Klasse muss die Schnittstelle org.activiti.engine.delegate.TaskListener implementieren
public class MyTaskListener implements TaskListener {
@Override
public void notify(DelegateTask delegateTask) {
if(delegateTask.getName().equals("创建出差申请")&&
delegateTask.getEventName().equals("create")){
//这里指定任务负责人
delegateTask.setAssignee("张三");
}
}
}
Der Inhalt des DelegateTask-Objekts lautet wie folgt:
2.1.3.1. Vorsichtsmaßnahmen
Verwenden Sie die Listener-Zuweisungsmethode, um die Benachrichtigungsmethode der Abhörklasse gemäß dem Abhörereignis auszuführen. Wenn die Methode nicht normal ausgeführt werden kann, wirkt sich dies auch auf die Ausführung von aus die Aufgabe.
2.2. Aufgaben abfragen Der Code
zum Abfragen der zu erledigenden Aufgaben des Aufgabenverantwortlichen
lautet wie folgt:
// 查询当前个人待执行的任务
@Test
public void findPersonalTaskList() {
// 流程定义key
String processDefinitionKey = "myEvection1";
// 任务负责人
String assignee = "张三";
// 获取TaskService
TaskService taskService = processEngine.getTaskService();
List<Task> taskList = taskService.createTaskQuery()
.processDefinitionKey(processDefinitionKey)
.includeProcessVariables()
.taskAssignee(assignee)
.list();
for (Task task : taskList) {
System.out.println("----------------------------");
System.out.println("流程实例id： " + task.getProcessInstanceId());
System.out.println("任务id： " + task.getId());
System.out.println("任务负责人： " + task.getAssignee());
System.out.println("任务名称： " + task.getName());
}
}
Anforderungen für die Zuordnung von businessKey
: In der tatsächlichen Anwendung von activiti werden beim Abfragen von To-Do-Aufgaben möglicherweise einige relevante Informationen des Geschäftssystems angezeigt.
Beispiel: Um die Liste der zu genehmigenden Dienstreiseaufgaben abzufragen, ist es notwendig, Informationen wie das Datum des Dienstreiseauftrags und die Anzahl der Dienstreisetage anzuzeigen.
Informationen wie die Anzahl der Geschäftsreisen sind im Geschäftssystem vorhanden, jedoch nicht in der activiti-Datenbank, sodass Informationen wie die Anzahl der Geschäftsreisen nicht über die activiti-API abgefragt werden können
. Realisierung: Verwenden Sie beim Abfragen von Aufgaben den BusinessKey (Geschäftskennung), um das Geschäftsreiseformular des Geschäftssystems zu korrelieren und abzufragen und die
Anzahl der Geschäftsreisetage und andere Informationen abzufragen.
@Test
public void findProcessInstance(){
// 获取processEngine
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// 获取TaskService
TaskService taskService = processEngine.getTaskService();
// 获取RuntimeService
RuntimeService runtimeService = processEngine.getRuntimeService();
// 查询流程定义的对象
Task task = taskService.createTaskQuery()
.processDefinitionKey("myEvection1")
.taskAssignee("张三")
.singleResult();
// 使用task对象获取实例id
String processInstanceId = task.getProcessInstanceId();
// 使用实例id，获取流程实例对象
ProcessInstance processInstance = runtimeService.createProcessInstanceQuery()
.processInstanceId(processInstanceId)
.singleResult();
// 使用processInstance，得到 businessKey
String businessKey = processInstance.getBusinessKey();
System.out.println("businessKey=="+businessKey);
}
2.3 Bearbeitung von Aufgaben
Hinweis: In praktischen Anwendungen muss vor der Erledigung einer Aufgabe überprüft werden, ob die für die Aufgabe verantwortliche Person die Befugnis zur Bearbeitung der Aufgabe hat.
/**
* 完成任务，判断当前用户是否有权限
*/
@Test
public void completTask() {
//任务id
String taskId = "15005";
// 任务负责人
String assingee = "张三";
//获取processEngine
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// 创建TaskService
TaskService taskService = processEngine.getTaskService();
// 完成任务前，需要校验该负责人可以完成当前任务
// 校验方法：
// 根据任务id和任务负责人查询当前任务，如果查到该用户有权限，就完成
Task task = taskService.createTaskQuery()
.taskId(taskId)
.taskAssignee(assingee)
.singleResult();
if(task != null){
taskService.complete(taskId);
System.out.println("完成任务");
}
}
3. Prozessvariablen
3.1 Was sind Prozessvariablen
? Prozessvariablen spielen bei Aktivitäten eine sehr wichtige Rolle. Der Prozessbetrieb hängt manchmal von Prozessvariablen ab. Bei der Kombination von Geschäftssystemen und Aktivitäten sind Prozessvariablen unverzichtbar. Prozessvariablen sind
die Grundlage für Aktivitäten zur Verwaltung von Arbeitsabläufen .Variablen, die durch die Anforderungen des Managements festgelegt werden. Wenn beispielsweise das Antragsverfahren für eine Geschäftsreise im Umlauf ist und die Geschäftsreisetage
mehr als 3 Tage betragen, wird dies vom Geschäftsführer überprüft, andernfalls direkt vom Personal. Die Geschäftsreisetage können sein als Prozessvariable gesetzt und im Prozessablauf verwendet.
Hinweis: Obwohl Geschäftsdaten in Prozessvariablen gespeichert werden können, können Sie Prozessvariablen über die API von activiti abfragen, um Geschäftsdaten abzufragen.
Dies und activiti Prozessvariablen festlegt für Prozessausführungsanforderungen. erstellen.
3.2. Prozessvariablentyp
Wenn pojo in einer Prozessvariablen gespeichert wird, muss die Serialisierungsschnittstelle serialisierbar implementiert werden. Um eine Deserialisierung aufgrund neuer Felder zu verhindern,
muss serialVersionUID generiert werden.
3.3. Gültigkeitsbereich einer Prozessvariablen
Der Gültigkeitsbereich einer Prozessvariablen kann eine Prozessinstanz (processInstance), eine Aufgabe (task) oder eine Ausführungsinstanz (execution) sein.
3.3.1, Globa-
Variable Der Standardbereich einer Prozessvariablen ist ein Prozess Beispiel. Wenn der Gültigkeitsbereich einer Prozessvariablen eine Prozessinstanz ist, kann sie als globale Variable bezeichnet werden.
Hinweis:
Zum Beispiel: Globale Variablen: userId (Variablenname), zhangsan (Variablenwert)
Die Variablennamen in der globalen Variablen sind nicht zulässig wiederholt werden. Legen Sie Variablen mit demselben Namen fest. Der später festgelegte Wert überschreibt den zuvor festgelegten Variablenwert.
3.3.2. Lokale Variablen
Aufgaben und Ausführungsinstanzen gelten nur für einen Aufgaben- und einen Ausführungsinstanzbereich, und der Umfang ist nicht so groß wie die Prozessinstanz, daher werden sie als lokale Variablen bezeichnet.
Da sich der Umfang lokaler Variablen in verschiedenen Aufgaben oder verschiedenen Ausführungsinstanzen nicht gegenseitig beeinflusst, können die Variablennamen ohne Einfluss identisch sein. Der lokale Variablenname kann auch
mit dem globalen Variablennamen identisch sein, er hat jedoch keine Auswirkung.
3.4. Verwendung von Prozessvariablen
3.4.1. Verwendung von UEL-Ausdrücken für Attribute
Sie können UEL-Ausdrücke beim Beauftragten festlegen, und der Wert des Ausdrucks ist die für die Aufgabe verantwortliche Person, zum Beispiel: ${assignee}, Beauftragter ist a Prozessvariablenname
.
Activiti erhält den Wert des UEL-Ausdrucks, also den Wert der Prozessvariablen „assignee“, und weist den Wert von „assee“ als Verantwortlicher der Aufgabe zu
3.4.2. UEL-Ausdruck für die Verbindung verwenden
Sie können den UEL-Ausdruck für die Verbindung festlegen, um die Flussrichtung zu bestimmen.
Beispiel: ${price<10000}. Der Preis ist ein Prozessvariablenname und der Ergebnistyp des UE-Ausdrucks ist Boolean.
Wenn der UEL-Ausdruck wahr ist, muss die Richtung der Prozessausführung bestimmt werden.
3.5. Verwenden Sie globale Variablen, um den Prozess zu steuern.
3.5.1. Anforderungen.
Mitarbeiter erstellen ein Antragsformular für eine Geschäftsreise, das vom Abteilungsleiter überprüft wird. Nachdem der Abteilungsleiter die Geschäftsreise für 3 Tage oder weniger genehmigt hat, wird sie direkt
genehmigt durch die Finanzabteilung. Genehmigt durch die Finanzgenehmigung.
3.5.2. Prozessdefinition
1), die Verbindungsbedingung, dass die Anzahl der Geschäftsreisetage größer oder gleich 3 ist,
kann auch durch Objektparameter wie evection.num benannt werden:
2), die Verbindungsbedingung, dass die Anzahl der Die Geschäftsreisetage beträgt weniger als 3.
Sie können auch nach Objektparametern benannt werden, z. B.:
3.5. 3. Legen Sie die globale Prozessvariable fest.
Legen Sie die Prozessvariable fest, bevor sie vom Abteilungsleiter überprüft wird. Der Variablenwert ist die Geschäftsreiseinformation (einschließlich der Anzahl der Dienstreisen). Nach der Überprüfung kann der Abteilungsleiter
anhand des Wertes der Prozessvariablen die Prozessrichtung bestimmen.
Beim Festlegen der Prozessvariablen kann diese festgelegt werden, wenn der Prozess gestartet wird, oder sie kann festgelegt werden, wenn die Aufgabe bearbeitet wird.
3.5.3.1. POJO-Objekt erstellen
Erstellen Sie ein Pojo-Objekt für den Geschäftsreiseantrag
import java.io.Serializable;
import java.util.Date;
/**
* 出差申请 pojo
*/
public class Evection implements Serializable {
/**
* 主键id
*/
private Long id;
/**
* 出差申请单名称
*/
private String evectionName;
/**
* 出差天数
*/
private Double num;
/**
* 预计开始时间
*/
private Date beginDate;
/**
* 预计结束时间
*/
private Date endDate;
/**
* 目的地
*/
private String destination;
/**
* 出差事由
*/
private String reson;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getEvectionName() {
return evectionName;
}
public void setEvectionName(String evectionName) {
this.evectionName = evectionName;
}
public Date getBeginDate() {
return beginDate;
}
public void setBeginDate(Date beginDate) {
this.beginDate = beginDate;
}
public Date getEndDate() {
return endDate;
}
public void setEndDate(Date endDate) {
this.endDate = endDate;
}
public String getDestination() {
return destination;
}
public void setDestination(String destination) {
this.destination = destination;
}
public String getReson() {
return reson;
}
public void setReson(String reson) {
this.reson = reson;
}
public Double getNum() {
return num;
}
public void setNum(Double num) {
this.num = num;
}
}
3.5.3.2. Variablen beim Starten eines Prozesses festlegen
Wenn Sie einen Prozess starten, legen Sie eine Prozessvariable fest, und der Gültigkeitsbereich der Variablen ist die gesamte Prozessinstanz.
Legen Sie die Prozessvariable über Map<key,value> fest, und in der Karte können mehrere Variablen festgelegt werden. Der Schlüssel ist der Name der Prozessvariablen.
/**
* 启动流程实例,设置流程变量的值
*/
@Test
public void startProcess(){
// 获取流程引擎
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// 获取RunTimeService
RuntimeService runtimeService = processEngine.getRuntimeService();
// 流程定义key
String key = "myEvection2";
// 创建变量集合
Map<String, Object> map = new HashMap<>();
// 创建出差pojo对象
Evection evection = new Evection();
// 设置出差天数
evection.setNum(2d);
// 定义流程变量，把出差pojo对象放入map
map.put("evection",evection);
// 设置assignee的取值，用户可以在界面上设置流程的执行
map.put("assignee0","张三");
map.put("assignee1","李经理");
map.put("assignee2","王总经理");
map.put("assignee3","赵财务");
// 启动流程实例，并设置流程变量的值（把map传入）
ProcessInstance processInstance = runtimeService
.startProcessInstanceByKey(key, map);
// 输出
System.out.println("流程实例名称="+processInstance.getName());
System.out.println("流程定义id=="+processInstance.getProcessDefinitionId());
}
/**
* 完成任务，判断当前用户是否有权限
*/
@Test
public void completTask() {
//任务id
String key = "myEvection2";
// 任务负责人
String assingee = "张三";
//获取processEngine
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// 创建TaskService
TaskService taskService = processEngine.getTaskService();
// 完成任务前，需要校验该负责人可以完成当前任务
// 校验方法：
// 根据任务id和任务负责人查询当前任务，如果查到该用户有权限，就完成
Task task = taskService.createTaskQuery()
.processDefinitionKey(key)
.taskAssignee(assingee)
.singleResult();
if(task != null){
taskService.complete(task.getId());
System.out.println("任务执行完成");
}
}
Beschreibung: Der Umfang der
Prozessvariablen startProcessInstanceByKey (processDefinitionKey, Variablen) ist eine Prozessinstanz, und die Prozessvariable wird in einer Karte gespeichert. Der Schlüssel in der Variablenzuordnung derselben Prozessinstanz ist auf denselben Wert festgelegt, und letzterer hat Vorrang das Vorherige. 3.5.3.2. Variablen festlegen, wenn eine Aufgabe abgeschlossen ist . Legen Sie eine Prozessvariable fest, wenn eine Aufgabe abgeschlossen ist. Die Prozessvariable kann nur von anderen Knoten verwendet werden, nachdem die Aufgabe abgeschlossen ist. Ihr Geltungsbereich ist die gesamte Prozessinstanz Wenn die Prozessvariable gesetzt ist Wenn der Schlüssel mit demselben Namen bereits in der Prozessinstanz vorhanden ist, ersetzt die später festgelegte Variable die zuvor festgelegte Variable. Hier müssen Sie die Prozessvariable festlegen, wenn die Aufgabe zum Erstellen einer Geschäftsreise abgeschlossen ist
/**
* 完成任务，判断当前用户是否有权限
*/
@Test
public void completTask() {
//任务id
String key = "myEvection2";
// 任务负责人
String assingee = "张三";
// 获取processEngine
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// 创建TaskService
TaskService taskService = processEngine.getTaskService();
// 创建变量集合
Map<String, Object> map = new HashMap<>();
// 创建出差pojo对象
Evection evection = new Evection();
// 设置出差天数
evection.setNum(2d);
// 定义流程变量
map.put("evection",evection);
// 完成任务前，需要校验该负责人可以完成当前任务
// 校验方法：
// 根据任务id和任务负责人查询当前任务，如果查到该用户有权限，就完成
Task task = taskService.createTaskQuery()
.processDefinitionKey(key)
.taskAssignee(assingee)
.singleResult();
if(task != null){
//完成任务是，设置流程变量的值
taskService.complete(task.getId(),map);
System.out.println("任务执行完成");
}
}
Hinweis:
Um die Prozessvariable über die aktuelle Aufgabe festzulegen, muss die aktuelle Aufgaben-ID angegeben werden. Wenn die aktuell ausgeführte Aufgaben-ID nicht vorhanden ist, wird eine Ausnahme ausgelöst.
Bei der Verarbeitung von Aufgaben werden Prozessvariablen auch über map<key,value> festgelegt, und es können mehrere Variablen gleichzeitig festgelegt werden.
3.5.3.3. Festlegen über die aktuelle Prozessinstanz
Um die globale Variable über die Prozessinstanz-ID festzulegen, darf die Prozessinstanz nicht abgeschlossen sein.
@Test
public void setGlobalVariableByExecutionId(){
// 当前流程实例执行 id，通常设置为当前执行的流程实例
String executionId="2601";
// 获取processEngine
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// 获取RuntimeService
RuntimeService runtimeService = processEngine.getRuntimeService();
// 创建出差pojo对象
Evection evection = new Evection();
// 设置天数
evection.setNum(3d);
// 通过流程实例 id设置流程变量
runtimeService.setVariable(executionId, "evection", evection);
// 一次设置多个值
// runtimeService.setVariables(executionId, variables)
}
Hinweis:
„executionId“ muss die Ausführungs-ID der aktuell nicht abgeschlossenen Prozessinstanz sein. Normalerweise legt diese ID die ID der Prozessinstanz fest. Prozessvariablen können auch über runtimeService.getVariable() abgerufen werden
.
3.5.3.4, durch die aktuellen Aufgabeneinstellungen
@Test
public void setGlobalVariableByTaskId(){
//当前待办任务id
String taskId="1404";
// 获取processEngine
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
TaskService taskService = processEngine.getTaskService();
Evection evection = new Evection();
evection.setNum(3);
//通过任务设置流程变量
taskService.setVariable(taskId, "evection", evection);
//一次设置多个值
//taskService.setVariables(taskId, variables)
}
Hinweis:
Die Aufgaben-ID muss die aktuelle Aufgaben-ID sein, die in act_ru_task vorhanden ist. Wenn die Aufgabe beendet ist, wird ein Fehler gemeldet.
Die Prozessvariable kann auch über taskService.getVariable() abgerufen werden.
3.5.4. Test
Normaler Test:
Stellen Sie den Wert der Prozessvariablen auf größer oder gleich 3 Tage ein und
entwerfen Sie den Wert der Prozessvariablen auf weniger als 3 Tage.
Abnormaler Test:
Die Prozessvariable ist nicht vorhanden,
der Wert der Prozessvariablen ist leer NULL und der Wert des Preisattributs ist leer.
UEL-Ausdrücke stimmen nicht überein. Bedingungen
Bedingungen für das Nichtsetzen von Verbindungen
3.5.5, Hinweise
1. Wenn der Prozessvariablenname im UEL-Ausdruck nicht vorhanden ist, tritt ein Fehler auf wird gemeldet.
2. Wenn der Wert der Prozessvariablen im UEL-Ausdruck NULL ist, wird der Prozess nicht gemäß dem UEL-Ausdruck ausgeführt und der Prozess wird beendet.
3. Wenn keiner der UEL-Ausdrücke die Bedingungen erfüllt, endet der Prozess.
4. Wenn die Verbindung die Bedingungen nicht festlegt, folgt sie der Zeile mit der kleineren Flusssequenznummer.
3.5.6. Legen Sie die Prozessvariable in der Operation fest Datenbanktabelle
und fügen Sie einen Datensatz in die aktuelle Ausführungsprozessvariablentabelle ein und fügen Sie außerdem Datensätze in die historische Prozessvariablentabelle ein.
//Aktuelle Prozessvariablentabelle
SELECT * FROM act_ru_variable
Zeichnen Sie die Prozessvariablen auf, die von der aktuell ausgeführten Prozessinstanz verwendet werden können, einschließlich globaler und lokaler Variablen.
ID_: Primärschlüssel
Typ_: Variablentyp
Name_: Variablenname
Ausführungs-ID_: Die Ausführungs-ID der Prozessinstanz, zu der sie gehört, sowohl global als auch lokal Variablen speichern
Proc_inst_id_: die Prozessinstanz-ID, zu der sie gehört, globale und lokale Variablen speichern
Task_id_: die Task-ID, zu der sie gehören, lokale Variablen speichern
Bytearray_: Variable vom serialisierbaren Typ speichert die ID der entsprechenden act_ge_bytearray-Tabelle
Double_: Variablenwert vom Typ Double
Long_: Variablenwert vom langen Typ
Text_: Variablenwert vom Texttyp
#Historische Prozessvariablentabelle
SELECT * FROM act_hi_varinst
zeichnet alle erstellten Prozessvariablen auf, einschließlich globaler und lokaler Variablen.
Feldbedeutungen beziehen sich auf die aktuelle Prozessvariablentabelle.
3.6. Setzen lokaler Prozessvariablen
3.6.1.
Setzen während der Aufgabenbearbeitung Beim Setzen lokaler Prozessvariablen während der Aufgabenbearbeitung kann die aktuell laufende Prozessinstanz nur vor dem Ende der Aufgabe verwendet werden und die Variable kann nicht
in der aktuellen Prozessinstanz verwendet werden Nach dem Ende der Aufgabe können Sie eine historische Aufgabenabfrage abfragen.
/*
*处理任务时设置local流程变量
*/
@Test
public void completTask() {
//任务id
String taskId = "1404";
// 获取processEngine
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
TaskService taskService = processEngine.getTaskService();
// 定义流程变量
Map<String, Object> variables = new HashMap<String, Object>();
Evection evection = new Evection ();
evection.setNum(3d);
// 定义流程变量
Map<String, Object> variables = new HashMap<String, Object>();
// 变量名是holiday，变量值是holiday对象
variables.put("evection", evection);
// 设置local变量，作用域为该任务
taskService.setVariablesLocal(taskId, variables);
// 完成任务
taskService.complete(taskId);
}
Beschreibung:
Legen Sie die lokale Variable fest, deren Gültigkeitsbereich die Aufgabe ist, und jede Aufgabe kann eine Variable mit demselben Namen festlegen, ohne sich gegenseitig zu beeinflussen.
3.6.2, durch die aktuellen Aufgabeneinstellungen
@Test
public void setLocalVariableByTaskId(){
// 当前待办任务id
String taskId="1404";
// 获取processEngine
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
TaskService taskService = processEngine.getTaskService();
Evection evection = new Evection ();
evection.setNum(3d);
// 通过任务设置流程变量
taskService.setVariableLocal(taskId, "evection", evection);
// 一次设置多个值
//taskService.setVariablesLocal(taskId, variables)
}
Hinweis:
Die Aufgaben-ID muss die aktuelle Aufgaben-ID sein, die in act_ru_task vorhanden ist.
3.6.3. Lokaler Variablentest 1
Ist es möglich, die Einstellung der globalen Variablen im obigen Beispiel in eine lokale Variable zu ändern? Warum?
Lokale Variablen können in der aktuellen Prozessinstanzausführung nach Beendigung der Aufgabe nicht mehr verwendet werden und es wird ein Fehler gemeldet, wenn die Variable in nachfolgenden Prozessausführungen benötigt wird.
3.6.4, Lokaler Variablentest 2
Richten Sie lokale Variablen während der Überprüfung durch Abteilungsleiter, Generalmanager und Finanzen ein. Der Wert von Prozessvariablen kann
auch beim Abfragen jeder historischen Aufgabe über HistoryService abgefragt werden.
Code wie folgt anzeigen:
// 创建历史任务查询对象
HistoricTaskInstanceQuery historicTaskInstanceQuery =
historyService.createHistoricTaskInstanceQuery();
// 查询结果包括 local变量
historicTaskInstanceQuery.includeTaskLocalVariables();
for (HistoricTaskInstance historicTaskInstance : list) {
System.out.println("==============================");
System.out.println("任务id：" + historicTaskInstance.getId());
System.out.println("任务名称：" + historicTaskInstance.getName());
System.out.println("任务负责人：" + historicTaskInstance.getAssignee());
System.out.println("任务local变量："+ historicTaskInstance.getTaskLocalVariables());
}
Hinweis: Das Abfragen historischer Prozessvariablen, insbesondere das Abfragen von Pojo-Variablen, muss deserialisiert werden, was nicht empfohlen wird.
4. Gruppenaufgaben
4.1. Anforderungen
In der Prozessdefinition wird der Aufgabenleiter im Beauftragten des Aufgabenknotens festgelegt, und die Teilnehmer werden in der .bpmn-Datei festgelegt, wenn der Prozess definiert wird. Wenn
der temporäre , schlechte Skalierbarkeit des Systems.
Für diesen Fall können mehrere Kandidaten für die Aufgabe festgelegt werden und aus den Kandidaten können Teilnehmer ausgewählt werden, die die Aufgabe erledigen.
4.2. Aufgabenkandidaten festlegen
Legen Sie Kandidatenbenutzer (Kandidaten) in der Konfiguration der Aufgabenknoten im Flussdiagramm fest und trennen Sie mehrere Kandidaten durch Kommas.
BPMN-Datei anzeigen
<userTask activiti:candidateUsers="lisi,wangwu" activiti:exclusive="true" id="_3" name="经理审
批"/>
Wir können sehen, dass die Prüfer des Abteilungsleiters auf eine Gruppe von Kandidaten wie Lisi und Wangwu festgelegt wurden. Sie können
activiti:candiateUsers=“user 1, user 2, user 3“ verwenden, um eine Gruppe von Kandidaten festzulegen
4.3. Gruppenaufgaben
4.3.1. Prozess zur Bearbeitung von Gruppenaufgaben
a. Gruppenaufgaben
abfragen Geben Sie einen Kandidaten an und fragen Sie die aktuell ausstehenden Aufgaben des Kandidaten ab.
Kandidaten können Aufgaben nicht sofort bearbeiten.
b. Aufgaben übernehmen (beanspruchen)
Alle Kandidaten für diese Aufgabengruppe können beansprucht werden.
Machen Sie aus der Gruppenaufgabe des Kandidaten eine persönliche Aufgabe. Der ursprüngliche Kandidat wird zum Verantwortlichen für die Aufgabe.
Wenn Sie die Aufgabe nach der Übernahme nicht mehr erledigen möchten?
Es ist notwendig, die übernommenen persönlichen Aufgaben an die Gruppe zurückzugeben und die persönlichen Aufgaben in Gruppenaufgaben umzuwandeln.
c. Persönliche Aufgaben abfragen
Die Abfragemethode ist dieselbe wie beim Teil „Persönliche Aufgaben“, und die persönlichen Aufgaben, für die der Benutzer verantwortlich ist, werden entsprechend dem Beauftragten abgefragt.
d. Persönliche Aufgaben bearbeiten
4.3.2. Gruppenaufgaben abfragen
Gruppenaufgaben nach Kandidaten abfragen
@Test
public void findGroupTaskList() {
// 流程定义key
String processDefinitionKey = "evection3";
// 任务候选人
String candidateUser = "lisi";
// 获取processEngine
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// 创建TaskService
TaskService taskService = processEngine.getTaskService();
//查询组任务
List<Task> list = taskService.createTaskQuery()
.processDefinitionKey(processDefinitionKey)
.taskCandidateUser(candidateUser)//根据候选人查询
.list();
for (Task task : list) {
System.out.println("----------------------------");
System.out.println("流程实例id：" + task.getProcessInstanceId());
System.out.println("任务id：" + task.getId());
System.out.println("任务负责人：" + task.getAssignee());
System.out.println("任务名称：" + task.getName());
}
}
4.3.3 、 Gruppenaufgabe aufnehmen
Nachdem der Kandidat die Gruppenaufgabe übernommen hat, wird die Aufgabe zu seiner persönlichen Aufgabe.
@Test
public void claimTask(){
// 获取processEngine
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
TaskService taskService = processEngine.getTaskService();
//要拾取的任务id
String taskId = "6302";
//任务候选人id
String userId = "lisi";
//拾取任务
//即使该用户不是候选人也能拾取(建议拾取时校验是否有资格)
//校验该用户有没有拾取任务的资格
Task task = taskService.createTaskQuery()
.taskId(taskId)
.taskCandidateUser(userId)//根据候选人查询
.singleResult();
if(task!=null){
//拾取任务
taskService.claim(taskId, userId);
System.out.println("任务拾取成功");
}
}
Hinweis: Auch wenn der Benutzer kein Kandidat ist, kann er sie abholen. Es wird empfohlen, bei der Abholung zu prüfen, ob er qualifiziert ist. Nachdem
die Gruppenaufgabe abgeholt wurde, gibt es für die Aufgabe einen Verantwortlichen und die Aufgabe kann nicht über den Kandidaten abgefragt werden
4.3.4 Persönliche Aufgaben abfragen
Die Abfragemethode ist die gleiche wie bei der Abfrage persönlicher Aufgaben
@Test
public void findPersonalTaskList() {
// 流程定义key
String processDefinitionKey = "evection1";
// 任务负责人
String assignee = "zhangsan";
// 获取processEngine
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// 创建TaskService
TaskService taskService = processEngine.getTaskService();
List<Task> list = taskService.createTaskQuery()
.processDefinitionKey(processDefinitionKey)
.taskAssignee(assignee)
.list();
for (Task task : list) {
System.out.println("----------------------------");
System.out.println("流程实例id：" + task.getProcessInstanceId());
System.out.println("任务id：" + task.getId());
System.out.println("任务负责人：" + task.getAssignee());
System.out.println("任务名称：" + task.getName());
}
}
4.3.5. Persönliche Aufgaben erledigen
Das Gleiche gilt für persönliche Aufgaben
/*完成任务*/
@Test
public void completeTask(){
// 任务ID
String taskId = "12304";
// 获取processEngine
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
processEngine.getTaskService()
.complete(taskId);
System.out.println("完成任务："+taskId);
}
Hinweis: Es wird empfohlen, vor Abschluss der Aufgabe zu überprüfen, ob der Benutzer die für die Aufgabe verantwortliche Person ist.
4.3.6. Gruppenaufgabe zurückgeben
Wenn eine Einzelperson die Gruppenaufgabe nicht bearbeiten möchte, kann sie die Gruppenaufgabe zurückgeben. Nach der Rückkehr ist der Benutzer nicht mehr der Verantwortliche für die Aufgabe
/*
*归还组任务，由个人任务变为组任务，还可以进行任务交接
*/
@Test
public void setAssigneeToGroupTask() {
// 获取processEngine
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// 查询任务使用TaskService
TaskService taskService = processEngine.getTaskService();
// 当前待办任务
String taskId = "6004";
// 任务负责人
String userId = "zhangsan2";
// 校验userId是否是taskId的负责人，如果是负责人才可以归还组任务
Task task = taskService
.createTaskQuery()
.taskId(taskId)
.taskAssignee(userId)
.singleResult();
if (task != null) {
// 如果设置为null，归还组任务,该 任务没有负责人
taskService.setAssignee(taskId, null);
}
}
Hinweis: Es wird empfohlen, vor der Rückgabe der Aufgabe zu prüfen, ob der Benutzer für die Aufgabe verantwortlich ist. Die
Aufgabe kann auch über die setAssignee-Methode an andere Benutzer delegiert werden. Beachten Sie, dass der delegierte Benutzer möglicherweise kein Kandidat ist (dies ist der Fall). Die Verwendung dieser Methode wird nicht empfohlen.)
4.3.7 Aufgabenübergabe Bei der Aufgabenübergabe
übergibt der Aufgabenverantwortliche die Aufgabe an andere Kandidaten zur Bearbeitung der Aufgabe
@Test
public void setAssigneeToCandidateUser() {
// 获取processEngine
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// 查询任务使用TaskService
TaskService taskService = processEngine.getTaskService();
// 当前待办任务
String taskId = "6004";
// 任务负责人
String userId = "zhangsan2";
// 将此任务交给其它候选人办理该 任务
String candidateuser = "zhangsan";
// 校验userId是否是taskId的负责人，如果是负责人才可以归还组任务
Task task = taskService
.createTaskQuery()
.taskId(taskId)
.taskAssignee(userId)
.singleResult();
if (task != null) {
taskService.setAssignee(taskId, candidateuser);
}
}
4.3.8. Datenbanktabellenoperation
Fragen Sie die aktuelle Aufgabenausführungstabelle ab.
SELECT * FROM act_ru_task
Aufgabenausführungstabelle, um die aktuell ausgeführte Aufgabe aufzuzeichnen. Da es sich bei der Aufgabe derzeit um eine Gruppenaufgabe handelt, sind alle Beauftragten leer. Nach dem Aufnehmen der Aufgabe ist dieses Feld leer Die ID
des Benutzers wird vom
Aufgabenteilnehmer abgefragt.
SELECT * FROM act_ru_identitylink
vom Aufgabenteilnehmer, den aktuellen Referenzaufgabenbenutzer oder die aktuelle Aufgabengruppe aufzeichnen. Wenn ein Kandidat für die aktuelle Aufgabe festgelegt ist, wird ein Kandidatendatensatz in die Tabelle eingefügt, und wenn mehrere Kandidaten vorhanden sind , fügen Sie einige entsprechend
act_ru_identitylink ein
. Es gibt auch eine Verlaufstabelle act_hi_identitylink. Durch das Einfügen von Datensätzen in act_ru_identitylink werden auch
Datensätze in die Verlaufstabelle eingefügt. Auftrag erledigt
V. Gateway
Das Gateway wird zur Steuerung des Prozessflusses verwendet.
5.1 Exklusives Gateway
5.1.1 Was ist ein exklusives Gateway:
Ein exklusives Gateway wird zur Implementierung der Entscheidungsfindung im Prozess verwendet. Wenn der Prozess zu diesem Gateway ausgeführt wird, beurteilen alle Zweige, ob die Bedingung wahr ist, und wenn sie wahr ist, wird der Zweig ausgeführt
. Hinweis: Das exklusive Gateway wählt nur einen echten Zweig zur Ausführung aus. Wenn zwei Zweigbedingungen wahr sind, wählt das exklusive Gateway einen Zweig mit einem kleineren ID-Wert
zur Ausführung aus.
Warum ein exklusives Gateway verwenden?
Zweige können auch ohne exklusives Gateway implementiert werden, z. B.: Festlegen von Zweigbedingungen für die Bedingungsbedingungen der Verbindung.
Nachteile des Festlegens von Bedingungsbedingungen für die Verbindung: Wenn die Bedingungen nicht erfüllt sind, wird der Prozess (abnormal) beendet.
Wenn Sie ein exklusives Gateway verwenden, um die Richtung der Verzweigung zu bestimmen, gehen Sie wie folgt vor:
Wenn nicht alle Bedingungen der vom Gateway ausgehenden Leitung erfüllt sind, löst das System eine Ausnahme aus.
org.activiti.engine.ActivitiException: No outgoing sequence flow of the exclusive gateway
'exclusivegateway1' could be selected for continuing the process
at
org.activiti.engine.impl.bpmn.behavior.ExclusiveGatewayActivityBehavior.leave(ExclusiveGatewa
yActivityBehavior.java:85)
5.1.2 Prozessdefinition
Exklusiv-Gateway-Symbol im roten Feld:
5.1.3 Nachdem der Test
vom Abteilungsleiter überprüft wurde, gehen Sie zum Exklusiv-Gateway. Vom Exklusiv-Gateway gibt es zwei Zweige. Eine besteht darin, festzustellen, ob die Geschäftsreise erfolgt beträgt mehr als 3 Tage, und das andere ist: Bestimmen Sie
, ob die Anzahl der Geschäftsreisetage kleiner oder gleich 3 Tagen ist.
Wenn beim Festlegen von Verzweigungsbedingungen nicht alle Verzweigungsbedingungen wahr sind, wird ein Fehler gemeldet:
org.activiti.engine.ActivitiException: No outgoing sequence flow of the exclusive gateway
'exclusivegateway1' could be selected for continuing the process
at
org.activiti.engine.impl.bpmn.behavior.ExclusiveGatewayActivityBehavior.leave(ExclusiveGatewa
yActivityBehavior.java:85)
5.2 Parallel Gateway ParallelGateway
5.2.1 Was ist Parallel Gateway?
Parallel Gateway ermöglicht die Aufteilung des Prozesses in mehrere Zweige und die Zusammenführung mehrerer Zweige. Die Funktion des Parallel Gateways basiert auf dem ein- und ausgehenden Sequenzfluss: l fork
Zweig:
nach parallel Für alle ausgehenden Sequenzflüsse von wird für jeden Sequenzfluss ein gleichzeitiger Zweig erstellt.
l Konvergenz beitreten:
Alle eingehenden Zweige, die am parallelen Gateway ankommen, warten hier, bis alle in den sequentiellen Fluss eintretenden Zweige eintreffen, und der Fluss durchläuft das konvergente Gateway.
Beachten Sie, dass dasselbe parallele Gateway sowohl über Verzweigungs- als auch über Konvergenzfunktionen verfügt, wenn es über mehrere eingehende und ausgehende Sequenzflüsse verfügt. Zu diesem Zeitpunkt aggregiert das Gateway zunächst alle
eingehenden Sequenzflüsse und teilt sie dann in mehrere parallele Zweige auf.
Der Hauptunterschied zu anderen Gateways besteht darin, dass parallele Gateways keine Bedingungen analysieren. Auch wenn im Sequenzfluss eine Bedingung definiert ist, wird diese ignoriert.
Beispiel:
Erläuterung:
Der technische Manager und der Projektmanager sind zwei Ausführungszweige. In der Tabelle act_ru_execution gibt es zwei Datensätze, nämlich den technischen Manager und den Projektmanager, und in
act_ru_execution gibt es einen weiteren Datensatz, der die Prozessinstanz angibt.
Nachdem alle Aufgaben des technischen Managers und des Projektmanagers abgeschlossen sind, laufen sie am Konvergenzpunkt zusammen und passieren das parallele Gateway parallelGateway.
Parallele Gateways werden in Geschäftsanwendungen häufig für Gegensignierungsaufgaben eingesetzt, bei denen es sich um Aufgaben handelt, die von mehreren Teilnehmern gemeinsam bearbeitet werden.
5.2.2 Prozessdefinition
Parallel-Gateway-Symbol im roten Feld:
5.2.3 Test
Wenn die Ausführung die Parallel-Gateway-Datenbank erreicht, erfolgt die Verfolgung wie folgt:
Zusammenfassung: Alle Zweige erreichen den Konvergenzknoten und die Ausführung des Parallel-Gateways erfolgt vollendet.
5.3 Inclusive Gateway
5.3.1 Was ist Inclusive Gateway?
Inclusive Gateway kann als eine Kombination aus Exclusive Gateway und Parallel Gateway betrachtet werden.
Wie beim exklusiven Gateway können Sie Bedingungen für den ausgehenden Sequenzfluss definieren, und das enthaltende Gateway löst diese auf. Der Hauptunterschied besteht jedoch darin, dass Containment-Gateways
genau wie parallele Gateways mehr als einen Sequenzfluss auswählen können.
Die Funktionalität des enthaltenen Gateways basiert auf eingehenden und ausgehenden Sequenzflüssen:
l Verzweigung:
Alle ausgehenden Sequenzflussbedingungen werden aufgelöst und Sequenzflüsse, die zu „true“ führen, werden weiterhin parallel ausgeführt, und für jede Sequenz wird eine Verzweigung erstellt fließen.
l Konvergenz:
Wenn alle parallelen Zweige am enthaltenden Gateway ankommen, treten sie in einen Wartezustand ein, bis jeder Zweig, der in den Sequenzfluss eintritt und das Prozess-Token enthält, eintrifft. Dies ist
der größte Unterschied zu parallelen Gateways. Mit anderen Worten: Das enthaltende Gateway wartet nur auf eingehende Sequenzflüsse, die zur Ausführung ausgewählt wurden. Nach der Konvergenz wird der Fluss durch das enthaltende Gateway fortgesetzt
.
5.3.2 Prozessdefinition:
Der Dienstreiseantrag muss vom Projektleiter genehmigt werden, wenn er länger als oder gleich 3 Tage ist, und er muss vom technischen Leiter genehmigt werden, wenn er weniger als 3 Tage dauert. Der Dienstreiseantrag muss vom Projektleiter genehmigt werden vom Personalleiter genehmigt werden.
Enthält das Gateway-Symbol im roten Feld:
Hinweis: Legen Sie die Bedingung für die Verbindung jedes Zweigs fest, der das Gateway enthält.
5.3.3 Test
Wenn die Prozessvariable in den Bedingungen, die Gateway-Einstellungen umfassen, nicht vorhanden ist, wird ein Fehler gemeldet;
org.activiti.engine.ActivitiException: Unknown property used in expression:
${
evection.num>=3}
Die Prozessvariable evection.num muss beim Start des Prozesses festgelegt werden.
1) Wenn der Prozess den ersten erreicht, der das Gateway enthält, beurteilt er anhand der Bedingungen, welche Verzweigungen derzeit ausgeführt werden sollen:
Ausführungstabelle der Prozessinstanz: SELECT * FROM act_ru_execution
Der erste Datensatz: enthält den Gateway-Zweig.
Die letzten beiden Datensätze stellen zwei auszuführende Zweige dar:
ACT_ID = „_13“ stellt den Projektmanager Shenpin dar.
ACT_ID = „_5“ stellt die Genehmigung des Personalmanagers dar.
Aktuelle Aufgabentabelle: ACT_RU_TASK
. In der obigen Abbildung die Genehmigung des Projektmanagers und Nach Zustimmung des Personalleiters werden beide aktuellen Aufgaben parallel ausgeführt.
Wenn es eine Verzweigungsausführung gibt, die zuerst zum Zweig des konvergierenden Knotens geht, muss sie warten, bis andere Ausführungszweige zum konvergierenden Knoten gehen.
2) Führen Sie zuerst die Genehmigung des Projektmanagers aus und fragen Sie dann die aktuelle Aufgabentabelle ab: ACT_RU_TASK Die
aktuelle Aufgabe muss noch vom Personalmanager genehmigt werden.
Prozessinstanzausführungstabelle: SELECT * FROM act_ru_execution
stellt fest, dass der Zweig des Personalmanagers noch vorhanden ist und der Zweig des Projektmanagers den Knoten ACT_ID = _18 erreicht hat. Und ACT_ID=__18 ist das zweite enthaltene Gateway.
Da zu diesem Zeitpunkt zwei Zweige ausgeführt werden müssen, wartet das enthaltene Gateway auf die Konvergenz aller Zweige, bevor die Ausführung abgeschlossen werden kann.
3) Führen Sie die Genehmigung des Personalmanagers aus
und fragen Sie dann die aktuelle Aufgabenliste ab: ACT_RU_TASK
Die aktuelle Aufgabenliste wird vom Personalmanager nicht mehr genehmigt, was darauf hinweist, dass die Genehmigung des Personalmanagers abgeschlossen ist.
Tabelle zur Ausführung der Prozessinstanz: SELECT * FROM act_ru_execution
enthält die abgeschlossene Gateway-Ausführung, Verzweigung und Konvergenz werden aus act_ru_execution gelöscht.
Zusammenfassung: Beim Verzweigen müssen die Bedingungen beurteilt werden. Die Zweige, die die Bedingungen erfüllen, werden ausgeführt, und die Zweige, die die Bedingungen erfüllen, werden schließlich aggregiert.
5.4 Ereignis-Gateway Das EventGateway-
Ereignis-Gateway ermöglicht die Beurteilung des Flusses entsprechend dem Ereignis. Jeder ausgehende Sequenzfluss des Gateways ist mit einem Zwischenerfassungsereignis verbunden. Wenn ein Prozess ein ereignisbasiertes
Gateway erreicht, wechselt das Gateway in einen Wartezustand: Die Ausführung wird ausgesetzt. Gleichzeitig werden für jeden ausgehenden Sequenzfluss relative Ereignisabonnements erstellt.
Der ausgehende Sequenzfluss des Ereignis-Gateways unterscheidet sich vom normalen Sequenzfluss. Diese Sequenzflüsse werden nicht wirklich „ausgeführt“, sondern lassen die Prozess-Engine entscheiden, welche Ereignisse abonniert werden müssen, wenn der Prozess beim Ereignis-Gateway ausgeführt
wird . Folgende Bedingungen sind zu berücksichtigen:
- Das Ereignis-Gateway muss über zwei oder mehr ausgehende Sequenzflüsse verfügen.
- Nach dem Ereignis-Gateway kann nur der Typ „intermediateCatchEvent“ verwendet werden (activiti unterstützt keine auf dem Ereignis-Gateway basierende Empfangsaufgabe).
- Zwischenerfassungsereignisse, die mit einem Ereignis-Gateway verbunden sind, dürfen nur einen Eingangssequenzfluss haben.
5.4.1 Prozessdefinition
Event-Gateway-Symbol im roten Feld
Von „intermediateCatchEvent“ und „intermediateCatchEvent“
unterstützte Ereignistypen :
Message Event: Nachrichtenereignis
Signal Event: Signalereignis
Timer Event: Timing-Ereignis
Definieren Sie einen Prozess mithilfe eines Event-Gateways:
