2. 程式人生 > >activiti工作流,駁回問題詳細解析(尤其會籤的駁回問題)

activiti工作流,駁回問題詳細解析(尤其會籤的駁回問題)

阿新 • • 發佈：2019-01-16
最近因為專案需要,所以研究了一下工作流,然而,我們都知道,國外的工作流框架,是不支援駁回問題的!這是其一!第二!專案的工作流要實現任意節點的流轉,這也是國外工作流框架所不具備的!因此,國外的工作流框架是沒有一個可以真正滿足我們的業務要求的,然而國內的工作流架構,我也沒有聽說過哪個可以支援中國式工作流!因此,在技術選型上面選擇了相對比較火的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();
        // 條件分支節點集合，userTask節點遍歷完畢，迭代遍歷此集合，查詢條件分支對應的userTask節點
        List<ActivityImpl> exclusiveGateways = new ArrayList<ActivityImpl>();
        // 並行節點集合，userTask節點遍歷完畢，迭代遍歷此集合，查詢並行節點對應的userTask節點
        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 {// 並行終點，臨時儲存此節點，本次迴圈結束，迭代集合，查詢對應的userTask節點
                    parallelGateways.add(activityImpl);
                }
            } else if ("startEvent".equals(type)) {// 開始節點，停止遞迴
                return rtnList;
            } else if ("userTask".equals(type)) {// 使用者任務
                tempList.add(activityImpl);
            } else if ("exclusiveGateway".equals(type)) {// 分支路線，臨時儲存此節點，本次迴圈結束，迭代集合，查詢對應的userTask節點
                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) {
            // 查詢當前節點的流向是否為並行終點，並獲取並行起點ID
            String id = findParallelGatewayId(currActivity);
            if (id == null || id.equals("")) {// 並行起點ID為空，此節點流向不是並行終點，符合駁回條件，儲存此節點
                rtnList.add(currActivity);
            } else {// 根據並行起點ID查詢當前節點，然後迭代查詢其對應的userTask任務節點
                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);

        // 獲取當前活動節點ID
        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;
                }
            }
        }

        // 根據節點ID，獲取對應的活動節點
        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();// 獲取當前任務的activitiyId
                    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());// 如果不是會籤的3個節點則直接審批
                    } 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

相關推薦

activiti工作流,駁回問題詳細解析(尤其會籤的駁回問題)

最近因為專案需要,所以研究了一下工作流,然而,我們都知道,國外的工作流框架,是不支援駁回問題的!這是其一!第二!專案的工作流要實現任意節點的流轉,這也是國外工作流框架所不具備的!因此,國外的工作流框架是沒有一個可以真正滿足我們的業務要求的,然而國內的工作流架構,我也沒有聽說過哪個可以支援中國式工作流!因此,在

簡易OA漫談之工作流設計(四,怎麼支援會籤)

會籤：就是一個步驟要所有人都審批完成才能完成。 上一步提交到會籤步驟時，該步驟的每個人都能收到一條待辦任務， 會籤審批人每次提交時都檢查該步驟所有會籤人是否已經審批，如果全部審批就產生下一手任務。 演示：http://wftest.bomye.cn/ 1、先建一個使用者組 2、給使用者組加兩個成

activiti工作流，資料庫表解析。

-- 釋出的流程資訊 存有id和名稱。   該id分別在“部署的流程” 和“通用資料” 中記錄 以該表為紐帶，關聯 “部署的流程act_re_procdef” 與“部署流程的配置資訊(該配置資訊記錄在‘通用資料’act_ge_bytearray表中)” select *

帶你瞭解什麼是Activiti工作流，Activiti工作流資料庫表詳細介紹（23張表）

帶你五分鐘瞭解工作流 什麼是工作流 說到工作流,一圖勝萬言。 工作流 Georgakopoulos給出的工作流定義是：工作流是將一組任務組織起來以完成某個經營過程：定義了任務的觸發順序和觸發條件，每個任務可以由一個或多個軟體系統完成，也可以由一個或一組人完成，還可以由一個或多個

Activiti工作流引擎添新丁：Flowable6.0(聽說無縫連線你會換嗎？)

如果你在還糾結該選擇JPMB還是Acitiviti的時候，或者還在糾結於是否該從JPMB遷移到Activiti的陣營中的時候，很不幸地告訴你，Flowable6.0已經發布了。 　　是不是變得更糾結啦？！又多了一種選擇。 　　1、 什麼是Flowable？ 　　

Activiti工作流REST方式訪問URI的解析

在Activiti工作流中提供一種訪問方式為REST方式訪問。針對查詢字串的格式採用一個如下一個工具類解析Uri中的提供的各種資訊。 package org.activiti.explorer.util; import java.io.UnsupportedEncodin

Activiti工作流引擎的官方例項配置詳細步驟

概述 學習Activiti工作流引擎，第一步自然是是下載官方提供的Demo原始碼來參考。 Activiti官網：activiti-5.22.0.zip 下載下來的原始碼結構為： war包裡就是官方示例 建立Java web專案

activiti工作流資料庫表詳細介紹

Activiti的後臺是有資料庫的支援，所有的表都以ACT_開頭。 第二部分是表示表的用途的兩個字母標識。 用途也和服務的API對應。 ACT_RE_*: 'RE'表示repository。 這個字首的表包含了流程定義和流程靜態資源 （圖片，規則，等等）。 A

Activiti工作流框架學習（一）之通用資料表詳細介紹

文/朱季謙 Activiti工作流引擎自帶了一套資料庫表，這裡面有一個需要注意的地方： 低於5.6.4的MySQL版本不支援時間戳或毫秒級的日期。更糟糕的是，某些版本在嘗試建立此類列時將引發異常，而其他版本則不會。執行自動建立/升級時，引擎將在執行DDL時更改它。使用DDL檔案方法時，既可以使用常規版本也可以

activiti工作流系列-activitirume

例如 參與者 span fin 動態 完全 def ini gin 1、什麽是工作流？ 工作流就是讓多個參與者之間按照某種預定義的規則傳遞文檔、信息或任務的過程，工作流由實體(Entity)、參與者(Participant)、流程定義(Flow Definition)、工作

Activiti工作流引擎數據庫表結構

activit let repr 通過 運行時 工作流 用例 pro ext Activiti工作流引擎數據庫表結構 一、數據庫表的命名 　　Acitiviti數據庫中表的命名都是以ACT_開頭的。第二部分是一個兩個字符用例表的標識。此用例大體與服務API是匹配的。 l

Java Activiti 工作流引擎 springmvc SSM 流程審批 後臺框架源碼

Activiti6.0工作流模塊----------------------------------------------------------------------------------------------------------1.模型管理 ：web在線流程設計器、預覽流程xml、導出x

activiti工作流EL表達式出現亂碼導致comment亂碼

com 重啟 down true 情況 工作流 原因 表達式 AC EL表達式出現亂碼的原因有很多，我記錄一下自己的情況。 在response和頁面都已設置utf-8編碼時仍然出現亂碼。 我修改了tomcat conf目錄下的server.xml文件 在原始配置上添加了u

Activiti6.0工作流引擎深度解析與實戰

word boot 事件處理 數據庫表 系統 講解 數據表設計 helloword posit 第1章 課程介紹本課程將系統且深入源碼講解Activiti6.0工作流引擎的使用、配置、核心api以及BPMN2.0規範、數據庫設計及模型映射，Spring Boot2.0集成，

Java Activiti 工作流引擎 流程審批 後臺框架源碼 springmvc SSM

物流查詢接口 主表 快速 font sql www. 物流 sock hit 博文來源：http://www.fhadmin.org/webnewsdetail1.html工作流模塊----------------------------------------------

工作流3-activiti工作流流程定義的CURD

activiti的流程定義API Explain:activiti對流程的增刪該查 (學習源自傳智播客itcast) 獲取引擎 ProcessEngine processEngine = ProcessEngine.getDefaultProcessEngine();

Activiti工作流引擎學習總結

經過這三天對與Activiti的軟磨硬泡，也算是小有所獲。 想要學會工作流引擎其實很簡單，搞清楚processengine （Activiti引擎），並且理解其中幾大服務介面： 服務:    reposit

Activiti工作流引擎學習及流程設計器的安裝（Eclipse外掛）

工作流簡介     我們先來描述一個在工作中經常用到的一個流程:請假     員工張三請假一天 主管王五批准     員工李四請假一天 主管王五不批准  &nbs

IDEA建立Activiti工作流開發第一篇（Maven專案）

首先建立一個新的Maven專案，建立完成後我們要安裝Activiti的外掛，首先開啟FIle的setting功能，搜尋Plugins： 輸入actiBPM，然後點選搜尋： 如圖點選安裝，它就會下載安裝 安裝好後點擊應用： 然後重啟IDEA，點選File檔案中的

Activiti工作流的環境配置

分享一下我老師大神的人工智慧教程吧。零基礎，通俗易懂！風趣幽默！http://www.captainbed.net/ 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！