流程引擎Camunda开发记录(四)—表act_hi_procinst和act_hi_actinst

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了流程引擎Camunda开发记录(四)—表act_hi_procinst和act_hi_actinst相关的知识,希望对你有一定的参考价值。

参考技术A 字段名称 | 字段类型| 可否为空 | 描述

:-------- | ----- | ---------- | :----------

ID_ | varchar(64) | | 主键

PROC_INST_ID_ | varchar(64) | | 流程实例ID

BUSINESS_KEY_ | varchar(255) | NULL | 业务KEY

PROC_DEF_KEY_ | varchar(255) | NULL | 流程定义KEY

PROC_DEF_ID_ | varchar(64) | | 流程定义ID

START_TIME_ | datetime | | 开始时间

END_TIME_ | datetime | NULL | 结束时间

REMOVAL_TIME_ | datetime | NULL | 移除时间

DURATION_ | bigint(20) | NULL | 耗时

START_USER_ID_ | varchar(255) | NULL | 启动人ID

START_ACT_ID_ | varchar(255) | NULL | 启动节点ID

END_ACT_ID_ | varchar(255) | NULL | 结束节点ID

SUPER_PROCESS_INSTANCE_ID_ | varchar(64) | NULL | 父流程实例ID

ROOT_PROC_INST_ID_ | varchar(64) | NULL | 流程实例根ID

SUPER_CASE_INSTANCE_ID_ | varchar(64) | NULL | 父案例实例ID

CASE_INST_ID_ | varchar(64) | NULL | 案例实例ID

DELETE_REASON_ | varchar(4000) | NULL | 删除原因

TENANT_ID_ | varchar(64) | NULL | 租户ID

STATE_ | varchar(255) | NULL | 状态

ID_ | varchar(64) | | 主键

PARENT_ACT_INST_ID_| varchar(64) | NULL | 父节点实例ID

PROC_DEF_KEY_| varchar(255) | NULL | 流程定义KEY

PROC_DEF_ID_ | varchar(64) | | 流程定义ID

ROOT_PROC_INST_ID_| varchar(64)| NULL | 流程实例根ID

PROC_INST_ID_ | varchar(64) | | 流程实例ID

EXECUTION_ID_| varchar(64)| | 执行实例ID

ACT_ID_| varchar(255)| | 节点ID

TASK_ID_ | varchar(64)| NULL| 任务ID

CALL_PROC_INST_ID_ | varchar(64)| NULL| 调用外部的流程实例ID

CALL_CASE_INST_ID_ | varchar(64)| NULL| 调用外部的案例实例ID

ACT_NAME_| varchar(255)| NULL| 节点名称

ACT_TYPE_ | varchar(255) | | 节点类型

ASSIGNEE_ | varchar(64)| NULL| 办理人

START_TIME_| datetime| | 开始时间

END_TIME_| datetime | NULL | 结束时间

DURATION_| bigint(20)| NULL| 耗时

ACT_INST_STATE_| int(11) | NULL | 活动实例状态

SEQUENCE_COUNTER_| bigint(20) | NULL| 序列计数器

TENANT_ID_ | varchar(64)| NULL| 租户ID

REMOVAL_TIME_| datetime| NULL| 删除时间

开源流程引擎Camunda BPM如何扩展数据库表

前言

在使用开源流程引擎(如:JBPM、Activiti、Flowable、Camunda等)的时候,经常会遇到这样的需求,我们需要按照业务需求增加一张数据库的表,而且这张表是跟工作流引擎有交互的(注意不是一张业务表),那么如何扩展一张数据库表并无缝地融入到流程引擎的机制中呢?下面以Camunda BPM为例,介绍如何扩展自定义数据库表。

模拟一个客户需求

假设某一客户的业务流程很多,有几百个,这些流程在camunda里是平层放的,没有按照业务归类,不便于管理和使用,客户希望把这些流程按照业务分类展示,就像一棵目录树,分A、B、C一层目录,A下面又分A1、A2、A3第二层目录,A1、A2、A3下面放的是具体的业务流程定义。
我们分析这个需求,需要扩展一张数据库表记录业务分类目录,同时需要在流程定义表里扩展一个字段,关联这个业务分类目录,这样才能实现流程定义按照业务分类展示。

扩展数据库表步骤

1. 建表

在camunda数据库里创建一张表,命名为act_re_proc_catalog(流程分类目录表)。

在这里插入图片描述
MySQL建表语句:

CREATE TABLE `act_re_proc_catalog` (
  `ID_` varchar(64) COLLATE utf8_bin NOT NULL DEFAULT \'\' COMMENT \'主键\',
  `CATALOG_CODE_` varchar(255) COLLATE utf8_bin DEFAULT NULL COMMENT \'业务分类编码\',
  `CATALOG_NAME_` varchar(255) COLLATE utf8_bin DEFAULT NULL COMMENT \'业务分类名称\',
  `PARENT_ID_` varchar(64) COLLATE utf8_bin DEFAULT NULL COMMENT \'父节点ID\',
  `CREATE_TIME_` datetime DEFAULT NULL COMMENT \'插入或修改时间\',
  `TENANT_ID_` varchar(64) COLLATE utf8_bin DEFAULT NULL,
  PRIMARY KEY (`ID_`) USING BTREE,
  KEY `ACT_IDX_PROC_CATALOG_TENANT_ID` (`TENANT_ID_`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin ROW_FORMAT=COMPACT;

2. 创建实体类

按照camunda的规则,创建实体类必须基于接口,所以先创建接口,接口命名为ProcessCatalog。
import java.util.Date;
public interface ProcessCatalog {
   

   String getId();

   String getCatalogCode() ;

   String getCatalogName() ;

   String getParentId() ;

   Date getCreateTime() ;

   String getTenantId();

}

接着创建实体类,实现上面的接口和DbEntity接口,实体类命名为ProcessCatalogEntity。

import org.camunda.bpm.engine.impl.db.DbEntity;
import org.camunda.bpm.engine.repository.ProcessCatalog;

import java.io.Serializable;
import java.util.Date;

/** * 流程目录实体类 */
public class ProcessCatalogEntity implements Serializable, ProcessCatalog, DbEntity {
   

  private static final long serialVersionUID = 1L;

  protected String id;
  protected String catalogCode;
  protected String catalogName;
  protected String parentId;
  protected Date createTime;
  protected String tenantId;


  public Object getPersistentState() {
   
    // properties of this entity are immutable
    // so always the same value is returned
    // so never will an update be issued for a DeploymentEntity
    return ProcessCatalogEntity.class;
  }


  public String getId() {
   
    return id;
  }

  public void setId(String id) {
   
    this.id = id;
  }

  public String getCatalogCode() {
   
    return catalogCode;
  }

  public void setCatalogCode(String catalogCode) {
   
    this.catalogCode = catalogCode;
  }

  public String getCatalogName() {
   
    return catalogName;
  }

  public void setCatalogName(String catalogName) {
   
    this.catalogName = catalogName;
  }

  public String getParentId() {
   
    return parentId;
  }

  public void setParentId(String parentId) {
   
    this.parentId = parentId;
  }

  public Date getCreateTime() {
   
    return createTime;
  }

  public void setCreateTime(Date createTime) {
   
    this.createTime = createTime;
  }

  public String getTenantId() {
   
    return tenantId;
  }

  public void setTenantId(String tenantId) {
   
    this.tenantId = tenantId;
  }


  @Override
  public String toString() {
   
    return this.getClass().getSimpleName()
           + "[id=" + id
           + ", catalogCode=" + catalogCode
           + ", catalogName=" + catalogName
           + ", parentId=" + parentId
            + ", createTime=" + createTime
           + ", tenantId=" + tenantId
           + "]";
  }

}

3. 创建mybatis mapper文件

mapper文件命名为ProcessCatalog.xml

insert into ${prefix}ACT_RE_PROC_CATALOG(ID_, CATALOG_CODE_, CATALOG_NAME_, PARENT_ID_, CREATE_TIME_, TENANT_ID_)
    values(#{id, jdbcType=VARCHAR},   #{catalogCode, jdbcType=VARCHAR}, #{catalogName, jdbcType=VARCHAR}, #{parentId, jdbcType=VARCHAR}, #{createTime, jdbcType=TIMESTAMP}, #{tenantId, jdbcType=VARCHAR})
  

  
    update ${prefix}ACT_RE_PROC_CATALOG
    
      PROCDEF_ = #{procdef, jdbcType=VARCHAR},
      CATALOG_CODE_ = #{catalogCode, jdbcType=VARCHAR},
      CATALOG_NAME_ = #{catalogName, jdbcType=VARCHAR},
      PARENT_ID_ = #{parentId, jdbcType=VARCHAR},
      CREATE_TIME_ = #{createTime, jdbcType=TIMESTAMP},
      TENANT_ID_ = #{tenantId, jdbcType=VARCHAR}
    
    where ID_= #{id, jdbcType=VARCHAR}
  

  
    delete from ${prefix}ACT_RE_PROC_CATALOG where ID_ = #{id}
    select * from ${prefix}ACT_RE_PROC_CATALOG where ID_ = #{id}
  
  	
    ${limitBefore}
    select ${distinct} RES.*
    ${limitBetween}
    
    ${orderBy}
    ${limitAfter}
  
    select count(distinct RES.ID_)
    
  

  

    from ${prefix}ACT_RE_PROC_CATALOG RES

    

    
      
        RES.ID_ = #{id}
      
      
        and RES.CATALOG_CODE_ = #{catalogCode}
      
      
        and RES.CATALOG_NAME_ = #{catalogName}
      
      
        and RES.PARENT_ID_ = #{parentId}
      
      
        and RES.CREATE_TIME_ < #{createTimeBefore}
      
      
        and RES.CREATE_TIME_ > #{createTimeAfter}
      
      
        
          and ( RES.TENANT_ID_ in
          
            #{tenantId}
          
          
            or RES.TENANT_ID_ is null
          
          )
        
        
          and RES.TENANT_ID_ is null
    select *
    from ${prefix}ACT_RE_PROC_CATALOG
    where PARENT_ID_ = #{parameter.parentId}
    
      and CATALOG_CODE_ = #{parameter.catalogCode}
    
    
      and CATALOG_NAME_ = #{parameter.catalogName}
    
    
      and TENANT_ID_ is null
    
    
      and TENANT_ID_ = #{parameter.tenantId}
    
    order by CATALOG_CODE_ asc
  

  
    
    ${limitBefore}
    select ${distinct} RES.*
    ${limitBetween}
    
   	${orderBy}
    ${limitAfter}
  

  
    select count(distinct RES.ID_)

4. 创建数据查询类

按照camunda的规则,创建查询类必须基于接口,所以先创建查询接口,接口命名为ProcessCatalogQuery.java。

import org.camunda.bpm.engine.impl.QueryPropertyImpl;
import org.camunda.bpm.engine.query.Query;
import org.camunda.bpm.engine.query.QueryProperty;
import java.util.Date;

/** * 流程分类查询接口 */
public interface ProcessCatalogQuery extends Query<ProcessCatalogQuery, ProcessCatalog>{
   

  public static final QueryProperty  CATALOG_CODE = new QueryPropertyImpl("CATALOG_CODE_");
  public static final QueryProperty CREATE_TIME = new QueryPropertyImpl("CREATE_TIME_");
  public static final QueryProperty TENANT_ID = new QueryPropertyImpl("TENANT_ID_");

   ProcessCatalogQuery id(String id);

   ProcessCatalogQuery catalogCode(String catalogCode) ;

   ProcessCatalogQuery catalogName(String catalogName);

   ProcessCatalogQuery parentId(String parentId) ;

   ProcessCatalogQuery createTimeBefore(Date before);

   ProcessCatalogQuery createTimeAfter(Date after) ;

   ProcessCatalogQuery tenantIdIn(String... tenantIds) ;

   ProcessCatalogQuery withoutTenantId() ;

   ProcessCatalogQuery orderByCatalogCode();

   ProcessCatalogQuery orderByCreateTime();

   ProcessCatalogQuery orderByTenantId();

}

然后创建查询实现类,命名为ProcessCatalogQueryImpl.java

import org.camunda.bpm.engine.impl.interceptor.CommandContext;
import org.camunda.bpm.engine.impl.interceptor.CommandExecutor;
import org.camunda.bpm.engine.impl.util.CompareUtil;
import org.camunda.bpm.engine.repository.ProcessCatalog;
import org.camunda.bpm.engine.repository.ProcessCatalogQuery;

import java.io.Serializable;
import java.util.Date;
import java.util.List;
import static org.camunda.bpm.engine.impl.util.EnsureUtil.ensureNotNull;

/** * 流程表单配置查询实现 */
public class ProcessCatalogQueryImpl extends AbstractQuery<ProcessCatalogQuery, ProcessCatalog> implements ProcessCatalogQuery, Serializable {
   

  private static final long serialVersionUID = 1L;
  protected String id;
  protected String catalogCode;
  protected String catalogName;
  protected String parentId;
  protected Date createTime;
  protected String tenantId;
  protected Date createTimeBefore;
  protected Date createTimeAfter;
  protected boolean isTenantIdSet = false;
  protected String[] tenantIds;


  public ProcessCatalogQueryImpl() {
   
  }

  public ProcessCatalogQueryImpl(CommandExecutor commandExecutor) {
   
    super(commandExecutor);
  }

  public ProcessCatalogQuery id(String id) {
   
    ensureNotNull("Id ", id);
    this.id = id;
    return this;
  }

  public ProcessCatalogQuery catalogCode(String catalogCode) {
   
    ensureNotNull("catalogCode", catalogCode);
    this.catalogCode = catalogCode;
    return this;
  }


  public ProcessCatalogQuery catalogName(String catalogName) {
   
    ensureNotNull("catalogName", catalogName);
    this.catalogName = catalogName;
    return this;
  }

  public ProcessCatalogQuery parentId(String parentId) {
   
    ensureNotNull("parentId", parentId);
    this.parentId = parentId;
    return this;
  }


  public ProcessCatalogQuery createTimeBefore(Date before) {
   
    ensureNotNull("createTimeBefore", before);
    this.createTimeBefore = before;
    return this;
  }

  public ProcessCatalogQuery createTimeAfter(Date after) {
   
    ensureNotNull("createTimeAfter", after);
    this.createTimeAfter = after;
    return this;
  }

  public ProcessCatalogQuery tenantIdIn(String... tenantIds) {
   
    ensureNotNull("tenantIds", (Object[]) tenantIds);
    this.tenantIds = tenantIds;
    isTenantIdSet = true;
    return this;
  }

  public ProcessCatalogQuery withoutTenantId() {
   
    isTenantIdSet = true;
    this.tenantIds = null;
    return this;
  }

  protected boolean hasExcludingConditions() {
   
    return super.hasExcludingConditions() || CompareUtil.areNotInAscendingOrder(createTimeAfter, createTimeBefore);
  }

  public ProcessCatalogQuery orderByCatalogCode() {
   
    return orderBy(ProcessCatalogQuery.CATALOG_CODE);
  }

  public ProcessCatalogQuery orderByCreateTime() {
   
    return orderBy(ProcessCatalogQuery.CREATE_TIME);
  }

  public ProcessCatalogQuery orderByTenantId() {
   
    return orderBy(ProcessCatalogQuery.TENANT_ID);
  }

  @Override
  public long executeCount(CommandContext commandContext) {
   
    checkQueryOk();
    return commandContext.getProcessCatalogManager().findProcessCatalogCountByQueryCriteria(this);
  }

  @Override
  public List executeList(CommandContext commandContext, Page page) {
   
    checkQueryOk();
    return commandContext.getProcessCatalogManager().findProcessCatalogsByQueryCriteria(this, page);
  }

  public String getId() {
   
    return id;
  }

  public String getCatalogCode() {
   
    return catalogCode;
  }
  public String getCatalogName() {
   
    return catalogName;
  }
  public String getParentId() {
   
    return parentId;
  }

  public Date getCreateTimeBefore() {
   
    return createTimeBefore;
  }

  public Date getCreateTimeAfter() {
   
    return createTimeAfter;
  }

}

5. 创建数据库操作类

数据库操作类类似于DAO类,camunda的规则为xxxManager,我们命名该类为ProcessCatalogManager.java

import org.camunda.bpm.engine.impl.Page;
import org.camunda.bpm.engine.impl.ProcessCatalogQueryImpl;
import org.camunda.bpm.engine.impl.db.ListQueryParameterObject;
import org.camunda.bpm.engine.impl.persistence.AbstractManager;
import org.camunda.bpm.engine.repository.ProcessCatalog;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/** * 流程分类数据库操作类 */
public class ProcessCatalogManager extends AbstractManager {
   

  public void insertProcessCatalog(ProcessCatalogEntity processCatalogEntity) {
   
    getDbEntityManager().insert(processCatalogEntity);
    getDbEntityManager().update(ProcessCatalogEntity.class,"updateProcessCatalog",processCatalogEntity);
  }

  public void updateProcessCatalog(ProcessCatalogEntity processCatalogEntity) {
   
    getDbEntityManager().update(ProcessCatalogEntity.class,"updateProcessCatalog",processCatalogEntity);
  }

  public void deleteProcessCatalog(String id, final boolean cascade) {
   
    if (cascade) {
    }
    getDbEntityManager().delete(ProcessCatalogEntity.class, "deleteProcessCatalog", id);
  }


  public List findProcessCatalogsByParentId(String parentId) {
   
    Map<String, Object> parameters = new HashMap<String, Object>();
    parameters.put("parentId", parentId);
    ListQueryParameterObject parameterObject = new ListQueryParameterObject();
    parameterObject.setParameter(parameters);
    List list = getDbEntityManager().selectList("selectProcessCatalogsByProcdef", parameterObject);
    return list;
  }

  public ProcessCatalogEntity findProcessCatalogById(String id) {
   
    return getDbEntityManager().selectById(ProcessCatalogEntity.class, id);
  }

  public long findProcessCatalogCountByQueryCriteria(ProcessCatalogQueryImpl processCatalogQuery) {
   
    configureQuery(processCatalogQuery);
    return (Long) getDbEntityManager().selectOne("selectProcessCatalogCountByQueryCriteria", processCatalogQuery);
  }

  @SuppressWarnings("unchecked")
  public List findProcessCatalogsByQueryCriteria(ProcessCatalogQueryImpl processCatalogQuery, Page page) {
   
    configureQuery(processCatalogQuery);
    return getDbEntityManager().selectList("selectProcessCatalogsByQueryCriteria", processCatalogQuery, page);
  }


  @Override
  public void close() {
   
  }

  @Override
  public void flush() {
   
  }

  protected void configureQuery(ProcessCatalogQueryImpl query) {
   
    getAuthorizationManager().configureCatalogQuery(query);
    getTenantManager().configureQuery(query);
  }
}

6. 在mybatis中注册mapping

我们自定义的的mapping文件需要注册到全局的mappings.xml中,其实就是mybatis的机制,找到mappings.xml文件,增加如下一条记录。

<mapper resource="org/camunda/bpm/engine/impl/mapping/entity/ProcessCatalog.xml" />

7. 在上下文中注册数据库操作类

Camunda中大量应用了命令模式,有自己的一套事务管理机制,数据库操作类必须要在CommandContext.java中进行注册。

public ProcessCatalogManager getProcessCatalogManager() {
   
    return getSession(ProcessCatalogManager.class);
  }

8. 在全局配置中注册数据库操作类

在ProcessEngineConfigurationImpl.java类的initSessionFactories方法中注册数据库操作类ProcessCatalogManager。

addSessionFactory(new GenericManagerFactory(ProcessCatalogManager.class));

总结

通过以上的8个步骤,就可以在camunda中任意扩展数据库表了,同时我们也深入了解camunda原生数据操作机制。

 

以上是关于流程引擎Camunda开发记录(四)—表act_hi_procinst和act_hi_actinst的主要内容,如果未能解决你的问题,请参考以下文章

流程引擎Camunda开发记录(四)—表 ACT_RE_PROCDEF、ACT_RE_DEPLOYMENT、ACT_RE_MODEL

流程引擎Camunda开发记录(一)

流程引擎Camunda开发记录(二)上

流程引擎之Camunda开发记录(三)

流程引擎之Camunda开发记录(六)流程部署的四种方法

流程引擎之Camunda开发记录(七)从中间节点开启实例