精华内容
下载资源
问答
  • 2021-06-03 07:39:13

    什么是包含网关?

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

    其实在我看来就是

    排他网关:解析条件,要不报错,要不走一个

    并行网关:不解析条件,不报错,都走

    包含网关:解析条件,条件成立就走,不成立就不走,全都不成立报错

    需求:

    体检流程

    如果是领导 就走 常规,抽血,VIP,普通员工只走常规,抽血

    使用流程变量控制

    领导:userType=2

    员工:userType=1

    package com.itheima.test.testGateWay;
    
    import org.activiti.engine.*;
    import org.activiti.engine.repository.Deployment;
    import org.activiti.engine.runtime.ProcessInstance;
    import org.activiti.engine.task.Task;
    import org.junit.Before;
    
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * 测试包含网关
     */
    public class Test {
    
        ProcessEngine defaultProcessEngine;
    
        @Before
        public void init() {
            defaultProcessEngine = ProcessEngines.getDefaultProcessEngine();
        }
    
        @org.junit.Test
        public void deployment(){
    
            RepositoryService repositoryService = defaultProcessEngine.getRepositoryService();
    
            Deployment deploy = repositoryService.createDeployment()
                    .addClasspathResource("pic/gateway/holidayGateway3.bpmn")
                    .name("体检流程")
                    .deploy();
    
            System.out.println(deploy);
    
        }
    
        @org.junit.Test
        public void startProcessInstance(){
    
            RuntimeService runtimeService = defaultProcessEngine.getRuntimeService();
    
            Integer userType = 1;
    
            Map<String,Object> map = new HashMap<>();
    
            map.put("userType",userType);
    
            ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("myProcess_1", map);
    
            System.out.println(processInstance);
    
        }
    
        /**
         * 提交任务
         */
        @org.junit.Test
        public void completTask(){
            String assignee = "sunqi";
            Task task = querySingResultByAssignee(assignee);
            System.out.println(task);
            TaskService taskService = defaultProcessEngine.getTaskService();
            taskService.complete(task.getId());
        }
    
        /**
         * 查询用户唯一任务
         * @param assignee
         * @return
         */
        public Task querySingResultByAssignee(String assignee){
            TaskService taskService = defaultProcessEngine.getTaskService();
            return taskService.createTaskQuery().processDefinitionKey("myProcess_1").taskAssignee(assignee).singleResult();
        }
    
    }
    

    主要查看act_hi_actinst表的流程变化,既可以发现

    userType=1 领取->常规->抽血->早餐->结束

    userType=2 领取->常规->抽血->早餐->VIP->结束

    作者:彼岸舞

    时间:2020\09\08

    内容关于:Activiti工作流

    本文来源于网络,只做技术分享,一概不负任何责任

    更多相关内容
  • 网关用来控制流程的流向网关可以消费也可以生成token。网关显示成菱形图形,内部有有一个小图标。 图标表示网关的类型。 1、基本分支: 首先 利用 流程变量 写个带有分支的一个基本流程 流程图: 部署...

    网关用来控制流程的流向 网关可以消费也可以生成token。网关显示成菱形图形,内部有有一个小图标。 图标表示网关的类型。

     

    1、基本分支:

    首先 利用 流程变量  写个带有分支的一个基本流程

    流程图:

    部署流程文件:

    //获取流程引擎
    	ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    	
    	@Test
    	public void deployFlow(){
    		
    		//获取仓库服务对象
    		RepositoryService repositoryService = processEngine.getRepositoryService();
    		
    		InputStream in = this.getClass().getResourceAsStream("/MyProcess11.zip");
    		ZipInputStream zipInputStream = new ZipInputStream(in);
    		
    		Deployment dm = repositoryService.createDeployment()
    											.name("学生请假")
    											.addZipInputStream(zipInputStream)
    											.deploy();
    		
    		System.out.println("id:"+dm.getId()+",name:"+dm.getName());
    	}
    

    启动流程 并 设置请假天数为 3天的 流程变量 提交 

    /**
    	 * 启动流程 并完成 提交
    	 */
    	@Test
    	public void startProcessAndComp(){
    		
    		RuntimeService runtimeService = processEngine.getRuntimeService();
    		ProcessInstance pi = runtimeService.startProcessInstanceByKey("leave");
    		
    		System.out.println("id:"+pi.getId()+",流程实例ID:"+pi.getProcessInstanceId()+",流程定义ID:"+pi.getProcessDefinitionId());
    		
    		TaskService taskService = processEngine.getTaskService();
    		
    		//通过流程实例ID获取任务对象
    		Task task = taskService.createTaskQuery()
    							.processInstanceId(pi.getProcessInstanceId())
    							.singleResult();
    		System.out.println("taskID:"+task.getId()+",name:"+task.getName());
    		
    		Map<String, Object> paramMap = new HashMap<String, Object>();
    		//设置流程变量day=3
    		paramMap.put("day", 3);
    		//提交任务的时候传入流程变量
    		taskService.complete(task.getId(), paramMap);
    		
    		//查询任务
    		task = taskService.createTaskQuery()
    				.processInstanceId(pi.getProcessInstanceId())
    				.singleResult();
    		
    		//如果任务对象为空,则流程执行结束
    		if (task != null) {
    			System.out.println("taskID:"+task.getId()+",name:"+task.getName());
    		} else {
    			System.out.println("任务执行完毕");
    		}
    	}
    

    最后的运行结果:

    id:1501,流程实例ID:1501,流程定义ID:leave:2:1404
    taskID:1504,name:班主任
    任务执行完毕

    我们可以再数据库中查看:

     


     

     

    我们再部署一个 流程文件 , 并且在提交 任务的时候 设置流程变量 请假天数为 10天

    最后的运行结果

    id:1701,流程实例ID:1701,流程定义ID:leave:3:1604
    taskID:1704,name:班主任
    taskID:1707,name:年级主任

    现在 流程就到了另外 一条线

     

    年纪主任审批通过:

    	/**
    	 * 提交任务
    	 */
    	@Test
    	public void completeTask(){
    		TaskService taskService = processEngine.getTaskService();
    		taskService.complete("1707");
    	}
    

    流程执行结束
                                                                                                                                                                                                                                                                       

    2、排他网关:

    排他网关描述

    排他网关(也叫异或(XOR)网关,或更技术性的叫法 基于数据的排他网关), 用来在流程中实现决策。 当流程执行到这个网关,所有外出顺序流都会被处理一遍。 其中条件解析为true的顺序流(或者没有设置条件,概念上在顺序流上定义了一个'true') 会被选中,让流程继续运行。

    注意这里的外出顺序流 与BPMN 2.0通常的概念是不同的。通常情况下,所有条件结果为true的顺序流 都会被选中,以并行方式执行,但排他网关只会选择一条顺序流执行。 就是说,虽然多个顺序流的条件结果为true, 那么XML中的第一个顺序流(也只有这一条)会被选中,并用来继续运行流程。 如果没有选中任何顺序流,会抛出一个异常。

    排他网关图形

    排他网关显示成一个普通网关(比如,菱形图形), 内部是一个“X”图标,表示异或(XOR)语义。 注意,没有内部图标的网关,默认为排他网关。 BPMN 2.0规范不允许在同一个流程定义中同时使用没有X和有X的菱形图形。

    流程文件:

     

    排他网关有个默认的选项  default flow ,  当 default flow 设定后  就不用设置表达式了,  如果所有的条件都不通过 就会执行默认的流程

    年级主任审批和校长审批

    首先 还是 先把文件部署 

    //获取流程引擎
    	ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    	
    	@Test
    	public void deployFlow2(){
    		
    		//获取仓库服务对象
    		RepositoryService repositoryService = processEngine.getRepositoryService();
    		
    		InputStream in = this.getClass().getResourceAsStream("/exclusiveGateway.zip");
    		ZipInputStream zipInputStream = new ZipInputStream(in);
    		
    		Deployment dm = repositoryService.createDeployment()
    											.name("学生请假")
    											.addZipInputStream(zipInputStream)
    											.deploy();
    		
    		System.out.println("id:"+dm.getId()+",name:"+dm.getName());
    	}
    

    启动流程, 并提交 设置 请假天数 为 10天   结果如下:

    id:2001,流程实例ID:2001,流程定义ID:exclusiveGateWay:1:1904
    taskID:2004,name:学生请假
    taskID:2008,name:年级主任审批
    

    再 重新部署一个流程文件 然后启动 提交  设置请假天数为 30天 执行结果:

    id:2201,name:学生请假
    
    id:2301,流程实例ID:2301,流程定义ID:exclusiveGateWay:2:2204
    taskID:2304,name:学生请假
    taskID:2308,name:校长审批

    最后在 部署一遍, 这次设置请假天数为 3天  结果:

    id:2501,name:学生请假
    
    id:2601,流程实例ID:2601,流程定义ID:exclusiveGateWay:3:2504
    taskID:2604,name:学生请假
    taskID:2608,name:班主任审批
    

    这里 流程走到了 当初 默认的设置  班主任审批


     

    当我们设置了 默认 的 配置  ,即使没有 设置表达式  流程 条件都 不满足的时候  都会执行默认的。

     

    3、并行网关

    并行网关描述
    网关也可以表示流程中的并行情况。最简单的并行网关是 并行网关,它允许将流程 分成多条分支,也可以把多条分支 汇聚到一起。 of execution.

    并行网关的功能是基于进入和外出的顺序流的:

    • 分支: 并行后的所有外出顺序流,为每个顺序流都创建一个并发分支。
    • 汇聚: 所有到达并行网关,在此等待的进入分支, 直到所有进入顺序流的分支都到达以后, 流程就会通过汇聚网关。

    注意,如果同一个并行网关有多个进入和多个外出顺序流, 它就同时具有分支和汇聚功能。 这时,网关会先汇聚所有进入的顺序流,然后再切分成多个并行分支。

    与其他网关的主要区别是,并行网关不会解析条件。 即使顺序流中定义了条件,也会被忽略。

    并行网关图形
    并行网关显示成一个普通网关(菱形)内部是一个“加号”图标, 表示“与(AND)”语义。

    首先 画一个简单的并行流程

    注意  并行 网关 要有2个  一个是用于 分支  一个用于 聚合

    部署启动

    @Test
    	public void deployFlow3() {
     
    		// 获取仓库服务对象
    		RepositoryService repositoryService = processEngine
    				.getRepositoryService();
     
    		InputStream in = this.getClass().getResourceAsStream("/Parallel.zip");
    		ZipInputStream zipInputStream = new ZipInputStream(in);
     
    		Deployment dm = repositoryService.createDeployment().name("并行网关")
    				.addZipInputStream(zipInputStream).deploy();
     
    		System.out.println("id:" + dm.getId() + ",name:" + dm.getName());
     
    		RuntimeService runtimeService = processEngine.getRuntimeService();
    		ProcessInstance pi = runtimeService
    				.startProcessInstanceByKey("parallel");
     
    		System.out.println("id:" + pi.getId() + ",流程实例ID:"
    				+ pi.getProcessInstanceId() + ",流程定义ID:"
    				+ pi.getProcessDefinitionId());
     
    	}
    

    输出结果:

    id:2801,name:并行网关
    id:2901,流程实例ID:2901,流程定义ID:parallel:1:2804

     

    此时流程进入  启动项目环节   通过流程实例ID 查看当前流程 进度

    /**
    	 * 启动流程 并完成 提交
    	 */
    	@Test
    	public void startProcessAndComp3() {
     
    		TaskService taskService = processEngine.getTaskService();
     
    		// 查询任务
    		Task task = taskService.createTaskQuery().processInstanceId("2901").singleResult();
     
    		// 如果任务对象为空,则流程执行结束
    		if (task != null) {
    			System.out.println("taskID:" + task.getId() + ",name:"
    					+ task.getName());
    		} else {
    			System.out.println("任务执行完毕");
    		}
     
    		// 通过流程实例ID获取任务对象
    		task = taskService.createTaskQuery().processInstanceId("2901").singleResult();
    		System.out.println("taskID:" + task.getId() + ",name:" + task.getName());
     
    		// 提交任务
    		taskService.complete(task.getId());
     
    	}
    

    输出结果:

    taskID:2904,name:项目启动
    taskID:2904,name:项目启动

    提交任务后,流程进入并行环节,同时执行 功能模块1 和 功能模块2

     


    这是我们可以看到  流程实例ID 和 执行对象ID 已经是不同了

    这个是 act_ru_execution 表的数据 

    我们先 提交一个  功能模块1的任务 

    在看 任务表  act_ru_task 


    此时 任务表 只有 功能模块2 

    我们在看  act_ru_execution  这个表  依旧是3条数据  功能模块1 的执行流程 被阻塞在   并行网关这里  没有进入 测试发布这个环节:

    在提交功能模块2  任务

    查看 这  2个表

    流程 已经 进入 下一个环节 

    提交最后一个人  整个流程结束,  我们在查看  历史活动表  act_hi_actinst

    整个流程 分成了 2 块

     

    4、包含网关

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

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

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

    注意,如果同一个包含节点拥有多个进入和外出顺序流, 它就会同时含有分支和汇聚功能。 这时,网关会先汇聚所有拥有流程token的进入顺序流, 再根据条件判断结果为true的外出顺序流,为它们生成多条并行分支。

    包含网关图形
    并行网关显示为一个普通网关(菱形),内部包含一个圆圈图标。

    当 main config 中的 表达式 条件返回的结果为真时  执行 并行网关 

    结果为假时 执行 排他任务

    具体的 流程 这里就不介绍了

     

    事件网关

    事件网关描述
    基于事件网关允许根据事件判断流向。网关的每个外出顺序流都要连接到一个中间捕获事件。 当流程到达一个基于事件网关,网关会进入等待状态:会暂停执行。 与此同时,会为每个外出顺序流创建相对的事件订阅。

    注意基于事件网关的外出顺序流和普通顺序流不同。这些顺序流不会真的"执行"。 相反,它们让流程引擎去决定执行到基于事件网关的流程需要订阅哪些事件。 要考虑以下条件:

    • 基于事件网关必须有两条或以上外出顺序流。
    • 基于事件网关后,只能使用intermediateCatchEvent类型。 (activiti不支持基于事件网关后连接ReceiveTask。)
    • 连接到基于事件网关的intermediateCatchEvent只能有一条进入顺序流。

    事件网关图形
    事件网关和其他BPMN网关一样显示成一个菱形, 内部包含指定图标。


    这里 事件 太多了  就 不一一介绍了。 
     

    本文转自:https://blog.csdn.net/a67474506/article/details/40428709 

    展开全文
  • 网关用来控制流程的流向网关可以消费也可以生成token。 网关显示成菱形图形,内部有有一个小图标。 图标表示网关的类型。 基本分支 首先 利用 流程变量 写个带有分支的一个基本流程 流程图: 部署流程...

    网关用来控制流程的流向 网关可以消费也可以生成token。

    网关显示成菱形图形,内部有有一个小图标。 图标表示网关的类型。

     

    基本分支

    首先 利用 流程变量  写个带有分支的一个基本流程

    流程图:


    部署流程文件
     

    //获取流程引擎
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        
        @Test
        public void deployFlow(){
            
            //获取仓库服务对象
            RepositoryService repositoryService = processEngine.getRepositoryService();
            
            InputStream in = this.getClass().getResourceAsStream("/MyProcess11.zip");
            ZipInputStream zipInputStream = new ZipInputStream(in);
            
            Deployment dm = repositoryService.createDeployment()
                                                .name("学生请假")
                                                .addZipInputStream(zipInputStream)
                                                .deploy();
            
            System.out.println("id:"+dm.getId()+",name:"+dm.getName());
        }

    启动流程 并 设置请假天数为 3天的 流程变量 提交 

    * 启动流程 并完成 提交
    	 */
    	@Test
    	public void startProcessAndComp(){
    		
    		RuntimeService runtimeService = processEngine.getRuntimeService();
    		ProcessInstance pi = runtimeService.startProcessInstanceByKey("leave");
    		
    		System.out.println("id:"+pi.getId()+",流程实例ID:"+pi.getProcessInstanceId()+",流程定义ID:"+pi.getProcessDefinitionId());
    		
    		TaskService taskService = processEngine.getTaskService();
    		
    		//通过流程实例ID获取任务对象
    		Task task = taskService.createTaskQuery()
    							.processInstanceId(pi.getProcessInstanceId())
    							.singleResult();
    		System.out.println("taskID:"+task.getId()+",name:"+task.getName());
    		
    		Map<String, Object> paramMap = new HashMap<String, Object>();
    		//设置流程变量day=3
    		paramMap.put("day", 3);
    		//提交任务的时候传入流程变量
    		taskService.complete(task.getId(), paramMap);
    		
    		//查询任务
    		task = taskService.createTaskQuery()
    				.processInstanceId(pi.getProcessInstanceId())
    				.singleResult();
    		
    		//如果任务对象为空,则流程执行结束
    		if (task != null) {
    			System.out.println("taskID:"+task.getId()+",name:"+task.getName());
    		} else {
    			System.out.println("任务执行完毕");
    		}
    	}

    最后的运行结果:

    id:1501,流程实例ID:1501,流程定义ID:leave:2:1404
    taskID:1504,name:班主任
    任务执行完毕

    我们再部署一个 流程文件 , 并且在提交 任务的时候 设置流程变量 请假天数为 10天

     

    最后的运行结果

    id:1701,流程实例ID:1701,流程定义ID:leave:3:1604
    taskID:1704,name:班主任
    taskID:1707,name:年级主任

     

    现在 流程就到了另外 一条线

     

    年纪主任审批通过:

        /**
         * 提交任务
         */
        @Test
        public void completeTask(){
            TaskService taskService = processEngine.getTaskService();
            taskService.complete("1707");
        }

    流程执行结束
                                                                                                                                                                                                                                                                        

    排他网关:

    排他网关描述
    排他网关(也叫异或(XOR)网关,或更技术性的叫法 基于数据的排他网关), 用来在流程中实现决策。 当流程执行到这个网关,所有外出顺序流都会被处理一遍。 其中条件解析为true的顺序流(或者没有设置条件,概念上在顺序流上定义了一个'true') 会被选中,让流程继续运行。

    注意这里的外出顺序流 与BPMN 2.0通常的概念是不同的。通常情况下,所有条件结果为true的顺序流 都会被选中,以并行方式执行,但排他网关只会选择一条顺序流执行。 就是说,虽然多个顺序流的条件结果为true, 那么XML中的第一个顺序流(也只有这一条)会被选中,并用来继续运行流程。 如果没有选中任何顺序流,会抛出一个异常。


    排他网关图形
    排他网关显示成一个普通网关(比如,菱形图形), 内部是一个“X”图标,表示异或(XOR)语义。 注意,没有内部图标的网关,默认为排他网关。 BPMN 2.0规范不允许在同一个流程定义中同时使用没有X和有X的菱形图形。

     

     

    排他网关有个默认的选项  default flow ,  当 default flow 设定后  就不用设置表达式了,  如果所有的条件都不通过 就会执行默认的流程

    年级主任审批和校长审批

    首先 还是 先把文件部署 

    //获取流程引擎
    	ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    	
    	@Test
    	public void deployFlow2(){
    		
    		//获取仓库服务对象
    		RepositoryService repositoryService = processEngine.getRepositoryService();
    		
    		InputStream in = this.getClass().getResourceAsStream("/exclusiveGateway.zip");
    		ZipInputStream zipInputStream = new ZipInputStream(in);
    		
    		Deployment dm = repositoryService.createDeployment()
    											.name("学生请假")
    											.addZipInputStream(zipInputStream)
    											.deploy();
    		
    		System.out.println("id:"+dm.getId()+",name:"+dm.getName());
    	}

    启动流程, 并提交 设置 请假天数 为 10天   结果

    1. id:2001,流程实例ID:2001,流程定义ID:exclusiveGateWay:1:1904

    2. taskID:2004,name:学生请假

    3. taskID:2008,name:年级主任审批

    再 重新部署一个流程文件 然后启动 提交  设置请假天数为 30天 执行结果

    id:2201,name:学生请假
    id:2301,流程实例ID:2301,流程定义ID:exclusiveGateWay:2:2204
    taskID:2304,name:学生请假
    taskID:2308,name:校长审批
    最后在 部署一遍, 这次设置请假天数为 3天  结果
    id:2501,name:学生请假
    id:2601,流程实例ID:2601,流程定义ID:exclusiveGateWay:3:2504
    taskID:2604,name:学生请假
    taskID:2608,name:班主任审批

    这里 流程走到了 当初 默认的设置  班主任审批

    当我们设置了 默认 的 配置  ,即使没有 设置表达式  流程 条件都 不满足的时候  都会执行默认的


    并行网关

    并行网关描述
    网关也可以表示流程中的并行情况。最简单的并行网关是 并行网关,它允许将流程 分成多条分支,也可以把多条分支 汇聚到一起。 of execution.

    并行网关的功能是基于进入和外出的顺序流的:

    分支: 并行后的所有外出顺序流,为每个顺序流都创建一个并发分支。

    汇聚: 所有到达并行网关,在此等待的进入分支, 直到所有进入顺序流的分支都到达以后, 流程就会通过汇聚网关。

    注意,如果同一个并行网关有多个进入和多个外出顺序流, 它就同时具有分支和汇聚功能。 这时,网关会先汇聚所有进入的顺序流,然后再切分成多个并行分支。

    与其他网关的主要区别是,并行网关不会解析条件。 即使顺序流中定义了条件,也会被忽略。

    并行网关图形
    并行网关显示成一个普通网关(菱形)内部是一个“加号”图标, 表示“与(AND)”语义。

    首先 画一个简单的并行流程

    注意  并行 网关 要有2个  一个是用于 分支  一个用于 聚合

    部署启动

    @Test
    	public void deployFlow3() {
     
    		// 获取仓库服务对象
    		RepositoryService repositoryService = processEngine
    				.getRepositoryService();
     
    		InputStream in = this.getClass().getResourceAsStream("/Parallel.zip");
    		ZipInputStream zipInputStream = new ZipInputStream(in);
     
    		Deployment dm = repositoryService.createDeployment().name("并行网关")
    				.addZipInputStream(zipInputStream).deploy();
     
    		System.out.println("id:" + dm.getId() + ",name:" + dm.getName());
     
    		RuntimeService runtimeService = processEngine.getRuntimeService();
    		ProcessInstance pi = runtimeService
    				.startProcessInstanceByKey("parallel");
     
    		System.out.println("id:" + pi.getId() + ",流程实例ID:"
    				+ pi.getProcessInstanceId() + ",流程定义ID:"
    				+ pi.getProcessDefinitionId());
     
    	}
    id:2801,name:并行网关
    id:2901,流程实例ID:2901,流程定义ID:parallel:1:2804

    此时流程进入  启动项目环节   通过流程实例ID 查看当前流程 进度

    /**
    	 * 启动流程 并完成 提交
    	 */
    	@Test
    	public void startProcessAndComp3() {
     
    		TaskService taskService = processEngine.getTaskService();
     
    		// 查询任务
    		Task task = taskService.createTaskQuery().processInstanceId("2901").singleResult();
     
    		// 如果任务对象为空,则流程执行结束
    		if (task != null) {
    			System.out.println("taskID:" + task.getId() + ",name:"
    					+ task.getName());
    		} else {
    			System.out.println("任务执行完毕");
    		}
     
    		// 通过流程实例ID获取任务对象
    		task = taskService.createTaskQuery().processInstanceId("2901").singleResult();
    		System.out.println("taskID:" + task.getId() + ",name:" + task.getName());
     
    		// 提交任务
    		taskService.complete(task.getId());
     
    	}
    taskID:2904,name:项目启动
    taskID:2904,name:项目启动

    提交任务后,流程进入并行环节,同时执行 功能模块1 和 功能模块2

    包含网关

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

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

    分支: 所有外出顺序流的条件都会被解析,结果为true的顺序流会以并行方式继续执行, 会为每个顺序流创建一个分支。

    汇聚: 所有并行分支到达包含网关,会进入等待章台, 直到每个包含流程token的进入顺序流的分支都到达。 这是与并行网关的最大不同。换句话说,包含网关只会等待被选中执行了的进入顺序流。 在汇聚之后,流程会穿过包含网关继续执行。

    注意,如果同一个包含节点拥有多个进入和外出顺序流, 它就会同时含有分支和汇聚功能。 这时,网关会先汇聚所有拥有流程token的进入顺序流, 再根据条件判断结果为true的外出顺序流,为它们生成多条并行分支。

    包含网关图形
    并行网关显示为一个普通网关(菱形),内部包含一个圆圈图标。

     

    当 main config 中的 表达式 条件返回的结果为真时  执行 并行网关 

    结果为假时 执行 排他任务

    具体的 流程 这里就不介绍了

    事件网关

    事件网关描述
    基于事件网关允许根据事件判断流向。网关的每个外出顺序流都要连接到一个中间捕获事件。 当流程到达一个基于事件网关,网关会进入等待状态:会暂停执行。 与此同时,会为每个外出顺序流创建相对的事件订阅。

    注意基于事件网关的外出顺序流和普通顺序流不同。这些顺序流不会真的"执行"。 相反,它们让流程引擎去决定执行到基于事件网关的流程需要订阅哪些事件。 要考虑以下条件:

    基于事件网关必须有两条或以上外出顺序流。

    基于事件网关后,只能使用intermediateCatchEvent类型。 (activiti不支持基于事件网关后连接ReceiveTask。)

    连接到基于事件网关的intermediateCatchEvent只能有一条进入顺序流。

    事件网关图形
    事件网关和其他BPMN网关一样显示成一个菱形, 内部包含指定图标。

     

     

     

     

     

     

     

     

     

    展开全文
  • 网关用来控制流程的流向 网关能够消费也能够生成token。 网关显示成菱形图形,内部有有一个小图标。 图标表示网关的类型。 基本分支 首先 利用 流程变量 写个带有分支的一个基本流程 流程图: ...

    文章转载于:http://www.cnblogs.com/yxysuanfa/p/7261306.html

    网关用来控制流程的流向 网关能够消费也能够生成token。

    网关显示成菱形图形,内部有有一个小图标。 图标表示网关的类型。

    基本分支

    首先 利用 流程变量  写个带有分支的一个基本流程

    流程图:




    部署流程文件:

    //获取流程引擎
    	ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    	
    	@Test
    	public void deployFlow(){
    		
    		//获取仓库服务对象
    		RepositoryService repositoryService = processEngine.getRepositoryService();
    		
    		InputStream in = this.getClass().getResourceAsStream("/MyProcess11.zip");
    		ZipInputStream zipInputStream = new ZipInputStream(in);
    		
    		Deployment dm = repositoryService.createDeployment()
    											.name("学生请假")
    											.addZipInputStream(zipInputStream)
    											.deploy();
    		
    		System.out.println("id:"+dm.getId()+",name:"+dm.getName());
    	}
    启动流程 并 设置请假天数为 3天的 流程变量 提交 

    /**
    	 * 启动流程 并完毕 提交
    	 */
    	@Test
    	public void startProcessAndComp(){
    		
    		RuntimeService runtimeService = processEngine.getRuntimeService();
    		ProcessInstance pi = runtimeService.startProcessInstanceByKey("leave");
    		
    		System.out.println("id:"+pi.getId()+",流程实例ID:"+pi.getProcessInstanceId()+",流程定义ID:"+pi.getProcessDefinitionId());
    		
    		TaskService taskService = processEngine.getTaskService();
    		
    		//通过流程实例ID获取任务对象
    		Task task = taskService.createTaskQuery()
    							.processInstanceId(pi.getProcessInstanceId())
    							.singleResult();
    		System.out.println("taskID:"+task.getId()+",name:"+task.getName());
    		
    		Map<String, Object> paramMap = new HashMap<String, Object>();
    		//设置流程变量day=3
    		paramMap.put("day", 3);
    		//提交任务的时候传入流程变量
    		taskService.complete(task.getId(), paramMap);
    		
    		//查询任务
    		task = taskService.createTaskQuery()
    				.processInstanceId(pi.getProcessInstanceId())
    				.singleResult();
    		
    		//假设任务对象为空,则流程运行结束
    		if (task != null) {
    			System.out.println("taskID:"+task.getId()+",name:"+task.getName());
    		} else {
    			System.out.println("任务运行完毕");
    		}
    	}

    最后的执行结果:

    id:1501,流程实例ID:1501,流程定义ID:leave:2:1404
    taskID:1504,name:班主任
    任务运行完成

    我们能够再数据库中查看:





    我们部署一个 流程文件 , 而且在提交 任务的时候 设置流程变量 请假天数为 10天


    最后的执行结果

    id:1701,流程实例ID:1701,流程定义ID:leave:3:1604
    taskID:1704,name:班主任
    taskID:1707,name:年级主任

    如今 流程就到了另外 一条线


    年纪主任审批通过:

    	/**
    	 * 提交任务
    	 */
    	@Test
    	public void completeTask(){
    		TaskService taskService = processEngine.getTaskService();
    		taskService.complete("1707");
    	}

    流程运行结束

                                                                                                                                                                                                                                                                        

    排他网关:

    排他网关描写叙述

    排他网关(也叫异或(XOR)网关,或更技术性的叫法 基于数据的排他网关), 用来在流程中实现决策。 当流程运行到这个网关,全部外出顺序流都会被处理一遍。 当中条件解析为true的顺序流(或者没有设置条件,概念上在顺序流上定义了一个'true') 会被选中,让流程继续执行。

    注意这里的外出顺序流 与BPMN 2.0通常的概念是不同的。

    通常情况下,全部条件结果为true的顺序流 都会被选中。以并行方式运行。但排他网关仅仅会选择一条顺序流运行。 就是说,尽管多个顺序流的条件结果为true。 那么XML中的第一个顺序流(也仅仅有这一条)会被选中,并用来继续运行流程。

    假设没有选中不论什么顺序流。会抛出一个异常。

    排他网关图形

    排他网关显示成一个普通网关(比方。菱形图形), 内部是一个“X”图标,表示异或(XOR)语义。

    注意。没有内部图标的网关,默觉得排他网关。 BPMN 2.0规范不同意在同一个流程定义中同一时候使用没有X和有X的菱形图形。

    流程文件:



    排他网关有个默认的选项  default flow ,  当 default flow 设定后  就不用设置表达式了,  假设全部的条件都不通过 就会运行默认的流程


    年级主任审批和校长审批



    首先 还是 先把文件部署 

    //获取流程引擎
    	ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    	
    	@Test
    	public void deployFlow2(){
    		
    		//获取仓库服务对象
    		RepositoryService repositoryService = processEngine.getRepositoryService();
    		
    		InputStream in = this.getClass().getResourceAsStream("/exclusiveGateway.zip");
    		ZipInputStream zipInputStream = new ZipInputStream(in);
    		
    		Deployment dm = repositoryService.createDeployment()
    											.name("学生请假")
    											.addZipInputStream(zipInputStream)
    											.deploy();
    		
    		System.out.println("id:"+dm.getId()+",name:"+dm.getName());
    	}


    启动流程, 并提交 设置 请假天数 为 10天   结果

    id:2001,流程实例ID:2001,流程定义ID:exclusiveGateWay:1:1904
    taskID:2004,name:学生请假
    taskID:2008,name:年级主任审批

    再 又一次部署一个流程文件 然后启动 提交  设置请假天数为 30天 运行结果

    id:2201,name:学生请假
    id:2301,流程实例ID:2301,流程定义ID:exclusiveGateWay:2:2204
    taskID:2304,name:学生请假
    taskID:2308,name:校长审批
    最后在 部署一遍, 这次设置请假天数为 3天  结果

    id:2501,name:学生请假
    id:2601,流程实例ID:2601,流程定义ID:exclusiveGateWay:3:2504
    taskID:2604,name:学生请假
    taskID:2608,name:班主任审批

    这里 流程走到了 当初 默认的设置  班主任审批



    当我们设置了 默认 的 配置  ,即使没有 设置表达式  流程 条件都 不满足的时候  都会运行默认的

    并行网关

    并行网关描写叙述

    网关也能够表示流程中的并行情况。最简单的并行网关是 并行网关,它同意将流程 成多条分支。也能够把多条分支 到一起。 of execution.

    并行网关的功能是基于进入和外出的顺序流的:

    • 分支: 并行后的全部外出顺序流,为每一个顺序流都创建一个并发分支。

    • 汇聚: 全部到达并行网关。在此等待的进入分支。 直到全部进入顺序流的分支都到达以后。 流程就会通过汇聚网关。

    注意。假设同一个并行网关有多个进入和多个外出顺序流。 它就同一时候具有分支和汇聚功能。 这时。网关会先汇聚全部进入的顺序流,然后再切分成多个并行分支。

    与其它网关的主要差别是,并行网关不会解析条件。

    即使顺序流中定义了条件。也会被忽略。

    并行网关图形

    并行网关显示成一个普通网关(菱形)内部是一个“加号”图标, 表示“与(AND)”语义。

    首先 画一个简单的并行流程



    注意  并行 网关 要有2个  一个是用于 分支  一个用于 聚合

    部署启动

    @Test
    	public void deployFlow3() {
    
    		// 获取仓库服务对象
    		RepositoryService repositoryService = processEngine
    				.getRepositoryService();
    
    		InputStream in = this.getClass().getResourceAsStream("/Parallel.zip");
    		ZipInputStream zipInputStream = new ZipInputStream(in);
    
    		Deployment dm = repositoryService.createDeployment().name("并行网关")
    				.addZipInputStream(zipInputStream).deploy();
    
    		System.out.println("id:" + dm.getId() + ",name:" + dm.getName());
    
    		RuntimeService runtimeService = processEngine.getRuntimeService();
    		ProcessInstance pi = runtimeService
    				.startProcessInstanceByKey("parallel");
    
    		System.out.println("id:" + pi.getId() + ",流程实例ID:"
    				+ pi.getProcessInstanceId() + ",流程定义ID:"
    				+ pi.getProcessDefinitionId());
    
    	}


    id:2801,name:并行网关
    id:2901,流程实例ID:2901,流程定义ID:parallel:1:2804
    此时流程进入  启动项目环节   通过流程实例ID 查看当前流程 进度

    /**
    	 * 启动流程 并完毕 提交
    	 */
    	@Test
    	public void startProcessAndComp3() {
    
    		TaskService taskService = processEngine.getTaskService();
    
    		// 查询任务
    		Task task = taskService.createTaskQuery().processInstanceId("2901").singleResult();
    
    		// 假设任务对象为空,则流程运行结束
    		if (task != null) {
    			System.out.println("taskID:" + task.getId() + ",name:"
    					+ task.getName());
    		} else {
    			System.out.println("任务运行完毕");
    		}
    
    		// 通过流程实例ID获取任务对象
    		task = taskService.createTaskQuery().processInstanceId("2901").singleResult();
    		System.out.println("taskID:" + task.getId() + ",name:" + task.getName());
    
    		// 提交任务
    		taskService.complete(task.getId());
    
    	}
    taskID:2904,name:项目启动
    taskID:2904,name:项目启动
    提交任务后,流程进入并行环节,同一时候运行 功能模块1 和 功能模块2


    这是我们能够看到  流程实例ID 和 运行对象ID 已经是不同了

    这个是 act_ru_execution 表的数据 


    我们先 提交一个  功能模块1的任务 

    在看 任务表  act_ru_task 


    此时 任务表 仅仅有 功能模块2 

    我们在看  act_ru_execution  这个表  依然是3条数据  功能模块1 的运行流程 被堵塞在   并行网关这里  没有进入 測试公布这个 环节


    在提交功能模块2  任务

    查看 这  2个表



    流程 已经 进入 下一个环节 

    提交最后一个人  整个流程结束,  我们在查看  历史活动表  act_hi_actinst


    整个流程 分成了 2 块



    包括网关

    包括网关描写叙述

    包括网关能够看做是排他网关和并行网关的结合体。 和排他网关一样,你能够在外出顺序流上定义条件。包括网关会解析它们。 可是基本的差别是包括网关能够选择多于一条顺序流。这和并行网关一样。

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

    • 分支: 全部外出顺序流的条件都会被解析。结果为true的顺序流会以并行方式继续运行。 会为每一个顺序流创建一个分支。

    • 汇聚: 全部并行分支到达包括网关。会进入等待章台, 直到每一个包括流程token的进入顺序流的分支都到达。 这是与并行网关的最大不同。换句话说,包括网关仅仅会等待被选中运行了的进入顺序流。 在汇聚之后,流程会穿过包括网关继续运行。

    注意,假设同一个包括节点拥有多个进入和外出顺序流。 它就会同一时候含有分支和汇聚功能

    这时,网关会先汇聚全部拥有流程token的进入顺序流。 再依据条件推断结果为true的外出顺序流,为它们生成多条并行分支。

    包括网关图形

    并行网关显示为一个普通网关(菱形),内部包括一个圆圈图标。


    当 main config 中的 表达式 条件返回的结果为真时  运行 并行网关 

    结果为假时 运行 排他任务

    详细的 流程 这里就不介绍了


    事件网关

    事件网关描写叙述

    基于事件网关同意依据事件推断流向。

    网关的每一个外出顺序流都要连接到一个中间捕获事件。 当流程到达一个基于事件网关,网关会进入等待状态:会暂停运行。 与此同一时候,会为每一个外出顺序流创建相对的事件订阅。

    注意基于事件网关的外出顺序流和普通顺序流不同。这些顺序流不会真的"运行"。

    相反。它们让流程引擎去决定运行到基于事件网关的流程须要订阅哪些事件。

    要考虑下面条件:

    • 基于事件网关必须有两条或以上外出顺序流。

    • 基于事件网关后,仅仅能使用intermediateCatchEvent类型。 (activiti不支持基于事件网关后连接ReceiveTask。)

    • 连接到基于事件网关的intermediateCatchEvent仅仅能有一条进入顺序流。

    事件网关图形

    事件网关和其它BPMN网关一样显示成一个菱形, 内部包括指定图标。


    展开全文
  • activiti包含网关

    千次阅读 2019-01-12 09:19:22
    import org.activiti.engine.ProcessEngine; import org.activiti.engine.ProcessEngines; import org.activiti.engine.TaskService; import org.activiti.engine.... * 测试包含网关 * 特点:具有排他网关和并行网...
  • Activiti7工作流程引擎之网关
  • 网关和分支是流程图中相当重要的一环。毕竟一个流程不可能是一条直线走到底的,可能需要并行处理,也可能需要根据条件的不同选择对应的路由,网关和分支的作用正是在此。本文主要探索一下这几种网关的常用方法,以及...
  • 网关(Gateway)又称网间连接器、协议转换器。 举例:什么是网关 假设你的名字叫小不点(很小),你住在一个大院子里,你的邻居有很多小伙伴,父母是你的网关。当你想跟院子里的某个小伙伴玩,只要你在院子里大喊一声 ...
  • activiti中有四种网关:并行网关,排他网关包含网关,基于事件网关 排它网关: 内部是一个“X”图标,用来在流程中实现决策。 当流程执行到这个网关,所有外出顺序流都会被处理一遍。 其中条件解析为true的顺序...
  • 最近遇到了需要使用Acitivi的项目,研究了一个多月,记录一个之前遇到的问题:包含网关内的节点如何设置执行的先后顺序,通过网上查阅资料基本都答非所问,自己研究了一下,通过流程图来控制执行顺序但是动态设置...
  • 网关用来控制流程的流向 网关可以 消费 也可以 生成 token。网关显示成菱形图形,内部有有一个小图标。 图标表示网关的类型。基本分支首先 利用 流程变量 写个带有分支的一个基本流程流程图:部署流程文件://...
  • 网关 逻辑服务器 控制台客户端 网络协议 (lproto) 关于测试 启动网关,等待来自客户端或服务器的消息 启动服务器,连接到网关网关设置服务器并保存服务器fd 启动客户端,连接到网关并连接服务器,将其他消息...
  • SpringSecurityOAuth2-3认证授权陈亮制作:包含网关,认证授权服务,资源服务,feign远程调用服务和vue-element-admin(没完全实现,简化版vue-admin-template), 公共模块和服务发现中心服务;功能:认证授权,java代码实现...
  • 基于nacos的spring cloud微服务框架、集成认证授权、动态网关、分库分表、dubbo开箱即用。 个人博客地址: qq群: 602107221 1、 wotrd-auth: 认证授权服务 2、 wotrd-client: 客户端服务 3、 wotrd-dubbo: dubbo...
  • 【第十一篇】Flowable中的各种网关

    千次阅读 2022-04-04 16:28:37
    网关 网关用来控制流程的流向 1.排他网关   排他网关(exclusive gateway)(也叫异或网关 XOR gateway,或者更专业的,基于数据的排他网关 exclusive data-based gateway),用于对流程中的决策建模。当执行到达...
  • * 获取并行网关内的任务节点 */ private void getParallelGatewayInsideNode() { List<FlowElement> flowElements = (List<FlowElement>)bpmnModel.getMainProcess().getFlowElements(); FlowNode ...
  • 工作流引擎之十 网关

    2022-02-15 18:32:47
    三,包含网关 3.1流程定义 3.2 测试 四,课程总结 什么是工作流? 什么 activiti? 如何使用 activiti 开发? 一,排他网关 排他网关(也叫异或(XOR)网关,或叫基于数据的排他网关),用来在流程中实现...
  • activiti入门3排他网关 并行网管 包含网关 事件网关
  • 解决方案:审核节点采用包括网关包括网关可以是并行网关与排他网关的结合,各个节点并行,同时可以设置条件决定节点是否走),在审核节点前的flow中定义条件,注意假设条件为${net != null} 时,我们在动态表单...
  • 目录1网关作用是什么1.1 排他网关ExclusiveGateway1.1.1 什么是排他网关:1.1.2 流程定义1.1.3 测试1.2 并行网关ParallelGateway1.2.1 什么是并行网关1.2.3 流程定义1.2.3 并行网关案例1.3 包含网关InclusiveGateway...
  • activiti7的网关

    千次阅读 2021-01-05 23:10:53
    工作流 —activiti7网关 1. 排他网关  排他网关(也叫异或(XOR)网关,或叫基于数据的排他网关),用来在流程中实现决策。   当流程执行到这个网关,所有分支都会判断条件是否为true,如果为 true 则执行...
  • Activiti进阶-网关

    2021-08-24 11:10:08
    五、网关 网关用来控制流程的流向 5.1 排他网关ExclusiveGateway 5.1.1 什么是排他网关: 排他网关,用来在流程中实现决策。 当流程执行到这个网关,所有分支都会判断条件是否为true,如果为true则执行该...
  • 排他网关(exclusive gateway)(也叫异或网关 XOR gateway,或者更专业的,基于数据的排他网关 exclusive data-based gateway),用于对流程中的决策建模。当执行到达这个网关时,会按照所有出口顺序流定义的顺序对...
  • 本手册详细介绍了天玥运维安全网关包括用户管理、资源与授权、规则管理、帐号与密码管理、自动运维、工单管理、审计管理、系统管理各功能模块的使用方法,用户可参考本手册,对天玥运维安全网关进行各种管理配置。
  • Activity7学习4——网关

    2022-01-09 10:30:43
    文章目录排他网关(exclusiveGateway)并行网关(parallelGateway)包含网关 排他网关(exclusiveGateway) 排他网关(也叫异或(XOR)网关,或叫基于数据的排他网关),用来在流程中实现决策。当流程执行到这个...
  • FlowAble工作流网关

    千次阅读 2021-06-20 15:09:20
    所有的BPMN 2.0任务与网关都可以使用默认顺序流(default sequence flow)。只有当没有其他顺序流可以选择时,才会选择默认顺序流作为活动的出口顺序流。流程会忽略默认顺序流上的条件。 图示 默认顺序流用起点带...
  • 了解BEACON系列网关产品,不占PLC机架槽位,并且应用在大型PLC系统等场合,国内估计应用的不多,相似产品太广,可以代替prosoft或者ANYBUS

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 227,645
精华内容 91,058
关键字:

包含网关

友情链接: CBF.rar