springboot 整合 activiti工作流 学习

springboot + activiti工作流 学习

第一步：

         引入依赖：
            
             	
	             	org.activiti
		            activiti-spring-boot-starter-basic
		            6.0.0
	            
	        
            	
	            	com.alibaba
		           druid
	            	0.2.16
	            

第二步：application.yml文件配置

       # 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文件夹

id要唯一

activiti工作流6大service服务的简单介绍

https://blog.csdn.net/a8532156/article/details/78427545

创建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 list = myActiviti(session);
        model.addAttribute("list",list);
        //myApproval();
        List list3 = myApproval(session);
        model.addAttribute("list3",list3);
        //myActivitiRecord();
        List list2 = myActivitiRecord(session);
        model.addAttribute("list2",list2);
        //myApprovalRecord();
        List list4 = myApprovalRecord(session);
        model.addAttribute("list4",list4);
        return "activitiList";
    }


    @RequestMapping(value = "/createActiviti", method = RequestMethod.POST)
    @ResponseBody
    public Object createActiviti(Activiti vac,HttpSession session){
        ResponseMsg