关于学习Activiti的过程：直接使用官方文档进行学习，希望会有好的效果。
 一.首先是现在官方的包，在其中拿到activiti-explorer.war包，将其部署到tomcate下进行访问，看看需要新学习的是一个什么东东。了解一个大概，在这其中可以看看随意别人博客中写的对Activiti的理解。
 二.进入学习：
 介绍ProcessEngineConfiguration的初始化，首先可以将其写为一个activiti.cfg.xml的配置文件，配置其一系列的属性。当然这一切都可以在java中写一个类去初始化。当然我们还可以交给spring，依赖注入帮我们初始化。
 1).java初始化如下：可以用不同的初始化类或者将配置信息放到(activiti.cfg.xml)进行初始化
 /*ProcessEngineConfiguration.createProcessEngineConfigurationFromResourceDefault();
 ProcessEngineConfiguration.createProcessEngineConfigurationFromResource(String resource);
 ProcessEngineConfiguration.createProcessEngineConfigurationFromResource(String resource, String beanName);
 ProcessEngineConfiguration.createProcessEngineConfigurationFromInputStream(InputStream inputStream);
 ProcessEngineConfiguration.createProcessEngineConfigurationFromInputStream(InputStream inputStream, String beanName);

 ProcessEngineConfiguration.createStandaloneProcessEngineConfiguration();
 ProcessEngineConfiguration.createStandaloneInMemProcessEngineConfiguration();*/

 ProcessEngine processEngine = ProcessEngineConfiguration.createStandaloneInMemProcessEngineConfiguration()
   .setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_FALSE)
   .setJdbcUrl("jdbc:h2:mem:my-own-db;DB_CLOSE_DELAY=1000")
   .setAsyncExecutorEnabled(true)
   .setAsyncExecutorActivate(false)
   .buildProcessEngine();
   
 2).spring 配置如下：
 <beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans   http://www.springframework.org/schema/beans/spring-beans.xsd">


   <bean id="processEngineConfiguration" class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">


 <property name="jdbcUrl" value="jdbc:h2:mem:activiti;DB_CLOSE_DELAY=1000" />
 <property name="jdbcDriver" value="org.h2.Driver" />
 <property name="jdbcUsername" value="sa" />
 <property name="jdbcPassword" value="" />


 <property name="databaseSchemaUpdate" value="true" />


 <property name="jobExecutorActivate" value="false" />
 <property name="asyncExecutorEnabled" value="true" />
 <property name="asyncExecutorActivate" value="false" />


 <property name="mailServerHost" value="mail.my-corp.com" />
 <property name="mailServerPort" value="5025" />
   </bean>


 </beans>

 三.构造ProcessEngine Bean(有多个类可以创建，适用于不同的环境中)
 activiti.cfg,必须包含一个xml bean id“processEngineConfiguration”       <bean id="processEngineConfiguration" class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">

 org.activiti.engine.impl.cfg。StandaloneProcessEngineConfiguration:流程引擎中使用一个独立的方法。Activiti会照顾的事务。默认情况下,数据库才会在发动机启动时检查(和抛出异常,如果没有Activiti模式或模式版本是错误的)。　　　　
 org.activiti.engine.impl.cfg。StandaloneInMemProcessEngineConfiguration:这是一个方便的类进行单元测试。Activiti会照顾的事务。默认使用一个H2内存数据库。时将创建和删除数据库引擎靴子和关闭。
 当使用这个,可能不需要额外的配置(除了当使用例如作业执行器或邮件功能)。　　　　
 org.activiti.spring.SpringProcessEngineConfiguration:当使用流程引擎中使用Spring的环境。有关更多信息,请参见Spring集成部分。　　　　
 org.activiti.engine.impl.cfg。JtaProcessEngineConfiguration:使用引擎运行时在独立模式下,JTA事务。

 四.数据库的配置：有两种方式初始化数据库信息，avtiviti会选择直接用jdbc ，支持的数据库有 h2 mysql oracle postgres db2 mssql
 1).构建基于提供的数据源JDBC属性将会默认MyBatis连接池设置。下面的属性可以被设置为调整连接池(取自MyBatis文档):
 jdbcMaxActiveConnections: 活动连接,连接池的数量最多可以包含在任何时间。默认的是10
 jdbcMaxIdleConnections: 空闲连接,连接池的数量最多可以包含在任何时间。
 jdbcMaxCheckoutTime: 以毫秒为单位的时间可以检查从连接池中连接之前,有力地回来了。默认是20000(20秒)。
 jdbcMaxWaitTime: 这是低水平设置,使池中有机会打印日志的连接状态和re-attempt收购情况采取不同寻常的长(为了避免失败永远默默地如果池配置错误的)默认是20000(20秒)。
 2).还有就是使用dataSource
 <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" >
   <property name="driverClassName" value="com.mysql.jdbc.Driver" />
   <property name="url" value="jdbc:mysql://localhost:3306/activiti" />
   <property name="username" value="activiti" />
   <property name="password" value="activiti" />
   <property name="defaultAutoCommit" value="false" />
 </bean>


 <bean id="processEngineConfiguration" class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">


 <property name="dataSource" ref="dataSource" />
 ...
 两种方式都可以使用以下属性：
 databaseType:一般不需要指定这个属性是自动从数据库连接元数据分析。应该只被指定,以防自动检测失败。可能的值:{ h2、mysql、甲骨文、postgres,该软件,db2 }。这个属性是必需的,当不使用默认的H2数据库。
 这个设置将决定哪个创建/删除脚本将使用和查询。请查看受支持的数据库部分支持哪些类型的概述。　　　　
 databaseSchemaUpdate:允许设置策略来处理流程引擎启动和关闭的数据库模式。　
 false(缺省值):检查DB模式对库的版本流程引擎时被创建并抛出一个异常,如果版本不匹配。　
 true:在构建流程引擎,执行检查和更新模式的性能
 create-drop:创建模式时,流程引擎时被创建和滴模式流程引擎被关闭。


 当然datasource可以选择jndi  使用如下：
  
 1.将rest项目（也在下周的包内）activiti-webapp-explorer2/src/main/webapp/WEB-INF/activiti-standalone-context.xml 和 activiti-webapp-rest2/src/main/resources/activiti-context.xml 下的dbProperties 和 dataSource 这两个Bean删除 增加
 <bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
 <property name="jndiName" value="java:comp/env/jdbc/activitiDB"/>
 </bean>
 接下来,我们需要添加上下文。xml文件包含默认H2配置。这些将由您的JNDI配置覆盖,如果它的存在。Activiti Explorer,替换文件activiti-webapp-explorer2 / src / main / webapp / meta - inf /上下文。xml包含以下:
 <Context antiJARLocking="true" path="/activiti-explorer2">
 <Resource auth="Container"
   name="jdbc/activitiDB"
   type="javax.sql.DataSource"
   scope="Shareable"
   description="JDBC DataSource"
   url="jdbc:h2:mem:activiti;DB_CLOSE_DELAY=1000"
   driverClassName="org.h2.Driver"
   username="sa"
   password=""
   defaultAutoCommit="false"
   initialSize="5"
   maxWait="5000"
   maxActive="120"
   maxIdle="5"/>
 </Context>

 Activiti休息webapp,添加activiti-webapp-rest2 / src / main / webapp / meta - inf /上下文。xml包含以下:
 <?xml version="1.0" encoding="UTF-8"?>
 <Context antiJARLocking="true" path="/activiti-rest2">
 <Resource auth="Container"
   name="jdbc/activitiDB"
   type="javax.sql.DataSource"
   scope="Shareable"
   description="JDBC DataSource"
   url="jdbc:h2:mem:activiti;DB_CLOSE_DELAY=-1"
   driverClassName="org.h2.Driver"
   username="sa"
   password=""
   defaultAutoCommit="false"
   initialSize="5"
   maxWait="5000"
   maxActive="120"
   maxIdle="5"/>
 </Context>

 五.配置数据库中Activiti需要用到的表
 1.最简单的方法：1）activiti-engine jar添加到类路径中　　　　
   2）添加一个合适的数据库驱动程序　　　　
   3）添加一个Activiti配置文件(activiti.cfg.xml)到您的类路径,指向您的数据库(参见数据库配置部分) 　　　　
   4）执行DbSchemaCreate类的主要方法
 2.也可以直接执行sql创建：Activiti的SQL DDL语句可以找到下载页面或在Activiti分布文件夹中,数据库中的子目录。脚本引擎也在jar(activiti-engine-x.jar),在包org/activiti/db/create(删除文件夹包含撤销语句)。

 3.说明 1.引擎.引擎执行所需的表。必需的。　　　　
 1.身份:表包含用户、组和会员的用户组。应该使用这些表是可选的,当使用附带的默认身份管理引擎。　　　　
 2.历史:包含历史和审计信息的表。可选:不需要当历史级别被设置为空。请注意,这也将禁用某些功能(如评论任务)在历史数据库中存储数据。
 4.表的含义
 1. ACT_RE_ *:代表库。与此表前缀包含静态信息如流程定义和流程资源(图片、规则等)。
 2. ACT_RU_ *:RU代表运行时。这些流程实例的运行时包含运行时数据的表,用户任务,变量,工作,等等。Activiti只存储运行时数据流程实例执行过程中,一个流程实例结束的时候和删除记录。这使运行时表小而快。　　　　
 3. ACT_ID_ *:ID代表身份。这些表包含身份信息,如用户、团体等。　　　　
 4. ACT_HI_ *:HI,代表历史。这些表包含历史数据,如过去的流程实例变量,任务等等。　　　　
 5. ACT_GE_ *:一般数据,用于各种用例。

 5.数据库升级问题：
 <beans >
   <bean id="processEngineConfiguration" class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
 <!-- ... -->
 <property name="databaseSchemaUpdate" value="true" />    <!-- 最好配置为false -->      
 <!-- ... -->
   </bean>
 </beans>


 6. 从版本5.17.0 Activiti提供了一个异步执行程序以及作业执行器， ManagedJobExecutor 和 ManagedAsyncJobExecutor 
 7. Job executor 的激活
 JobExecutor是一个组件,它管理几个线程火计时器(后来也异步消息)。对于单元测试场景,它是繁琐的处理多个线程。因此API允许查询(ManagementService.createJobQuery)和执行工作(ManagementService.executeJob)
  通过API,这样的工作可以从内部控制执行单元测试。为了避免干涉作业执行器,它可以被关闭。 默认情况下,JobExecutor在流程引擎启动时被激活。如果不需要
  <property name="jobExecutorActivate" value="false" />
  
 8.Async executor 的激活
 默认情况下,AsyncExecutor不启用和使用JobExecutor由于遗留原因。不过建议使用新的AsyncExecutor代替。可以通过定义两个属性
 <property name="asyncExecutorEnabled" value="true" />     启用异步执行器取代了旧的工作执行人
 <property name="asyncExecutorActivate" value="true" />    指示Activiti引擎启动异步执行器在启动时线程池。

 9.可选的邮件服务配置   配置邮件服务器是可选的。在业务流程中Activiti支持发送电子邮件。发送一封电子邮件,一个有效的SMTP邮件服务器配置是必需的。看到电子邮件的任务配置选项
 10.可选的历史配置      <property name="history" value="audit" />
 11.暴露配置bean

 12.部署缓存配置    
 1.根据实际情况设置：<property name="processDefinitionCacheLimit" value="10" />  
 2.实现 org.activiti.engine.impl.persistence.deploy.DeploymentCache    
 <property name="processDefinitionCache">
   <bean class="org.activiti.MyCache" />
 </property>
 13.日志信息  如果没有实现jar添加,SLF4J将使用一个NOP-logger,不记录任何东西,除了一个警告,不会被记录。
 <dependency>
   <groupId>org.slf4j</groupId>
   <artifactId>slf4j-log4j12</artifactId>
 </dependency>
 或者
 <dependency>
   <groupId>org.slf4j</groupId>
   <artifactId>jcl-over-slf4j</artifactId>
 </dependency>
 14.配置日志的上下文映射 可以在log4j配置中添加
  log4j.appender.consoleAppender.layout.ConversionPattern =ProcessDefinitionId=%X{mdcProcessDefinitionID}
 executionId=%X{mdcExecutionId} mdcProcessInstanceID=%X{mdcProcessInstanceID} mdcBusinessKey=%X{mdcBusinessKey} %m%n"
 15.事件处理器  org.activiti.engine.delegate.event.ActivitiEvent的子类型。事件暴露了(如果可用)类型,executionId,processInstanceId processDefinitionId。
 1）事件监听的实现
 public class MyEventListener implements ActivitiEventListener {


   @Override
   public void onEvent(ActivitiEvent event) {
 switch (event.getType()) {


   case JOB_EXECUTION_SUCCESS:
 System.out.println("A job well done!");
 break;


   case JOB_EXECUTION_FAILURE:
 System.out.println("A job has failed...");
 break;


   default:
 System.out.println("Event received: " + event.getType());
 }
   }


   @Override
   public boolean isFailOnException() {   //建议return false
 // The logic in the onEvent method of this listener is not critical, exceptions
 // can be ignored if logging fails...
 return false;
   }
 }

 或者可以使用 org.activiti.engine.delegate.event。BaseEntityEventListener:一个事件监听器的基类,它可以用来进行侦听实体相关的事件为一个特定类型的实体或实体。它隐藏了类型检查和提供了4种方法,
 应该覆盖:onCreate(. .),onUpdate(. .)和onDelete(. .)创建一个实体时,更新或删除。进行所有其他实体相关的事件,onEntityEvent(. .)。

 2）配置和设置
 下面的代码片段添加一个事件监听器的配置通知派遣任何事件时,无论它的类型:
 <bean id="processEngineConfiguration" class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
 ...
 <property name="eventListeners">
   <list>
  <bean class="org.activiti.engine.example.MyEventListener" />
   </list>
 </property>
 </bean>
 下面的代码片段添加一个事件监听器的配置,这是当工作执行成功或失败的通知:
 <bean id="processEngineConfiguration" class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
 ...
 <property name="typedEventListeners">
   <map>
 <entry key="JOB_EXECUTION_SUCCESS,JOB_EXECUTION_FAILURE" >
   <list>
 <bean class="org.activiti.engine.example.MyJobEventListener" />
   </list>
 </entry>
   </map>
 </property>
 </bean>

 3）添加侦听器在运行时   可以添加和删除额外的事件监听器引擎通过使用API(RuntimeService):    在运行时请注意,侦听器添加引擎重新启动时不保留。
 /**
  * Adds an event-listener which will be notified of ALL events by the dispatcher.
  * @param listenerToAdd the listener to add
  */
 void addEventListener(ActivitiEventListener listenerToAdd);


 /**
  * Adds an event-listener which will only be notified when an event occurs, which type is in the given types.
  * @param listenerToAdd the listener to add
  * @param types types of events the listener should be notified for
  */
 void addEventListener(ActivitiEventListener listenerToAdd, ActivitiEventType... types);


 /**
  * Removes the given listener from this dispatcher. The listener will no longer be notified,
  * regardless of the type(s) it was registered for in the first place.
  * @param listenerToRemove listener to remove
  */
  void removeEventListener(ActivitiEventListener listenerToRemove);

 4）添加侦听器过程定义
 5）调度事件通过API
 6）支持的事件类型  如下：对应org.activiti.engine.delegate.event.ActivitiEventType.的枚举
 ENGINE_CREATED ENGINE_CLOSED ENTITY_CREATED ENTITY_INITIALIZED ENTITY_UPDATED ENTITY_DELETED ENTITY_SUSPENDED ENTITY_ACTIVATED 等

 六. The Activiti API
 1. 流程引擎API和服务

 七.Spring 的集成
 八.部署
 九.BPMN 2.0介绍
 十.BPMN 2.0的结构
 十一.JPA
 十二.History
 十三.Activiti Explorer
 十四.Activiti Modeler
 十五.REST API
 十六.CDI集成
 十七.LDAP 集成
 十八.模拟与Activiti-Crystalball(实验)
 十九.工具JMX














































































































































































  

很棒的学习文档，activiti bpm

地址：http://www.mossle.com/docs/activiti/

目录
 
 
一：Activiti的介绍
 
二：牛刀小试---------搭建第一个Activiti项目流程
 
三：Activiti流程部署的方法

http://wenku.baidu.com/view/bb7364ad4693daef5ff73d32.html
 
 
 
 
安利一下国产化OpenWebFlow！！
 
https://github.com/bluejoe2008/openwebflow
 
 
 
OpenWebFlow是基于Activiti扩展的工作流引擎，它扩展的功能包括：
 
    
完全接管了Activiti对活动（activity）权限的管理；
完全接管了Activiti对用户表（IDENTITY_XXX表）的管理；
允许运行时定义activity！彻底满足“中国特色”，并提供了安全的（同时也是优雅的）催办、代办、加签（包括前加签/后加签）、自由跳转（包括前进/后）、分裂节点等功能；
 
 
1. 初识Activiti
 
 
1.1. 工作流与工作流引擎
 
 
工作流（workflow）就是工作流程的计算模型，即将工作流程中的工作如何前后组织在一起的逻辑和规则在计算机中以恰当的模型进行表示并对其实施计算。它主要解决的是“使在多个参与者之间按照某种预定义的规则传递文档、信息或任务的过程自动进行，从而实现某个预期的业务目标，或者促使此目标的实现”。（我的理解就是：将部分或者全部的工作流程、逻辑让计算机帮你来处理，实现自动化）
 
 
所谓工作流引擎是指workflow作为应用系统的一部分，并为之提供对各应用系统有决定作用的根据角色、分工和条件的不同决定信息传递路由、内容等级等核心解决方案。
 
 
例如开发一个系统最关键的部分不是系统的界面，也不是和数据库之间的信息交换，而是如何根据业务逻辑开发出符合实际需要的程序逻辑并确保其稳定性、易维护性和弹性。
 
 
比如你的系统中有一个任务流程，一般情况下这个任务的代码逻辑、流程你都要自己来编写。实现它是没有问题的。但是谁能保证逻辑编写的毫无纰漏？经过无数次的测试与改进，这个流程没有任何漏洞也是可以实现的，但是明显就会拖慢整个项目的进度。
 
 
 工作流引擎解决的就是这个问题：如果应用程序缺乏强大的逻辑层，势必变得容易出错（信息的路由错误、死循环等等）。
 
 
1.2. BPMN2.0规范
 
 
BPMN（Business Process Model and Notation）--业务流程模型与符号。
 
 
BPMN是一套流程建模的标准，主要目标是被所有业务用户容易理解的符号，支持从创建流程轮廓的业务分析到这些流程的最终实现，知道最终用户的管理监控。
 
 
通俗一点其实就是一套规范，画流程模型的规范。流程模型包括：流程图、协作图、编排图、会话图。详细信息请google。
 
 
1.3. Activiti概述
 
 
1.3.1. Activiti由来
 
 
学习过Activiti的朋友都知道，Activiti的创始人也就是JBPM（也是一个优秀的BPM引擎）的创始人，从Jboss离职后开发了一个新的BPM引擎：Activiti。所以，Activiti有很多地方都有JBPM的影子。所以，据说学习过JBPM的朋友学起Activiti来非常顺手。
 
 
由于本人之前没有工作流及JBPM的相关基础，刚开始学习Activiti的时候可以说是无比痛苦的，根本不知道从何下手，这里也建议大家先进行工作流及BPMN2.0规范的学习，有了一定的基础后，再着手学习Activiti。
 
 
1.3.2. Activiti简介
 
 
Activiti是一个开源的工作流引擎，它实现了BPMN 2.0规范，可以发布设计好的流程定义，并通过api进行流程调度。
 
 
Activiti 作为一个遵从 Apache 许可的工作流和业务流程管理开源平台，其核心是基于 Java 的超快速、超稳定的 BPMN2.0 流程引擎，强调流程服务的可嵌入性和可扩展性，同时更加强调面向业务人员。
 
 
Activiti 流程引擎重点关注在系统开发的易用性和轻量性上。每一项 BPM 业务功能 Activiti 流程引擎都以服务的形式提供给开发人员。通过使用这些服务，开发人员能够构建出功能丰富、轻便且高效的 BPM 应用程序。
 
 
1.4. 文档说明
 
 
以上部分对工作流、BPMN、Activiti的概念做了一个简单的介绍，目的是了解Activiti究竟是什么，能做些什么…及在学习Activiti之前需要了解的知识与技术。其中大部分文字来自Copy网上的各种资料与文档，通过总结而来的。具体的更详细的内容需自己google，参考一些官方的文档与手册。
 
 
本文档之后内容如下：
 
 
1)      下载与使用
 
 
2)      核心组件与说明
 
 
3)      入门示例
 
 
4)      Eclipse中的Activiti插件的使用
 
 
本文档旨在为初学Activiti的朋友提供入门级别的参考，不会对其原理及其结构进行深层次的探究（更多是因为目前自身理解还不是很透彻），只是为大家理清思路，方便以后更深层次的学习。本文档还有一个重要的特点，那就是根据自己看官方手册的经验，教大家如何看手册从而更有效率！由于是初学，很多术语或解释难免理解有偏差，所以一定要看官方提供的文档与手册，那才是学习的最佳途径！
 
 
2. 开始学习
 
 
2.1. 必要的准备
 
 
2.1.1. 下载与了解目录
 
 
下载Activiti：下载路径，也就是官方网站的地址：http://activiti.org/download.html。下载后解压（我所使用的是5.12版本的，Activiti更新速度飞快，几乎每两个月就会有一个更新的小版本），看到如下目录：
 
 
 
 
 
1)      database：里面存放的是Activiti使用到的数据库信息的sql文件，它支持的数据库类型如下图，使用时只需执行你自己的数据库类型的文件即可。如：你的数据库是mysql，那么就执行activiti.mysql.create.*.sql即可。
 
 
 
 
 
2)      docs：毫无疑问，api文档是也。
 
 
3)      libs：使用Activiti所需要的所有的jar包和源文件。
 
 
4)      wars：官方给我们提供的示例Demo，通过使用Demo可以更加快速的了解Activiti。
 
 
2.1.2. 其他准备
 
 
使用Activiti，首先当然要有jdk了！6+版本就可以了。其次，要有一款IDE，我们当然会使用Eclipse，这里使用Juno版本。然后，web容器当然也要有，这里使用Tomcat6.0版本。然后就是Activiti的Eclipse插件了，这个后面再介绍。
 
 
2.1.3. 一分钟入门（见用户手册）
 
 
所谓的一分钟入门就是通过运行你下载的包里的wars文件夹里的activiti-explorer.war文件，以便更快的了解Activiti。将文件拷贝至Tomcat的webapps目录，启动tomcat，输入http://localhost:8080/activiti-explorer。然后你就可以开整了！总算是有一点微小的进展了。
 
 
这里需要说明的就是，这个Demo默认采用的是h2内存数据库，如果想用你自己的数据库，就需要修改web应用WEB-INF/classes目录下的db.properties。然后，按上面说的，把database里的create文件夹里的数据库文件导入你自己的数据库（如果没有修改db.properties，就不用导入了）。
 
 
Demo的具体解释与数据库配置的具体信息详见官方手册，手册已经说的很清楚了。这里需要重点了解activiti.cfg.xml的配置以及如何构建ProcessEngine（配置文件构建方式、代码构建方式）。
 
 
对Demo的使用介绍在官方文档的后面才开始介绍，这里建议应用跑起来之后，先自己试试手（可看后面介绍Demo如何使用的章节），看看如何跑一个流程、整个流程是怎么流的、并随时关注数据库表里的数据的变化等，对以后的学习很有帮助！
 
 
2.2. 核心组件介绍
 
 
2.2.1. 关键对象
 
 
1.      Deployment：流程部署对象，部署一个流程时创建。
 
 
2.      ProcessDefinitions：流程定义，部署成功后自动创建。
 
 
3.      ProcessInstances：流程实例，启动流程时创建。 
 
 
4.      Task：任务，在Activiti中的Task仅指有角色参与的任务，即定义中的UserTask。 
 
 
5.      Execution：执行计划，流程实例和流程执行中的所有节点都是Execution，如UserTask、ServiceTask等。
 
 
2.2.2. 服务接口
 
 
1.      ProcessEngine：流程引擎的抽象，通过它我们可以获得我们需要的一切服务。 
 
 
2.      RepositoryService：Activiti中每一个不同版本的业务流程的定义都需要使用一些定义文件，部署文件和支持数据(例如BPMN2.0 XML文件，表单定义文件，流程定义图像文件等)，这些文件都存储在Activiti内建的Repository中。RepositoryService提供了对 repository的存取服务。
 
 
3.      RuntimeService：在Activiti中，每当一个流程定义被启动一次之后，都会生成一个相应的流程对象实例。RuntimeService提供了启动流程、查询流程实例、设置获取流程实例变量等功能。此外它还提供了对流程部署，流程定义和流程实例的存取服务。
 
 
4.      TaskService: 在Activiti中业务流程定义中的每一个执行节点被称为一个Task，对流程中的数据存取，状态变更等操作均需要在Task中完成。TaskService提供了对用户Task 和Form相关的操作。它提供了运行时任务查询、领取、完成、删除以及变量设置等功能。 
 
 
5.      IdentityService: Activiti中内置了用户以及组管理的功能，必须使用这些用户和组的信息才能获取到相应的Task。IdentityService提供了对Activiti 系统中的用户和组的管理功能。
 
 
6.      ManagementService: ManagementService提供了对Activiti流程引擎的管理和维护功能，这些功能不在工作流驱动的应用程序中使用，主要用于Activiti系统的日常维护。 
 
 
7.      HistoryService: HistoryService用于获取正在运行或已经完成的流程实例的信息，与RuntimeService中获取的流程信息不同，历史信息包含已经持久化存储的永久信息，并已经被针对查询优化。
 
 
现在至少要知道有这些对象和接口。并结合Activiti Api这一章节来看，你就会对部署流程、启动流程、执行任务等操作有一个基本的概念。之后编写一个简单的单元测试，主要为了测试activiti.cfg.xml配置的是否正确，流程是否可以被部署即可。
 
 
至于与Spring的集成，一定要熟悉基于Spring配置Activiti，以及事务的处理。
 
 
 
 
3. 入门示例（参考手册中10分钟教程）
 
 
 
3.1. 概述
 
 
 
下面开始编写一个示例。这个Demo为一个“月度报表申请”流程。由“sales(销售)”组的用户制作月度报表，提交给“management(经理)”组的用户，经理审批该报表，最后结束。流程图如下：
 
 
 
这个Demo完成之后，我们会进行两个测试。一个是代码中的单元测试，就是跑一遍流程，看一下流程在跑的过程中输出的信息；一个是我们将编辑好的bpmn20.xml文件通过我们之前一分钟入门的示例activiti-explorer应用导入进去，查看它的流程图，并完整执行一遍流程。
 
在编写这个Demo之前，至少要了解Activiti与Spring如何集成、XxxService各自的任务与作用，并完成上一章的Demo。
 
3.2. 流程文件xxx.bpmn20.xml
 
首先，我们就来编写这个流程的bpmn20.xml文件。
 
 
 
<definitions  id="definitions"
   targetNamespace="http://activiti.org/bpmn20"
   xmlns:activiti="http://activiti.org/bpmn"
   xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL">

         <process id="financialReport" name="Monthly financial report reminderprocess">

           <startEvent  id="theStart" />

           <sequenceFlow  id='flow1' sourceRef='theStart' targetRef='writeReportTask' />
 
 

           <userTask  id="writeReportTask" name="Write monthly financial report" >
             <documentation>
               Write monthly financial reportfor publication to shareholders.
             </documentation>
             <potentialOwner>
               <resourceAssignmentExpression>
                 <formalExpression>sales</formalExpression>
               </resourceAssignmentExpression>
             </potentialOwner>
           </userTask>

           <sequenceFlow  id='flow2' sourceRef='writeReportTask' targetRef='verifyReportTask' />

           <userTask  id="verifyReportTask" name="Verify monthly financial report" >
             <documentation>
               Verify monthly financial reportcomposed by the accountancy department.
               This financial report is goingto be sent to all the company shareholders.
             </documentation>
             <potentialOwner>
               <resourceAssignmentExpression>
                 <formalExpression>management</formalExpression>
               </resourceAssignmentExpression>
             </potentialOwner>
           </userTask>

           <sequenceFlow  id='flow3' sourceRef='verifyReportTask' targetRef='theEnd' />

           <endEvent  id="theEnd" />

         </process>

</definitions>
 
 
 
 
这里对部分代码进行解释。
 
1)       文件的开头部分，这里的id对于Activiti来说， 应该叫做key。创建流程实例时，会根据此id来得到这个流程。
 
 
 
2)      开始流程。
 
 
 
3)      顺序流（就是连接各个节点的指向线）
 
 
 
sourceRef和targetRef分别为起始节点和目标节点。
 
4)      描述用户任务
 
 
 
id为该用户任务的标识。
 
documentation为该用户任务的描述。
 
5)      分配用户
 
 
 
可以把任务分配给指定的用户，也可以分配给指定的组，并且可以有多个，详见用户手册。
 
3.3. Spring配置文件
 
这里配置了数据源、事务管理、流程引擎及几个必要的xxxService。这里数据源使用的是dbcp。数据库信息就配置成你自己本地数据库的信息，如果不会配置。
 
 
 
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
 
         destroy-method="close">
 
         <property name="driverClassName" value="com.mysql.jdbc.Driver" />
 
         <property name="url" value="jdbc:mysql://localhost:3306/activiti"/>
 
         <property name="username" value="root"/>
 
         <property name="password" value="root"/>
 
         <property name="initialSize" value="20" />
 
         <property name="maxActive" value="50"/>
 
         <property name="maxIdle" value="20"/>
 
         <property name="minIdle" value="10"/>
 
    </bean>
 
 
 
    <bean id="transactionManager"
 
         class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
 
         <property name="dataSource" ref="dataSource"></property>
 
    </bean>
 
    <bean id="processEngineConfiguration" class="org.activiti.spring.SpringProcessEngineConfiguration">
 
         <property name="dataSource" ref="dataSource" />
 
         <property name="transactionManager" ref="transactionManager" />
 
         <property name="databaseSchemaUpdate" value="true" />
 
         <property name="jobExecutorActivate" value="false" />
 
    </bean>
 
 
 
    <bean id="processEngine" class="org.activiti.spring.ProcessEngineFactoryBean">
 
         <property name="processEngineConfiguration" ref="processEngineConfiguration" />
 
    </bean>
 
 
 
    <bean id="repositoryService" factory-bean="processEngine"
 
         factory-method="getRepositoryService" />
 
    <bean id="runtimeService" factory-bean="processEngine"
 
         factory-method="getRuntimeService" />
 
    <bean id="taskService" factory-bean="processEngine"
 
         factory-method="getTaskService" />
 
    <bean id="historyService" factory-bean="processEngine"
 
         factory-method="getHistoryService" />
 
    <bean id="managementService" factory-bean="processEngine"
 
         factory-method="getManagementService" />
 
 
 
    <tx:annotation-driven transaction-manager="transactionManager" />
 
 
 
注：bpmn20.xml文件中用到了两个用户组（sales、management），是因为我们启动Tomcat运行activiti-explorer应用初始化时自动就会往数据库里添加一些数据，其中用户组的表中就会添加几条记录，其中就包括这两个组，所以不用管它怎么来的，总之数据库里有这两个组就对了。而应用默认使用的是内存数据库，服务一停止数据也就没有了。所以为了进行单元测试，需要按前面讲的修改数据库配置的方法：
 
 
 
把activiti-explorer应用的数据库配置改成你自己的本地数据库的信息，我使用的是Mysql数据库。再启动tomcat运行应用（目的就是为了让数据库有数据），这时你的本地数据库就有数据了，可以编写测试用例进行单元测试了。
 
3.4. 编写测试用例
 
1)      读取Spring配置文件，注入流程所需的Service
 
 
 
2)      编写测试方法
 
   @Test
 
    public  void monthtest() {
 
        // 部署流程定义
 
        repositoryService.createDeployment().addClasspathResource("myProcess.bpmn20.xml").deploy();
 
        // 启动流程实例
 
        String procId = runtimeService.startProcessInstanceByKey("financialReport").getId();
 
        // 获得第一个任务
 
        List<Task> tasks = taskService.createTaskQuery().taskCandidateGroup("sales").list();
 
        for (Task task : tasks) {
 
            System.out.println("Following task is available for sales group: " + task.getName());
 
            // 认领任务这里由foozie认领，因为fozzie是sales组的成员
 
            taskService.claim(task.getId(), "fozzie");
 
        }
 
        // 查看fozzie现在是否能够获取到该任务
 
        tasks = taskService.createTaskQuery().taskAssignee("fozzie").list();
 
        for (Task task : tasks) {
 
            System.out.println("Task for fozzie: " + task.getName());
 
            // 执行(完成)任务
 
            taskService.complete(task.getId());
 
        }
 
        // 现在fozzie的可执行任务数就为0了
 
        System.out.println("Number of tasks for fozzie: "
 
                           + taskService.createTaskQuery().taskAssignee("fozzie").count());
 
        // 获得第二个任务
 
        tasks = taskService.createTaskQuery().taskCandidateGroup("management").list();
 
        for (Task task : tasks) {
 
            System.out.println("Following task is available for accountancy group:" + task.getName());
 
            // 认领任务这里由kermit认领，因为kermit是management组的成员
 
            taskService.claim(task.getId(), "kermit");
 
        }
 
        // 完成第二个任务结束流程
 
        for (Task task : tasks) {
 
            taskService.complete(task.getId());
 
        }
 
        // 核实流程是否结束,输出流程结束时间
 
        HistoricProcessInstancehistoricProcessInstance =  historyService.createHistoricProcessInstanceQuery()
 
                                                                       .processInstanceId(procId).singleResult();
 
        System.out.println("Process instance end time: " + historicProcessInstance.getEndTime());
 
}
 
 
 
3)  运行示例，Demo完成。这就是一个最简单的流程，通过这个流程，了解到Activiti中流程是怎么流的，我们怎么控制它。
 
3.5. 导入activiti-explorer
 
1)      单元测试完成后，我们可以将该bpmn20.xml文件导入之前我们部署的activiti-explorer应用中：点击流程的流程设计工作区，点击导入，将刚才我们编写的文件导入进去。
 
 
 
2)      导入之后在右上角点击部署。
 
 
 
3)      在已部署流程定义中我们可以看到这个流程，及它的流程图。
 
 
 
4)      点击启动流程，该流程就会被启动，再点击任务中，列队就会有该任务了，而且是分配给sales的，这正是我们定义流程时所分配给的用户组啊。注意，现在只有sales组的用户才可以看到此任务！
 
 
 
5)      sales组的用户进入之后点击“签收”，该任务就分配给该用户了，然后该用户就可以进行处理，也就是在代办任务和受邀里。
 
 
 
6)      进去之后点击完成任务，该任务就流到下一个节点，也就是流转到management组中去了，要由management组的用户去处理。
 
 
 
7)      于是这时候，队列中management组就有一个新的任务了，等待management组的成员来“签收”，并完成任务。该流程也就结束了。
 
 
 
8)      此时就可以查看历史任务了，就是我们这里的“已归档”。用户完成的任务会在这里显示。
 
这就是整个Demo的编写、测试过程。这样一个小小的流程基本能够体现出Activiti的功能及使用方法。
 
4. Eclipse中的Activiti插件
 
Activiti有一个Eclipse插件，Activiti Eclipse Designer，可用于图形化建模、测试、部署 BPMN 2.0的流程。这样就不用我们自己去编写繁琐的流程文件了。具体安装方法见手册。
 
4.1. 安装
 
打开 Help-> Install New Software.在如下面板中 , 点击 Add 按钮, 然后填入下列字段:
 
Name: Activiti BPMN 2.0 designer
 
Location: http://activiti.org/designer/update/
 
 
 
然后一步步的安装就可以了。
 
4.2. 使用
 
至于如何使用，文档中介绍的非常详细，这里基于我初次使用的经验，强调几点：
 
1)      安装之后将“保存bpmn文件时创建图片文件”勾选上。这样你每次保存bpmn文件时，会为你自动创建图片文件。
 
 
 
2)      节点的所有属性可在properties控制台中设置。
 
 
 
3)      在使用设计器之前，先去钻研BPNM2.0规范吧，了解BPNM结构（可参看用户手册），才能画出符合逻辑且完美的流程图。
 
 
 
该例为使用Activiti Eclipse Designer设计的“请假”流程图。