activiti工作流框架简介

最新推荐文章于 2024-07-03 16:21:03 发布

weixin_30249203

最新推荐文章于 2024-07-03 16:21:03 发布

阅读量235

点赞数

文章标签：数据库 runtime java

原文链接：http://www.cnblogs.com/rodge-run/p/6492842.html

版权

常见的工作流框架:activiti, JBPM, OSWorkflow

activiti框架基于23张基础的表数据, 基于Mybatis操作数据库.

JBPM框架基于18张基础的表数据, 基于hibernate操作数据库.

一. activiti基础数据表的创建

1.通过sql创建

导入activiti-5.13\database\create目录下的sql建表语句, 如果数据库是mysql, 则需要导入activiti.mysql.create.engine.sql, activiti.mysql.create.history.sql, activiti.mysql.create.identity.sql三张表;

2.通过java代码创建

2.1 在不提供xml配置文件的情况下

　　//通过在java中创建流程引擎配置对象来创activiti的基础表数据
   @Test
   public void demo1 () {
       //创建流程引擎配置对象
       ProcessEngineConfiguration configuration =
               ProcessEngineConfiguration.createStandaloneProcessEngineConfiguration();
       configuration.setJdbcDriver("com.mysql.jdbc.Driver");
       configuration.setJdbcUrl("jdbc:mysql://localhost:3306/activiti_demo");
       configuration.setJdbcUsername("root");
       configuration.setJdbcPassword("123");
       //设置自动建表
       configuration.setDatabaseSchemaUpdate("true");
       //创建流程引擎对象, 在创建流程引擎对象时会自动建表
       ProcessEngine buildProcessEngine = configuration.buildProcessEngine();
   }

2.2 提供xml配置文件

1.配置文件位于src根路径下, 名称为activiti-context.xml

<bean id="processEngineConfiguration"
       class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
       <property name="jdbcDriver" value="com.mysql.jdbc.Driver"></property>
       <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/activiti_demo"></property>
       <property name="jdbcUsername" value="root"></property>
       <property name="jdbcPassword" value="luoji1025"></property>
       <property name="databaseSchemaUpdate" value="true"></property>
   </bean>

   
   <bean id="processEngine" class="org.activiti.spring.ProcessEngineFactoryBean">
       <property name="processEngineConfiguration" ref="processEngineConfiguration"></property>
   </bean>
</beans>

2.Java代码

     //通过配置文件结合java代码实现activiti基础表的创建
   @Test
   public void demo2() {
       //通过配置文件,创建流程引擎配置对象
       ProcessEngineConfiguration configuration = ProcessEngineConfiguration.
               createProcessEngineConfigurationFromResource("activiti-context.xml", "processEngineConfiguration");
       ProcessEngine processEngine = configuration.buildProcessEngine();
   }

2.3 使用默认的配置文件(推荐使用)

　　要求配置文件必须在类路径的根路径下，配置文件的名称必须为activiti-context.xml或者为activiti.cfg.xml,xml配置文件中必须配置流程引擎配置对象，id必须为processEngineConfiguration，必须配置流程引擎工厂bean，id必须为processEngine(具体配置与上面的xml一致)

     //通过默认的配置文件创建activiti基础表
   @Test
   public void demo3 () {
       ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
   }

二. activiti中23张表的介绍

Activiti的后台是有数据库的支持，所有的表都以ACT_开头。第二部分是表示表的用途的两个字母标识。用途也和服务的API对应。

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

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

3) ACT_ID_*: 'ID'表示identity。这些表包含身份信息，比如用户，组等等。

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

ACT_GE_*: 通用数据，用于不同场景下。

　　业务流程建模与标注（Business Process Model and Notation，BPMN) ，描述流程的基本符号，包括这些图元如何组合成一个业务流程图（Business Process Diagram）

三. activiti中常用的对象

3.1 几个和流程相关的对象

Deployment:部署对象，和部署表对应act_re_deployment

ProcessDefinition:流程定义对象,和流程定义表对应act_re_procdef

ProcessInstance:流程实例对象,和流程实例表对应act_ru_execution

Task:任务对象,和任务表对应act_ru_task

3.2 几个Service对象

RepositoryService:操作部署、流程定义等静态资源信息

RuntimeService:操作流程实例，启动流程实例、查询流程实例、删除流程实例等动态信息

TaskService:操作任务，查询任务、办理任务等和任务相关的信息

HistoryService:操作历史信息的，查询历史信息

IdentityService:操作用户和组

3.3 几个Query对象

DeploymentQuery:对应查询部署表act_re_deployment

ProcessDefinitionQuery:对应查询流程定义表act_re_procdef

ProcessInstanceQuery:对应查询流程实例表act_ru_execution

TaskQuery:对应查询任务表act_ru_task

四. Activiti流程定义框架中常用的API

4.1 部署与流程定义相关的API

4.1.1 部署流程定义

1>基于元数据(bpmn和png)文件创建

/*
   * 部署流程定义
   * 影响的表
   * 1.act_re_deployment:部署表
   * 2.act_re_procdef:流程定义表(流程部署后,会在流程定义表中创建一个流程定义对象)
   * 3.act_ge_bytearray:二进制表(保存bpmn和png文件)
   */

　private ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
   @Test
   public void demo4 () {
       //创建一个部署构建器对象, 用于加载制定的文件
       DeploymentBuilder deployment = processEngine.getRepositoryService().createDeployment();
       deployment.addClasspathResource("qjlc.bpmn");
       deployment.addClasspathResource("qjlc.png");
       //部署,返回部署对象
       Deployment deploy = deployment.deploy();
       System.out.println(deploy.getId());
   }

2> 基于bpmn和png文件的压缩文件创建

@Test
   public void demo1 () {
       //获取文件部署构建器对象
       DeploymentBuilder deploymentBuilder = processEngine.getRepositoryService().createDeployment();
       //2.通过zip文件部署(常用)
       ZipInputStream zipInputStream = new ZipInputStream(this.getClass().getClassLoader()
               .getResourceAsStream("qjlc.zip"));
       deploymentBuilder.addZipInputStream(zipInputStream);
       Deployment deploy = deploymentBuilder.deploy();
       System.out.println(deploy.getId());
   }

4.1.2 查询部署信息

    @Test
   public void demo2 () {
       DeploymentQuery query = processEngine.getRepositoryService().createDeploymentQuery();
//       query.deploymentId("701");
       List<Deployment> list = query.list();
       for (Deployment deployment : list) {
           System.out.println(deployment.getId() + " " + deployment.getName());
       }
   }

4.1.3 删除部署信息

    /*
   * 删除部署信息
   */
   @Test
   public void demo3 () {
       String deploymentId = "601";
       boolean cascade = false;
       processEngine.getRepositoryService().deleteDeployment(deploymentId, cascade);
   }

4.1.4 查询流程定义

　/*
   * 查询流程定义
   * 操作的数据表：act_re_procdef流程定义表
   */
   @Test
   public void demo5 () {
       //获取流程定义查询对象
       ProcessDefinitionQuery query = processEngine.getRepositoryService().createProcessDefinitionQuery();
       //根据流程定义的key进行过滤
       query.processDefinitionKey("qjlc");
       //添加排序条件
       query.orderByProcessDefinitionVersion().desc();

　　　//查询最新的版本

　　　query.latestVersion();
       //查询
       List<ProcessDefinition> list = query.list();
       for (ProcessDefinition definition : list) {
           System.out.println(definition.getId() + " " + definition.getKey() + " " + definition.getName());
       }
   }

4.1.5 查询一次部署对应的流程部署文件名称和输入流

@Test
   public void demo5 () {
       String deploymentId = "1";
       List<String> names = processEngine.getRepositoryService().getDeploymentResourceNames(deploymentId);
       for (String name : names) {
           System.out.println(name);
           InputStream inputStream = processEngine.getRepositoryService().getResourceAsStream(deploymentId, name);
           try {
               FileUtils.copyInputStreamToFile(inputStream, new File("E:\\"+name));
               inputStream.close();
           } catch (Exception e) {
               e.printStackTrace();
           }
       }
   }

4.1.6 获取文件名称和输入流

    @Test
   public void demo6 () throws IOException {
       //获取流程定义的id
       String processDefinitionId = "qjlc:4:904";
       //获取流程定义查询对象
       ProcessDefinitionQuery query = processEngine.getRepositoryService().createProcessDefinitionQuery();
       //根据id进行查询
       query.processDefinitionId(processDefinitionId);
       //调整查询结果集
       ProcessDefinition processDefinition = query.singleResult();
       //根据流程定义对象获取png图片的名称
       String name = processDefinition.getDiagramResourceName();
       //获取png图片对应的输入流
       InputStream inputStream = processEngine.getRepositoryService().getProcessDiagram(processDefinitionId);
       //调用fileutils工具类查询数据
       FileUtils.copyInputStreamToFile(inputStream, new File("e:\\"+name));
       inputStream.close();
   }

4.2 流程定义实例和任务相关的API

4.2.1 启动流程定义实例

　　/*
   * 启动流程实例
   * 操作的数据表:
   * 1.act_ru_execution:流程实例表
   * 2.act_ru_task:任务表(启动流程实例时,会在任务表中创建一个任务)
   */
   @Test
   public void demo6 () {
       //流程定义的id
       String processId = "qjlc:1:4";
       //通过runtimeservice启动流程实例
       ProcessInstance processInstance = processEngine.getRuntimeService().startProcessInstanceById(processId);
       System.out.println(processInstance.getId() + " " + processInstance.getBusinessKey() + " " + processInstance.getParentId());
   }

4.2.2 查询流程实例

    @Test
   public void demo8 () {
       ProcessInstanceQuery query = processEngine.getRuntimeService().createProcessInstanceQuery();
       List<ProcessInstance> list = query.list();
       for (ProcessInstance processInstance : list) {
           System.out.println(processInstance.getId() + " " + processInstance.getActivityId());
       }
       //查询任务
       TaskQuery query2 = processEngine.getTaskService().createTaskQuery();
       List<Task> list2 = query2.list();
       for (Task task : list2) {
           System.out.println(task.getId() + " " + task.getName());
       }
   }

4.2.3 查询任务

     /*
   * 查询任务
   */
   @Test
   public void demo7 () {
       TaskQuery taskQuery = processEngine.getTaskService().createTaskQuery();
       taskQuery.taskAssignee("王五");
       List<Task> list = taskQuery.list();
       for (Task task : list) {
           System.out.println(task.getId() + " " + task.getName());
       }
   }

4.2.4 办理任务

     /*
   * 办理任务
   */
   @Test
   public void demo8 () {
       String taskId = "402";
       processEngine.getTaskService().complete(taskId);
   }

五. 流程变量

5.1流程变量的创建

流程变量的创建有四种方式:创建流程实例时创建, 办理任务时创建, 基于runtimeservice创建, 基于taskservice创建

5.1.1 当流程实例启动时设置流程变量

     @Test
   public void demo2 () {
       String processDefinitionId = "qjlc:5:1604";
       Map<String, Object> variables = new HashMap<String, Object>();
       variables.put("key1", "value1");
       variables.put("key2", "value2");
       ProcessInstance processInstance = processEngine.getRuntimeService().startProcessInstanceById(processDefinitionId, variables);
       System.out.println(processInstance.getId());
   }

5.1.2 在办理任务时创建

     @Test
   public void demo3 () {
       TaskService taskService = processEngine.getTaskService();
       TaskQuery taskQuery = taskService.createTaskQuery();
       List<Task> list = taskQuery.list();
       for (Task task : list) {
           System.out.println(task.getId());
           String taskId = task.getId();
           Map<String, Object> variables = new HashMap<String, Object>();
           variables.put("k1", "v1");
           variables.put("k2", "v2");
           taskService.complete(taskId, variables);
       }

   }

5.1.3 利用runtimeservice创建流程变量

     @Test
   public void demo4 () {
       String executionId = "1701";
       String variableName = "qjyy";
       Object value = "想请假了!";
       //创建单个流程变量
       processEngine.getRuntimeService().setVariable(executionId, variableName, value);
       //创建多个流程变量
       Map<String, Object> variables = new HashMap<>();
       variables.put("k3", "v3");
       variables.put("k4", "v4");
       processEngine.getRuntimeService().setVariables(executionId, variables);
   }

5.1.4 利用taskservice创建流程变量

     @Test
   public void demo5 () {
       String taskId = "1804";
       String variableName = "qjts";
       Object value = 7;
       //创建单个流程变量
       processEngine.getTaskService().setVariable(taskId, variableName, value);
       //创建多个流程对象
       Map<String, Object> variables = new HashMap<>();
       variables.put("k5", "v5");
       variables.put("k6", "v6");
       processEngine.getTaskService().setVariables(taskId, variables);
   }

5.1.5 流程变量中存放自定义对象(自定义对象要实现Serializable接口)

     @Test
   public void demo5_1 () {
       //创建流程实例
       /*String processDefinitionKey = "qjlc";
       ProcessInstance processInstance = processEngine.getRuntimeService().startProcessInstanceByKey(processDefinitionKey );
       System.out.println(processInstance.getId());*/
       //创建流程变量
       String executionId = "2501";
       Map<String, Object> variables = new HashMap<>();
       User user = new User();
       user.setUsername("老王");
       user.setPassword("123");
       variables.put("user", user );
       processEngine.getRuntimeService().setVariables(executionId , variables);
   }

自定义对象User

package cn.rodge.activiti.variable;
import java.io.Serializable;
public class User implements Serializable {
   private static final long serialVersionUID = 1L;
   private String username;
   private String password;
   public String getUsername() {
       return username;
   }
   public void setUsername(String username) {
       this.username = username;
   }
   public String getPassword() {
       return password;
   }
   public void setPassword(String password) {
       this.password = password;
   }
}

5.2 流程变量的获取

5.2.1 基于RuntimeService获取

     @Test
   public void demo6 () {
       String executionId = "1701";
       String variableName = "qjts";
       //获取单个流程变量
       Object variable = processEngine.getRuntimeService().getVariable(executionId, variableName);
       System.out.println(variable);
       //获取多个流程变量
       Map<String, Object> variables = processEngine.getRuntimeService().getVariables(executionId);
       System.out.println(variables);
   }

5.2.2 基于TaskService获取

    @Test
   public void demo7 () {
       String taskId = "1804";
       String variableName = "qjyy";
       //获取单个流程变量
       Object variable = processEngine.getTaskService().getVariable(taskId, variableName);
       System.out.println(variable);
       Object getVariables;
       //获取多个流程变量, 获取当前流程所在流程实例中的所有流程变量
       Map<String, Object> variables = processEngine.getTaskService().getVariables(taskId);
       System.out.println(variables);
   }

六. 组任务

6.1 候选人组任务

6.1.1 查询组任务

    @Test
   public void demo5 () {
       TaskQuery taskQuery = processEngine.getTaskService().createTaskQuery();
       taskQuery.taskCandidateUser("李四");
       List<Task> list = taskQuery.list();
       for (Task task : list) {
           System.out.println(task.getId() + " " + task.getName());
       }
   }

6.1.2 拾取组任务

    @Test
   public void demo6 () {
       String taskId = "3802";
       String userId = "李四";
       processEngine.getTaskService().claim(taskId, userId);
   }

6.1.3 退回组任务

     @Test
   public void demo7 () {
       String taskId = "3802";
       String userId = null;
       processEngine.getTaskService().setAssignee(taskId, userId);
   }

6.2 候选组组任务

6.2.1 创建组

        @Test
       public void demo3 () {
           Group group = new GroupEntity();
           group.setId("财务人员组");
           group.setName("财务人员组");
           processEngine.getIdentityService().saveGroup(group);
       }

6.2.2 创建用户

    @Test
   public void demo4 () {
       User user = new UserEntity();
       user.setId("002");
       user.setFirstName("小明");
       processEngine.getIdentityService().saveUser(user);
   }

6.2.3 将用户添加到组

    @Test
   public void demo5 () {
       String groupId = "财务人员组";
       String userId = "002";
       processEngine.getIdentityService().createMembership(userId, groupId);
   }

6.2.4 查询组任务

    @Test
   public void demo8 () {
       TaskQuery taskQuery = processEngine.getTaskService().createTaskQuery();
       taskQuery.taskCandidateUser("002");
       List<Task> list = taskQuery.list();
       for (Task task : list) {
           System.out.println(task.getId() + " " + task.getName());
       }
   }

6.2.5 拾取组任务

    @Test
   public void demo9 () {
       String userId = "002";
       String taskId = "4702";
       processEngine.getTaskService().claim(taskId, userId);
   }

拾取完组任务后,就可以按照正常的任务办理流程办理任务了

6.2.6 退回组任务

     @Test
   public void demo10 () {
       String userId = null;
       String taskId = "4702";
       processEngine.getTaskService().setAssignee(taskId, userId);
   }

七. 网关(排他网关)

private ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

   /*
   * 部署流程
   */
   @Test
   public void demo1() {
       DeploymentBuilder deploymentBuilder = processEngine.getRepositoryService().createDeployment();
       deploymentBuilder.addClasspathResource("cn/rodge/activiti/gatewall/bxlcnew.bpmn");
       deploymentBuilder.addClasspathResource("cn/rodge/activiti/gatewall/bxlcnew.png");
       Deployment deploy = deploymentBuilder.deploy();
       System.out.println(deploy.getId());
   }

   /*
   * 创建流程实例
   */
   @Test
   public void demo2() {
       String processDefinitionKey = "cwlc";
       ProcessInstance processInstance = processEngine.getRuntimeService()
               .startProcessInstanceByKey(processDefinitionKey);
       System.out.println(processInstance.getId());
   }

   /*
   * 查询流程实例
   */
   @Test
   public void demo3() {
       ProcessInstanceQuery processInstanceQuery = processEngine.getRuntimeService().createProcessInstanceQuery();
       List<ProcessInstance> list = processInstanceQuery.list();
       for (ProcessInstance processInstance : list) {
           System.out.println(processInstance.getId() + " " + processInstance.getActivityId());
       }
   }
   /*
   * 查询任务
   */
   @Test
   public void demo4 () {
       TaskQuery taskQuery = processEngine.getTaskService().createTaskQuery();
       taskQuery.taskAssignee("王五");
       List<Task> list = taskQuery.list();
       for (Task task : list) {
           System.out.println(task.getId() + " " + task.getAssignee());
       }
   }
   /*
   * 执行任务同时创建变量bxje
   */
   @Test
   public void demo5 () {
       String taskId = "6004";
       Map<String, Object> variables = new HashMap<>();
       variables.put("bxje", 2000);
       processEngine.getTaskService().complete(taskId, variables);
   }

当定义的流程变量bxje>1000时, 就会执行"财务主管审批"的分支

八. spring整合activiti

第一步：提供spring配置文件，配置数据源、事务管理器、spring提供的流程引擎配置对象、流程引擎工厂bean

java代码

public class ActivitiSpring {
   public static void main(String[] args) {
       // 获取配置文件
       ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
       // 从配置文件中获取流程引擎对象
       ProcessEngine processEngine = (ProcessEngine) context.getBean("processEngine");
       ProcessDefinitionQuery definitionQuery = processEngine.getRepositoryService().createProcessDefinitionQuery();
       List<ProcessDefinition> list = definitionQuery.list();
       for (ProcessDefinition processDefinition : list) {
           System.out.println(processDefinition.getId() + " " + processDefinition.getName());
       }
   }
}

转载于:https://www.cnblogs.com/rodge-run/p/6492842.html