Spring学习之整合Activiti（一）

忘是亡心i 2023-02-12 08:29 15阅读 0赞

# 1. 背景 #

Activiti是现在应用很广的一个流程框架，自己在学习过程中看到官网有Activiti Modeler可以使用页面管理Activiti流程，所以试着自己整合SpringMVC+Activiti Modeler。

## 1.1. 工作流与工作流引擎 ##

工作流（workflow）就是工作流程的计算模型，即将工作流程中的工作如何前后组织在一起的逻辑和规则在计算机中以恰当的模型进行表示并对其实施计算。它主要解决的是“使在多个参与者之间按照某种预定义的规则传递文档、信息或任务的过程自动进行，从而实现某个预期的业务目标，或者促使此目标的实现”。（我的理解就是：将部分或者全部的工作流程、逻辑让计算机帮你来处理，实现自动化）

所谓工作流引擎是指workflow作为应用系统的一部分，并为之提供对各应用系统有决定作用的根据角色、分工和条件的不同决定信息传递路由、内容等级等核心解决方案。

## 1.2. BPMN2.0规范 ##

BPMN（Business Process Model and Notation）--业务流程模型与符号。

BPMN是一套流程建模的标准，主要目标是被所有业务用户容易理解的符号，支持从创建流程轮廓的业务分析到这些流程的最终实现，知道最终用户的管理监控。

通俗一点其实就是一套规范，画流程模型的规范。流程模型包括：流程图、协作图、编排图、会话图。详细信息请google。

## 1.3. Activiti概述 ##

### 1.3.1. Activiti由来 ###

学习过Activiti的朋友都知道，Activiti的创始人也就是JBPM（也是一个优秀的BPM引擎）的创始人，从Jboss离职后开发了一个新的BPM引擎：Activiti。所以，Activiti有很多地方都有JBPM的影子。所以，据说学习过JBPM的朋友学起Activiti来非常顺手。

由于本人之前没有工作流及JBPM的相关基础，刚开始学习Activiti的时候可以说是无比痛苦的，根本不知道从何下手，这里也建议大家先进行工作流及BPMN2.0规范的学习，有了一定的基础后，再着手学习Activiti。

### 1.3.2. Activiti简介 ###

Activiti是一个开源的工作流引擎，它实现了BPMN 2.0规范，可以发布设计好的流程定义，并通过api进行流程调度。

Activiti 作为一个遵从 Apache 许可的工作流和业务流程管理开源平台，其核心是基于 Java 的超快速、超稳定的 BPMN2.0 流程引擎，强调流程服务的可嵌入性和可扩展性，同时更加强调面向业务人员。

Activiti 流程引擎重点关注在系统开发的易用性和轻量性上。每一项 BPM 业务功能 Activiti 流程引擎都以服务的形式提供给开发人员。通过使用这些服务，开发人员能够构建出功能丰富、轻便且高效的 BPM 应用程序。

# 2. 前期准备 #

本文是在[Spring学习之整合MyBatis][Spring_MyBatis]的基础上完成的，所以不清楚的可以点击查看

2.1. Activiti所需环境

使用Activiti，首先当然要有jdk了！6+版本就可以了。其次，要有一款IDE，我们当然会使用Eclipse。然后，web容器当然也要有，这里使用Tomcat7.0版本。然后就是Activiti的Eclipse插件了，这个后面再介绍。

2.2. 下载Activiti Demo包

下载activiti-5.22.0.rar，官网地址大家可以自行百度，但是下载会被墙，网盘地址：[https://pan.baidu.com/s/1XVTammPbIrbzU1MK7TBFOA][https_pan.baidu.com_s_1XVTammPbIrbzU1MK7TBFOA]

2.3. 配置pom.xml文件

新增activiti依赖：

<properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <junit.version>4.10</junit.version>
        <spring.version>4.1.3.RELEASE</spring.version>
        <jackson.version>2.7.4</jackson.version>
        <activiti.version>5.22.0</activiti.version>
      </properties>
    
    
    
        <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-common-rest</artifactId>
            <version>${activiti.version}</version>
        </dependency>
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-crystalball</artifactId>
            <version>${activiti.version}</version>
        </dependency>
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-diagram-rest</artifactId>
            <version>${activiti.version}</version>
        </dependency>
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-explorer</artifactId>
            <version>${activiti.version}</version>
        </dependency>
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-json-converter</artifactId>
            <version>${activiti.version}</version>
        </dependency>
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-modeler</artifactId>
            <version>${activiti.version}</version>
        </dependency>
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-simple-workflow</artifactId>
            <version>${activiti.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.xmlgraphics</groupId>
            <artifactId>xmlgraphics-commons</artifactId>
            <version>1.2</version>
        </dependency>

***Batik包*** 在添加activiti-modeler依赖后自动加载，不用显式添加依赖

2.4. 配置spring-activiti.xml文件

在resources/spring/ 新建spring-activiti.xml配置文件：

![format_png][]

`spring-activiti.xml`文件内容如下：

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:context="http://www.springframework.org/schema/context" xmlns:mvc="http://www.springframework.org/schema/mvc"
        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd
            http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd">
            
    
        
        
        <bean id="objectMapper" class="com.fasterxml.jackson.databind.ObjectMapper"/>
    
        
        <bean id="processEngineConfiguration" class="org.activiti.spring.SpringProcessEngineConfiguration">
            <property name="dataSource" ref="jdbcDataSource" />
            <property name="transactionManager" ref="transactionManager" />
            
            <property name="databaseSchemaUpdate" value="false" />
            
            <property name="jobExecutorActivate" value="false" />
            
            
            
            <property name="processDefinitionCacheLimit" value="10"/>
            
            
            
            
            
            
            <property name="activityFontName" value="宋体"/>
            <property name="labelFontName" value="宋体"/>
            
            
    
            
            
    
            
            
            
            <property name="dbIdentityUsed" value="false"/>
            
            <property name="customSessionFactories">
                <list>
                    <bean class="com.zr.workflow.activiti.utils.CustomUserEntityManagerFactory">
                        <property name="customUserEntityManager" ref="customUserEntityManager"></property>
                    </bean>
                    <bean class="com.zr.workflow.activiti.utils.CustomGroupEntityManagerFactory">
                        <property name="customGroupEntityManager" ref="customGroupEntityManager"></property>
                    </bean>
                </list>
            </property>
        </bean>
        
        <bean id="customUserEntityManager" class="com.zr.workflow.activiti.utils.CustomUserEntityManager"></bean>
        <bean id="customGroupEntityManager" class="com.zr.workflow.activiti.utils.CustomGroupEntityManager"></bean>
        
        
         
        <bean id="processEngine" class="org.activiti.spring.ProcessEngineFactoryBean" destroy-method="destroy">
            <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="taskService" factory-bean="processEngine" factory-method="getTaskService" />
        <bean id="formService" factory-bean="processEngine" factory-method="getFormService" />
        <bean id="historyService" factory-bean="processEngine" factory-method="getHistoryService" />
        <bean id="managementService" factory-bean="processEngine" factory-method="getManagementService" />
        
        
    </beans>

其中，需要注意的是：  
1、`databaseSchemaUpdate`，项目启动是否自动创建数据表（activiti的23张表），这里我设置成false，因为我没有用activiti的用户管理表，而是采用自定义的用户管理表，所以在项目启动之前需要将所有需要的表创建完成。  
2、`dbIdentityUsed`：是否创建identity用户相关表；由于项目已经有一套用户管理表，所以这里设置成`false`；  
3、新增property `customSessionFactories` 指定自定义用户管理工厂，包括：用户管理和组管理。  
其中，用户管理工厂`CustomUserEntityManagerFactory.java`如下：

package com.zr.workflow.activiti.util;
    
    import javax.annotation.Resource;
    
    import org.activiti.engine.impl.interceptor.Session;
    import org.activiti.engine.impl.interceptor.SessionFactory;
    import org.activiti.engine.impl.persistence.entity.UserIdentityManager;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    /**
     * 自定义用户管理，用户session
     * 这里的属性需要与`spring-activiti.xml`中的该类的property一致
     * 不能使用identityService
     * @author Administrator
     *
     */
    @Service
    public class CustomUserEntityManagerFactory implements SessionFactory {
        
        @Resource
        private CustomUserEntityManager customUserEntityManager;
        
    
        @Override
        public Class<?> getSessionType() {
            return UserIdentityManager.class;
        }
    
        @Override
        public Session openSession() {
            return customUserEntityManager;
        }
    
        
        @Autowired
        public void setCustomUserEntityManager(CustomUserEntityManager customUserEntityManager) {
            this.customUserEntityManager = customUserEntityManager;
        }
    
    }

组管理工厂 `CustomGroupEntityManagerFactory.java`:

package com.zr.workflow.activiti.util;
    
    import javax.annotation.Resource;
    
    import org.activiti.engine.impl.interceptor.Session;
    import org.activiti.engine.impl.interceptor.SessionFactory;
    import org.activiti.engine.impl.persistence.entity.GroupIdentityManager;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    /**
     * 自定义用户管理，用户组session
     * 这里的属性需要与spring-activiti.xml中的该类的property一致
     * 不能使用identityService
     * @author Administrator
     *
     */
    @Service
    public class CustomGroupEntityManagerFactory implements SessionFactory {
        
        @Resource
        private CustomGroupEntityManager customGroupEntityManager;
        
        
        @Override
        public Class<?> getSessionType() {
            return GroupIdentityManager.class;
        }
    
        @Override
        public Session openSession() {
            return customGroupEntityManager;
        }
    
        @Autowired  
        public void setCustomGroupEntityManager(CustomGroupEntityManager customGroupEntityManager) {
            this.customGroupEntityManager = customGroupEntityManager;
        }
    }

4、注册自动义用户管理类。

由于我们这个项目中设置任务执行人时没有涉及到候选组，都是指定具体的执行人或获取某个角色组中所有的人员，然后调用`setCandidateUsers`方法将某个候选组所有的成员加进去，如果项目需要设置候选组，请扩展这两个类：`CustomUserEntityManager`和`CustomGroupEntityManager`，重写其中的  
`hasUser()`(必须实现)、  
`getUserName()`(可选)、  
`getUserPassword()`(可选)、  
`getUserEmail()`(可选)、  
`getRoleList()`(必须实现)。  
然后将实现类注册到spring\_activiti.xml中，替换以下两行：

<bean id="customUserEntityManager" class="com.zr.workflow.activiti.utils.CustomUserEntityManager"></bean>
        <bean id="customGroupEntityManager" class="com.zr.workflow.activiti.utils.CustomGroupEntityManager"></bean>

`CustomUserEntityManager.java`代码如下:

package com.zr.workflow.activiti.util;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Map;
    
    import org.activiti.engine.identity.Group;
    import org.activiti.engine.identity.User;
    import org.activiti.engine.impl.persistence.entity.GroupEntity;
    import org.activiti.engine.impl.persistence.entity.UserEntity;
    import org.activiti.engine.impl.persistence.entity.UserEntityManager;
    import org.springframework.dao.EmptyResultDataAccessException;
    
    
    import org.springframework.stereotype.Component;
    
    @Component
    public class CustomUserEntityManager extends UserEntityManager {
    
    
        public User findUserById(String userId) {
            System.out.println("CustomUserEntityManager  findUserById userId:" + userId);
            if (userId == null)
                return null;
            try {
                UserEntity userEntity = new UserEntity();
                boolean hasUser = hasUser(userId);
                if (!hasUser)return null;
    
                userEntity.setId(userId);
                userEntity.setFirstName(getUserName(userId));
                userEntity.setPassword(getUserPassword(userId));
                userEntity.setEmail(getUserEmail(userId));
                userEntity.setRevision(1);
                return userEntity;
            } catch (EmptyResultDataAccessException e) {
                e.printStackTrace();
                return null;
            }
        }
    
        public boolean hasUser(String userId) {
            return true;
        }
        
        public List<Group> findGroupsByUser(String userId) {
            System.out.println("CustomUserEntityManager  findGroupsByUser userId:" + userId);
            if (userId == null)
                return null;
            boolean hasUser = hasUser(userId);
            if (!hasUser)return null;
            List<Map<String,Object>> roleList = getRoleList(userId);
            List<Group> groupEntitys = new ArrayList<Group>();
            if(null != roleList) {
                for (Map<String, Object> role : roleList) {
                    String roleCode = null == role.get("roleCode")?"":role.get("roleCode").toString();
                    String roleName = null == role.get("roleName")?"":role.get("roleName").toString();
                    GroupEntity groupEntity = toActivitiGroup(roleCode,roleName);
                    groupEntitys.add(groupEntity);
                }
            }
            return groupEntitys;
        }
    
        public static GroupEntity toActivitiGroup(String roleCode,String roleName) {
            GroupEntity groupEntity = new GroupEntity();
            groupEntity.setRevision(1);
            groupEntity.setType("assignment");
            groupEntity.setId(roleCode);
            groupEntity.setName(roleName);
            return groupEntity;
        }
        
        public String getUserName(String userId) {
            return "";
        }
        
        public String getUserPassword(String userId) {
            return "";
        }
        
        public String getUserEmail(String userId) {
            return "";
        }
        
        public List<Map<String, Object>> getRoleList(String userId) {
            return null;
    //      List<Map<String,Object>> roleList = new ArrayList<>();
    //      List<MisUserRole> misUserRoleList = misUserRoleDao.findByUserId(userId);
    //      for (MisUserRole misUserRole : misUserRoleList) {
    //          final String roleId = misUserRole.getRoleId();
    //          boolean isExitRole = misRoleDao.findRoleById(roleId) != null && misRoleDao.findRoleById(roleId).size()>0;
    //          MisRole role = isExitRole ? misRoleDao.findRoleById(roleId).get(0) : null;
    //          Map<String, Object> roleMap = new HashMap<>();
    //          if(role != null){
    //              roleMap.put("roleCode", role.getCode());
    //              roleMap.put("roleName", role.getName());
    //              
    //          }
    //          roleList.add(roleMap);
    //      }
    //      return roleList;
        }
    
    }

`CustomGroupEntityManager.java`代码如下:

# 3. 开始整合 #

3.1. 代码拷贝

把Activiti-webapp-explorer2项目的resources下的stencilset.json文件拷至我的项目中的resources目录下：

![format_png 1][]

解压出activiti-5.22.0.rar，看到如下目录：

1.  database：里面存放的是Activiti使用到的数据库信息的sql文件，它支持的数据库类型如下图，使用时只需执行你自己的数据库类型的文件即可。如：你的数据库是mysql，那么就执行activiti.mysql.create.\*.sql即可。( **注意：** 这里由于采用的是自定义用户管理，则去掉activiti其中创建用户相关表的sql语句，最终的sql文件请见项目中的init\_activities\_empty.sql：)：

![format_png 2][]

**注意：**  
sql中新增表act\_cus\_user\_task：

-- ----------------------------
    -- Table structure for act_cus_user_task
    -- ----------------------------
    DROP TABLE IF EXISTS `act_cus_user_task`;
    CREATE TABLE `act_cus_user_task` (
      `ID` int(11) NOT NULL AUTO_INCREMENT,
      `PROC_DEF_KEY` varchar(255) DEFAULT NULL COMMENT '流程id',
      `PROC_DEF_NAME` varchar(255) DEFAULT NULL COMMENT '流程名',
      `TASK_DEF_KEY` varchar(255) DEFAULT NULL COMMENT '节点id',
      `TASK_NAME` varchar(255) DEFAULT NULL COMMENT '节点名',
      `ACTIVITY_TYPE` varchar(255) DEFAULT '' COMMENT '当前Activiti节点类型：N-普通用户任务；M-多实例节点',
      `TASK_TYPE` varchar(255) DEFAULT NULL COMMENT '节点的处理人员类型：assignee(人员)、candidateUser(候选人)、candidateGroup(候选组)',
      `CANDIDATE_NAME` varchar(255) DEFAULT NULL COMMENT '执行人名',
      `CANDIDATE_IDS` varchar(255) DEFAULT NULL COMMENT '执行人id',
      `GROUP_ID` varchar(255) DEFAULT NULL COMMENT '组id',
      `GROUP_NAME` varchar(255) DEFAULT NULL COMMENT '组名称',
      PRIMARY KEY (`ID`)
    ) ENGINE=InnoDB AUTO_INCREMENT=465 DEFAULT CHARSET=utf8;

act\_cus\_user\_task:业务用户信息关联至工作流用户任务表

1.  docs：毫无疑问，api文档。
2.  libs：使用Activiti所需要的所有的jar包和源文件。
3.  wars：官方给我们提供的示例Demo，通过使用Demo可以更加快速的了解Activiti。

找到wars目录下的 activiti-explorer.war， 将其拷贝到Tomcat 的 webapps目录下，然后运行tomcat: /bin/statup.bat（如果启动时控制台一闪而过，请看[Tomcat7中双击bin文件的startup.bat一闪而过解决办法][Tomcat7_bin_startup.bat]），启动tomcat 之后，会自动将activiti-explorer.war 解压。

![format_png 3][]

进入到下图目录中，将diagram-viewer，editor-app和modeler.html拷贝到自己工程的webapp目录下。

![format_png 4][]

将下图路径中的StencilsetRestResource.class。和下图路径中的ModelEditorJsonRestResource.class，ModelSaveRestResource.class。反编译.

![format_png 5][]

![format_png 6][]

在自己的项目中新建对应的class，将反编译内容复制进去，如图：

![format_png 7][]

其中,`StencilsetRestResource`类,是加载模板设置,加载`resources`下的`stencilset.json`,其代码如下:

package com.zr.activiti.controller.design.model;
    
    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.RestController;
    
    @RestController
    public class StencilsetRestResource
    {
      @RequestMapping(value={"/editor/stencilset"}, method={org.springframework.web.bind.annotation.RequestMethod.GET}, produces={"application/json;charset=utf-8"})
      public String getStencilset()
      {
          System.out.println("StencilsetRestResource.getStencilset-----------");
        InputStream stencilsetStream = getClass().getClassLoader().getResourceAsStream("stencilset.json");
        try {
          return IOUtils.toString(stencilsetStream, "utf-8");
        } catch (Exception e) {
          throw new ActivitiException("Error while loading stencil set", e);
        }
      }
    }

`ModelEditorJsonRestResource`类是根据模型名称读取以`Json`存储在`act_ge_bytearray`表中的`source`,编辑器接收到之后解析展示为图片,其核心代码如下:

package com.zr.activiti.controller.design.model;
    
    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.RepositoryService;
    import org.activiti.engine.repository.Model;
    import org.apache.commons.lang3.StringUtils;
    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.RestController;
    
    @RestController
    public class ModelEditorJsonRestResource
      implements ModelDataJsonConstants
    {
      protected static final Logger LOGGER = LoggerFactory.getLogger(ModelEditorJsonRestResource.class);
    
      @Autowired
      private RepositoryService repositoryService;
    
      @Autowired
      private ObjectMapper objectMapper;
    
      @RequestMapping(value={"/model/{modelId}/json"}, method={org.springframework.web.bind.annotation.RequestMethod.GET}, produces={"application/json"})
      public ObjectNode getEditorJson(@PathVariable String modelId) { ObjectNode modelNode = null;
    
        System.out.println("ModelEditorJsonRestResource.getEditorJson---------");
        Model model = this.repositoryService.getModel(modelId);
    
        if (model != null) {
          try {
            if (StringUtils.isNotEmpty(model.getMetaInfo())) {
              modelNode = (ObjectNode)this.objectMapper.readTree(model.getMetaInfo());
            } else {
              modelNode = this.objectMapper.createObjectNode();
              modelNode.put("name", model.getName());
            }
            modelNode.put("modelId", model.getId());
            ObjectNode editorJsonNode = (ObjectNode)this.objectMapper.readTree(new String(this.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;
      }
    }

`ModelSaveRestResource`就是将经过编辑器编辑过的模型保存起来,核心代码如下:

package com.zr.activiti.controller.design.model;
    
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.fasterxml.jackson.databind.node.ObjectNode;
    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.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.http.HttpStatus;
    import org.springframework.util.MultiValueMap;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestBody;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.ResponseStatus;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController
    public class ModelSaveRestResource
      implements ModelDataJsonConstants
    {
      protected static final Logger LOGGER = LoggerFactory.getLogger(ModelSaveRestResource.class);
    
      @Autowired
      private RepositoryService repositoryService;
    
      @Autowired
      private ObjectMapper objectMapper;
      
      @RequestMapping(value={"/model/{modelId}/save"}, method={org.springframework.web.bind.annotation.RequestMethod.PUT})
      @ResponseStatus(HttpStatus.OK)
      public void saveModel(@PathVariable String modelId, @RequestBody MultiValueMap<String, String> values) { 
          try { 
              Model model = this.repositoryService.getModel(modelId);
              System.out.println("ModelSaveRestResource.saveModel----------");
              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"));
              model.setKey(modelId);
        
              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 e){
              LOGGER.error("Error saving model", e);
              throw new ActivitiException("Error saving model", e);
            }
      } 
    }

3.2. 核心组件介绍

3.2.1. 关键对象

1.  Deployment：流程部署对象，部署一个流程时创建。
2.  ProcessDefinitions：流程定义，部署成功后自动创建。
3.  ProcessInstances：流程实例，启动流程时创建。
4.  Task：任务，在Activiti中的Task仅指有角色参与的任务，即定义中的UserTask。
5.  Execution：执行计划，流程实例和流程执行中的所有节点都是Execution，如UserTask、ServiceTask等。

3.2.2. 服务接口

1.  ProcessEngine：流程引擎的抽象，通过它我们可以获得我们需要的一切服务。
2.  RepositoryService：Activiti中每一个不同版本的业务流程的定义都需要使用一些定义文件，部署文件和支持数据(例如BPMN2.0 XML文件，表单定义文件，流程定义图像文件等)，这些文件都存储在Activiti内建的Repository中。RepositoryService提供了对 repository的存取服务。
3.  RuntimeService：在Activiti中，每当一个流程定义被启动一次之后，都会生成一个相应的流程对象实例。RuntimeService提供了启动流程、查询流程实例、设置获取流程实例变量等功能。此外它还提供了对流程部署，流程定义和流程实例的存取服务。
4.  TaskService: 在Activiti中业务流程定义中的每一个执行节点被称为一个Task，对流程中的数据存取，状态变更等操作均需要在Task中完成。TaskService提供了对用户Task 和Form相关的操作。它提供了运行时任务查询、领取、完成、删除以及变量设置等功能。
5.  IdentityService: Activiti中内置了用户以及组管理的功能，必须使用这些用户和组的信息才能获取到相应的Task。IdentityService提供了对Activiti 系统中的用户和组的管理功能。
6.  ManagementService: ManagementService提供了对Activiti流程引擎的管理和维护功能，这些功能不在工作流驱动的应用程序中使用，主要用于Activiti系统的日常维护。
7.  HistoryService: HistoryService用于获取正在运行或已经完成的流程实例的信息，与RuntimeService中获取的流程信息不同，历史信息包含已经持久化存储的永久信息，并已经被针对查询优化。

现在至少要知道有这些对象和接口。并结合Activiti Api这一章节来看，你就会对部署流程、启动流程、执行任务等操作有一个基本的概念。

3.3. 代码修改

1、在`editor-app`目录下找到`app-cfg.js`文件，将'contextRoot' : '/activiti-explorer/service',修改为本项目的路径。如下所示:

/*
     * Activiti Modeler component part of the Activiti project
     * Copyright 2005-2014 Alfresco Software, Ltd. All rights reserved.
     * 
     * This library is free software; you can redistribute it and/or
     * modify it under the terms of the GNU Lesser General Public
     * License as published by the Free Software Foundation; either
     * version 2.1 of the License, or (at your option) any later version.
     *
     * This library is distributed in the hope that it will be useful,
     * but WITHOUT ANY WARRANTY; without even the implied warranty of
     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     * Lesser General Public License for more details.
    
     * You should have received a copy of the GNU Lesser General Public
     * License along with this library; if not, write to the Free Software
     * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
     */
    'use strict';
    
    var ACTIVITI = ACTIVITI || {};
    ACTIVITI.CONFIG = {
            'contextRoot' : appContextRoot+'/service',
        };
    //ACTIVITI.CONFIG = {
    //  'contextRoot' : '/activiti-explorer/service',
    //};

2、修改modeler.html  
去掉Activiti Afresco的logo标题栏，并且把样式上的空白栏去掉：  
注意不要把该文本删除，建议加`style=”display:none”`,删除后其会造成底层下的一些内容有40个像数的东西显示不出来。：

![format_png 8][]

在load `app-cfg.js`之前加上以下脚本：

如图所示：

![format_png 9][]

3.4. 测试

在浏览器中输入以下地址：  
[http://localhost:8080/ActivitiWorkFlowDemo][http_localhost_8080_ActivitiWorkFlowDemo]（自己项目名）/model/create 请求创建模型接口  
获取到modelId后；  
再输入[http://localhost:8080/ActivitiWorkFlowDemo/modeler.html?modelId=][http_localhost_8080_ActivitiWorkFlowDemo_modeler.html_modelId]获取到的modelId 即可进入modeler.html创建模型页面。  
结果如下：

![format_png 10][]

如果报：  
Failed to load resource: the server responded with a status of 404 (Not Found)  
首先确认路径没有错。

在请求分发时，没有找到"/ActivitiWorkFlowDemo/modeler.html"的映射(No mapping found for ...)。原来是spring mvc拦截了页面对静态资源的请求，但你的controller中又没有这个路径的映射，所以页面对静态资源文件的请求并没有正确下发，那么该怎么解决这个问题呢？下面我给出参考的方法：

解决方案：

1.采用<mvc:default-servlet-handler />。 在spring mvc的xml配置文件上加上一句：<mvc:default-servlet-handler />。如下图所示：

<mvc:default-servlet-handler />
        <mvc:resources location="/resources/" mapping="/resources/**" />

加入之后，spring mvc就会对进入DispatcherServlet的URL进行筛查，如果发现是静态资源的请求，就将该请求转由Web应用服务器默认的Servlet处理，如果不是静态资源的请求，才由DispatcherServlet继续处理。这个方法是最快捷的。

2.采用<mvc:resources />。可以使用<mvc:resources />，并将静态资源放在WEB-INF目录下（或者其他你喜欢的地方），然后在springMVC-servlet中添加如下配置：

<mvc:resources location="/文件路径" mapping="/映射路径"/>

根据实际情况填写路径。

3.在web.xml文件中将spring mvc的拦截路径改为/springmvc/\*（"springmvc"可以替换成你喜欢的路径）

**附加知识点：Activiti工作流的自带数据表的含义**

1.  资源库流程规则表  
    1)act\_re\_deployment 部署信息表  
    2)act\_re\_model 流程设计模型部署表  
    3)act\_re\_procdef 流程定义数据表
2.  运行时数据库表  
    1)act\_ru\_execution 运行时流程执行实例表  
    2)act\_ru\_identitylink 运行时流程人员表，主要存储任务节点与参与者的相关信息  
    3)act\_ru\_task 运行时任务节点表  
    4)act\_ru\_variable 运行时流程变量数据表
3.  历史数据库表  
    1)act\_hi\_actinst 历史节点表  
    2)act\_hi\_attachment 历史附件表  
    3)act\_hi\_comment 历史意见表  
    4)act\_hi\_identitylink 历史流程人员表  
    5)act\_hi\_detail 历史详情表，提供历史变量的查询  
    6)act\_hi\_procinst 历史流程实例表  
    7)act\_hi\_taskinst 历史任务实例表  
    8)act\_hi\_varinst 历史变量表
4.  组织机构表  
    1)act\_id\_group 用户组信息表  
    2)act\_id\_info 用户扩展信息表  
    3)act\_id\_membership 用户与用户组对应信息表  
    4)act\_id\_user 用户信息表  
    这四张表很常见，基本的组织机构管理，关于用户认证方面建议还是自己开发一套，组件自带的功能太简单，使用中有很多需求难以满足
5.  通用数据表  
    1)act\_ge\_bytearray 二进制数据表  
    2)act\_ge\_property 属性数据表存储整个流程引擎级别的数据,初始化表结构时，会默认插入三条记录
6.  自定义数据表  
    act\_cus\_user\_task:流程各节点执行人信息表，启动流程之前初始化流程节点信息时插入节点key、节点名称、业务key和已知的各节点执行人信息。

**注**：代码已上传至GitHub：  
[https://github.com/ruoki/ActivitiWorkFlowDemo][https_github.com_ruoki_ActivitiWorkFlowDemo]  
欢迎star

[Spring_MyBatis]: https://www.jianshu.com/p/950ed3647a73
[https_pan.baidu.com_s_1XVTammPbIrbzU1MK7TBFOA]: https://links.jianshu.com/go?to=https%3A%2F%2Fpan.baidu.com%2Fs%2F1XVTammPbIrbzU1MK7TBFOA
[format_png]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy82MjEzNTc5LWM5NjY2NTNiOWIxYjljNTEucG5n?x-oss-process=image/format,png
[format_png 1]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy82MjEzNTc5LTg4YTZhNWUxZjk4MjQxZjcucG5n?x-oss-process=image/format,png
[format_png 2]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy82MjEzNTc5LWY2ZjZiMTI0ZjAzNjFjNGIucG5n?x-oss-process=image/format,png
[Tomcat7_bin_startup.bat]: https://www.jianshu.com/p/6112c07fa874
[format_png 3]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy82MjEzNTc5LTA2YTljNzY5OGQzMDk2MTgucG5n?x-oss-process=image/format,png
[format_png 4]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy82MjEzNTc5LTNmNTVmMWE5ODc3NWEwNDYucG5n?x-oss-process=image/format,png
[format_png 5]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy82MjEzNTc5LTFiNTA5OWJmNDQ0YWM5YTQucG5n?x-oss-process=image/format,png
[format_png 6]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy82MjEzNTc5LTZmMmM2YzNhMWY4YzRlZmMucG5n?x-oss-process=image/format,png
[format_png 7]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy82MjEzNTc5LTFmMTM5MjlmNzk3OTdhNDMucG5n?x-oss-process=image/format,png
[format_png 8]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy82MjEzNTc5LWNlMTVkMTBmZmJmY2ZkMjIucG5n?x-oss-process=image/format,png
[format_png 9]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy82MjEzNTc5LTQwZTdmOGE2NDU0NWUyYzIucG5n?x-oss-process=image/format,png
[http_localhost_8080_ActivitiWorkFlowDemo]: https://links.jianshu.com/go?to=http%3A%2F%2Flocalhost%3A8080%2FActivitiWorkFlowDemo
[http_localhost_8080_ActivitiWorkFlowDemo_modeler.html_modelId]: https://links.jianshu.com/go?to=http%3A%2F%2Flocalhost%3A8080%2FActivitiWorkFlowDemo%2Fmodeler.html%3FmodelId%3D
[format_png 10]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy82MjEzNTc5LWJmNTdmMzg0MTYzOTVlN2MucG5n?x-oss-process=image/format,png
[https_github.com_ruoki_ActivitiWorkFlowDemo]: https://links.jianshu.com/go?to=https%3A%2F%2Fgithub.com%2Fruoki%2FActivitiWorkFlowDemo