工作流（activiti7）-进阶使用（流程变量，网关，监听器，拦截器）（四）

最新推荐文章于 2024-06-10 18:21:03 发布

Angus博客

最新推荐文章于 2024-06-10 18:21:03 发布

阅读量8.1k

点赞数 7

分类专栏： activiti

本文链接：https://blog.csdn.net/onceing/article/details/107953938

版权

activiti 专栏收录该内容

15 篇文章 33 订阅

订阅专栏

工作流（activiti7）教程-简单的介绍和使用（一）

工作流（activiti7）教程-简单的介绍和使用（二）

工作流（activiti7）-进阶使用（流程实例，个人任务,组任务）（三）

工作流（activiti7）-进阶使用（流程变量，网关，监听器，拦截器）（四）

工作流（activiti7）-进阶使用（子流程CallActivity详细使用）（五）

一，流程变量

流程变量在activiti中是一个非常重要的角色，流程运转有时需要靠流程变量，业务系统和activiti结合时少不了流程变量，流程变量就是activiti在管理工作流时根据管理需要而设置的变量。变量可以带这很多数据，（业务的数据，或者业务的标识信息等）

1.启动流程时设置

    @Test
    public void test3() {
        //开启流程
        String processDefinitionId = "qjlc:1:4";
        String variables = "流程变量";
        Map m = new HashMap();
        m.put("variables",variables);

//        ProcessInstance pi = pe.getRuntimeService().startProcessInstanceById(processDefinitionId);
//        ProcessInstance pi = pe.getRuntimeService().startProcessInstanceByKey(); //多种方式请求
        ProcessInstance pi  =  pe.getRuntimeService().startProcessInstanceById(processDefinitionId,m);
        System.out.println(pi.getId());

    }

2. 在执行任务中设置

    @Test
    public void test333() {
        //开启流程
        String processDefinitionId = "qjlc:1:4";
        String variables = "流程变量";
        Map m = new HashMap();
        m.put("variables",variables);
        //在任务中设置流程变量
        pe.getTaskService().setVariables("taskid",m);

    }

3，单钱运行实例设置

    @Test
    public void test3333() {
        //开启流程
        String processDefinitionId = "qjlc:1:4";
        String variables = "流程变量";
        Map m = new HashMap();
        m.put("variables",variables);
        //在任务中设置流程变量
        pe.getRuntimeService().setVariables("executionID",m);

    }

基本上常用的三种。。。。

二，网关

1，排他网关

有选择性判断，根据条件只走其中一条流程，IF else逻辑如图

2，并行网关

互不影响，各走各的。。

3，包含网关

包含网关可以看做是排他网关和并行网关的结合体。和排他网关一样，你可以在外出顺序流上定义条件，包含网关会解析它们。但是主要的区别是包含网关可以选择多于一条顺序流，这和并行网关一样。

包含网关的功能是基于进入和外出顺序流的：

分支：
所有外出顺序流的条件都会被解析，结果为true的顺序流会以并行方式继续执行，会为每个顺序流创建一个分支。
汇聚：
所有并行分支到达包含网关，会进入等待状态，直到每个包含流程token的进入顺序流的分支都到达。这是与并行网关的最大不同。换句话说，包含网关只会等待被选中执行了的进入顺序流。在汇聚之后，流程会穿过包含网关继续执行。

三，监听器

事件监听器（全局）ps:不需要修改流程图

监听器代码，type种类很多（二三十种）,这里写了其中几种。。

package testssss;

import org.activiti.engine.delegate.event.ActivitiEvent;
import org.activiti.engine.delegate.event.ActivitiEventListener;
import org.springframework.stereotype.Component;

/**
 * @ClassName WsjActivitiEventListener
 * @Description: 全局
 * @Author wsj
 * @Date 2020/8/19
 **/
@Component
public class WsjActivitiEventListener implements ActivitiEventListener {

    @Override
    public void onEvent(ActivitiEvent activitiEvent) {
        switch (activitiEvent.getType()){
            //流程开始
            case PROCESS_STARTED:
                System.out.println("流程开始");
                break;
            //流程结束
            case PROCESS_COMPLETED:
                System.out.println("流程结束");
                break;
            //任务开始
            case TASK_CREATED:
                System.out.println("任务开始");
                break;
            //任务完成
            case TASK_COMPLETED:
                System.out.println("任务完成");
                break;
            //进程取消，删除实例
            case PROCESS_CANCELLED:
                System.out.println("进程取消，删除实例");
            default:
        }
    }

    /**
     *
     * @return
     */
    @Override
    public boolean isFailOnException() {
        return false;
    }

}

需要注册下和配置bean

 <property name="eventListeners">
            <list>
                <!-- 配置上监听器 -->
                <bean class="testssss.WsjActivitiEventListener"/>
            </list>
        </property>

配置配置文件

<bean class="testssss.ActivitiConfig"/>

然后配置文件代码：

package testssss;

import org.activiti.engine.delegate.event.ActivitiEventListener;
import org.activiti.spring.SpringProcessEngineConfiguration;
import org.activiti.spring.boot.ProcessEngineConfigurationConfigurer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;

/**
 * @ClassName ActivitiConfig
 * @Description: TODO
 * @Author wsj
 * @Date 2020/8/19
 **/
@Component
public class ActivitiConfig implements ProcessEngineConfigurationConfigurer {

    @Autowired
    private WsjActivitiEventListener wsjActivitiEventListener;

    @Override
    public void configure(SpringProcessEngineConfiguration processEngineConfiguration) {
        List<ActivitiEventListener> activitiEventListener=new ArrayList<ActivitiEventListener>();

        activitiEventListener.add(wsjActivitiEventListener);//配置全局监听器
        System.out.println("注册监听");
        processEngineConfiguration.setEventListeners(activitiEventListener);
    }
}

这样启动流程就回监听到相关数据如图debug下

任务监听器（需要在流程图中配置）

class配置类启动就可以监听到相关数据

监听器代码

package testssss;
 
 
import org.activiti.engine.delegate.DelegateExecution;
import org.activiti.engine.delegate.DelegateTask;
import org.activiti.engine.delegate.ExecutionListener;
import org.activiti.engine.delegate.TaskListener;
import org.springframework.stereotype.Component;

@Component
public class ActivitiListenner implements TaskListener, ExecutionListener {
 
	@Override
	public void notify(DelegateExecution execution) {
		System.out.println("xml流程：" + execution.getId() + " ActivitiListenner" + this.toString());
	}
 
 
	@Override
	public void notify(DelegateTask delegateTask) {
		System.out.println("xml任务：" + delegateTask.getId() + " ActivitiListenner" + this.toString());
	}
 
 
}

也可以单独监听：

package testssss;

import org.activiti.engine.delegate.DelegateTask;
import org.activiti.engine.delegate.TaskListener;
import org.springframework.stereotype.Component;

/**
 * @ClassName WsjTaskListener
 * @Description: TODO
 * @Author wsj
 * @Date 2020/7/1
 **/
@Component
public class WsjTaskListener implements TaskListener {
    @Override
    public void notify(DelegateTask delegateTask) {
        System.out.println("getEventName"+delegateTask.getEventName());
        System.out.println("getCategory"+delegateTask.getCategory());
        System.out.println("getDelegationState"+delegateTask.getDelegationState());
    }
}

执行器监听器（需要在流程图中配置）

监听器代码

package testssss;

import org.activiti.engine.delegate.DelegateExecution;
import org.activiti.engine.delegate.ExecutionListener;

public class MyExecutionListener implements ExecutionListener {
    public void notify(DelegateExecution execution) {
        String eventName = execution.getEventName();
//start
        if ("start".equals(eventName)) {
            System.out.println("start=========");
        } else if ("end".equals(eventName)) {
            System.out.println("end=========");
        }
    }
}

四，拦截器

拦截器类似监听器，只不过全局拦截数据更全面，在流程启动前，过程中，有会有相关拦截输出

拦截器代码

package com.wsj.demo.controller;

import org.activiti.engine.impl.interceptor.AbstractCommandInterceptor;
import org.activiti.engine.impl.interceptor.Command;
import org.activiti.engine.impl.interceptor.CommandConfig;

public class MyCommandInterceptorC extends AbstractCommandInterceptor {

    @Override
        public <T> T execute(CommandConfig config, Command<T> command) {
            System.out.println("拦截器执行command.getClass().getName()" + command.getClass().getName());
            System.out.println("拦截器执行command.getClass().toString()" + command.getClass().toString());
            System.out.println("拦截器执行command.getClass().getComponentType()" + command.getClass().getComponentType());
            System.out.println("拦截器执行config.toString()" + config.toString());
            System.out.println("拦截器执行config.getTransactionPropagation().name()" + config.getTransactionPropagation().name());
            System.out.println("拦截器执行config.getTransactionPropagation().toString()" + config.getTransactionPropagation().toString());
            System.out.println("拦截器执行config.getTransactionPropagation().getDeclaringClass().getName()" + config.getTransactionPropagation().getDeclaringClass().getName());
            System.out.println("拦截器执行config.transactionRequired().toString()" + config.transactionRequired().toString());
            return this.getNext().execute(config,command);
        }
}

配置：

       <property name="customPreCommandInterceptors">
            <list>
                <bean class="com.wsj.demo.controller.MyCommandInterceptorC"></bean>
            </list>
        </property>

启动一个流程打印：

代码地址 https://github.com/itwsj/activitidemo

Angus博客

关注

7
点赞
踩
26

收藏

觉得还不错? 一键收藏
5
评论
工作流（activiti7）-进阶使用（流程变量，网关，监听器，拦截器）（四）

一，流程变量流程变量在activiti中是一个非常重要的角色，流程运转有时需要靠流程变量，业务系统和activiti结合时少不了流程变量，流程变量就是activiti在管理工作流时根据管理需要而设置的变量。变量可以带这很多数据，（业务的数据，或者业务的标识信息等）1.启动流程时设置 @Test public void test3() { //开启流程 String processDefinitionId = "qjlc:1:4"; ...
复制链接

扫一扫

专栏目录