帮帮忙~~~关于jbpm4.3,怎样在结束了一个任务不要自动删除任务,因为我还想要查看历史流程图

[qw1424]

RT!!!~~帮帮小弟吧!
帮帮忙~~~关于jbpm4.3,怎样在结束了一个任务不要自动删除任务,因为我还想要查看历史流程图

[baolong101010]

我也在等答案...

[baolong101010]

我已经找到答案了，现将答案公布出来：
目前据我自己测试得知jbpm4.3以后的版本，都会在任务结束后自动删除ProcessInstance，包括4.4我也亲自测试了，这就会造成我们的困惑，像楼主刚才的那个需求我也是有的，就会为了查出历史操作记录和画出流程节点走向示意图，最后我按照自己的猜想，经过测试发现是可以的，那就是你需要获取一个历史工作流对象，这样就可以间接的得到其他原来你需要通过ProcessInstance得到的对象，代码如下：

import java.io.IOException;
import java.io.InputStream;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.jbpm.api.ProcessEngine;
import org.jbpm.api.RepositoryService;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;

import com.baolong.exception.SystemException;
import com.baolong.util.StringUtil;

public class JbpmCurrentNodeImg extends HttpServlet{

	private RepositoryService rs;
		
	public void init() throws ServletException {
		WebApplicationContext wac =
		    WebApplicationContextUtils.getRequiredWebApplicationContext(getServletContext());
		ProcessEngine processEngine = (ProcessEngine)wac.getBean("processEngine");
		rs = processEngine.getRepositoryService();
	}
	
	public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		String deploymentId = request.getParameter("deploymentId");
		String deployName = request.getParameter("deployName");
		InputStream is = null;
		if(StringUtil.isNotNull(deploymentId)) {		
			is = rs.getResourceAsStream(deploymentId, deployName + ".png");
		} else {
			throw new SystemException("deploymentId is null");
		}	
		
		byte[] b = new byte[1024];
		int len = -1;	
		while((len = is.read(b, 0, 1024)) != -1) {
			response.getOutputStream().write(b, 0, len);
		}
	}

	public void doPost(HttpServletRequest req, HttpServletResponse resp)
			throws ServletException, IOException {
		doGet(req, resp);
	}
	
}

[baolong101010]

下面的是JbpmUtil，本来应该是JbpmService，但其实是这个service调用了util里的每个方法，service我就不提供了，你自己按照service调用util的方法逐个包装就行了...

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.zip.ZipInputStream;

import javax.servlet.ServletException;
import javax.servlet.http.HttpSession;

import org.jbpm.api.Execution;
import org.jbpm.api.ExecutionService;
import org.jbpm.api.HistoryService;
import org.jbpm.api.ProcessDefinition;
import org.jbpm.api.ProcessDefinitionQuery;
import org.jbpm.api.ProcessEngine;
import org.jbpm.api.ProcessInstance;
import org.jbpm.api.RepositoryService;
import org.jbpm.api.TaskService;
import org.jbpm.api.history.HistoryProcessInstance;
import org.jbpm.api.history.HistoryProcessInstanceQuery;
import org.jbpm.api.model.ActivityCoordinates;
import org.jbpm.api.task.Task;

import com.baolong.model.dto.User;

public class JbpmUtil {

	private ProcessEngine pe;
	private RepositoryService rs;
	private ExecutionService es;
	private TaskService ts;
	private HistoryService hs;
	
	public JbpmUtil(ProcessEngine processEngine) {
		pe = processEngine;
		rs = pe.getRepositoryService();
		es = pe.getExecutionService();
		ts = pe.getTaskService();
		hs = pe.getHistoryService();
	}

	public void deploy(String name) throws FileNotFoundException {
		String filePath = Thread.currentThread().getContextClassLoader().getResource("/jbpm").getPath();
		ZipInputStream zis = new ZipInputStream(new FileInputStream(new File(filePath + name + ".zip")));
		rs.createDeployment().addResourcesFromZipInputStream(zis).deploy();
	}
	
	public void deleteByDeploymentId(String deploymentId) {
		rs.deleteDeploymentCascade(deploymentId);
	}
	
	/** 
     * 获取最新版本的流程定义 
     * @param request 
     * @param response 
     * @return 
     * @throws ServletException 
     * @throws IOException 
     */  
	public List<ProcessDefinition> getLatestProcessDefinition(String name)  
            throws ServletException, IOException {  
        List<ProcessDefinition> processDefinitions = rs  
                .createProcessDefinitionQuery().processDefinitionName(name).orderAsc(  
                        ProcessDefinitionQuery.PROPERTY_NAME).list();  
        Map<String, ProcessDefinition> map = new LinkedHashMap<String, ProcessDefinition>();  
        for (ProcessDefinition pd : processDefinitions) {  
            String key = pd.getKey();  
            ProcessDefinition definition = map.get(key);  
            if ((definition == null)  
                    || (definition.getVersion() < pd.getVersion())) {  
                map.put(key, pd);  
            }  
        }
        return new ArrayList(map.values());  
    } 
	
	/** 
     * 根据流程定义ID获取流程实例 
     * @param request 
     * @param response 
     * @return 
     * @throws ServletException 
     * @throws IOException 
     */  
	public List<ProcessInstance> getProcessInstancesByPdId(String pdId) {
		 return es.createProcessInstanceQuery().processDefinitionId(pdId).list();
	}
	
	/** 
     * 根据流程定义ID创建新的流程实例 
     * @param request 
     * @param response 
     * @return 
     * @throws ServletException 
     * @throws IOException 
     */  
	public ProcessInstance getProcessInstanceByPiId(String piId) {
		return es.findProcessInstanceById(piId);
	}
		
	/** 
     * 根据流程定义ID创建新的流程实例 
     * @param request 
     * @param response 
     * @return 
     * @throws ServletException 
     * @throws IOException 
     */  
	public ProcessInstance startProcessInstanceByPdId(String pdId,Map map) {
		return es.startProcessInstanceById(pdId, map);
	}
	
	public ProcessDefinition getProcessDefinitionById(String pdId) {
		return rs.createProcessDefinitionQuery().processDefinitionId(pdId).uniqueResult();
	}
	
	public ProcessDefinition getProcessDefinitionByPiId(String piId) {
		String pdId = getProcessInstanceByPiId(piId).getProcessDefinitionId();
		return rs.createProcessDefinitionQuery().processDefinitionId(pdId).uniqueResult();
	}
	
	/** 
     * 根据流程实例ID删除流程实例 
     * @param request 
     * @param response 
     * @return 
     * @throws ServletException 
     * @throws IOException 
     */  
	public void deleteProcessInstanceByPiId(String piId) {
		es.deleteProcessInstanceCascade(piId);
	}
	
	/**
	 * 获取当前用户下的所有待办任务
	 * @param session
	 * @return
	 */
	public Task getTaskById(String taskId) {
		return ts.getTask(taskId);
	}
	
	/**
	 * 获取当前用户下的所有待办任务
	 * @param session
	 * @return
	 */
	public List<Task> getTasksByUser(HttpSession session) {
		return ts.findPersonalTasks(((User)session.getAttribute("user")).getId());
	}
	
	/**
	 * 根据流程实例下所有的Task
	 * @param session
	 * @return
	 */
	public List<Task> getTasksByPiId(String piId) {
		return ts.createTaskQuery().processInstanceId(piId).list();
	}
	
	/**
	 * 根据流程实例Id和ActiveName获取Task
	 * @param piId
	 * @param activeName
	 * @return
	 */
	public Task getTaskByPiIdAndActiveName(String piId,String activeName) {
		return ts.createTaskQuery().processInstanceId(piId).activityName(activeName).uniqueResult();
	}
	
	/**
	 * 根据流程实例Id和任务分配者获取Task
	 * @param piId
	 * @param activeName
	 * @return
	 */
	public Task getTaskByPiIdAndUser(String piId,String user) {
		return ts.createTaskQuery().processInstanceId(piId).assignee(user).uniqueResult(); 
	}
	
	public ProcessInstance getProcessInstanceByTask(String taskId) {
		Task task=ts.getTask(taskId);
		Execution execution = es.findExecutionById(task.getExecutionId());
		String piId = execution.getIsProcessInstance() ? execution.getId() : execution.getProcessInstance().getId();
		return getProcessInstanceByPiId(piId);
	}
	
	/**
	 * 处理流程
	 * @param taskId
	 * @param map
	 * @param result
	 */
	public void dispose(String taskId,Map<String,Object> map,String result) {
		//Task task = ts.getTask(taskId);
		ts.setVariables(taskId, map);
		
		if(StringUtil.isNull(result))
			ts.completeTask(taskId);
		else
			ts.completeTask(taskId,result);
	}
	
	/**
	 * 根据流程实例Id得到ActivityCoordinates
	 * @param piId
	 * @return
	 */
	public ActivityCoordinates getActivityCoordinates(String piId) {
		ProcessInstance pi = es.findProcessInstanceById(piId);
		Set<String> activityName = pi.findActiveActivityNames();
		return pe.getRepositoryService().getActivityCoordinates(pi.getProcessDefinitionId(), activityName.iterator().next());
	}
	
	/**
	 * 根据流程实例Id得到ActivityCoordinates
	 * @param piId
	 * @return
	 */
	public ActivityCoordinates getHistoryActivityCoordinates(String piId) {	
		HistoryProcessInstance hpi = getHistoryProcessInstancesByPiId(piId).get(0);
		return pe.getRepositoryService().getActivityCoordinates(hpi.getProcessDefinitionId(), hpi.getEndActivityName());
	}
	
	public List<HistoryProcessInstance> getHistoryProcessInstancesByDId(String dId) {
		return hs.createHistoryProcessInstanceQuery().processDefinitionId(dId).orderDesc(HistoryProcessInstanceQuery.PROPERTY_STARTTIME).list();
	}
	
	public List<HistoryProcessInstance> getHistoryProcessInstancesByPiId(String piId) {
		return hs.createHistoryProcessInstanceQuery().processInstanceId(piId).list();
	}
	
	public Execution findExecutionById(String eId) {
		return es.findExecutionById(eId);
	}
}