流程引擎

发现写一点逻辑就更新下博客，有点麻烦，还是后端逻辑写完了在来更新了，可以去文章下方看看我gitee提交的代码，陆续更改吧！！！

流程引擎对于工作中，时刻在使用，最简单的就是请假，需要填写相关信息，提交给上级，然后再上一级，逐级下去，完成自己的请假。
以前使用activiti流程引擎实现工作上的任务扭转，基本就是通过调用api获取process的对象，基于此来进行一些逻辑判断。而现在因为工作不使用activiti，那么就只能开始了造轮子系列，前端菜鸟这里就只展示自己后端逻辑了。

前期设计

模板表设计（并不完整，后续补充）

1.模板表：用于记录流程模型
2.节点表：用于记录流程节点，与模板表关联
3.模板关联表：用于记录模型与表单关联

package com.process.processengine.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import java.util.Date;

@Data
public class BaseEntity {
    @TableId(type = IdType.ASSIGN_UUID)
    @ApiModelProperty(value = "主键")
    private String id;
    private Date createTime;
    private Date updateTime;
    private String createBy;
    private String updateBy;
}

package com.process.processengine.entity;

import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

@Data
@TableName("process_model")
@ApiModel(value="模板", description="模板")
public class ProcessModelEntity extends BaseEntity{

    @ApiModelProperty(value = "模板名")
    private String modelName;

    @ApiModelProperty(value = "是否启用 0否 1是")
    private Integer modelStatus = 0;
}

package com.process.processengine.entity;

import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.experimental.Accessors;

@Data
@ApiModel(value = "节点信息")
@TableName("process_model_node")
@Accessors(chain = true)
public class ProcessModelNodeEntity extends BaseEntity{
    @ApiModelProperty(value = "节点code")
    private String nodeCode;

    @ApiModelProperty(value = "节点名")
    private String nodeName;

    @ApiModelProperty(value = "节点类型 0开始节点 1普通节点 2判断节点 3退回到上一步节点 4退回到开始节点 5结束节点 （类型等扩展）")
    private Integer nodeType;

    @ApiModelProperty(value = "模板id")
    private String modelId;

    @ApiModelProperty(value = "下一节点code")
    private String nextNodeCode;

    @ApiModelProperty(value = "下一节点名")
    private String nextNodeName;

    @ApiModelProperty(value = "参与类型 机构0 人员1 角色2")
    private Integer participationType;

    @ApiModelProperty(value = "参与类型code 机构id 人员id 角色id")
    private String participationCode;

    @ApiModelProperty(value = "判断条件")
    private String paramCondition;
}

package com.process.engine.entity;

import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.experimental.Accessors;

@Data
@ApiModel("模板表单关联表")
@TableName("process_model_table")
@Accessors(chain = true)
public class ProcessModelTableEntity extends BaseEntity{
    @ApiModelProperty("表id")
    private String tableId;

    @ApiModelProperty("模板id")
    private String modelId;
}

流程模板相关功能

package com.process.engine.controller;

import com.process.common.result.Result;
import com.process.engine.entity.ProcessModelEntity;
import com.process.engine.service.ProcessModelService;
import com.process.engine.vo.Model2TableVo;
import com.process.engine.vo.ProcessModelInfoVo;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/processModle")
@Api(tags = "processModel")
public class ProcessModelController {

    @Autowired
    private ProcessModelService processModelService;

    /**
     * ProcessModelInfoVo 模板信息
     * 存储修改模板
     */
    @PostMapping("/saveOrUpdateModel")
    @ApiOperation(value = "存储修改模板", notes = "存储修改模板")
    public Result<?> saveOrUpdateModel(@RequestBody ProcessModelInfoVo processModelInfoVo) {
        try {
            return Result.ok(processModelService.saveOrUpdateModel(processModelInfoVo));
        }catch (RuntimeException e){
            e.printStackTrace();
            return Result.error("存储修改模板系统繁忙");
        }
    }

    /**
     * 查询模板
     * queryType 查询类型，默认查询本人，传1查询全部
     */
    @GetMapping("/getModel")
    @ApiOperation(value = "查询模板", notes = "查询模板")
    public Result<?> getModel(Integer queryType) {
        try{
            return  Result.ok(processModelService.findModel(queryType));
        }catch (RuntimeException e){
            e.printStackTrace();
            return Result.error("查询模板系统繁忙");
        }
    }

    /**
     * 启用暂停模板
     * modelId 模板id
     */
    @PostMapping("/start2Stop")
    @ApiOperation(value = "启用暂停模板", notes = "启用暂停模板")
    public Result<?> start2Stop(@RequestBody ProcessModelEntity processModelEntity) {
        try{
            processModelService.start2Stop(processModelEntity);
            return  Result.ok();
        }catch (RuntimeException e){
            e.printStackTrace();
            return Result.error(e.getMessage());
        }
    }

    @PostMapping("saveModel2Table")
    @ApiOperation(value = "模板与表单关联", notes = "模板与表单关联")
    public Result<?> saveModel2Table(@RequestBody Model2TableVo model2TableVo){
        try{
            processModelService.saveModel2Table(model2TableVo);
            return  Result.ok();
        }catch (RuntimeException e){
            e.printStackTrace();
            return Result.error(e.getMessage());
        }
    }
}

package com.process.engine.service.serviceImpl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.process.engine.Intercept.UserIntercept;
import com.process.common.utils.BeanChangeUtils;
import com.process.engine.entity.BaseEntity;
import com.process.engine.entity.ProcessModelEntity;
import com.process.engine.entity.ProcessModelNodeEntity;
import com.process.engine.entity.ProcessModelTableEntity;
import com.process.engine.mappers.ProcessModelMapper;
import com.process.engine.mappers.ProcessModelNodeMapper;
import com.process.engine.mappers.ProcessModelTableMapper;
import com.process.engine.service.ProcessModelService;
import com.process.engine.vo.Model2TableVo;
import com.process.engine.vo.ProcessModelInfoVo;
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 java.util.Date;
import java.util.List;
import java.util.UUID;

@Service
public class ProcessModelServiceImpl extends ServiceImpl<ProcessModelMapper, ProcessModelEntity> implements ProcessModelService {
    @Autowired
    private ProcessModelMapper processModelMapper;

    @Autowired
    private ProcessModelNodeMapper processModelNodeMapper;

    @Autowired
    private ProcessModelTableMapper processModelTableMapper;

    @Override
    @Transactional
    public String saveOrUpdateModel(ProcessModelInfoVo processModelInfoVo) {
        List<ProcessModelNodeEntity> nodeList = processModelInfoVo.getNodeList();
        ProcessModelEntity processModelEntity = new ProcessModelEntity();
        if (StringUtils.isEmpty(processModelInfoVo.getModelId())) {
            processModelEntity.setModelName(processModelInfoVo.getModelName());
            processModelMapper.insert(processModelEntity);
            if (nodeList == null || nodeList.size() < 1) throw new RuntimeException("节点信息未录入");
            for (ProcessModelNodeEntity node : nodeList) {
                node.setId(UUID.randomUUID().toString().trim().replaceAll("-", ""));
                node.setModelId(processModelEntity.getId());
                node.setCreateBy(UserIntercept.getCurrentUser().getCreateBy());
                node.setCreateTime(new Date());
            }
            processModelNodeMapper.saveNode(nodeList);
            return processModelEntity.getId();
        }
        //如果传了模板id，则模板节点修改
        processModelEntity.setId(processModelInfoVo.getModelId());
        if (StringUtils.isNotEmpty(processModelInfoVo.getModelName())) {
            processModelEntity.setModelName(processModelInfoVo.getModelName());
            processModelMapper.updateById(processModelEntity);
        }
        LambdaQueryWrapper<ProcessModelNodeEntity> nodeQueryWrapper = new LambdaQueryWrapper<>();
        nodeQueryWrapper.eq(ProcessModelNodeEntity::getModelId, processModelInfoVo.getModelId());
        processModelNodeMapper.delete(nodeQueryWrapper);
        if (nodeList == null || nodeList.size() < 1) throw new RuntimeException("节点信息未录入");
        for (ProcessModelNodeEntity node : nodeList) {
            node.setId(UUID.randomUUID().toString().trim().replaceAll("-", ""));
            node.setModelId(processModelInfoVo.getModelId());
            node.setCreateBy(UserIntercept.getCurrentUser().getCreateBy());
            node.setCreateTime(new Date());
        }
        processModelNodeMapper.saveNode(nodeList);
        return processModelEntity.getId();
    }

    @Override
    public List<ProcessModelEntity> findModel(Integer queryType) {
        LambdaQueryWrapper<ProcessModelEntity> queryWrapper = new LambdaQueryWrapper<>();
        if (queryType == null || queryType != 1) {
            queryWrapper.eq(BaseEntity::getCreateBy, UserIntercept.getCurrentUser().getCreateBy());
        }
        return processModelMapper.selectList(queryWrapper);
    }

    @Override
    public void start2Stop(ProcessModelEntity processModelEntity) {
        if (processModelEntity.getModelStatus() == 0) {
            processModelEntity.setModelStatus(1);
        } else {
            processModelEntity.setModelStatus(0);
        }
        if (processModelMapper.updateById(processModelEntity) < 1) {
            throw new RuntimeException("修改状态失败");
        }
    }

    @Override
    public void saveModel2Table(Model2TableVo model2TableVo) {
        //查询模板是否启用
        LambdaQueryWrapper<ProcessModelEntity> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(BaseEntity::getId,model2TableVo.getModelId());
        ProcessModelEntity processModelEntity = processModelMapper.selectOne(queryWrapper);
        if (processModelEntity != null && processModelEntity.getModelStatus() != 1) throw new RuntimeException("关联失败,请启动模板");

        //删除表单以前绑定模板，在重新关联
        LambdaQueryWrapper<ProcessModelTableEntity> pmtQueryWrapper = new LambdaQueryWrapper<>();
        pmtQueryWrapper.eq(ProcessModelTableEntity::getModelId,model2TableVo.getModelId()).eq(ProcessModelTableEntity::getTableId,model2TableVo.getTableId());
        processModelTableMapper.delete(pmtQueryWrapper);
        ProcessModelTableEntity processModelTableEntity = BeanChangeUtils.convert(model2TableVo, ProcessModelTableEntity.class);
        if (processModelTableMapper.insert(processModelTableEntity) < 1) {
            throw new RuntimeException("关联失败");
        }
    }
}

自己的gitee地址

随缘慢慢更新

https://gitee.com/skyfly-l/process-engine

原文链接：https://blog.csdn.net/GCsky_fly/article/details/124651245