springboot+activity6.0实际应用案例

最新推荐文章于 2024-07-06 19:58:09 发布
最新推荐文章于 2024-07-06 19:58:09 发布
阅读量495 收藏 4
点赞数
分类专栏： activiti 工作流 文章标签： activiti 工作流 activity6.0
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LT11hka/article/details/109746733
版权

本想在个人博客添加一个模拟审批流程，后台代码已写完，奈何本人不是专业前端，前台页面进度太过缓慢，为了节省时间，决定不写前台页面，这里将后台代码上传，供大家参考

整个代码包含流程部署、启动、流程详情查看、审批、驳回、审批历史查看、审批流程图查看、动态指定下一审批人（根据指定approver变量来指定审批人）、流程删除

1.bpmn流程图（执行流程不规范，纯属个人yy）

在这里插入图片描述

2.Controller

package com.chat.api.web.restctrl;


import com.chat.api.utils.ResultUtil;
import com.chat.api.utils.util.DateUtil;
import com.chat.api.utils.util.ParamUtil;
import com.chat.api.web.service.ApprovalService;
import com.chat.api.web.vo.ApprovalEntity;
import com.chat.api.web.vo.MessageEntity;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.websocket.server.PathParam;
import java.util.Date;

@Controller
@RequestMapping("/approval")
public class ApprovalCtrl {

    @Autowired
    private ApprovalService approvalService;

    @RequestMapping(value = "deploy",produces = "application/json",method = RequestMethod.GET)
    @ApiOperation("部署审批流程")
    public void deploy(HttpServletRequest request) {
        String flowName = "面试审批流程";
        Boolean result = approvalService.deployProcess(flowName);
    }

    @RequestMapping(value = "startApproval",produces = "application/json",method = RequestMethod.POST)
    @ApiOperation("启动审批流程")
    public MessageEntity startApproval(HttpServletRequest request,
                                       @RequestParam("name") String name,
                                       @RequestParam("iphone") String iphone,
                                       @RequestParam("email") String email,
                                       @RequestParam("job") String job,
                                       @RequestParam("score") Integer score,
                                       @RequestParam("startTime") String startTimeS,
                                       @RequestParam("endTime") String endTimeS) {
        ApprovalEntity approvalEntity = new ApprovalEntity();
        Date startTime = new Date();
        Date endTime = new Date();
        if (startTimeS!=null){
            startTime = DateUtil.strToDate(startTimeS, 6);
        }
        if (endTimeS!=null){
            endTime = DateUtil.strToDate(endTimeS, 6);
        }
        approvalEntity.setName(name);
        approvalEntity.setIphone(iphone);
        approvalEntity.setEmail(email);
        approvalEntity.setJob(job);
        approvalEntity.setScore(score);
        approvalEntity.setStartTime(startTime);
        approvalEntity.setEndTime(endTime);
        approvalService.startApproval(approvalEntity,request);
        return ResultUtil.success(request);
    }

    @RequestMapping(value = "findFlowImage",produces = "application/json",method = RequestMethod.POST)
    @ApiOperation("查看审批流程图")
    public MessageEntity findFlowImage(HttpServletRequest request, HttpServletResponse response,
                                       @RequestParam(value = "id") String id) {
        Long idL = ParamUtil.getLongParameter(id, -1L);
        return approvalService.getApprovalRate(idL,response);
    }

    @RequestMapping(value = "findFlowDetail",produces = "application/json",method = RequestMethod.POST)
    @ApiOperation("查看审批流程节点详情")
    public String findFlowDetail(HttpServletRequest request, ModelMap mm,
                                 @RequestParam("id") String ids) {
        Long id = com.cbim.common.util.ParamUtil.getLongParameter(request, "ids", -1);
        return approvalService.findFlowDetail(id,mm);
    }

    @RequestMapping(value = "approval",produces = "application/json",method = RequestMethod.POST)
    @ApiOperation("流程节点审批")
    public MessageEntity approval(HttpServletRequest request, HttpServletResponse response,
                                  @RequestParam("name") String name,
                                  @RequestParam("iphone") String iphone,
                                  @RequestParam("email") String email,
                                  @RequestParam("job") String job,
                                  @RequestParam("result") String result,
                                  @RequestParam("score") Integer score,
                                  @RequestParam("startTime") String startTimeS,
                                  @RequestParam("endTime") String endTimeS) {
        ApprovalEntity approvalEntity = new ApprovalEntity();
        Date startTime = new Date();
        Date endTime = new Date();
        if (startTimeS!=null){
            startTime = DateUtil.strToDate(startTimeS, 6);
        }
        if (endTimeS!=null){
            endTime = DateUtil.strToDate(endTimeS, 6);
        }
        approvalEntity.setName(name);
        approvalEntity.setIphone(iphone);
        approvalEntity.setEmail(email);
        approvalEntity.setJob(job);
        approvalEntity.setResult(Integer.parseInt(result));
        approvalEntity.setScore(score);
        approvalEntity.setStartTime(startTime);
        approvalEntity.setEndTime(endTime);
        return approvalService.approval(request,approvalEntity);
    }

    @RequestMapping(value = "findWithDown",produces = "application/json",method = RequestMethod.GET)
    @ApiOperation("获取待办流程列表")
    public String findWithDown(HttpServletRequest request, ModelMap mm) {
        return approvalService.findWithDown(request,mm);
    }

    @RequestMapping(value = "findFlowHistory",produces = "application/json",method = RequestMethod.POST)
    @ApiOperation("查看审批历史")
    public MessageEntity findFlowHistory(HttpServletRequest request,
                                         @RequestParam(value = "id") String id) {
        return approvalService.findFlowHistory(id);
    }

}

3.Service

package com.chat.api.web.service;

import cn.hutool.core.collection.CollUtil;
import com.chat.api.common.exception.ApiException;
import com.chat.api.utils.ResultUtil;
import com.chat.api.utils.util.IdWorkerUtil;
import com.chat.api.utils.util.ParamUtil;
import com.chat.api.web.dao.ApprovalRepo;
import com.chat.api.web.po.ApprovalBean;
import com.chat.api.web.po.BlogBean;
import com.chat.api.web.po.UserBean;
import com.chat.api.web.vo.ApprovalEntity;
import com.chat.api.web.vo.MessageEntity;
import com.google.common.collect.Lists;
import org.activiti.bpmn.model.BpmnModel;
import org.activiti.engine.*;
import org.activiti.engine.history.HistoricActivityInstance;
import org.activiti.engine.history.HistoricProcessInstance;
import org.activiti.engine.identity.User;
import org.activiti.engine.repository.Deployment;
import org.activiti.engine.repository.ProcessDefinition;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.activiti.engine.task.TaskQuery;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.ui.ModelMap;

import javax.imageio.ImageIO;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.awt.image.BufferedImage;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.*;

@Service
public class ApprovalService {

    @Autowired
    private ApprovalRepo approvalRepo;
    @Autowired
    private TaskService taskService;
    @Autowired
    private ProcessEngine processEngine;
    @Autowired
    private HistoryService historyService;
    @Autowired
    private RepositoryService repositoryService;
    @Autowired
    private RuntimeService runtimeService;
    @Autowired
    private UserService userService;
    @Autowired
    private ChatService chatService;

    /**
     * 部署审批流程
     * @return
     */
    public Boolean deployProcess(String flowName) {
        Deployment deployment = repositoryService.createDeployment()
                .name(flowName)
                .addClasspathResource("processes/apply1.bpmn")
                .addClasspathResource("processes/apply1.png")
                .deploy();
        System.out.println("部署ID："+deployment.getId());//1
        System.out.println("部署时间："+deployment.getDeploymentTime());
        return true;
    }

    /**
     * 启动流程
     * @return
     * @param approvalEntity
     */
    @Transactional(readOnly = false)
    public void startApproval(ApprovalEntity approvalEntity,HttpServletRequest request) {
        UserBean userInfo = userService.findByUserInfo(request);
        approvalEntity.setId(IdWorkerUtil.getInstance().toString());
        //获取审批流程id
        Deployment de = repositoryService.createDeploymentQuery()
                .deploymentName("面试审批")
                .singleResult();
        //启动一个新的审批流程
        ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery()
                .deploymentId(de.getId()).singleResult();
        ProcessInstance processInstance = runtimeService.startProcessInstanceById(processDefinition.getId());
        String processInstanceId = processInstance.getProcessInstanceId();

        //提交审批
        Task task = taskService.createTaskQuery().processInstanceId(processInstanceId).singleResult();
        Map<String, Object> map = new HashMap<>();
        //将下一个审批人数据存到对象里
        map.put("inner_introduce",approvalEntity.getApprover());
        taskService.complete(task.getId(),map);
        ApprovalBean approvalBean = new ApprovalBean();
        approvalEntity.setBean(approvalBean);
        approvalBean.setApproverId(approvalEntity.getApprover());
        approvalBean.setInitiatorId(userInfo.getId());
        approvalBean.setProcInstId(processInstanceId);
        approvalBean.setCreateBy(userInfo.getId());
        approvalBean.setCreateDate(new Date());
        approvalRepo.save(approvalBean);
    }

    /**
     * @Des: 查看待办流程
     * @Author: liut
     * @Date: 2020/11/13 10:11
     */
    public String findWithDown(HttpServletRequest request, ModelMap mm){
        List<ApprovalEntity> list = Lists.newArrayList();
        UserBean userInfo = userService.findByUserInfo(request);
        List<ApprovalBean> approvalBeans = approvalRepo.findByApproverId(userInfo.getId());
        //查出所有待办流程
        for (ApprovalBean approvalBean : approvalBeans) {
            Task task = taskService.createTaskQuery().taskAssignee(approvalBean.getProcInstId()).singleResult();
            if (!approvalBean.getProcInstId().equals(task.getProcessInstanceId()))
                continue;
            ApprovalEntity entity = new ApprovalEntity();
            entity.setValue(approvalBean);
            UserBean initiator = userService.findById(approvalBean.getInitiatorId());
            entity.setInitiator(initiator.getName());
            entity.setFlowNodeName(task.getName());
            list.add(entity);
        }
        mm.addAttribute("user",userInfo);
        mm.addAttribute("list",list);
        return "/approval/approvalList.html";
    }

    /**
     * @Des: 查看流程节点详情
     * @Author: liut 
     * @Date: 2020/11/13 11:26
     */
    public String findFlowDetail(Long approvalId, ModelMap mm){
        ApprovalBean bean = approvalRepo.getOne(approvalId);
        ApprovalEntity entity = new ApprovalEntity();
        entity.setValue(bean);
        mm.addAttribute("entity",entity);
        return "/approval/form.html";
    }

    /**
     * 进行审批
     * @return
     */
    @Transactional(readOnly = false)
    public MessageEntity approval(HttpServletRequest request,ApprovalEntity approvalEntity){
        UserBean userInfo = userService.findByUserInfo(request);
        //进行流程审批
        List<Task> list = taskService.createTaskQuery().taskAssignee(userInfo.getUsername()).list();
        for (Task task : list) {
            if (!task.getProcessInstanceId().equals(approvalEntity.getProcInstId())){
                continue;
            }
            Map<String, Object> map = CollUtil.newHashMap();
            map.put("result",approvalEntity.getResult());
            map.put("score",approvalEntity.getScore());
            map.put("user",approvalEntity.getApprover());
            taskService.complete(task.getId(),map);
            //将最新数据持久化
            ApprovalBean approvalBean = new ApprovalBean();
            approvalEntity.setBean(approvalBean);
            //将下一个审批人数据存到对象里
            approvalBean.setApproverId(approvalEntity.getApprover());
            approvalBean.setUpdateBy(userInfo.getId());
            approvalBean.setUpdateDate(new Date());
            approvalRepo.save(approvalBean);//流程节点名称、开始时间、审批人、状态
        }
        return ResultUtil.success("审批完成");
    }

    /**
     * 删除审批流程
     * @param approvalEntity
     */
    @Transactional(readOnly = false)
    public MessageEntity deleteByBlogId(ApprovalEntity approvalEntity) {
        try {
            String message = "很抱歉，您的面试申请已被驳回，。。。";
            Task task = taskService.createTaskQuery().taskId(approvalEntity.getProcInstId()).singleResult();
            if (task == null) return ResultUtil.success("未找到相对应流程");
            runtimeService.deleteProcessInstance(task.getProcessInstanceId(),"终止流程");
            chatService.sendMsg(Long.parseLong(approvalEntity.getInitiator()),message);
            return ResultUtil.success("审批流程删除成功");
        }catch (Exception e){
            e.printStackTrace();
            throw new ApiException("删除审批流程异常");
        }
    }

    /**
     * 查看审批进度图
     */
    public MessageEntity getApprovalRate(Long approvalId, HttpServletResponse response) {
        try {
            ApprovalBean bean = approvalRepo.getOne(approvalId);
            if (bean == null){
                return ResultUtil.success("没有流程图可供查看");
            }
            Task task = taskService.createTaskQuery().processInstanceId(bean.getProcInstId()).singleResult();
            InputStream is =getDiagram(task.getProcessInstanceId());
            if (is == null) ResultUtil.success("没有流程图可供查看");
            response.setContentType("image/png");

            BufferedImage image = ImageIO.read(is);
            OutputStream out = response.getOutputStream();
            ImageIO.write(image, "png", out);

            is.close();
            out.close();
            return ResultUtil.success("成功");
        }catch (Exception e){
            e.printStackTrace();
            throw new ApiException("系统繁忙，请稍后再试！！！");
        }
    }

    //获取流程审批进程图
    public InputStream getDiagram(String processInstanceId) {
        //获得流程实例
        ProcessInstance processInstance = runtimeService.createProcessInstanceQuery()
                .processInstanceId(processInstanceId).singleResult();
        String processDefinitionId = StringUtils.EMPTY;
        if (processInstance == null) {
            //查询已经结束的流程实例
            HistoricProcessInstance processInstanceHistory =
                    historyService.createHistoricProcessInstanceQuery()
                            .processInstanceId(processInstanceId).singleResult();
            if (processInstanceHistory == null)
                return null;
            else
                processDefinitionId = processInstanceHistory.getProcessDefinitionId();
        } else {
            processDefinitionId = processInstance.getProcessDefinitionId();
        }

        //使用宋体
        String fontName = "宋体";
        //获取BPMN模型对象
        BpmnModel model = repositoryService.getBpmnModel(processDefinitionId);
        //获取流程实例当前的节点，需要高亮显示
        List<String> currentActs = Collections.EMPTY_LIST;
        if (processInstance != null)
            currentActs = runtimeService.getActiveActivityIds(processInstance.getId());

        return processEngine.getProcessEngineConfiguration()
                .getProcessDiagramGenerator()
                .generateDiagram(model, "png", currentActs, new ArrayList<String>(),
                        fontName, fontName, fontName, null, 1.0);
    }

    /**
     * @Des: 查看审批历史记录
     * @Author: liut
     * @Date: 2020/11/13 13:34
     */
    public MessageEntity findFlowHistory(String proinstId) {
        List<HistoricActivityInstance> list = historyService.createHistoricActivityInstanceQuery().processInstanceId(proinstId).list();
//        for (HistoricActivityInstance hai : list) {
//            System.out.println("===========================");
//            System.out.println("任务ID:"+hai.getId());
//            System.out.println("流程实例ID:"+hai.getProcessInstanceId());
//            System.out.println("活动名称："+hai.getActivityName());
//            System.out.println("办理人："+hai.getAssignee());
//            System.out.println("开始时间："+hai.getStartTime());
//            System.out.println("结束时间："+hai.getEndTime());
//            System.out.println("===========================");
//        }
        return ResultUtil.success(list);
    }
}
三3三
关注
专栏目录
Springboot整合Activiti6.0 工作流项目实践
qq_41018959的博客
04-18 7663
最近项目中需要用到工作流，所以又临时对Activiti工作流进行突击补习，再参考网上各大牛的技术博客，总算对Activiti有了一丢丢的了解及应用技巧。 开始做之前，我们要先学会制作工作流程图，网上都有介绍制图工具，我用的是idea下的actiBPM插件，其他的还有eclipse+activiti插件以及activiti6.0的工作站等。 Idea安装actiBPM插件，在plugin下，搜索...
springBoot2.0+activity6.0整合前端编辑器设计流程
qq_37703723的博客
12-26 2118
springBoot整合activity6.0+前端设计器 application.properties文件配置如下 #server 配置 spring.application.name=gisv2-activity server.port=9100 server.servlet.context-path=/ spring.thymeleaf.mode=LEGACYHTML5 spring.thy...
【activiti 7】spring boot集成activiti 7工作流
m0_71621983的博客
07-20 940
1，什么是工作流：工作流()，就是通过计算机对业务流程自动化执行管理。它主要解决的是“使在多个参与者之间按照某种预定义的规则自动进行传递文档、信息或任务的过程，从而实现某个预期的业务目标，或者促使此目标的实现”。2，工作流系统：一个软件系统中具有工作流的功能，我们把它称为工作流系统，一个系统中工作流的功能是什么？就是对系统的业务流程进行自动化管理，所以工作流是建立在业务流程的基础上，所以一个软件的系统核心根本上还是系统的业务流程，工作流只是协助进行业务流程管理。即使没有工作流业务系统也可以开发运行，只不过有
spring boot 完整Activiti6.0 Demo
09-19
spring boot 完整Activiti6.0 实现，经过测试可以使用。
springboot集成activity
最新发布
猿脑2.0的博客
07-06 656
Spring Boot 是一个开源的 Java-based 微服务框架，用于创建独立的、生产级别的基于 Spring 的应用程序。而 Activity 是一个工作流引擎，用于构建业务流程管理（BPM）平台。将 Spring Boot 与 Activity 集成，可以使得 Spring Boot 应用拥有流程管理的功能。
springboot整合activiti简单案例
So_hhh的博客
06-21 1792
springboot整合activiti简单案例： springboot：1.5 activiti：6.0 所需要的pom依赖： springboot整合activiti只需要一个pom依赖就够了。 <dependencies> <dependency> <groupId>org.ac...
《SpringBoot2.0 实战》系列-集成Activiti6.0（案例详解）
小葫芦的博客
11-11 6611
前言 最近项目中需要用到工作流审批流程，业务功能比较简单，就是员工请假，领导审批同意或者驳回的操作。本来准备自己做一套简单的审批流程（数据库记录下状态的这种），但是考虑到后期的拓展性，可能会有多审批、加签等复杂的操作，还是决定使用工作流框架，最后选择了Activiti。 简介 Activiti是一种轻量级，可嵌入的BPM引擎，而且还设计适用于可扩展的云架构。可以和springboot完...
Springboot集成activity过程图解
08-19
主要介绍了Springboot集成activity过程图解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
基于springboot+mybatis+shiro+activity的企业办公Oa系统（源码+数据库），个人学习，本科毕业设计
06-16
基于springboot+mybatis+shiro+activity构建的企业办公Oa系统，适合个人学习，本科毕业设计，大作业，项目经过严格测试，确保可以运行！ OA 项目介绍 基于 springboot+myvatis_+ mvc + activiti+quarts+quartz 写的...
毕业设计使用springboot+mybatis+shiro+activity的企业办公Oa系统.zip
02-25
毕业设计使用springboot+mybatis+shiro+activity的企业办公Oa系统.zip 项目介绍 基于 springboot+myvatis_+ mvc + activiti+quarts+quartz 写的一个办公企业管理系统 OA 软件架构 springboot+myvatis_+ mvc + ...
Springboot2.0.5+activiti6.0 vue-element-admin 前后端分离 流程跟踪优化
a_54654646的博客
07-13 4432
本项目使用：Springboot vue-element-admin shiro activiti前后端分离，流程审批，权限管理框架 技术说明： java版本：jdk1.8 Springboot：2.0.5 activiti：6.0.0 id生成采用雪花算法高效生成，适用于分布式系统 数据库：mysql-5.7.14 权限shiro：1.4.0 swagger：1.8.0 前端：vue-2.6....
activiti7和springboot经典实例工程
02-02
activiti7
spring boot整合activiti modeler实例源码下载
06-06
spring boot 1.5.3整合activiti modeler 5.22.0，详细参考：http://blog.csdn.net/chenhai201/article/details/72668275
springboot整合activiti完整demo
05-31
SpringBoot整合Activiti简单示例，示例中包含正常流程执行、指定流程节点执行人等测试代码。
activiti 7 + springboot2（七） Activiti流程实例的运行过程源代码
01-13
流程部署完成后，每启动一次流程就是一个流程实例。 （一）根据流程定义key启动流程实例 （二）启动流程实例的时候指定businesskey(业务标识) （三）查询流程实例 （四）删除已经部署成功的流程 （五）删除流程实例 （六）操作流程挂起、激活 （七）单个流程实例的挂起，激活 （八）实例任务的执行
idea +springboot + activiti 请假实例源码
08-23
在idea中将springboot于activiti整合的简单实例，一看就懂
毕业设计，基于springboot+mybatis+shiro+activity+bootstrap开发的的企业办公OA系统
01-10
毕业设计，基于springboot+mybatis+shiro+activity+bootstrap开发的的企业办公OA系统 项目介绍 基于 springboot+myvatis_+ mvc + activiti+quarts+quartz 写的一个办公企业管理系统 OA 软件架构 springboot+...
Spring Boot-2.3.7.RELEASE整合activiti-6.0示例步骤
sjy_2010的专栏
08-21 434
涉及简单审批时一般都是有人发起，再由另外一人确认审核即可！实际项目中有时涉及利益的时候，比如常见的请假，报销等，就不是那么简单一人审核了事！其中有权力和责任的体现，同时执行过程中也涉及业务流程管理、工作流、服务协作等，此时开源Activiti就是个不错的选择！现介绍Spring Boot整合activiti-6.0步骤如下！
springBoot1x版本+Activiti6.0完整demo实例
weixin_44034570的博客
02-14 528
在开始操作之前呢，先去了解清楚Activit是什么？版本有何不同，我这里呢使用的是6.0版本。 闲话不多说，我们开始项目教程基于SpringBoot+Activiti的demo案例，首先我们需要导入所需要的Activiti依赖(记住要将springBoot版本改为1.0版本，用2.0后续启动需要去除安全框架比较麻烦，当然你也可以选择用2.0然后去掉，我这里就演示1.0的) 依赖导完，我们就开始在s...
做一个springboot+vue人事管理系统,系统数据流图怎么画
04-19
具体来说，可以使用UML中的活动图(Activity Diagram)来表示人事管理系统的数据流程。在活动图中，可以使用矩形框表示每个活动或动作，使用箭头表示不同活动之间的流程关系。同时，也可以使用不同的泳道(或线程)来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值