Activiti工作流会签二 启动流程

上一篇文单中简单说了一下工作流中流程定义，下面面我们在简单聊一聊启动流程。

启动工作流

在我的项目中启动一个工作流调用本地的API有点多，这里就只把核心的代码帖出来。

public String startProcess(ActBusiness actBusiness) {

        String userId = securityUtil.getCurrUser().getId();
        // 权限判断
        ActProcess actProcess = actProcessMapper.selectById(actBusiness.getProcDefId());
        if(actProcess==null){
            throw new TbootException("流程定义不存在");
        }
        if(actProcess.getAllUser()!=null&&!actProcess.getAllUser()){
            // 判断有无权限
            if(!actStarterService.hasRecord(actBusiness.getProcDefId(), userId)){
                throw new TbootException("抱歉，您无权发起该流程");
            }
        }
        // 启动流程用户
        identityService.setAuthenticatedUserId(userId);
        // 启动流程 需传入业务表id变量
        actBusiness.getParams().put("tableId", actBusiness.getTableId());
        ProcessInstance pi = runtimeService.startProcessInstanceById(actBusiness.getProcDefId(), actBusiness.getId(), actBusiness.getParams());
        // 设置流程实例名称
        runtimeService.setProcessInstanceName(pi.getId(), actBusiness.getTitle());
        List<Task> tasks = taskService.createTaskQuery().processInstanceId(pi.getId()).list();
        for(Task task : tasks){
            if(actBusiness.getFirstGateway()){
                // 网关类型
                List<User> users = getNode(task.getTaskDefinitionKey()).getUsers();
                // 如果下个节点未分配审批人为空 取消结束流程
                if(users==null||users.size()==0){
                    throw new TbootException("有任务节点未分配任何候选审批人，发起流程失败");
                }else{
                    // 分配了节点负责人分发给全部
                    for(User user : users){
                        taskService.addCandidateUser(task.getId(), user.getId());
                        // 异步发消息
                        messageUtil.sendActMessage(user.getId(), ActivitiConstant.MESSAGE_TODO_CONTENT, actBusiness.getSendMessage(),
                                actBusiness.getSendSms(), actBusiness.getSendEmail());
                    }
                }
            }else {
                // 分配第一个任务用户
                for (String assignee : actBusiness.getAssignees()) {
                    taskService.addCandidateUser(task.getId(), assignee);
                    // 异步发消息
                    messageUtil.sendActMessage(assignee, ActivitiConstant.MESSAGE_TODO_CONTENT, actBusiness.getSendMessage(),
                            actBusiness.getSendSms(), actBusiness.getSendEmail());
                }
            }
            // 设置任务优先级
            taskService.setPriority(task.getId(), actBusiness.getPriority());
        }
        return pi.getId();
    }

下面我们简单介绍一下上面的代码。
第一步： 我先获取了当前用户的id，判断当前用户有没有发起流程的权限，此一步纯属本项目中的业务，可以不做。

第二步：设置当前流程是谁启动的到activiti中。identityService 是activiti自带的bean对象，直接注入就行。

 @Autowired
 private IdentityService identityService;
 // 启动流程用户
 identityService.setAuthenticatedUserId(userId);

第三步： 我们就可以启动流程了。第一个参数是流程定义id: leave:1:7 第二个参数是随机的id,这里因为业务需要所以才传的actBusiness表中的id和工作流本身无关。第三个参数是传入到这个流程实例中的参数，我们可以在别的地方获取里面的参数。这里是不是有点像Netty中给channel管理设置参数呢？

  // 启动流程 需传入业务表id变量
        actBusiness.getParams().put("tableId", actBusiness.getTableId());
        ProcessInstance pi = runtimeService.startProcessInstanceById(actBusiness.getProcDefId(), 						
  										actBusiness.getId(), actBusiness.getParams());

第四步：设置流程实例名称

runtimeService.setProcessInstanceName(pi.getId(), actBusiness.getTitle());

第四步： 下面就是给人分配任务了， 代码中的逻辑是给任务分配人。 这也是这个工作流框架的设计思想吧。 如果以人为核心开发就没有办法和业务分离了， 因此这个框架就是把任务分离，然后在把人和业务填充到工作流框架中。

在这里我们就获取所有的任务，然后判断第一个节点是不是网关， 然后获取网关的用户，给分配任务。
如果不是网关就直接分配任务， 这里使用了循环，是因为一个任务可能是交给好几个人来做的，所以是有好几个人。

  @Autowired
    private TaskService taskService;


 List<Task> tasks = taskService.createTaskQuery().processInstanceId(pi.getId()).list();
        for(Task task : tasks){
            if(actBusiness.getFirstGateway()){
                // 网关类型
                List<User> users = getNode(task.getTaskDefinitionKey()).getUsers();
                // 如果下个节点未分配审批人为空 取消结束流程
                if(users==null||users.size()==0){
                    throw new TbootException("有任务节点未分配任何候选审批人，发起流程失败");
                }else{
                    // 分配了节点负责人分发给全部
                    for(User user : users){
                        taskService.addCandidateUser(task.getId(), user.getId());
                        // 异步发消息
                        messageUtil.sendActMessage(user.getId(), ActivitiConstant.MESSAGE_TODO_CONTENT, actBusiness.getSendMessage(),
                                actBusiness.getSendSms(), actBusiness.getSendEmail());
                    }
                }
            }else {
                // 分配第一个任务用户
                for (String assignee : actBusiness.getAssignees()) {
                    taskService.addCandidateUser(task.getId(), assignee);
                    // 异步发消息
                    messageUtil.sendActMessage(assignee, ActivitiConstant.MESSAGE_TODO_CONTENT, actBusiness.getSendMessage(),
                            actBusiness.getSendSms(), actBusiness.getSendEmail());
                }
            }

这里需要注意的一点是，我们只获取到了流程定义中的第一个需要处理的任务，因此我们在并行网关中一次性设置了两个，所以这个地方会获取到两个任务，他不会提示这是一个网关，因此我们需要在前把这是一个网关传过来。 在这里进行判断。
为了方便观看，我把流程设计图在这里在粘贴一次。

判断是不是网关

我们在介绍启动工作流的时候其实是少了一部分的工作还没有做。 下面我们简单介绍一下。

在整个工作流的中，通过流程定义id获取第一个任务节点。 这其实就是我们想做的，如果第一个任务节点是普通任务，我们就拼接一些信息给前端返回，后果不是任务节点是网关，我就把网关类型返回，这样在启动流程的时候我们就知道应第一个节点是不是网关了。如果是网关的话，根据网关类型来处理任务。

 public ProcessNodeVo getFirstNode(String procDefId) {

        BpmnModel bpmnModel = repositoryService.getBpmnModel(procDefId);
        ProcessNodeVo node = new ProcessNodeVo();

        List<Process> processes = bpmnModel.getProcesses();
        Collection<FlowElement> elements = processes.get(0).getFlowElements();
        // 流程开始节点
        StartEvent startEvent = null;
        for (FlowElement element : elements) {
            if (element instanceof StartEvent) {
                startEvent = (StartEvent) element;
                break;
            }
        }
        FlowElement e = null;
        // 判断开始后的流向节点
        SequenceFlow sequenceFlow = startEvent.getOutgoingFlows().get(0);
        for (FlowElement element : elements) {
            if(element.getId().equals(sequenceFlow.getTargetRef())){
                if(element instanceof UserTask){
                    e = element;
                    node.setType(ActivitiConstant.NODE_TYPE_TASK);
                    break;
                }else if(element instanceof ExclusiveGateway){
                    e = element;
                    node.setType(ActivitiConstant.NODE_TYPE_EG);
                    break;
                }else if(element instanceof ParallelGateway){
                    e = element;
                    node.setType(ActivitiConstant.NODE_TYPE_PG);
                    break;
                }else{
                    throw new TbootException("流程设计错误，开始节点后只能是用户任务节点、排他网关、并行网关");
                }
            }
        }
        // 排他、平行网关直接返回
        if(e instanceof ExclusiveGateway || e instanceof ParallelGateway){
            return node;
        }
        node.setTitle(e.getName());
        // 是否为自选用户节点
        Boolean customUser = actNodeService.hasCustomUser(e.getId());
        if(customUser){
            node.setType(ActivitiConstant.NODE_TYPE_CUSTOM);
        }else{
            // 设置关联用户
            List<User> users = getNodetUsers(e.getId());
            node.setUsers(removeDuplicate(users));
        }
        return node;
    }

好了到此为止，我们的启动流程就介绍完了， 在重新梳理一下逻辑，在启动流程之前我们先去获取第一个节点是不是网关，在启动流程之后，我们去获取第一个任务， 在根据第一个节点的情况来处理任务。也就是给任务分配处理人员。

交个朋友