关于在IDEA中SpringBoot项目中activiti工作流的使用详解

程序员文章站 2024-01-04 10:28:16

记录一下工作流的在springboot中的使用,，顺便写个demo，概念，什么东西的我就不解释了，如有问题欢迎各位大佬指导一下。1.创建springboot项目后导入依赖

记录一下工作流的在springboot中的使用,，顺便写个demo，概念，什么东西的我就不解释了，如有问题欢迎各位大佬指导一下。

1.创建springboot项目后导入依赖

 <dependency>
      <groupid>org.activiti</groupid>
      <artifactid>activiti-spring-boot-starter-basic</artifactid>
      <version>6.0.0</version>
    </dependency>

添加配置之后再springboot启动类后面加上一行代码否则启动时会报错

@springbootapplication(exclude = securityautoconfiguration.class)

添加数据源以及activiti的配置

spring:
 activiti:
  database-schema-update: drop‐create 
   //默认为false,activiti在启动的时候会对比数据库中的表中保存的版本，如果不一样会抛出异常
   // true activiti会对数据库中的表进行更新操作，如果表不存在，则自动创建
   // create_drop 在activiti启动的时候创建表，关闭时删除表，必须手动关闭
   // drop-create 在启动的时候先删除表后再创建新的表
  check-process-definitions: false
 datasource:
  driver-class-name: com.mysql.cj.jdbc.driver
  url: jdbc:mysql://localhost:3306/test?useunicode=true&characterencoding=utf8&usessl=false&servertimezone=utc
  username: root
  password: root

2.初始化activiti表

这里一共有3种方式去创建

第一种

@test
  public void inittables() {
    //创建数据源
//    drivermanagerdatasource datasource=new drivermanagerdatasource();
//    datasource.setdriverclassname("com.mysql.jdbc.driver");
//    datasource.seturl("jdbc:mysql://127.0.0.1:3306/test");
//    datasource.setusername("root");
//    datasource.setpassword("root");

    // 创建流程引擎的配置
    processengineconfiguration configuration = processengineconfiguration
        .createstandaloneprocessengineconfiguration();
    configuration.setjdbcdriver("com.mysql.cj.jdbc.driver");
    configuration.setjdbcurl("jdbc:mysql://localhost:3306/test?useunicode=true&nullcatalogmeanscurrent=true&characterencoding=utf8&usessl=false&servertimezone=utc");
    configuration.setjdbcusername("root");
    configuration.setjdbcpassword("root");
//		configuration.setdatasource(datasource);
    /**
     * processengineconfiguration.db_schema_update_false 如果数据库里面没有activit的表，也不会创建
     * processengineconfiguration.db_schema_update_create_drop 创建表，使用完之后删除
     * processengineconfiguration.db_schema_update_true 如果数据库里面没有表，就创建
     *
     * dorp-create 代表如果数据库里面有表，那么先删除再创建
     *
     */
    //配置表的初始化的方式
    configuration.setdatabaseschemaupdate(processengineconfiguration.db_schema_update_true);

    //得到流程引擎
    processengine processengine=configuration.buildprocessengine();
    system.out.println(processengine);
  }

第二种配置activiti.cfg.xml

<?xml version="1.0" encoding="utf-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:xsi="http://www.w3.org/2001/xmlschema-instance"
    xsi:schemalocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context.xsd
	http://www.springframework.org/schema/tx
	http://www.springframework.org/schema/tx/spring-tx.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop.xsd">


  <bean id="processengineconfiguration" class="org.activiti.engine.impl.cfg.standaloneprocessengineconfiguration">
    <property name="jdbcdriver" value="com.mysql.cj.jdbc.driver"></property>
    <property name="jdbcurl" value="jdbc:mysql://localhost:3306/test?useunicode=true%26nullcatalogmeanscurrent=true%26characterencoding=utf8%26usessl=false%26servertimezone=utc"></property>
    <property name="jdbcusername" value="root"></property>
    <property name="jdbcpassword" value="root"></property>
    <!--
    flase： 默认值。activiti在启动时，会对比数据库表中保存的版本，如果没有表或者版本不匹配，将抛出异常。
    true： activiti会对数据库中所有表进行更新操作。如果表不存在，则自动创建。
    create_drop： 在activiti启动时创建表，在关闭时删除表（必须手动关闭引擎，才能删除表）。
    drop-create： 在activiti启动时删除原来的旧表，然后在创建新表（不需要手动关闭引擎）。 -->
    <property name="databaseschemaupdate" value="drop-create"></property>
  </bean>
</beans>

然后写一个测试类

@test
	public void intitables2() {
		processengineconfiguration configuration = processengineconfiguration
				.createprocessengineconfigurationfromresource("activiti.cfg.xml");
		// 得到流程引擎
		processengine processengine = configuration.buildprocessengine();
		system.out.println(processengine);

	}

第三种方法

  @test
  public void intitables3() {
    //必须创建activiti.cfg.xml 并配置好数据库的信息
    processengine processengine= processengines.getdefaultprocessengine();
    system.out.println(processengine);
  }

3.打开数据库查看

我们打开数据库查看数据库，会发现activiti已自动帮我们创建了28张表（有的好像也只有24张表，有兴趣的可以研究一下）

这里为大家解释一下各张表的含义：activiti的后台是有数据库的支持，所有的表都以act_开头。第二部分是表示表的用途的两个字母标识。

act_re_*: 're'表示repository。这个前缀的表包含了流程定义和流程静态资源（图片，规则，等等）。

act_ru_*: 'ru'表示runtime。这些运行时的表，包含流程实例，任务，变量，异步任务，等运行中的数据。 activiti只在流程实例执行过程中保存这些数据，在流程结束时就会删除这些记录。这样运行时表可以一直很小速度很快。

act_id_*: 'id'表示identity。这些表包含身份信息，比如用户，组等等。

act_hi_*: 'hi'表示history。这些表包含历史数据，比如历史流程实例，变量，任务等等。

act_ge_*: 通用数据，用于不同场景下，如存放资源文件。

#repositoryservice
select * from act_ge_bytearray; 二进制文件夹表
select * from act_re_deployment; 流程部署表
select * from act_re_procdef; 流程定义表
select * from act_ge_property; 属性数据表存储整个流程引擎级别的数据,初始化表结构时，会默认插入三条记录

#runtimeservice taskservice  运行时数据库表
select * from act_ru_excution; 流程启动一次只要没有执行完就会有一条数据
select * from act_ru_task; 可能有多条数据
select * from act_ru_variable; 记录流程运行时的流程变量
select * from act_ru_identitylink; 存放流程办理人的信息

#historyservice 历史数据库表
select * from act_hi_procinst; 历史流程实例
select * from act_hi_taskinst; 历史任务实例
select * from act_hi_actinst; 历史节点表
select * from act_hi_attachment; 历史附件表
select * from act_hicomment; 历史意见表
select * from act_hi_identitylink; 历史流程人员表
select * from act_hi_detail; 历史详情表提供历史变量查询
select * from act_hi_procinst; 历史流程实例表
select * from act_hi_taskinst; 历史任务实例表
select * from act_hi_varinst; 历史变量表

#identityservice 这四张表尽量使用自己的一套，难以满足需求
select * from act_id_group; 用户组信息表
select * from act_id_info; 用户拓展信息表
select * from act_id_menbership; 用户与用户组对应表
select * from act_id_user; 用户信息表

4.接下来开始画请假流程图（需要先安装插件），新建一个bpm文件开始编辑

关于在IDEA中SpringBoot项目中activiti工作流的使用详解

assignee相当于办理人的意思我这里是zhang 提出申请，主管yuan 审核。

5.部署流程流程

  // 得到流程引擎
	private processengine processengine = processengines.getdefaultprocessengine();

  @test
  public void deployprocess01() {
    // 得到流程部署的service
    repositoryservice repositoryservice = this.processengine.getrepositoryservice();
    deployment deploy = repositoryservice.createdeployment().name("请假流程").addclasspathresource("activititest.bpmn").deploy();
    system.out.println("部署成功:流程部署id：" + deploy.getid());
  }

6.启动流程（这里的key与第五部第一张途中对应）

  /**
   * 启动流程
   */
  @test
  public void startprocess() {
    runtimeservice runtimeservice = this.processengine.getruntimeservice();
//    string processdefinitionid="helloworld:1:4";
//		runtimeservice.startprocessinstancebyid(processdefinitionid);
    string processdefinitionkey="mytest";
    runtimeservice.startprocessinstancebykey(processdefinitionkey);
    system.out.println("流程启动成功");
  }

7.根据用户查询任务（这里使用流程图中的assignee字段）

 @test
  public void querytask() {
    taskservice taskservice = this.processengine.gettaskservice();
    string assignee="chen";
    list<task> list = taskservice.createtaskquery().taskassignee(assignee).list();
    if(null!=list&&list.size()>0) {
      for (task task : list) {
        system.out.println("任务id:"+task.getid());
        system.out.println("流程实例id:"+task.getprocessinstanceid());
        system.out.println("执行实例id:"+task.getexecutionid());
        system.out.println("流程定义id:"+task.getprocessdefinitionid());
        system.out.println("任务名称:"+task.getname());
        system.out.println("任务办理人:"+task.getassignee());
        system.out.println("################################");
      }
    }
  }

8.办理任务（配合步骤8查询出taskid然后进行办理任务）

  @test
  public void completetask() {
    taskservice taskservice = this.processengine.gettaskservice();
    string taskid="5005";//步骤8中查询出来的taskid
    taskservice.complete(taskid);
    system.out.println("任务完成");
  }

重复7、8两个步骤，自此一个完整的请假流程就完成了。

那么肯定会有人问了，如果我想查看一我们流程定义的信息，流程图，删除流程定义等怎么办呢，话不多说直接上代码

package com.example;

import org.activiti.engine.processengine;
import org.activiti.engine.processengines;
import org.activiti.engine.repositoryservice;
import org.activiti.engine.runtimeservice;
import org.activiti.engine.repository.deployment;
import org.activiti.engine.repository.processdefinition;
import org.junit.jupiter.api.test;

import java.io.bufferedoutputstream;
import java.io.file;
import java.io.fileoutputstream;
import java.io.inputstream;
import java.util.collection;
import java.util.hashmap;
import java.util.list;
import java.util.map;
import java.util.zip.zipinputstream;

public class testprocessprodef {
  // 得到流程引擎
  private processengine processengine = processengines.getdefaultprocessengine();

  /**
   * 部署流程使用classpath
   */
  @test
  public void deployprocess01() {
    // 得到流程部署的service
    repositoryservice repositoryservice = this.processengine.getrepositoryservice();
    deployment deploy = repositoryservice.createdeployment().name("请假流程2").addclasspathresource("activiti.bpmn").deploy();
    system.out.println("部署成功:流程部署id：" + deploy.getid());
  }


  /**
   * 查询流程部署信息 act_re_deployment
   */
  @test
  public void queryprocessdeploy() {
    repositoryservice repositoryservice = this.processengine.getrepositoryservice();
    // 创建部署信息的查询
    string deploymentid = "1";
//		deployment deploy = repositoryservice.createdeploymentquery()
    list<deployment> list = repositoryservice.createdeploymentquery()
        // 条件
        // .deploymentid(deploymentid) //根据部署id去查询
        // .deploymentname(name)//根据部署名称去查询
        // .deploymenttenantid(tenantid)//根据tenantid去查询
//		.deploymentnamelike(namelike)//根据部署名称模糊查询
        // .deploymenttenantidlike(tenantidlike)//根据tenantid模糊查询
        // 排序
//		.orderbydeploymentid().asc() //根据部署id升序
        // .orderbydeploymentime().desc() //根据部署时间降序
        // .orderbydeploymentname()//根据部署名称升序
        // 结果集
        .list(); // 查询返回list集合
//		.listpage(firstresult, maxresults) 分页查询返回list集合
    // .singleresult(); //返回单个对象
//		.count();

    /*
     * system.out.println("部署id:"+deploy.getid());
     * system.out.println("部署名称:"+deploy.getname());
     * system.out.println("部署时间:"+deploy.getdeploymenttime());
     */
//		system.out.println(count);
    for (deployment deployment : list) {
      system.out.println("部署id:" + deployment.getid());
      system.out.println("部署名称:" + deployment.getname());
      system.out.println("部署时间:" + deployment.getdeploymenttime());
      system.out.println("########################");
    }
  }

  /**
   * 查询流程定义
   */
  @test
  public void queryprocdef() {
    repositoryservice repositoryservice = this.processengine.getrepositoryservice();
    list<processdefinition> list = repositoryservice.createprocessdefinitionquery()
        // 条件
//		.deploymentid(deploymentid) 根据部署id查询
//		.deploymentids(deploymentids) 根据部署id的集合查询set<string> deploymentids
//		.processdefinitionid(processdefinitionid)//根据流程定义idhelloworld:1:4
//		.processdefinitionids(processdefinitionids)//根据流程定义的ids查询
//		.processdefinitionkey(processdefinitionkey)//根据流程定义的的key查询
//		.processdefinitionkeylike(processdefinitionkeylike)//根据流程定义的的key模糊查询
//		.processdefinitionname(processdefinitionname)//根据流程定义的名称查询
//		.processdefinitionnamelike(processdefinitionnamelike)//根据流程定义的名称模糊查询
//		.processdefinitionresourcename(resourcename)//根据流程图的bpmn文件名查询
//		.processdefinitionresourcenamelike(resourcenamelike)//根据流程图的bpmn文件名模糊查询
//		.processdefinitionversion(processdefinitionversion)//根据流程定义的版本查询
//		.processdefinitionversiongreaterthan(processdefinitionversion)//version>num
//		.processdefinitionversiongreaterthanorequals(processdefinitionversion)//version>=num
//		.processdefinitionversionlowerthan(processdefinitionversion)//version<num
//		.processdefinitionversionlowerthanorequals(processdefinitionversion)//version<=num
        // 排序
//		.orderbydeploymentid()
//		.orderbyprocessdefinitionid()
//		.orderbyprocessdefinitionkey()
//		.orderbyprocessdefinitionname()
//		.orderbyprocessdefinitionversion()
        // 结果集
        .list();
//		.listpage(firstresult, maxresults)\
//		.count()
//		.singleresult()
    if (null != list && list.size() > 0) {
      for (processdefinition pd : list) {
        system.out.println("流程定义id:" + pd.getid());
        system.out.println("流程部署id:" + pd.getdeploymentid());
        system.out.println("流程定义key:" + pd.getkey());
        system.out.println("流程定义的名称:" + pd.getname());
        system.out.println("流程定义的bpmn文件名:" + pd.getresourcename());// bpmn的name
        system.out.println("流程图片名:" + pd.getdiagramresourcename());// png的name
        system.out.println("流程定义的版本号:" + pd.getversion());
        system.out.println("##################");
      }
    }
  }

  /**
   * 启动流程
   */
  @test
  public void startprocess() {
    runtimeservice runtimeservice = this.processengine.getruntimeservice();
    string processdefinitionkey = "mytest";
    runtimeservice.startprocessinstancebykey(processdefinitionkey);
    system.out.println("流程启动成功");
  }

  /**
   * 删除流程定义
   */
  @test
  public void deleteprocessdef() {
    repositoryservice repositoryservice = this.processengine.getrepositoryservice();
    string deploymentid = "2501";
    // 根据流程部署id删除流程定义 如果当前id的流程正在执行，那么会报错
    // repositoryservice.deletedeployment(deploymentid);
    // 根据流程部署id删除删除流程定义 如果当前id的流程正在执行,会把正在执行的流程数据删除 act_ru_*和act_hi_*表里面的数据
    repositoryservice.deletedeployment(deploymentid, true);
//		repositoryservice.deletedeploymentcascade(deploymentid);==repositoryservice.deletedeployment(deploymentid, true);
    system.out.println("删除成功");
  }

  /**
   * 查询流程图 根据流程定义id
   */
  @test
  public void viewprocessimg() {
    repositoryservice repositoryservice = this.processengine.getrepositoryservice();
    string processdefinitionid = "mytest:2:2504";
    inputstream inputstream = repositoryservice.getprocessdiagram(processdefinitionid);

    file file = new file("d:/mytest.png");
    try {
      bufferedoutputstream outputstream = new bufferedoutputstream(new fileoutputstream(file));
      int len = 0;
      byte[] b = new byte[1024];
      while ((len = inputstream.read(b)) != -1) {
        outputstream.write(b, 0, len);
        outputstream.flush();
      }
      outputstream.close();
      inputstream.close();
      system.out.println("查询成功");
    } catch (exception e) {
      // todo auto-generated catch block
      e.printstacktrace();
    }
  }

  /**
   * 查询流程图 根据流流程部署id
   */
  @test
  public void viewprocessimg2() {
    repositoryservice repositoryservice = this.processengine.getrepositoryservice();
    // 根据流程部署id查询流程定义对象
    string deploymentid = "1";
    processdefinition processdefinition = repositoryservice.createprocessdefinitionquery()
        .deploymentid(deploymentid).singleresult();
    // 从流程定义对象里面查询出流程定义id
    string processdefinitionid = processdefinition.getid();
    inputstream inputstream = repositoryservice.getprocessdiagram(processdefinitionid);

    file file = new file("d:/" + processdefinition.getdiagramresourcename());
    try {
      bufferedoutputstream outputstream = new bufferedoutputstream(new fileoutputstream(file));
      int len = 0;
      byte[] b = new byte[1024];
      while ((len = inputstream.read(b)) != -1) {
        outputstream.write(b, 0, len);
        outputstream.flush();
      }
      outputstream.close();
      inputstream.close();
      system.out.println("查询成功");
    } catch (exception e) {
      // todo auto-generated catch block
      e.printstacktrace();
    }
  }

  /**
   * 查询最新的流程定义
   */
  @test
  public void querynewprocessdef() {
    map<string, processdefinition> map = new hashmap<>();

    // 查询所有的流程定义根据版本号升序
    repositoryservice repositoryservice = this.processengine.getrepositoryservice();
    list<processdefinition> list = repositoryservice.createprocessdefinitionquery()
        .orderbyprocessdefinitionversion().asc().list();
    if (null != list && list.size() > 0) {
      for (processdefinition pd : list) {
        map.put(pd.getkey(), pd);
      }
    }
    // 循环map集合
    collection<processdefinition> values = map.values();
    for (processdefinition pd : values) {
      system.out.println("流程定义id:" + pd.getid());
      system.out.println("流程部署id:" + pd.getdeploymentid());
      system.out.println("流程定义key:" + pd.getkey());
      system.out.println("流程定义的名称:" + pd.getname());
      system.out.println("流程定义的bpmn文件名:" + pd.getresourcename());// bpmn的name
      system.out.println("流程图片名:" + pd.getdiagramresourcename());// png的name
      system.out.println("流程定义的版本号:" + pd.getversion());
      system.out.println("##################");
    }
  }

  /**
   * 已知key 附加功能：删除流程定义（删除key相同的所有不同版本的流程定义）
   */
  public void deleteallsameversion() {
    string processdefinitionkey = "mytest";
    repositoryservice repositoryservice = this.processengine.getrepositoryservice();
    // 根据流程定义的key查询流程集合
    list<processdefinition> list = repositoryservice.createprocessdefinitionquery()
        .processdefinitionkey(processdefinitionkey).list();

    if (null != list && list.size() > 0) {
      for (processdefinition pd : list) {
        repositoryservice.deletedeployment(pd.getdeploymentid(), true);

      }
    }

  }
}

肯定还有人会问，上面的请假流程是走完了，但是没有写请假理由，请假天数，如果是报销单的话还需要上传报销单据等，那么这个怎么解决呢？这个时候就需要activiti提供给我们的流程变量了，那么什么是流程变量呢？

流程变量在整个工作流中扮演很重要的作用。例如：请假流程中有请假天数、请假原因等一些参数都为流程变量的范围。流程变量的作用域范围是只对应一个流程实例。也就是说各个流程实例的流程变量是不相互影响的。流程实例结束完成以后流程变量还保存在数据库中（存放到流程变量的历史表中）。图中红框的信息就是流程变量。

关于在IDEA中SpringBoot项目中activiti工作流的使用详解

那么我们怎么设置流程变量呢，我们启动流程的时候就可以设置流程变量了，见代码：

	/**
	 * 启动流程
	 */
	@test
	public void startprocess() {
		runtimeservice runtimeservice = this.processengine.getruntimeservice();
		string processdefinitionkey = "mytest";
//		processinstance processinstance = runtimeservice.startprocessinstancebykey(processdefinitionkey);
		//创建流程变量对象
		map<string,object> variables=new hashmap<>();
		variables.put("请假天数", 30);//int
		variables.put("请假原因", "结婚");
		variables.put("请假时间", new date());
		processinstance processinstance = runtimeservice.startprocessinstancebykey(processdefinitionkey, variables);
		system.out.println("流程启动成功:" + processinstance.getid() + "  " + processinstance.getprocessdefinitionid() + " "
				+ processinstance.getprocessinstanceid());

	}

说明：

1)流程变量的作用域就是流程实例，所以只要设置就行了，不用管在哪个阶段设置

2)基本类型设置流程变量，在taskservice中使用任务id，定义流程变量的名称，设置流程变量的值。

3)javabean类型设置获取流程变量，除了需要这个javabean实现了serializable接口外，还要求流程变量对象的属性不能发生变化，否则抛出异常。解决方案，固定序列化id

4)设置流程变量的时候，向act_ru_variable这个表添加数据

runtimeservice对象可以设置流程变量和获取流程变量 taskservice对象可以设置流程变量和获取流程变量

map集合的key表示流程变量的名称 map集合的value表示流程变量的值

查询流程变量以及查询历史流程变量：

	/**
	 * 获取流程变量
	 */
	@test
	public void getvariables() {
		runtimeservice runtimeservice = this.processengine.getruntimeservice();
		string executionid="2501";
		integer days=(integer) runtimeservice.getvariable(executionid, "请假天数");
		date date=(date) runtimeservice.getvariable(executionid, "请假时间");
		user user=(user) runtimeservice.getvariable(executionid, "用户对象");
		system.out.println(days);
		system.out.println(date.tolocalestring());
		system.out.println(user.getid()+" "+user.getname());
	}
	
	/**
	 * 7：查询历史的流程变量
	 */
	@test
	public void gethistoryvariables() {
		historyservice historyservice = this.processengine.gethistoryservice();
		
		/*historicvariableinstance singleresult = historyservice.createhistoricvariableinstancequery().id("2503").singleresult();;
		system.out.println(singleresult.getid());
		system.out.println(singleresult.getvalue());
		system.out.println(singleresult.getvariablename());
		system.out.println(singleresult.getvariabletypename());*/
		string processinstanceid="2501";
		list<historicvariableinstance> list = historyservice.createhistoricvariableinstancequery().processinstanceid(processinstanceid).list();
		
		for (historicvariableinstance hvs : list) {
			system.out.println("id"+hvs.getid());
			system.out.println("变量值"+hvs.getvalue());
			system.out.println("变量名"+hvs.getvariablename());
			system.out.println("变量类型"+hvs.getvariabletypename());
			system.out.println("#####################");
		}
	}

查询历史流程实例、查询历史活动以及查询历史任务

public class testhistoryquery {

	private processengine processengine=processengines.getdefaultprocessengine();
	historyservice historyservice = this.processengine.gethistoryservice();
	
	/* 1，查询历史流程实例 */
	@test
	public void historyprocessinstince() {
		list<historicprocessinstance> list = historyservice.createhistoricprocessinstancequery()
		//条件
//		.processdefinitionid(processdefinitionid)
//		.processdefinitionkey(processdefinitionkey)
//		.processdefinitionkeyin(processdefinitionkeys)
//		.processdefinitionname(processdefinitionname)
//		.processdefinitionversion(processdefinitionversion)
//		.processinstancebusinesskey(processinstancebusinesskey)
//		.processinstanceid(processinstanceid)
//		.processinstanceids(processinstanceids)
		//排序
//		.orderbyprocessdefinitionid()
//		.orderbyprocessinstancebusinesskey()
//		.orderbyprocessinstanceduration()
//		.orderbyprocessinstancestarttime()
//		.orderbyprocessinstanceid()
		//结果集
		.list();
//		.listpage(firstresult, maxresults)
//		.count()
//		.singleresult();
		
		if(null!=list&&list.size()>0) {
			for (historicprocessinstance hpi : list) {
				system.out.println("历史流程实例id:" + hpi.getid());
				system.out.println("流程定义id:" + hpi.getprocessdefinitionid());
				system.out.println("历史流程实例的业务id:" + hpi.getbusinesskey());
				system.out.println("流程部署id:" + hpi.getdeploymentid());
				system.out.println("流程定义key:" + hpi.getprocessdefinitionkey());
				system.out.println("开始活动id:" + hpi.getstartactivityid());
				system.out.println("结束活动id:" + hpi.getendactivityid());
				system.out.println("########################");
			}
		}
		
	}
	
	
	
	/* 2，查询历史活动 */
	@test
	public void queryhistoryact() {
		list<historicactivityinstance> list = this.historyservice.createhistoricactivityinstancequery()
		//条件
//		.activityid(activityid)
//		.activityinstanceid(activityinstanceid)
//		.activityname(activityname)
		//排序
//		.orderbyactivityid()
//		.orderbyactivityname()
		//结果集
		.list();
		if(null!=list&&list.size()>0)
		{
			for (historicactivityinstance hai : list) {
				system.out.println("id:"+hai.getid());
				system.out.println("流程定义id:"+hai.getprocessdefinitionid());
				system.out.println("流程实例id:"+hai.getprocessinstanceid());
				system.out.println("执行实例id:"+hai.getexecutionid());
				system.out.println("活动id:"+hai.getactivityid());
				system.out.println("任务id:"+hai.gettaskid());
				system.out.println("活动名称:"+hai.getactivityname());
				system.out.println("活动类型:"+hai.getactivitytype());
				system.out.println("任务办理人:"+hai.getassignee());
				system.out.println("开始时间:"+hai.getstarttime());
				system.out.println("结束时间:"+hai.getendtime());
				system.out.println("持续时间:"+hai.getdurationinmillis());
				system.out.println("#######################################");
			}
		}
	}
	/* 3，查询历史任务 act_hi_taskinst */
	@test
	public void queryhistorytask() {
		list<historictaskinstance> list = this.historyservice.createhistorictaskinstancequery()
		//条件
//		.deploymentid(deploymentid)
//		.deploymentidin(deploymentids)
//		.executionid(executionid)
//		.processdefinitionid(processdefinitionid)
//		.processdefinitionkey(processdefinitionkey)
//		.processdefinitionkeyin(processdefinitionkeys)
//		.processdefinitionkeylike(processdefinitionkeylike)   processdefinitionkeylike="%hello%"
//		.processdefinitionname(processdefinitionname)
//		.processdefinitionnamelike(processdefinitionnamelike)
		//排序
//		.orderbytaskdefinitionkey()
		//结果集
		.list();
//		.listpage(firstresult, maxresults)
//		.count()
//		.singleresult()
		if(null!=list&&list.size()>0)
		{
			for (historictaskinstance task : list) {
				system.out.println("任务id:" + task.getid());
				system.out.println("任务办理人:" + task.getassignee());
				system.out.println("执行实例id:" + task.getexecutionid());
				system.out.println("任务名称:" + task.getname());
				system.out.println("流程定义id:" + task.getprocessdefinitionid());
				system.out.println("流程实例id:" + task.getprocessinstanceid());
				system.out.println("任务创建时间:" + task.getcreatetime());
				system.out.println("任务结束时间:" + task.getendtime());
				system.out.println("#######################################");
			}
		}
	}
}

最近我发现上面的代码不能完全在开发中应用，比如上面的用户申请是在画流程图的时候写死的，在实际开发中肯定是根据当前登录的用户来提出申请，另外还没有分支的情况，所以我特地修改了一下流程图。

关于在IDEA中SpringBoot项目中activiti工作流的使用详解

这个流程图中没有设置用户，在condition中传入参数#{userid},后面的重要与不重要分支同样加上condition条件${message=='重要'}和${message=='不重要'}，然后主管审核和总经理的assignee可以设置成固定的值也可以像用户一样根据传参设置。接下来直接上代码

1.启动流程

 /**启动流程实例*/

  @test
  public void startprocessinstance(){
    string processdefinitionkey = "myprocess_1";
    /**启动流程实例的同时，设置流程变量，使用流程变量用来指定任务的办理人，对应task.pbmn文件中#{userid}*/

    map<string, object> variables = new hashmap<string, object>();
    variables.put("userid", "袁志豪");
    processinstance pi = processengine.getruntimeservice()//与正在执行的流程实例和执行对象相关的service
     .startprocessinstancebykey(processdefinitionkey,variables);//使用流程定义的key启动流程实例，key对应helloworld.bpmn文件中id的属性值，使用key值启动，默认是按照最新版本的流程定义启动

    system.out.println("流程实例id:"+pi.getid());//流程实例id  101

    system.out.println("流程定义id:"+pi.getprocessdefinitionid());//流程定义id

  }

用户完成申请提交，主管在流成图中没有设置固定值

  @test
  public void completetask() {
    taskservice taskservice = this.processengine.gettaskservice();
    string taskid = "2508";
    // 根据任务id去完成任务
   // taskservice.complete(taskid);
    // 根据任务id去完成任务并指定流程变量
    map<string,object > variable =new hashmap<>();
    string shenheren ="张三";//实际开发中可在前台选择主管传入后台
    variable.put("zhuguan","张三");//这里的 zhuguan 和 activiti.bpmn中的#{zhuguan}保持一致,既可以设置下一级审核主管
		taskservice.complete(taskid, variables);
    system.out.println("任务完成");
  }

主管审核

  @test
  public void complatetask2(){
    taskservice taskservice = this.processengine.gettaskservice();
    string taskid2= "5002";
    map<string,object > variable =new hashmap<>();
    /***这里的message 是流程图中分支条件message,根据传入的参数判断走那一条线***/
    variable.put("message","重要");
//    variable.put("message","不重要");
    taskservice.complete(taskid2,variable);
  }

经理审核

 @test
  public void complatetask3(){
    taskservice taskservice = this.processengine.gettaskservice();
    string taskid2= "7503";
    map<string,object > variable =new hashmap<>();
    variable.put("审核意见","好好休假注意身体");//领导审核意见
    taskservice.complete(taskid2,variable);
  }

另外我在开发中发现在流程图画完之后将bpmn后缀改为xml方式生成图片之后，再次改为bpmn的时候，发现之前写的condition中变成了\n,如图

关于在IDEA中SpringBoot项目中activiti工作流的使用详解