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);

　　

　　

　　

　　

　

时间： 2024-10-09 06:29:19

activiti整合开发实例总结的相关文章

Spring2.5整合Ibatis入门级开发实例

分类: SPRING IBATIS2010-11-22 20:19 1170人阅读 评论(0) 收藏 举报 ibatisspringstringpropertiesclassuser 最近一直在看spring和ibatis的东西,由于目前SSH的流行,大多讲Spring和Hibernate的整合开发,作者一直对Hibernate不是很感冒,也许是因为日常开发程序对性能要求比较高,和Hibernate比较起来Ibatis更合适.虽然网络上有很多讲Spring和Ibatis整合的文章,但查看了许多,

RDIFramework.NET （.NET快速信息化系统开发整合框架） 【开发实例】之产品管理（MVC版）

RDIFramework.NET—.NET快速开发整合框架 [开发实例]之产品管理(MVC版) 第1部分 概述 RDIFramework.NET,基于.NET的快速信息化系统开发.整合框架,为企业或个人在.NET环境下快速开发系统提供了强大的支持,开发人员不需要开发系统的基础功能和公共模块,框架自身提供了强大的函数库和开发包,开发人员只须集中精力专注于业务部分的开发,因此大大提高开发效率和节约开发成本.框架采用目前最主流的C#语言开发完成,支持多种数据库类型,支持WinForm与Web.使用RD

Thinkphp5整合微信扫码支付开发实例

ThinkPHP框架是比较多人用的,曾经做过的一个Thinkphp5整合微信扫码支付开发实例,分享出来大家一起学习 打开首页生成订单,并显示支付二维码 public function index() { $wechat = new Wechat(); $data['order'] = date('Ymd') . substr(implode(NULL, array_map('ord', str_split(substr(uniqid(), 7, 13), 1))), 0, 8); //订单号 $

HTML5端云整合：智能端应用与云端服务整合开发实战

课程简介:       作为Web与移动开发的新标准的HTML5/JavaScript/CSS3,已经纷纷被手机应该开发采用,这不但让UI极具弹性,而且也更容易与云计算整合. 本课程是云计算与智能终端时代的HTML5开发的一站式解决方案,专为企业内训和公开课制作,是完整覆盖HTML5时代开发人员所需使用的360度的技术解决方案,内容细致入微: 课程目标: 全面解析以HTML5+JavaScript来开发应用: 使用JavaScript开发云计算: 定制浏览器并具备开放html5浏览器的能力: 学

从MVC和三层架构说到ssh整合开发-下

这章主要讲整合开发,直接从实战讲起,对与ssh的单方面了解,请继续等待我的兴许文章. 解说不到位的地方欢迎大家指正:联系方式rlovep.com 具体请看源码凝视: 全部代码下载(csdn):链接 Github链接:链接https://github.com/wpeace1212/javaBlog/tree/master/sshDemo 写文章不易,欢迎大家採我的文章,以及给出实用的评论.当然大家也能够关注一下我的github.多谢. 1.整合流程 针对一个简单项目.让大家对三层机构和MVC有一个

eclipse+webservice开发实例

1.參考文献: 1.利用Java编写简单的WebService实例  http://nopainnogain.iteye.com/blog/791525 2.Axis2与Eclipse整合开发Web Service  http://tech.ddvip.com/2009-05/1242968642120461.html 3.http://blog.csdn.net/lightao220/article/details/3489015 4.http://clq9761.iteye.com/blog

SSH整合开发时Scope为默认时现象与原理

1.前提知识 1)scope默认值 进行SSH整合开发时,Struts2的action需要用spring容器进行管理,只要涉及到类以bean的形式入到spring容器中,不管是xml配置还是使用注解方式进行配置,都会涉及到spring管理bean的scope,其一共有五种取值,而其默认值为singleton,也就是单例模型,所有对此bean引用为同一个对象. 2)action应为多例 struts2作为MVC中视图(View)层框架,其最主要任务就是接收用户请求,然后调用业务逻辑层进行处理,这种

从MVC和三层架构说到SSH整合开发

相信很多人都认同JavaWeb开发是遵从MVC开发模式的,遵从三层架构进行开发的,是的,大家都这么认同.但是相信大家都会有过这样一个疑问,if(MVC三层模式==三层架构思想)out.println(“请继续观看……”) 1.MVC(MODEL-VIEW-CONTROLLER)设计模式: 首先让我们了解下MVC(Model-View-Controller)的概念: MVC全名是Model View Controller,是模型(model)-视图(view)-控制器(controller)的缩写

轻量级Java EE企业应用实战（第4版）：Struts 2+Spring 4+Hibernate整合开发(含CD光盘1张)

轻量级Java EE企业应用实战(第4版):Struts 2+Spring 4+Hibernate整合开发(含CD光盘1张)(国家级奖项获奖作品升级版,四版累计印刷27次发行量超10万册的轻量级Java EE经典著作) 李刚 编著   ISBN 978-7-121-24253-3 2014年10月出版 定价:108.00元 824页 16开 编辑推荐 国内知名IT图书作家李刚老师基于曾荣获中国书刊发行业协会“年度全行业优秀畅销品种”大奖的<轻量级Java EE企业应用实战(第3版)>全新升级: