最近因爲項目需要,所以研究了一下工作流,然而,我們都知道,國外的工作流框架,是不支持駁回問題的!這是其一!第二!項目的工作流要實現任意節點的流轉,這也是國外工作流框架所不具備的!因此,國外的工作流框架是沒有一個可以真正滿足我們的業務要求的,然而國內的工作流架構,我也沒有聽說過哪個可以支持中國式工作流!因此,在技術選型上面選擇了相對比較火的activiti框架!當時我們的原則就是儘可能的不改變框架,而實現我們的業務邏輯,因爲,工作流這一大模塊是本屌全權負責,就研究了一通!本項目實現了工作流節點的任意流轉,工作流回退(包含會籤),等等一系列操作,至於研究會籤問題的辛酸淚就不在多說,本節也不多說其他功能,主要說工作流回退,特別強調會籤回退,以及網上一些會籤回退的問題!
本屌在研究工作流的時候,曾參考csdn上某一位同志的博客(點擊藍色文字可以進入),但是在使用的時候,發現會籤是有一些問題的,所以對代碼進行了一些調整,驗證完美實現會籤駁回
另外,在上代碼之前一定聲明一點,大家一定注意我在完成任務的時候,進行了一系類的邏輯判斷,此判斷尤其重要,關係到會籤是否真正的沒有問題,曾經我出現過會籤駁回之後審批會出現多條記錄的情況,因此,希望大家一定要看仔細代碼,最後:聲明一點,前面已經說了,本屌參考了一篇博客,說明出處,因此有雷同代碼,不要疑惑和糾結!廢話不在多少,直接上代碼!
下面爲核心代碼,但是會籤的時候在審批要注意,在覈心代碼之後我會貼出我對會籤審批的處理
/**
*
* @param taskId 任務id
* @param msg 批註
* @param endActivityId 結束節點的activitiyId
* @throws Exception
*/
public void turnBackNew(String taskId, String msg, String endActivityId) throws Exception {
Map<String, Object> variables;
HistoricTaskInstance currTask = historyService
.createHistoricTaskInstanceQuery().taskId(taskId)
.singleResult();
ProcessInstance instance = runtimeService
.createProcessInstanceQuery()
.processInstanceId(currTask.getProcessInstanceId())
.singleResult();
if (instance == null) {
throw new RuntimeException("流程已結束");
}
variables = instance.getProcessVariables();
ProcessDefinitionEntity definition = (ProcessDefinitionEntity) ((RepositoryServiceImpl) repositoryService)
.getDeployedProcessDefinition(currTask
.getProcessDefinitionId());
if (definition == null) {
throw new RuntimeException("流程定義未找到");
}
ActivityImpl currActivity = ((ProcessDefinitionImpl) definition)
.findActivity(currTask.getTaskDefinitionKey());
List<ActivityImpl> rtnList = new ArrayList<>();
List<ActivityImpl> tempList = new ArrayList<>();
List<ActivityImpl> activities = iteratorBackActivity(
taskId,
currActivity,
rtnList,
tempList
);
if (activities == null || activities.size() <= 0) throw new RuntimeException("沒有可以選擇的駁回節點!");
List<Task> list = taskService.createTaskQuery().processInstanceId(instance.getId()).list();
for (Task task : list) {
if (!task.getId().equals(taskId)) {
task.setAssignee("排除標記");
commitProcess(task.getId(), null, endActivityId);
}
}
turnTransition(taskId, activities.get(0).getId(), null);
}
/**
* @param taskId 當前任務ID
* @param variables 流程變量
* @param activityId 流程轉向執行任務節點ID<br>
* 此參數爲空,默認爲提交操作
* @throws Exception
*/
private void commitProcess(String taskId, Map<String, Object> variables,
String activityId) throws Exception {
if (variables == null) {
variables = new HashMap<String, Object>();
}
if (activityId == null || activityId.equals("")) {
taskService.complete(taskId, variables);
} else {
turnTransition(taskId, activityId, variables);
}
}
/**
* 清空指定活動節點流向
*
* @param activityImpl 活動節點
* @return 節點流向集合
*/
private List<PvmTransition> clearTransition(ActivityImpl activityImpl) {
List<PvmTransition> oriPvmTransitionList = new ArrayList<PvmTransition>();
List<PvmTransition> pvmTransitionList = activityImpl
.getOutgoingTransitions();
for (PvmTransition pvmTransition : pvmTransitionList) {
oriPvmTransitionList.add(pvmTransition);
}
pvmTransitionList.clear();
return oriPvmTransitionList;
}
/**
* 還原指定活動節點流向
*
* @param activityImpl 活動節點
* @param oriPvmTransitionList 原有節點流向集合
*/
private void restoreTransition(ActivityImpl activityImpl,
List<PvmTransition> oriPvmTransitionList) {
List<PvmTransition> pvmTransitionList = activityImpl
.getOutgoingTransitions();
pvmTransitionList.clear();
for (PvmTransition pvmTransition : oriPvmTransitionList) {
pvmTransitionList.add(pvmTransition);
}
}
/**
* 流程轉向操作
*
* @param taskId 當前任務ID
* @param activityId 目標節點任務ID
* @param variables 流程變量
* @throws Exception
*/
private void turnTransition(String taskId, String activityId,
Map<String, Object> variables) throws Exception {
ActivityImpl currActivity = findActivitiImpl(taskId, null);
List<PvmTransition> oriPvmTransitionList = clearTransition(currActivity);
TransitionImpl newTransition = currActivity.createOutgoingTransition();
ActivityImpl pointActivity = findActivitiImpl(taskId, activityId);
newTransition.setDestination(pointActivity);
taskService.complete(taskId, variables);
pointActivity.getIncomingTransitions().remove(newTransition);
restoreTransition(currActivity, oriPvmTransitionList);
}
/**
* 迭代循環流程樹結構,查詢當前節點可駁回的任務節點
*
* @param taskId 當前任務ID
* @param currActivity 當前活動節點
* @param rtnList 存儲回退節點集合
* @param tempList 臨時存儲節點集合(存儲一次迭代過程中的同級userTask節點)
* @return 回退節點集合
*/
private List<ActivityImpl> iteratorBackActivity(String taskId,
ActivityImpl currActivity, List<ActivityImpl> rtnList,
List<ActivityImpl> tempList) throws Exception {
ProcessInstance processInstance = findProcessInstanceByTaskId(taskId);
List<PvmTransition> incomingTransitions = currActivity
.getIncomingTransitions();
List<ActivityImpl> exclusiveGateways = new ArrayList<ActivityImpl>();
List<ActivityImpl> parallelGateways = new ArrayList<ActivityImpl>();
for (PvmTransition pvmTransition : incomingTransitions) {
TransitionImpl transitionImpl = (TransitionImpl) pvmTransition;
ActivityImpl activityImpl = transitionImpl.getSource();
String type = (String) activityImpl.getProperty("type");
/**
* 並行節點配置要求:<br>
* 必須成對出現,且要求分別配置節點ID爲:XXX_start(開始),XXX_end(結束)
*/
if ("parallelGateway".equals(type)) {
String gatewayId = activityImpl.getId();
String gatewayType = gatewayId.substring(gatewayId
.lastIndexOf("_") + 1);
if ("START".equals(gatewayType.toUpperCase())) {
return rtnList;
} else {
parallelGateways.add(activityImpl);
}
} else if ("startEvent".equals(type)) {
return rtnList;
} else if ("userTask".equals(type)) {
tempList.add(activityImpl);
} else if ("exclusiveGateway".equals(type)) {
currActivity = transitionImpl.getSource();
exclusiveGateways.add(currActivity);
}
}
/**
* 迭代條件分支集合,查詢對應的userTask節點
*/
for (ActivityImpl activityImpl : exclusiveGateways) {
iteratorBackActivity(taskId, activityImpl, rtnList, tempList);
}
/**
* 迭代並行集合,查詢對應的userTask節點
*/
for (ActivityImpl activityImpl : parallelGateways) {
iteratorBackActivity(taskId, activityImpl, rtnList, tempList);
}
/**
* 根據同級userTask集合,過濾最近發生的節點
*/
currActivity = filterNewestActivity(processInstance, tempList);
if (currActivity != null) {
String id = findParallelGatewayId(currActivity);
if (id == null || id.equals("")) {
rtnList.add(currActivity);
} else {
currActivity = findActivitiImpl(taskId, id);
}
tempList.clear();
iteratorBackActivity(taskId, currActivity, rtnList, tempList);
}
return rtnList;
}
/**
* 根據當前節點,查詢輸出流向是否爲並行終點,如果爲並行終點,則拼裝對應的並行起點ID
*
* @param activityImpl 當前節點
* @return
*/
private String findParallelGatewayId(ActivityImpl activityImpl) {
List<PvmTransition> incomingTransitions = activityImpl
.getOutgoingTransitions();
for (PvmTransition pvmTransition : incomingTransitions) {
TransitionImpl transitionImpl = (TransitionImpl) pvmTransition;
activityImpl = transitionImpl.getDestination();
String type = (String) activityImpl.getProperty("type");
if ("parallelGateway".equals(type)) {
String gatewayId = activityImpl.getId();
String gatewayType = gatewayId.substring(gatewayId
.lastIndexOf("_") + 1);
if ("END".equals(gatewayType.toUpperCase())) {
return gatewayId.substring(0, gatewayId.lastIndexOf("_"))
+ "_start";
}
}
}
return null;
}
/**
* 根據流入任務集合,查詢最近一次的流入任務節點
*
* @param processInstance 流程實例
* @param tempList 流入任務集合
* @return
*/
private ActivityImpl filterNewestActivity(ProcessInstance processInstance,
List<ActivityImpl> tempList) {
while (tempList.size() > 0) {
ActivityImpl activity_1 = tempList.get(0);
HistoricActivityInstance activityInstance_1 = findHistoricUserTask(
processInstance, activity_1.getId());
if (activityInstance_1 == null) {
tempList.remove(activity_1);
continue;
}
if (tempList.size() > 1) {
ActivityImpl activity_2 = tempList.get(1);
HistoricActivityInstance activityInstance_2 = findHistoricUserTask(
processInstance, activity_2.getId());
if (activityInstance_2 == null) {
tempList.remove(activity_2);
continue;
}
if (activityInstance_1.getEndTime().before(
activityInstance_2.getEndTime())) {
tempList.remove(activity_1);
} else {
tempList.remove(activity_2);
}
} else {
break;
}
}
if (tempList.size() > 0) {
return tempList.get(0);
}
return null;
}
/**
* 查詢指定任務節點的最新記錄
*
* @param processInstance 流程實例
* @param activityId
* @return
*/
private HistoricActivityInstance findHistoricUserTask(
ProcessInstance processInstance, String activityId) {
HistoricActivityInstance rtnVal = null;
List<HistoricActivityInstance> historicActivityInstances = historyService
.createHistoricActivityInstanceQuery().activityType("userTask")
.processInstanceId(processInstance.getId()).activityId(
activityId).finished()
.orderByHistoricActivityInstanceEndTime().desc().list();
if (historicActivityInstances.size() > 0) {
rtnVal = historicActivityInstances.get(0);
}
return rtnVal;
}
/**
* 根據任務ID和節點ID獲取活動節點 <br>
*
* @param taskId 任務ID
* @param activityId 活動節點ID <br>
* 如果爲null或"",則默認查詢當前活動節點 <br>
* 如果爲"end",則查詢結束節點 <br>
* @return
* @throws Exception
*/
private ActivityImpl findActivitiImpl(String taskId, String activityId)
throws Exception {
ProcessDefinitionEntity processDefinition = findProcessDefinitionEntityByTaskId(taskId);
if (activityId == null || "".equals(activityId)) {
activityId = findTaskById(taskId).getTaskDefinitionKey();
}
if (activityId.toUpperCase().equals("END")) {
for (ActivityImpl activityImpl : processDefinition.getActivities()) {
List<PvmTransition> pvmTransitionList = activityImpl
.getOutgoingTransitions();
if (pvmTransitionList.isEmpty()) {
return activityImpl;
}
}
}
ActivityImpl activityImpl = ((ProcessDefinitionImpl) processDefinition)
.findActivity(activityId);
return activityImpl;
}
/**
* 根據任務ID獲取流程定義
*
* @param taskId 任務ID
* @return
* @throws Exception
*/
private ProcessDefinitionEntity findProcessDefinitionEntityByTaskId(
String taskId) throws Exception {
ProcessDefinitionEntity processDefinition = (ProcessDefinitionEntity) ((RepositoryServiceImpl) repositoryService)
.getDeployedProcessDefinition(findTaskById(taskId)
.getProcessDefinitionId());
if (processDefinition == null) {
throw new Exception("流程定義未找到!");
}
return processDefinition;
}
/**
* 根據任務ID獲得任務實例
*
* @param taskId 任務ID
* @return
* @throws Exception
*/
private TaskEntity findTaskById(String taskId) throws Exception {
TaskEntity task = (TaskEntity) taskService.createTaskQuery().taskId(
taskId).singleResult();
if (task == null) {
throw new Exception("任務實例未找到!");
}
return task;
}
/**
* 根據任務ID獲取對應的流程實例
*
* @param taskId 任務ID
* @return
* @throws Exception
*/
private ProcessInstance findProcessInstanceByTaskId(String taskId)
throws Exception {
ProcessInstance processInstance = runtimeService
.createProcessInstanceQuery().processInstanceId(
findTaskById(taskId).getProcessInstanceId())
.singleResult();
if (processInstance == null) {
throw new Exception("流程實例未找到!");
}
return processInstance;
}
- 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
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
- 141
- 142
- 143
- 144
- 145
- 146
- 147
- 148
- 149
- 150
- 151
- 152
- 153
- 154
- 155
- 156
- 157
- 158
- 159
- 160
- 161
- 162
- 163
- 164
- 165
- 166
- 167
- 168
- 169
- 170
- 171
- 172
- 173
- 174
- 175
- 176
- 177
- 178
- 179
- 180
- 181
- 182
- 183
- 184
- 185
- 186
- 187
- 188
- 189
- 190
- 191
- 192
- 193
- 194
- 195
- 196
- 197
- 198
- 199
- 200
- 201
- 202
- 203
- 204
- 205
- 206
- 207
- 208
- 209
- 210
- 211
- 212
- 213
- 214
- 215
- 216
- 217
- 218
- 219
- 220
- 221
- 222
- 223
- 224
- 225
- 226
- 227
- 228
- 229
- 230
- 231
- 232
- 233
- 234
- 235
- 236
- 237
- 238
- 239
- 240
- 241
- 242
- 243
- 244
- 245
- 246
- 247
- 248
- 249
- 250
- 251
- 252
- 253
- 254
- 255
- 256
- 257
- 258
- 259
- 260
- 261
- 262
- 263
- 264
- 265
- 266
- 267
- 268
- 269
- 270
- 271
- 272
- 273
- 274
- 275
- 276
- 277
- 278
- 279
- 280
- 281
- 282
- 283
- 284
- 285
- 286
- 287
- 288
- 289
- 290
- 291
- 292
- 293
- 294
- 295
- 296
- 297
- 298
- 299
- 300
- 301
- 302
- 303
- 304
- 305
- 306
- 307
- 308
- 309
- 310
- 311
- 312
- 313
- 314
- 315
- 316
- 317
- 318
- 319
- 320
- 321
- 322
- 323
- 324
- 325
- 326
- 327
- 328
- 329
- 330
- 331
- 332
- 333
- 334
- 335
- 336
- 337
- 338
- 339
- 340
- 341
- 342
- 343
- 344
- 345
- 346
- 347
- 348
- 349
- 350
- 351
- 352
- 353
- 354
- 355
- 356
- 357
- 358
- 359
- 360
- 361
- 362
- 363
- 364
- 365
- 366
- 367
- 368
- 369
- 370
- 371
- 372
- 373
- 374
- 375
- 376
- 377
- 378
- 379
- 380
- 381
- 382
- 383
- 384
- 385
- 386
- 387
- 388
- 389
- 390
- 391
- 392
- 393
- 394
- 395
- 396
- 397
- 398
- 399
- 400
- 401
- 402
- 403
- 404
- 405
- 406
- 407
- 408
- 409
- 410
- 411
- 412
下面尤其重要的說明一點,會簽在提交的時候,一定要如我之判定,否則,會在多次駁回的時候,出現多條記錄,流程混亂的問題
public void submitTask(ProjectWorkflowRequest param, String userCode, String username, User user) throws Exception {
String s = WorkflowReflectionLog.refectCompare(projectService.getProjectByProjectId(projectService.getNewestProjectIdByApplicationId(param.getProject().getTab1().getApplicationProjectId())), param.getProject())
// if (true) throw new RuntimeException()
projectService.applicationSubmit(param.getProject(), user)
Task task = taskService.createTaskQuery().taskId(param.getTaskId()).singleResult()
String processInstanceId = task.getProcessInstanceId()
taskService.addComment(param.getTaskId(), processInstanceId, param.getMsg())
taskService.setVariableLocal(param.getTaskId(), "projectId", param.getProject().getTab1().getProjectId())
if (s != null) taskService.setVariableLocal(param.getTaskId(), "log", s)
runtimeService.setVariables(task.getExecutionId(), new HashMap() {{
this.put("LAST_USER", userCode)
this.put("LAST_USER_NAME", username)
}})
runtimeService.setVariable(processInstanceId, "LAST_USER", username)
// 因爲前臺標記駁回還是通過還是終止流程,分別用0,1,2標識,所以,你就當是三種情況,通過駁回,終止
if ("1".equals(param.getFlag())) {// 通過
switch (param.getType()) {
case 1: {
String sid = task.getTaskDefinitionKey()
List<Task> list = taskService.createTaskQuery().processInstanceId(task.getProcessInstanceId()).list()
if (list.size() == 1) {// 如果只剩一個任務,可能是普通任務,可能是會籤任務
if (
"sid-71E0BFA1-AD56-45D6-907E-D4B61F445D84".equals(sid) ||
"sid-9795199D-77F0-4F34-A0D6-E388525FA8BE".equals(sid) ||
"sid-6340E7E8-2BA1-4B2F-B7CF-19FE31412E58".equals(sid)) {// 如果是會籤,則提交到下一個審批節點(並行網關之後的第一個節點)
//工作流任意流轉,流轉到下一個審批節點,因爲我的會籤裏面包含三個節點,所以經過activitiyId來判定是不是這三個節點,如果是,則任意流轉節點,如果不是,則正常完成任務,注意:工作流程圖確定之後,每個節點的activityId是永恆不變的!因此,纔可以做此判定
commitProcess(task.getId(), null, "sid-C6334E47-F8A8-430C-9A35-FA98CFD0C405")
} else if (
"sid-62D73895-5AB3-4818-8795-D8CCCDB59CE6".equals(sid) ||
"sid-CFDED207-B694-478A-AE94-3DFFD486E77F".equals(sid) ||
"sid-7A523F96-9F43-4C2C-979F-06B7BC9656B6".equals(sid)
) else taskService.complete(task.getId())
} else {
commitProcess(task.getId(), null, "sid-404150FC-8E2D-4582-9CFB-BC9FF43F09E1")
}
}
break
case 2: {
Map<String, Object> variables = new HashMap<>()
variables.put("a", param.getU1())
variables.put("b", param.getU2())
taskService.complete(param.getTaskId(), variables)
}
break
case 3: {
Map<String, Object> variables = new HashMap<>()
variables.put("flag", param.getFlag1())
taskService.complete(param.getTaskId(), variables)
}
break
}
} else if ("0".equals(param.getFlag())) {// 拒絕 // // TODO: 2017/11/8 0008
turnBackNew(param.getTaskId(), param.getMsg(), "sid-404150FC-8E2D-4582-9CFB-BC9FF43F09E1")
} else if ("2".equals(param.getFlag())) {// 終止流程
endProcess(param.getTaskId(), "sid-404150FC-8E2D-4582-9CFB-BC9FF43F09E1")
}
}
- 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
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59