activiti – 那啥快看

Activiti里附件Attachment管理（添加、查询、删除）

前言

在流程流转过程中可能会需要附带一些文件，每个任务办理人都可以上传附件，然后在流转过程中可能会被多次审批。

本篇将介绍附件的添加、查询、下载和删除代码操作。

代码示例

老规矩，本文只贴activiti附件相关的代码，其它基础代码可以参看《SpringBoot2.0整合activiti6示例》

添加附件

activiti里添加附件有两种方式，文件方式url方式。

/**
     * 添加附件（file文件）
     * @param file
     * @param taskId
     * @param processInstanceId
     * @param attachmentName
     * @param attachmentDescription
     * @throws IOException
     */
    @PostMapping("/addAttachmentFile")
    public void addAttachment(@RequestParam("file")MultipartFile file,
                              @RequestParam("taskId")String taskId,
                              @RequestParam("processInstanceId")String processInstanceId,
                              @RequestParam("attachmentName")String attachmentName,
                              @RequestParam("attachmentDescription")String attachmentDescription) throws IOException {
        String attachmentType = file.getContentType() + ";" + FilenameUtils.getExtension(file.getOriginalFilename());
        // 从session里获取当前登录用户
//        identityService.setAuthenticatedUserId("");
        taskService.createAttachment(attachmentType, taskId, processInstanceId, attachmentName, attachmentDescription
                , file.getInputStream());
    }

/**

* 添加附件（file文件）

* @param file

* @param taskId

* @param processInstanceId

* @param attachmentName

* @param attachmentDescription

* @throws IOException

@PostMapping("/addAttachmentFile")

public void addAttachment(@RequestParam("file")MultipartFile file,

@RequestParam("taskId")String taskId,

@RequestParam("processInstanceId")String processInstanceId,

@RequestParam("attachmentName")String attachmentName,

@RequestParam("attachmentDescription")String attachmentDescription) throws IOException {

String attachmentType = file.getContentType() + ";" + FilenameUtils.getExtension(file.getOriginalFilename());

// 从session里获取当前登录用户

// identityService.setAuthenticatedUserId("");

taskService.createAttachment(attachmentType, taskId, processInstanceId, attachmentName, attachmentDescription

, file.getInputStream());

}

/**
     * 添加附件（url）
     * @param url
     * @param attachmentType
     * @param taskId
     * @param processInstanceId
     * @param attachmentName
     * @param attachmentDescription
     * @throws IOException
     */
    @PostMapping("/addAttachmentUrl")
    public void addAttachment(@RequestParam("url")String url,
                              @RequestParam("attachmentType")String attachmentType,
                              @RequestParam("taskId")String taskId,
                              @RequestParam("processInstanceId")String processInstanceId,
                              @RequestParam("attachmentName")String attachmentName,
                              @RequestParam("attachmentDescription")String attachmentDescription) throws IOException {
        // 从session里获取当前登录用户
//        identityService.setAuthenticatedUserId("");
        taskService.createAttachment(attachmentType, taskId, processInstanceId, attachmentName, attachmentDescription
                , url);
    }

/**

* 添加附件（url）

* @param url

* @param attachmentType

* @param taskId

* @param processInstanceId

* @param attachmentName

* @param attachmentDescription

* @throws IOException

@PostMapping("/addAttachmentUrl")

public void addAttachment(@RequestParam("url")String url,

@RequestParam("attachmentType")String attachmentType,

@RequestParam("taskId")String taskId,

@RequestParam("processInstanceId")String processInstanceId,

@RequestParam("attachmentName")String attachmentName,

@RequestParam("attachmentDescription")String attachmentDescription) throws IOException {

// 从session里获取当前登录用户

// identityService.setAuthenticatedUserId("");

taskService.createAttachment(attachmentType, taskId, processInstanceId, attachmentName, attachmentDescription

, url);

}

查询附件

/**
     * 查询某个task所关联的附件集合
     * @param taskId
     * @return
     */
    @GetMapping("taskAttachmentList")
    public List<Attachment> getTaskAttachments(String taskId){
        return taskService.getTaskAttachments(taskId);
    }

    /**
     * 查询某个实例所关联的附件集合（多个task组合成一个实例）
     * @param processInstanceId
     * @return
     */
    @GetMapping("instanceAttachmentList")
    public List<Attachment> getInstanceAttachments(String processInstanceId){
        return taskService.getProcessInstanceAttachments(processInstanceId);
    }

/**

* 查询某个task所关联的附件集合

* @param taskId

* @return

@GetMapping("taskAttachmentList")

public List<Attachment> getTaskAttachments(String taskId){

return taskService.getTaskAttachments(taskId);

}

/**

* 查询某个实例所关联的附件集合（多个task组合成一个实例）

* @param processInstanceId

* @return

@GetMapping("instanceAttachmentList")

public List<Attachment> getInstanceAttachments(String processInstanceId){

return taskService.getProcessInstanceAttachments(processInstanceId);

}

下载附件

@GetMapping("/downLoadAttachment/{attachmentId}")
    public void downLoadAttachment(@PathVariable("attachmentId")String attachmentId, HttpServletResponse response) throws IOException {
        Attachment attachment = taskService.getAttachment(attachmentId);
        InputStream attachmentContent = taskService.getAttachmentContent(attachmentId);
        String contentType = StringUtils.substringBefore(attachment.getType(), ";");
        response.addHeader("Content-Type", contentType + ";charset=UTF-8");
        String extensionFileName = StringUtils.substringAfter(attachment.getType(), ";");
        String fileName = attachment.getName() + "." + extensionFileName;
        response.setHeader("Content-Disposition", "attachment; filename=" + fileName);
        IOUtils.copy(new BufferedInputStream(attachmentContent), response.getOutputStream());
    }

@GetMapping("/downLoadAttachment/{attachmentId}")

public void downLoadAttachment(@PathVariable("attachmentId")String attachmentId, HttpServletResponse response) throws IOException {

Attachment attachment = taskService.getAttachment(attachmentId);

InputStream attachmentContent = taskService.getAttachmentContent(attachmentId);

String contentType = StringUtils.substringBefore(attachment.getType(), ";");

response.addHeader("Content-Type", contentType + ";charset=UTF-8");

String extensionFileName = StringUtils.substringAfter(attachment.getType(), ";");

String fileName = attachment.getName() + "." + extensionFileName;

response.setHeader("Content-Disposition", "attachment; filename=" + fileName);

IOUtils.copy(new BufferedInputStream(attachmentContent), response.getOutputStream());

}

删除附件信息

/**
     * 根据附件ID删除附件信息
     * @param attachmentId
     */
    @GetMapping("deleteAttachment")
    public void  deleteAttachment(String attachmentId){
        // 如果有必要可先删除远程文件。deleleFile(remoteFileUrl)
        taskService.deleteAttachment(attachmentId);
    }

/**

* 根据附件ID删除附件信息

* @param attachmentId

@GetMapping("deleteAttachment")

public void deleteAttachment(String attachmentId){

// 如果有必要可先删除远程文件。deleleFile(remoteFileUrl)

taskService.deleteAttachment(attachmentId);

}

Activiti删除流程实例

省略了其它和本例无关的代码，需要查看请参阅《SpringBoot2.0整合activiti6示例》

/**
     * 删除流程实例
     * @return
     */
    @GetMapping("/deleteProcessInstance/{processInstanceId}")
    public void deleteProcessInstance(@PathVariable(value = "processInstanceId") String processInstanceId){
        log.info("=============删除流程实例============");
        List<ProcessInstance> processInstances = runtimeService.createProcessInstanceQuery()
                .processInstanceId(processInstanceId).list();
        if (processInstances.isEmpty()) {
            // 历史流程实例
            List<HistoricProcessInstance> historicProcessInstances = historyService.createHistoricProcessInstanceQuery()
                    .processInstanceId(processInstanceId).list();
            if (historicProcessInstances.isEmpty()) {
                String msg = "No process instances with the ID: " + processInstanceId;
                log.error(msg);
                throw new ActivitiException(msg);
            }
            historyService.deleteHistoricProcessInstance(processInstanceId);
            return;
        }
        runtimeService.deleteProcessInstance(processInstanceId, "删除原因");
    }

/**

* 删除流程实例

* @return

@GetMapping("/deleteProcessInstance/{processInstanceId}")

public void deleteProcessInstance(@PathVariable(value = "processInstanceId") String processInstanceId){

log.info("=============删除流程实例============");

List<ProcessInstance> processInstances = runtimeService.createProcessInstanceQuery()

.processInstanceId(processInstanceId).list();

if (processInstances.isEmpty()) {

// 历史流程实例

List<HistoricProcessInstance> historicProcessInstances = historyService.createHistoricProcessInstanceQuery()

.processInstanceId(processInstanceId).list();

if (historicProcessInstances.isEmpty()) {

String msg = "No process instances with the ID: " + processInstanceId;

log.error(msg);

throw new ActivitiException(msg);

}

historyService.deleteHistoricProcessInstance(processInstanceId);

return;

}

runtimeService.deleteProcessInstance(processInstanceId, "删除原因");

}

简介

在学习工作流的时候，我们可以想到这样一个场景，一个员工离职，可能要很多部门或领导盖章审批，像主管、部门经理、财务部、资产管理部等等。这种过程我们就可以称之为会签。

在activiti里，允许配置了多实例特性的活动在流程运行时以顺序或并行的方式创建活动实例。其中因为用户任务（UserTask）涉及到了“人”的这个重要特性，所以学会使用用户任务的多实例变得尤为重要。

下面会依据员工离职的流程，分别介绍用户任务多实例的顺序方式办理、并行方式办理以及如何自定义设置多实例的结束条件。

还是老规矩，本教程的代码是在《SpringBoot2.0整合activiti6示例》基础上写的，这边只贴本教程相关的代码，其它的代码就可以到之前的这篇博文去看。

顺序方式办理

顺序办理，就是员工要离职，需要拿着离职单一个个找主管、部门经理、财务部、资产管理部签字审批，它们的顺序可以颠倒，但是同一时刻只能是给一个领导或部门签字。

顺序执行流程图

bpmn文件 departureSequence.bpmn20.xml

<?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:activiti="http://activiti.org/bpmn" xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI" xmlns:omgdc="http://www.omg.org/spec/DD/20100524/DC" xmlns:omgdi="http://www.omg.org/spec/DD/20100524/DI" typeLanguage="http://www.w3.org/2001/XMLSchema" expressionLanguage="http://www.w3.org/1999/XPath" targetNamespace="http://www.activiti.org/processdef">
  <process id="departureSequence" name="departureSequence" isExecutable="true">
    <startEvent id="startEvent1"></startEvent>
    <userTask id="sid-C2FB8238-3EA8-416F-8AF1-72C772255EAF" name="employee" activiti:assignee="${yuangong}">
      <extensionElements>
        <modeler:initiator-can-complete xmlns:modeler="http://activiti.com/modeler"><![CDATA[false]]></modeler:initiator-can-complete>
      </extensionElements>
      <multiInstanceLoopCharacteristics isSequential="true" activiti:collection="${yuangongs}"
                                        activiti:elementVariable="yuangong"></multiInstanceLoopCharacteristics>
    </userTask>
    <sequenceFlow id="sid-F9B12974-9A50-45A5-90AC-12A29DA9E3C9" sourceRef="startEvent1" targetRef="sid-C2FB8238-3EA8-416F-8AF1-72C772255EAF"></sequenceFlow>
    <endEvent id="sid-859FAA78-9ABF-4AC6-9578-1424ACF67EFB"></endEvent>
    <sequenceFlow id="sid-4291B834-771E-42EA-948E-6A426EE7F2BB" sourceRef="sid-C2FB8238-3EA8-416F-8AF1-72C772255EAF" targetRef="sid-859FAA78-9ABF-4AC6-9578-1424ACF67EFB"></sequenceFlow>
  </process>
  <bpmndi:BPMNDiagram id="BPMNDiagram_departureSequence">
    <bpmndi:BPMNPlane bpmnElement="departureSequence" id="BPMNPlane_departureSequence">
      <bpmndi:BPMNShape bpmnElement="startEvent1" id="BPMNShape_startEvent1">
        <omgdc:Bounds height="30.0" width="30.0" x="120.0" y="135.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="sid-C2FB8238-3EA8-416F-8AF1-72C772255EAF" id="BPMNShape_sid-C2FB8238-3EA8-416F-8AF1-72C772255EAF">
        <omgdc:Bounds height="80.0" width="100.0" x="225.0" y="110.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="sid-859FAA78-9ABF-4AC6-9578-1424ACF67EFB" id="BPMNShape_sid-859FAA78-9ABF-4AC6-9578-1424ACF67EFB">
        <omgdc:Bounds height="28.0" width="28.0" x="405.0" y="136.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNEdge bpmnElement="sid-4291B834-771E-42EA-948E-6A426EE7F2BB" id="BPMNEdge_sid-4291B834-771E-42EA-948E-6A426EE7F2BB">
        <omgdi:waypoint x="325.0" y="150.0"></omgdi:waypoint>
        <omgdi:waypoint x="405.0" y="150.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="sid-F9B12974-9A50-45A5-90AC-12A29DA9E3C9" id="BPMNEdge_sid-F9B12974-9A50-45A5-90AC-12A29DA9E3C9">
        <omgdi:waypoint x="150.0" y="150.0"></omgdi:waypoint>
        <omgdi:waypoint x="225.0" y="150.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
    </bpmndi:BPMNPlane>
  </bpmndi:BPMNDiagram>
</definitions>

<?xml version="1.0" encoding="UTF-8"?>

<modeler:initiator-can-complete xmlns:modeler="http://activiti.com/modeler"><![CDATA[false]]></modeler:initiator-can-complete>

</extensionElements>

<multiInstanceLoopCharacteristics isSequential="true" activiti:collection="${yuangongs}"

activiti:elementVariable="yuangong"></multiInstanceLoopCharacteristics>

</userTask>

</process>

<bpmndi:BPMNDiagram id="BPMNDiagram_departureSequence">

<bpmndi:BPMNPlane bpmnElement="departureSequence" id="BPMNPlane_departureSequence">

<bpmndi:BPMNShape bpmnElement="startEvent1" id="BPMNShape_startEvent1">

<omgdc:Bounds height="30.0" width="30.0" x="120.0" y="135.0"></omgdc:Bounds>

</bpmndi:BPMNShape>

<bpmndi:BPMNShape bpmnElement="sid-C2FB8238-3EA8-416F-8AF1-72C772255EAF" id="BPMNShape_sid-C2FB8238-3EA8-416F-8AF1-72C772255EAF">

<omgdc:Bounds height="80.0" width="100.0" x="225.0" y="110.0"></omgdc:Bounds>

</bpmndi:BPMNShape>

<bpmndi:BPMNShape bpmnElement="sid-859FAA78-9ABF-4AC6-9578-1424ACF67EFB" id="BPMNShape_sid-859FAA78-9ABF-4AC6-9578-1424ACF67EFB">

<omgdc:Bounds height="28.0" width="28.0" x="405.0" y="136.0"></omgdc:Bounds>

</bpmndi:BPMNShape>

<bpmndi:BPMNEdge bpmnElement="sid-4291B834-771E-42EA-948E-6A426EE7F2BB" id="BPMNEdge_sid-4291B834-771E-42EA-948E-6A426EE7F2BB">

<omgdi:waypoint x="325.0" y="150.0"></omgdi:waypoint>

<omgdi:waypoint x="405.0" y="150.0"></omgdi:waypoint>

</bpmndi:BPMNEdge>

<bpmndi:BPMNEdge bpmnElement="sid-F9B12974-9A50-45A5-90AC-12A29DA9E3C9" id="BPMNEdge_sid-F9B12974-9A50-45A5-90AC-12A29DA9E3C9">

<omgdi:waypoint x="150.0" y="150.0"></omgdi:waypoint>

<omgdi:waypoint x="225.0" y="150.0"></omgdi:waypoint>

</bpmndi:BPMNEdge>

</bpmndi:BPMNPlane>

</bpmndi:BPMNDiagram>

</definitions>

测试代码

@GetMapping("/departureSequence")
public void departureSequence(){
	List<String> yuangongs = Arrays.asList("Y00001", "Y00002", "Y00003");
	Map<String, Object> variables = new HashMap<>();
	variables.put("yuangongs", yuangongs);

	// 部署流程
	Deployment deployment = repositoryService.createDeployment()
			.addClasspathResource("processes/departureSequence.bpmn20.xml")
			.name("departure sequence")
			.key("ds")
			.deploy();

	ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery()
			.deploymentId(deployment.getId()).singleResult();
	log.info("流程名称 ： [" + processDefinition.getName() + "]， 流程ID ： ["
			+ processDefinition.getId() + "], 流程KEY : " + processDefinition.getKey());

	// 开始流程
	String procId = runtimeService.startProcessInstanceByKey(processDefinition.getKey(), variables).getId();


	for (String yuangong: yuangongs) {
		Task task = taskService.createTaskQuery().taskAssignee(yuangong).singleResult();
		taskService.complete(task.getId());
	}
}

@GetMapping("/departureSequence")

public void departureSequence(){

List<String> yuangongs = Arrays.asList("Y00001", "Y00002", "Y00003");

Map<String, Object> variables = new HashMap<>();

variables.put("yuangongs", yuangongs);

// 部署流程

Deployment deployment = repositoryService.createDeployment()

.addClasspathResource("processes/departureSequence.bpmn20.xml")

.name("departure sequence")

.key("ds")

.deploy();

ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery()

.deploymentId(deployment.getId()).singleResult();

log.info("流程名称： [" + processDefinition.getName() + "]，流程ID ： ["

+ processDefinition.getId() + "], 流程KEY : " + processDefinition.getKey());

// 开始流程

String procId = runtimeService.startProcessInstanceByKey(processDefinition.getKey(), variables).getId();

for (String yuangong: yuangongs) {

Task task = taskService.createTaskQuery().taskAssignee(yuangong).singleResult();

taskService.complete(task.getId());

}

在浏览器里访问 http://localhost:5656/departureSequence

查看数据库表，说明顺序执行成功。

离职流程的多实例顺序执行的过程

并行方式办理

并行办理，就是离职员工拿着请假单下的N个子项目纸条，送到各个部门领导那儿，让他们审批盖章，最后再统一汇总（例子可能不太好，就是那个意思）。

流程图

并行处理方式和顺序处理方式只有一个，isSequential=”true”还是”false”，其它配置都一样。

bpmn文件 departureParallel.bpmn20.xml

<?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:activiti="http://activiti.org/bpmn" xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI" xmlns:omgdc="http://www.omg.org/spec/DD/20100524/DC" xmlns:omgdi="http://www.omg.org/spec/DD/20100524/DI" typeLanguage="http://www.w3.org/2001/XMLSchema" expressionLanguage="http://www.w3.org/1999/XPath" targetNamespace="http://www.activiti.org/processdef">
  <process id="departureParallel" name="departureParallel" isExecutable="true">
    <startEvent id="startEvent1"></startEvent>
    <userTask id="sid-C2FB8238-3EA8-416F-8AF1-72C772255EAF" name="employee" activiti:assignee="${yuangong}">
      <extensionElements>
        <modeler:initiator-can-complete xmlns:modeler="http://activiti.com/modeler"><![CDATA[false]]></modeler:initiator-can-complete>
      </extensionElements>
      <multiInstanceLoopCharacteristics isSequential="false" activiti:collection="${yuangongs}" activiti:elementVariable="yuangong"></multiInstanceLoopCharacteristics>
    </userTask>
    <sequenceFlow id="sid-F9B12974-9A50-45A5-90AC-12A29DA9E3C9" sourceRef="startEvent1" targetRef="sid-C2FB8238-3EA8-416F-8AF1-72C772255EAF"></sequenceFlow>
    <endEvent id="sid-859FAA78-9ABF-4AC6-9578-1424ACF67EFB"></endEvent>
    <sequenceFlow id="sid-4291B834-771E-42EA-948E-6A426EE7F2BB" sourceRef="sid-C2FB8238-3EA8-416F-8AF1-72C772255EAF" targetRef="sid-859FAA78-9ABF-4AC6-9578-1424ACF67EFB"></sequenceFlow>
  </process>
  <bpmndi:BPMNDiagram id="BPMNDiagram_departureParallel">
    <bpmndi:BPMNPlane bpmnElement="departureParallel" id="BPMNPlane_departureParallel">
      <bpmndi:BPMNShape bpmnElement="startEvent1" id="BPMNShape_startEvent1">
        <omgdc:Bounds height="30.0" width="30.0" x="120.0" y="135.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="sid-C2FB8238-3EA8-416F-8AF1-72C772255EAF" id="BPMNShape_sid-C2FB8238-3EA8-416F-8AF1-72C772255EAF">
        <omgdc:Bounds height="80.0" width="100.0" x="225.0" y="110.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="sid-859FAA78-9ABF-4AC6-9578-1424ACF67EFB" id="BPMNShape_sid-859FAA78-9ABF-4AC6-9578-1424ACF67EFB">
        <omgdc:Bounds height="28.0" width="28.0" x="405.0" y="136.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNEdge bpmnElement="sid-4291B834-771E-42EA-948E-6A426EE7F2BB" id="BPMNEdge_sid-4291B834-771E-42EA-948E-6A426EE7F2BB">
        <omgdi:waypoint x="325.0" y="150.0"></omgdi:waypoint>
        <omgdi:waypoint x="405.0" y="150.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="sid-F9B12974-9A50-45A5-90AC-12A29DA9E3C9" id="BPMNEdge_sid-F9B12974-9A50-45A5-90AC-12A29DA9E3C9">
        <omgdi:waypoint x="150.0" y="150.0"></omgdi:waypoint>
        <omgdi:waypoint x="225.0" y="150.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
    </bpmndi:BPMNPlane>
  </bpmndi:BPMNDiagram>
</definitions>

<?xml version="1.0" encoding="UTF-8"?>

<modeler:initiator-can-complete xmlns:modeler="http://activiti.com/modeler"><![CDATA[false]]></modeler:initiator-can-complete>

</extensionElements>

</userTask>

</process>

<bpmndi:BPMNDiagram id="BPMNDiagram_departureParallel">

<bpmndi:BPMNPlane bpmnElement="departureParallel" id="BPMNPlane_departureParallel">

<bpmndi:BPMNShape bpmnElement="startEvent1" id="BPMNShape_startEvent1">

<omgdc:Bounds height="30.0" width="30.0" x="120.0" y="135.0"></omgdc:Bounds>

</bpmndi:BPMNShape>

<bpmndi:BPMNShape bpmnElement="sid-C2FB8238-3EA8-416F-8AF1-72C772255EAF" id="BPMNShape_sid-C2FB8238-3EA8-416F-8AF1-72C772255EAF">

<omgdc:Bounds height="80.0" width="100.0" x="225.0" y="110.0"></omgdc:Bounds>

</bpmndi:BPMNShape>

<bpmndi:BPMNShape bpmnElement="sid-859FAA78-9ABF-4AC6-9578-1424ACF67EFB" id="BPMNShape_sid-859FAA78-9ABF-4AC6-9578-1424ACF67EFB">

<omgdc:Bounds height="28.0" width="28.0" x="405.0" y="136.0"></omgdc:Bounds>

</bpmndi:BPMNShape>

<bpmndi:BPMNEdge bpmnElement="sid-4291B834-771E-42EA-948E-6A426EE7F2BB" id="BPMNEdge_sid-4291B834-771E-42EA-948E-6A426EE7F2BB">

<omgdi:waypoint x="325.0" y="150.0"></omgdi:waypoint>

<omgdi:waypoint x="405.0" y="150.0"></omgdi:waypoint>

</bpmndi:BPMNEdge>

<bpmndi:BPMNEdge bpmnElement="sid-F9B12974-9A50-45A5-90AC-12A29DA9E3C9" id="BPMNEdge_sid-F9B12974-9A50-45A5-90AC-12A29DA9E3C9">

<omgdi:waypoint x="150.0" y="150.0"></omgdi:waypoint>

<omgdi:waypoint x="225.0" y="150.0"></omgdi:waypoint>

</bpmndi:BPMNEdge>

</bpmndi:BPMNPlane>

</bpmndi:BPMNDiagram>

</definitions>

测试代码

@GetMapping("/departureParallel")
public void departureParallel(){
	List<String> yuangongs = Arrays.asList("Y00008", "Y00009", "Y00010");
	Map<String, Object> variables = new HashMap<>();
	variables.put("yuangongs", yuangongs);

	// 部署流程
	Deployment deployment = repositoryService.createDeployment()
			.addClasspathResource("processes/departureParallel.bpmn20.xml")
			.name("departure parallel")
			.key("dp")
			.deploy();

	ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery()
			.deploymentId(deployment.getId()).singleResult();
	log.info("流程名称 ： [" + processDefinition.getName() + "]， 流程ID ： ["
			+ processDefinition.getId() + "], 流程KEY : " + processDefinition.getKey());

	// 开始流程
	String procId = runtimeService.startProcessInstanceByKey(processDefinition.getKey(), variables).getId();


	for (String yuangong: yuangongs) {
		long count = taskService.createTaskQuery().taskAssignee(yuangong).count();
		log.info("员工{}有{}个待办任务", yuangong, count);
	}
}

@GetMapping("/departureParallel")

public void departureParallel(){

List<String> yuangongs = Arrays.asList("Y00008", "Y00009", "Y00010");

Map<String, Object> variables = new HashMap<>();

variables.put("yuangongs", yuangongs);

// 部署流程

Deployment deployment = repositoryService.createDeployment()

.addClasspathResource("processes/departureParallel.bpmn20.xml")

.name("departure parallel")

.key("dp")

.deploy();

ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery()

.deploymentId(deployment.getId()).singleResult();

log.info("流程名称： [" + processDefinition.getName() + "]，流程ID ： ["

+ processDefinition.getId() + "], 流程KEY : " + processDefinition.getKey());

// 开始流程

String procId = runtimeService.startProcessInstanceByKey(processDefinition.getKey(), variables).getId();

for (String yuangong: yuangongs) {

long count = taskService.createTaskQuery().taskAssignee(yuangong).count();

log.info("员工{}有{}个待办任务", yuangong, count);

}

在浏览器里访问 http://localhost:5656/departureParallel

查看控制台，并行处理的话，它是一下子就生成了三个任务，然后它们的assignee分别就是代码里设置的Y00008、Y00009、Y00010。

离职流程的多实例并行执行的过程

设置结束条件（completion condition）

上面两个例子都是默认所有实例的任务都完成了，任务节点才结束，那如果想提前结束呢？

比方说，员工离职本来是需要三个部门领导审批盖章的，现在放松了，可以只一个部门领导审批（随机）盖章就OK了。

流程图

在completion condition栏里设置了如下代码，意思是当已完成的实例/所有实例大于或等于我们设置的比率（比方说30%），那就结束。

${nrOfCompletedInstances/nrOfInstances>=rate}

1	${nrOfCompletedInstances/nrOfInstances>=rate}

bpmn文件 departureSequenceCompleteCondition.bpmn20.xml

<?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:activiti="http://activiti.org/bpmn" xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI" xmlns:omgdc="http://www.omg.org/spec/DD/20100524/DC" xmlns:omgdi="http://www.omg.org/spec/DD/20100524/DI" typeLanguage="http://www.w3.org/2001/XMLSchema" expressionLanguage="http://www.w3.org/1999/XPath" targetNamespace="http://www.activiti.org/processdef">
  <process id="departureSequence" name="departureSequence" isExecutable="true">
    <startEvent id="startEvent1"></startEvent>
    <userTask id="sid-C2FB8238-3EA8-416F-8AF1-72C772255EAF" name="employee" activiti:assignee="${yuangong}">
      <extensionElements>
        <modeler:initiator-can-complete xmlns:modeler="http://activiti.com/modeler"><![CDATA[false]]></modeler:initiator-can-complete>
      </extensionElements>
      <multiInstanceLoopCharacteristics isSequential="true" activiti:collection="${yuangongs}" activiti:elementVariable="yuangong">
        <completionCondition>${nrOfCompletedInstances/nrOfInstances&gt;=rate}</completionCondition>
      </multiInstanceLoopCharacteristics>
    </userTask>
    <sequenceFlow id="sid-F9B12974-9A50-45A5-90AC-12A29DA9E3C9" sourceRef="startEvent1" targetRef="sid-C2FB8238-3EA8-416F-8AF1-72C772255EAF"></sequenceFlow>
    <endEvent id="sid-859FAA78-9ABF-4AC6-9578-1424ACF67EFB"></endEvent>
    <sequenceFlow id="sid-4291B834-771E-42EA-948E-6A426EE7F2BB" sourceRef="sid-C2FB8238-3EA8-416F-8AF1-72C772255EAF" targetRef="sid-859FAA78-9ABF-4AC6-9578-1424ACF67EFB"></sequenceFlow>
  </process>
  <bpmndi:BPMNDiagram id="BPMNDiagram_departureSequence">
    <bpmndi:BPMNPlane bpmnElement="departureSequence" id="BPMNPlane_departureSequence">
      <bpmndi:BPMNShape bpmnElement="startEvent1" id="BPMNShape_startEvent1">
        <omgdc:Bounds height="30.0" width="30.0" x="120.0" y="135.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="sid-C2FB8238-3EA8-416F-8AF1-72C772255EAF" id="BPMNShape_sid-C2FB8238-3EA8-416F-8AF1-72C772255EAF">
        <omgdc:Bounds height="80.0" width="100.0" x="225.0" y="110.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="sid-859FAA78-9ABF-4AC6-9578-1424ACF67EFB" id="BPMNShape_sid-859FAA78-9ABF-4AC6-9578-1424ACF67EFB">
        <omgdc:Bounds height="28.0" width="28.0" x="405.0" y="136.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNEdge bpmnElement="sid-4291B834-771E-42EA-948E-6A426EE7F2BB" id="BPMNEdge_sid-4291B834-771E-42EA-948E-6A426EE7F2BB">
        <omgdi:waypoint x="325.0" y="150.0"></omgdi:waypoint>
        <omgdi:waypoint x="405.0" y="150.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="sid-F9B12974-9A50-45A5-90AC-12A29DA9E3C9" id="BPMNEdge_sid-F9B12974-9A50-45A5-90AC-12A29DA9E3C9">
        <omgdi:waypoint x="150.0" y="150.0"></omgdi:waypoint>
        <omgdi:waypoint x="225.0" y="150.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
    </bpmndi:BPMNPlane>
  </bpmndi:BPMNDiagram>
</definitions>

<?xml version="1.0" encoding="UTF-8"?>

<modeler:initiator-can-complete xmlns:modeler="http://activiti.com/modeler"><![CDATA[false]]></modeler:initiator-can-complete>

</extensionElements>

<completionCondition>${nrOfCompletedInstances/nrOfInstances>=rate}</completionCondition>

</multiInstanceLoopCharacteristics>

</userTask>

</process>

<bpmndi:BPMNDiagram id="BPMNDiagram_departureSequence">

<bpmndi:BPMNPlane bpmnElement="departureSequence" id="BPMNPlane_departureSequence">

<bpmndi:BPMNShape bpmnElement="startEvent1" id="BPMNShape_startEvent1">

<omgdc:Bounds height="30.0" width="30.0" x="120.0" y="135.0"></omgdc:Bounds>

</bpmndi:BPMNShape>

<bpmndi:BPMNShape bpmnElement="sid-C2FB8238-3EA8-416F-8AF1-72C772255EAF" id="BPMNShape_sid-C2FB8238-3EA8-416F-8AF1-72C772255EAF">

<omgdc:Bounds height="80.0" width="100.0" x="225.0" y="110.0"></omgdc:Bounds>

</bpmndi:BPMNShape>

<bpmndi:BPMNShape bpmnElement="sid-859FAA78-9ABF-4AC6-9578-1424ACF67EFB" id="BPMNShape_sid-859FAA78-9ABF-4AC6-9578-1424ACF67EFB">

<omgdc:Bounds height="28.0" width="28.0" x="405.0" y="136.0"></omgdc:Bounds>

</bpmndi:BPMNShape>

<bpmndi:BPMNEdge bpmnElement="sid-4291B834-771E-42EA-948E-6A426EE7F2BB" id="BPMNEdge_sid-4291B834-771E-42EA-948E-6A426EE7F2BB">

<omgdi:waypoint x="325.0" y="150.0"></omgdi:waypoint>

<omgdi:waypoint x="405.0" y="150.0"></omgdi:waypoint>

</bpmndi:BPMNEdge>

<bpmndi:BPMNEdge bpmnElement="sid-F9B12974-9A50-45A5-90AC-12A29DA9E3C9" id="BPMNEdge_sid-F9B12974-9A50-45A5-90AC-12A29DA9E3C9">

<omgdi:waypoint x="150.0" y="150.0"></omgdi:waypoint>

<omgdi:waypoint x="225.0" y="150.0"></omgdi:waypoint>

</bpmndi:BPMNEdge>

</bpmndi:BPMNPlane>

</bpmndi:BPMNDiagram>

</definitions>

测试代码

/**
     * 带有完成条件的多实例（ nrOfCompletedInstances/nrOfInstances>=rate 为true时触发结束）
     * 内置变量含义
     *    1.nrOfInstances 该会签环节中总共有多少个实例
     *    2.nrOfActiveInstances 当前活动的实例的数量，即还没有 完成的实例数量。
     *    3.nrOfCompletedInstances 已经完成的实例的数量
     */
    @GetMapping("/departureSequenceCompleteCondition")
    public void departureSequenceCompleteCondition(){
        List<String> yuangongs = Arrays.asList("Y00013", "Y000014", "Y00015");
        Map<String, Object> variables = new HashMap<>();
        variables.put("yuangongs", yuangongs);
        variables.put("rate", 0.3d);// 完成条件为30%

        // 部署流程
        Deployment deployment = repositoryService.createDeployment()
                .addClasspathResource("processes/departureSequenceCompleteCondition.bpmn20.xml")
                .name("departure sequence complete condition")
                .key("dscc")
                .deploy();

        ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery()
                .deploymentId(deployment.getId()).singleResult();
        log.info("流程名称 ： [" + processDefinition.getName() + "]， 流程ID ： ["
                + processDefinition.getId() + "], 流程KEY : " + processDefinition.getKey());

        // 开始流程
        String procId = runtimeService.startProcessInstanceByKey(processDefinition.getKey(), variables).getId();


        // 因为该流程只有一个任务节点，所以这个任务节点完成了该流程实例就结束了
        // 每当一个用户完成任务，就判断一下当前流程实例是否结束
        // 我们设置的结束条件是30%，因为多实例总共是3个用户，所以可以预期的是当前1个员工完成任务后，该流程实例就结束了
        for (String yuangong: yuangongs) {
            Task task = taskService.createTaskQuery().taskAssignee(yuangong).singleResult();
            taskService.complete(task.getId());
            log.info("员工{}完成任务", yuangong);
            long count = historyService.createHistoricProcessInstanceQuery().finished().count();
            if (count == 1){
                log.info("流程实例{}已结束", procId);
                break;
            }
        }
    }

/**

* 带有完成条件的多实例（ nrOfCompletedInstances/nrOfInstances>=rate 为true时触发结束）

* 内置变量含义

* 1.nrOfInstances 该会签环节中总共有多少个实例

* 2.nrOfActiveInstances 当前活动的实例的数量，即还没有完成的实例数量。

* 3.nrOfCompletedInstances 已经完成的实例的数量

@GetMapping("/departureSequenceCompleteCondition")

public void departureSequenceCompleteCondition(){

List<String> yuangongs = Arrays.asList("Y00013", "Y000014", "Y00015");

Map<String, Object> variables = new HashMap<>();

variables.put("yuangongs", yuangongs);

variables.put("rate", 0.3d);// 完成条件为30%

// 部署流程

Deployment deployment = repositoryService.createDeployment()

.addClasspathResource("processes/departureSequenceCompleteCondition.bpmn20.xml")

.name("departure sequence complete condition")

.key("dscc")

.deploy();

ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery()

.deploymentId(deployment.getId()).singleResult();

log.info("流程名称： [" + processDefinition.getName() + "]，流程ID ： ["

+ processDefinition.getId() + "], 流程KEY : " + processDefinition.getKey());

// 开始流程

String procId = runtimeService.startProcessInstanceByKey(processDefinition.getKey(), variables).getId();

// 因为该流程只有一个任务节点，所以这个任务节点完成了该流程实例就结束了

// 每当一个用户完成任务，就判断一下当前流程实例是否结束

// 我们设置的结束条件是30%，因为多实例总共是3个用户，所以可以预期的是当前1个员工完成任务后，该流程实例就结束了

for (String yuangong: yuangongs) {

Task task = taskService.createTaskQuery().taskAssignee(yuangong).singleResult();

taskService.complete(task.getId());

log.info("员工{}完成任务", yuangong);

long count = historyService.createHistoricProcessInstanceQuery().finished().count();

if (count == 1){

log.info("流程实例{}已结束", procId);

break;

}

在浏览器里访问 http://localhost:5656/departureSequenceCompleteCondition

查看控制台

总结

activiti用户任务多实例的员工请假教程结束，有问题或者写的不对的欢迎指正留言。

参考《Activiti实战》

activiti禁用自带的用户身份模块

简介

activiti自带的身份模块属实鸡肋，根本不符合咱们国内绝大多数系统的要求。

国内一般一个完整的系统，都会有自己的身份模块，大多是管理用户、组织、角色、岗位等。而activiti里既没有组织也没有角色的概念，只有一个组（Group）的概念。

综上有两点理由我们需要配置activiti禁用自带的用户身份模块。

activiti自带的身份模块和业务系统的身份模块冲突，同时维护两套不实际
activiti自带的身份模块太过简陋

配置

1.在配置类里给 ProcessEngineConfiguration 加上配置

processEngineConfiguration.setDbIdentityUsed(false);

1	processEngineConfiguration.setDbIdentityUsed(false);

2.删除数据库里涉及到的四张表

act_id_group、act_id_info、act_id_membership、act_id_user

1	act_id_group、act_id_info、act_id_membership、act_id_user

这个时候我们再重新启动集成了activiti的业务系统，activiti引擎就不会再检查以ACT_ID_*开头的表了，也就等于实现了activiti禁用自带的用户身份模块。

Activiti里使用自定义命令实现任务的回退、跳转

简介

一个完善的任务流程不仅需要正常往下走，有时也需要有回退或驳回的功能。本文旨在解决这个需求。

环境

SpringBoot2.X + activiti6

准备bpmn流程文件

一个简单的流程，两个任务节点，原始任务A的assignee是zhangsan，原始任务B的assignee是lisi。

继续阅读

activiti里的命令、拦截器原理介绍和源码分析

简介

activiti里的api服务核心是它的命令和拦截器，所以我们有必要了解它的运行机制。

activiti里用到的设计模式

activiti的整体架构采用了外观模式（Facede）、命令模式（Command）、拦截器模式（Interceptor）这三种主要的设计模式，activiti里的所有API均是在此基础上实现的。

继续阅读

Activiti 部署流程等资源文件的四种方式

Activiti 的流程资源可以是各种类型的文件，在启动流程或流程实例运行过程中会被读取。

一、Activiti流程资源

流程定义文件：文件扩展为*.bpmn20.xml或*.bpmn
流程定义的图片：用BPMN2.0规范的各种图形描绘，文件扩展为*.png
表单文件：把表单内容保存在一个文件中，文件扩展为*.form
规则文件：文件扩展为*.drl

二、部署资源文件

1.classpath方式

public class ProcessDefinitionTest {  
	/**流程引擎（核心对象），默认加载类路径下命名为activiti.cfg.xml*/  
	ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();  
	  
	//部署流程定义  
	@Test  
	public void deployementProcessDefinition(){  
		Deployment deployment = processEngine.getRepositoryService()//获取流程定义和部署对象相关的Service  
						.createDeployment()//创建部署对象  
						.name("helloworld演示")//声明流程的名称  
						.addClasspathResource("diagrams/helloworld.bpmn")//加载资源文件，一次只能加载一个文件  
						.addClasspathResource("diagrams/helloworld.png")//  
						.deploy();//完成部署  
		System.out.println("部署ID："+deployment.getId());//1  
		System.out.println("部署时间："+deployment.getDeploymentTime());  
	}  
}

public class ProcessDefinitionTest {

/**流程引擎（核心对象），默认加载类路径下命名为activiti.cfg.xml*/

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

//部署流程定义

@Test

public void deployementProcessDefinition(){

Deployment deployment = processEngine.getRepositoryService()//获取流程定义和部署对象相关的Service

.createDeployment()//创建部署对象

.name("helloworld演示")//声明流程的名称

.addClasspathResource("diagrams/helloworld.bpmn")//加载资源文件，一次只能加载一个文件

.addClasspathResource("diagrams/helloworld.png")//

.deploy();//完成部署

System.out.println("部署ID："+deployment.getId());//1

System.out.println("部署时间："+deployment.getDeploymentTime());

}

2.InputStream方式

使用InputStream方式部署流程资源需要传入一个输入流及资源的名称，输入流的来源不限，可以从classpath读取，也可以从一个绝对路径文件读取，也可以是从网络上读取。

//Inputstream方式  
@Test  
public void deployementProcessDefinitionByInputStream() throws FileNotFoundException{  
	//获取资源相对路径  
	String bpmnPath = "diagrams/helloworld.bpmn";  
	String pngPath = "diagrams/helloworld.png";  
	  
	//读取资源作为一个输入流  
	FileInputStream bpmnfileInputStream = new FileInputStream(bpmnPath);  
	FileInputStream pngfileInputStream = new FileInputStream(pngPath);  
	  
	Deployment deployment = processEngine.getRepositoryService()//获取流程定义和部署对象相关的Service  
					.createDeployment()//创建部署对象  
					.addInputStream("helloworld.bpmn",bpmnfileInputStream)  
					.addInputStream("helloworld.png", pngfileInputStream)  
					.deploy();//完成部署  
	System.out.println("部署ID："+deployment.getId());//1  
	System.out.println("部署时间："+deployment.getDeploymentTime());  
}

//Inputstream方式

@Test

public void deployementProcessDefinitionByInputStream() throws FileNotFoundException{

//获取资源相对路径

String bpmnPath = "diagrams/helloworld.bpmn";

String pngPath = "diagrams/helloworld.png";

//读取资源作为一个输入流

FileInputStream bpmnfileInputStream = new FileInputStream(bpmnPath);

FileInputStream pngfileInputStream = new FileInputStream(pngPath);

Deployment deployment = processEngine.getRepositoryService()//获取流程定义和部署对象相关的Service

.createDeployment()//创建部署对象

.addInputStream("helloworld.bpmn",bpmnfileInputStream)

.addInputStream("helloworld.png", pngfileInputStream)

.deploy();//完成部署

System.out.println("部署ID："+deployment.getId());//1

System.out.println("部署时间："+deployment.getDeploymentTime());

}

3.字符串方式

利用字符串方式可以直接传入纯文本作为资源的来源，和前两种方式类似，字符串方式的实现原理是把一组字符串的内容转化为字节流后再部署。

//字符串方式  
@Test  
public void deployementProcessDefinitionByString() throws FileNotFoundException{  
	//字符串  
	String text = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><definitions>...</definitions>";           
	  
	Deployment deployment = processEngine.getRepositoryService()//获取流程定义和部署对象相关的Service  
					.createDeployment()//创建部署对象  
					.addString("helloworld.bpmn",text)                    
					.deploy();//完成部署  
	System.out.println("部署ID："+deployment.getId());//1  
	System.out.println("部署时间："+deployment.getDeploymentTime());  
}

//字符串方式

@Test

public void deployementProcessDefinitionByString() throws FileNotFoundException{

//字符串

String text = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><definitions>...</definitions>";

Deployment deployment = processEngine.getRepositoryService()//获取流程定义和部署对象相关的Service

.createDeployment()//创建部署对象

.addString("helloworld.bpmn",text)

.deploy();//完成部署

System.out.println("部署ID："+deployment.getId());//1

System.out.println("部署时间："+deployment.getDeploymentTime());

}

4.zip/bar格式压缩包方式

以上3种部署方式一次只能部署一个资源，除非执行多次deployment.addXxx()方法，如何一次部署多个资源呢？很简单，是我们可以使用zip/bar格式压缩包方式。将资源文件手动或使用Ant脚本，打包文件扩展名可以是Activiti官方推荐的bar或普通的zip。

//部署流程定义（zip）  
@Test  
public void deployementProcessDefinitionByzip(){  
	//从classpath路径下读取资源文件  
	InputStream in = this.getClass().getClassLoader().getResourceAsStream("diagrams/helloworld.zip");  
	ZipInputStream zipInputStream = new ZipInputStream(in);  
	Deployment deployment = processEngine.getRepositoryService()//获取流程定义和部署对象相关的Service  
					.createDeployment()//创建部署对象                   
					.addZipInputStream(zipInputStream)//使用zip方式部署，将helloworld.bpmn和helloworld.png压缩成zip格式的文件  
					.deploy();//完成部署  
	System.out.println("部署ID："+deployment.getId());//1  
	System.out.println("部署时间："+deployment.getDeploymentTime());  
}

//部署流程定义（zip）

@Test

public void deployementProcessDefinitionByzip(){

//从classpath路径下读取资源文件

InputStream in = this.getClass().getClassLoader().getResourceAsStream("diagrams/helloworld.zip");

ZipInputStream zipInputStream = new ZipInputStream(in);

Deployment deployment = processEngine.getRepositoryService()//获取流程定义和部署对象相关的Service

.createDeployment()//创建部署对象

.addZipInputStream(zipInputStream)//使用zip方式部署，将helloworld.bpmn和helloworld.png压缩成zip格式的文件

.deploy();//完成部署

System.out.println("部署ID："+deployment.getId());//1

System.out.println("部署时间："+deployment.getDeploymentTime());

}

Activiti6生成实时流程图并高亮已执行流程节点和连接线

前言

Activiti5.x 的追踪流程节点查找，可以用 ActivityImpl 这个类来实现，但是在 Activiti6 版本里，pvm包整个类包都被删除，也就是说不能用 ActivityImpl 这个类来实现流程图追踪了。

不过Activiti6也有自己的实现方法，主要是利用 ProcessDiagramGenerator 这个接口实现类，去实现 generateDiagram 这个方法。默认可以采用 ProcessDiagramGenerator 的子类 DefaultProcessDiagramGenerator 调用 generateDiagram 实现流程图。当然也可以自定义相应的子类 CustomProcessDiagramGenerator 去定制化实现。

生成流程图核心方法

public InputStream generateDiagram(BpmnModel bpmnModel, String imageType, List<String> highLightedActivities, List<String> highLightedFlows, 
      String activityFontName, String labelFontName, String annotationFontName, ClassLoader customClassLoader, double scaleFactor;

1 2	public InputStream generateDiagram(BpmnModel bpmnModel, String imageType, List<String> highLightedActivities, List<String> highLightedFlows, String activityFontName, String labelFontName, String annotationFontName, ClassLoader customClassLoader, double scaleFactor;

其中比较重要的是 bpmnmodel，highLightedActivities，highLightedFlows 这三个参数。

bpmnmodel模型通过以下代码获取

BpmnModel bpmnModel = repositoryService.getBpmnModel(historicProcessInstance.getProcessDefinitionId());

1	BpmnModel bpmnModel = repositoryService.getBpmnModel(historicProcessInstance.getProcessDefinitionId());

highLightedActivities（需要高亮的执行流程节点集合的获取）获取方法的核心代码

// 获取历史流程实例
HistoricProcessInstance historicProcessInstance = historyService.createHistoricProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();
// 获取流程中已经执行的节点，按照执行先后顺序排序
List<HistoricActivityInstance> historicActivityInstances = historyService.createHistoricActivityInstanceQuery().processInstanceId(processInstanceId)
		.orderByHistoricActivityInstanceId().asc().list();
// 高亮已经执行流程节点ID集合
List<String> highLightedActivitiIds = new ArrayList<>();
for (HistoricActivityInstance historicActivityInstance : historicActivityInstances) {
	highLightedActivitiIds.add(historicActivityInstance.getActivityId());
}

// 获取历史流程实例

HistoricProcessInstance historicProcessInstance = historyService.createHistoricProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();

// 获取流程中已经执行的节点，按照执行先后顺序排序

List<HistoricActivityInstance> historicActivityInstances = historyService.createHistoricActivityInstanceQuery().processInstanceId(processInstanceId)

.orderByHistoricActivityInstanceId().asc().list();

// 高亮已经执行流程节点ID集合

List<String> highLightedActivitiIds = new ArrayList<>();

for (HistoricActivityInstance historicActivityInstance : historicActivityInstances) {

highLightedActivitiIds.add(historicActivityInstance.getActivityId());

}

highLightedFlows（需要高亮流程连接线集合的获取）获取方法的核心代码

/**
 * 获取已经流转的线
 * 
 * @param bpmnModel
 * @param historicActivityInstances
 * @return
 */
private static List<String> getHighLightedFlows(BpmnModel bpmnModel, List<HistoricActivityInstance> historicActivityInstances) {
	// 高亮流程已发生流转的线id集合
	List<String> highLightedFlowIds = new ArrayList<>();
	// 全部活动节点
	List<FlowNode> historicActivityNodes = new ArrayList<>();
	// 已完成的历史活动节点
	List<HistoricActivityInstance> finishedActivityInstances = new ArrayList<>();

	for (HistoricActivityInstance historicActivityInstance : historicActivityInstances) {
		FlowNode flowNode = (FlowNode) bpmnModel.getMainProcess().getFlowElement(historicActivityInstance.getActivityId(), true);
		historicActivityNodes.add(flowNode);
		if (historicActivityInstance.getEndTime() != null) {
			finishedActivityInstances.add(historicActivityInstance);
		}
	}

	FlowNode currentFlowNode = null;
	FlowNode targetFlowNode = null;
	// 遍历已完成的活动实例，从每个实例的outgoingFlows中找到已执行的
	for (HistoricActivityInstance currentActivityInstance : finishedActivityInstances) {
		// 获得当前活动对应的节点信息及outgoingFlows信息
		currentFlowNode = (FlowNode) bpmnModel.getMainProcess().getFlowElement(currentActivityInstance.getActivityId(), true);
		List<SequenceFlow> sequenceFlows = currentFlowNode.getOutgoingFlows();

		/**
		 * 遍历outgoingFlows并找到已已流转的 满足如下条件认为已已流转： 1.当前节点是并行网关或兼容网关，则通过outgoingFlows能够在历史活动中找到的全部节点均为已流转 2.当前节点是以上两种类型之外的，通过outgoingFlows查找到的时间最早的流转节点视为有效流转
		 */
		if ("parallelGateway".equals(currentActivityInstance.getActivityType()) || "inclusiveGateway".equals(currentActivityInstance.getActivityType())) {
			// 遍历历史活动节点，找到匹配流程目标节点的
			for (SequenceFlow sequenceFlow : sequenceFlows) {
				targetFlowNode = (FlowNode) bpmnModel.getMainProcess().getFlowElement(sequenceFlow.getTargetRef(), true);
				if (historicActivityNodes.contains(targetFlowNode)) {
					highLightedFlowIds.add(targetFlowNode.getId());
				}
			}
		} else {
			List<Map<String, Object>> tempMapList = new ArrayList<>();
			for (SequenceFlow sequenceFlow : sequenceFlows) {
				for (HistoricActivityInstance historicActivityInstance : historicActivityInstances) {
					if (historicActivityInstance.getActivityId().equals(sequenceFlow.getTargetRef())) {
						Map<String, Object> map = new HashMap<>();
						map.put("highLightedFlowId", sequenceFlow.getId());
						map.put("highLightedFlowStartTime", historicActivityInstance.getStartTime().getTime());
						tempMapList.add(map);
					}
				}
			}

			if (!CollectionUtils.isEmpty(tempMapList)) {
				// 遍历匹配的集合，取得开始时间最早的一个
				long earliestStamp = 0L;
				String highLightedFlowId = null;
				for (Map<String, Object> map : tempMapList) {
					long highLightedFlowStartTime = Long.valueOf(map.get("highLightedFlowStartTime").toString());
					if (earliestStamp == 0 || earliestStamp >= highLightedFlowStartTime) {
						highLightedFlowId = map.get("highLightedFlowId").toString();
						earliestStamp = highLightedFlowStartTime;
					}
				}

				highLightedFlowIds.add(highLightedFlowId);
			}

		}

	}
	return highLightedFlowIds;
}

/**

* 获取已经流转的线

* @param bpmnModel

* @param historicActivityInstances

* @return

private static List<String> getHighLightedFlows(BpmnModel bpmnModel, List<HistoricActivityInstance> historicActivityInstances) {

// 高亮流程已发生流转的线id集合

List<String> highLightedFlowIds = new ArrayList<>();

// 全部活动节点

List<FlowNode> historicActivityNodes = new ArrayList<>();

// 已完成的历史活动节点

List<HistoricActivityInstance> finishedActivityInstances = new ArrayList<>();

for (HistoricActivityInstance historicActivityInstance : historicActivityInstances) {

FlowNode flowNode = (FlowNode) bpmnModel.getMainProcess().getFlowElement(historicActivityInstance.getActivityId(), true);

historicActivityNodes.add(flowNode);

if (historicActivityInstance.getEndTime() != null) {

finishedActivityInstances.add(historicActivityInstance);

}

FlowNode currentFlowNode = null;

FlowNode targetFlowNode = null;

// 遍历已完成的活动实例，从每个实例的outgoingFlows中找到已执行的

for (HistoricActivityInstance currentActivityInstance : finishedActivityInstances) {

// 获得当前活动对应的节点信息及outgoingFlows信息

currentFlowNode = (FlowNode) bpmnModel.getMainProcess().getFlowElement(currentActivityInstance.getActivityId(), true);

List<SequenceFlow> sequenceFlows = currentFlowNode.getOutgoingFlows();

/**

* 遍历outgoingFlows并找到已已流转的满足如下条件认为已已流转： 1.当前节点是并行网关或兼容网关，则通过outgoingFlows能够在历史活动中找到的全部节点均为已流转 2.当前节点是以上两种类型之外的，通过outgoingFlows查找到的时间最早的流转节点视为有效流转

if ("parallelGateway".equals(currentActivityInstance.getActivityType()) || "inclusiveGateway".equals(currentActivityInstance.getActivityType())) {

// 遍历历史活动节点，找到匹配流程目标节点的

for (SequenceFlow sequenceFlow : sequenceFlows) {

targetFlowNode = (FlowNode) bpmnModel.getMainProcess().getFlowElement(sequenceFlow.getTargetRef(), true);

if (historicActivityNodes.contains(targetFlowNode)) {

highLightedFlowIds.add(targetFlowNode.getId());

}

} else {

List<Map<String, Object>> tempMapList = new ArrayList<>();

for (SequenceFlow sequenceFlow : sequenceFlows) {

for (HistoricActivityInstance historicActivityInstance : historicActivityInstances) {

if (historicActivityInstance.getActivityId().equals(sequenceFlow.getTargetRef())) {

Map<String, Object> map = new HashMap<>();

map.put("highLightedFlowId", sequenceFlow.getId());

map.put("highLightedFlowStartTime", historicActivityInstance.getStartTime().getTime());

tempMapList.add(map);

}

if (!CollectionUtils.isEmpty(tempMapList)) {

// 遍历匹配的集合，取得开始时间最早的一个

long earliestStamp = 0L;

String highLightedFlowId = null;

for (Map<String, Object> map : tempMapList) {

long highLightedFlowStartTime = Long.valueOf(map.get("highLightedFlowStartTime").toString());

if (earliestStamp == 0 || earliestStamp >= highLightedFlowStartTime) {

highLightedFlowId = map.get("highLightedFlowId").toString();

earliestStamp = highLightedFlowStartTime;

}

highLightedFlowIds.add(highLightedFlowId);

}

return highLightedFlowIds;

}

activiti6生成流程图代码

/**
 * 根据流程实例Id,获取实时流程图片
 * 
 * @param processInstanceId
 * @param outputStream
 * @return
 */
public static void getFlowImgByInstanceId(String processInstanceId, OutputStream outputStream) {
	try {
		if (StringUtils.isEmpty(processInstanceId)) {
			logger.error("processInstanceId is null");
			return;
		}
		// 获取历史流程实例
		HistoricProcessInstance historicProcessInstance = historyService.createHistoricProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();
		// 获取流程中已经执行的节点，按照执行先后顺序排序
		List<HistoricActivityInstance> historicActivityInstances = historyService.createHistoricActivityInstanceQuery().processInstanceId(processInstanceId)
				.orderByHistoricActivityInstanceId().asc().list();
		// 高亮已经执行流程节点ID集合
		List<String> highLightedActivitiIds = new ArrayList<>();
		for (HistoricActivityInstance historicActivityInstance : historicActivityInstances) {
			highLightedActivitiIds.add(historicActivityInstance.getActivityId());
		}

		List<HistoricProcessInstance> historicFinishedProcessInstances = historyService.createHistoricProcessInstanceQuery().processInstanceId(processInstanceId).finished()
				.list();
		ProcessDiagramGenerator processDiagramGenerator = null;
		// 如果还没完成，流程图高亮颜色为绿色，如果已经完成为红色
		if (!CollectionUtils.isEmpty(historicFinishedProcessInstances)) {
			// 如果不为空，说明已经完成
			processDiagramGenerator = processEngineConfiguration.getProcessDiagramGenerator();
		} else {
			processDiagramGenerator = new CustomProcessDiagramGenerator();
		}

		BpmnModel bpmnModel = repositoryService.getBpmnModel(historicProcessInstance.getProcessDefinitionId());
		// 高亮流程已发生流转的线id集合
		List<String> highLightedFlowIds = getHighLightedFlows(bpmnModel, historicActivityInstances);

		// 使用默认配置获得流程图表生成器，并生成追踪图片字符流
		InputStream imageStream = processDiagramGenerator.generateDiagram(bpmnModel, "png", highLightedActivitiIds, highLightedFlowIds, "宋体", "微软雅黑", "黑体", null, 2.0);

		// 输出图片内容
		byte[] b = new byte[1024];
		int len;
		while ((len = imageStream.read(b, 0, 1024)) != -1) {
			outputStream.write(b, 0, len);
		}
	} catch (Exception e) {
		logger.error("processInstanceId" + processInstanceId + "生成流程图失败，原因：" + e.getMessage(), e);
	}

}

/**

* 根据流程实例Id,获取实时流程图片

* @param processInstanceId

* @param outputStream

* @return

public static void getFlowImgByInstanceId(String processInstanceId, OutputStream outputStream) {

try {

if (StringUtils.isEmpty(processInstanceId)) {

logger.error("processInstanceId is null");

return;

}

// 获取历史流程实例

HistoricProcessInstance historicProcessInstance = historyService.createHistoricProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();

// 获取流程中已经执行的节点，按照执行先后顺序排序

List<HistoricActivityInstance> historicActivityInstances = historyService.createHistoricActivityInstanceQuery().processInstanceId(processInstanceId)

.orderByHistoricActivityInstanceId().asc().list();

// 高亮已经执行流程节点ID集合

List<String> highLightedActivitiIds = new ArrayList<>();

for (HistoricActivityInstance historicActivityInstance : historicActivityInstances) {

highLightedActivitiIds.add(historicActivityInstance.getActivityId());

}

List<HistoricProcessInstance> historicFinishedProcessInstances = historyService.createHistoricProcessInstanceQuery().processInstanceId(processInstanceId).finished()

.list();

ProcessDiagramGenerator processDiagramGenerator = null;

// 如果还没完成，流程图高亮颜色为绿色，如果已经完成为红色

if (!CollectionUtils.isEmpty(historicFinishedProcessInstances)) {

// 如果不为空，说明已经完成

processDiagramGenerator = processEngineConfiguration.getProcessDiagramGenerator();

} else {

processDiagramGenerator = new CustomProcessDiagramGenerator();

}

BpmnModel bpmnModel = repositoryService.getBpmnModel(historicProcessInstance.getProcessDefinitionId());

// 高亮流程已发生流转的线id集合

List<String> highLightedFlowIds = getHighLightedFlows(bpmnModel, historicActivityInstances);

// 使用默认配置获得流程图表生成器，并生成追踪图片字符流

InputStream imageStream = processDiagramGenerator.generateDiagram(bpmnModel, "png", highLightedActivitiIds, highLightedFlowIds, "宋体", "微软雅黑", "黑体", null, 2.0);

// 输出图片内容

byte[] b = new byte[1024];

int len;

while ((len = imageStream.read(b, 0, 1024)) != -1) {

outputStream.write(b, 0, len);

}

} catch (Exception e) {

logger.error("processInstanceId" + processInstanceId + "生成流程图失败，原因：" + e.getMessage(), e);

}

activiti5.x生成流程图代码

/**
 * 根据流程实例Id,获取实时流程图片
 * 
 * @param processInstanceId
 * @return
 */
public static InputStream getFlowImgByInstantId(String processInstanceId) {
	if (StringUtils.isEmpty(processInstanceId)) {
		return null;
	}
	// 获取流程图输入流
	InputStream inputStream = null;
	// 查询历史
	HistoricProcessInstance historicProcessInstance = historyService.createHistoricProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();
	if (historicProcessInstance.getEndTime() != null) { // 该流程已经结束
		ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().processDefinitionId(historicProcessInstance.getProcessDefinitionId())
				.singleResult();
		inputStream = repositoryService.getResourceAsStream(processDefinition.getDeploymentId(), processDefinition.getDiagramResourceName());
	} else {
		// 查询当前的流程实例
		ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();
		BpmnModel bpmnModel = repositoryService.getBpmnModel(processInstance.getProcessDefinitionId());
		ProcessDefinitionEntity processDefinitionEntity = (ProcessDefinitionEntity) repositoryService.createProcessDefinitionQuery()
				.processDefinitionId(processInstance.getProcessDefinitionId()).singleResult();
		List<String> highLightedFlows = new ArrayList<String>();
		List<HistoricActivityInstance> historicActivityInstances = historyService.createHistoricActivityInstanceQuery().processInstanceId(processInstanceId)
				.orderByHistoricActivityInstanceStartTime().asc().list();
		List<String> historicActivityInstanceList = new ArrayList<String>();
		for (HistoricActivityInstance hai : historicActivityInstances) {
			historicActivityInstanceList.add(hai.getActivityId());
		}
		List<String> highLightedActivities = runtimeService.getActiveActivityIds(processInstanceId);
		historicActivityInstanceList.addAll(highLightedActivities);
		for (ActivityImpl activity : processDefinitionEntity.getActivities()) {
			int index = historicActivityInstanceList.indexOf(activity.getId());
			if (index >= 0 && index + 1 < historicActivityInstanceList.size()) {
				List<PvmTransition> pvmTransitionList = activity.getOutgoingTransitions();
				for (PvmTransition pvmTransition : pvmTransitionList) {
					String destinationFlowId = pvmTransition.getDestination().getId();
					if (destinationFlowId.equals(historicActivityInstanceList.get(index + 1))) {
						highLightedFlows.add(pvmTransition.getId());
					}
				}
			}
		}
		ProcessDiagramGenerator diagramGenerator = processEngineConfiguration.getProcessDiagramGenerator();
		List<String> activeActivityIds = new ArrayList<String>();
		List<Task> tasks = taskService.createTaskQuery().processInstanceId(processInstanceId).list();
		for (org.activiti.engine.task.Task task : tasks) {
			activeActivityIds.add(task.getTaskDefinitionKey());
		}
		inputStream = diagramGenerator.generateDiagram(bpmnModel, "png", activeActivityIds, highLightedFlows, "宋体", "宋体", null, null, 1.0);
	}
	return inputStream;
}

/**

* 根据流程实例Id,获取实时流程图片

* @param processInstanceId

* @return

public static InputStream getFlowImgByInstantId(String processInstanceId) {

if (StringUtils.isEmpty(processInstanceId)) {

return null;

}

// 获取流程图输入流

InputStream inputStream = null;

// 查询历史

HistoricProcessInstance historicProcessInstance = historyService.createHistoricProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();

if (historicProcessInstance.getEndTime() != null) { // 该流程已经结束

ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().processDefinitionId(historicProcessInstance.getProcessDefinitionId())

.singleResult();

inputStream = repositoryService.getResourceAsStream(processDefinition.getDeploymentId(), processDefinition.getDiagramResourceName());

} else {

// 查询当前的流程实例

ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();

BpmnModel bpmnModel = repositoryService.getBpmnModel(processInstance.getProcessDefinitionId());

ProcessDefinitionEntity processDefinitionEntity = (ProcessDefinitionEntity) repositoryService.createProcessDefinitionQuery()

.processDefinitionId(processInstance.getProcessDefinitionId()).singleResult();

List<String> highLightedFlows = new ArrayList<String>();

List<HistoricActivityInstance> historicActivityInstances = historyService.createHistoricActivityInstanceQuery().processInstanceId(processInstanceId)

.orderByHistoricActivityInstanceStartTime().asc().list();

List<String> historicActivityInstanceList = new ArrayList<String>();

for (HistoricActivityInstance hai : historicActivityInstances) {

historicActivityInstanceList.add(hai.getActivityId());

}

List<String> highLightedActivities = runtimeService.getActiveActivityIds(processInstanceId);

historicActivityInstanceList.addAll(highLightedActivities);

for (ActivityImpl activity : processDefinitionEntity.getActivities()) {

int index = historicActivityInstanceList.indexOf(activity.getId());

if (index >= 0 && index + 1 < historicActivityInstanceList.size()) {

List<PvmTransition> pvmTransitionList = activity.getOutgoingTransitions();

for (PvmTransition pvmTransition : pvmTransitionList) {

String destinationFlowId = pvmTransition.getDestination().getId();

if (destinationFlowId.equals(historicActivityInstanceList.get(index + 1))) {

highLightedFlows.add(pvmTransition.getId());

}

ProcessDiagramGenerator diagramGenerator = processEngineConfiguration.getProcessDiagramGenerator();

List<String> activeActivityIds = new ArrayList<String>();

List<Task> tasks = taskService.createTaskQuery().processInstanceId(processInstanceId).list();

for (org.activiti.engine.task.Task task : tasks) {

activeActivityIds.add(task.getTaskDefinitionKey());

}

inputStream = diagramGenerator.generateDiagram(bpmnModel, "png", activeActivityIds, highLightedFlows, "宋体", "宋体", null, null, 1.0);

}

return inputStream;

}

自定义样式生成流程图思路

activiti提供的样式可能不是特别美观，它的api目前只能改字体大小。如果遇到改颜色等，可以通过重写ProcessDiagramCanvas这个类，并实现ProcessDiagramGenerator这个类的接口。

生成的实时流程图效果图

SpringBoot2.0整合activiti7示例

前文《SpringBoot2.0整合activiti6示例》已经介绍了SpringBoot2.0与activiti6的集成，虽然现在activiti6的使用量还是很大，但是activiti7将来毕竟是趋势，所以本文将介绍如何整合SpringBoot2.0与activiti7，并且通过这两次代码整合，最后会分析activiti7相比activiti6有哪些改进。

继续阅读

SpringBoot2.0整合activiti6示例

最近公司项目用到了activiti流程引擎，正好是自己在做，那就记录一下，方便自己后续查看，也方便需要的朋友查看。

既然已经开始看这篇代码整合文章了，我就当大家已经对activiti已经有了初步的了解了。

初始化activiti的表

activiti默认是H2数据库，这边我们使用mysql,从官方下载的文件里可以找到sql脚本，这边要注意不要选择mysql55那个版本的脚本，那是旧版本的mysql使用的（当然如果你的mysql版本低于5.5那当我没说）

另外就是，也可以不用手工运行脚本，当我们第一次在代码里使用activiti时，会自动帮我们建好表。

maven的pom.xml文件

activiti-spring-boot-starter，把版本换一下即可

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.0.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-freemarker</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.2</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.45</version>
        </dependency>
        <!--- Activiti依赖导入 -->
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-spring-boot-starter-basic</artifactId>
            <version>6.0.0</version>
        </dependency>
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-spring-boot-starter-rest-api</artifactId>
            <version>6.0.0</version>
        </dependency>
        <!--- Activiti依赖导入end -->
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-parent</artifactId>

<version>2.0.0.RELEASE</version>

</parent>

<groupId>com.example</groupId>

<version>0.0.1-SNAPSHOT</version>

<description>Demo project for Spring Boot</description>

<java.version>1.8</java.version>

</properties>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-web</artifactId>

</dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-freemarker</artifactId>

</dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-jdbc</artifactId>

</dependency>

<groupId>org.projectlombok</groupId>

<artifactId>lombok</artifactId>

<scope>provided</scope>

</dependency>

<groupId>mysql</groupId>

<artifactId>mysql-connector-java</artifactId>

</dependency>

<groupId>org.activiti</groupId>

<artifactId>activiti-spring-boot-starter-basic</artifactId>

</dependency>

<groupId>org.activiti</groupId>

<artifactId>activiti-spring-boot-starter-rest-api</artifactId>

</dependency>

</dependencies>

<build>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-maven-plugin</artifactId>

</plugin>

</plugins>

</build>

</project>

application.properties

最后两行日志配置是为了使用activiti时在控制台打印它的sql，方便查看

server.port=5656

spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/activiti?useUnicode=true&characterEncoding=utf8&useSSL=false&allowMultiQueries=true

#建表规则
#flase： 默认值。activiti在启动时，会对比数据库表中保存的版本，如果没有表或者版本不匹配，将抛出异常。
#true： activiti会对数据库中所有表进行更新操作。如果表不存在，则自动创建。
#create_drop： 在activiti启动时创建表，在关闭时删除表（必须手动关闭引擎，才能删除表）。
#drop-create： 在activiti启动时删除原来的旧表，然后在创建新表（不需要手动关闭引擎）
spring.activiti.check-process-definitions=false
#自动更新数据库结构
spring.activiti.database-schema-update=true 

# 打印mybatis的sql日志
logging.level.com.len.mapper=DEBUG
# 打印activiti的sql日志
logging.level.org.activiti.engine.impl.persistence.entity=trace

server.port=5656

spring.datasource.username=root

spring.datasource.password=123456

spring.datasource.driver-class-name=com.mysql.jdbc.Driver

spring.datasource.url=jdbc:mysql://localhost:3306/activiti?useUnicode=true&characterEncoding=utf8&useSSL=false&allowMultiQueries=true

#建表规则

#flase：默认值。activiti在启动时，会对比数据库表中保存的版本，如果没有表或者版本不匹配，将抛出异常。

#true： activiti会对数据库中所有表进行更新操作。如果表不存在，则自动创建。

#create_drop：在activiti启动时创建表，在关闭时删除表（必须手动关闭引擎，才能删除表）。

#drop-create：在activiti启动时删除原来的旧表，然后在创建新表（不需要手动关闭引擎）

spring.activiti.check-process-definitions=false

#自动更新数据库结构

spring.activiti.database-schema-update=true

# 打印mybatis的sql日志

logging.level.com.len.mapper=DEBUG

# 打印activiti的sql日志

logging.level.org.activiti.engine.impl.persistence.entity=trace

log4j.properties

#set log levels
log4j.rootLogger = debug , stdout , D , E

#输出到控制台
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern = %d{ABSOLUTE} %5p %c{ 1 }:%L - %m%n

#set log levels

log4j.rootLogger = debug , stdout , D , E

#输出到控制台

log4j.appender.stdout = org.apache.log4j.ConsoleAppender

log4j.appender.stdout.Target = System.out

log4j.appender.stdout.layout = org.apache.log4j.PatternLayout

log4j.appender.stdout.layout.ConversionPattern = %d{ABSOLUTE} %5p %c{ 1 }:%L - %m%n

inspectProcess.bpmn20.xml

这是我的流程文件，可以通过eclipse或idea的activiti插件或者官方的流程设计器来进行设计

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL"
             xmlns:activiti="http://activiti.org/bpmn"
             xmlns:di="http://www.omg.org/spec/DD/20100524/DI"
             xmlns:tns="http://www.activiti.org/testm1583982383250"
             xmlns:xsd="http://www.w3.org/2001/XMLSchema"
             xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI"
             xmlns:dc="http://www.omg.org/spec/DD/20100524/DC"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             expressionLanguage="http://www.w3.org/1999/XPath"
             id="m1583982383250"
             name=""
             targetNamespace="http://www.activiti.org/testm1583982383250"
             typeLanguage="http://www.w3.org/2001/XMLSchema">
   <process id="inspectProcess" isClosed="false" isExecutable="true"
            name="inspectProcess"
            processType="None">
      <startEvent id="_begin" name="begin"/>
      <userTask activiti:candidateGroups="student" activiti:exclusive="true" id="_pir"
                name="post inspect request"/>
      <sequenceFlow id="_4" sourceRef="_begin" targetRef="_pir"/>
      <userTask activiti:exclusive="true" id="_da" name="director approve"/>
      <sequenceFlow id="_6" sourceRef="_pir" targetRef="_da"/>
      <endEvent id="_end" name="end"/>
      <sequenceFlow id="_8" sourceRef="_da" targetRef="_end"/>
   </process>
   <bpmndi:BPMNDiagram xmlns=""
                       documentation="background=#3C3F41;count=1;horizontalcount=1;orientation=0;width=842.4;height=1195.2;imageableWidth=832.4;imageableHeight=1185.2;imageableX=5.0;imageableY=5.0"
                       id="Diagram-_1"
                       name="New Diagram">
      <bpmndi:BPMNPlane bpmnElement="inspectProcess">
         <bpmndi:BPMNShape bpmnElement="_begin" id="Shape-_begin">
            <dc:Bounds height="32.0" width="32.0" x="75.0" y="195.0"/>
            <bpmndi:BPMNLabel>
               <dc:Bounds height="32.0" width="32.0" x="0.0" y="0.0"/>
            </bpmndi:BPMNLabel>
         </bpmndi:BPMNShape>
         <bpmndi:BPMNShape bpmnElement="_pir" id="Shape-_pir">
            <dc:Bounds height="55.0" width="85.0" x="205.0" y="190.0"/>
            <bpmndi:BPMNLabel>
               <dc:Bounds height="55.0" width="85.0" x="0.0" y="0.0"/>
            </bpmndi:BPMNLabel>
         </bpmndi:BPMNShape>
         <bpmndi:BPMNShape bpmnElement="_da" id="Shape-_da">
            <dc:Bounds height="55.0" width="85.0" x="405.0" y="190.0"/>
            <bpmndi:BPMNLabel>
               <dc:Bounds height="55.0" width="85.0" x="0.0" y="0.0"/>
            </bpmndi:BPMNLabel>
         </bpmndi:BPMNShape>
         <bpmndi:BPMNShape bpmnElement="_end" id="Shape-_end">
            <dc:Bounds height="32.0" width="32.0" x="580.0" y="205.0"/>
            <bpmndi:BPMNLabel>
               <dc:Bounds height="32.0" width="32.0" x="0.0" y="0.0"/>
            </bpmndi:BPMNLabel>
         </bpmndi:BPMNShape>
         <bpmndi:BPMNEdge bpmnElement="_4" id="BPMNEdge__4" sourceElement="_2" targetElement="_3">
            <di:waypoint x="107.0" y="211.0"/>
            <di:waypoint x="205.0" y="217.5"/>
            <bpmndi:BPMNLabel>
               <dc:Bounds height="0.0" width="0.0" x="0.0" y="0.0"/>
            </bpmndi:BPMNLabel>
         </bpmndi:BPMNEdge>
         <bpmndi:BPMNEdge bpmnElement="_6" id="BPMNEdge__6" sourceElement="_3" targetElement="_5">
            <di:waypoint x="290.0" y="217.5"/>
            <di:waypoint x="405.0" y="217.5"/>
            <bpmndi:BPMNLabel>
               <dc:Bounds height="0.0" width="0.0" x="0.0" y="0.0"/>
            </bpmndi:BPMNLabel>
         </bpmndi:BPMNEdge>
         <bpmndi:BPMNEdge bpmnElement="_8" id="BPMNEdge__8" sourceElement="_5" targetElement="_7">
            <di:waypoint x="490.0" y="217.5"/>
            <di:waypoint x="580.0" y="221.0"/>
            <bpmndi:BPMNLabel>
               <dc:Bounds height="0.0" width="0.0" x="0.0" y="0.0"/>
            </bpmndi:BPMNLabel>
         </bpmndi:BPMNEdge>
      </bpmndi:BPMNPlane>
   </bpmndi:BPMNDiagram>
</definitions>

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>

<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL"

xmlns:activiti="http://activiti.org/bpmn"

xmlns:di="http://www.omg.org/spec/DD/20100524/DI"

xmlns:tns="http://www.activiti.org/testm1583982383250"

xmlns:xsd="http://www.w3.org/2001/XMLSchema"

xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI"

xmlns:dc="http://www.omg.org/spec/DD/20100524/DC"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

expressionLanguage="http://www.w3.org/1999/XPath"

id="m1583982383250"

name=""

targetNamespace="http://www.activiti.org/testm1583982383250"

typeLanguage="http://www.w3.org/2001/XMLSchema">

<process id="inspectProcess" isClosed="false" isExecutable="true"

name="inspectProcess"

processType="None">

<userTask activiti:candidateGroups="student" activiti:exclusive="true" id="_pir"

name="post inspect request"/>

</process>

<bpmndi:BPMNDiagram xmlns=""

documentation="background=#3C3F41;count=1;horizontalcount=1;orientation=0;width=842.4;height=1195.2;imageableWidth=832.4;imageableHeight=1185.2;imageableX=5.0;imageableY=5.0"

id="Diagram-_1"

name="New Diagram">

<bpmndi:BPMNPlane bpmnElement="inspectProcess">

<bpmndi:BPMNShape bpmnElement="_begin" id="Shape-_begin">

<dc:Bounds height="32.0" width="32.0" x="75.0" y="195.0"/>

<bpmndi:BPMNLabel>

<dc:Bounds height="32.0" width="32.0" x="0.0" y="0.0"/>

</bpmndi:BPMNLabel>

</bpmndi:BPMNShape>

<bpmndi:BPMNShape bpmnElement="_pir" id="Shape-_pir">

<dc:Bounds height="55.0" width="85.0" x="205.0" y="190.0"/>

<bpmndi:BPMNLabel>

<dc:Bounds height="55.0" width="85.0" x="0.0" y="0.0"/>

</bpmndi:BPMNLabel>

</bpmndi:BPMNShape>

<bpmndi:BPMNShape bpmnElement="_da" id="Shape-_da">

<dc:Bounds height="55.0" width="85.0" x="405.0" y="190.0"/>

<bpmndi:BPMNLabel>

<dc:Bounds height="55.0" width="85.0" x="0.0" y="0.0"/>

</bpmndi:BPMNLabel>

</bpmndi:BPMNShape>

<bpmndi:BPMNShape bpmnElement="_end" id="Shape-_end">

<dc:Bounds height="32.0" width="32.0" x="580.0" y="205.0"/>

<bpmndi:BPMNLabel>

<dc:Bounds height="32.0" width="32.0" x="0.0" y="0.0"/>

</bpmndi:BPMNLabel>

</bpmndi:BPMNShape>

<bpmndi:BPMNEdge bpmnElement="_4" id="BPMNEdge__4" sourceElement="_2" targetElement="_3">

<di:waypoint x="107.0" y="211.0"/>

<di:waypoint x="205.0" y="217.5"/>

<bpmndi:BPMNLabel>

<dc:Bounds height="0.0" width="0.0" x="0.0" y="0.0"/>

</bpmndi:BPMNLabel>

</bpmndi:BPMNEdge>

<bpmndi:BPMNEdge bpmnElement="_6" id="BPMNEdge__6" sourceElement="_3" targetElement="_5">

<di:waypoint x="290.0" y="217.5"/>

<di:waypoint x="405.0" y="217.5"/>

<bpmndi:BPMNLabel>

<dc:Bounds height="0.0" width="0.0" x="0.0" y="0.0"/>

</bpmndi:BPMNLabel>

</bpmndi:BPMNEdge>

<bpmndi:BPMNEdge bpmnElement="_8" id="BPMNEdge__8" sourceElement="_5" targetElement="_7">

<di:waypoint x="490.0" y="217.5"/>

<di:waypoint x="580.0" y="221.0"/>

<bpmndi:BPMNLabel>

<dc:Bounds height="0.0" width="0.0" x="0.0" y="0.0"/>

</bpmndi:BPMNLabel>

</bpmndi:BPMNEdge>

</bpmndi:BPMNPlane>

</bpmndi:BPMNDiagram>

</definitions>

在resources资源目录下新建processes目录,把资源文件放进去， src/main/resources/processes, springboot默认是到这个文件夹里去找流程图进行部署的

ActivitiConfig.java

import org.activiti.engine.*;
import org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration;
import org.activiti.rest.service.api.RestResponseFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.converter.ContentTypeResolver;
import org.springframework.messaging.converter.DefaultContentTypeResolver;
import org.springframework.stereotype.Component;

@Configuration
public class ActivitiConfig {

    @Value("${spring.datasource.url}")
    private String url;

    @Value("${spring.datasource.username}")
    private String userName;

    @Value("${spring.datasource.password}")
    private String password;

    @Value("${spring.datasource.driver-class-name}")
    private String driver;


    // activiti rest service
    @Bean
    public RestResponseFactory restResponseFactory(){
        return new RestResponseFactory();
    }

    @Bean
    public ContentTypeResolver contentTypeResolver(){
        return new DefaultContentTypeResolver();
    }

    // activiti core
    // ProcessEngine 和服务类都是线程安全的。

    @Bean
    public ProcessEngineConfiguration processEngineConfiguration() {
        ProcessEngineConfiguration processEngineConfiguration = new StandaloneProcessEngineConfiguration();
        // 连接数据库的配置
        processEngineConfiguration.setJdbcDriver(driver);
        processEngineConfiguration.setJdbcUrl(url);
        processEngineConfiguration.setJdbcUsername(userName);
        processEngineConfiguration.setJdbcPassword(password);
        processEngineConfiguration.setAsyncExecutorActivate(true);
        processEngineConfiguration.setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);
        return processEngineConfiguration;
    }
    
   /* @Bean
    public ProcessEngine processEngine() {
        return processEngineConfiguration().buildProcessEngine();
    }
    */
    @Bean
    public RepositoryService repositoryService() {
        return processEngineConfiguration().buildProcessEngine().getRepositoryService();
    }

    @Bean
    public RuntimeService runtimeService() {
        return processEngineConfiguration().buildProcessEngine().getRuntimeService();
    }

    @Bean
    public TaskService taskService() {
        return processEngineConfiguration().buildProcessEngine().getTaskService();
    }

    @Bean
    public FormService formService() {
        return processEngineConfiguration().buildProcessEngine().getFormService();
    }

    @Bean
    public HistoryService historyService() {
        return processEngineConfiguration().buildProcessEngine().getHistoryService();
    }

    @Bean
    public ManagementService managementService() {
        return processEngineConfiguration().buildProcessEngine().getManagementService();
    }

    @Bean
    public IdentityService identityService() {
        return processEngineConfiguration().buildProcessEngine().getIdentityService();
    }
}

import org.activiti.engine.*;

import org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration;

import org.activiti.rest.service.api.RestResponseFactory;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.messaging.converter.ContentTypeResolver;

import org.springframework.messaging.converter.DefaultContentTypeResolver;

import org.springframework.stereotype.Component;

@Configuration

public class ActivitiConfig {

@Value("${spring.datasource.url}")

private String url;

@Value("${spring.datasource.username}")

private String userName;

@Value("${spring.datasource.password}")

private String password;

@Value("${spring.datasource.driver-class-name}")

private String driver;

// activiti rest service

@Bean

public RestResponseFactory restResponseFactory(){

return new RestResponseFactory();

}

@Bean

public ContentTypeResolver contentTypeResolver(){

return new DefaultContentTypeResolver();

}

// activiti core

// ProcessEngine 和服务类都是线程安全的。

@Bean

public ProcessEngineConfiguration processEngineConfiguration() {

ProcessEngineConfiguration processEngineConfiguration = new StandaloneProcessEngineConfiguration();

// 连接数据库的配置

processEngineConfiguration.setJdbcDriver(driver);

processEngineConfiguration.setJdbcUrl(url);

processEngineConfiguration.setJdbcUsername(userName);

processEngineConfiguration.setJdbcPassword(password);

processEngineConfiguration.setAsyncExecutorActivate(true);

processEngineConfiguration.setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);

return processEngineConfiguration;

}

/* @Bean

public ProcessEngine processEngine() {

return processEngineConfiguration().buildProcessEngine();

}

@Bean

public RepositoryService repositoryService() {

return processEngineConfiguration().buildProcessEngine().getRepositoryService();

}

@Bean

public RuntimeService runtimeService() {

return processEngineConfiguration().buildProcessEngine().getRuntimeService();

}

@Bean

public TaskService taskService() {

return processEngineConfiguration().buildProcessEngine().getTaskService();

}

@Bean

public FormService formService() {

return processEngineConfiguration().buildProcessEngine().getFormService();

}

@Bean

public HistoryService historyService() {

return processEngineConfiguration().buildProcessEngine().getHistoryService();

}

@Bean

public ManagementService managementService() {

return processEngineConfiguration().buildProcessEngine().getManagementService();

}

@Bean

public IdentityService identityService() {

return processEngineConfiguration().buildProcessEngine().getIdentityService();

}

LeaveProcessController.java

import lombok.extern.slf4j.Slf4j;
import org.activiti.engine.*;
import org.activiti.engine.history.HistoricProcessInstance;
import org.activiti.engine.identity.Group;
import org.activiti.engine.identity.User;
import org.activiti.engine.repository.Deployment;
import org.activiti.engine.repository.ProcessDefinition;
import org.activiti.engine.task.Task;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
@Slf4j
public class LeaveProcessController {

    @Autowired
    private RuntimeService runtimeService;

    @Autowired
    private TaskService taskService;

    @Autowired
    private RepositoryService repositoryService;

    @Autowired
    private HistoryService historyService;

    @Autowired
    private IdentityService identityService;

    /**
     * 一个示例流程
     * @return
     */
    @GetMapping("/process")
    public void process(){

        // 先准备好用户、用户组
        addUser();
        addGroup();
        relationUserGroup();

        // 部署流程
        Deployment deployment = repositoryService.createDeployment()
                .addClasspathResource("processes/inspectProcess.bpmn20.xml")
                .name("test inspect")
                .key("shOffice")
                .deploy();

        ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery()
                .deploymentId(deployment.getId()).singleResult();
        log.info("流程名称 ： [" + processDefinition.getName() + "]， 流程ID ： ["
                + processDefinition.getId() + "], 流程KEY : " + processDefinition.getKey());

        // 开始流程
        String procId = runtimeService.startProcessInstanceByKey(processDefinition.getKey()).getId();

        /*// 给一个新任务添加候选人组student
        Task sTask = taskService.newTask();
        taskService.addCandidateGroup(sTask.getId(), "student");*/

        // 获取指定用户组的 Task 列表,并使用指定用户领取这些任务
        List<Task> tasks = taskService.createTaskQuery().taskCandidateGroup("student").list();
        for (Task task : tasks) {
            System.out.println("student分组的任务: " + task.getName());
            // 用户Jonathan领取任务
            taskService.claim(task.getId(), "Jonathan");
        }

        // 获取Jonathan用户的工作 Task 列表，并完成这些任务
        tasks = taskService.createTaskQuery().taskAssignee("Jonathan").list();
        for (Task task : tasks) {
            log.info("Jonathan的任务: " + task.getName());
            // 完成
            taskService.complete(task.getId());
        }

        log.info("用户Jonathan的任务数量: " +
                taskService.createTaskQuery().taskAssignee("Jonathan").count());

        // 使用 HistoryService 来查询指定流程实例的状态
        HistoricProcessInstance historicProcessInstance =
                historyService.createHistoricProcessInstanceQuery().processInstanceId(procId).singleResult();
        log.info("流程结束时间: " + historicProcessInstance.getEndTime());
    }


    public void addUser(){
        //先查询用户
        User userInDb = identityService.createUserQuery().userId("Jonathan").singleResult();
        if (userInDb == null){
            User user = identityService.newUser("Jonathan");
            user.setFirstName("Jonathan");
            user.setLastName("chang");
            user.setEmail("whatlookingfor@gmail.com");
            user.setPassword("123");
            //保存用户到数据库
            identityService.saveUser(user);
        }
    }

    public void addGroup(){
        Group groupInDb = identityService.createGroupQuery().groupId("student").singleResult();
        if (groupInDb == null){
            //创建用户组对象
            Group group = identityService.newGroup("student");
            group.setName("student用户组");
            group.setType("ask");
            //保存用户组
            identityService.saveGroup(group);
        }
    }

    public void relationUserGroup(){
        // 查询属于student用户组的用户
        User userInGroup = identityService.createUserQuery().memberOfGroup("student").singleResult();
        User userInDb = identityService.createUserQuery().userId("Jonathan").singleResult();
        if (userInGroup == null || !userInGroup.getId().equals(userInDb.getId())){
            //将用户Jonathan加入到用户组student中
            identityService.createMembership("Jonathan","student");
        }
    }


}

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

import lombok.extern.slf4j.Slf4j;

import org.activiti.engine.*;

import org.activiti.engine.history.HistoricProcessInstance;

import org.activiti.engine.identity.Group;

import org.activiti.engine.identity.User;

import org.activiti.engine.repository.Deployment;

import org.activiti.engine.repository.ProcessDefinition;

import org.activiti.engine.task.Task;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.web.bind.annotation.GetMapping;

import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController

@Slf4j

public class LeaveProcessController {

@Autowired

private RuntimeService runtimeService;

@Autowired

private TaskService taskService;

@Autowired

private RepositoryService repositoryService;

@Autowired

private HistoryService historyService;

@Autowired

private IdentityService identityService;

/**

* 一个示例流程

* @return

@GetMapping("/process")

public void process(){

// 先准备好用户、用户组

addUser();

addGroup();

relationUserGroup();

// 部署流程

Deployment deployment = repositoryService.createDeployment()

.addClasspathResource("processes/inspectProcess.bpmn20.xml")

.name("test inspect")

.key("shOffice")

.deploy();

ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery()

.deploymentId(deployment.getId()).singleResult();

log.info("流程名称： [" + processDefinition.getName() + "]，流程ID ： ["

+ processDefinition.getId() + "], 流程KEY : " + processDefinition.getKey());

// 开始流程

String procId = runtimeService.startProcessInstanceByKey(processDefinition.getKey()).getId();

/*// 给一个新任务添加候选人组student

Task sTask = taskService.newTask();

taskService.addCandidateGroup(sTask.getId(), "student");*/

// 获取指定用户组的 Task 列表,并使用指定用户领取这些任务

List<Task> tasks = taskService.createTaskQuery().taskCandidateGroup("student").list();

for (Task task : tasks) {

System.out.println("student分组的任务: " + task.getName());

// 用户Jonathan领取任务

taskService.claim(task.getId(), "Jonathan");

}

// 获取Jonathan用户的工作 Task 列表，并完成这些任务

tasks = taskService.createTaskQuery().taskAssignee("Jonathan").list();

for (Task task : tasks) {

log.info("Jonathan的任务: " + task.getName());

// 完成

taskService.complete(task.getId());

}

log.info("用户Jonathan的任务数量: " +

taskService.createTaskQuery().taskAssignee("Jonathan").count());

// 使用 HistoryService 来查询指定流程实例的状态

HistoricProcessInstance historicProcessInstance =

historyService.createHistoricProcessInstanceQuery().processInstanceId(procId).singleResult();

log.info("流程结束时间: " + historicProcessInstance.getEndTime());

}

public void addUser(){

//先查询用户

User userInDb = identityService.createUserQuery().userId("Jonathan").singleResult();

if (userInDb == null){

User user = identityService.newUser("Jonathan");

user.setFirstName("Jonathan");

user.setLastName("chang");

user.setEmail("whatlookingfor@gmail.com");

user.setPassword("123");

//保存用户到数据库

identityService.saveUser(user);

}

public void addGroup(){

Group groupInDb = identityService.createGroupQuery().groupId("student").singleResult();

if (groupInDb == null){

//创建用户组对象

Group group = identityService.newGroup("student");

group.setName("student用户组");

group.setType("ask");

//保存用户组

identityService.saveGroup(group);

}

public void relationUserGroup(){

// 查询属于student用户组的用户

User userInGroup = identityService.createUserQuery().memberOfGroup("student").singleResult();

User userInDb = identityService.createUserQuery().userId("Jonathan").singleResult();

if (userInGroup == null || !userInGroup.getId().equals(userInDb.getId())){

//将用户Jonathan加入到用户组student中

identityService.createMembership("Jonathan","student");

}

工程图

这样SpringBoot2.0整合activiti6示例就完成了。如果有问题欢迎留言。