no commit message

JeeSpringCloud/jeespring-act/src/main/java/com/jeespring/modules/act/rest/editor/main/StencilsetRestResource.java

+/* Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.jeespring.modules.act.rest.editor.main;
+
+import java.io.InputStream;
+
+import org.activiti.engine.ActivitiException;
+import org.apache.commons.io.IOUtils;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * @author Tijs Rademakers
+ */
+@RestController
+public class StencilsetRestResource {
+	
+	@RequestMapping(value = "/act/service/editor/stencilset", method = RequestMethod.GET, produces = "application/json;charset=utf-8")
+	public @ResponseBody String getStencilset() {
+		InputStream stencilsetStream = this.getClass().getClassLoader().getResourceAsStream("stencilset.json");
+		try {
+			return IOUtils.toString(stencilsetStream, "utf-8");
+		} catch (Exception e) {
+			throw new ActivitiException("Error while loading stencil set", e);
+		}
+	}
+}

JeeSpringCloud/jeespring-act/src/main/java/com/jeespring/modules/act/rest/editor/model/ModelEditorJsonRestResource.java

+/* Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.jeespring.modules.act.rest.editor.model;
+
+import org.activiti.editor.constants.ModelDataJsonConstants;
+import org.activiti.engine.ActivitiException;
+import org.activiti.engine.RepositoryService;
+import org.activiti.engine.repository.Model;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.shiro.authz.annotation.RequiresPermissions;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.RestController;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+
+/**
+ * @author Tijs Rademakers
+ */
+@RestController
+public class ModelEditorJsonRestResource implements ModelDataJsonConstants {
+
+	protected static final Logger LOGGER = LoggerFactory.getLogger(ModelEditorJsonRestResource.class);
+
+	@Autowired
+	private RepositoryService repositoryService;
+
+//	@Autowired
+//	private ObjectMapper objectMapper;
+	protected ObjectMapper objectMapper = new ObjectMapper();
+
+	@RequiresPermissions("act:model:edit")
+	@RequestMapping(value = "/act/service/model/{modelId}/json", method = RequestMethod.GET, produces = "application/json")
+	public ObjectNode getEditorJson(@PathVariable String modelId) {
+		ObjectNode modelNode = null;
+
+		Model model = repositoryService.getModel(modelId);
+
+		if (model != null) {
+			try {
+				if (StringUtils.isNotEmpty(model.getMetaInfo())) {
+					modelNode = (ObjectNode) objectMapper.readTree(model.getMetaInfo());
+				} else {
+					modelNode = objectMapper.createObjectNode();
+					modelNode.put(MODEL_NAME, model.getName());
+				}
+				modelNode.put(MODEL_ID, model.getId());
+				ObjectNode editorJsonNode = (ObjectNode) objectMapper.readTree(new String(repositoryService.getModelEditorSource(model.getId()),
+						"utf-8"));
+				modelNode.put("model", editorJsonNode);
+
+			} catch (Exception e) {
+				LOGGER.error("Error creating model JSON", e);
+				throw new ActivitiException("Error creating model JSON", e);
+			}
+		}
+		return modelNode;
+	}
+}

JeeSpringCloud/jeespring-act/src/main/java/com/jeespring/modules/act/rest/editor/model/ModelSaveRestResource.java

+/* Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.jeespring.modules.act.rest.editor.model;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.InputStream;
+
+import org.activiti.editor.constants.ModelDataJsonConstants;
+import org.activiti.engine.ActivitiException;
+import org.activiti.engine.RepositoryService;
+import org.activiti.engine.repository.Model;
+import org.apache.batik.transcoder.TranscoderInput;
+import org.apache.batik.transcoder.TranscoderOutput;
+import org.apache.batik.transcoder.image.PNGTranscoder;
+import org.apache.log4j.Logger;
+import org.apache.shiro.authz.annotation.RequiresPermissions;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.util.LinkedMultiValueMap;
+import org.springframework.util.MultiValueMap;
+import org.springframework.web.bind.annotation.*;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+/**
+ * @author Tijs Rademakers
+ */
+@RestController
+public class ModelSaveRestResource implements ModelDataJsonConstants {
+
+	protected static final Logger LOGGER = Logger.getLogger(ModelSaveRestResource.class);
+
+	@Autowired
+	private RepositoryService repositoryService;
+
+	//	@Autowired
+	//	private ObjectMapper objectMapper;
+	protected ObjectMapper objectMapper = new ObjectMapper();
+
+	@RequiresPermissions("act:model:edit")
+	@RequestMapping(value = "/act/service/model/{modelId}/save",method ={RequestMethod.POST,RequestMethod.GET,RequestMethod.PUT})
+	@ResponseStatus(value = HttpStatus.OK)
+	// @RequestBody MultiValueMap<String, String> values,MultiValueMap<String, String> valuesa
+	public void saveModel(@PathVariable String modelId, HttpServletRequest request, HttpServletResponse response) {
+		try {
+			MultiValueMap<String, String> values=new LinkedMultiValueMap<>();;
+			Model model = repositoryService.getModel(modelId);
+			String name="",description="",json_xml="",svg_xml="";
+			values.add("name",request.getParameter("name"));
+			values.add("description",request.getParameter("description"));
+			values.add("json_xml",request.getParameter("json_xml"));
+			values.add("svg_xml",request.getParameter("svg_xml"));
+			ObjectNode modelJson = (ObjectNode) objectMapper.readTree(model.getMetaInfo());
+
+			modelJson.put(MODEL_NAME, values.getFirst("name"));
+			modelJson.put(MODEL_DESCRIPTION, values.getFirst("description"));
+			model.setMetaInfo(modelJson.toString());
+			model.setName(values.getFirst("name"));
+
+			repositoryService.saveModel(model);
+
+			repositoryService.addModelEditorSource(model.getId(), values.getFirst("json_xml").getBytes("utf-8"));
+
+			InputStream svgStream = new ByteArrayInputStream(values.getFirst("svg_xml").getBytes("utf-8"));
+			TranscoderInput input = new TranscoderInput(svgStream);
+
+			PNGTranscoder transcoder = new PNGTranscoder();
+			// Setup output
+			ByteArrayOutputStream outStream = new ByteArrayOutputStream();
+			TranscoderOutput output = new TranscoderOutput(outStream);
+
+			// Do the transformation
+			transcoder.transcode(input, output);
+			final byte[] result = outStream.toByteArray();
+			repositoryService.addModelEditorSourceExtra(model.getId(), result);
+			outStream.close();
+
+		} catch (Exception e) {
+			LOGGER.error("Error saving model", e);
+			throw new ActivitiException("Error saving model", e);
+		}
+	}
+}

JeeSpringCloud/jeespring-act/src/main/java/com/jeespring/modules/act/rest/servlet/FilterServletOutputStream.java

+package com.jeespring.modules.act.rest.servlet;
+
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+
+import javax.servlet.ServletOutputStream;
+import javax.servlet.WriteListener;
+
+public class FilterServletOutputStream extends ServletOutputStream {
+
+	private DataOutputStream stream;
+
+	public FilterServletOutputStream(OutputStream output) {
+		stream = new DataOutputStream(output);
+	}
+
+	@Override
+    public void write(int b) throws IOException {
+		stream.write(b);
+	}
+
+	@Override
+    public void write(byte[] b) throws IOException {
+		stream.write(b);
+	}
+
+	@Override
+    public void write(byte[] b, int off, int len) throws IOException {
+		stream.write(b, off, len);
+	}
+
+	@Override
+	public boolean isReady() {
+		return false;
+	}
+
+	@Override
+	public void setWriteListener(WriteListener writeListener) {
+
+	}
+}
\ No newline at end of file

JeeSpringCloud/jeespring-act/src/main/java/com/jeespring/modules/act/rest/servlet/GenericResponseWrapper.java

+package com.jeespring.modules.act.rest.servlet;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintWriter;
+
+import javax.servlet.ServletOutputStream;
+import javax.servlet.http.HttpServletResponse;
+import javax.servlet.http.HttpServletResponseWrapper;
+
+public class GenericResponseWrapper extends HttpServletResponseWrapper {
+	
+	private ByteArrayOutputStream output;
+	private int contentLength;
+	private String contentType;
+
+	public GenericResponseWrapper(HttpServletResponse response) {
+		super(response);
+		output = new ByteArrayOutputStream();
+	}
+
+	public byte[] getData() {
+		return output.toByteArray();
+	}
+
+	@Override
+    public ServletOutputStream getOutputStream() {
+		return new FilterServletOutputStream(output);
+	}
+
+	@Override
+    public PrintWriter getWriter() {
+		return new PrintWriter(getOutputStream(), true);
+	}
+
+	@Override
+    public void setContentLength(int length) {
+		this.contentLength = length;
+		super.setContentLength(length);
+	}
+
+	public int getContentLength() {
+		return contentLength;
+	}
+
+	@Override
+    public void setContentType(String type) {
+		this.contentType = type;
+		super.setContentType(type);
+	}
+
+	@Override
+    public String getContentType() {
+		return contentType;
+	}
+}

JeeSpringCloud/jeespring-act/src/main/java/com/jeespring/modules/act/rest/servlet/JsonpCallbackFilter.java

+package com.jeespring.modules.act.rest.servlet;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.Map;
+
+import javax.servlet.Filter;
+import javax.servlet.FilterChain;
+import javax.servlet.FilterConfig;
+import javax.servlet.ServletException;
+import javax.servlet.ServletRequest;
+import javax.servlet.ServletResponse;
+import javax.servlet.annotation.WebFilter;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@WebFilter(urlPatterns={"/act/service/*"})
+public class JsonpCallbackFilter implements Filter
+ {
+
+	private static Logger log = LoggerFactory.getLogger(JsonpCallbackFilter.class);
+
+	@Override
+	public void init(FilterConfig fConfig) throws ServletException {}
+
+	@Override
+	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
+		
+		HttpServletRequest httpRequest = (HttpServletRequest) request;
+		HttpServletResponse httpResponse = (HttpServletResponse) response;
+
+		@SuppressWarnings("unchecked")
+		Map<String, String[]> parms = httpRequest.getParameterMap();
+
+		if (parms.containsKey("callback")) {
+			if (log.isDebugEnabled()) {
+				log.debug("Wrapping response with JSONP callback '" + parms.get("callback")[0] + "'");
+			}
+
+			OutputStream out = httpResponse.getOutputStream();
+
+			GenericResponseWrapper wrapper = new GenericResponseWrapper(httpResponse);
+
+			chain.doFilter(request, wrapper);
+
+			//handles the content-size truncation
+			ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+			outputStream.write(new String(parms.get("callback")[0] + "(").getBytes());
+			outputStream.write(wrapper.getData());
+			outputStream.write(new String(");").getBytes());
+			byte[] jsonpResponse = outputStream.toByteArray();
+
+			wrapper.setContentType("text/javascript;charset=UTF-8");
+			wrapper.setContentLength(jsonpResponse.length);
+
+			out.write(jsonpResponse);
+
+			out.close();
+
+		} else {
+			chain.doFilter(request, response);
+		}
+	}
+
+	@Override
+	public void destroy() {}
+}

JeeSpringCloud/jeespring-act/src/main/java/com/jeespring/modules/act/service/ActModelService.java

+/**
+ * Copyright &copy; 2012-2016 <a href="https://gitee.com/JeeHuangBingGui/jeeSpringCloud">JeeSpring</a> All rights reserved.
+ */
+package com.jeespring.modules.act.service;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+import java.util.List;
+
+import javax.servlet.http.HttpServletResponse;
+
+import org.activiti.bpmn.converter.BpmnXMLConverter;
+import org.activiti.bpmn.model.BpmnModel;
+import org.activiti.editor.constants.ModelDataJsonConstants;
+import org.activiti.editor.language.json.converter.BpmnJsonConverter;
+import org.activiti.engine.ActivitiException;
+import org.activiti.engine.RepositoryService;
+import org.activiti.engine.repository.Deployment;
+import org.activiti.engine.repository.Model;
+import org.activiti.engine.repository.ModelQuery;
+import org.activiti.engine.repository.ProcessDefinition;
+import org.apache.commons.io.IOUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.jeespring.common.persistence.Page;
+import com.jeespring.common.service.AbstractService;
+
+/**
+ * 流程模型相关Controller
+ * @author JeeSpring
+ * @version 2013-11-03
+ */
+@Service
+@Transactional(readOnly = true)
+public class ActModelService extends AbstractService {
+
+	@Autowired
+	private RepositoryService repositoryService;
+	
+//	@Autowired
+//	private ObjectMapper objectMapper;
+	protected ObjectMapper objectMapper = new ObjectMapper();
+
+	/**
+	 * 流程模型列表
+	 */
+	public Page<Model> modelList(Page<Model> page, String category) {
+
+		ModelQuery modelQuery = repositoryService.createModelQuery().latestVersion().orderByLastUpdateTime().desc();
+		
+		if (StringUtils.isNotEmpty(category)){
+			modelQuery.modelCategory(category);
+		}
+		
+		page.setCount(modelQuery.count());
+		page.setList(modelQuery.listPage(page.getFirstResult(), page.getMaxResults()));
+
+		return page;
+	}
+
+	/**
+	 * 创建模型
+	 * @throws UnsupportedEncodingException 
+	 */
+	@Transactional(readOnly = false)
+	public Model create(String name, String key, String description, String category) throws UnsupportedEncodingException {
+		
+		ObjectNode editorNode = objectMapper.createObjectNode();
+		editorNode.put("id", "canvas");
+		editorNode.put("resourceId", "canvas");
+		ObjectNode properties = objectMapper.createObjectNode();
+		properties.put("process_author", "jeesite");
+		editorNode.put("properties", properties);
+		ObjectNode stencilset = objectMapper.createObjectNode();
+		stencilset.put("namespace", "http://b3mn.org/stencilset/bpmn2.0#");
+		editorNode.put("stencilset", stencilset);
+		
+		Model modelData = repositoryService.newModel();
+		description = StringUtils.defaultString(description);
+		modelData.setKey(StringUtils.defaultString(key));
+		modelData.setName(name);
+		modelData.setCategory(category);
+		modelData.setVersion(Integer.parseInt(String.valueOf(repositoryService.createModelQuery().modelKey(modelData.getKey()).count()+1)));
+
+		ObjectNode modelObjectNode = objectMapper.createObjectNode();
+		modelObjectNode.put(ModelDataJsonConstants.MODEL_NAME, name);
+		modelObjectNode.put(ModelDataJsonConstants.MODEL_REVISION, modelData.getVersion());
+		modelObjectNode.put(ModelDataJsonConstants.MODEL_DESCRIPTION, description);
+		modelData.setMetaInfo(modelObjectNode.toString());
+		
+		repositoryService.saveModel(modelData);
+		repositoryService.addModelEditorSource(modelData.getId(), editorNode.toString().getBytes("utf-8"));
+		
+		return modelData;
+	}
+
+	/**
+	 * 根据Model部署流程
+	 */
+	@Transactional(readOnly = false)
+	public String deploy(String id) {
+		String message = "";
+		try {
+			Model modelData = repositoryService.getModel(id);
+			BpmnJsonConverter jsonConverter = new BpmnJsonConverter();
+			JsonNode editorNode = new ObjectMapper().readTree(repositoryService.getModelEditorSource(modelData.getId()));
+			BpmnModel bpmnModel = jsonConverter.convertToBpmnModel(editorNode);
+			BpmnXMLConverter xmlConverter = new BpmnXMLConverter();
+			byte[] bpmnBytes = xmlConverter.convertToXML(bpmnModel);
+			
+			String processName = modelData.getName();
+			if (!StringUtils.endsWith(processName, ".bpmn20.xml")){
+				processName += ".bpmn20.xml";
+			}
+//			System.out.println("========="+processName+"============"+modelData.getName());
+			ByteArrayInputStream in = new ByteArrayInputStream(bpmnBytes);
+			Deployment deployment = repositoryService.createDeployment().name(modelData.getName())
+					.addInputStream(processName, in).deploy();
+//					.addString(processName, new String(bpmnBytes)).deploy();
+			
+			// 设置流程分类
+			List<ProcessDefinition> list = repositoryService.createProcessDefinitionQuery().deploymentId(deployment.getId()).list();
+			for (ProcessDefinition processDefinition : list) {
+				repositoryService.setProcessDefinitionCategory(processDefinition.getId(), modelData.getCategory());
+				message = "部署成功，流程ID=" + processDefinition.getId();
+			}
+			if (list.size() == 0){
+				message = "部署失败，没有流程。";
+			}
+		} catch (Exception e) {
+			throw new ActivitiException("设计模型图不正确，检查模型正确性，模型ID="+id, e);
+		}
+		return message;
+	}
+	
+	/**
+	 * 导出model的xml文件
+	 * @throws IOException 
+	 * @throws JsonProcessingException 
+	 */
+	public void export(String id, HttpServletResponse response) {
+		try {
+			Model modelData = repositoryService.getModel(id);
+			BpmnJsonConverter jsonConverter = new BpmnJsonConverter();
+			JsonNode editorNode = new ObjectMapper().readTree(repositoryService.getModelEditorSource(modelData.getId()));
+			BpmnModel bpmnModel = jsonConverter.convertToBpmnModel(editorNode);
+			BpmnXMLConverter xmlConverter = new BpmnXMLConverter();
+			byte[] bpmnBytes = xmlConverter.convertToXML(bpmnModel);
+
+			ByteArrayInputStream in = new ByteArrayInputStream(bpmnBytes);
+			IOUtils.copy(in, response.getOutputStream());
+			String filename = bpmnModel.getMainProcess().getId() + ".bpmn20.xml";
+			response.setHeader("Content-Disposition", "attachment; filename=" + filename);
+			response.flushBuffer();
+		} catch (Exception e) {
+			throw new ActivitiException("导出model的xml文件失败，模型ID="+id, e);
+		}
+		
+	}
+
+	/**
+	 * 更新Model分类
+	 */
+	@Transactional(readOnly = false)
+	public void updateCategory(String id, String category) {
+		Model modelData = repositoryService.getModel(id);
+		modelData.setCategory(category);
+		repositoryService.saveModel(modelData);
+	}
+	
+	/**
+	 * 删除模型
+	 * @param id
+	 * @return
+	 */
+	@Transactional(readOnly = false)
+	public void delete(String id) {
+		repositoryService.deleteModel(id);
+	}
+}

JeeSpringCloud/jeespring-act/src/main/java/com/jeespring/modules/act/service/ActProcessService.java

+/**
+ * Copyright &copy; 2012-2016 <a href="https://gitee.com/JeeHuangBingGui/jeeSpringCloud">JeeSpring</a> All rights reserved.
+ */
+package com.jeespring.modules.act.service;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.UnsupportedEncodingException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.zip.ZipInputStream;
+
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+
+import org.activiti.bpmn.converter.BpmnXMLConverter;
+import org.activiti.bpmn.model.BpmnModel;
+import org.activiti.editor.constants.ModelDataJsonConstants;
+import org.activiti.editor.language.json.converter.BpmnJsonConverter;
+import org.activiti.engine.ActivitiException;
+import org.activiti.engine.RepositoryService;
+import org.activiti.engine.RuntimeService;
+import org.activiti.engine.repository.Deployment;
+import org.activiti.engine.repository.ProcessDefinition;
+import org.activiti.engine.repository.ProcessDefinitionQuery;
+import org.activiti.engine.runtime.ProcessInstance;
+import org.activiti.engine.runtime.ProcessInstanceQuery;
+import org.apache.commons.io.FileUtils;
+import org.apache.commons.io.FilenameUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.multipart.MultipartFile;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.jeespring.common.persistence.Page;
+import com.jeespring.common.service.AbstractService;
+import com.jeespring.common.utils.StringUtils;
+
+/**
+ * 流程定义相关Controller
+ * @author JeeSpring
+ * @version 2013-11-03
+ */
+@Service
+@Transactional(readOnly = true)
+public class ActProcessService extends AbstractService {
+
+	@Autowired
+	private RepositoryService repositoryService;
+	@Autowired
+	private RuntimeService runtimeService;
+
+	/**
+	 * 流程定义列表
+	 */
+	public Page<Object[]> processList(Page<Object[]> page, String category) {
+
+	    ProcessDefinitionQuery processDefinitionQuery = repositoryService.createProcessDefinitionQuery()
+	    		.latestVersion().orderByProcessDefinitionKey().asc();
+	    
+	    if (StringUtils.isNotEmpty(category)){
+	    	processDefinitionQuery.processDefinitionCategory(category);
+		}
+	    
+	    page.setCount(processDefinitionQuery.count());
+	    
+	    List<ProcessDefinition> processDefinitionList = processDefinitionQuery.listPage(page.getFirstResult(), page.getMaxResults());
+	    for (ProcessDefinition processDefinition : processDefinitionList) {
+	      String deploymentId = processDefinition.getDeploymentId();
+	      Deployment deployment = repositoryService.createDeploymentQuery().deploymentId(deploymentId).singleResult();
+	      page.getList().add(new Object[]{processDefinition, deployment});
+	    }
+
+		return page;
+	}
+
+	/**
+	 * 流程定义列表
+	 */
+	public Page<ProcessInstance> runningList(Page<ProcessInstance> page, String procInsId, String procDefKey) {
+
+	    ProcessInstanceQuery processInstanceQuery = runtimeService.createProcessInstanceQuery();
+
+	    if (StringUtils.isNotBlank(procInsId)){
+		    processInstanceQuery.processInstanceId(procInsId);
+	    }
+	    
+	    if (StringUtils.isNotBlank(procDefKey)){
+		    processInstanceQuery.processDefinitionKey(procDefKey);
+	    }
+	    
+	    page.setCount(processInstanceQuery.count());
+	    page.setList(processInstanceQuery.listPage(page.getFirstResult(), page.getMaxResults()));
+		return page;
+	}
+	
+	/**
+	 * 读取资源，通过部署ID
+	 * @param processDefinitionId  流程定义ID
+	 * @param processInstanceId 流程实例ID
+	 * @param resourceType 资源类型(xml|image)
+	 */
+	public InputStream resourceRead(String procDefId, String proInsId, String resType) throws Exception {
+		
+		if (StringUtils.isBlank(procDefId)){
+			ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processInstanceId(proInsId).singleResult();
+			procDefId = processInstance.getProcessDefinitionId();
+		}
+		ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().processDefinitionId(procDefId).singleResult();
+		
+		String resourceName = "";
+		if ("image".equals(resType)) {
+			resourceName = processDefinition.getDiagramResourceName();
+		} else if ("xml".equals(resType)) {
+			resourceName = processDefinition.getResourceName();
+		}
+		
+		InputStream resourceAsStream = repositoryService.getResourceAsStream(processDefinition.getDeploymentId(), resourceName);
+		return resourceAsStream;
+	}
+	
+	/**
+	 * 部署流程 - 保存
+	 * @param file
+	 * @return
+	 */
+	@Transactional(readOnly = false)
+	public String deploy(String exportDir, String category, MultipartFile file) {
+
+		String message = "";
+		
+		String fileName = file.getOriginalFilename();
+		
+		try {
+			InputStream fileInputStream = file.getInputStream();
+			Deployment deployment;
+			String extension = FilenameUtils.getExtension(fileName);
+			if ("zip".equals(extension) || "bar".equals(extension)) {
+				ZipInputStream zip = new ZipInputStream(fileInputStream);
+				deployment = repositoryService.createDeployment().addZipInputStream(zip).deploy();
+			} else if ("png".equals(extension)) {
+				deployment = repositoryService.createDeployment().addInputStream(fileName, fileInputStream).deploy();
+			} else if (fileName.indexOf("bpmn20.xml") != -1) {
+				deployment = repositoryService.createDeployment().addInputStream(fileName, fileInputStream).deploy();
+			} else if ("bpmn".equals(extension)) { // bpmn扩展名特殊处理，转换为bpmn20.xml
+				String baseName = FilenameUtils.getBaseName(fileName); 
+				deployment = repositoryService.createDeployment().addInputStream(baseName + ".bpmn20.xml", fileInputStream).deploy();
+			} else {
+				message = "不支持的文件类型：" + extension;
+				return message;
+			}
+			
+			List<ProcessDefinition> list = repositoryService.createProcessDefinitionQuery().deploymentId(deployment.getId()).list();
+
+			// 设置流程分类
+			for (ProcessDefinition processDefinition : list) {
+//					ActUtils.exportDiagramToFile(repositoryService, processDefinition, exportDir);
+				repositoryService.setProcessDefinitionCategory(processDefinition.getId(), category);
+				message += "部署成功，流程ID=" + processDefinition.getId() + "<br/>";
+			}
+			
+			if (list.size() == 0){
+				message = "部署失败，没有流程。";
+			}
+			
+		} catch (Exception e) {
+			throw new ActivitiException("部署失败！", e);
+		}
+		return message;
+	}
+	
+	/**
+	 * 设置流程分类
+	 */
+	@Transactional(readOnly = false)
+	public void updateCategory(String procDefId, String category) {
+		repositoryService.setProcessDefinitionCategory(procDefId, category);
+	}
+
+	/**
+	 * 挂起、激活流程实例
+	 */
+	@Transactional(readOnly = false)
+	public String updateState(String state, String procDefId) {
+		if ("active".equals(state)) {
+			repositoryService.activateProcessDefinitionById(procDefId, true, null);
+			return "已激活ID为[" + procDefId + "]的流程定义。";
+		} else if ("suspend".equals(state)) {
+			repositoryService.suspendProcessDefinitionById(procDefId, true, null);
+			return "已挂起ID为[" + procDefId + "]的流程定义。";
+		}
+		return "无操作";
+	}
+	
+	/**
+	 * 将部署的流程转换为模型
+	 * @param procDefId
+	 * @throws UnsupportedEncodingException
+	 * @throws XMLStreamException
+	 */
+	@Transactional(readOnly = false)
+	public org.activiti.engine.repository.Model convertToModel(String procDefId) throws UnsupportedEncodingException, XMLStreamException {
+		
+		ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().processDefinitionId(procDefId).singleResult();
+		InputStream bpmnStream = repositoryService.getResourceAsStream(processDefinition.getDeploymentId(),
+		processDefinition.getResourceName());
+		XMLInputFactory xif = XMLInputFactory.newInstance();
+		InputStreamReader in = new InputStreamReader(bpmnStream, "UTF-8");
+		XMLStreamReader xtr = xif.createXMLStreamReader(in);
+		BpmnModel bpmnModel = new BpmnXMLConverter().convertToBpmnModel(xtr);
+	
+		BpmnJsonConverter converter = new BpmnJsonConverter();
+		ObjectNode modelNode = converter.convertToJson(bpmnModel);
+		org.activiti.engine.repository.Model modelData = repositoryService.newModel();
+		modelData.setKey(processDefinition.getKey());
+		modelData.setName(processDefinition.getResourceName());
+		modelData.setCategory(processDefinition.getCategory());//.getDeploymentId());
+		modelData.setDeploymentId(processDefinition.getDeploymentId());
+		modelData.setVersion(Integer.parseInt(String.valueOf(repositoryService.createModelQuery().modelKey(modelData.getKey()).count()+1)));
+	
+		ObjectNode modelObjectNode = new ObjectMapper().createObjectNode();
+		modelObjectNode.put(ModelDataJsonConstants.MODEL_NAME, processDefinition.getName());
+		modelObjectNode.put(ModelDataJsonConstants.MODEL_REVISION, modelData.getVersion());
+		modelObjectNode.put(ModelDataJsonConstants.MODEL_DESCRIPTION, processDefinition.getDescription());
+		modelData.setMetaInfo(modelObjectNode.toString());
+	
+		repositoryService.saveModel(modelData);
+	
+		repositoryService.addModelEditorSource(modelData.getId(), modelNode.toString().getBytes("utf-8"));
+	
+		return modelData;
+	}
+	
+	/**
+	 * 导出图片文件到硬盘
+	 */
+	public List<String> exportDiagrams(String exportDir) throws IOException {
+		List<String> files = new ArrayList<String>();
+		List<ProcessDefinition> list = repositoryService.createProcessDefinitionQuery().list();
+		
+		for (ProcessDefinition processDefinition : list) {
+			String diagramResourceName = processDefinition.getDiagramResourceName();
+			String key = processDefinition.getKey();
+			int version = processDefinition.getVersion();
+			String diagramPath = "";
+
+			InputStream resourceAsStream = repositoryService.getResourceAsStream(
+					processDefinition.getDeploymentId(), diagramResourceName);
+			byte[] b = new byte[resourceAsStream.available()];
+
+			@SuppressWarnings("unused")
+			int len = -1;
+			resourceAsStream.read(b, 0, b.length);
+
+			// create file if not exist
+			String diagramDir = exportDir + "/" + key + "/" + version;
+			File diagramDirFile = new File(diagramDir);
+			if (!diagramDirFile.exists()) {
+				diagramDirFile.mkdirs();
+			}
+			diagramPath = diagramDir + "/" + diagramResourceName;
+			File file = new File(diagramPath);
+
+			// 文件存在退出
+			if (file.exists()) {
+				// 文件大小相同时直接返回否则重新创建文件(可能损坏)
+				logger.debug("diagram exist, ignore... : {}", diagramPath);
+				
+				files.add(diagramPath);
+			} else {
+				file.createNewFile();
+				logger.debug("export diagram to : {}", diagramPath);
+
+				// wirte bytes to file
+				FileUtils.writeByteArrayToFile(file, b, true);
+				
+				files.add(diagramPath);
+			}
+			
+		}
+		
+		return files;
+	}
+
+	/**
+	 * 删除部署的流程，级联删除流程实例
+	 * @param deploymentId 流程部署ID
+	 */
+	@Transactional(readOnly = false)
+	public void deleteDeployment(String deploymentId) {
+		repositoryService.deleteDeployment(deploymentId, true);
+	}
+	
+	/**
+	 * 删除部署的流程实例
+	 * @param procInsId 流程实例ID
+	 * @param deleteReason 删除原因，可为空
+	 */
+	@Transactional(readOnly = false)
+	public void deleteProcIns(String procInsId, String deleteReason) {
+		runtimeService.deleteProcessInstance(procInsId, deleteReason);
+	}
+	
+}

JeeSpringCloud/jeespring-act/src/main/java/com/jeespring/modules/act/service/cmd/CreateAndTakeTransitionCmd.java

+package com.jeespring.modules.act.service.cmd;
+
+import java.util.Map;
+
+import org.activiti.engine.impl.context.Context;
+import org.activiti.engine.impl.interceptor.Command;
+import org.activiti.engine.impl.interceptor.CommandContext;
+import org.activiti.engine.impl.persistence.entity.ExecutionEntity;
+import org.activiti.engine.impl.persistence.entity.TaskEntity;
+import org.activiti.engine.impl.pvm.process.ActivityImpl;
+import org.activiti.engine.impl.pvm.runtime.AtomicOperation;
+
+public class CreateAndTakeTransitionCmd implements Command<Void> {
+	
+	private TaskEntity currentTaskEntity;
+	private ActivityImpl activity;
+	protected Map<String, Object> variables;
+
+	public CreateAndTakeTransitionCmd(TaskEntity currentTaskEntity, ActivityImpl activity, Map<String, Object> variables) {
+		this.currentTaskEntity = currentTaskEntity;
+		this.activity = activity;
+		this.variables = variables;
+	}
+
+	@Override
+	public Void execute(CommandContext commandContext) {
+		if (currentTaskEntity != null) {
+
+			ExecutionEntity execution = commandContext.getExecutionEntityManager().findExecutionById(currentTaskEntity.getExecutionId());
+			execution.setActivity(activity);
+			execution.performOperation(AtomicOperation.TRANSITION_CREATE_SCOPE);
+
+			if (variables != null) {
+				if (currentTaskEntity.getExecutionId() != null) {
+					currentTaskEntity.setExecutionVariables(variables);
+				} else {
+					currentTaskEntity.setVariables(variables);
+				}
+			}
+			//删除当前的任务，不能删除当前正在执行的任务，所以要先清除掉关联
+			Context.getCommandContext().getTaskEntityManager().deleteTask(currentTaskEntity, TaskEntity.DELETE_REASON_DELETED, false);
+		}
+		return null;
+	}
+}
\ No newline at end of file

JeeSpringCloud/jeespring-act/src/main/java/com/jeespring/modules/act/service/cmd/JumpTaskCmd.java

+package com.jeespring.modules.act.service.cmd;
+
+import java.util.Map;
+
+import org.activiti.engine.impl.context.Context;
+import org.activiti.engine.impl.interceptor.Command;
+import org.activiti.engine.impl.interceptor.CommandContext;
+import org.activiti.engine.impl.persistence.entity.ExecutionEntity;
+import org.activiti.engine.impl.persistence.entity.TaskEntity;
+import org.activiti.engine.impl.pvm.process.ActivityImpl;
+import org.activiti.engine.impl.pvm.runtime.AtomicOperation;
+
+public class JumpTaskCmd implements Command<Void> {
+	
+	private TaskEntity taskEntity;
+	private ActivityImpl targetActivity;
+	protected Map<String, Object> variables;
+
+	public JumpTaskCmd(TaskEntity taskEntity, ActivityImpl targetActivity, Map<String, Object> variables) {
+		this.taskEntity = taskEntity;
+		this.targetActivity = targetActivity;
+		this.variables = variables;
+	}
+
+	@Override
+	public Void execute(CommandContext commandContext) {
+		
+		if (taskEntity != null) {
+			
+			//删除当前的任务，不能删除当前正在执行的任务，所以要先清除掉关联
+			if (variables != null) {
+				if (taskEntity.getExecutionId() != null) {
+					taskEntity.setExecutionVariables(variables);
+				} else {
+					taskEntity.setVariables(variables);
+				}
+			}
+
+//			// 完成活动历史
+//			Context.getCommandContext().getHistoryManager()
+//				.recordActivityEnd((ExecutionEntity) taskEntity.getExecution());
+			
+			// 完成待办任务
+			Context.getCommandContext().getTaskEntityManager().deleteTask(taskEntity, 
+					TaskEntity.DELETE_REASON_COMPLETED, false);	// DELETE_REASON_DELETED  DELETE_REASON_COMPLETED
+			
+			// 跳转任务
+			ExecutionEntity execution = taskEntity.getExecution();
+			execution.setActivity(targetActivity);
+			execution.performOperation(AtomicOperation.ACTIVITY_START);
+			
+		}
+
+		return null;
+	}
+}
\ No newline at end of file

JeeSpringCloud/jeespring-act/src/main/java/com/jeespring/modules/act/service/cmd/ModelDeployProcessDefinitionCmd.java

+package com.jeespring.modules.act.service.cmd;
+
+import java.io.ByteArrayInputStream;
+
+import org.activiti.bpmn.converter.BpmnXMLConverter;
+import org.activiti.bpmn.model.BpmnModel;
+import org.activiti.editor.language.json.converter.BpmnJsonConverter;
+import org.activiti.engine.ActivitiException;
+import org.activiti.engine.RepositoryService;
+import org.activiti.engine.impl.cfg.ProcessEngineConfigurationImpl;
+import org.activiti.engine.impl.context.Context;
+import org.activiti.engine.impl.db.DbSqlSession;
+import org.activiti.engine.impl.interceptor.Command;
+import org.activiti.engine.impl.interceptor.CommandContext;
+import org.activiti.engine.impl.persistence.entity.DeploymentEntity;
+import org.activiti.engine.impl.persistence.entity.ResourceEntity;
+import org.activiti.engine.impl.persistence.entity.ResourceEntityManager;
+import org.activiti.engine.impl.util.IoUtil;
+import org.activiti.engine.repository.ProcessDefinition;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+/**
+ * 模型部署或更新到流程定义
+ * @author JeeSpring
+ * @version 2016年8月2日
+ */
+public class ModelDeployProcessDefinitionCmd implements Command<Void> {
+	
+	private String modelId;
+	private String procDefKey;
+	private String procDefName;
+
+	public ModelDeployProcessDefinitionCmd(String modelId, String procDefKey, String procDefName) {
+		this.modelId = modelId;
+		this.procDefKey = procDefKey;
+		this.procDefName = procDefName;
+	}
+
+	@Override
+	public Void execute(CommandContext commandContext) {
+		RepositoryService repositoryService = Context.getProcessEngineConfiguration()
+				.getRepositoryService();
+		try{
+			// 生成部署名称和数据 JeeSpring
+			JsonNode editorNode = new ObjectMapper().readTree(repositoryService
+						.getModelEditorSource(modelId));
+			BpmnModel bpmnModel = new BpmnJsonConverter().convertToBpmnModel(editorNode);
+			byte[] bpmnBytes = new BpmnXMLConverter().convertToXML(bpmnModel);
+			
+			// 查询流程定义是否已经存在了 JeeSpring
+			ProcessDefinition processDefinition = Context.getProcessEngineConfiguration()
+					.getRepositoryService().createProcessDefinitionQuery()
+					.processDefinitionKey(procDefKey).latestVersion().singleResult();
+			if (processDefinition != null){
+				ResourceEntityManager resourceEntityManager = commandContext.getResourceEntityManager();
+				DeploymentEntity deployment = (DeploymentEntity)repositoryService.createDeploymentQuery()
+						.deploymentId(processDefinition.getDeploymentId()).singleResult();
+				
+				// 删除原资源
+				resourceEntityManager.deleteResourcesByDeploymentId(deployment.getId());
+				Context.getCommandContext().getSession(DbSqlSession.class).flush();
+				
+				// 插入新资源
+			    ResourceEntity resource = new ResourceEntity();
+			    resource.setDeploymentId(deployment.getId());
+			    resource.setName(procDefName + ".bpmn20.xml");
+			    resource.setBytes(bpmnBytes);
+				deployment.addResource(resource);
+				resourceEntityManager.insertResource(resource);
+				
+				// 插入资源图片
+				ProcessEngineConfigurationImpl processEngineConfiguration = Context.getProcessEngineConfiguration();
+				byte[] diagramBytes = IoUtil.readInputStream(processEngineConfiguration.
+	                    getProcessDiagramGenerator().generateDiagram(bpmnModel, "png", processEngineConfiguration.getActivityFontName(),
+	                        processEngineConfiguration.getLabelFontName(),processEngineConfiguration.getAnnotationFontName(), processEngineConfiguration.getClassLoader()), null);
+				ResourceEntity diagramResource = new ResourceEntity();
+				diagramResource.setDeploymentId(deployment.getId());
+				diagramResource.setName(procDefName + "." + processDefinition.getKey() + ".png");
+				diagramResource.setBytes(diagramBytes);
+				deployment.addResource(diagramResource);
+				resourceEntityManager.insertResource(diagramResource);
+			}
+			// 不存在部署一个新的流程 JeeSpring
+			else{ 
+				repositoryService.createDeployment().name(procDefName).addInputStream(
+						procDefName + ".bpmn20.xml", new ByteArrayInputStream(bpmnBytes)).deploy();
+			}
+		}catch(Exception e){
+			throw new ActivitiException("模型部署到流程定义错误", e);
+		}
+		return null;
+	}
+}
\ No newline at end of file

JeeSpringCloud/jeespring-act/src/main/java/com/jeespring/modules/act/service/creator/ChainedActivitiesCreator.java

+package com.jeespring.modules.act.service.creator;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.activiti.engine.ProcessEngine;
+import org.activiti.engine.impl.persistence.entity.ProcessDefinitionEntity;
+import org.activiti.engine.impl.pvm.process.ActivityImpl;
+import org.springframework.util.CollectionUtils;
+
+import com.jeespring.modules.act.utils.ProcessDefUtils;
+
+public class ChainedActivitiesCreator extends RuntimeActivityCreatorSupport implements RuntimeActivityCreator {
+	
+	@Override
+    @SuppressWarnings("unchecked")
+	public ActivityImpl[] createActivities(ProcessEngine processEngine, ProcessDefinitionEntity processDefinition,
+			RuntimeActivityDefinitionEntity info) {
+		info.setFactoryName(ChainedActivitiesCreator.class.getName());
+		RuntimeActivityDefinitionEntityIntepreter radei = new RuntimeActivityDefinitionEntityIntepreter(info);
+
+		if (radei.getCloneActivityIds() == null) {
+			radei.setCloneActivityIds(CollectionUtils.arrayToList(new String[radei.getAssignees().size()]));
+		}
+
+		return createActivities(processEngine, processDefinition, info.getProcessInstanceId(), radei.getPrototypeActivityId(),
+				radei.getNextActivityId(), radei.getAssignees(), radei.getCloneActivityIds());
+	}
+
+	private ActivityImpl[] createActivities(ProcessEngine processEngine, ProcessDefinitionEntity processDefinition, String processInstanceId,
+			String prototypeActivityId, String nextActivityId, List<String> assignees, List<String> activityIds) {
+		ActivityImpl prototypeActivity = ProcessDefUtils.getActivity(processEngine, processDefinition.getId(), prototypeActivityId);
+
+		List<ActivityImpl> activities = new ArrayList<ActivityImpl>();
+		for (int i = 0; i < assignees.size(); i++) {
+			if (activityIds.get(i) == null) {
+				String activityId = createUniqueActivityId(processInstanceId, prototypeActivityId);
+				activityIds.set(i, activityId);
+			}
+
+			ActivityImpl clone = createActivity(processEngine, processDefinition, prototypeActivity, activityIds.get(i), assignees.get(i));
+			activities.add(clone);
+		}
+
+		ActivityImpl nextActivity = ProcessDefUtils.getActivity(processEngine, processDefinition.getId(), nextActivityId);
+		createActivityChain(activities, nextActivity);
+
+		return activities.toArray(new ActivityImpl[0]);
+	}
+}

JeeSpringCloud/jeespring-act/src/main/java/com/jeespring/modules/act/service/creator/MultiInstanceActivityCreator.java

+package com.jeespring.modules.act.service.creator;
+
+import java.util.List;
+
+import org.activiti.engine.ProcessEngine;
+import org.activiti.engine.impl.bpmn.behavior.MultiInstanceActivityBehavior;
+import org.activiti.engine.impl.bpmn.behavior.ParallelMultiInstanceBehavior;
+import org.activiti.engine.impl.bpmn.behavior.SequentialMultiInstanceBehavior;
+import org.activiti.engine.impl.bpmn.behavior.TaskActivityBehavior;
+import org.activiti.engine.impl.el.FixedValue;
+import org.activiti.engine.impl.persistence.entity.ProcessDefinitionEntity;
+import org.activiti.engine.impl.pvm.PvmTransition;
+import org.activiti.engine.impl.pvm.process.ActivityImpl;
+
+import com.jeespring.modules.act.utils.ProcessDefUtils;
+
+public class MultiInstanceActivityCreator extends RuntimeActivityCreatorSupport implements RuntimeActivityCreator {
+	
+	@Override
+    public ActivityImpl[] createActivities(ProcessEngine processEngine, ProcessDefinitionEntity processDefinition,
+                                           RuntimeActivityDefinitionEntity info) {
+		info.setFactoryName(MultiInstanceActivityCreator.class.getName());
+		RuntimeActivityDefinitionEntityIntepreter radei = new RuntimeActivityDefinitionEntityIntepreter(info);
+
+		if (radei.getCloneActivityId() == null) {
+			String cloneActivityId = createUniqueActivityId(info.getProcessInstanceId(), radei.getPrototypeActivityId());
+			radei.setCloneActivityId(cloneActivityId);
+		}
+
+		return new ActivityImpl[] { createMultiInstanceActivity(processEngine, processDefinition, info.getProcessInstanceId(),
+				radei.getPrototypeActivityId(), radei.getCloneActivityId(), radei.getSequential(), radei.getAssignees()) };
+	}
+
+	private ActivityImpl createMultiInstanceActivity(ProcessEngine processEngine, ProcessDefinitionEntity processDefinition,
+			String processInstanceId, String prototypeActivityId, String cloneActivityId, boolean isSequential, List<String> assignees) {
+		ActivityImpl prototypeActivity = ProcessDefUtils.getActivity(processEngine, processDefinition.getId(), prototypeActivityId);
+
+		//拷贝listener，executionListeners会激活历史记录的保存
+		ActivityImpl clone = cloneActivity(processDefinition, prototypeActivity, cloneActivityId, "executionListeners", "properties");
+		//拷贝所有后向链接
+		for (PvmTransition trans : prototypeActivity.getOutgoingTransitions()) {
+			clone.createOutgoingTransition(trans.getId()).setDestination((ActivityImpl) trans.getDestination());
+		}
+
+		MultiInstanceActivityBehavior multiInstanceBehavior = isSequential ? new SequentialMultiInstanceBehavior(clone,
+				(TaskActivityBehavior) prototypeActivity.getActivityBehavior()) : new ParallelMultiInstanceBehavior(clone,
+				(TaskActivityBehavior) prototypeActivity.getActivityBehavior());
+
+		clone.setActivityBehavior(multiInstanceBehavior);
+
+		clone.setScope(true);
+		clone.setProperty("multiInstance", isSequential ? "sequential" : "parallel");
+
+		//设置多实例节点属性
+		multiInstanceBehavior.setLoopCardinalityExpression(new FixedValue(assignees.size()));
+		multiInstanceBehavior.setCollectionExpression(new FixedValue(assignees));
+		return clone;
+	}
+}

JeeSpringCloud/jeespring-act/src/main/java/com/jeespring/modules/act/service/creator/RuntimeActivityCreator.java

+package com.jeespring.modules.act.service.creator;
+
+import org.activiti.engine.ProcessEngine;
+import org.activiti.engine.impl.persistence.entity.ProcessDefinitionEntity;
+import org.activiti.engine.impl.pvm.process.ActivityImpl;
+
+public interface RuntimeActivityCreator
+{
+	public ActivityImpl[] createActivities(ProcessEngine processEngine, ProcessDefinitionEntity processDefinition,
+                                           RuntimeActivityDefinitionEntity info);
+}
\ No newline at end of file

JeeSpringCloud/jeespring-act/src/main/java/com/jeespring/modules/act/service/creator/RuntimeActivityCreatorSupport.java

+package com.jeespring.modules.act.service.creator;
+
+import java.lang.reflect.Field;
+import java.util.List;
+
+import org.activiti.engine.ProcessEngine;
+import org.activiti.engine.impl.bpmn.behavior.UserTaskActivityBehavior;
+import org.activiti.engine.impl.el.FixedValue;
+import org.activiti.engine.impl.persistence.entity.ProcessDefinitionEntity;
+import org.activiti.engine.impl.pvm.process.ActivityImpl;
+import org.activiti.engine.impl.task.TaskDefinition;
+import org.apache.commons.lang3.reflect.FieldUtils;
+import org.junit.Assert;
+import org.springframework.beans.BeanUtils;
+
+import com.jeespring.modules.act.utils.ProcessDefUtils;
+
+public abstract class RuntimeActivityCreatorSupport {
+	private static int SEQUNCE_NUMBER = 0;
+
+	protected ActivityImpl cloneActivity(ProcessDefinitionEntity processDefinition, ActivityImpl prototypeActivity, String newActivityId,
+			String... fieldNames) {
+		ActivityImpl clone = processDefinition.createActivity(newActivityId);
+		copyFields(prototypeActivity, clone, fieldNames);
+
+		return clone;
+	}
+
+	protected TaskDefinition cloneTaskDefinition(TaskDefinition taskDefinition) {
+		TaskDefinition newTaskDefinition = new TaskDefinition(taskDefinition.getTaskFormHandler());
+		BeanUtils.copyProperties(taskDefinition, newTaskDefinition);
+		return newTaskDefinition;
+	}
+
+	protected ActivityImpl createActivity(ProcessEngine processEngine, ProcessDefinitionEntity processDefinition, ActivityImpl prototypeActivity,
+			String cloneActivityId, String assignee) {
+		ActivityImpl clone = cloneActivity(processDefinition, prototypeActivity, cloneActivityId, "executionListeners", "properties");
+
+		//设置assignee
+		UserTaskActivityBehavior activityBehavior = (UserTaskActivityBehavior) (prototypeActivity.getActivityBehavior());
+
+		TaskDefinition taskDefinition = cloneTaskDefinition(activityBehavior.getTaskDefinition());
+		taskDefinition.setKey(cloneActivityId);
+		if (assignee != null) {
+			taskDefinition.setAssigneeExpression(new FixedValue(assignee));
+		}
+
+		UserTaskActivityBehavior cloneActivityBehavior = new UserTaskActivityBehavior(null, taskDefinition);
+		clone.setActivityBehavior(cloneActivityBehavior);
+
+		return clone;
+	}
+
+	protected ActivityImpl createActivity(ProcessEngine processEngine, ProcessDefinitionEntity processDefinition, String prototypeActivityId,
+			String cloneActivityId, String assignee) {
+		ActivityImpl prototypeActivity = ProcessDefUtils.getActivity(processEngine, processDefinition.getId(), prototypeActivityId);
+
+		return createActivity(processEngine, processDefinition, prototypeActivity, cloneActivityId, assignee);
+	}
+
+	protected void createActivityChain(List<ActivityImpl> activities, ActivityImpl nextActivity) {
+		for (int i = 0; i < activities.size(); i++) {
+			//设置各活动的下线
+			activities.get(i).getOutgoingTransitions().clear();
+			activities.get(i).createOutgoingTransition("flow" + (i + 1))
+					.setDestination(i == activities.size() - 1 ? nextActivity : activities.get(i + 1));
+		}
+	}
+
+	protected String createUniqueActivityId(String processInstanceId, String prototypeActivityId) {
+		return processInstanceId + ":" + prototypeActivityId + ":" + System.currentTimeMillis() + "-" + (SEQUNCE_NUMBER++);
+	}
+
+	private static void copyFields(Object source, Object target, String... fieldNames) {
+		Assert.assertNotNull(source);
+		Assert.assertNotNull(target);
+		Assert.assertSame(source.getClass(), target.getClass());
+
+		for (String fieldName : fieldNames) {
+			try {
+				Field field = FieldUtils.getField(source.getClass(), fieldName, true);
+				field.setAccessible(true);
+				field.set(target, field.get(source));
+			} catch (Exception e) {
+				e.printStackTrace();
+			}
+		}
+	}
+}

JeeSpringCloud/jeespring-act/src/main/java/com/jeespring/modules/act/service/creator/RuntimeActivityDefinitionEntity.java

+package com.jeespring.modules.act.service.creator;
+
+import java.io.IOException;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+
+public interface RuntimeActivityDefinitionEntity
+{
+	/**
+	 * 反序列化PropertiesText到Map
+	 */
+	void deserializeProperties() throws IOException;
+
+	/**
+	 * 获取工厂名
+	 */
+	String getFactoryName();
+
+	/**
+	 * 获取流程定义的ID
+	 */
+	String getProcessDefinitionId();
+
+	/**
+	 * 获取流程实例的ID
+	 */
+	String getProcessInstanceId();
+
+	/**
+	 * 获取PropertiesText，它是一个JSON字符串
+	 */
+	String getPropertiesText();
+
+	/**
+	 * 获取指定的属性值
+	 */
+	<T> T getProperty(String name);
+
+	/**
+	 * 序列化Map至PropertiesText
+	 */
+	void serializeProperties() throws JsonProcessingException;
+
+	/**
+	 * 设置工厂名
+	 */
+	void setFactoryName(String factoryName);
+
+	/**
+	 * 设置流程定义ID
+	 */
+	void setProcessDefinitionId(String processDefinitionId);
+
+	/**
+	 * 设置流程实例ID
+	 */
+	void setProcessInstanceId(String processInstanceId);
+
+	/**
+	 * 设置PropertiesText
+	 */
+	void setPropertiesText(String propertiesText);
+
+	<T> void setProperty(String name, T value);
+}
\ No newline at end of file

JeeSpringCloud/jeespring-act/src/main/java/com/jeespring/modules/act/service/creator/RuntimeActivityDefinitionEntityIntepreter.java

+package com.jeespring.modules.act.service.creator;
+
+import java.util.List;
+
+/**
+ * RuntimeActivityDefinitionEntity的解释类（代理类）
+ * 主要用以解释properties字段的值，如为get("name")提供getName()方法
+ * 
+ * @author bluejoe2008@gmail.com
+ * 
+ */
+public class RuntimeActivityDefinitionEntityIntepreter
+{
+	RuntimeActivityDefinitionEntity _entity;
+
+	public RuntimeActivityDefinitionEntityIntepreter(RuntimeActivityDefinitionEntity entity)
+	{
+		super();
+		_entity = entity;
+	}
+
+	public List<String> getAssignees()
+	{
+		return _entity.getProperty("assignees");
+	}
+
+	public String getCloneActivityId()
+	{
+		return _entity.getProperty("cloneActivityId");
+	}
+
+	public List<String> getCloneActivityIds()
+	{
+		return _entity.getProperty("cloneActivityIds");
+	}
+
+	public String getNextActivityId()
+	{
+		return _entity.getProperty("nextActivityId");
+	}
+
+	public String getPrototypeActivityId()
+	{
+		return _entity.getProperty("prototypeActivityId");
+	}
+
+	public boolean getSequential()
+	{
+		return (Boolean) _entity.getProperty("sequential");
+	}
+
+	public void setAssignees(List<String> assignees)
+	{
+		_entity.setProperty("assignees", assignees);
+	}
+
+	public void setCloneActivityId(String cloneActivityId)
+	{
+		_entity.setProperty("cloneActivityId", cloneActivityId);
+	}
+
+	public void setCloneActivityIds(List<String> cloneActivityIds)
+	{
+		_entity.setProperty("cloneActivityIds", cloneActivityIds);
+	}
+
+	public void setNextActivityId(String nextActivityId)
+	{
+		_entity.setProperty("nextActivityId", nextActivityId);
+	}
+
+	public void setPrototypeActivityId(String prototypeActivityId)
+	{
+		_entity.setProperty("prototypeActivityId", prototypeActivityId);
+	}
+
+	public void setSequential(boolean sequential)
+	{
+		_entity.setProperty("sequential", sequential);
+	}
+}

JeeSpringCloud/jeespring-act/src/main/java/com/jeespring/modules/act/service/creator/RuntimeActivityDefinitionManager.java

+package com.jeespring.modules.act.service.creator;
+
+import java.util.List;
+
+public interface RuntimeActivityDefinitionManager
+{
+	/**
+	 * 获取所有的活动定义信息，引擎会在启动的时候加载这些活动定义并进行注册
+	 */
+	List<RuntimeActivityDefinitionEntity> list() throws Exception;
+
+	/**
+	 * 删除所有活动定义
+	 */
+	void removeAll() throws Exception;
+
+	/**
+	 * 新增一条活动定义的信息
+	 */
+	void save(RuntimeActivityDefinitionEntity entity) throws Exception;
+
+}
\ No newline at end of file

JeeSpringCloud/jeespring-act/src/main/java/com/jeespring/modules/act/service/creator/SimpleRuntimeActivityDefinitionEntity.java

+package com.jeespring.modules.act.service.creator;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+public class SimpleRuntimeActivityDefinitionEntity implements RuntimeActivityDefinitionEntity {
+	String _factoryName;
+
+	String _processDefinitionId;
+
+	public Map<String, Object> getProperties() {
+		return _properties;
+	}
+
+	public void setProperties(Map<String, Object> properties) {
+		_properties = properties;
+	}
+
+	@Override
+    public void setFactoryName(String factoryName) {
+		_factoryName = factoryName;
+	}
+
+	@Override
+    public void setProcessDefinitionId(String processDefinitionId) {
+		_processDefinitionId = processDefinitionId;
+	}
+
+	@Override
+    public void setProcessInstanceId(String processInstanceId) {
+		_processInstanceId = processInstanceId;
+	}
+
+	@Override
+    public void setPropertiesText(String propertiesText) {
+		_propertiesText = propertiesText;
+	}
+
+	String _processInstanceId;
+
+	Map<String, Object> _properties = new HashMap<String, Object>();
+
+	String _propertiesText;
+
+	@Override
+	public void deserializeProperties() throws IOException {
+		ObjectMapper objectMapper = new ObjectMapper();
+		_properties = objectMapper.readValue(_propertiesText, Map.class);
+	}
+
+	@Override
+	public String getFactoryName() {
+		return _factoryName;
+	}
+
+	@Override
+	public String getProcessDefinitionId() {
+		return _processDefinitionId;
+	}
+
+	@Override
+	public String getProcessInstanceId() {
+		return _processInstanceId;
+	}
+
+	@Override
+	public String getPropertiesText() {
+		return _propertiesText;
+	}
+
+	@Override
+	public <T> T getProperty(String name) {
+		return (T) _properties.get(name);
+	}
+
+	@Override
+	public void serializeProperties() throws JsonProcessingException {
+		ObjectMapper objectMapper = new ObjectMapper();
+		_propertiesText = objectMapper.writeValueAsString(_properties);
+	}
+
+	@Override
+	public <T> void setProperty(String name, T value) {
+		_properties.put(name, value);
+	}
+}