SpringMVC集成activity工作流

最新推荐文章于 2025-04-18 20:51:33 发布

原创最新推荐文章于 2025-04-18 20:51:33 发布 · 1k 阅读

1 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

java

springmvc

本文介绍了如何将Activiti工作流与SpringMVC整合，详细步骤包括下载activiti-5.22.0，解压并配置工程目录，修改editor-app的app-cfg.js，引入jar包，配置applicationContext.xml，创建ActivitiController，以及启动后的流程创建和查看地址。

1.下载activiti-5.22.0 SpringMVC集成activity工作流中文集成
解压后的目录结构
在这里插入图片描述
2.解压activiti-explorer.war文件
解压后的目录结构，拷贝diagram-viewer，editor-app，VAADIN，favicon.ico，modeler.html这些目录和文件，放在自己工程下webapp目录下
并修改editor-app下app-cfg.js的内容
ACTIVITI.CONFIG = {
‘contextRoot’ : ‘/项目运行起来的工程名字/activiti’
};
如果你的工程Controller类上没@RequestMapping("/activiti")就不用加
如：ACTIVITI.CONFIG = {
‘contextRoot’ : ‘/项目运行起来的工程名字’
};
3.按路径找到stencilset.json文件，拷贝至工程的resources下
在这里插入图片描述
4.pom.xml引入jar包

 <properties>
       <!--activiti流程配置 -->
        <activiti.version>5.22.0</activiti.version>
        <!--activiti流程配置 end-->
    </properties>

    <dependency>
        <groupId>org.activiti</groupId>
        <artifactId>activiti-modeler</artifactId>
        <version>${activiti.version}</version>
    </dependency>
    <dependency>
        <groupId>org.activiti</groupId>
        <artifactId>activiti-engine</artifactId>
        <version>${activiti.version}</version>
    </dependency>
    <dependency>
        <groupId>org.activiti</groupId>
        <artifactId>activiti-spring</artifactId>
        <version>${activiti.version}</version>
    </dependency>
    <dependency>
        <groupId>org.activiti</groupId>
        <artifactId>activiti-bpmn-model</artifactId>
        <version>${activiti.version}</version>
    </dependency>
    <dependency>
        <groupId>org.activiti</groupId>
        <artifactId>activiti-bpmn-layout</artifactId>
        <version>${activiti.version}</version>
    </dependency>
    <dependency>
        <groupId>org.activiti</groupId>
        <artifactId>activiti-bpmn-converter</artifactId>
        <version>${activiti.version}</version>
    </dependency>
    <dependency>
        <groupId>org.activiti</groupId>
        <artifactId>activiti-process-validation</artifactId>
        <version>${activiti.version}</version>
    </dependency>
    <dependency>
        <groupId>org.activiti</groupId>
        <artifactId>activiti-image-generator</artifactId>
        <version>${activiti.version}</version>
    </dependency>
    <dependency>
        <groupId>org.activiti</groupId>
        <artifactId>activiti-json-converter</artifactId>
        <version>${activiti.version}</version>
    </dependency>
   <!-- activiti end -->

5.创建applicationContext.xml，启动的时候注册

<!-- 在线编辑器配置开始 -->
	<bean id="objectMapper" class="com.fasterxml.jackson.databind.ObjectMapper"/>
	<!-- 在线编辑器配置结束 -->
	<!-- activiti 配置开始 -->
	<bean id="processEngineConfiguration" class="org.activiti.spring.SpringProcessEngineConfiguration">
		<!-- 注入数据库连接池 -->
		<property name="dataSource" ref="dataSource"/>
		<!-- 配置事物管理器 -->
		<property name="transactionManager" ref="transactionManager"/>
		<!-- 自动构建数据库表，设置value="true"，第一次启动建表；设置value="drop-create"，每次启动时建新表 -->
		<property name="databaseSchemaUpdate" value="true"/>
		<!--激活Timer和异步消息的线程的组件,即activiti的定时扫描任务,默认:true,不使用的话建议关掉 -->
		<property name="jobExecutorActivate" value="false"/>
		<!-- 生成流程图的字体 -->
		<property name="activityFontName" value="宋体"/>
		<property name="labelFontName" value="宋体"/>
		<property name="annotationFontName" value="宋体"/>
		<!-- UUID作为主键生成策略 -->
		<!-- <property name="idGenerator" ref="uuidGenerator" /> -->
		<!-- 自动部署,只有流程数据库中没有和自动部署的流程定义相同的记录才会部署 -->
<!--		<property name="deploymentResources">-->
<!--			<list>-->
<!--				<value>classpath*:/deployments/*.bpmn</value>-->
<!--				<value>classpath*:/deployments/*.png</value>-->
<!--			</list>-->
<!--		</property>-->
	</bean>
	<!-- 创建流程引擎对象 -->
	<bean id="processEngine" class="org.activiti.spring.ProcessEngineFactoryBean">
		<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="historyService" factory-bean="processEngine" factory-method="getHistoryService"/>
	<!-- 提供了流程引擎的管理和维护功能-->
	<bean id="managementService" factory-bean="processEngine" factory-method="getManagementService"/>
	<!-- 表单管理服务-->
	<bean id="formService" factory-bean="processEngine" factory-method="getFormService"/>
	<!-- 提供基础的用户管理以及身份认证 -->
	<bean id="IdentityService" factory-bean="processEngine" factory-method="getIdentityService"/>
	<!-- activiti 配置结束 -->

6.创建ActivitiController的类，要检查工程是否启动扫描加载了

package controller.activiti;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import org.activiti.editor.constants.ModelDataJsonConstants;
import org.activiti.engine.ActivitiException;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
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.commons.io.IOUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Controller;
import org.springframework.util.MultiValueMap;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;

@Controller
@RequestMapping("/activiti")
public class ActivitiController{
    private final static Logger logger = LogManager.getLogger(ActivitiController.class);

    @Autowired
    private RepositoryService repositoryService;
    @Autowired
    private ObjectMapper objectMapper;

    /**
     * 创建模型
     */
    @RequestMapping(value="/create", method = RequestMethod.GET)
    public void create(HttpServletRequest request, HttpServletResponse response) {
        try {
            ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
            RepositoryService repositoryService = processEngine.getRepositoryService();
            ObjectMapper objectMapper = new ObjectMapper();

            ObjectNode stencilSetNode = objectMapper.createObjectNode();
            stencilSetNode.put("namespace", "http://b3mn.org/stencilset/bpmn2.0#");

            ObjectNode properties =  objectMapper.createObjectNode();
            properties.put("process_author","author");

            ObjectNode editorNode = objectMapper.createObjectNode();
            editorNode.put("id", "canvas");
            editorNode.put("resourceId", "canvas");
            editorNode.put("stencilset", stencilSetNode);
            editorNode.put("properties", properties);

            int version = (int)repositoryService.createModelQuery().modelKey("").count()+1;
            ObjectNode modelNode = objectMapper.createObjectNode();
            modelNode.put(ModelDataJsonConstants.MODEL_NAME, super.getLoginUsers().getName());
            modelNode.put(ModelDataJsonConstants.MODEL_REVISION, version);
            modelNode.put(ModelDataJsonConstants.MODEL_DESCRIPTION,"创建者");

            Model modelData = repositoryService.newModel();
            modelData.setName("创建人名称");
            modelData.setKey("创建人编号");
            modelData.setVersion(version);
            modelData.setMetaInfo(modelNode.toString());
            modelData.setCategory(null);

            // 保存模型
            repositoryService.saveModel(modelData);
            repositoryService.addModelEditorSource(modelData.getId(), editorNode.toString().getBytes("UTF-8"));
            logger.info(request.getContextPath() + "/activiti/modeler.html?modelId=" + modelData.getId());
            response.sendRedirect(request.getContextPath() + "/activiti/modeler.html?modelId=" + modelData.getId());
        } catch (Exception e) {
            System.out.println("创建模型失败：");
        }
    }



    @RequestMapping(value="/model/{modelId}/json", method = RequestMethod.GET, produces = "application/json")
    @ResponseBody
    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(ModelDataJsonConstants.MODEL_NAME, model.getName());
                }
                modelNode.put(ModelDataJsonConstants.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;
    }

    @RequestMapping(value="/model/{modelId}/save", method = RequestMethod.PUT)
    @ResponseStatus(HttpStatus.OK)
    public void saveModel(@PathVariable String modelId, @RequestBody MultiValueMap<String, String> values) {
        try {
            Model model = this.repositoryService.getModel(modelId);
            ObjectNode modelJson = (ObjectNode)this.objectMapper.readTree(model.getMetaInfo());
            modelJson.put("name", (String)values.getFirst("name"));
            modelJson.put("description", (String)values.getFirst("description"));
            model.setMetaInfo(modelJson.toString());
            model.setName((String)values.getFirst("name"));
            this.repositoryService.saveModel(model);
            this.repositoryService.addModelEditorSource(model.getId(), ((String)values.getFirst("json_xml")).getBytes("utf-8"));
            InputStream svgStream = new ByteArrayInputStream(((String)values.getFirst("svg_xml")).getBytes("utf-8"));
            TranscoderInput input = new TranscoderInput(svgStream);
            PNGTranscoder transcoder = new PNGTranscoder();
            ByteArrayOutputStream outStream = new ByteArrayOutputStream();
            TranscoderOutput output = new TranscoderOutput(outStream);
            transcoder.transcode(input, output);
            byte[] result = outStream.toByteArray();
            this.repositoryService.addModelEditorSourceExtra(model.getId(), result);
            outStream.close();
        } catch (Exception var11) {
            throw new ActivitiException("Error saving model", var11);
        }
    }
    @RequestMapping(value = {"/editor/stencilset"}, method = {RequestMethod.GET}, produces = {"application/json;charset=utf-8"})
    @ResponseBody
    public String getStencilset() {
        InputStream stencilsetStream = this.getClass().getClassLoader().getResourceAsStream("stencilset.json");
        try {
            return IOUtils.toString(stencilsetStream, "utf-8");
        } catch (Exception var3) {
            throw new ActivitiException("Error while loading stencil set", var3);
        }
    }
}