springboot 整合 activiti工作流 学习

最新推荐文章于 2025-07-08 08:43:33 发布
最新推荐文章于 2025-07-08 08:43:33 发布
阅读量554 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： 【工作流】 文章标签： spring boot spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/xiamaocheng/article/details/120498086
本文档详细介绍了如何在SpringBoot项目中整合Activiti工作流，包括引入Maven依赖、配置文件设置、流程文件部署、服务创建、实体类及业务接口的实现，以及控制器中任务操作的方法。通过示例展示了工作流的启动、查询、审批等关键步骤，提供了一个完整的工作流管理系统的基础框架。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

idea activiti 工作流安装插件

LD is tigger forever，CG are not brothers forever， throw the pot and shine forever.
Modesty is not false, solid is not naive, treacherous but not deceitful, stay with good people, and stay away from poor people.
talk is cheap, show others the code and KPI， Keep progress，make a better result.
Survive during the day and develop at night。

目录

概 述

引入的Maven

         引入依赖：
            <!-- activiti -->
             	<dependency>
	             	<groupId>org.activiti</groupId>
		            <artifactId>activiti-spring-boot-starter-basic</artifactId>
		            <version>6.0.0</version>
	            </dependency>
	        <!--整合activiti的 druid 要求的版本为0.2.16 或 1.0.9，百度上说是官方的bug-->
            	<dependency>
	            	<groupId>com.alibaba</groupId>
		           <artifactId>druid</artifactId>
	            	<version>0.2.16</version>
	            </dependency>

配置文件

       # activiti default configuration
       #在activiti的默认配置中，process-definition-location-prefix 是指定activiti流程描述文件的前缀（即路径），
       #启动时，activiti就会去寻找此路径下的流程描述文件，并且自动部署；suffix 是一个String数组，表示描述文件的默    认后缀名，默认以上两种。
       activiti:
         database-schema-update: true #是否每次都更新数据库
         # 自动部署验证设置:true-开启（默认）、false-关闭
         check-process-definitions: true # activti是否自动部署
         process-definition-location-prefix: classpath:/processes/
         #process-definition-location-suffixes: .bpmn
         history-level: full
         #db-history-used: true
         db-identity-used: false

第三步：建processes文件夹

利用工具生成对应的bpmn 对应的流程图：

创建创建activiti提供的各种服务 ActivitiConfig

package com.shiro_learning.demo.config.activiti;

import org.activiti.engine.*;
import org.activiti.spring.SpringProcessEngineConfiguration;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.Resource;
import org.springframework.core.io.ResourceLoader;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import javax.sql.DataSource;
import java.io.IOException;

     /**
           创建activiti提供的各种服务
      */

 @Configuration
public class ActivitiConfig{
private Logger logger = LoggerFactory.getLogger(ActivitiConfig.class);

@Value("${spring.activiti.database-schema-update}")
private String databaseSchemaUpdate;

@Value("${spring.activiti.db-identity-used}")
private boolean dbIdentityUsed;

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

@Bean
public ProcessEngine processEngine(DataSourceTransactionManager transactionManager, DataSource dataSource) throws IOException {
    logger.info("==========activiti=======开始==============");
    SpringProcessEngineConfiguration configuration = new SpringProcessEngineConfiguration();

    /*  自动部署已有的流程文件
    作用相当于 (据bpmn文件部署流程repositoryService.createDeployment().addClasspathResource("singleAssignee.bpmn").deploy();)*/

    Resource[] resources = new PathMatchingResourcePatternResolver().getResources(ResourceLoader.CLASSPATH_URL_PREFIX + "processes/*.bpmn");
    configuration.setTransactionManager(transactionManager);
    //设置数据源
    configuration.setDataSource(dataSource);
    //是否每次都更新数据库
    //configuration.setDatabaseSchemaUpdate(databaseSchemaUpdate);
    configuration.setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_FALSE);
    //configuration.setAsyncExecutorActivate(false);
    configuration.setDeploymentResources(resources);
    //设置是否使用activti自带的用户体系
    configuration.setDbIdentityUsed(dbIdentityUsed);
    return configuration.buildProcessEngine();
}


/**
 * 工作流仓储服务
 * @param processEngine
 * @return
 */

@Bean
public RepositoryService repositoryService(ProcessEngine processEngine) {
    return processEngine.getRepositoryService();
}


/**
 * 工作流运行服务
 * @param processEngine
 * @return
 */

@Bean
public RuntimeService runtimeService(ProcessEngine processEngine) {
    return processEngine.getRuntimeService();
}

/**
 * 工作流任务服务
 * @param processEngine
 * @return
 */

@Bean
public TaskService taskService(ProcessEngine processEngine) {
    return processEngine.getTaskService();
}


/**
 * 工作流历史数据服务
 * @param processEngine
 * @return
 */

@Bean
public HistoryService historyService(ProcessEngine processEngine) {
    return processEngine.getHistoryService();
}


/**
 * 工作流管理服务
 * @param processEngine
 * @return
 */

@Bean
public ManagementService managementService(ProcessEngine processEngine) {
    return processEngine.getManagementService();
}


/**
 * 工作流唯一服务
 * @param processEngine
 * @return
 */

@Bean
public IdentityService identityService(ProcessEngine processEngine) {
    return processEngine.getIdentityService();
   }
}

实体类：ActivitiTask，Activiti 业务类：ActivitiServiceImpl 和 业务接口：ActivitiService 控制类：ActivitiController

package com.shiro_learning.demo.controller;

import com.shiro_learning.demo.entity.Activiti;
import com.shiro_learning.demo.entity.ActivitiTask;
import com.shiro_learning.demo.entity.ResponseMsg;
import com.shiro_learning.demo.entity.User;
import com.shiro_learning.demo.service.ActivitiService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpSession;
import java.util.List;

@Controller
@RequestMapping("/activity")
public class ActivitiController {

    @Autowired
    private ActivitiService activitiService;

    @RequestMapping(value = "/allRecord", method = RequestMethod.GET)
    //@ResponseBody
    public String allRecord(HttpSession session,Model model) {
        //myActiviti();
        List<Activiti> list = myActiviti(session);
        model.addAttribute("list",list);
        //myApproval();
        List<ActivitiTask> list3 = myApproval(session);
        model.addAttribute("list3",list3);
        //myActivitiRecord();
        List<Activiti> list2 = myActivitiRecord(session);
        model.addAttribute("list2",list2);
        //myApprovalRecord();
        List<Activiti> list4 = myApprovalRecord(session);
        model.addAttribute("list4",list4);
        return "activitiList";
    }


    @RequestMapping(value = "/createActiviti", method = RequestMethod.POST)
    @ResponseBody
    public Object createActiviti(Activiti vac,HttpSession session){
        ResponseMsg<Object> msg = new ResponseMsg<Object>();
        User user=(User)session.getAttribute("user");
        String userName = user.getUsername();
        activitiService.startActiviti(vac, userName);
        msg.setCode(0);
        return msg;
    }

    //我正在申请的假
    @RequestMapping(value = "/myActiviti", method = RequestMethod.GET)
    public List<Activiti> myActiviti(HttpSession session) {
        User user=(User)session.getAttribute("user");
        String userName = user.getUsername();
        List<Activiti> list = activitiService.myActiviti(userName);
        return list;
    }

    //待我审核的请假
    @RequestMapping(value = "/myApproval", method = RequestMethod.GET)
    public List<ActivitiTask> myApproval(HttpSession session) {
        User user=(User)session.getAttribute("user");
        //String userName = user.getUsername();
        String userName = "huangxu2";
        List<ActivitiTask> list3 = activitiService.myApproval(userName);
        return list3;
    }

    @RequestMapping(value = "/passApproval", method = RequestMethod.POST)
    @ResponseBody
    public Object passApproval(String id,String result,HttpSession session) {
        ResponseMsg<Object> msg = new ResponseMsg<Object>();
        User user=(User)session.getAttribute("user");
        ActivitiTask activitiTask = new ActivitiTask();
        Activiti activiti = new Activiti();
        activitiTask.setId(id);
        activiti.setResult(result);
        activitiTask.setActiviti(activiti);
        String userName = user.getUsername();
        activitiService.passApproval(userName, activitiTask);
        msg.setCode(0);
        return msg;
    }

    //我申请过的假
    @RequestMapping(value = "/myActivitiRecord", method = RequestMethod.GET)
    public List<Activiti> myActivitiRecord(HttpSession session) {
        User user=(User)session.getAttribute("user");
        String userName = user.getUsername();
        List<Activiti> list2 = activitiService.myActivitiRecord(userName);
        return list2;
    }

    //我的审核记录
    @RequestMapping(value = "/myApprovalRecord", method = RequestMethod.GET)
    public List<Activiti> myApprovalRecord(HttpSession session) {
        User user=(User)session.getAttribute("user");
        String userName = user.getUsername();
        List<Activiti> list4 = activitiService.myApprovalRecord(userName);
        return list4;
    }
}

任务列表：



import java.util.Date;

public class ActivitiTask {

    private String id;
    private String name;
    private Activiti activiti;
    private Date createTime;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Activiti getActiviti() {
        return activiti;
    }

    public void setActiviti(Activiti activiti) {
        this.activiti = activiti;
    }
}

工作流：

import java.io.Serializable;
import java.util.Date;

public class Activiti implements Serializable{

/**
 * 申请人
 */
private String applyUser;
private int days;
private String reason;
private Date applyTime;
private String applyStatus;

/**
 * 审核人
 */
private String auditor;
private String result;
private Date auditTime;

public String getApplyUser() {
    return applyUser;
}

public void setApplyUser(String applyUser) {
    this.applyUser = applyUser;
}

public int getDays() {
    return days;
}

public void setDays(int days) {
    this.days = days;
}

public String getReason() {
    return reason;
}

public void setReason(String reason) {
    this.reason = reason;
}

public Date getApplyTime() {
    return applyTime;
}

public void setApplyTime(Date applyTime) {
    this.applyTime = applyTime;
}

public String getApplyStatus() {
    return applyStatus;
}

public void setApplyStatus(String applyStatus) {
    this.applyStatus = applyStatus;
}

public String getAuditor() {
    return auditor;
}

public void setAuditor(String auditor) {
    this.auditor = auditor;
}

public String getResult() {
    return result;
}

public void setResult(String result) {
    this.result = result;
}

public Date getAuditTime() {
    return auditTime;
}

public void setAuditTime(Date auditTime) {
    this.auditTime = auditTime;
}

工作流：

/**
   RepositoryService:  流程仓库Service，用于管理流程仓库，例如：部署，删除，读取流程资源

   IdentityService：身份Service，可以管理，查询用户，组之间的关系

   RuntimeService：运行时Service，可以处理所有正在运行状态的流程实例，任务等

   TaskService：任务Service，用于管理，查询任务，例如：签收，办理，指派等

   HistoryService：历史Service，可以查询所有历史数据，例如：流程实例，任务，活动，变量，附件等

   FormService：表单Service，用于读取和流程，任务相关的表单数据

   ManagementService：引擎管理Service，和具体业务无关，主要是可以查询引擎配置，数据库，作业等

   DynamicBpmnService：一个新增的服务，用于动态修改流程中的一些参数信息等，是引擎中的一个辅助的服务
  */
  @Service
  public class ActivitiServiceImpl implements ActivitiService {
  private Logger logger = LoggerFactory.getLogger(ActivitiServiceImpl.class);
   //所运行工作流的名字
   //private static final String PROCESS_DEFINE_KEY = "test.bpmn";
   private static final String PROCESS_DEFINE_KEY = "demo2";
   private static final String NEXT_ASSIGNEE = "huangxu2";
   @Resource
   private RuntimeService runtimeService;
   @Resource
   private IdentityService identityService;
   @Resource
   private TaskService taskService;
   @Resource
   private HistoryService historyService;
   @Resource
   private RepositoryService repositoryService;

/* //工作流运行服务
@Autowired
private RuntimeService runtimeService;

//工作流唯一服务
@Autowired
private IdentityService identityService;

//工作流任务服务
@Autowired
private TaskService taskService;

//工作流管理服务
@Autowired
private HistoryService historyService;
@Autowired
private RepositoryService repositoryService;
  */
/**
 * 开始流程
 * @param vac
 * @param userName
 * @return
 */
@Override
public Boolean startActiviti(Activiti vac, String userName) {
    logger.info("method startActivityDemo begin....");
    /*认证用户的作用是设置流程发起人：在流程开始之前设置，会自动在表ACT_HI_PROCINST 中的START_USER_ID_中设置用户ID
    用来设置启动流程的人员ID，引擎会自动把用户ID保存到activiti:initiator中*/
    try{
        identityService.setAuthenticatedUserId(userName);
        // 开始流程
        ProcessInstance pi = runtimeService.startProcessInstanceByKey(PROCESS_DEFINE_KEY);
        String processId = pi.getId();
        logger.info("===============processId==================="+processId);

        // 查询当前任务
        Task currentTask = taskService.createTaskQuery().processInstanceId(pi.getId()).singleResult();
        String taskId1 = currentTask.getId();
        logger.info("===============taskId1==================="+taskId1);

        // 申明任务人
        //taskService.claim(currentTask.getId(), userName);
        taskService.setAssignee(taskId1, userName);
        Map<String, Object> vars = new HashMap<>(4);
        vars.put("applyUser", userName);
        vars.put("days", vac.getDays());
        vars.put("reason", vac.getReason());
        //在此方法中，Vaction 是申请时的具体信息，在完成“申请请假”任务时，可以将这些信息设置成参数。
        //完成第一步申请
        taskService.complete(currentTask.getId(), vars);

        // 到了下一个任务， 应该在此处指派任务由谁来处理
        // 重新获取当前任务
        Task task = taskService.createTaskQuery().processInstanceId(processId).singleResult();
        String taskId2 = task.getId();
        logger.info("===============taskId2==================="+taskId2);
        taskService.setAssignee(taskId2, NEXT_ASSIGNEE);
    }catch (Exception e){
        e.printStackTrace();
    }
    return true;
}


@Override
public List<Activiti> myActiviti(String userName) {
    List<ProcessInstance> instanceList = runtimeService.createProcessInstanceQuery().startedBy(userName).list();
    List<Activiti> activitisList = new ArrayList<>();
    for (ProcessInstance instance : instanceList) {
        Activiti activiti = getActiviti(instance);
        activitisList.add(activiti);
    }
    return activitisList;
}


/**
 * 查询需要自己审批
 * @param userName
 * @return
 */
@Override
public List<ActivitiTask> myApproval(String userName) {
    userName = "huangxu2";
    List<Task> taskList = taskService.createTaskQuery().taskAssignee(userName)
            .orderByTaskCreateTime().desc().list();
            // 多此一举 taskList中包含了以下内容(用户的任务中包含了所在用户组的任务)
            //        Group group = identityService.createGroupQuery().groupMember(userName).singleResult();
            //        List<Task> list = taskService.createTaskQuery().taskCandidateGroup(group.getId()).list();
            //        taskList.addAll(list);
    List<ActivitiTask> activitiTaskList = new ArrayList<>();
    for (Task task : taskList) {
        ActivitiTask activitiTask = new ActivitiTask();
        activitiTask.setId(task.getId());
        activitiTask.setName(task.getName());
        activitiTask.setCreateTime(task.getCreateTime());
        String instanceId = task.getProcessInstanceId();
        ProcessInstance instance = runtimeService.createProcessInstanceQuery().processInstanceId(instanceId).singleResult();
        Activiti activiti = getActiviti(instance);
        activitiTask.setActiviti(activiti);
        activitiTaskList.add(activitiTask);
    }
    return activitiTaskList;
}


private Activiti getActiviti(ProcessInstance instance) {
    Integer days = runtimeService.getVariable(instance.getId(), "days", Integer.class);
    String reason = runtimeService.getVariable(instance.getId(), "reason", String.class);
    Activiti activiti = new Activiti();
    activiti.setApplyUser(instance.getStartUserId());
    activiti.setDays(days);
    activiti.setReason(reason);
    Date startTime = instance.getStartTime(); // activiti 6 才有
    activiti.setApplyTime(startTime);
    activiti.setApplyStatus(instance.isEnded() ? "申请结束" : "等待审批");
    return activiti;
}


/**
 * Activiti任务认领
 * taskService.setAssignee(String taskId, String userId);
 * taskService.claim(String taskId, String userId);
 * taskService.setOwner(String taskId, String userId);
 * setAssignee和claim两个的区别是在认领任务时，claim会检查该任务是否已经被认领，如果被认领则会抛出ActivitiTaskAlreadyClaimedException ,而setAssignee不会进行这样的检查，其他方面两个方法效果一致。
 * setOwner和setAssignee的区别在于,setOwner是在代理任务时使用，代表着任务的归属者，而这时，setAssignee代表的是代理办理者，
 *
 * 举个例子来说，公司总经理现在有个任务taskA，去核实一下本年度的财务报表，他现在又很忙没时间，于是将该任务委托给其助理进行办理，此时，就应该这么做
 * taskService.setOwner(taskA.getId(), 总经理.getId());
 * taskService.setAssignee/claim(taskA.getId(), 助理.getId());
 */
/**
 * 审批操作
 * @param userName
 * @param activitiTask
 * @return
 */
/**
 * 同理，result是审批的结果，也是在完成审批任务时需要传入的参数；taskId是刚才老板查询到的当前需要自己完成的审批任务ID。
 * （如果流程在这里设置分支，可以通过判断result的值来跳转到不同的任务）
 */
@Override
public Boolean passApproval(String userName, ActivitiTask activitiTask) {
    userName = "huangxu2";
    String taskId = activitiTask.getId();
    String result = activitiTask.getActiviti().getResult();
    Map<String, Object> vars = new HashMap<>();
    vars.put("result", result);
    vars.put("auditor", userName);
    vars.put("auditTime", new Date());
    //taskService.claim(taskId, userName);
    taskService.setAssignee(taskId, userName);
    taskService.complete(taskId, vars);
    return true;
}


/**
 * 查询已完成的请假记录
 * 由于已完成的请假在数据库runtime表中查不到（runtime表只保存正在进行的流程示例信息），所以需要在history表中查询。
 * @param userName
 * @return
 */
@Override
public List<Activiti> myActivitiRecord(String userName) {
    List<HistoricProcessInstance> hisProInstance = historyService.createHistoricProcessInstanceQuery()
            .processDefinitionKey(PROCESS_DEFINE_KEY).startedBy(userName).finished()
            .orderByProcessInstanceEndTime().desc().list();

    List<Activiti> activitiList = new ArrayList<>();
    for (HistoricProcessInstance hisInstance : hisProInstance) {
        Activiti activiti = new Activiti();
        activiti.setApplyUser(hisInstance.getStartUserId());
        activiti.setApplyTime(hisInstance.getStartTime());
        activiti.setApplyStatus("申请结束");
        List<HistoricVariableInstance> varInstanceList = historyService.createHistoricVariableInstanceQuery()
                .processInstanceId(hisInstance.getId()).list();
        ActivitiUtil.setVars(activiti, varInstanceList);
        activitiList.add(activiti);
    }
    return activitiList;
}


/**
 * 我审批的记录列表
 * @param userName
 * @return
 */
@Override
public List<Activiti> myApprovalRecord(String userName) {
    userName = "huangxu2";
    List<HistoricProcessInstance> hisProInstance = historyService.createHistoricProcessInstanceQuery()
            .processDefinitionKey(PROCESS_DEFINE_KEY).involvedUser(userName).finished()
            .orderByProcessInstanceEndTime().desc().list();

    List<String> auditTaskNameList = new ArrayList<>();
    auditTaskNameList.add("经理审批");
    auditTaskNameList.add("总监审批");
    List<Activiti> activitiList = new ArrayList<>();
    for (HistoricProcessInstance hisInstance : hisProInstance) {
        /*List<HistoricTaskInstance> hisTaskInstanceList = historyService.createHistoricTaskInstanceQuery()
                .processInstanceId(hisInstance.getId()).processFinished()
                .taskAssignee(userName)
                .taskNameIn(auditTaskNameList)
                .orderByHistoricTaskInstanceEndTime().desc().list();
        boolean isMyAudit = false;
        for (HistoricTaskInstance taskInstance : hisTaskInstanceList) {
            if (taskInstance.getAssignee().equals(userName)) {
                isMyAudit = true;
            }
        }
        if (!isMyAudit) {
            continue;
        }*/
        Activiti activiti = new Activiti();
        activiti.setApplyUser(hisInstance.getStartUserId());
        activiti.setApplyStatus("申请结束");
        activiti.setApplyTime(hisInstance.getStartTime());
        List<HistoricVariableInstance> varInstanceList = historyService.createHistoricVariableInstanceQuery()
                .processInstanceId(hisInstance.getId()).list();
        ActivitiUtil.setVars(activiti, varInstanceList);
        activitiList.add(activiti);
    }
    return activitiList;
  }
}

interface接口

public interface ActivitiService {

public Boolean startActiviti(Activiti vac, String userName);

public List<Activiti> myActiviti(String userName);

public List<ActivitiTask> myApproval(String userName);

public Boolean passApproval(String userName, ActivitiTask activitiTask);

public List<Activiti> myActivitiRecord(String userName);

public List<Activiti> myApprovalRecord(String userName);

}



import com.shiro_learning.demo.util.ActivitiUtil;
 import com.shiro_learning.demo.entity.Activiti;
 import com.shiro_learning.demo.entity.ActivitiTask;
 import com.shiro_learning.demo.service.ActivitiService;
 import org.activiti.engine.*;
 import org.activiti.engine.history.HistoricProcessInstance;
 import org.activiti.engine.history.HistoricVariableInstance;
 import org.activiti.engine.runtime.ProcessInstance;
 import org.activiti.engine.task.Task;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Service;
 import javax.annotation.Resource;
 import java.util.*;
/**
   RepositoryService:  流程仓库Service，用于管理流程仓库，例如：部署，删除，读取流程资源

   IdentityService：身份Service，可以管理，查询用户，组之间的关系

   RuntimeService：运行时Service，可以处理所有正在运行状态的流程实例，任务等

   TaskService：任务Service，用于管理，查询任务，例如：签收，办理，指派等

   HistoryService：历史Service，可以查询所有历史数据，例如：流程实例，任务，活动，变量，附件等

   FormService：表单Service，用于读取和流程，任务相关的表单数据

   ManagementService：引擎管理Service，和具体业务无关，主要是可以查询引擎配置，数据库，作业等

   DynamicBpmnService：一个新增的服务，用于动态修改流程中的一些参数信息等，是引擎中的一个辅助的服务
  */
 @Service
  public class ActivitiServiceImpl implements ActivitiService {
  private Logger logger = LoggerFactory.getLogger(ActivitiServiceImpl.class);
   //所运行工作流的名字
   //private static final String PROCESS_DEFINE_KEY = "test.bpmn";
   private static final String PROCESS_DEFINE_KEY = "demo2";
   private static final String NEXT_ASSIGNEE = "huangxu2";
   @Resource
   private RuntimeService runtimeService;
   @Resource
   private IdentityService identityService;
   @Resource
   private TaskService taskService;
   @Resource
   private HistoryService historyService;
   @Resource
   private RepositoryService repositoryService;


/* //工作流运行服务
@Autowired
private RuntimeService runtimeService;

//工作流唯一服务
@Autowired
private IdentityService identityService;

//工作流任务服务
@Autowired
private TaskService taskService;

//工作流管理服务
@Autowired
private HistoryService historyService;
@Autowired
private RepositoryService repositoryService;

总结：

/**
 * 开始流程
 * @param vac
 * @param userName
 * @return
 */
@Override
public Boolean startActiviti(Activiti vac, String userName) {
    logger.info("method startActivityDemo begin....");
    /*认证用户的作用是设置流程发起人：在流程开始之前设置，会自动在表ACT_HI_PROCINST 中的START_USER_ID_中设置用户ID
    用来设置启动流程的人员ID，引擎会自动把用户ID保存到activiti:initiator中*/
    try{
        identityService.setAuthenticatedUserId(userName);
        // 开始流程
        ProcessInstance pi = runtimeService.startProcessInstanceByKey(PROCESS_DEFINE_KEY);
        String processId = pi.getId();
        logger.info("===============processId==================="+processId);

        // 查询当前任务
        Task currentTask = taskService.createTaskQuery().processInstanceId(pi.getId()).singleResult();
        String taskId1 = currentTask.getId();
        logger.info("===============taskId1==================="+taskId1);

        // 申明任务人
        //taskService.claim(currentTask.getId(), userName);
        taskService.setAssignee(taskId1, userName);
        Map<String, Object> vars = new HashMap<>(4);
        vars.put("applyUser", userName);
        vars.put("days", vac.getDays());
        vars.put("reason", vac.getReason());
        //在此方法中，Vaction 是申请时的具体信息，在完成“申请请假”任务时，可以将这些信息设置成参数。
        //完成第一步申请
        taskService.complete(currentTask.getId(), vars);

        // 到了下一个任务， 应该在此处指派任务由谁来处理
        // 重新获取当前任务
        Task task = taskService.createTaskQuery().processInstanceId(processId).singleResult();
        String taskId2 = task.getId();
        logger.info("===============taskId2==================="+taskId2);
        taskService.setAssignee(taskId2, NEXT_ASSIGNEE);
    }catch (Exception e){
        e.printStackTrace();
    }
    return true;
}


@Override
public List<Activiti> myActiviti(String userName) {
    List<ProcessInstance> instanceList = runtimeService.createProcessInstanceQuery().startedBy(userName).list();
    List<Activiti> activitisList = new ArrayList<>();
    for (ProcessInstance instance : instanceList) {
        Activiti activiti = getActiviti(instance);
        activitisList.add(activiti);
    }
    return activitisList;
}


/**
 * 查询需要自己审批
 * @param userName
 * @return
 */
@Override
public List<ActivitiTask> myApproval(String userName) {
    userName = "huangxu2";
    List<Task> taskList = taskService.createTaskQuery().taskAssignee(userName)
            .orderByTaskCreateTime().desc().list();
            // 多此一举 taskList中包含了以下内容(用户的任务中包含了所在用户组的任务)
            //        Group group = identityService.createGroupQuery().groupMember(userName).singleResult();
            //        List<Task> list = taskService.createTaskQuery().taskCandidateGroup(group.getId()).list();
            //        taskList.addAll(list);
    List<ActivitiTask> activitiTaskList = new ArrayList<>();
    for (Task task : taskList) {
        ActivitiTask activitiTask = new ActivitiTask();
        activitiTask.setId(task.getId());
        activitiTask.setName(task.getName());
        activitiTask.setCreateTime(task.getCreateTime());
        String instanceId = task.getProcessInstanceId();
        ProcessInstance instance = runtimeService.createProcessInstanceQuery().processInstanceId(instanceId).singleResult();
        Activiti activiti = getActiviti(instance);
        activitiTask.setActiviti(activiti);
        activitiTaskList.add(activitiTask);
    }
    return activitiTaskList;
}

private Activiti getActiviti(ProcessInstance instance) {
    Integer days = runtimeService.getVariable(instance.getId(), "days", Integer.class);
    String reason = runtimeService.getVariable(instance.getId(), "reason", String.class);
    Activiti activiti = new Activiti();
    activiti.setApplyUser(instance.getStartUserId());
    activiti.setDays(days);
    activiti.setReason(reason);
    Date startTime = instance.getStartTime(); // activiti 6 才有
    activiti.setApplyTime(startTime);
    activiti.setApplyStatus(instance.isEnded() ? "申请结束" : "等待审批");
    return activiti;
}

/**
 * 审批操作
 * @param userName
 * @param activitiTask
 * @return
 */
/**
 * 同理，result是审批的结果，也是在完成审批任务时需要传入的参数；taskId是刚才老板查询到的当前需要自己完成的审批任务ID。
 * （如果流程在这里设置分支，可以通过判断result的值来跳转到不同的任务）
 */
@Override
public Boolean passApproval(String userName, ActivitiTask activitiTask) {
    userName = "huangxu2";
    String taskId = activitiTask.getId();
    String result = activitiTask.getActiviti().getResult();
    Map<String, Object> vars = new HashMap<>();
    vars.put("result", result);
    vars.put("auditor", userName);
    vars.put("auditTime", new Date());
    //taskService.claim(taskId, userName);
    taskService.setAssignee(taskId, userName);
    taskService.complete(taskId, vars);
    return true;
}


/**
 * 我审批的记录列表
 * @param userName
 * @return
 */
@Override
public List<Activiti> myApprovalRecord(String userName) {
    userName = "huangxu2";
    List<HistoricProcessInstance> hisProInstance = historyService.createHistoricProcessInstanceQuery()
            .processDefinitionKey(PROCESS_DEFINE_KEY).involvedUser(userName).finished()
            .orderByProcessInstanceEndTime().desc().list();

    List<String> auditTaskNameList = new ArrayList<>();
    auditTaskNameList.add("经理审批");
    auditTaskNameList.add("总监审批");
    List<Activiti> activitiList = new ArrayList<>();
    for (HistoricProcessInstance hisInstance : hisProInstance) {
        /*List<HistoricTaskInstance> hisTaskInstanceList = historyService.createHistoricTaskInstanceQuery()
                .processInstanceId(hisInstance.getId()).processFinished()
                .taskAssignee(userName)
                .taskNameIn(auditTaskNameList)
                .orderByHistoricTaskInstanceEndTime().desc().list();
        boolean isMyAudit = false;
        for (HistoricTaskInstance taskInstance : hisTaskInstanceList) {
            if (taskInstance.getAssignee().equals(userName)) {
                isMyAudit = true;
            }
        }
        if (!isMyAudit) {
            continue;
        }*/
        Activiti activiti = new Activiti();
        activiti.setApplyUser(hisInstance.getStartUserId());
        activiti.setApplyStatus("申请结束");
        activiti.setApplyTime(hisInstance.getStartTime());
        List<HistoricVariableInstance> varInstanceList = historyService.createHistoricVariableInstanceQuery()
                .processInstanceId(hisInstance.getId()).list();
        ActivitiUtil.setVars(activiti, varInstanceList);
        activitiList.add(activiti);
    }
    return activitiList;
  }
}

页面展示

相关工具如下：

分析：

小结：

springboot 整合 activiti工作流 学习，请大家指正~

参考资料和推荐阅读

1.链接: 参考资料.

SpringBoot集成Activiti完整工作流管理系统源码及SQL
01-11
SpringBoot集成Activiti完整工作流管理系统源码及SQL 包含如下主要内容： 1、工作流完整案例（请假流程、请假会签流程Demo） 2、系统用户权限、工作流用户和用户组管理 3、支持在线流程模型定义、部署、导出。也可用.bpmn文件直接导入系统
在springBoot项目中使用activiti
jvm123 的博客
03-14 514
原文以及源代码请查看作者博客：http://www.jvm123.com/2019/08/springboot-activiti/依赖：新建springBoot项目时勾选activiti，或者在已建立的springBoot项目添加以下依赖：<dependency> <groupId>org.activiti</groupId> <artifactId&...
SpringBoot + flowable 快速实现工作流
m0_73735578的博客
06-25 876
在程序员工作中，或多或少都会遇见审批流程类型的业务需求。一个审批流程可能包含开始->申请->领导审批->老板审批->结束等多个阶段，如果我们用字段去定义每一个流程阶段(0->开始 1->申请 2->领导审批 3->老板审批 4->结束)，虽然可以实现流程运行逻辑，但这样业务代码逻辑复杂。如果审批流程还有驳回操作，则还需要加一个是否驳回字段，显然这样实现，成本太大，且不利于维护。为了解决上述用代码逻辑硬写审批流程而导致的成本大，不利用维护的缺点，工作流因此而生。
springboot整合activity工作流
MMKJSH的博客
10-08 236
springboot整合activity工作流
springboot整合activiti完整demo
05-31
SpringBoot整合Activiti简单示例，示例中包含正常流程执行、指定流程节点执行人等测试代码。
springboot 整合 activiti工作流 学习
热门推荐
weixin_40991408的博客
04-04 1万+
springboot + activiti工作流 学习 第一步： 引入依赖： <!-- activiti --> <dependency> <groupId>org.activiti</groupId> <artif...
SpringBoot整合Activiti工作流完整指南
最新发布
weixin_51040479的博客
07-08 1299
本文摘要： SpringBoot整合Activiti工作流开发指南提供了从基础到实战的完整解决方案。文章首先介绍工作流引擎核心概念和BPMN2.0标准，然后详细讲解开发环境搭建、SpringBoot集成配置和项目结构设计。实战部分包含请假流程和复杂报销流程的建模示例，覆盖流程变量管理、条件表达式设计和表单处理等核心功能。高级特性章节探讨了任务监听器、执行监听器和自定义服务任务的实现，以及性能监控与优化策略。最后提供了数据库配置、缓存优化和常见问题解决方案等最佳实践。通过REST API设计示例和完整项目代码
Springboot 整合activiti及使用案例
10-26
**SpringBoot 整合Activiti工作流详解** 在企业级应用开发中，工作流管理系统扮演着重要的角色，它能够帮助实现业务流程自动化，提高工作效率。Activiti 是一个开源的工作流引擎，它支持 BPMN 2.0 标准，使得业务...
springboot 整合Activiti工作流 集成 Diagram Viewer跟踪流程
10-09
本文将详细讲解如何在SpringBoot项目中整合Activiti工作流，并集成Diagram Viewer来跟踪流程。 首先，我们需要在SpringBoot项目中引入Activiti的依赖。在`pom.xml`文件中，添加如下Maven依赖： ```xml <groupId>...
【干货】基于SpringBoot2开发的Activiti引擎流程管理项目脚手架
JAVA葵花宝典
05-28 2889
前言在工作中，难免会遇到需要开发基于流程管理的系统，例如一些OA/审批系统、工厂管理、ERP等等，新手入门工作流是有一定难度的，但假如你遇到今天这篇文章，那么，你幸运了。...
springboot2.2 集成 activity6实现请假完整流程示例详解
08-18
主要介绍了springboot2.2 集成 activity6实现请假完整流程示例详解,本文通过示例代码图文相结合给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
idea +springboot + activiti 请假实例源码
08-23
在idea中将springboot于activiti整合的简单实例，一看就懂
工作流源码
12-21
工作流平台,带源码---------------------------------------------------------------------------------
java中Activiti工作流引擎关于- 提交审批和审批一些源码.rar
08-06
java中Activiti工作流引擎关于- 提交审批和审批一些源码java中Activiti工作流引擎关于- 提交审批和审批一些源码
SpringBoot+sqlToy+Activiti环境搭建实现请假流程
Mr_xiayijie的博客
03-10 1090
效果图： 流程图： 源码地址(后台)：https://gitee.com/xcodinglifex/sqltoydemo.git 源码地址(前台)：https://gitee.com/xcodinglifex/activitidemo.git
springboot实现定时自动任务
txyllyyj的博客
11-14 545
1.导入依赖 <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> <version>2.3.0</version> </dependency> 2.创建定时任务类(任务开始时间，间隔，结束时间等用七子表达式设置） p
springboot entity date_在springBoot项目中整合使用activiti
weixin_39611008的博客
11-22 174
作者｜yawn Lauhttp://jvm123.com/2019/08/springboot-activiti.html依赖：新建springBoot项目时勾选activiti，或者在已建立的springBoot项目添加以下依赖：org.activitiactiviti-spring-boot-starter-basic6.0.0配置：数据源和activiti配置：server: port: ...
工作流审批业务代码详解（一）
小鲍侃java
11-03 1239
1.源码结构 下载好源码后，只需要关注flowable这个包，其他功能有兴趣可以自己查看。 有关于api的介绍请参考前文。 其中有几个通用的方法，为架构封装 ResponseFactory：将api提供的实体对象转为符合前台的对象 BaseFlowableController：为所有controller父类，提供了分页查询和所有查询，以及排序功能。如果看到 FlowablePage page = this.pageList(modelQueryVo, modelQuery, ModelListWr
springboot整合activiti工作流
04-30
SpringBoot是一款非常流行的框架，而Activiti是一款开源的工作流引擎。两者的结合可以为企业提供高效的业务流程管理，节约了企业的时间和成本。 首先，在使用SpringBoot整合Activiti之前，需要了解Activiti的基本结构和工作原理。Activiti的核心是BPMN 2.0，即业务流程建模和标记规范。Activiti在BPMN 2.0的基础上实现了整个流程的执行。当流程被执行时，Activiti将生成一系列的任务，这些任务可以由人员或系统自动完成。在使用Activiti时，需要在代码中引入Activiti的jar包，并使用其提供的API进行开发。另外，Activiti也提供了一系列的工具和管理界面，方便用户进行流程的部署、管理和监控。 基于此，SpringBoot整合Activiti的步骤如下： 1. 在SpringBoot项目中引入Activiti依赖（例如：org.activiti.spring.boot）。 2. 创建Activiti配置类，通过@Configuration注解将其装载到SpringBoot容器中。 3. 编写Activiti的相关配置，例如数据库连接、流程引擎配置等。 4. 在代码中使用Activiti提供的API进行业务流程的定义和执行。 5. 可以结合其他SpringBoot组件，例如Thymeleaf模板引擎、Spring Security安全框架等，提供更强大的功能。 总的来说，SpringBoot整合Activiti可以使企业更加高效地进行业务流程管理，同时也为开发人员提供了强大的工具和API，方便快速开发和部署。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

迅捷的软件产品制作专家

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值