Flowable 流程跟踪图片

最新推荐文章于 2024-06-11 16:34:47 发布
最新推荐文章于 2024-06-11 16:34:47 发布
阅读量2.7k 收藏 20
点赞数 6
分类专栏： java 文章标签： flowable
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46157986/article/details/107176834
版权

文章目录

1. DefaultProcessDiagramGenerator

DefaultProcessDiagramGenerator是flowable默认的流程图生成器

该类中定义了各种生成图片和一些画图的方法，还有一些辅助方法（如：获取所有节点）

可以查看源码

2. DefaultProcessDiagramCanvas

DefaultProcessDiagramCanvas ：flowable 提供的默认的流程图画布
类中定义了许多字体、颜色、大小、字体等静态变量，还有bpmn中节点（task，gateway，event，flow…）的基本行程，以及各类事件的图标

initialize方法，还有用来画各种节点、连线、事件等等的方法
可以查看源码

3. 使用Flowable默认的流程图生成器

/**
 * 流程申请 流转图片输入流
 */
public void getFlowDiagram(String procInsId){

    String procDefId;
    ProcessInstance processInstance = runtimeService.createProcessInstanceQuery()
            .processInstanceId(procInsId)
            .singleResult();
    if (processInstance == null) {
        HistoricProcessInstance historicProcessInstance = historyService.createHistoricProcessInstanceQuery().processInstanceId(procInsId).singleResult();
        procDefId = historicProcessInstance.getProcessDefinitionId();

    } else {
        procDefId = processInstance.getProcessDefinitionId();
    }

    BpmnModel bpmnModel = repositoryService.getBpmnModel(procDefId);
    DefaultProcessDiagramGenerator defaultProcessDiagramGenerator = new DefaultProcessDiagramGenerator(); // 创建默认的流程图生成器
    String imageType = "png"; // 生成图片的类型
    List<String> highLightedActivities = new ArrayList<>(); // 高亮节点集合
    List<String> highLightedFlows = new ArrayList<>(); // 高亮连线集合
    List<HistoricActivityInstance> hisActInsList = historyService.createHistoricActivityInstanceQuery()
            .processInstanceId(procInsId)
            .list(); // 查询所有历史节点信息
    hisActInsList.forEach(historicActivityInstance -> { // 遍历
        if("sequenceFlow".equals(historicActivityInstance.getActivityType())) {
        	// 添加高亮连线
            highLightedFlows.add(historicActivityInstance.getActivityId());
        } else {
        	// 添加高亮节点
            highLightedActivities.add(historicActivityInstance.getActivityId());
        }
    });
    String activityFontName = "宋体"; // 节点字体
    String labelFontName = "微软雅黑"; // 连线标签字体
    String annotationFontName = "宋体"; // 连线标签字体
    ClassLoader customClassLoader = null; // 类加载器
    double scaleFactor = 1.0d; // 比例因子，默认即可
    boolean drawSequenceFlowNameWithNoLabelDI = true; // 不设置连线标签不会画
    // 生成图片
    InputStream inputStream = defaultProcessDiagramGenerator.generateDiagram(bpmnModel, imageType, highLightedActivities 
            , highLightedFlows, activityFontName, labelFontName, annotationFontName, customClassLoader,
            scaleFactor, drawSequenceFlowNameWithNoLabelDI); // 获取输入流
    /*
    try {
        // 先将图片保存
        FileUtils.copyInputStreamToFile(inputStream, new File("E:\\", "1.png"));
    } catch (IOException e) {
        e.printStackTrace();
    }
    */
    
    // 直接写到页面，要先获取HttpServletResponse
    byte[] bytes = IoUtil.readInputStream(inputStream, "flow diagram inputStream");
    response.setContentType("image/png");
    ServletOutputStream outputStream = response.getOutputStream();
    response.reset();
    outputStream.write(bytes);
    outputStream.flush();
    outputStream.close();
}

4. 自定义流程图生成器

4.1 扩展DefaultProcessDiagramCanvas

想画什么只需要覆盖掉DefaultProcessDiagramCanvas中的那个方法即可

package top.theonly.workflow.image;

import org.flowable.bpmn.model.AssociationDirection;
import org.flowable.bpmn.model.GraphicInfo;
import org.flowable.image.impl.DefaultProcessDiagramCanvas;

import java.awt.*;
import java.awt.font.FontRenderContext;
import java.awt.font.LineBreakMeasurer;
import java.awt.font.TextAttribute;
import java.awt.font.TextLayout;
import java.awt.geom.Line2D;
import java.awt.geom.Rectangle2D;
import java.awt.geom.RoundRectangle2D;
import java.text.AttributedCharacterIterator;
import java.text.AttributedString;

public class MyDefaultProcessDiagramCanvas extends DefaultProcessDiagramCanvas {
    //设置高亮线的颜色  这里我设置成绿色
    protected static Color HIGHLIGHT_SEQUENCEFLOW_COLOR = Color.GREEN;
    //设置连接线（网关）的条件字体颜色  这里我设置成绿色
    protected static Color LABEL_COLOR = new Color(10, 176, 213);

    public MyDefaultProcessDiagramCanvas(int width, int height, int minX, int minY, String imageType, String activityFontName, String labelFontName, String annotationFontName, ClassLoader customClassLoader) {
        super(width, height, minX, minY, imageType, activityFontName, labelFontName, annotationFontName, customClassLoader);
    }

    public MyDefaultProcessDiagramCanvas(int width, int height, int minX, int minY, String imageType) {
        super(width, height, minX, minY, imageType);
    }

    /**
     * 画线颜色设置
     * @param xPoints
     * @param yPoints
     * @param conditional
     * @param isDefault
     * @param connectionType
     * @param associationDirection
     * @param highLighted
     * @param scaleFactor
     */
    public void drawConnection(int[] xPoints, int[] yPoints, boolean conditional, boolean isDefault, String connectionType,
                               AssociationDirection associationDirection, boolean highLighted, double scaleFactor) {

        Paint originalPaint = g.getPaint();
        Stroke originalStroke = g.getStroke();

        g.setPaint(CONNECTION_COLOR);
        if (connectionType.equals("association")) {
            g.setStroke(ASSOCIATION_STROKE);
        } else if (highLighted) {
            //设置线的颜色
            g.setPaint(HIGHLIGHT_SEQUENCEFLOW_COLOR);
            g.setStroke(HIGHLIGHT_FLOW_STROKE);
        }

        for (int i = 1; i < xPoints.length; i++) {
            Integer sourceX = xPoints[i - 1];
            Integer sourceY = yPoints[i - 1];
            Integer targetX = xPoints[i];
            Integer targetY = yPoints[i];
            Line2D.Double line = new Line2D.Double(sourceX, sourceY, targetX, targetY);
            g.draw(line);
        }

        if (isDefault) {
            Line2D.Double line = new Line2D.Double(xPoints[0], yPoints[0], xPoints[1], yPoints[1]);
            drawDefaultSequenceFlowIndicator(line, scaleFactor);
        }

        if (conditional) {
            Line2D.Double line = new Line2D.Double(xPoints[0], yPoints[0], xPoints[1], yPoints[1]);
            drawConditionalSequenceFlowIndicator(line, scaleFactor);
        }

        if (associationDirection == AssociationDirection.ONE || associationDirection == AssociationDirection.BOTH) {
            Line2D.Double line = new Line2D.Double(xPoints[xPoints.length - 2], yPoints[xPoints.length - 2], xPoints[xPoints.length - 1], yPoints[xPoints.length - 1]);
            drawArrowHead(line, scaleFactor);
        }
        if (associationDirection == AssociationDirection.BOTH) {
            Line2D.Double line = new Line2D.Double(xPoints[1], yPoints[1], xPoints[0], yPoints[0]);
            drawArrowHead(line, scaleFactor);
        }
        g.setPaint(originalPaint);
        g.setStroke(originalStroke);
    }

    /**
     * 高亮节点设置
     * @param x
     * @param y
     * @param width
     * @param height
     */
    public void drawHighLight(int x, int y, int width, int height) {
        Paint originalPaint = g.getPaint();
        Stroke originalStroke = g.getStroke();
        //设置高亮节点的颜色
        g.setPaint(HIGHLIGHT_COLOR);
        g.setStroke(THICK_TASK_BORDER_STROKE);

        RoundRectangle2D rect = new RoundRectangle2D.Double(x, y, width, height, 20, 20);
        g.draw(rect);

        g.setPaint(originalPaint);
        g.setStroke(originalStroke);
    }

    /**
     * 条件表达式 value字体设置
     * @param text
     * @param graphicInfo
     * @param centered
     */
    public void drawLabel(String text, GraphicInfo graphicInfo, boolean centered) {
        float interline = 1.0f;

        // text
        if (text != null && text.length() > 0) {
            Paint originalPaint = g.getPaint();
            Font originalFont = g.getFont();

            g.setPaint(LABEL_COLOR);
            g.setFont(LABEL_FONT);

            int wrapWidth = 100;
            double textY = graphicInfo.getY();

            // TODO: use drawMultilineText()
            AttributedString as = new AttributedString(text);
            as.addAttribute(TextAttribute.FOREGROUND, g.getPaint());
            as.addAttribute(TextAttribute.FONT, g.getFont());
            AttributedCharacterIterator aci = as.getIterator();
            FontRenderContext frc = new FontRenderContext(null, true, false);
            LineBreakMeasurer lbm = new LineBreakMeasurer(aci, frc);

            while (lbm.getPosition() < text.length()) {
                TextLayout tl = lbm.nextLayout(wrapWidth);
                textY += tl.getAscent();
                Rectangle2D bb = tl.getBounds();
                double tX = graphicInfo.getX();
                if (centered) {
                    tX += (int) (graphicInfo.getWidth() / 2 - bb.getWidth() / 2);
                }
                tl.draw(g, (float) tX, (float) textY);
                textY += tl.getDescent() + tl.getLeading() + (interline - 1.0f) * tl.getAscent();
            }

            // restore originals
            g.setFont(originalFont);
            g.setPaint(originalPaint);
        }
    }
}

4.2 扩展DefaultProcessDiagramGenerator

package top.theonly.workflow.image;

import org.flowable.bpmn.model.*;
import org.flowable.image.impl.DefaultProcessDiagramGenerator;

import java.util.*;

public class MyDefaultProcessDiagramGenerator extends DefaultProcessDiagramGenerator {

    protected MyDefaultProcessDiagramCanvas generateProcessDiagram(BpmnModel bpmnModel, String imageType,
                                                                 List<String> highLightedActivities, List<String> highLightedFlows,
                                                                 String activityFontName, String labelFontName, String annotationFontName, ClassLoader customClassLoader, double scaleFactor, boolean drawSequenceFlowNameWithNoLabelDI) {
        this.prepareBpmnModel(bpmnModel);
        MyDefaultProcessDiagramCanvas processDiagramCanvas = initProcessDiagramCanvas(bpmnModel, imageType,
                activityFontName, labelFontName, annotationFontName, customClassLoader);
        // 实现同父类实现一模一样

        // Draw pool shape, if process is participant in collaboration
        for (Pool pool : bpmnModel.getPools()) {
            GraphicInfo graphicInfo = bpmnModel.getGraphicInfo(pool.getId());
            processDiagramCanvas.drawPoolOrLane(pool.getName(), graphicInfo, scaleFactor);
        }

        // Draw lanes
        for (org.flowable.bpmn.model.Process process : bpmnModel.getProcesses()) {
            for (Lane lane : process.getLanes()) {
                GraphicInfo graphicInfo = bpmnModel.getGraphicInfo(lane.getId());
                processDiagramCanvas.drawPoolOrLane(lane.getName(), graphicInfo, scaleFactor);
            }
        }

        // Draw activities and their sequence-flows
        for (org.flowable.bpmn.model.Process process : bpmnModel.getProcesses()) {
            for (FlowNode flowNode : process.findFlowElementsOfType(FlowNode.class)) {
                if (!isPartOfCollapsedSubProcess(flowNode, bpmnModel)) {
                    drawActivity(processDiagramCanvas, bpmnModel, flowNode, highLightedActivities, highLightedFlows, scaleFactor,drawSequenceFlowNameWithNoLabelDI);
                }
            }
        }

        // Draw artifacts
        for (org.flowable.bpmn.model.Process process : bpmnModel.getProcesses()) {

            for (Artifact artifact : process.getArtifacts()) {
                drawArtifact(processDiagramCanvas, bpmnModel, artifact);
            }

            List<SubProcess> subProcesses = process.findFlowElementsOfType(SubProcess.class, true);
            if (subProcesses != null) {
                for (SubProcess subProcess : subProcesses) {

                    GraphicInfo graphicInfo = bpmnModel.getGraphicInfo(subProcess.getId());
                    if (graphicInfo != null && graphicInfo.getExpanded() != null && !graphicInfo.getExpanded()) {
                        continue;
                    }

                    if (!isPartOfCollapsedSubProcess(subProcess, bpmnModel)) {
                        for (Artifact subProcessArtifact : subProcess.getArtifacts()) {
                            drawArtifact(processDiagramCanvas, bpmnModel, subProcessArtifact);
                        }
                    }
                }
            }
        }

        return processDiagramCanvas;
    }

    protected static MyDefaultProcessDiagramCanvas initProcessDiagramCanvas(BpmnModel bpmnModel, String imageType,
                                                                           String activityFontName, String labelFontName, String annotationFontName, ClassLoader customClassLoader) {
        // 这里与父类代码一模一样
        // We need to calculate maximum values to know how big the image will be in its entirety
        double minX = Double.MAX_VALUE;
        double maxX = 0;
        double minY = Double.MAX_VALUE;
        double maxY = 0;

        for (Pool pool : bpmnModel.getPools()) {
            GraphicInfo graphicInfo = bpmnModel.getGraphicInfo(pool.getId());
            minX = graphicInfo.getX();
            maxX = graphicInfo.getX() + graphicInfo.getWidth();
            minY = graphicInfo.getY();
            maxY = graphicInfo.getY() + graphicInfo.getHeight();
        }

        List<FlowNode> flowNodes = gatherAllFlowNodes(bpmnModel);
        for (FlowNode flowNode : flowNodes) {

            GraphicInfo flowNodeGraphicInfo = bpmnModel.getGraphicInfo(flowNode.getId());

            // width
            if (flowNodeGraphicInfo.getX() + flowNodeGraphicInfo.getWidth() > maxX) {
                maxX = flowNodeGraphicInfo.getX() + flowNodeGraphicInfo.getWidth();
            }
            if (flowNodeGraphicInfo.getX() < minX) {
                minX = flowNodeGraphicInfo.getX();
            }
            // height
            if (flowNodeGraphicInfo.getY() + flowNodeGraphicInfo.getHeight() > maxY) {
                maxY = flowNodeGraphicInfo.getY() + flowNodeGraphicInfo.getHeight();
            }
            if (flowNodeGraphicInfo.getY() < minY) {
                minY = flowNodeGraphicInfo.getY();
            }

            for (SequenceFlow sequenceFlow : flowNode.getOutgoingFlows()) {
                List<GraphicInfo> graphicInfoList = bpmnModel.getFlowLocationGraphicInfo(sequenceFlow.getId());
                if (graphicInfoList != null) {
                    for (GraphicInfo graphicInfo : graphicInfoList) {
                        // width
                        if (graphicInfo.getX() > maxX) {
                            maxX = graphicInfo.getX();
                        }
                        if (graphicInfo.getX() < minX) {
                            minX = graphicInfo.getX();
                        }
                        // height
                        if (graphicInfo.getY() > maxY) {
                            maxY = graphicInfo.getY();
                        }
                        if (graphicInfo.getY() < minY) {
                            minY = graphicInfo.getY();
                        }
                    }
                }
            }
        }

        List<Artifact> artifacts = gatherAllArtifacts(bpmnModel);
        for (Artifact artifact : artifacts) {

            GraphicInfo artifactGraphicInfo = bpmnModel.getGraphicInfo(artifact.getId());

            if (artifactGraphicInfo != null) {
                // width
                if (artifactGraphicInfo.getX() + artifactGraphicInfo.getWidth() > maxX) {
                    maxX = artifactGraphicInfo.getX() + artifactGraphicInfo.getWidth();
                }
                if (artifactGraphicInfo.getX() < minX) {
                    minX = artifactGraphicInfo.getX();
                }
                // height
                if (artifactGraphicInfo.getY() + artifactGraphicInfo.getHeight() > maxY) {
                    maxY = artifactGraphicInfo.getY() + artifactGraphicInfo.getHeight();
                }
                if (artifactGraphicInfo.getY() < minY) {
                    minY = artifactGraphicInfo.getY();
                }
            }

            List<GraphicInfo> graphicInfoList = bpmnModel.getFlowLocationGraphicInfo(artifact.getId());
            if (graphicInfoList != null) {
                for (GraphicInfo graphicInfo : graphicInfoList) {
                    // width
                    if (graphicInfo.getX() > maxX) {
                        maxX = graphicInfo.getX();
                    }
                    if (graphicInfo.getX() < minX) {
                        minX = graphicInfo.getX();
                    }
                    // height
                    if (graphicInfo.getY() > maxY) {
                        maxY = graphicInfo.getY();
                    }
                    if (graphicInfo.getY() < minY) {
                        minY = graphicInfo.getY();
                    }
                }
            }
        }

        int nrOfLanes = 0;
        for (org.flowable.bpmn.model.Process process : bpmnModel.getProcesses()) {
            for (Lane l : process.getLanes()) {

                nrOfLanes++;

                GraphicInfo graphicInfo = bpmnModel.getGraphicInfo(l.getId());
                // // width
                if (graphicInfo.getX() + graphicInfo.getWidth() > maxX) {
                    maxX = graphicInfo.getX() + graphicInfo.getWidth();
                }
                if (graphicInfo.getX() < minX) {
                    minX = graphicInfo.getX();
                }
                // height
                if (graphicInfo.getY() + graphicInfo.getHeight() > maxY) {
                    maxY = graphicInfo.getY() + graphicInfo.getHeight();
                }
                if (graphicInfo.getY() < minY) {
                    minY = graphicInfo.getY();
                }
            }
        }

        // Special case, see https://activiti.atlassian.net/browse/ACT-1431
        if (flowNodes.isEmpty() && bpmnModel.getPools().isEmpty() && nrOfLanes == 0) {
            // Nothing to show
            minX = 0;
            minY = 0;
        }
        //设置返回自定义ProcessDiagramCanvas
        return new MyDefaultProcessDiagramCanvas((int)maxX + 10, (int)maxY + 10, (int)minX, (int)minY, imageType, activityFontName, labelFontName, annotationFontName, customClassLoader);
    }
}

4.3 或者自定义类实现ProcessDiagramGenerator

将DefaultProcessDiagramGenerator的代码拷过来
将类中的 DefaultProcessDiagramCanvas 改成 MyDefaultProcessDiagramCanvas 即可
不要忘了修改构造函数

4.4 使用自定义的流程图生成器生成流程图

将 3 代码中的默认生成器替换为自定义的生成器即可

//DefaultProcessDiagramGenerator defaultProcessDiagramGenerator = new DefaultProcessDiagramGenerator();
MyDefaultProcessDiagramGenerator defaultProcessDiagramGenerator = new MyDefaultProcessDiagramGenerator();

在这里插入图片描述

theONLY24
关注
  • 6
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Flowable深入浅出-13 Flowable-BPMN操作流程之流程进展查看之流程图
01-17
Flowable深入浅出-13 Flowable-BPMN操作流程之流程进展查看之流程图,欢迎在我的专栏查看该文章（第13篇），专栏地址:https://blog.csdn.net/houyj1986/column/info/31755
Activiti6-流程跟踪监控图-节点-流程线高亮显示-支持通过、不通过、驳回、退回
03-25
Activiti6-流程跟踪监控图-节点-流程线高亮显示-支持通过、不通过、驳回、退回 支持内容： 已完成节点高亮显示、当前执行中节点红色显示 支持一个节点多条流出线，包括通过、不通过、驳回、退回，按照已执行操作正确显示高亮流程线
Flowable6.x导出/查看/跟踪流程图（续）
超然楼
04-18 1506
通过对flowable源码中bpmnModel绘制功能的整合，可以较好的实现交互式的流程图跟踪展现功能。相较静态图方式展现的流程图，这种实现方式用户交互体验更好，获取信息更加方便，具有明显优势。
《Flowable流程引擎从零到壹》引入日志框架和部署流程定义
热门推荐
小虚竹的专栏
11-27 1万+
《Flowable流程引擎从零到壹》引入日志框架和部署流程定义
Springboot 整合 Flowable（一）：使用 flowable-UI 绘制流程图
最新发布
原名：@程序员大禹
06-11 1814
​ Flowable 是一个使用 Java 编写的轻量级业务流程引擎。Flowable 流程引擎可用于部署 BPMN 2.0流程定义（用于定义流程的行业XML标准）， 创建这些流程定义的流程实例，进行查询，访问运行中或历史的流程实例与相关数据等等。 ​
Flowable6.x导出/查看/跟踪流程图
超然楼
04-18 2355
本文介绍4种绘制流程图的方式，前3种是在后台绘制静态图（image/png格式），以Stream形式返回前端显示。最后1种是后端生成JSON形式的结构化数据，由前端使用Snap.svg绘制的交互式SVG动画流程图。
获取flowable流程图资源
yang_da_da的博客
12-16 916
@PostMapping(value = "/flow/resource") public FlowResultVO getFlowResource(@RequestBody HashMap<String, String> map) throws IOException { String pId = map.get("pId"); String ...
Flowable 中生成图片
hyhanyu的博客
09-06 4252
public static void getFloawableImgae(HttpServletResponse response,String processInstanceId) throws Exception{ HistoricProcessInstance his = historyService.createHistoricProcessInstanceQuery().pr...
flowable流程引擎-核心表分析
06-27
Flowable流程引擎核心表分析 流程引擎的核心表是Flowable流程引擎的基础组件，用于存储流程引擎的各种数据。这些表可以配置为在启动时生成，所有的表都以“act_”开头，沿用了Activiti的传统。 Flowable流程引擎...
vue使用flowable绘制流程图.docx
12-11
在Vue项目中使用Flowable来绘制流程图，可以借助`workflow-bpmn-modeler`这个库，它基于Vue和bpmn.io，为Flowable提供了可视化工作流设计器。 首先，创建一个Vue 2.x项目。确保选择的Vue版本是兼容的，因为`...
flowable流程在线编辑项目
09-27
最新版flowable6.3.1流程在线编辑项目，war包形式，放置Tomcat的webapp下，自动部署安装。
springboot 整合Activiti工作流 集成 Diagram Viewer跟踪流程
10-09
springboot 整合Activiti工作流 集成 Diagram Viewer跟踪流程
Flowable 请假流程 demo 示例
02-19
Flowable 是一个强大的开源工作流和业务自动化引擎，它提供了高度灵活的业务流程管理（BPM）和案例管理（Case Management）解决方案。这个"Flowable 请假流程 demo 示例"是用于展示如何使用 Flowable 实现一个典型的...
Flowable入门系列文章172 - 用户图片获取与更新
分享牛
03-12 626
flowable入门、flowable现状、flowable开源产品、flwoable入门系列、flowable课程、flowable与activiti区别Flowable是用Java编写的轻量级业务流程引擎。 Flowable流程引擎允许您部署BPMN 2.0流程定义（用于定义流程的行业XML标准），创建流程定义的流程实例，运行查询，访问活动或历史流程实例以及相关数据等等。本节将逐步介绍各种概念和API，通过您可以在自己的开发机器上进行的实例进行实现。
flowable（三） 启动一个流程并跟踪
nalanxiaoxiao2011的博客
12-15 1559
flowable 工作流启动过程
日志10.11Flowable基本操作
Answer_G的博客
10-11 804
Flowable基本操作 1.创建ProcessEngine 2.部署流程定义 3.启动流程实例 4.查看任务 5.完成任务 6.流程的删除 7.查看历史信息
Flowable 6.6.0 BPMN用户指南 - 17 高级用例 - 17.13 日志记录会话[实验性]
月满闲庭的博客
01-05 308
17.13 日志记录会话[实验性] Added in 6.5.0, Logging sessions allow you to collect information about process execution even if an exception causes the transaction to be rolled back. This is enabled by providing a LoggingListener implementation to the engine configura
flowable绘制流程图
qq_36022463的博客
01-28 1166
flowable流程图中文乱码解决 ： https://blog.csdn.net/qq_21518697/article/details/126917630。
springboot+flowable第二节（流程基本操作）
悢七的CSDN博客
03-18 4054
mysql数据库 目录1.部署流程2.引入流程引擎3.启动流程4.查询待办列表5.审批通过6.查询已办列表7.查询发起列表 1.部署流程 举例：部署一个如下图的流程 在src/main/resources下创建processes文件夹，然后新建bpmn20.xml文件 添加如下内容： <?xml version="1.0" encoding="UTF-8"?> <definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值