复习步骤18- 22 BPMN任务（3）任务与流程监听器

I、其他任务：

• 手工任务  --表示不需要任何的程序或者流程引擎的驱动，就会自动执行，和抛出事件一样，都是自动的，在activiti会自动记录一下历史数据就完事了
• 接收任务: RuntimeService.trigger --不会自动执行，会一直等待外界的通知，和捕获事件一样，用RuntimeService.trigger触发它，让它接受通知，继续往前走
• 邮件任务 -- 不是重点，因为可以在上节课ServiceTask中调邮件API接口，同样可完成发邮件操作

 

• Mule任务 （会在之后的Mule章节讲）
• 业务规则任务 （会之后在规则引擎章节讲）
• 

 

 

II.任务监听器的三种指定方式

   指定的方式：一、使用class指定监听器  -- 课程建议用这个，

 

          1.1 测试class指定监听器 参照如图 新建 class指定监听器 的 流程class-task-listener.bpmn,和自定义class监听器类 PropertyConfigListener 需实现TaskListener接口

                 新建class-task-listener.bpmn

                  

                    新建自定义监听器类 PropertyConfigListener 实现TaskListener接口

                 PropertyConfigListener.java

               package com.xiangshuai.act.c21;

 

import org.activiti.engine.delegate.DelegateTask;

import org.activiti.engine.delegate.TaskListener;

 

public class PropertyConfigListener implements TaskListener {

    private static final long serialVersionUID = 1L;

 

    @Override

    public void notify(DelegateTask task) {

           System.out.println("测试在"+task.getName()+" create时就触发自定义的监听器"); 

    }

 

}

        1.2修改 class-task-listener.bpmn，将我们监听器类指定给 User Task流程，并指定此 监听器触发时机 为任务创建时间触发

   

      1.3 测试方法

  /**

      * 任务监听器 指定的方式：一、使用class指定监听器

     * 测试class指定监听器,监听器触发时机 为任务创建时间触发

     */

    public  static void testPropertyConfigListener(){

        ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();

         // 存储服务

         RepositoryService rs = engine.getRepositoryService();

         // 运行时服务

         RuntimeService runService = engine.getRuntimeService();

         // 任务服务

         TaskService taskService = engine.getTaskService();

         Deployment dep = rs.createDeployment().addClasspathResource("class-task-listener.bpmn").deploy();

         ProcessDefinition pd = rs.createProcessDefinitionQuery().deploymentId(dep.getId()).singleResult();

        

         // 启动流程

         ProcessInstance pi = runService.startProcessInstanceById(pd.getId());

        

       /*  class-task-listener.bpmn

         <userTask id="usertask1" name="User Task">

             <extensionElements>

                  <activiti:taskListener event="create"

                      class="com.xiangshuai.act.c21.PropertyConfigListener">

                  </activiti:taskListener>

              </extensionElements>   

         </userTask>

         在启动流程，创建User Task 会触发com.xiangshuai.act.c21.PropertyConfigListener 监听器，执行PropertyConfigListener、

         的方法 notify 输出  System.out.println("测试在"+task.getName()+" create时就触发自定义的监听器")--测试在User Task create时就触发自定义的监听器; 

         */

         //

     }

 

 

 

         二、使用expression指定监听器

           

2.1 测试expression指定监听器

 参照如图 新建 expression指定监听器 的 流程expression-task-listener.bpmn,和自定义class类 ExpressionBean 需实现 Serializable序列化即可

              新建   expression-task-listener.bpmn

 

     新建 ExpressionBean  实现 Serializable序列化，并参照上上图 创建testBean(DelegateTask task) 方法

      ExpressionBean.java

  package com.xiangshuai.act.c21;

 

import java.io.Serializable;

 

import org.activiti.engine.delegate.DelegateTask;

 

public class ExpressionBean implements Serializable {

    private static final long serialVersionUID = 1L;

    /*

    userTask id="usertask1" name="User Task">

        <extensionElements>

             <activiti:taskListener event="create"

                 expression="${myBean.testBean(task)}">

             </activiti:taskListener>

         </extensionElements>   

    </userTask>

    在流程创建时触发监听器，执行expression ，执行${myBean.testBean(task)} 传入参数task对象为监听的流程任务对象

    */

    public void testBean(DelegateTask task){

       System.out.println("测试expression指定监听器在"+task.getName()+" create时就触发的监听器");

    }

   

 

}

2.2 修改   expression-task-listener.bpmn

 

2.3 测试方法

/**

     * 任务监听器 指定的方式： 二、使用expression指定监听器

    * 测试expression指定监听器,监听器触发时机 为任务创建时间触发

    */

    public  static void testExpressionBean(){

       ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();

       // 存储服务

       RepositoryService rs = engine.getRepositoryService();

        // 运行时服务

        RuntimeService runService = engine.getRuntimeService();

        TaskService taskService = engine.getTaskService();

       Deployment dep = rs.createDeployment().addClasspathResource("expression-task-listener.bpmn").deploy();

       ProcessDefinition pd = rs.createProcessDefinitionQuery().deploymentId(dep.getId()).singleResult();

        Map<String, Object> vars=new HashMap<String, Object>();

        vars.put("myBean",new ExpressionBean()); //bpmn 中用的key 就是 myBean

         //bpmn 中用到 ${juel自定义类，必须让activiti能识别}，所以在启动流程时需用ByKey，将带自定义类的map作为参数启动流程

        ProcessInstance pi = runService.startProcessInstanceByKey(pd.getKey(), vars);

       /*  expression-task-listener.bpmn 中

         <userTask id="usertask1" name="User Task">

           <extensionElements>

                <activiti:taskListener event="create"

                    expression="${myBean.testBean(task)}">

                </activiti:taskListener>

            </extensionElements>

    </userTask>

         在启动流程，创建User Task 会触发执行JUEL表达式 "${myBean.testBean(task)}"，执行myBean即 ExpressionBean的testBean(DelegateTask task)

         的方法  输出  System.out.println("测试expression指定监听器在"+task.getName()+" create时就触发的监听器")--测试expression指定监听器在User Task create时就触发的监听器; 

        */

       //

    }

 

   三、使用delegateExpression 指定监听器

  

 

3.1测试delegateExpression 指定监听器

 参照如图新建delegateExpression指定监听器 的 流程delegateExpression-task-listener.bpmn,和自定义class类 DelegateBean 需实现 Serializable序列化，并实现TaskListener

              新建   delegateExpression-task-listener.bpmn

              

              新建DelegateBean

package com.xiangshuai.act.c21;

 

import java.io.Serializable;

 

import org.activiti.engine.delegate.DelegateTask;

import org.activiti.engine.delegate.TaskListener;

 

public class DelegateBean implements Serializable, TaskListener {

         private static final long serialVersionUID = 1L;

 

         @Override

         public void notify(DelegateTask task) {

                  System.out.println("测试delegateExpression指定监听器在"+task.getName()+" create时就触发的监听器");

         }

 

}

        3.2 修改 delegateExpression-task-listener.bpmn

 

3.3 测试方法

/**

     * 任务监听器 指定的方式三： 使用delegateExpression 指定监听器

     * 测试delegateExpression指定监听器,监听器触发时机 为任务创建时间触发

     */

    public  static void testDelegateExpression(){

       ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();

       // 存储服务

       RepositoryService rs = engine.getRepositoryService();

       // 运行时服务

       RuntimeService runService = engine.getRuntimeService();

       TaskService taskService = engine.getTaskService();

       Deployment dep = rs.createDeployment().addClasspathResource("delegateExpression-task-listener.bpmn").deploy();

       ProcessDefinition pd = rs.createProcessDefinitionQuery().deploymentId(dep.getId()).singleResult();

       Map<String, Object> vars=new HashMap<String, Object>();

       vars.put("myDelegate",new DelegateBean()); //bpmn 中用的key 就是 myDelegate

       //bpmn 中用到 ${juel自定义类，必须让activiti能识别}，所以在启动流程时需用ByKey，将带自定义类的map作为参数启动流程

      ProcessInstance pi = runService.startProcessInstanceByKey(pd.getKey(), vars);

       /*  delegateExpression-task-listener.bpmn 中

         <userTask id="usertask1" name="User Task">

            <extensionElements>

                <activiti:taskListener event="create"

                    expression="${myDelegate}">

                </activiti:taskListener>

            </extensionElements>

    </userTask>

    </userTask>

         在启动流程，创建User Task 会触发执行JUEL表达式 "${myDelegate}"，执行myDelegate即DelegateBean重写的notify

         的方法  输出  System.out.println("测试delegateExpression指定监听器在"+task.getName()+" create时就触发的监听器")--测试delegateExpression指定监听器在User Task create时就触发的监听器; 

        */

       //

    }

 

III.监听器的触发  -- 触发时机,1.任务创建时间触发 2.指定任务代理人事件触发3.任务完成时间触发

   下图中的 自定义三个calss类都必须实现TaskListener

       3.1测试监听器的触发  -- 触发时机, 参照上图 新建含有 1. 任务创建时间触发的TaskListenerA, 2.指定任务代理人事件触发TaskListenerB,3. 任务完成时间触发TaskListenerC 三个自定义类，任务监听器 监听方式均采用class指定监听器 的。

       新建triggered-task-listener.bpmn

 

 

         新建TaskListenerA, TaskListenerB, TaskListenerC 三个自定义类均是class方式监听，所以需全部实现TaskListener

        TaskListenerA.java

package com.xiangshuai.act.c21;

 

import org.activiti.engine.delegate.DelegateTask;

import org.activiti.engine.delegate.TaskListener;

 

public class TaskListenerA implements TaskListener {

         private static final long serialVersionUID = 1L;

 

         @Override

         public void notify(DelegateTask arg0) {

                  System.out.println("流程任务创建时触发的");

         }

 

}

        TaskListenerB.java

package com.xiangshuai.act.c21;

 

import org.activiti.engine.delegate.DelegateTask;

import org.activiti.engine.delegate.TaskListener;

 

public class TaskListenerB implements TaskListener {

         private static final long serialVersionUID = 1L;

 

         @Override

         public void notify(DelegateTask arg0) {

                  System.out.println("指定代理人时触发的");

         }

 

}

        TaskListenerC.java

package com.xiangshuai.act.c21;

 

import org.activiti.engine.delegate.DelegateTask;

import org.activiti.engine.delegate.TaskListener;

 

public class TaskListenerC implements TaskListener {

         private static final long serialVersionUID = 1L;

 

         @Override

         public void notify(DelegateTask arg0) {

                  System.out.println("完成任务的时候触发的");

         }

 

}

       3.2 参照上上图 修改 triggered-task-listener.bpmn

       3.3测试方法

/**

     * 测试监听器的触发  -- 触发时机, 参照上图 新建含有 1. 任务创建时间触发的TaskListenerA, 2.指定任务代理人事件触发TaskListenerB,

     * 3. 任务完成时间触发TaskListenerC 三个自定义类，任务监听器 监听方式均采用class指定监听器 的。

     * 代理人在  triggered-task-listener.bpmn <userTask id="usertask1" name="User Task" activiti:assignee="crazyit">

         <extensionElements>

                <activiti:taskListener event="create"

                中已指定

     */

    public  static void testTriggeredTaskListener(){

       ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();

       // 存储服务

       RepositoryService rs = engine.getRepositoryService();

       // 运行时服务

       RuntimeService runService = engine.getRuntimeService();

       TaskService taskService = engine.getTaskService();

       Deployment dep = rs.createDeployment().addClasspathResource("triggered-task-listener.bpmn").deploy();

       ProcessDefinition pd = rs.createProcessDefinitionQuery().deploymentId(dep.getId()).singleResult();

       //启动流程

       ProcessInstance pi = runService.startProcessInstanceById(pd.getId());

       /*

       输出结果   TaskListenerA,TaskListenerB的notify方法

       指定代理人时触发的

                流程任务创建时触发的

       */

       Task task = taskService.createTaskQuery().processInstanceId(pi.getId()).singleResult();

       taskService.complete(task.getId());//完成usertask1节点触发complete事件 输出TaskListenerC的notify方法 完成任务的时候触发的

 

 

 

       

 

IIII.属性注入

        这个属性在下图自定义类中必须申明，并提供set方法让activiti将StringValue="creayit"进行注入，而且这个属性只能是FixedValue类型

 

 

 4.1 新建 property-injection.bpmn, PropertyInjection.java-- 申明类型为FixedValue的userName属性，并提供set方法, 让activiti可以将StringValue="creayit"进行注入，另外如图这个PropertyInjection是 class监听器，所以必须实现TaskListener

         新建property-injection.bpmn

     

    新建PropertyInjection.java-- 申明类型为FixedValue的userName属性，并提供set方法

                PropertyInjection.java

package com.xiangshuai.act.c21;

 

import org.activiti.engine.delegate.DelegateTask;

import org.activiti.engine.delegate.TaskListener;

import org.activiti.engine.impl.el.FixedValue;

 

public class PropertyInjection implements TaskListener{

    private FixedValue userName;

 

    public void setUserName(FixedValue userName) {

       System.out.println("在property-injection.bpmn中定义好这样activiti可以将StringValue=进行注入userName= "+userName.getExpressionText());

       this.userName = userName;

    }

 

    @Override

    public void notify(DelegateTask task) {

          System.out.println("流程创建触发监听时已有userName= "+this.userName.getExpressionText());

    }

     

}

        4.2 按上上图 修改 property-injection.bpmn

 

测试方法

/**

     * 任务监听器 指定的方式：一、使用class指定监听器

    * 测试class指定监听器,监听器触发时机 为任务创建时间触发

    * 新建 property-injection.bpmn, PropertyInjection.java-- 申明类型为FixedValue的userName属性，并提供set方法,

    *  让activiti可以将StringValue="creayit"进行注入，

    * 另外如图这个PropertyInjection是 class监听器，所以必须实现TaskListener

    */

   public  static void testPropertyInjection(){

    ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();

        // 存储服务

        RepositoryService rs = engine.getRepositoryService();

        // 运行时服务

        RuntimeService runService = engine.getRuntimeService();

        // 任务服务

        TaskService taskService = engine.getTaskService();

        Deployment dep = rs.createDeployment().addClasspathResource("property-injection.bpmn").deploy();

        ProcessDefinition pd = rs.createProcessDefinitionQuery().deploymentId(dep.getId()).singleResult();

       

        // 启动流程

        ProcessInstance pi = runService.startProcessInstanceById(pd.getId());

       

      /* property-injection.bpmn

         <userTask id="usertask1" name="User Task">

         <extensionElements>

                <activiti:taskListener event="create"

                    class="com.xiangshuai.act.c21.PropertyInjection">

                    <activiti:field name="userName" stringValue="creayit"/>

                </activiti:taskListener>

            </extensionElements>   

    </userTask>

        在启动流程，创建User Task 会触发com.xiangshuai.act.c21.PropertyInjection 监听器，先执行setUserName方法进行属性注入，输出

        在property-injection.bpmn中定义好这样activiti可以将StringValue=进行注入userName= creayit

        再执行PropertyInjection

        的方法 notify 输出     --流程创建触发监听时已有userName= creayit

        */

        //

 

        总测试方法类

ListenerTest.java

package com.xiangshuai.act.c21;

 

import java.util.HashMap;

import java.util.Map;

 

import org.activiti.engine.ProcessEngine;

import org.activiti.engine.ProcessEngines;

import org.activiti.engine.RepositoryService;

import org.activiti.engine.RuntimeService;

import org.activiti.engine.TaskService;

import org.activiti.engine.delegate.DelegateTask;

import org.activiti.engine.repository.Deployment;

import org.activiti.engine.repository.ProcessDefinition;

import org.activiti.engine.runtime.ProcessInstance;

import org.activiti.engine.task.Task;

import org.activiti.engine.task.TaskQuery;

 

 

/**

 * @author lqx

 * 任务监听器

      指定的方式：一、使用class指定监听器  -- 课程建议用这个， 二、使用expression指定监听器,  三、使用delegateExpression 指定监听器

   属性注入

   流程监听器

   

    文件在 E:\学习文档子目录压缩\框架\工作流引擎\Activiti6.0\window\复习步骤18- 22 BPMN任务（3）任务与流程监听器

 * 或 我的网盘\我的笔记\学习文档子目录压缩\框架\工作流引擎\Activiti6.0\window\复习步骤18- 22 BPMN任务（3）任务与流程监听器

 */

public class ListenerTest {

         public static void main(String[] args) {

            //testPropertyConfigListener();

                  //testExpressionBean();

                  //testDelegateExpression();

                  //testTriggeredTaskListener();

                 

                  testPropertyInjection();

         }

          

   

         /**

     * 任务监听器 指定的方式：一、使用class指定监听器

    * 测试class指定监听器,监听器触发时机 为任务创建时间触发

    */

   public  static void testPropertyConfigListener(){

      ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();

        // 存储服务

        RepositoryService rs = engine.getRepositoryService();

        // 运行时服务

        RuntimeService runService = engine.getRuntimeService();

        // 任务服务

        TaskService taskService = engine.getTaskService();

        Deployment dep = rs.createDeployment().addClasspathResource("class-task-listener.bpmn").deploy();

        ProcessDefinition pd = rs.createProcessDefinitionQuery().deploymentId(dep.getId()).singleResult();

       

        // 启动流程

        ProcessInstance pi = runService.startProcessInstanceById(pd.getId());

       

      /*  class-task-listener.bpmn

        <userTask id="usertask1" name="User Task">

                  <extensionElements>

                       <activiti:taskListener event="create"

                           class="com.xiangshuai.act.c21.PropertyConfigListener">

                       </activiti:taskListener>

                   </extensionElements>   

        </userTask>

        在启动流程，创建User Task 会触发com.xiangshuai.act.c21.PropertyConfigListener 监听器，执行PropertyConfigListener、

        的方法 notify 输出  System.out.println("测试在"+task.getName()+" create时就触发自定义的监听器")--测试在User Task create时就触发自定义的监听器; 

        */

        //

    }

 

   

    /**

     * 任务监听器 指定的方式： 二、使用expression指定监听器

    * 测试expression指定监听器,监听器触发时机 为任务创建时间触发

    */

    public  static void testExpressionBean(){

             ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();

             // 存储服务

             RepositoryService rs = engine.getRepositoryService();

              // 运行时服务

        RuntimeService runService = engine.getRuntimeService();

        TaskService taskService = engine.getTaskService();

             Deployment dep = rs.createDeployment().addClasspathResource("expression-task-listener.bpmn").deploy();

             ProcessDefinition pd = rs.createProcessDefinitionQuery().deploymentId(dep.getId()).singleResult();

        Map<String, Object> vars=new HashMap<String, Object>();

                   vars.put("myBean",new ExpressionBean()); //bpmn 中用的key 就是 myBean

                   //bpmn 中用到 ${juel自定义类，必须让activiti能识别}，所以在启动流程时需用ByKey，将带自定义类的map作为参数启动流程

                   ProcessInstance pi = runService.startProcessInstanceByKey(pd.getKey(), vars);

             /*  expression-task-listener.bpmn 中

         <userTask id="usertask1" name="User Task">

           <extensionElements>

                <activiti:taskListener event="create"

                    expression="${myBean.testBean(task)}">

                </activiti:taskListener>

            </extensionElements>

    </userTask>

         在启动流程，创建User Task 会触发执行JUEL表达式 "${myBean.testBean(task)}"，执行myBean即 ExpressionBean的testBean(DelegateTask task)

         的方法  输出  System.out.println("测试expression指定监听器在"+task.getName()+" create时就触发的监听器")--测试expression指定监听器在User Task create时就触发的监听器; 

              */

             //

    }

    /**

     * 任务监听器 指定的方式三： 使用delegateExpression 指定监听器

     * 测试delegateExpression指定监听器,监听器触发时机 为任务创建时间触发

     */

    public  static void testDelegateExpression(){

             ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();

             // 存储服务

             RepositoryService rs = engine.getRepositoryService();

             // 运行时服务

             RuntimeService runService = engine.getRuntimeService();

             TaskService taskService = engine.getTaskService();

             Deployment dep = rs.createDeployment().addClasspathResource("delegateExpression-task-listener.bpmn").deploy();

             ProcessDefinition pd = rs.createProcessDefinitionQuery().deploymentId(dep.getId()).singleResult();

             Map<String, Object> vars=new HashMap<String, Object>();

             vars.put("myDelegate",new DelegateBean()); //bpmn 中用的key 就是 myDelegate

             //bpmn 中用到 ${juel自定义类，必须让activiti能识别}，所以在启动流程时需用ByKey，将带自定义类的map作为参数启动流程

             ProcessInstance pi = runService.startProcessInstanceByKey(pd.getKey(), vars);

             /*  delegateExpression-task-listener.bpmn 中

         <userTask id="usertask1" name="User Task">

            <extensionElements>

                <activiti:taskListener event="create"

                    expression="${myDelegate}">

                </activiti:taskListener>

            </extensionElements>

    </userTask>

    </userTask>

         在启动流程，创建User Task 会触发执行JUEL表达式 "${myDelegate}"，执行myDelegate即DelegateBean重写的notify

         的方法  输出  System.out.println("测试delegateExpression指定监听器在"+task.getName()+" create时就触发的监听器")--测试delegateExpression指定监听器在User Task create时就触发的监听器; 

              */

             //

    }

    /**

     * 测试监听器的触发  -- 触发时机, 参照上图 新建含有 1. 任务创建时间触发的TaskListenerA, 2.指定任务代理人事件触发TaskListenerB,

     * 3. 任务完成时间触发TaskListenerC 三个自定义类，任务监听器 监听方式均采用class指定监听器 的。

     * 代理人在  triggered-task-listener.bpmn <userTask id="usertask1" name="User Task" activiti:assignee="crazyit">

         <extensionElements>

                <activiti:taskListener event="create"

                中已指定

     */

    public  static void testTriggeredTaskListener(){

            

             ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();

             // 存储服务

             RepositoryService rs = engine.getRepositoryService();

             // 运行时服务

             RuntimeService runService = engine.getRuntimeService();

             TaskService taskService = engine.getTaskService();

             Deployment dep = rs.createDeployment().addClasspathResource("triggered-task-listener.bpmn").deploy();

             ProcessDefinition pd = rs.createProcessDefinitionQuery().deploymentId(dep.getId()).singleResult();

             //启动流程

             ProcessInstance pi = runService.startProcessInstanceById(pd.getId());

             /*

             输出结果   TaskListenerA,TaskListenerB的notify方法

             指定代理人时触发的

                流程任务创建时触发的

             */

             Task task = taskService.createTaskQuery().processInstanceId(pi.getId()).singleResult();

             taskService.complete(task.getId());//完成usertask1节点触发complete事件 输出TaskListenerC的notify方法 完成任务的时候触发的

    }

    

   

         /**

     * 任务监听器 指定的方式：一、使用class指定监听器

    * 测试class指定监听器,监听器触发时机 为任务创建时间触发

    * 新建 property-injection.bpmn, PropertyInjection.java-- 申明类型为FixedValue的userName属性，并提供set方法,

    *  让activiti可以将StringValue="creayit"进行注入，

    * 另外如图这个PropertyInjection是 class监听器，所以必须实现TaskListener

    */

   public  static void testPropertyInjection(){

      ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();

        // 存储服务

        RepositoryService rs = engine.getRepositoryService();

        // 运行时服务

        RuntimeService runService = engine.getRuntimeService();

        // 任务服务

        TaskService taskService = engine.getTaskService();

        Deployment dep = rs.createDeployment().addClasspathResource("property-injection.bpmn").deploy();

        ProcessDefinition pd = rs.createProcessDefinitionQuery().deploymentId(dep.getId()).singleResult();

       

        // 启动流程

        ProcessInstance pi = runService.startProcessInstanceById(pd.getId());

       

      /* property-injection.bpmn

         <userTask id="usertask1" name="User Task">

         <extensionElements>

                <activiti:taskListener event="create"

                    class="com.xiangshuai.act.c21.PropertyInjection">

                    <activiti:field name="userName" stringValue="creayit"/>

                </activiti:taskListener>

            </extensionElements>   

    </userTask>

        在启动流程，创建User Task 会触发com.xiangshuai.act.c21.PropertyInjection 监听器，先执行setUserName方法进行属性注入，输出

        在property-injection.bpmn中定义好这样activiti可以将StringValue=进行注入userName= creayit

        再执行PropertyInjection

        的方法 notify 输出     --流程创建触发监听时已有userName= creayit

        */

        //

    }

}

 

 

IIIII.流程监听器   --和任务监听器很像（就是换个activiti标签而已，任务监听器是<activiti:taskListener 流程监听器是<activiti: executionListener） ，指定方式也是如下三种