【业务功能篇36】Springboot+activiti7 工作流引擎

雨点打透心脏的1/2处 2024-03-17 12:47 34阅读 0赞

> 业务场景：前段时间总结的有一个告警工单流程，我们都是直接自己建表，状态节点，操作节点，都是自定义设计的，而到后面会有很多的工单流程，比如创建一个遗留问题电子流，指定处理人进行分析闭环，等等多种电子流，后期重复的开发工作以及维护工作会越来越多。那么这里我们可以借助开源的工作流引擎 activiti

*  Activiti是一个工作流引擎， activiti可以将业务系统中复杂的业务流程抽取出来，使用专门的建模语言（BPMN2.0）进行定义，业务系统按照预先定义的流程进行执行，实现了业务系统的业务流程由activiti进行管理，减少业务系统由于流程变更进行系统升级改造的工作量，从而提高系统的健壮性，同时也减少了系统开发维护成本。

## **前置条件** ##

1.  本地安装jdk8以上
2.  下载tomcat, 下载过程需要选择jre，所以要先安装好jdk

### 安装 ###

> Activiti6.0官方文档：https://www.activiti.org/userguide/
> 
> 下载Activiti6.0，解压后有activiti-app.war、activiti-admin.war、activiti-rest.war三个war包。
> 
>  *  activiti-app：在线流程设计器、表单管理、应用管理、用户管理等；
>  *  activiti-admin：查看流程定义、发起的流程实例、任务等；
>  *  activiti-rest：提供Restful风格的服务；
> 
> 将上面3个war放到tomcat的webapps目录下，运行bin目录下的startup.bat可以启动应用。
> 
> 启动应用后，浏览器可以访问：  
> http://localhost:8080/activiti-app 默认账号密码：admin test  
> http://localhost:8080/activiti-admin 默认账号密码：admin admin  
> http://127.0.0.1:8080/activiti-rest/docs 默认账号密码：kermit kermit
> 
> 补充： 这里我们只需要运用这个app包，来进行在线流程设计，也就是用建模语言bpmn2.0定义流程图，结合实际业务场景的流程进行作图设计，然后再导出 xml文件，再放到我们的项目程序运行即可

### 访问登录后页面 ###

### ![f658ac1265f7432fa591578dd5a75dd4.png][] ###

这里我们是利用create process 创建流程，进行我们的业务流程图定义

![8dc47cb8811146338e38a47515570dad.png][]

### 总结特点： ###

> 1.流程图准备：
> 
> 把对应的流程图画好导出bpmn2.0文件后，放入到项目中 resources -> process 目录下 ，文件以xml形式保存
> 
> 2.引入依赖jar包
> 
>     <dependency>
>     
>     <groupId>org.activiti</groupId>
>     
>     <artifactId>activiti-spring-boot-starter</artifactId>
>     
>     <version>7.1.0.M6</version>
>     
>     <exclusions>
>     
>     <exclusion>
>     
>     <groupId>org.springframework.boot</groupId>
>     
>     <artifactId>spring-boot-actuator-autoconfigure</artifactId>
>     
>     </exclusion>
>     
>     </exclusions>
>     
>     </dependency>
>     
>     
>     
>     <dependency>
>     
>     <groupId>org.springframework.boot</groupId>
>     
>     <artifactId>spring-boot-starter-security</artifactId>
>     
>     <version>2.6.6</version>
>     
>     </dependency>
> 
> 3.配置文件中 进行配置
> 
>     activiti:
>     
>     database-schema-update:true   
>     
>     #drop-create   该配置表示每次会删除activiti框架内置的表，然后再重新创建   true值则不会再重新建表
>     
>     history-level:full
>     
>     deployment-name:deploy-test
>     
>     db-history-used:true
>     
>     #process-definition-location-prefix:classpath*:/processes/
> 
> 4.接着运行程序项目后，框架会许多事情：
> 
> act\_ge\_bytearray 保存bpmn2.0xml文件记录
> 
> act\_re\_procdef 给bpmn2.0xml，创建对应的流程定义
> 
> 5.也可以调用service接口 当前前端在创建一个问题电子流时，先生成一个 流程定义，对应的在act\_re\_procdef 表中会生成一个流程定义记录，对应的key是自定义的一个常量
> 
>     @Override
>     
>     publicProcessDefinitiongetKnowIssueProcessDef(){
>     
>     Return repositoryService.createProcessDefinitionQuery()
>     
>     .processDefinitionKey(KNOWN_ISSUE_PROCESS_DEF_KEY)
>     
>     .latestVersion()
>     
>     .singleResult();
>     
>     }
> 
> 6.针对该流程定义，创建一个实例，也就是开始一个流程的处理，需要由一个实例类对象来承载完成，与此同时，在对应的act\_ru\_task表中会生成一个该流程的一个子任务，也就是说，流程实例创建后，会对应这多个task任务，比如责任人处理任务，审批任务等，会把当前节点转到第一个子任务上，而不是在一开始的 开始事件
> 
> ProcessInstanceprocessInstance=runtimeService.startProcessInstanceByKey(*KNOWN\_ISSUE\_PROCESS\_DEF\_KEY*);
> 
> 7.状态开始流转，节点任务走完，调用task的接口方法，传递对应的任务id
> 
>     ProcessInstanceprocessInstance=runtimeService.startProcessInstanceByKey(KNOWN_ISSUE_PROCESS_DEF_KEY);
>     
>     StringprocessInstanceId=processInstance.getId();
>     
>     Tasktask=getKnownIssueTaskByProcessInstanceId(processInstanceId);
>     
>      
>     
>     @Override
>     
>     publicTaskgetKnownIssueTaskByProcessInstanceId(StringprocessInstanceId){
>     
>     returntaskService.createTaskQuery()
>     
>     .active()
>     
>     .processInstanceId(processInstanceId)
>     
>     .taskDefinitionKey(KNOWN_ISSUE_TASK_DEF_KEY)
>     
>     .singleResult();
>     
>     }
>     
>      
>     
>      
>     
>     taskService.complete(task.getId());
> 
> 8.如果流程只有一个任务节点，那么完成之后，流程就会结束，在act\_ru\_task表中的任务记录就会删除，并且在 act\_hi\_taskinst表中会记录着这个任务的历史记录 ， act\_hi\_actinst表中则会记录整个流程过程记录，比如一开始的开始事件--》 到任务节点 --》 到结束事件，分别记录这几条数据，任务节点停留了多长时间
> 
> 9.流程涉及有审批的话，就会有审批通过与驳回，这时需要增加一个 排他网关节点，通过设定一个全局变量，在审批任务执行完成时，通过内置方设置变量值，我们自定义，值为true则审批通过，流程结束，为false那么就驳回，流程节点回到前一个任务，设置变量记录会在 act\_ru\_variable表中记录
> 
> ![f165caee0a1a415598cbd26e0cae53ca.png][]
> 
> 10.一个流程，调用另外一个子流程
> 
> ![9c8fa475686a45029c4549a2be9463a3.png][]

### 这里直接展开我们业务的遗留问题单电子流的功能设计开发 ###

### controller层 ###

package com.xxx.service;
    
    import com.xxx.delegate.ProcessKnownIssueDelegate;
    import org.springframework.web.bind.annotation.*;
    import com.xxx.model.KnowIssueCreateParam;
    import org.springframework.validation.annotation.Validated;
    import com.xxx.model.UpdateProgressParam;
    import com.xxx.tools.commonlib.exception.ServiceException;
    import org.springframework.beans.factory.annotation.Autowired;
    import com.xxx.model.KnownIssueInfo;
    import com.xxx.model.ResponseVo;
    
    
    
    @RestController
    @RequestMapping(value = "/process/knownIssue", produces = {"application/json;charset=UTF-8"})
    @Validated
    public class ProcessKnownIssueController {
    
        @Autowired(required=false) 
        private ProcessKnownIssueDelegate delegate;  
    	
        @RequestMapping(
        		value = "/closeKnownIssue", 
        		produces = { "application/json" }, 
        		method = RequestMethod.POST)
        public ResponseVo closeKnownIssue(@RequestBody KnownIssueInfo knownIssueInfo) 
                throws ServiceException {
        	    
    		return delegate.closeKnownIssue(knownIssueInfo);
        }
    
    	
        @RequestMapping(
        		value = "/createKnownIssue", 
        		produces = { "application/json" }, 
        		method = RequestMethod.POST)
        public ResponseVo createKnownIssue(@RequestBody KnowIssueCreateParam knowIssueCreateParam) 
                throws ServiceException {
        	    
    		return delegate.createKnownIssue(knowIssueCreateParam);
        }
    
    	
        @RequestMapping(
        		value = "/getKnownIssueDesc", 
        		produces = { "application/json" }, 
        		method = RequestMethod.GET)
        public ResponseVo getKnownIssueDesc( @RequestParam(value = "knownIssueId", required = true) String knownIssueId) 
                throws ServiceException {
        	    
    		return delegate.getKnownIssueDesc(knownIssueId);
        }
    
    	
        @RequestMapping(
        		value = "/getKnownIssueDetails", 
        		produces = { "application/json" }, 
        		method = RequestMethod.GET)
        public ResponseVo getKnownIssueDetails( @RequestParam(value = "knownIssueId", required = true) String knownIssueId) 
                throws ServiceException {
        	    
    		return delegate.getKnownIssueDetails(knownIssueId);
        }
    
    	
        @RequestMapping(
        		value = "/getKnownIssueList", 
        		produces = { "application/json" }, 
        		method = RequestMethod.GET)
        public ResponseVo getKnownIssueList( @RequestParam(value = "pageNo", required = true) Integer pageNo,
        		 @RequestParam(value = "pageSize", required = true) Integer pageSize) 
                throws ServiceException {
        	    
    		return delegate.getKnownIssueList(pageNo
    			, pageSize);
        }
    
    	
        @RequestMapping(
        		value = "/getKnownIssueMoreDetails", 
        		produces = { "application/json" }, 
        		method = RequestMethod.GET)
        public ResponseVo getKnownIssueMoreDetails( @RequestParam(value = "knownIssueId", required = true) String knownIssueId) 
                throws ServiceException {
        	    
    		return delegate.getKnownIssueMoreDetails(knownIssueId);
        }
    
    	
        @RequestMapping(
        		value = "/getKnownIssueProgress", 
        		produces = { "application/json" }, 
        		method = RequestMethod.GET)
        public ResponseVo getKnownIssueProgress( @RequestParam(value = "knownIssueId", required = true) String knownIssueId) 
                throws ServiceException {
        	    
    		return delegate.getKnownIssueProgress(knownIssueId);
        }
    
    	
        @RequestMapping(
        		value = "/updateProgress", 
        		produces = { "application/json" }, 
        		method = RequestMethod.POST)
        public ResponseVo updateProgress(@RequestBody UpdateProgressParam updateProgressParam) 
                throws ServiceException {
        	    
    		return delegate.updateProgress(updateProgressParam);
        }
    }

### service层 接口 ###

package com.xxx.delegate;
    
    import com.xxx.model.KnowIssueCreateParam;
    import com.xxx.model.KnownIssueInfo;
    import com.xxx.model.UpdateProgressParam;
    import com.xxx.model.ResponseVo;
    import com.xxx.tools.commonlib.exception.ServiceException;
    
    
    
    public interface ProcessKnownIssueDelegate {
      
        ResponseVo closeKnownIssue(KnownIssueInfo knownIssueInfo) 
        	throws ServiceException;
      
        ResponseVo createKnownIssue(KnowIssueCreateParam knowIssueCreateParam) 
        	throws ServiceException;
      
        ResponseVo getKnownIssueDesc(String knownIssueId) 
        	throws ServiceException;
      
        ResponseVo getKnownIssueDetails(String knownIssueId) 
        	throws ServiceException;
      
        ResponseVo getKnownIssueList(Integer pageNo,
                         Integer pageSize) 
        	throws ServiceException;
      
        ResponseVo getKnownIssueMoreDetails(String knownIssueId) 
        	throws ServiceException;
      
        ResponseVo getKnownIssueProgress(String knownIssueId) 
        	throws ServiceException;
      
        ResponseVo updateProgress(UpdateProgressParam updateProgressParam) 
        	throws ServiceException;
      
    }

### service层 实现类 ###

这里的业务层比较抽象，下层还有定义了更具象的服务接口，注入该实现类进行调用

package com.xxx.impl.process;
    
    import com.xxx.delegate.ProcessKnownIssueDelegate;
    import com.xxx.model.KnowIssueCreateParam;
    import com.xxx.model.KnownIssueInfo;
    import com.xxx.model.ResponseVo;
    import com.xxx.model.UpdateProgressParam;
    import com.xxx.energytools.domain.entity.VerifyInfo;
    import com.xxx.energytools.service.process.ProcessKnownIssueService;
    import com.xxx.energytools.utils.ResponseUtils;
    import lombok.extern.slf4j.Slf4j;
    import org.apache.commons.lang3.StringUtils;
    import org.springframework.stereotype.Service;
    
    import javax.annotation.Resource;
    import java.util.List;
    
    
    @Slf4j
    @Service
    public class ProcessKnownIssueDelegateImpl implements ProcessKnownIssueDelegate {
        @Resource
        ProcessKnownIssueService processKnownIssueService;
    
    
        /**
         * closeKnownIssue
         * 
         * @param knownIssueInfo knownIssueInfo
         * @return ResponseVo
         */
        @Override
        public ResponseVo closeKnownIssue(KnownIssueInfo knownIssueInfo) {
            boolean closed = processKnownIssueService.closeKnownIssue(knownIssueInfo.getKnownIssueId());
            if (closed) {
                return ResponseUtils.successResponse("问题关闭成功", "问题关闭成功");
            }
            return ResponseUtils.errorResponse(null, "问题关闭失败");
        }
    
    
        /**
         * createKnownIssue
         * 
         * @param knowIssueCreateParam knowIssueCreateParam
         * @return ResponseVo
         */
        @Override
        public ResponseVo createKnownIssue(KnowIssueCreateParam knowIssueCreateParam) {
            VerifyInfo info = verifyKnowIssueCreateParam(knowIssueCreateParam);
            if (!info.isPass()) {
                return ResponseUtils.errorResponse(info.getMessage(), "创建字段错误");
            }
            VerifyInfo knownIssue = processKnownIssueService.createKnownIssue(knowIssueCreateParam);
            if (knownIssue.isPass()) {
                return ResponseUtils.successResponse(knownIssue.getMessage(), "创建遗留问题成功");
            }
            return ResponseUtils.errorResponse(knownIssue.getMessage(), "创建遗留问题失败");
        }
    
    
        /**
         * verifyKnowIssueCreateParam
         * 
         * @param knowIssueCreateParam knowIssueCreateParam
         * @return VerifyInfo
         */
        private VerifyInfo verifyKnowIssueCreateParam(KnowIssueCreateParam knowIssueCreateParam) {
            VerifyInfo result = new VerifyInfo();
            if (knowIssueCreateParam == null) {
                return result.notPassed("创建字段为空");
            }
            if (StringUtils.isEmpty(knowIssueCreateParam.getIssueDesc())) {
                return result.notPassed("问题描述为空");
            }
            List<String> handlers = knowIssueCreateParam.getHandlers();
            if (handlers == null || handlers.isEmpty()) {
                result.notPassed("处理人为空");
            }
            return result;
        }
    
    
        /**
         * getKnownIssueDesc
         * 
         * @param knownIssueId knownIssueId
         * @return ResponseVo
         */
        @Override
        public ResponseVo getKnownIssueDesc(String knownIssueId) {
            return ResponseUtils.successResponse(processKnownIssueService.getKnownIssueDesc(knownIssueId), "获取信息成功");
        }
    
    
        /**
         * getKnownIssueDetails
         * 
         * @param knownIssueId knownIssueId
         * @return ResponseVo
         */
        @Override
        public ResponseVo getKnownIssueDetails(String knownIssueId) {
            return ResponseUtils.successResponse(processKnownIssueService.getKnownIssueDetails(knownIssueId), "获取信息成功");
        }
    
    
        /**
         * getKnownIssueList
         * 
         * @param pageNo pageNo
         * @param pageSize pageSize
         * @return ResponseVo
         */
        @Override
        public ResponseVo getKnownIssueList(Integer pageNo, Integer pageSize) {
            return processKnownIssueService.getKnownIssueList(pageNo, pageSize);
        }
    
    
        /**
         * getKnownIssueMoreDetails
         * 
         * @param knownIssueId knownIssueId
         * @return ResponseVo
         */
        @Override
        public ResponseVo getKnownIssueMoreDetails(String knownIssueId) {
            return ResponseUtils.successResponse(processKnownIssueService.getKnownIssueDetails(knownIssueId), "获取信息成功");
        }
    
    
        /**
         * getKnownIssueProgress
         * 
         * @param knownIssueId knownIssueId
         * @return ResponseVo
         */
        @Override
        public ResponseVo getKnownIssueProgress(String knownIssueId) {
            return ResponseUtils.successResponse(processKnownIssueService.getProgressDetailsByKnowIssueId(knownIssueId), "获取信息成功");
        }
    
    
        /**
         * updateProgress
         * 
         * @param updateProgressParam updateProgressParam
         * @return ResponseVo
         */
        @Override
        public ResponseVo updateProgress(UpdateProgressParam updateProgressParam) {
            String content = updateProgressParam.getContent();
            if (StringUtils.isBlank(content)) {
                return ResponseUtils.errorResponse(null, "更新进展失败: 进展不能为空");
            }
            VerifyInfo verifyInfo = processKnownIssueService.updateProcess(updateProgressParam);
            if (verifyInfo.isPass()) {
                return ResponseUtils.successResponse("更新进展成功", "更新进展成功");
            }
            return ResponseUtils.errorResponse(null, verifyInfo.getMessage());
        }
    }

### service层 接口 ###

package com.xxx.service.process;
    
    import com.xxx.model.KnowIssueCreateParam;
    import com.xxx.model.ResponseVo;
    import com.xxx.model.UpdateProgressParam;
    import com.xxx.domain.entity.VerifyInfo;
    import com.xxx.domain.vo.process.KnownIssueDetailsVo;
    import com.xxx.domain.vo.ProgressDetailsVo;
    
    import org.activiti.engine.repository.ProcessDefinition;
    import org.activiti.engine.task.Task;
    
    import java.util.List;
    
    
    public interface ProcessKnownIssueService {
    
        /**
         * getKnowIssueProcessDef
         * 
         * @return ProcessDefinition
         */
        ProcessDefinition getKnowIssueProcessDef();
    
    
        /**
         * createKnownIssue
         * 
         * @param createParam createParam
         * @return VerifyInfo
         */
        VerifyInfo createKnownIssue(KnowIssueCreateParam createParam);
    
    
        /**
         * getKnownIssueTaskByProcessInstanceId
         * 
         * @param processInstanceId processInstanceId
         * @return Task
         */
        Task getKnownIssueTaskByProcessInstanceId(String processInstanceId);
    
    
        /**
         * closeKnownIssue
         * 
         * @param knownIssueId knownIssueId
         * @return boolean
         */
        boolean closeKnownIssue(String knownIssueId);
    
    
        /**
         * getKnownIssueDetails
         * 
         * @param taskId taskId
         * @return KnownIssueDetailsVo
         */
        KnownIssueDetailsVo getKnownIssueDetails(String taskId);
    
    
        /**
         * getKnownIssueDesc
         * 
         * @param taskId taskId
         * @return String
         */
        String getKnownIssueDesc(String taskId);
    
    
        /**
         * getProgressDetailsByKnowIssueId
         * 
         * @param taskId taskId
         * @return List<ProgressDetailsVo>
         */
        List<ProgressDetailsVo> getProgressDetailsByKnowIssueId(String taskId);
    
    
        /**
         * updateProcess
         * 
         * @param updateProgressParam updateProgressParam
         * @return VerifyInfo
         */
        VerifyInfo updateProcess(UpdateProgressParam updateProgressParam);
    
    
        /**
         * getKnownIssueList
         * 
         * @param pageNo pageNo
         * @param pageSize pageSize
         * @return ResponseVo
         */
        ResponseVo getKnownIssueList(Integer pageNo, Integer pageSize);
    }

### service层 实现类 ###

package com.xxx.service.impl.process;
    
    import com.alibaba.fastjson.JSONArray;
    import com.alibaba.fastjson.JSONObject;
    import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
    import com.xxx.model.KnowIssueCreateParam;
    import com.xxx.model.ResponseVo;
    import com.xxx.model.UpdateProgressParam;
    import com.xxx.adapter.UserAdapter;
    import com.xxx.domain.dto.process.ProcessVarHistoryRecordDto;
    import com.xxx.domain.entity.VerifyInfo;
    import com.xxx.domain.entity.user.UserModel;
    import com.xxx.domain.model.DpProcessMessage;
    import com.xxx.domain.model.KnownIssueDetailsTab;
    import com.xxx.domain.vo.ProgressDetailsVo;
    import com.xxx.domain.vo.UserVo;
    import com.xxx.domain.vo.process.KnownIssueDetailsVo;
    import com.xxx.domain.vo.process.KnownIssueInfoVo;
    import com.xxx.enums.State;
    import com.xxx.service.UserService;
    import com.xxx.service.dao.iservice.process.KnownIssueDetailsService;
    import com.xxx.service.dao.mapper.process.ProcessVarHistoryMapper;
    import com.xxx.service.process.ProcessKnownIssueService;
    import com.xxx.service.process.ProcessMessage;
    import com.xxx.utils.ResponseUtils;
    import lombok.extern.slf4j.Slf4j;
    import org.activiti.engine.RepositoryService;
    import org.activiti.engine.RuntimeService;
    import org.activiti.engine.TaskService;
    import org.activiti.engine.repository.ProcessDefinition;
    import org.activiti.engine.runtime.ProcessInstance;
    import org.activiti.engine.task.Task;
    import org.apache.commons.lang3.StringUtils;
    import org.springframework.stereotype.Service;
    
    import javax.annotation.Resource;
    import java.time.LocalDateTime;
    import java.util.ArrayList;
    import java.util.Comparator;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    import java.util.stream.Collectors;
    
    import static com.xxx.constants.process.ProcessConstants.CANCELED_STATE;
    import static com.xxx.constants.process.ProcessConstants.CLOSE_STATE;
    import static com.xxx.constants.process.ProcessConstants.KNOWN_ISSUE_PROCESS_DEF_KEY;
    import static com.xxx.constants.process.ProcessConstants.KNOWN_ISSUE_PROGRESS_CONTENT;
    import static com.xxx.constants.process.ProcessConstants.KNOWN_ISSUE_PROGRESS_UPDATER;
    import static com.xxx.constants.process.ProcessConstants.KNOWN_ISSUE_PROGRESS_VAR;
    import static com.xxx.constants.process.ProcessConstants.KNOWN_ISSUE_TASK_DEF_KEY;
    import static com.xxx.constants.process.ProcessConstants.KNOWN_ISSUE_TASK_STATE_VAR;
    import static com.xxx.constants.process.ProcessConstants.OPEN_STATE;
    
    
    @Service
    @Slf4j
    public class ProcessKnownIssueServiceImpl extends ProcessMessage implements ProcessKnownIssueService {
        @Resource
        RepositoryService repositoryService;
    
        @Resource
        RuntimeService runtimeService;
    
        @Resource
        TaskService taskService;
    
        @Resource
        KnownIssueDetailsService knownIssueDetailsService;
    
        @Resource
        ProcessVarHistoryMapper processVarHistoryMapper;
    
        @Resource
        UserService userService;
    
        @Resource
        UserAdapter userAdapter;
    
    
        /**
         * getKnowIssueProcessDef
         * 获取流程定义  key值是在BPMN2.0流程图设计过程中 给变量 process identifier赋值的名称 需要与图中的名称一致才能找到该流程图
         * @return ProcessDefinition
         */
        @Override
        public ProcessDefinition getKnowIssueProcessDef() {
            return repositoryService.createProcessDefinitionQuery()
                .processDefinitionKey(KNOWN_ISSUE_PROCESS_DEF_KEY)
                .latestVersion()
                .singleResult();
        }
    
    
        /**
         * createKnownIssue
         * 创建遗留问题电子流
         * @param createParam createParam
         * @return VerifyInfo
         */
        @Override
        public VerifyInfo createKnownIssue(KnowIssueCreateParam createParam) {
            VerifyInfo result = new VerifyInfo();
            ProcessDefinition knowIssueProcessDef = getKnowIssueProcessDef();
            if (knowIssueProcessDef == null) {
                return result.notPassed("system error: 未找到 遗留问题 流程定义");
            }
    		
    		//开启流程的一个实例对象，对应的key还是流程图的process identifier值  流程key
            ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(KNOWN_ISSUE_PROCESS_DEF_KEY);
    		//获取流程id 
            String processInstanceId = processInstance.getId();
    		//通过流程id 获取对应的一个子任务task
            Task task = getKnownIssueTaskByProcessInstanceId(processInstanceId);
            if (task == null) {
                return result.notPassed("system error: 未找到 遗留问题 实例任务");
            }
    		
    		//这里是创建业务的遗留问题单电子流表单，包括了业务的一些信息，以及对应的任务id，流程id 才能去关联对应的流程信息
            VerifyInfo createInfo = knownIssueDetailsService.createKnownIssue(task.getId(), task.getProcessInstanceId(),
                task.getCreateTime(), createParam);
            if (!createInfo.isPass()) {
    			//创建不成功的话 就设置子任务id，对应的一个变量值 knownIssueState ，赋值CANCELED  并将任务提交complete 由于这个电子流比较简单只有一个处理任务 提交后，整个流程就结束了 这里赋值变量会插入到act_ru_variable表中的 TEXT_字段
                log.error("create known issue failed");
                taskService.setVariable(task.getId(), KNOWN_ISSUE_TASK_STATE_VAR, CANCELED_STATE);
                taskService.complete(task.getId());
                return result.notPassed(createInfo.getMessage());
            }
    		
    		//创建成功，则设置状态变量knownIssueState 赋值 OPEN
            taskService.setVariable(task.getId(), KNOWN_ISSUE_TASK_STATE_VAR, OPEN_STATE);
    
    		//这里是创建一个业务流程电子流表，目的是承载一个简化通用的电子流清单，可能会存在多种业务电子流，用户会有多种业务类型电子流，统一展示在一个表单中，有一个表承载多种业务类型电子流
            DpProcessMessage message = new DpProcessMessage();
            message.setProcessType("遗留问题清单");
            message.setStatus("问题处理中");
            message.setMessage(createParam.getIssueDesc());
            message.setProcessCode(createInfo.getMessage());
    
    		//这里是获取用户信息  电子流可能涉及多个处理人 list封装
            List<UserModel> users = userAdapter.getUserInfo(createParam.getHandlers());
            StringBuffer userStr = new StringBuffer();
    		//多个用户进行拼接在一个字符串中，张三  01   是一个用户信息 然后换行放下一个用户信息
            users.forEach(user -> userStr.append(user.getNameCn()).append(String.format("  %s\n", user.getId())));
            message.setCreateUser(userStr.toString());
            message.setDealUser(userStr.toString());
    
            message.setProcessUrl(String.format("/leftIssueDetail?knownIssueId=%s", message.getProcessCode()));
            message.setCreateTime(LocalDateTime.now());
            sendMessage(message);
            return result.pass(createInfo.getMessage());
        }
    
    
        /**
         * getKnownIssueTaskByProcessInstanceId
         * 获取流程的指定子任务task
         * @param processInstanceId processInstanceId
         * @return Task
         */
        @Override
        public Task getKnownIssueTaskByProcessInstanceId(String processInstanceId) {
            return taskService.createTaskQuery()
                .active()
                .processInstanceId(processInstanceId)
                .taskDefinitionKey(KNOWN_ISSUE_TASK_DEF_KEY)
                .singleResult();
        }
    
    
        /**
         * closeKnownIssue
         * 关闭电子流
         * @param knownIssueId knownIssueId
         * @return boolean
         */
        @Override
        public boolean closeKnownIssue(String knownIssueId) {
    		//获取指定单号的遗留问题电子流
            KnownIssueDetailsTab detailsTab = getDetailTabByKnowIssueId(knownIssueId);
            if (detailsTab == null) {
                return false;
            }
            // SR为生产预警单，定时任务自动关闭，不走当前用户判断逻辑
            if (!"SR".equals(knownIssueId.substring(0, 2)) && !detailsTab.getHandler()
                .contains(userService.getUser().getAccount())) {
                return false;
            }
            Task task = getKnownIssueTaskByProcessInstanceId(detailsTab.getProcessInstanceId());
            if (task == null) {
                return false;
            }
    		//存在对应电子流，将其子任务 状态变量赋值 CLOSE   并提交完成  流程结束
            taskService.setVariable(task.getId(), KNOWN_ISSUE_TASK_STATE_VAR, CLOSE_STATE);
            taskService.complete(task.getId());
    
    		//删除通用信息表记录，这样用户前台就没有显示问题清单了
            deleteMessage(knownIssueId);
            return true;
        }
    
    
        /**
         * getKnownIssueDetails
         * 获取问题电子流的明细
         * @param knowIssueId knowIssueId
         * @return KnownIssueDetailsVo
         */
        @Override
        public KnownIssueDetailsVo getKnownIssueDetails(String knowIssueId) {
            KnownIssueDetailsTab issueDetailsTab = getDetailTabByKnowIssueId(knowIssueId);
            if (!issueDetailsTab.getHandler().contains(userService.getUser().getAccount())) {
                return new KnownIssueDetailsVo();
            }
            return parse2KnownIssueDetailsVo(issueDetailsTab);
        }
    
    
        /**
         * parse2KnownIssueDetailsVo
         * 
         * @param detailsTab detailsTab
         * @return KnownIssueDetailsVo
         */
        private KnownIssueDetailsVo parse2KnownIssueDetailsVo(KnownIssueDetailsTab detailsTab) {
            KnownIssueDetailsVo result = new KnownIssueDetailsVo();
            if (detailsTab == null) {
                return result;
            }
            result.setKnownIssueId(detailsTab.getId());
            result.setLabel(detailsTab.getLabel());
            result.setPduName(detailsTab.getPduName());
            result.setPlanFinishedDate(detailsTab.getPlanFinishedDate());
    		
    		//这里是获取是流程对应的一个 状态最新情况 是打开 还是关闭 
            ProcessVarHistoryRecordDto stateVar = processVarHistoryMapper.findLatestVarByProcInsId(
                detailsTab.getProcessInstanceId(), KNOWN_ISSUE_TASK_STATE_VAR);
            if (stateVar != null && !StringUtils.isEmpty(stateVar.getVarContent())) {
    			//这里状态值的设置   由于后台变量记录的是英文 OPEN , 前台需要展示中文，所以我们用枚举类 State 对每个状态进行转换
                result.setIssueStatus(State.valueOf(stateVar.getVarContent()).getNameCn());
            }
            result.setCurrentHandlers(getUserInfo(detailsTab));
            return result;
        }
    
    
        /**
         * getKnownIssueDesc
         * 获取问题的描述信息
         * @param knowIssueId knowIssueId
         * @return String
         */
        @Override
        public String getKnownIssueDesc(String knowIssueId) {
            KnownIssueDetailsTab detailsTab = getDetailTabByKnowIssueId(knowIssueId);
            if (detailsTab == null) {
                return null;
            }
            if (!detailsTab.getHandler().contains(userService.getUser().getAccount())) {
                return null;
            }
            return detailsTab.getIssueDesc();
        }
    
    
        /**
         * getProgressDetailsByKnowIssueId
         * 获取遗留问题单的进展细节
         * @param knowIssueId knowIssueId
         * @return List<ProgressDetailsVo>
         */
        @Override
        public List<ProgressDetailsVo> getProgressDetailsByKnowIssueId(String knowIssueId) {
            KnownIssueDetailsTab detailsTab = getDetailTabByKnowIssueId(knowIssueId);
            if (detailsTab == null) {
                return new ArrayList<>();
            }
            if (!detailsTab.getHandler().contains(userService.getUser().getAccount())) {
                return new ArrayList<>();
            }
            String taskId = detailsTab.getTaskId();
    		//通过任务id 以及设置变量  PROGRESS_DETAIL问题进展，查询表中的历史提交进展记录 多次提交就有多个记录
            List<ProcessVarHistoryRecordDto> progressRecords = processVarHistoryMapper.findVarHistoryByTaskId(taskId,
                KNOWN_ISSUE_PROGRESS_VAR);
            return progressRecords.stream().map(this::parseHisDetail).collect(Collectors.toList());
        }
    
    
        /**
         * parseHisDetail
         * 解析历史进展细节
         * @param one one
         * @return ProgressDetailsVo
         */
        private ProgressDetailsVo parseHisDetail(ProcessVarHistoryRecordDto one) {
            ProgressDetailsVo result = new ProgressDetailsVo();
            result.setUpdateDate(one.getOperateDate());
    		//这里的TEXT_值，前台返回的是 包括 更新人，更新内容两个信息 我们转换成json字符串保存{"UPDATER":"用户账号","CONTENT":"<p>进展内容</p>"}
            JSONObject varCont = JSONObject.parseObject(one.getVarContent());
    		//解析JSON对象 获取 UPDATER 和 CONTENT 分别赋值
            result.setUser(userAdapter.getUserInfo(varCont.getString(KNOWN_ISSUE_PROGRESS_UPDATER)));
            result.setContent(varCont.getString(KNOWN_ISSUE_PROGRESS_CONTENT));
            return result;
        }
    
    
        /**
         * updateProcess
         * 更新遗留问题进展
         * @param updateProgressParam updateProgressParam
         * @return VerifyInfo
         */
        @Override
        public VerifyInfo updateProcess(UpdateProgressParam updateProgressParam) {
            VerifyInfo result = new VerifyInfo();
            Map<String, Object> progressMap = new HashMap<>();
            UserVo user = userService.getUser();
            if (user == null) {
                return result.notPassed("未获取到用户信息");
            }
    		
    		//传参有更新的问题单号，查询该单号的问题记录
            KnownIssueDetailsTab tab = getDetailTabByKnowIssueId(updateProgressParam.getKnownIssueId());
            if (!tab.getHandler().contains(userService.getUser().getAccount())) {
                return result.notPassed("您无权限修改此流程");
            }
    		//获取流程id的流程当前最新状态
            State state = getStateByProcInsId(tab.getProcessInstanceId());
            if (!State.OPEN.equals(state)) {
                return result.notPassed("问题已关闭，无法更新进展");
            }
    		
    		//信息类map插入 更新人 更新内容
            progressMap.put(KNOWN_ISSUE_PROGRESS_UPDATER, user.getAccount());
            progressMap.put(KNOWN_ISSUE_PROGRESS_CONTENT, updateProgressParam.getContent());
    
    		//给对应流程的这个子任务设置任务局部变量 流程进展 赋值为信息类
            taskService.setVariableLocal(tab.getTaskId(), KNOWN_ISSUE_PROGRESS_VAR, progressMap);
            return result.pass("更新进展成功");
        }
    
    
        /**
         * getStateByProcInsId
         * 
         * @param processInstanceId processInstanceId
         * @return State
         */
        private State getStateByProcInsId(String processInstanceId) {
            ProcessVarHistoryRecordDto stateDto = processVarHistoryMapper.findLatestVarByProcInsId(processInstanceId,
                KNOWN_ISSUE_TASK_STATE_VAR);
            if (stateDto == null) {
                return null;
            }
            return State.valueOf(stateDto.getVarContent());
        }
    
    
        /**
         * getKnownIssueList
         * 获取问题清单
         * @param pageNo pageNo
         * @param pageSize pageSize
         * @return ResponseVo
         */
        @Override
        public ResponseVo getKnownIssueList(Integer pageNo, Integer pageSize) {
            UserVo user = userService.getUser();
            if (user == null) {
                return ResponseUtils.unAuthResponse(new ArrayList<>(), "请登录系统");
            }
            List<KnownIssueDetailsTab> list = knownIssueDetailsService.list(
                new LambdaQueryWrapper<KnownIssueDetailsTab>().like(KnownIssueDetailsTab::getHandler,
                    "%" + user.getAccount() + "%"));
            List<String> taskIds = list.stream()
                .map(KnownIssueDetailsTab::getTaskId)
                .distinct()
                .collect(Collectors.toList());
            List<String> procInsIds = list.stream()
                .map(KnownIssueDetailsTab::getProcessInstanceId)
                .distinct()
                .collect(Collectors.toList());
            Map<String, ProcessVarHistoryRecordDto> progressMap = getLatestProgressMap(taskIds);
            Map<String, ProcessVarHistoryRecordDto> stateMap = getStateMap(procInsIds);
    
            List<KnownIssueInfoVo> infos = list.stream()
                .filter(item -> item.getHandler().contains(user.getAccount()))
                .map(knownIssueDetailsTab -> parseDetailTab(knownIssueDetailsTab, progressMap, stateMap))
                .collect(Collectors.toList());
            List<KnownIssueInfoVo> result = infos.stream()
                .sorted(Comparator.comparing(KnownIssueInfoVo::getKnownIssueId).reversed())
                .skip((long) (pageNo - 1) * pageSize)
                .limit(pageSize)
                .collect(Collectors.toList());
            return ResponseUtils.successPageResponse(result, infos.size());
        }
    
    
        /**
         * getStateMap
         * 
         * @param procInsIds procInsIds
         * @return Map<String,ProcessVarHistoryRecordDto>
         */
        private Map<String, ProcessVarHistoryRecordDto> getStateMap(List<String> procInsIds) {
            List<ProcessVarHistoryRecordDto> stateVars = processVarHistoryMapper.findLatestVarByProcInsIds(procInsIds,
                KNOWN_ISSUE_TASK_STATE_VAR);
            return stateVars.stream().collect(Collectors.toMap(ProcessVarHistoryRecordDto::getProcInsId, item -> item));
        }
    
    
        /**
         * getLatestProgressMap
         * 
         * @param taskIds taskIds
         * @return Map<String,ProcessVarHistoryRecordDto>
         */
        private Map<String, ProcessVarHistoryRecordDto> getLatestProgressMap(List<String> taskIds) {
            List<ProcessVarHistoryRecordDto> progressVars = processVarHistoryMapper.findLatestVarByTaskIds(taskIds,
                KNOWN_ISSUE_PROGRESS_VAR);
            return progressVars.stream().collect(Collectors.toMap(ProcessVarHistoryRecordDto::getTaskId, item -> item));
        }
    
    
        /**
         * parseDetailTab
         * 
         * @param knownIssueDetailsTab knownIssueDetailsTab
         * @param progressMap progressMap
         * @param stateMap stateMap
         * @return KnownIssueInfoVo
         */
        private KnownIssueInfoVo parseDetailTab(KnownIssueDetailsTab knownIssueDetailsTab,
            Map<String, ProcessVarHistoryRecordDto> progressMap, Map<String, ProcessVarHistoryRecordDto> stateMap) {
            KnownIssueInfoVo result = new KnownIssueInfoVo();
            String knownIssueId = knownIssueDetailsTab.getId();
            String taskId = knownIssueDetailsTab.getTaskId();
            String processInstanceId = knownIssueDetailsTab.getProcessInstanceId();
            result.setKnownIssueId(knownIssueId);
            result.setIssueDesc(knownIssueDetailsTab.getIssueDesc());
            result.setLabel(knownIssueDetailsTab.getLabel());
            result.setPduName(knownIssueDetailsTab.getPduName());
            result.setPlanFinishedDate(knownIssueDetailsTab.getPlanFinishedDate());
            result.setCurrentHandlers(
                getUserInfo(knownIssueDetailsTab).stream().map(UserModel::getNameCn).collect(Collectors.joining(",")));
            if (progressMap.containsKey(taskId)) {
                ProcessVarHistoryRecordDto processVarHistoryRecordDto = progressMap.get(taskId);
                String varContent = processVarHistoryRecordDto.getVarContent();
                JSONObject jsonObject = JSONObject.parseObject(varContent);
                result.setLatestProgress(jsonObject.getString(KNOWN_ISSUE_PROGRESS_CONTENT));
                UserModel userInfo = userAdapter.getUserInfo(jsonObject.getString(KNOWN_ISSUE_PROGRESS_UPDATER));
                if (userInfo != null) {
                    result.setLatestUpdater(userInfo.getNameCn());
                }
            }
            if (stateMap.containsKey(processInstanceId)) {
                ProcessVarHistoryRecordDto processVarHistoryRecordDto = stateMap.get(processInstanceId);
                State state = State.valueOf(processVarHistoryRecordDto.getVarContent());
                result.setIssueStatus(state.getNameCn());
                if (State.CLOSE.equals(state)) {
                    result.setCloseDate(processVarHistoryRecordDto.getOperateDate());
                }
            }
            return result;
        }
    
    
        /**
         * getUserInfo
         * 
         * @param knownIssueDetailsTab knownIssueDetailsTab
         * @return List<UserModel>
         */
        private List<UserModel> getUserInfo(KnownIssueDetailsTab knownIssueDetailsTab) {
            return userAdapter.getUserInfo(JSONArray.parseArray(knownIssueDetailsTab.getHandler(), String.class));
        }
    
    
        /**
         * getDetailTabByKnowIssueId
         * 
         * @param knowIssueId knowIssueId
         * @return KnownIssueDetailsTab
         */
        private KnownIssueDetailsTab getDetailTabByKnowIssueId(String knowIssueId) {
            return knownIssueDetailsService.getOne(
                new LambdaQueryWrapper<KnownIssueDetailsTab>().eq(KnownIssueDetailsTab::getId, knowIssueId));
        }
    }

###  ###

### dao层 接口 创建遗留问题单 ###

package com..service.dao.iservice.process;
    
    import com.model.KnowIssueCreateParam;
    import com.domain.entity.VerifyInfo;
    import com.domain.model.KnownIssueDetailsTab;
    
    import com.baomidou.mybatisplus.extension.service.IService;
    
    import java.util.Date;
    
    
    public interface KnownIssueDetailsService extends IService<KnownIssueDetailsTab> {
    
    
        /**
         * createKnownIssue
         * 
         * @param taskId taskId
         * @param procInsId procInsId
         * @param createTime createTime
         * @param param param
         * @return VerifyInfo
         */
        VerifyInfo createKnownIssue(String taskId, String procInsId, Date createTime, KnowIssueCreateParam param);
    }

###  ###

### dao层 实现 创建遗留问题单 ###

package com..service.impl.dao.iservice.process;
    
    import com.model.KnowIssueCreateParam;
    import com.domain.entity.VerifyInfo;
    import com.domain.model.KnownIssueDetailsTab;
    import com.service.dao.iservice.process.KnownIssueDetailsService;
    import com.service.dao.mapper.process.KnownIssueDetailsMapper;
    import com.utils.DateUtils;
    import com.it.auth.util.StringUtils;
    import com.tools.commonlib.exception.ServiceException;
    
    import com.alibaba.fastjson.JSONArray;
    import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    
    import lombok.extern.slf4j.Slf4j;
    
    import org.springframework.stereotype.Service;
    
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.Locale;
    import java.util.concurrent.locks.ReentrantLock;
    
    
    @Service
    @Slf4j
    public class KnownIssueDetailsServiceImpl extends ServiceImpl<KnownIssueDetailsMapper, KnownIssueDetailsTab>
        implements KnownIssueDetailsService {
    
    	//可重入锁  目的就是如果存在大量的问题单在同一时刻创建，那么就会导致 问题单号的重复，因为单号是根据表中当前的数量累加，可能存在第一次请求还没结束 第二次的也接着请求 导致单号最大数值一样了 加锁目的就是为了请求是一次次的完成 
        private static final ReentrantLock LOCK = new ReentrantLock();
    
    
        /**
         * createKnownIssue
         * 
         * @param taskId taskId
         * @param procInsId procInsId
         * @param createTime createTime
         * @param param param
         * @return VerifyInfo
         */
        @Override
        public VerifyInfo createKnownIssue(String taskId, String procInsId, Date createTime, KnowIssueCreateParam param) {
            VerifyInfo result = new VerifyInfo();
            KnownIssueDetailsTab saveOne = new KnownIssueDetailsTab();
            saveOne.setTaskId(taskId);
            saveOne.setProcessInstanceId(procInsId);
            saveOne.setIssueDesc(param.getIssueDesc());
    		
    		//存储处理人 转换成json格式数组
            saveOne.setHandler(JSONArray.toJSONString(param.getHandlers()));
            saveOne.setLabel(param.getLabel());
            saveOne.setPduName(param.getPduName());
            saveOne.setCreatedDate(createTime);
            try {
                SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
                saveOne.setPlanFinishedDate(dateFormat.parse(param.getPlanFinishedDate()));
            } catch (ParseException e) {
                log.error("date format error");
                return result.notPassed("param error: date format error");
            }
            try {
                LOCK.lock();
                String id = "";
                if (StringUtils.isEmpty(param.getProblemNo())) {
                    id = String.format(Locale.ROOT, "KI%s%s", DateUtils.getTimeMillisString(new Date()),
                        formatNum2Five(baseMapper.getTodayKnownIssueNum() + 1));
                    saveOne.setId(id);
                } else {
                    id = param.getProblemNo();
                }
                saveOne.setId(id);
    			
    			//调用mp的内置方法 插入数据
                save(saveOne);
                return result.pass(id);
            } catch (ServiceException e) {
                log.error("create problem failed");
                return result.notPassed("system error: create KI id, save data error");
            } finally {
                LOCK.unlock();
            }
        }
    
    
        /**
         * formatNum2Five
         * 
         * @param num num
         * @return String
         * @throws ServiceException ServiceException
         */
        private String formatNum2Five(int num) throws ServiceException {
            if (num > 99999 || num < 0) {
                throw new ServiceException("num out of range");
            }
            String numStr = String.valueOf(num);
            StringBuilder builder = new StringBuilder();
            for (int i = 0; i < (5 - numStr.length()); i++) {
                builder.append("0");
            }
            return builder + numStr;
        }
    
    }

### dao层 mapper接口 ###

package com.service.dao.mapper.process;
    
    import com.domain.model.KnownIssueDetailsTab;
    
    import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    
    import org.apache.ibatis.annotations.Mapper;
    import org.apache.ibatis.annotations.Select;
    
    
    @Mapper
    public interface KnownIssueDetailsMapper extends BaseMapper<KnownIssueDetailsTab> {
    
    
        /**
         * getTodayKnownIssueNum
         * 
         * @return int
         */
        @Select("select count(*) from dp_process_known_issue_details where TO_DAYS(created_date) = TO_DAYS(NOW()) ")
        int getTodayKnownIssueNum();
    }

--------------------

### dao层 mapper接口 获取流程历史记录的变量信息 ###

*  这里我们设定了两种变量 一个是流程状态knownIssueState， 一个是进展细节 PROGRESS\_DETAIL ，都是保存在表中的act\_hi\_detail，这里是历史记录表，会记录这个流程或者任务我们设定的变量的全部过程，比如状态 ，是从 OPEN开始的，闭环了则增加一条 CLOSE的内容，也就是状态变量 记录有2条，进展细节也是同理，一个子任务 提交多少次细节处理，我们就把内容都赋值给变量进行插入记录。对应就有相应条数记录

package com.service.dao.mapper.process;
    
    import com.domain.dto.process.ProcessVarHistoryRecordDto;
    
    import org.apache.ibatis.annotations.Mapper;
    import org.apache.ibatis.annotations.Param;
    
    import java.util.List;
    
    
    @Mapper
    public interface ProcessVarHistoryMapper {
    
        /**
         * 根据 任务id taskId 查询 流程 局部变量信息
         *
         * @param taskId taskId
         * @param varName varName
         * @return List<ProcessVarHistoryRecordDto>
         */
        List<ProcessVarHistoryRecordDto> findVarHistoryByTaskId(@Param("taskId") String taskId,
            @Param("varName") String varName);
    
        /**
         * 根据 流程实例id procInsId 查询 流程 变量信息
         *
         * @param procInsId procInsId
         * @param varName varName
         * @return List<ProcessVarHistoryRecordDto>
         */
        List<ProcessVarHistoryRecordDto> findVarHistoryByProcInsId(@Param("procInsId") String procInsId,
            @Param("varName") String varName);
    
        /**
         * 根据taskIds 批量获取 遗留问题的最新进展详情
         *
         * @param taskIds taskIds
         * @param varName varName
         * @return List<ProcessVarHistoryRecordDto>
         */
        List<ProcessVarHistoryRecordDto> findLatestVarByTaskIds(@Param("taskIds") List<String> taskIds,
            @Param("varName") String varName);
    
        /**
         * 根据procInsIds 批量获取 遗留问题的进展详情
         *
         * @param procInsIds procInsIds
         * @param varName varName
         * @return List<ProcessVarHistoryRecordDto>
         */
        List<ProcessVarHistoryRecordDto> findLatestVarByProcInsIds(@Param("procInsIds") List<String> procInsIds,
            @Param("varName") String varName);
    
        /**
         * 根据taskId 获取单个 局部变量 最新的详情
         *
         * @param taskId taskId
         * @param varName varName
         * @return ProcessVarHistoryRecordDto
         */
        ProcessVarHistoryRecordDto findLatestVarByTaskId(@Param("taskId") String taskId, @Param("varName") String varName);
    
        /**
         * 根据procInsId 获取单个 实例变量 最新的详情
         *
         * @param procInsId procInsId
         * @param varName varName
         * @return ProcessVarHistoryRecordDto
         */
        ProcessVarHistoryRecordDto findLatestVarByProcInsId(@Param("procInsId") String procInsId,
            @Param("varName") String varName);
    }

### dao层 xml映射 获取流程历史记录的变量信息 ###

<?xml version="1.0" encoding="UTF-8"?>
    
    
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.service.dao.mapper.process.ProcessVarHistoryMapper">
        <select id="findVarHistoryByTaskId" resultType="com.domain.dto.process.ProcessVarHistoryRecordDto">
            select
                TASK_ID_ as taskId,
                PROC_INST_ID_ as procInsId,
                NAME_ as varName,
                VAR_TYPE_ as varType,
                TIME_ as operateDate,
                TEXT_ as varContent
            from act_hi_detail
            where TASK_ID_ = #{taskId} and NAME_ =#{varName}
              and TYPE_ = 'VariableUpdate'
            order by TIME_ asc
        </select>
    
        <select id="findVarHistoryByProcInsId" resultType="com.domain.dto.process.ProcessVarHistoryRecordDto">
            select
                TASK_ID_ as taskId,
                PROC_INST_ID_ as procInsId,
                NAME_ as varName,
                VAR_TYPE_ as varType,
                TIME_ as operateDate,
                TEXT_ as varContent
            from act_hi_detail
            where PROC_INST_ID_ = #{procInsId} and NAME_ =#{varName}
              and TYPE_ = 'VariableUpdate'
            order by TIME_ asc
        </select>
    
        <select id="findLatestVarByTaskIds" resultType="com.domain.dto.process.ProcessVarHistoryRecordDto">
            select
                a.TASK_ID_ as taskId,
                a.PROC_INST_ID_ as procInsId,
                a.NAME_ as varName,
                a.VAR_TYPE_ as varType,
                a.TIME_ as operateDate,
                a.TEXT_ as varContent
            from (
                    select *,
                           row_number() over(partition by TASK_ID_ order by TIME_ desc) as rank_number
                    from act_hi_detail
                    <where>
                        <if test="taskIds != null and taskIds.size > 0">
                            and TASK_ID_ in
                            <foreach collection="taskIds" item="taskId" open="(" separator="," close=")">
                                #{taskId}
                            </foreach>
                        </if>
                        and NAME_ =#{varName}
                        and TYPE_ = 'VariableUpdate'
                    </where>
            ) a
            where rank_number = 1
        </select>
    
        <select id="findLatestVarByProcInsIds" resultType="com.domain.dto.process.ProcessVarHistoryRecordDto">
            select
                a.TASK_ID_ as taskId,
                a.PROC_INST_ID_ as procInsId,
                a.NAME_ as varName,
                a.VAR_TYPE_ as varType,
                a.TIME_ as operateDate,
                a.TEXT_ as varContent
            from (
                    select *,
                        row_number() over(partition by PROC_INST_ID_ order by TIME_ desc) as rank_number
                    from act_hi_detail
                    <where>
                        <if test="procInsIds != null and procInsIds.size > 0">
                            and PROC_INST_ID_ in
                            <foreach collection="procInsIds" item="procInstId" open="(" separator="," close=")">
                                #{procInstId}
                            </foreach>
                        </if>
                        and NAME_ =#{varName}
                        and TYPE_ = 'VariableUpdate'
                    </where>
            ) a
            where rank_number = 1
        </select>
    
    
        <select id="findLatestVarByTaskId" resultType="com.domain.dto.process.ProcessVarHistoryRecordDto">
            select
                a.TASK_ID_ as taskId,
                a.PROC_INST_ID_ as procInsId,
                a.NAME_ as varName,
                a.VAR_TYPE_ as varType,
                a.TIME_ as operateDate,
                a.TEXT_ as varContent
            from (
            select *,
            row_number() over(partition by TASK_ID_ order by TIME_ desc) as rank_number
            from act_hi_detail
            <where>
                and TASK_ID_ = #{taskId}
                and NAME_ =#{varName}
                and TYPE_ = 'VariableUpdate'
            </where>
            ) a
            where rank_number = 1
        </select>
    
        <select id="findLatestVarByProcInsId" resultType="com.domain.dto.process.ProcessVarHistoryRecordDto">
            select
            a.TASK_ID_ as taskId,
            a.PROC_INST_ID_ as procInsId,
            a.NAME_ as varName,
            a.VAR_TYPE_ as varType,
            a.TIME_ as operateDate,
            a.TEXT_ as varContent
            from (
            select *,
            row_number() over(partition by PROC_INST_ID_ order by TIME_ desc) as rank_number
            from act_hi_detail
            <where>
                and PROC_INST_ID_ = #{procInsId}
                and NAME_ =#{varName}
                and TYPE_ = 'VariableUpdate'
            </where>
            ) a
            where rank_number = 1
        </select>
    </mapper>

--------------------

### 通用信息设计接口 ###

*  观察者模式，注入了一个 集合list 目的是后续能得到多个被观察者实现类的内容，之前我们有一篇文章 写导出数据与导出模板用一个接口完成的，就涉及到这个模式设计的运用，利用反射或者每个实现类名去区别不同类方法 [【业务功能篇04】Springboot+mybatis-plus+POI模板表头下载以及数据查询下载\_studyday1的博客-CSDN博客][04_Springboot_mybatis-plus_POI_studyday1_-CSDN]

### controller层 ###

直接调用mapper层内置的查询接口

package com.controller;
    
    import com.domain.dto.process.ProcessContent;
    import com.domain.model.DpProcessMessage;
    import com.qualitybigdata.model.ResponseVo;
    import com.service.UserService;
    import com.service.dao.mapper.DpProcessMessageMapper;
    import com.utils.ResponseUtils;
    
    import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
    import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
    import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
    
    import lombok.extern.slf4j.Slf4j;
    
    import org.apache.commons.lang3.ObjectUtils;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestBody;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.List;
    import java.util.function.Consumer;
    import java.util.stream.Collectors;
    
    import javax.annotation.Resource;
    
    /**
     * 流程消息接口
     *
     */
    @RestController
    @RequestMapping("/message")
    @Slf4j
    public class ProcessMessageController {
        @Autowired
        DpProcessMessageMapper processMessageMapper;
    
        @Resource
        UserService userService;
    
        /**
         * getMessage
         *
         * @param pageNo pageNo
         * @param pageSize pageSize
         * @param keyword keyword
         * @return ResponseVo
         */
        @PostMapping("/getMessage")
        public ResponseVo getMessage(@RequestParam Long pageNo, @RequestParam Integer pageSize,
            @RequestBody ProcessContent keyword) {
            return queryMessage(pageNo, pageSize, keyword.getKeyword(),
                wrapper -> wrapper.like(DpProcessMessage::getDealUser, userService.getUser().getAccount()));
        }
    
        /**
         * getApplication
         *
         * @param pageNo pageNo
         * @param pageSize pageSize
         * @param keyword keyword
         * @return ResponseVo
         */
        @PostMapping("/getApplication")
        public ResponseVo getApplication(@RequestParam Long pageNo, @RequestParam Integer pageSize,
            @RequestBody ProcessContent keyword) {
            return queryMessage(pageNo, pageSize, keyword.getKeyword(),
                wrapper -> wrapper.like(DpProcessMessage::getCreateUser, userService.getUser().getAccount()));
        }
    
        /**
         * getApplication
         *
         * @param keyword keyword
         * @param processType processType
         * @return ResponseVo
         */
        @GetMapping("/getComponentCode")
        public ResponseVo getApplication(@RequestParam String keyword, @RequestParam String processType) {
            Page<DpProcessMessage> page = new Page<>(1, 5);
            LambdaQueryWrapper<DpProcessMessage> wrapper = new LambdaQueryWrapper<>();
            if (ObjectUtils.isNotEmpty(keyword)) {
                wrapper.like(DpProcessMessage::getMessage, keyword);
            }
            if ("getMessage".equals(processType)) {
                wrapper.like(DpProcessMessage::getDealUser, userService.getUser().getAccount());
            } else {
                wrapper.like(DpProcessMessage::getCreateUser, userService.getUser().getAccount());
            }
            wrapper.orderByDesc(DpProcessMessage::getProcessCode);
            List<String> list = processMessageMapper.selectPage(page, wrapper)
                .getRecords()
                .stream()
                .map(DpProcessMessage::getMessage)
                .collect(Collectors.toList());
            return ResponseUtils.successResponse(list, "");
        }
    
        /**
         * getApplicationNum
         *
         * @return ResponseVo
         */
        @GetMapping("/getApplicationNum")
        public ResponseVo getApplicationNum() {
            String Account = userService.getUser().getAccount();
            return ResponseUtils.successResponse(new Long[] {
                countMessage(wrapper -> wrapper.like(DpProcessMessage::getDealUser, Account)),
                countMessage(wrapper -> wrapper.like(DpProcessMessage::getCreateUser, Account))
            }, "");
        }
    
        /**
         * countMessage
         *
         * @param consumer consumer
         * @return Long
         */
        private Long countMessage(Consumer<LambdaQueryChainWrapper<DpProcessMessage>> consumer) {
            LambdaQueryChainWrapper<DpProcessMessage> wrapper = new LambdaQueryChainWrapper<>(processMessageMapper);
            consumer.accept(wrapper);
            return wrapper.count();
        }
    
        /**
         * queryMessage
         *
         * @param pageNo pageNo
         * @param pageSize pageSize
         * @param keyWord keyWord
         * @param consumer consumer
         * @return ResponseVo
         */
        private ResponseVo queryMessage(Long pageNo, Integer pageSize, String keyWord,
            Consumer<LambdaQueryWrapper<DpProcessMessage>> consumer) {
            Page<DpProcessMessage> page = new Page<>(pageNo, pageSize);
            LambdaQueryWrapper<DpProcessMessage> wrapper = new LambdaQueryWrapper<>();
            consumer.accept(wrapper);
            if (ObjectUtils.isNotEmpty(keyWord)) {
                wrapper.like(DpProcessMessage::getMessage, keyWord);
            }
            wrapper.orderByDesc(DpProcessMessage::getProcessCode);
            return ResponseUtils.successPageResponse(processMessageMapper.selectPage(page, wrapper).getRecords(), page);
        }
    }

###  ###

### 通用信息类 ###

package com.service.process;
    
    import com.domain.model.DpProcessMessage;
    import com.observe.ProcessObserve;
    
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Value;
    
    import java.util.List;
    
    
    public abstract class ProcessMessage {
        @Value("${Url}")
        private String Url;
    
    	
        @Autowired
        List<ProcessObserve> observeList;
    
    
        /**
         * sendMessage
         *
         * @param message message
         */
        protected void sendMessage(DpProcessMessage message) {
            observeList.forEach(observe -> observe.saveMessage(message));
        }
    
    
        /**
         * deleteMessage
         *
         * @param processCode processCode
         */
        protected void deleteMessage(String processCode) {
            observeList.forEach(observe -> observe.removeMessage(processCode));
        }
    }

### 观察者接口 ###

package comobserve;
    
    import com.domain.model.DpProcessMessage;
    
    
    public interface ProcessObserve {
    
        /**
         * saveMessage
         * 
         * @param message message
         */
        void saveMessage(DpProcessMessage message);
    
    
        /**
         * removeMessage
         * 
         * @param processCode processCode
         */
        void removeMessage(String processCode);
    }

### 观察者 实现类 ###

package com.observe;
    
    import com.service.dao.mapper.DpProcessMessageMapper;
    import com.domain.model.DpProcessMessage;
    
    import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    import org.springframework.transaction.annotation.Transactional;
    
    
    @Component
    public class ProcessMessageImpl implements ProcessObserve {
    
        @Autowired
        DpProcessMessageMapper processMessageMapper;
    
    
        /**
         * saveMessage
         * 
         * @param message message
         */
        @Transactional(rollbackFor = Exception.class)
        @Override
        public void saveMessage(DpProcessMessage message) {
            deleteByProcessCode(message.getProcessCode());
            processMessageMapper.insert(message);
        }
    
    
        /**
         * removeMessage
         * 
         * @param processCode processCode
         */
        @Override
        public void removeMessage(String processCode) {
            deleteByProcessCode(processCode);
        }
    
    
        /**
         * deleteByProcessCode
         * 
         * @param processCode processCode
         */
        private void deleteByProcessCode(String processCode) {
            QueryWrapper<DpProcessMessage> wrapper = new QueryWrapper<>();
            wrapper.lambda().eq(DpProcessMessage::getProcessCode, processCode);
            processMessageMapper.delete(wrapper);
        }
    }

### 观察者 mapper接口 ###

package com.service.dao.mapper;
    
    import com.domain.model.DpProcessMessage;
    import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    import org.apache.ibatis.annotations.Mapper;
    
    
    @Mapper
    public interface DpProcessMessageMapper extends BaseMapper<DpProcessMessage> {
    
    }

### 通用信息 实体类 ###

package com.domain.model;
    
    import com.baomidou.mybatisplus.annotation.IdType;
    import com.baomidou.mybatisplus.annotation.TableField;
    import com.baomidou.mybatisplus.annotation.TableId;
    import com.baomidou.mybatisplus.annotation.TableName;
    import com.fasterxml.jackson.annotation.JsonFormat;
    
    import lombok.Data;
    import lombok.EqualsAndHashCode;
    import lombok.NoArgsConstructor;
    import lombok.experimental.Accessors;
    
    import java.io.Serializable;
    import java.time.LocalDateTime;
    
    
    @Data
    @EqualsAndHashCode(callSuper = false)
    @Accessors(chain = true)
    @NoArgsConstructor
    @TableName("dp_process_message")
    public class DpProcessMessage implements Serializable {
    
        private static final long serialVersionUID = 1L;
    
        /**
         * 主键id
         */
        @TableId(value = "id", type = IdType.AUTO)
        private Long id;
    
        /**
         * 流程类型
         */
        @TableField("process_type")
        private String processType;
    
        /**
         * 流程单号
         */
        @TableField("process_code")
        private String processCode;
    
        /**
         * 流程跳转url
         */
        @TableField("process_url")
        private String processUrl;
    
        /**
         * 流程信息
         */
        @TableField("message")
        private String message;
    
        /**
         * 流程状态
         */
        @TableField("status")
        private String status;
    
        /**
         * 创建人
         */
        @TableField("create_user")
        private String createUser;
    
        /**
         * 处理人
         */
        @TableField("deal_user")
        private String dealUser;
    
        @TableField(value = "msg_create_user", exist = false)
        private String msgCreateUser;
    
        /**
         * 创建时间
         */
        @TableField("create_time")
        @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
        private LocalDateTime createTime;
    }

--------------------

## 涉及部分的实体类 ##

### 流程常量类 ###

*  方便直接调用

package com.constants.process;
    
    /**
     * 流程常量
     *
     */
    public class ProcessConstants {
    
        /**
         * 开始
         */
        public static final String START_EVENT_ID = "start";
    
        /**
         * 结束
         */
        public static final String END_EVENT_ID = "end";
    
    
        /**
         * 遗留问题 流程定义 key
         */
        public static final String KNOWN_ISSUE_PROCESS_DEF_KEY = "knownIssue";
    
        /**
         * 遗留问题 任务定义 key
         */
        public static final String KNOWN_ISSUE_TASK_DEF_KEY = "knownIssueTaskId";
    
        /**
         * 遗留问题 任务状态 variables
         */
        public static final String KNOWN_ISSUE_TASK_STATE_VAR = "knownIssueState";
    
        /**
         * 遗留问题 进展 变量名
         */
        public static final String KNOWN_ISSUE_PROGRESS_VAR = "PROGRESS_DETAIL";
    
        /**
         * 遗留问题 更新人
         */
        public static final String KNOWN_ISSUE_PROGRESS_UPDATER = "UPDATER";
    
        /**
         * 遗留问题 更新内容
         */
        public static final String KNOWN_ISSUE_PROGRESS_CONTENT = "CONTENT";
    
    
        /**
         * 开启
         */
        public static final String OPEN_STATE = "OPEN";
    
        /**
         * 关闭
         */
        public static final String CLOSE_STATE = "CLOSE";
    
        /**
         * 完成
         */
        public static final String FINISHED_STATE = "FINISHED";
    
        /**
         * 取消
         */
        public static final String CANCELED_STATE = "CANCELED";
    
    }

### 业务流程表单实体类 ###

### 状态变量 枚举类 ###

package com.enums;
    
    import lombok.Getter;
    
    
    public enum State {
    
        OPEN(0, "进行中", "open"),
        CLOSE(1, "已关闭", "close"),
        FINISHED(2, "已完成", "finished"),
        CANCELED(3, "已撤销", "canceled"),
        UNDO(4, "未开始", "undo"),
    
        REJECTED(5, "被驳回", "rejected"),
    
        DRAFT(6, "草稿", "draft");
    
        @Getter
        private final Integer code;
    
        @Getter
        private final String nameCn;
    
        @Getter
        private final String nameEn;
    
        State(Integer code, String nameCn, String nameEn) {
            this.code = code;
            this.nameCn = nameCn;
            this.nameEn = nameEn;
        }
    }

### 创建遗留问题单 传参类 ###

package com.model;
    
    import java.util.*;
    import java.io.Serializable;
    import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
    import com.fasterxml.jackson.annotation.JsonProperty;
    
    
    
    
     @JsonIgnoreProperties(ignoreUnknown = true)
    
    public class KnowIssueCreateParam implements Serializable {
        private static final long serialVersionUID = 1L;
        
        @JsonProperty("handlers")
        private List<String> handlers = new ArrayList<String>();
        
        @JsonProperty("issueDesc")
        private String issueDesc = null;
        
        @JsonProperty("planFinishedDate")
        private String planFinishedDate = null;
        
        @JsonProperty("label")
        private String label = null;
        
        @JsonProperty("pduName")
        private String pduName = null;
        
        @JsonProperty("problemNo")
        private String problemNo = null;
        
        @JsonProperty("handler")
        private String handler = null;
        
        public KnowIssueCreateParam() {
            super();
        } 
        
        /**
        **/
        public List<String> getHandlers() {
            return handlers;
        }
    
        public void setHandlers(List<String> handlers) {
            this.handlers = handlers;
        }
        
        /**
        **/
        public String getIssueDesc() {
            return issueDesc;
        }
    
        public void setIssueDesc(String issueDesc) {
            this.issueDesc = issueDesc;
        }
        
        /**
        **/
        public String getPlanFinishedDate() {
            return planFinishedDate;
        }
    
        public void setPlanFinishedDate(String planFinishedDate) {
            this.planFinishedDate = planFinishedDate;
        }
        
        /**
        **/
        public String getLabel() {
            return label;
        }
    
        public void setLabel(String label) {
            this.label = label;
        }
        
        /**
        **/
        public String getPduName() {
            return pduName;
        }
    
        public void setPduName(String pduName) {
            this.pduName = pduName;
        }
        
        /**
        **/
        public String getProblemNo() {
            return problemNo;
        }
    
        public void setProblemNo(String problemNo) {
            this.problemNo = problemNo;
        }
        
        /**
        **/
        public String getHandler() {
            return handler;
        }
    
        public void setHandler(String handler) {
            this.handler = handler;
        }
        
          
        
          
        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {
                return false;
            }
            
            
            KnowIssueCreateParam knowIssueCreateParam = (KnowIssueCreateParam) o;
            return Objects.equals(this.handlers,
                    knowIssueCreateParam.handlers)
                    && Objects.equals(this.issueDesc,
                    knowIssueCreateParam.issueDesc)
                    && Objects.equals(this.planFinishedDate,
                    knowIssueCreateParam.planFinishedDate)
                    && Objects.equals(this.label,
                    knowIssueCreateParam.label)
                    && Objects.equals(this.pduName,
                    knowIssueCreateParam.pduName)
                    && Objects.equals(this.problemNo,
                    knowIssueCreateParam.problemNo)
                    && Objects.equals(this.handler,
                    knowIssueCreateParam.handler);
        } 
        
          
        @Override
        public int hashCode() {
            return Objects.hash(handlers
                    , issueDesc
                    , planFinishedDate
                    , label
                    , pduName
                    , problemNo
                    , handler);
        } 
        
           
    
          
        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append("class KnowIssueCreateParam { ");
            
            sb.append("  handlers: ").append(handlers).append(", ");
            sb.append("  issueDesc: ").append(issueDesc).append(", ");
            sb.append("  planFinishedDate: ").append(planFinishedDate).append(", ");
            sb.append("  label: ").append(label).append(", ");
            sb.append("  pduName: ").append(pduName).append(", ");
            sb.append("  problemNo: ").append(problemNo).append(", ");
            sb.append("  handler: ").append(handler).append(", ");
            sb.append("} ");
            return sb.toString();
          }
    }

### 流程变量封装类 ###

package com.domain.dto.process;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    import java.util.Date;
    
    
    @AllArgsConstructor
    @NoArgsConstructor
    @Data
    public class ProcessVarHistoryRecordDto {
        private String taskId;
    
        private String procInsId;
    
        private String varName;
    
        private String varType;
    
        private String varContent;
    
        private Date operateDate;
    }

[f658ac1265f7432fa591578dd5a75dd4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/7b175450fd62484fb3a99d592e040284.png
[8dc47cb8811146338e38a47515570dad.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/32403f5bf08b47109708d8e11ebf380a.png
[f165caee0a1a415598cbd26e0cae53ca.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/824f3a8d7fb04951a42d8962ded755a3.png
[9c8fa475686a45029c4549a2be9463a3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/10b7d88b05f7400499d0213026ddbf8b.png
[04_Springboot_mybatis-plus_POI_studyday1_-CSDN]: https://blog.csdn.net/studyday1/article/details/130926304