activiti整合开发实例总结

参考手册：http://www.mossle.com/docs/activiti/

一、applicationContext.xml中引入activiti相关配置的xml文件

<!-- begin:工作流相关配置开始 -->
    <import resource="classpath:com/future/sem/resource/activiti/config/activiti-core-context.xml" />
<!-- end:工作流相关配置结束 -->

二、activiti-core-context.xml　　

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
  xmlns:jee="http://www.springframework.org/schema/jee" xmlns:aop="http://www.springframework.org/schema/aop"
  xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
       http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd" default-lazy-init="true">

  <!--  配置Process Engine Definition -->
  <bean id="processEngineConfiguration" class="org.activiti.spring.SpringProcessEngineConfiguration">
  	<!--spring的xml中已经配置 -->
　　　　 <property name="dataSource" ref="dataSource" />
  	<property name="transactionManager" ref="txManager" />

  	<!--工作流引擎启动和关闭时对数据库表结构的处理策略 false(default),true,create,create-drop -->
  	<property name="databaseSchemaUpdate" value="true" />
  	<!--激活Timer和异步消息的线程的组件 true(default) ,false -->
  	<property name="jobExecutorActivate" value="false" />
  	<property name="enableDatabaseEventLogging" value="true" />
  	<property name="history" value="full" />
  	<property name="databaseType" value="oracle" />
	<property name="activityFontName" value="微软雅黑" />
	<property name="labelFontName" value="微软雅黑" />

	<!-- 自动部署，每次重启都要重新加载 -->
	<property name="deploymentResources" value="classpath*:/com/future/sem/resource/activiti/diagrams/*.bpmn" />
  </bean>

  <bean id="processEngine" class="org.activiti.spring.ProcessEngineFactoryBean" destroy-method="destroy">
  	<property name="processEngineConfiguration" ref="processEngineConfiguration" />
  </bean>

  <!-- 创建activiti提供的各种服务 -->
  <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="formService" factory-bean="processEngine" factory-method="getFormService" />
  <bean id="historyService" factory-bean="processEngine" factory-method="getHistoryService" />
  <bean id="managementService" factory-bean="processEngine" factory-method="getManagementService" />
  <bean id="identityService" factory-bean="processEngine" factory-method="getIdentityService" />

</beans>

　三、*.bpmn流程相关的文件

使用elipse，添加流程相关插件

插件地址：http://activiti.org/designer/update/

　　activiti需要第三方依赖库:graphiti
　　地址：http://download.eclipse.org/graphiti/updates/0.9.0

实例图：

安装图解说明：

四、主要的服务service代码

RepositoryService ： 提供方法获取各种流程和部署文件的信息 .

TaskService : 提供对任务相关的各种操作

identityService : 管理用户和用户组。

FormService : 获取或者绑定数据到流程实例上

RuntimeService : 提供操作部署文件，流程文件和流程实例的方法 .

ManagementService : 提供管理员对流程引擎的监控，和流程引擎服务应用无关。

HistoryService : 提供正在执行和过去执行的各种流程实例信息

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

RuntimeService runtimeService = processEngine.getRuntimeService();
RepositoryService repositoryService = processEngine.getRepositoryService();
TaskService taskService = processEngine.getTaskService();
ManagementService managementService = processEngine.getManagementService();
IdentityService identityService = processEngine.getIdentityService();
HistoryService historyService = processEngine.getHistoryService();
FormService formService = processEngine.getFormService();

　项目中具体服务类实例：　

package com.future.sem.common.activiti.service;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.ResourceBundle;

import javax.annotation.Resource;

import org.activiti.engine.FormService;
import org.activiti.engine.HistoryService;
import org.activiti.engine.IdentityService;
import org.activiti.engine.ManagementService;
import org.activiti.engine.RepositoryService;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.activiti.engine.history.HistoricProcessInstance;
import org.activiti.engine.identity.Group;
import org.activiti.engine.identity.User;
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.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.future.sem.common.util.ResourceUtil;

@Service("activitiCoreService")
@Transactional
public class ActivitiCoreService {
	/**
	 * 打印日志
	 */
	private static Logger logger = LoggerFactory
			.getLogger(ActivitiCoreService.class);

	@Resource
	private RepositoryService repositoryService;

	@Resource
	private RuntimeService runtimeService;

	@Resource
	private TaskService taskService;

	@Resource
	private FormService formService;

	@Resource
	private HistoryService historyService;

	@Resource
	private ManagementService managementService;

	@Resource
	private IdentityService identityService;

	// public static final String processDefinitionId = "myProcess"; //流程id

	/**
	 * 获取资源文件中配置的流程id
	 *
	 * @return 流程id
	 * @说明 流程的命名规则
	 */
	public String getProcessDefID(String groupId) {
		ResourceBundle rb = ResourceUtil.getBundle("sem_system_config");// 读取src根目录下的sem_system_config.properties文件，调用不用的流程
		String key = "com.future.sem.activiti.process." + groupId
				+ "ProcessDefinitionId";
		return rb.getString(key);
	}

	/**
	 * 方法：部署流程
	 *
	 * @title: deploymentActiviti
	 * @param
	 * @return void
	 */
	public void deploymentActiviti(String path) {
		// repositoryService.createDeployment().addClasspathResource(path).deploy();
		// //简单的部署流程
		// repositoryService.deleteDeployment("depolyid"); //删除流程
		// repositoryService.createDeploymentQuery().list();//查询流程
		try {
			SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmSS");
			Deployment dep = repositoryService.createDeployment().category(
					"人员审核流程").name(sdf.format(new Date()) + "测试流程")
					.addClasspathResource(path).deploy();
			logger.debug(
					"\n\t文件:{}部署成功!\n\t名称:{}\n\tid:{}\n\t部署时间:{}\n\t类别:{}",
					new Object[] {
							path,
							dep.getName(),
							dep.getId(),
							new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS")
									.format(dep.getDeploymentTime()),
							dep.getCategory() });
			logger.debug("\n\t>>>>目前已部署流程{}个!",
					new Object[] { repositoryService.createDeploymentQuery()
							.count() });
		} catch (Exception e) {
			logger.error("流程部署失败");
		}
	}

	/**
	 * 方法：启动流程
	 *
	 * @title: startProcessInstanceByKey
	 * @param
	 * @return ProcessInstance
	 */
	public ProcessInstance startProcessInstanceByKey(String businessKey,
			String userId, Map<String, Object> varsMap,
			String processDefinitionId) {
		ProcessInstance pi = null;
		try {
			identityService.setAuthenticatedUserId(userId);// 设置启动流程的人员ID
			pi = runtimeService.startProcessInstanceByKey(processDefinitionId,
					businessKey, varsMap);
			logger.info("\n\tNumber of process instances: "
					+ runtimeService.createProcessInstanceQuery().count()
					+ "\n\tprocessId:" + pi.getId() + "\n\tbusinessKey:"
					+ pi.getBusinessKey() + "\n\tprocessDefinitionId:"
					+ pi.getProcessDefinitionId() + "\n\tprocessInstanceId:"
					+ pi.getProcessInstanceId() + "\n\tsuspend:"
					+ pi.isSuspended());
		} catch (Exception e) {
			e.printStackTrace();
		}

		return pi;
	}

	/**
	 * 方法：角色的流程任务列表
	 *
	 * @title: findTaskByProcessId
	 * @param
	 * @return List<Task>
	 */
	public List<Task> findTaskByGroupName(String groupname) {
		List<Task> list = null;
		try {
			list = taskService.createTaskQuery().taskCandidateGroup(groupname)
					.list();
			for (Task task : list) {
				String a = task.getAssignee();
				logger.info("task========:" + task.getName() + "------------"
						+ task.getId());
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return list;
	}

	/**
	 * 方法分配任务给指定人员
	 *
	 * @title: claimTask
	 * @param
	 * @return void
	 */
	public void claimTask(Task task, String username) {
		try {
			// claim it
			if (StringUtils.isBlank(task.getAssignee())) {
				taskService.claim(task.getId(), username);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 方法 ：任务签收人
	 *
	 * @title: setAssignee
	 * @param
	 * @return void
	 */
	public void setAssignee(String taskid, String username) {
		try {
			taskService.setAssignee(taskid, username);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 方法 ：获得任务
	 *
	 * @title: getCurrentTaskByUserid
	 * @param
	 * @return Task
	 */
	public Task getCurrentTaskByUserid(String userId) {
		Task task = null;
		try {
			List<Task> refuseTaskList = taskService.createTaskQuery()
					.taskAssignee(userId).active().orderByTaskPriority().desc()
					.orderByTaskCreateTime().desc().list();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return task;
	}

	/**
	 * 方法 ：获得当前活动的任务
	 *
	 * @title: getCurrentActiveTaskBypid
	 * @param
	 * @return Task
	 */
	public Task getCurrentActiveTaskBypid(String processInstanceId) {
		Task task = null;
		try {
			task = taskService.createTaskQuery().processInstanceId(
					processInstanceId).active().singleResult();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return task;
	}

	/**
	 * 方法 ：完成当前的任务
	 *
	 * @title: completeTask
	 * @param
	 * @return void
	 */
	public void completeTask(String taskid, Map<String, Object> varsMap) {
		try {
			taskService.complete(taskid, varsMap);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 方法 ：根据用户id查看代办列表
	 *
	 * @title: findUndoTask
	 * @param
	 * @return List
	 */
	public List findUndoTask(String userId, String processDefinitionId) {
		// 签收未完成的任务
		List<Task> todoList = taskService.createTaskQuery()
				.processDefinitionKey(processDefinitionId).taskAssignee(userId)
				.active().orderByTaskPriority().desc().orderByTaskCreateTime()
				.desc().list();
		logger.info("\n用户“" + userId + "”签收未完成的任务：" + todoList.size() + "个.");
		// 未签收的任务
		List<Task> unsignedTasks = taskService.createTaskQuery()
				.processDefinitionKey(processDefinitionId).taskCandidateUser(
						userId).active().orderByTaskPriority().desc()
				.orderByTaskCreateTime().desc().list();
		logger
				.info("\n用户“" + userId + "”未签收的任务：" + unsignedTasks.size()
						+ "个.");
		List<Task> allList = new ArrayList<Task>();
		allList.addAll(todoList);
		allList.addAll(unsignedTasks);
		return allList;
	}

	/**
	 * 方法 ：用户已经发布的流程（该用户创建的已经结束的流程）
	 *
	 * @title: findPublishedOfFinishedTaskList
	 * @param
	 * @return List
	 */
	public List findPublishedOfFinishedTaskList(String userId) {
		List<HistoricProcessInstance> list = historyService
				.createHistoricProcessInstanceQuery().startedBy(userId)
				.finished().list();
		logger.info("=============当前用户启动的已经结束的流程=======" + list.size());
		return list;
	}

	/**
	 * 方法 ：用户已经发布的流程（该用户创建的已经结束的流程）
	 *
	 * @title: findRunningProcessInstaceList
	 * @param
	 * @return List
	 */
	public List findRunningProcessInstaceList(String processDefinitionId) {
		List<ProcessInstance> list = runtimeService
				.createProcessInstanceQuery().processDefinitionKey(
						processDefinitionId).active().list();
		logger.info("=============运行中的流程个数=======" + list.size());
		return list;
	}

	/**
	 * 方法 ：获取已经结束的流程
	 *
	 * @title: findFinishedProcessInstaces
	 * @param
	 * @return List
	 */
	public List findFinishedProcessInstaces(String processDefinitionId) {
		List<HistoricProcessInstance> list = historyService
				.createHistoricProcessInstanceQuery().processDefinitionKey(
						processDefinitionId).finished().list();
		logger.info("=============已经结束的流程个数=======" + list.size());
		return list;
	}

	/**
	 * 方法 ：根据流程id 查看历史记录
	 *
	 * @title: findHistoryByproid
	 * @param
	 * @return List
	 */
	public List findHistoryByproid(String procId) {
		List listh2 = historyService.createHistoricDetailQuery()
				.formProperties().processInstanceId(procId)
				.orderByVariableName().asc().list();
		return listh2;
	}

	/**
	 * 方法 ：查询流程定义对象
	 *
	 * @title: getProcessDefinition
	 * @param
	 * @return ProcessDefinition
	 */
	public ProcessDefinition getProcessDefinition(String processDefinitionId) {
		ProcessDefinition processDefinition = repositoryService
				.createProcessDefinitionQuery().processDefinitionId(
						processDefinitionId).singleResult();
		return processDefinition;
	}

	/**
	 * 方法 ：查询当前活动的流程实例
	 *
	 * @title: getCurrentProcess
	 * @param
	 * @return ProcessDefinition
	 */
	public ProcessDefinition getCurrentProcess(String processInstanceId) {
		ProcessDefinition processDefinition = (ProcessDefinition) runtimeService
				.createProcessInstanceQuery().processInstanceId(
						processInstanceId).active().singleResult();
		return processDefinition;
	}

	/**
	 * 方法 ：查找流程表中的用户User列表
	 *
	 * @title: findListByUserid
	 * @param
	 * @return List<User>
	 */
	public List<User> findUserByUserid(String userId) {
		List<org.activiti.engine.identity.User> list = identityService
				.createUserQuery().userId(userId).list();
		return list;
	}

	/**
	 * 方法 ：保存用户到流程表中
	 *
	 * @title: saveActiviteUser
	 * @param
	 * @return void
	 */
	public void saveActiviteUser(User activitiUser) {
		identityService.saveUser(activitiUser);
	}

	/**
	 * 方法 ：查找流程中的用户组Group列表
	 *
	 * @title: findgGroupByID
	 * @param
	 * @return List<Group>
	 */
	public List<Group> findgGroupByID(String groupId) {
		List<Group> list = identityService.createGroupQuery().groupId(groupId)
				.list();
		return list;
	}

}

五、调用方法

// 获得流程id，启动不同的流程
String processDefId = activitiCoreService.getProcessDefID(groupId);
ProcessInstance pi = activitiCoreService.startProcessInstanceByKey(businessKey, userId,varsMap, processDefId);

/查看当前任务节点
task = activitiCoreService.getCurrentActiveTaskBypid(person.getProcessInstanceId());

//分配任务
activitiCoreService.claimTask(task, userId);