1. //获取流程引擎  
2.     ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();  
3.       
4.     @Test  
5.     public void deployFlow(){  
6.           
7.         //获取仓库服务对象  
8.         RepositoryService repositoryService = processEngine.getRepositoryService();  
9.           
10.         InputStream in = this.getClass().getResourceAsStream("/MyProcess11.zip");  
11.         ZipInputStream zipInputStream = new ZipInputStream(in);  
12.           
13.         Deployment dm = repositoryService.createDeployment()  
14.                                             .name("学生请假")  
15.                                             .addZipInputStream(zipInputStream)  
16.                                             .deploy();  
17.           
18.         System.out.println("id:"+dm.getId()+",name:"+dm.getName());  
19.     }  

1. /** 
2.      * 启动流程 并完成 提交 
3.      */  
4.     @Test  
5.     public void startProcessAndComp(){  
6.           
7.         RuntimeService runtimeService = processEngine.getRuntimeService();  
8.         ProcessInstance pi = runtimeService.startProcessInstanceByKey("leave");  
9.           
10.         System.out.println("id:"+pi.getId()+",流程实例ID:"+pi.getProcessInstanceId()+",流程定义ID:"+pi.getProcessDefinitionId());  
11.           
12.         TaskService taskService = processEngine.getTaskService();  
13.           
14.         //通过流程实例ID获取任务对象  
15.         Task task = taskService.createTaskQuery()  
16.                             .processInstanceId(pi.getProcessInstanceId())  
17.                             .singleResult();  
18.         System.out.println("taskID:"+task.getId()+",name:"+task.getName());  
19.           
20.         Map<String, Object> paramMap = new HashMap<String, Object>();  
21.         //设置流程变量day=3  
22.         paramMap.put("day", 3);  
23.         //提交任务的时候传入流程变量  
24.         taskService.complete(task.getId(), paramMap);  
25.           
26.         //查询任务  
27.         task = taskService.createTaskQuery()  
28.                 .processInstanceId(pi.getProcessInstanceId())  
29.                 .singleResult();  
30.           
31.         //如果任务对象为空,则流程执行结束  
32.         if (task != null) {  
33.             System.out.println("taskID:"+task.getId()+",name:"+task.getName());  
34.         } else {  
35.             System.out.println("任务执行完毕");  
36.         }  
37.     }  

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

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

1. /** 
2.  * 提交任务 
3.  */  
4. @Test  
5. public void completeTask(){  
6.     TaskService taskService = processEngine.getTaskService();  
7.     taskService.complete("1707");  
8. }  

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

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

排他网关图形

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

1. //获取流程引擎  
2.     ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();  
3.       
4.     @Test  
5.     public void deployFlow2(){  
6.           
7.         //获取仓库服务对象  
8.         RepositoryService repositoryService = processEngine.getRepositoryService();  
9.           
10.         InputStream in = this.getClass().getResourceAsStream("/exclusiveGateway.zip");  
11.         ZipInputStream zipInputStream = new ZipInputStream(in);  
12.           
13.         Deployment dm = repositoryService.createDeployment()  
14.                                             .name("学生请假")  
15.                                             .addZipInputStream(zipInputStream)  
16.                                             .deploy();  
17.           
18.         System.out.println("id:"+dm.getId()+",name:"+dm.getName());  
19.     }  

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

1. id:2201,name:学生请假  

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

1. id:2501,name:学生请假  

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

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

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

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

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

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

1. @Test  
2.     public void deployFlow3() {  
3.   
4.         // 获取仓库服务对象  
5.         RepositoryService repositoryService = processEngine  
6.                 .getRepositoryService();  
7.   
8.         InputStream in = this.getClass().getResourceAsStream("/Parallel.zip");  
9.         ZipInputStream zipInputStream = new ZipInputStream(in);  
10.   
11.         Deployment dm = repositoryService.createDeployment().name("并行网关")  
12.                 .addZipInputStream(zipInputStream).deploy();  
13.   
14.         System.out.println("id:" + dm.getId() + ",name:" + dm.getName());  
15.   
16.         RuntimeService runtimeService = processEngine.getRuntimeService();  
17.         ProcessInstance pi = runtimeService  
18.                 .startProcessInstanceByKey("parallel");  
19.   
20.         System.out.println("id:" + pi.getId() + ",流程实例ID:"  
21.                 + pi.getProcessInstanceId() + ",流程定义ID:"  
22.                 + pi.getProcessDefinitionId());  
23.   
24.     }  

1. id:2801,name:并行网关  

1. id:2901,流程实例ID:2901,流程定义ID:parallel:1:2804  

1. /** 
2.      * 启动流程 并完成 提交 
3.      */  
4.     @Test  
5.     public void startProcessAndComp3() {  
6.   
7.         TaskService taskService = processEngine.getTaskService();  
8.   
9.         // 查询任务  
10.         Task task = taskService.createTaskQuery().processInstanceId("2901").singleResult();  
11.   
12.         // 如果任务对象为空,则流程执行结束  
13.         if (task != null) {  
14.             System.out.println("taskID:" + task.getId() + ",name:"  
15.                     + task.getName());  
16.         } else {  
17.             System.out.println("任务执行完毕");  
18.         }  
19.   
20.         // 通过流程实例ID获取任务对象  
21.         task = taskService.createTaskQuery().processInstanceId("2901").singleResult();  
22.         System.out.println("taskID:" + task.getId() + ",name:" + task.getName());  
23.   
24.         // 提交任务  
25.         taskService.complete(task.getId());  
26.   
27.     }  

1. taskID:2904,name:项目启动  
2. taskID:2904,name:项目启动  

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

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

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

并行网关显示为一个普通网关（菱形），内部包含一个圆圈图标。

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

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

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