Activiti自我总结

Spring代码

<?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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.1.xsd">
    <bean id="dataSource"
        class="org.springframework.jdbc.datasource.SimpleDriverDataSource">
        <property name="driverClass" value="oracle.jdbc.driver.OracleDriver" />
        <property name="url" value="jdbc:oracle:thin:@127.0.0.1:1521:jasgis" />
        <property name="username" value="zsmseip" />
        <property name="password" value="a111111" />
    </bean>
    <bean id="transactionManager"
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>
    <!-- Activiti 配置  begin-->
    <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" />
        <property name="history" value="full" />
        <property name="processDefinitionCacheLimit" value="10" />
        <!-- 流程图节点乱码问题配置 -->
        <property name="activityFontName" value="微软雅黑"/>
    </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="formService" factory-bean="processEngine"
        factory-method="getFormService" />
    <bean id="identityService" factory-bean="processEngine"
        factory-method="getIdentityService" />
    <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" />
    <!-- Activiti 配置 end -->
</beans>

Jave代码

/**
 * 
 */
package com.activiti;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.activiti.bpmn.model.BpmnModel;
import org.activiti.engine.FormService;
import org.activiti.engine.HistoryService;
import org.activiti.engine.IdentityService;
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.history.HistoricActivityInstance;
import org.activiti.engine.history.HistoricActivityInstanceQuery;
import org.activiti.engine.history.HistoricDetail;
import org.activiti.engine.history.HistoricProcessInstance;
import org.activiti.engine.history.HistoricTaskInstance;
import org.activiti.engine.history.HistoricVariableInstance;
import org.activiti.engine.history.HistoricVariableUpdate;
import org.activiti.engine.impl.ProcessEngineImpl;
import org.activiti.engine.impl.RepositoryServiceImpl;
import org.activiti.engine.impl.bpmn.diagram.ProcessDiagramGenerator;
import org.activiti.engine.impl.context.Context;
import org.activiti.engine.impl.persistence.entity.ExecutionEntity;
import org.activiti.engine.impl.persistence.entity.ProcessDefinitionEntity;
import org.activiti.engine.impl.pvm.PvmTransition;
import org.activiti.engine.impl.pvm.process.ActivityImpl;
import org.activiti.engine.impl.pvm.process.TransitionImpl;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.activiti.engine.task.TaskQuery;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 
 * @author Test
 * @createDate 2014-6-1上午10:08:05
 * @className TestFinancial.java
 * @useFor
 */
public class TestFinancial {

	private RuntimeService runtimeService;
	private IdentityService identityService;
	private RepositoryService repositoryService;
	private FormService formService;
	private TaskService taskService;
	private HistoryService historyService;
	ProcessEngine processEngine;

	/**
	 * 
	 * @author Test
	 * @createDate 2014-6-1下午10:34:26
	 * @params
	 * @return void
	 * @useFor 初始化ProcessEngine和重要的service
	 */
	@Before
	public void initActiviti() {
		// 加载spring配置
		ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext(
				"applicationContext.xml");
		// 流程引擎
		processEngine = (ProcessEngine) ctx.getBean("processEngine");
		// 发布流程
		repositoryService = processEngine.getRepositoryService();
		// 获得流程实例和运行实例（Execution）
		runtimeService = (RuntimeService) ctx.getBean("runtimeService");
		taskService = (TaskService) ctx.getBean("taskService");
		identityService = (IdentityService) ctx.getBean("identityService");
		formService = processEngine.getFormService();
		deploy("diagrams/ActivitiTest.bpmn");
		historyService = (HistoryService) ctx.getBean("historyService");
	}

	/**
	 * 
	 * @author Test
	 * @createDate 2014-6-1下午10:32:49
	 * @params
	 * @return void
	 * @useFor 部署流程
	 */
	public void deploy(String srcName) {
		// Deploy the process definition
		repositoryService.createDeployment().addClasspathResource(srcName)
				.deploy();
	}

	/**
	 * 
	 * @author Test
	 * @createDate 2014-6-1下午10:38:29
	 * @params keyName 表示流程图ID businessID是业务主键ID
	 * @return ProcessInstance
	 * @useFor 开启流程
	 */
	public ProcessInstance startProcessInstanceByKey(String keyName,
			String businessID) {
		return runtimeService.startProcessInstanceByKey(keyName, businessID);
	}

	/**
	 * 
	 * @author Test
	 * @createDate 2014-6-1下午10:42:36
	 * @params 指定用户ID
	 * @return List<Task>
	 * @useFor 获得指定用户的任务集合 taskAssignee只是针对 Assignee的对candidate不适用
	 */
	public List<Task> getTaskFromAssignee(String assigneeName) {
		List<Task> result = new ArrayList<Task>();
		result = taskService.createTaskQuery().taskAssignee(assigneeName)
				.list();
		return result;
	}

	/**
	 * 
	 * @author Test
	 * @createDate 2014-6-2上午10:13:07
	 * @params
	 * @return List<Task>
	 * @useFor 查询委托组的任务列表
	 */
	public List<Task> getTaskFromCandidateGroup(String groupName) {
		return taskService.createTaskQuery().taskCandidateGroup(groupName)
				.list();
	}

	/**
	 * 
	 * @author Test
	 * @createDate 2014-6-2上午10:16:32
	 * @params
	 * @return List<Task>
	 * @useFor 查询委托用户的任务列表 只能对candidate适用 用户在某个组下也适用
	 */
	public List<Task> getTaskFromCandidateUser(String userName) {
		return taskService.createTaskQuery().taskCandidateUser(userName).list();
	}

	/**
	 * 
	 * @author test
	 * @createDate 2014-6-8下午05:46:34
	 * @params
	 * @return byte[]
	 * @useFor 获得流程图加亮
	 */
	public byte[] getActivitiPngBytes(ProcessInstance processInstance)
			throws IOException {
		byte[] result = null;
		try {
			BpmnModel bpmnModel = repositoryService
					.getBpmnModel(processInstance.getProcessDefinitionId());
			List<String> activeActivityIds = runtimeService
					.getActiveActivityIds(processInstance.getId());
			ProcessEngineImpl defaultProcessEngine = (ProcessEngineImpl) ProcessEngines
					.getDefaultProcessEngine();
			Context.setProcessEngineConfiguration(defaultProcessEngine
					.getProcessEngineConfiguration());
			/** 得到图片输出流 **/
			InputStream imageStream = ProcessDiagramGenerator.generateDiagram(
					bpmnModel, "png", activeActivityIds);
			result = new byte[imageStream.available()];
			imageStream.read(result);
		} catch (IOException e) {
			e.printStackTrace();
		}
		return result;
	}

	/**
	 * 
	 * @author Test
	 * @createDate 2014-6-2下午12:19:00
	 * @params
	 * @return void
	 * @useFor 流程圖保存到本地
	 */
	public void loadActivitiPng(byte[] srcPng, String locationStr) {
		File file = null;
		OutputStream out = null;
		file = new File(locationStr);
		try {
			out = new FileOutputStream(file);
			out.write(srcPng);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	/**
	 * 
	 * @author Test
	 * @createDate 2014-6-2下午06:11:48
	 * @params 发起人名称
	 * @return void
	 * @useFor 设置发起人
	 */
	public void startProcessBy(String userName) {
		identityService.setAuthenticatedUserId("Test");
	}

	/**
	 * 
	 * @author Test
	 * @createDate 2014-6-2下午06:16:18
	 * @params
	 * @return List
	 * @useFor 查看某个人的开启过的流程
	 */
	public List<HistoricProcessInstance> getProcinstListStartBy(String userName) {
		List<HistoricProcessInstance> hpis = historyService
				.createHistoricProcessInstanceQuery().startedBy(userName)
				.list();
		return hpis;
	}

	public String getVariableNameAndValueFromProcIns(String processInsId,
			String keyName) {
		List<HistoricVariableInstance> list = historyService
				.createHistoricVariableInstanceQuery().processInstanceId(
						processInsId).list();
		for (HistoricVariableInstance variableInstance : list) {
			System.out.println("variable: "
					+ variableInstance.getVariableName() + " = "
					+ variableInstance.getValue());

			if (keyName.equals("variableInstance.getVariableName()")) {
				return variableInstance.getValue().toString();
			}
		}
		return "";
	}

	/**
	 * 
	 * @author Test
	 * @createDate 2014-6-1下午10:39:05
	 * @params
	 * @return void
	 * @useFor 测试流程
	 */
	@Test
	public void activitiTest() {

		// 流程起始参数，会保存在流程实例的变量中
		Map<String, Object> map = new HashMap<String, Object>();
		// 设置发起人
		startProcessBy("Test");
		// 开启流程并传参数
		ProcessInstance processInstance = startProcessInstanceByKey(
				"myProcess", "ddddaaddd");
		// 获得流程实例中的任务
		List<Task> tasks = getTaskQueryByUserid("456").list();
		System.out.println("456ID的任务个数：" + tasks.size());
		for (Task task : tasks) {
			// claim调用claim的用户将变成该任务的所有人，其它用户将不能claim与complete该任务
			// taskService.claim(task.getId(), "456");
			// 节点任务结束
			map.put("comments", "456前台汇总");
			taskService.claim(task.getId(), "456");
			taskService.complete(task.getId(), map);
			try {
				loadActivitiPng(getActivitiPngBytes(processInstance),
						"d://activitiTest1.png");
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		// 转后台123
		System.out.println("123ID的任务数："
				+ getTaskQueryByUserid("123").list().size());
		tasks = getTaskQueryByUserid("123").list();
		for (Task task : tasks) {
			task.setDescription("啦啦啦啦啦");
			map.put("comments", "123认真学习认真工作  不同意");
			oneActivity2Another(task, "不同意", map, "123");
			// taskService.claim(task.getId(), "123");
			// taskService.complete(task.getId(),map);
			try {
				loadActivitiPng(getActivitiPngBytes(processInstance),
						"d://activitiTest2.png");
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		// 获得流程实例中的任务
		tasks = getTaskQueryByUserid("456").list();
		System.out.println("456ID的任务个数：" + tasks.size());
		for (Task task : tasks) {
			// claim调用claim的用户将变成该任务的所有人，其它用户将不能claim与complete该任务
			// taskService.claim(task.getId(), "456");
			// 节点任务结束
			task.setDescription("啦啦啦啦啦");
			map.put("comments", "456认真学习认真工作2");
			// 转办
			// taskService.addCandidateUser(task.getId(), "123");
			taskService.claim(task.getId(), "456");
			taskService.complete(task.getId(), map);
			try {
				loadActivitiPng(getActivitiPngBytes(processInstance),
						"d://activitiTest1.png");
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		// 转办123
		System.out.println("123ID的任务数："
				+ getTaskQueryByUserid("123").list().size());
		tasks = getTaskQueryByUserid("123").list();
		for (Task task : tasks) {
			task.setDescription("啦啦啦啦啦");
			map.put("comments", "123认真学习认真工作  同意");
			taskService.claim(task.getId(), "123");
			taskService.complete(task.getId(), map);
			try {
				loadActivitiPng(getActivitiPngBytes(processInstance),
						"d://activitiTest2.png");
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		// 获得流程实例中的任务
		tasks = getTaskQueryByUserid("567").list();
		Map<String, Object> map1 = new HashMap<String, Object>();
		System.out.println("567ID的任务个数：" + tasks.size());
		for (Task task : tasks) {
			System.out.println("formKey值----->"
					+ getFormKeyByTaskId(task.getId()));
			// 传到后台后根据pass值 来判断是否撤回
			map1.put("comments", "567认真学习认真工作");
			// 这个pass 就是流程图中任务节点（预算审核）中不同意路径的Main
			// config中的condition值即${!pass}
			// map1.put("pass", true);
			taskService.addComment(task.getId(), task.getProcessInstanceId(),
					"567认真学习认真工作");
			taskService.claim(task.getId(), "567");
			taskService.complete(task.getId(), map1);
		}
		List<HistoricProcessInstance> hpis = getProcinstListStartBy("Test");
		System.out.println("Test开启过得流程有：" + hpis.size() + "个");
		try {
			loadActivitiPng(getActivitiPngBytes(processInstance),
					"d://activitiTest3.png");
		} catch (IOException e) {
			e.printStackTrace();
		}
		HistoricProcessInstance historicProcessInstance = getProcessInstanceIdByBusinessId("ddddaaddd");
		System.out.println(" 流程id--->" + historicProcessInstance.getId());
		List<HistoricActivityInstance> actInsList = getHisUserTaskActivityInstanceList(historicProcessInstance
				.getId());
		for (HistoricActivityInstance v : actInsList) {
			System.out.println(v.getId());
			System.out
					.println("开始时间--->"
							+ v.getStartTime()
							+ "   结束时间------>"
							+ v.getEndTime()
							+ "   任务名称---->"
							+ v.getActivityName()
							+ "   办理人---->"
							+ identityService.createUserQuery().userId(
									v.getAssignee()).singleResult()
									.getFirstName() + " UserId---->"
							+ v.getAssignee()
							+ "   审批意见---->"
							// +
							// taskService.getTaskComments(v.getTaskId()).get(0).getFullMessage());
							+ getWorkflowVariables(v.getProcessInstanceId(), v
									.getId()));
		}
	}

	/**
	 * 
	 * @author Test
	 * @createDate 2014-6-1下午10:58:16
	 * @params 任务
	 * @return void
	 * @useFor 从当前节点转向另一个节点
	 */
	public void oneActivity2Another(Task task, String flowName,
			Map<String, Object> map, String userid) {

		ProcessDefinitionEntity processDefinition = (ProcessDefinitionEntity) ((RepositoryServiceImpl) repositoryService)
				.getDeployedProcessDefinition(task.getProcessDefinitionId());

		ExecutionEntity executionEntity = (ExecutionEntity) runtimeService
				.createExecutionQuery().executionId(task.getExecutionId())
				.singleResult();// 执行实例
		String activitiId = executionEntity.getActivityId();
		System.out.println("当前运行节点id值：" + activitiId);
		List<ActivityImpl> activitiList = new ArrayList<ActivityImpl>();
		// 流程定义对象才能得到节点对象
		activitiList = processDefinition.getActivities();
		// 当前实例的执行到哪个节点
		ActivityImpl srcActivity = findActivity(activitiList, activitiId);
		ActivityImpl endActivity = null;
		TransitionImpl transitionImpl = null;
		List<PvmTransition> pvmTransitionList = srcActivity
				.getOutgoingTransitions();// 获取当前节点的所以出口（这个方法做的不好，应该返回List<TransitionImpl>才对的，这样就不用下面的强转换了，我想以后版本会改了这点）
		for (PvmTransition pvmTransition : pvmTransitionList) {
			transitionImpl = (TransitionImpl) pvmTransition;// 强转为TransitionImpl
			System.out.println(transitionImpl.getProperty("name"));
			if (flowName.equals(transitionImpl.getProperty("name"))) {
				endActivity = transitionImpl.getDestination();
			}
		}
		List<PvmTransition> oriPvmTransitionList = new ArrayList<PvmTransition>();
		oriPvmTransitionList.addAll(pvmTransitionList);

		// 先清空其他Transition
		pvmTransitionList.clear();
		pvmTransitionList.add((PvmTransition) transitionImpl);
		transitionImpl.setDestination(endActivity);
		taskService.claim(task.getId(), userid);
		taskService.complete(task.getId(), map);
		// 还原回去其他Transition
		pvmTransitionList.clear();
		pvmTransitionList.addAll(oriPvmTransitionList);
	}

	public ActivityImpl findActivity(List<ActivityImpl> activitiList,
			String activitiId) {
		for (ActivityImpl activityImpl : activitiList) {
			String id = activityImpl.getId();
			if (id.equals(activitiId)) {
				return activityImpl;
			}
		}
		return null;
	}

	/**
	 * 
	 * @author Test
	 * @createDate 2014-6-29上午08:25:13
	 * @params
	 * @return TaskQuery
	 * @useFor 根据用户名获得待办任务列表
	 */
	private TaskQuery getTaskQueryByUserid(String candidateUserId) {
		TaskQuery taskQuery = taskService.createTaskQuery();
		if (candidateUserId != null) {
			taskQuery = taskQuery.taskCandidateUser(candidateUserId);
		}
		return taskQuery;
	}

	/**
	 * 
	 * @author Test
	 * @createDate 2014-6-29上午08:35:38
	 * @params
	 * @return String
	 * @useFor 根据任务id获得formkey 值
	 */
	private String getFormKeyByTaskId(String taskId) {
		HistoricTaskInstance historicTaskInstance = historyService
				.createHistoricTaskInstanceQuery().taskId(taskId)
				.singleResult();

		return historicTaskInstance.getFormKey();
	}

	/**
	 * 
	 * @author Test
	 * @createDate 2014-6-29上午08:57:30
	 * @params
	 * @return String
	 * @useFor
	 */
	private HistoricProcessInstance getProcessInstanceIdByBusinessId(
			String eventid) {
		return historyService.createHistoricProcessInstanceQuery()
				.processInstanceBusinessKey(eventid).singleResult();
	}

	/**
	 * 
	 * @author Test
	 * @createDate 2014-6-29上午09:00:12
	 * @params
	 * @return List<HistoricActivityInstance>
	 * @useFor 获取审批记录
	 */
	private List<HistoricActivityInstance> getHisUserTaskActivityInstanceList(
			String processInstanceId) {
		List<HistoricActivityInstance> hisActivityInstanceList = ((HistoricActivityInstanceQuery) historyService
				.createHistoricActivityInstanceQuery().processInstanceId(
						processInstanceId).activityType("userTask").finished()
				.orderByHistoricActivityInstanceEndTime().desc()).list();
		return hisActivityInstanceList;
	}

	/**
	 * 
	 * @author Test
	 * @createDate 2014-6-29上午09:11:18
	 * @params
	 * @return String
	 * @useFor 获得审批意见
	 */
	private String getWorkflowVariables(String processInstanceId,
			String activityInstanceId) {
		// 执行任务时提的意见
		String comment = "";
		List<HistoricDetail> historicDetailList = historyService
				.createHistoricDetailQuery().processInstanceId(
						processInstanceId).activityInstanceId(
						activityInstanceId).list();
		if (historicDetailList != null && historicDetailList.size() > 0) {
			for (Iterator<HistoricDetail> iterator = historicDetailList
					.iterator(); iterator.hasNext();) {
				HistoricDetail historicDetail = (HistoricDetail) iterator
						.next();
				HistoricVariableUpdate variable = (HistoricVariableUpdate) historicDetail;
				if ("comments".equals(variable.getVariableName())) {
					comment = String.valueOf(variable.getValue());
					return comment;
				}

			}
		}
		return comment;
	}

	@After
	public void end() {
		System.out.println("流程测试完毕");
	}
}