前后端分离的情况下生成activiti流程图

已于 2022-02-02 15:36:29 修改
阅读量1.5k 收藏 3
点赞数
分类专栏： java 文章标签： java 后端
于 2022-02-02 15:30:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37148232/article/details/122769775
版权
该篇博客主要讨论如何在Linux服务器上通过接口调用来显示图片流。当部署到某些最小化的Linux环境时，遇到中文显示不全的问题，原因是系统缺少宋体字体。解决方案是安装字体以确保正确显示。文中详细展示了接口定义、Activiti模板方法、ActivitiProcessImageHelper类以及相关方法的实现，用于处理图片流并高亮显示流程节点。
摘要由CSDN通过智能技术生成

页面用调接口的方式，将图片流显示。效果图：
注意：布署到有些最小安装的linux服务器时，用户任务框里面的中文会显示不出来，这是因为缺少系统字体(宋体)，需要在服务器安装字体才能正常显示。
在这里插入图片描述
接口定义：

//instanceId为业务数据绑定到前端列表接口
@RequestMapping("/img")
	public void showProposess(String instanceId) throws Exception {
		activitiTemplate.responseProcessImg(instanceId, "proposes_410000_v1");
	}

activiti模板方法:

@Autowired
	private ActivitiProcessImageHelper imageHelper;

	public void responseProcessImg(String instanceId, String processDefinitionKey) {
		imageHelper.responseProcessImg(instanceId, processDefinitionKey);
	}

ActivitiProcessImageHelper 类：

public class ActivitiProcessImageHelper {

	@Autowired
	RuntimeService runtimeService;
	@Autowired
	RepositoryService repositoryService;
	@Autowired
	HistoryService historyService;
	@Autowired
	LakerProcessDiagramGenerator lakerProcessDiagramGenerator;
	@Autowired(required = false)
	HttpServletResponse response;

	public void responseProcessImg(String instanceId, String processDefinitionKey) {
		BpmnModel bpmnModel = getBpmnModel(processDefinitionKey);
		List<String> highLightedActivities = null;
		try {
			highLightedActivities = runtimeService.getActiveActivityIds(instanceId);
		} catch (Exception e) {
			// 已完结的流程查不到活动节点
			highLightedActivities = new ArrayList<String>();
		}

		List<HistoricActivityInstance> historyActivits = historyService.createHistoricActivityInstanceQuery()
				.processInstanceId(instanceId).orderByHistoricActivityInstanceId().asc().list();
		List<String> highLightedFlows = getHighLightedFlows(bpmnModel, historyActivits);
		try (InputStream ins = generateImgStream(bpmnModel, highLightedActivities, highLightedFlows);
				ServletOutputStream outputStream = response.getOutputStream()) {
			response.setContentType("image/jpg");
			int len = 0;
			byte[] b = new byte[1024];
			while ((len = ins.read(b)) != -1) {
				outputStream.write(b, 0, len);
				outputStream.flush();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	private InputStream generateImgStream(BpmnModel bpmnModel, List<String> highLightedActivities,
			List<String> highLightedFlows) {
		return lakerProcessDiagramGenerator.generateDiagram(bpmnModel, "jpg", highLightedActivities, highLightedFlows,
				"宋体", "宋体", "宋体", null, 1);
	}

	private BpmnModel getBpmnModel(String definitionKey) {
		ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().latestVersion()
				.processDefinitionKey(definitionKey).singleResult();
		return repositoryService.getBpmnModel(processDefinition.getId());// 模型
	}

	private List<String> getHighLightedFlows(BpmnModel bpmnModel, List<HistoricActivityInstance> historyActivitis) {
		// 高亮流程已发生流转的线id集合
		List<String> highLightedFlowIds = new ArrayList<>();
		// 全部活动节点
		List<FlowNode> historicActivityNodes = new ArrayList<>();
		// 已完成的历史活动节点
		List<HistoricActivityInstance> finishedActivityInstances = new ArrayList<>();

		for (HistoricActivityInstance historicActivityInstance : historyActivitis) {
			FlowNode flowNode = (FlowNode) bpmnModel.getMainProcess()
					.getFlowElement(historicActivityInstance.getActivityId(), true);
			historicActivityNodes.add(flowNode);
			if (historicActivityInstance.getEndTime() != null) {
				finishedActivityInstances.add(historicActivityInstance);
			}
		}

		FlowNode currentFlowNode = null;
		FlowNode targetFlowNode = null;
		// 遍历已完成的活动实例，从每个实例的outgoingFlows中找到已执行的
		for (HistoricActivityInstance currentActivity : finishedActivityInstances) {
			// 获得当前活动对应的节点信息及outgoingFlows信息
			currentFlowNode = (FlowNode) bpmnModel.getMainProcess().getFlowElement(currentActivity.getActivityId(),
					true);
			List<SequenceFlow> sequenceFlows = currentFlowNode.getOutgoingFlows();

			/**
			 * 遍历outgoingFlows 并找到已已流转的 满足如下条件认为已已流转： 
			 * 1.当前节点是并行网关或兼容网关 ，则通过outgoingFlows能够在历史活动中找到的全部节点均为已流转 
			 * 2.当前节点是以上两种类型之外的， 通过outgoingFlows查找到的时间最早的流转节点视为有效流转
			 */
			if ("parallelGateway".equals(currentActivity.getActivityType())
					|| "inclusiveGateway".equals(currentActivity.getActivityType())) {
				// 遍历历史活动节点，找到匹配流程目标节点的
				for (SequenceFlow sequenceFlow : sequenceFlows) {
					targetFlowNode = (FlowNode) bpmnModel.getMainProcess().getFlowElement(sequenceFlow.getTargetRef(),
							true);
					if (historicActivityNodes.contains(targetFlowNode)) {
						highLightedFlowIds.add(targetFlowNode.getId());
					}
				}
			} else {
				for (int i = 0; i < historyActivitis.size(); i++) {
					if (i != historyActivitis.size() - 1) {
						HistoricActivityInstance historyActiviti = historyActivitis.get(i);
						if (currentActivity.getActivityId().equals(historyActiviti.getActivityId())) {
							// 找到当前节点的下一个节点
							HistoricActivityInstance nexActivity = historyActivitis.get(i + 1);
							for (SequenceFlow sequenceFlow : sequenceFlows) {
								if (nexActivity.getActivityId().equals(sequenceFlow.getTargetRef())) {
									highLightedFlowIds.add(sequenceFlow.getId());
								}
							}
							continue;
						}
					}

				}
			}

		}
		return highLightedFlowIds;
	}
}

LakerProcessDiagramCanvas类：

public class LakerProcessDiagramCanvas extends DefaultProcessDiagramCanvas {

	public LakerProcessDiagramCanvas(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);
		THICK_TASK_BORDER_STROKE = new BasicStroke(6.0f);
		Color wcolor = new Color(240, 240, 240);
		//任务盒子的底色
		TASK_BOX_COLOR = wcolor;
		//子流程底色
		SUBPROCESS_BOX_COLOR = wcolor;
		//事件的底色
		EVENT_COLOR = wcolor;
		//连接箭头颜色
		CONNECTION_COLOR = new Color(220, 220, 220);
		CONDITIONAL_INDICATOR_COLOR = wcolor;
		//高亮线条颜色
		HIGHLIGHT_COLOR = Color.BLUE;
		//任务里面那个字的颜色
		LABEL_COLOR =Color.RED;
		//任务边框颜色
		TASK_BORDER_COLOR = new Color(220, 220, 220);
		EVENT_BORDER_COLOR = new Color(220, 220, 220);
		SUBPROCESS_BORDER_COLOR = new Color(100, 100, 100);
		HIGHLIGHT_FLOW_STROKE = new BasicStroke(3f);
		GATEWAY_TYPE_STROKE = new BasicStroke(1.0f);
		try {
			//用户任务左上角那个图标的图片类路径地址
			USERTASK_IMAGE = ImageIO.read(ReflectUtil.getResource("img/taskicon.jpg", customClassLoader));
		} catch (IOException e) {
			e.printStackTrace();
		}
		g.setColor(new Color(220, 220, 220));
	}

	public LakerProcessDiagramCanvas(int width, int height, int minX, int minY, String imageType) {
		super(width, height, minX, minY, imageType);
		HIGHLIGHT_COLOR = Color.BLUE;
		THICK_TASK_BORDER_STROKE = new BasicStroke(6.0f);
	}

	public void drawHighLightColor(int x, int y, int width, int height, Color color) {
		Paint originalPaint = g.getPaint();
		Stroke originalStroke = g.getStroke();

		g.setPaint(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);
	}
}

LakerProcessDiagramGenerator 类：

import java.awt.Color;
import java.util.List;

import org.activiti.bpmn.model.Activity;
import org.activiti.bpmn.model.Artifact;
import org.activiti.bpmn.model.BpmnModel;
import org.activiti.bpmn.model.CallActivity;
import org.activiti.bpmn.model.FlowElement;
import org.activiti.bpmn.model.FlowElementsContainer;
import org.activiti.bpmn.model.FlowNode;
import org.activiti.bpmn.model.Gateway;
import org.activiti.bpmn.model.GraphicInfo;
import org.activiti.bpmn.model.Lane;
import org.activiti.bpmn.model.MultiInstanceLoopCharacteristics;
import org.activiti.bpmn.model.Pool;
import org.activiti.bpmn.model.Process;
import org.activiti.bpmn.model.SequenceFlow;
import org.activiti.bpmn.model.SubProcess;
import org.activiti.image.impl.DefaultProcessDiagramCanvas;
import org.activiti.image.impl.DefaultProcessDiagramGenerator;

public class LakerProcessDiagramGenerator extends DefaultProcessDiagramGenerator {
	// private BufferedImage processDiagram;

	@Override
	protected DefaultProcessDiagramCanvas generateProcessDiagram(BpmnModel bpmnModel, String imageType,
			List<String> highLightedActivities, List<String> highLightedFlows, String activityFontName,
			String labelFontName, String annotationFontName, ClassLoader customClassLoader, double scaleFactor) {

		{

			prepareBpmnModel(bpmnModel);

			DefaultProcessDiagramCanvas 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);
			}

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

			// Draw activities and their sequence-flows
			for (FlowNode flowNode : bpmnModel.getProcesses().get(0).findFlowElementsOfType(FlowNode.class)) {
				drawActivity(processDiagramCanvas, bpmnModel, flowNode, highLightedActivities, highLightedFlows,
						scaleFactor);
			}

			for (Process process : bpmnModel.getProcesses()) {
				for (FlowNode flowNode : process.findFlowElementsOfType(FlowNode.class)) {
					drawActivity(processDiagramCanvas, bpmnModel, flowNode, highLightedActivities, highLightedFlows,
							scaleFactor);
				}
			}

			// Draw artifacts
			for (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) {
						for (Artifact subProcessArtifact : subProcess.getArtifacts()) {
							drawArtifact(processDiagramCanvas, bpmnModel, subProcessArtifact);
						}
					}
				}
			}

			return processDiagramCanvas;
		}
	}

	@Override
	protected void drawActivity(DefaultProcessDiagramCanvas processDiagramCanvas, BpmnModel bpmnModel,
			FlowNode flowNode, List<String> highLightedActivities, List<String> highLightedFlows, double scaleFactor) {

		{

			ActivityDrawInstruction drawInstruction = activityDrawInstructions.get(flowNode.getClass());
			if (drawInstruction != null) {

				drawInstruction.draw(processDiagramCanvas, bpmnModel, flowNode);

				// Gather info on the multi instance marker
				boolean multiInstanceSequential = false, multiInstanceParallel = false, collapsed = false;
				if (flowNode instanceof Activity) {
					Activity activity = (Activity) flowNode;
					MultiInstanceLoopCharacteristics multiInstanceLoopCharacteristics = activity
							.getLoopCharacteristics();
					if (multiInstanceLoopCharacteristics != null) {
						multiInstanceSequential = multiInstanceLoopCharacteristics.isSequential();
						multiInstanceParallel = !multiInstanceSequential;
					}
				}

				// Gather info on the collapsed marker
				GraphicInfo graphicInfo = bpmnModel.getGraphicInfo(flowNode.getId());
				if (flowNode instanceof SubProcess) {
					collapsed = graphicInfo.getExpanded() != null && !graphicInfo.getExpanded();
				} else if (flowNode instanceof CallActivity) {
					collapsed = true;
				}

				if (scaleFactor == 1.0) {
					// Actually draw the markers
					processDiagramCanvas.drawActivityMarkers((int) graphicInfo.getX(), (int) graphicInfo.getY(),
							(int) graphicInfo.getWidth(), (int) graphicInfo.getHeight(), multiInstanceSequential,
							multiInstanceParallel, collapsed);
				}

			
				if (highLightedActivities.contains(flowNode.getId())) {
					if (highLightedActivities.get(highLightedActivities.size() - 1)
							.equalsIgnoreCase(flowNode.getId())) {

						LakerProcessDiagramCanvas lakerProcessDiagramCanvas = ((LakerProcessDiagramCanvas) processDiagramCanvas);
						lakerProcessDiagramCanvas.drawHighLightColor((int) graphicInfo.getX(), (int) graphicInfo.getY(),
								(int) graphicInfo.getWidth(), (int) graphicInfo.getHeight(), Color.YELLOW);
					} else {
						processDiagramCanvas.drawHighLight((int) graphicInfo.getX(), (int) graphicInfo.getY(),
								(int) graphicInfo.getWidth(), (int) graphicInfo.getHeight());
					}

				}

			}

			// Outgoing transitions of activity
			for (SequenceFlow sequenceFlow : flowNode.getOutgoingFlows()) {
				boolean highLighted = (highLightedFlows.contains(sequenceFlow.getId()));
				String defaultFlow = null;
				if (flowNode instanceof Activity) {
					defaultFlow = ((Activity) flowNode).getDefaultFlow();
				} else if (flowNode instanceof Gateway) {
					defaultFlow = ((Gateway) flowNode).getDefaultFlow();
				}

				boolean isDefault = false;
				if (defaultFlow != null && defaultFlow.equalsIgnoreCase(sequenceFlow.getId())) {
					isDefault = true;
				}
				boolean drawConditionalIndicator = sequenceFlow.getConditionExpression() != null
						&& !(flowNode instanceof Gateway);

				String sourceRef = sequenceFlow.getSourceRef();
				String targetRef = sequenceFlow.getTargetRef();
				FlowElement sourceElement = bpmnModel.getFlowElement(sourceRef);
				FlowElement targetElement = bpmnModel.getFlowElement(targetRef);
				List<GraphicInfo> graphicInfoList = bpmnModel.getFlowLocationGraphicInfo(sequenceFlow.getId());
				if (graphicInfoList != null && graphicInfoList.size() > 0) {
					graphicInfoList = connectionPerfectionizer(processDiagramCanvas, bpmnModel, sourceElement,
							targetElement, graphicInfoList);
					int xPoints[] = new int[graphicInfoList.size()];
					int yPoints[] = new int[graphicInfoList.size()];

					for (int i = 1; i < graphicInfoList.size(); i++) {
						GraphicInfo graphicInfo = graphicInfoList.get(i);
						GraphicInfo previousGraphicInfo = graphicInfoList.get(i - 1);

						if (i == 1) {
							xPoints[0] = (int) previousGraphicInfo.getX();
							yPoints[0] = (int) previousGraphicInfo.getY();
						}
						xPoints[i] = (int) graphicInfo.getX();
						yPoints[i] = (int) graphicInfo.getY();

					}

					processDiagramCanvas.drawSequenceflow(xPoints, yPoints, drawConditionalIndicator, isDefault,
							highLighted, scaleFactor);

					// Draw sequenceflow label
					GraphicInfo labelGraphicInfo = bpmnModel.getLabelGraphicInfo(sequenceFlow.getId());
					if (labelGraphicInfo != null) {
						processDiagramCanvas.drawLabel(sequenceFlow.getName(), labelGraphicInfo, false);
					}
				}
			}

			// Nested elements
			if (flowNode instanceof FlowElementsContainer) {
				for (FlowElement nestedFlowElement : ((FlowElementsContainer) flowNode).getFlowElements()) {
					if (nestedFlowElement instanceof FlowNode) {
						drawActivity(processDiagramCanvas, bpmnModel, (FlowNode) nestedFlowElement,
								highLightedActivities, highLightedFlows, scaleFactor);
					}
				}
			}
		}
	}

	protected static DefaultProcessDiagramCanvas 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 (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;
		}

		return new LakerProcessDiagramCanvas((int) maxX + 10, (int) maxY + 10, (int) minX, (int) minY, imageType,
				activityFontName, labelFontName, annotationFontName, customClassLoader);
	}

}
浅度差文
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring boot整合activiti项目，前后端分离。
qq_34445909的博客
01-08 856
SpringBoot整合Activiti实现流程图的在线绘制、流程规则配置、请假流程申请和借款流程申请，流程流转与业务处理。 1、项目截图展示 登录 首页 功能菜单 模型管理（设计流程页面）和流程管理（管理已经运行的流程，可外部导入流程文件） 请假申请流程图 个人任务代办和已办任务 通过流程后自定义指定下一个审批人 管理运行中的流程和查看详情 2.项目获取 评论加微信获取源码和资料。 ...
Spring Boot 2.x整合Activiti工作流以及模型设计器（前后端分离 iview admin vue 集成activiti工作流 模型设计器 动态数据权限 ）
xhyxxx的博客
04-18 1万+
宣传官网 http://xb.exrick.cn 在线Demo http://xboot.exrick.cn 开源版Github地址 https://github.com/Exrick/x-boot 开发文档 https://www.kancloud.cn/exrick/xboot/1009234 获取完整版 http://xpay.exrick.cn/pay?xboot 集成Activ...
前后端分离Springboot 整合使用activiti7教程（一）（全网最细）
谁说自己不可以
03-30 4624
SpringBootyuActiviti7的详细整合使用，笔记整理不易，请继续关注订阅专栏
前后端分离项目中引入activiti工作流引擎
09-05
基于前后端分离项目引入activiti工作流引擎，某些配置信息需根据自己项目情况修改
SpringBoot项目中Activiti工作流的使用（前后端代码+数据库）
最新发布
2301_81867536的博客
05-23 580
springboot+vue+activiti集成了activiti在线编辑器，流行的前后端分离部署开发模式，快速开发平台，可插拔工作流服务。工作流表单可平滑的接入自定义表单，接入后进行业务审批流转。本项目集成了工作流所有的功能，并做了一个测试的表单进行审批演示。工作流部分功能含：流程图在线绘制，在线发布，工作流权限设置，审批节点设置（角色，直接指定人，部门等），业务表单关联，提交，撤回，与签或签，同意，驳回（支持驳回到任意岗），审批委托，流程挂起，流程图实时跟踪，审批提醒，可接入钉钉进行钉钉通知，企业微信
Springboot 项目源码 vue.js html 跨域 前后分离 websocket即时通讯
07-16 516
后台框架：springboot2.1.2+activiti6.0.0+mybaits+maven+接口前端页面：html +vue.js 形式 jqueryajax 异步跨域 json 格式数据交互 前后分离，前后台分开部署（特别注意，前端用的vue.js, 就是html页面引入vue.js形式， 用tomcat部署运行，更适合后台开发者）-------------...
前后端分离项目中引入activiti工作流引擎步骤
05-05
前后端分离项目中引入activiti工作流引擎步骤
Activiti工作流引擎入门
12-20
- 它支持动态流程变更，无需修改代码即可调整流程，这是因为流程的管理基于流程图，而不是硬编码的状态字段。 - Activiti通过工作流引擎自动推进流程，通过记录当前节点状态来确保流程的正确执行。 - 它提供了一套...
jeecg-boot 集成Activiti6 后端Java 模块代码
10-26
它是一个基于Spring Boot的开源项目，提供了丰富的功能，如代码生成、前后端分离、插件化开发等，旨在提高开发效率，降低维护成本。Jeecg-boot集成了许多流行的技术，如MyBatis Plus、Shiro、JWT等，为开发者构建...
java OA办公管理系统 Springboot vue.js 前后分离 跨域 工作流 集成代码生成器（csdn）——.pdf
12-01
本文将详细讲解一个基于Java的OA办公管理系统，该系统采用Springboot框架，前端使用vue.js实现前后端分离，同时具备跨域处理、工作流管理和集成代码生成器等功能。此系统旨在提高开发效率，提供高效稳定的办公自动化...
springBoot+activiti
12-13
本文将深入探讨如何在 Spring Boot 应用中集成 Activiti 5.22 版本，以及如何实现流程图的高亮显示、XML 文件的生成，并通过测试用例进行验证。 ### 一、Activiti 简介 Activiti 是一个基于 BPMN 2.0 规范的开源...
x-boot前后端分离开发平台
11-03
基于Spring Boot 2.x的前后端分离开发平台X-Boot 前端：Vue+iView Admin 后端：Spring Boot 2.x/Spring Security/JWT/Spring Data JPA+Mybatis-Plus/Redis/Elasticsearch/Activiti 分布式限流/同步锁/验证码/SnowFlake雪花算法ID生成 动态权限管理 数据权限 工作流 代码生成 日志记录 定时任务 第三方社交账号、短信登录 单点登录
Spring Boot 2.x整合Websocket（基于Spring Boot 2.x 前后端分离 iview admin vue 集成activiti工作流 模型设计器 动态数据权限 ）
xhyxxx的博客
04-18 1819
宣传官网 http://xb.exrick.cn 在线Demo http://xboot.exrick.cn 开源版Github地址 https://github.com/Exrick/x-boot 开发文档 https://www.kancloud.cn/exrick/xboot/1009234 获取完整版 http://xpay.exrick.cn/pay?xboot Stomp是一...
Java Spring boot element ui activiti前后端分离，流程审批，权限管理框架
热门推荐
爱技术、爱生活
08-29 4万+
是什么？ 使用springboot,activiti,mybatis,vue elementui开发的后台管理系统（包含权限管理、工作流等功能），真正前后端分离的微服务架构,经过很多项目实战、淬炼、软件开发公司主流技术的集大成者。 有什么用？ 在此基础上可二次开发(OA、ERP、CRM、金融、网站后台)等管理系统 可以做APP、微信企业号、公众号的后台，json标准接口 系统功能完善（用户...
Java Spring boot element-ui activiti前后端分离，流程审批，权限管理框架
weixin_33961829的博客
09-02 1791
是什么？使用springboot,activiti,mybatis,vue elementui开发的后台管理系统（包含权限管理、工作流等功能），真正前后端分离的微服务架构,经过很多项目实战、淬炼、软件开发公司主流技术的集大成者。功能点、技术点前端采用vue elementui框架，后端springboot,mybatis开发框架，数据库:mysql后端多模块项目（基础设施子项目、基础功能子项目、业...
Activiti工作流开发指南（springboot 2.x iview admin vue 前后端分离 模型设计器 动态数据权限 权限按钮显示 spring security）
xhyxxx的博客
04-18 5858
宣传官网 http://xb.exrick.cn 在线Demo http://xboot.exrick.cn 开源版Github地址 https://github.com/Exrick/x-boot 开发文档 https://www.kancloud.cn/exrick/xboot/1009234 获取完整版 http://xpay.exrick.cn/pay?xboot 集成Activ...
使用Html+echarts+ajax+flask，构建一个前后端分离的数据可视化（基础图形)
moyuxi188的博客
06-29 757
此次为学生党的一个期末作业，涉及到了python链接mysql、flask搭建简易后端、python数据处理、html+echarts绘制图表。搭建后端。
activiti7项目-spingboot+vue前后端分离
Ailurophile的博客
07-01 2950
工作流的一个demo项目 前端使用vue框架，组件库采用的是iview，基于iview-admin-simple进行的二次开发 后端是gradle构建的spingboot项目，RSA非对称加密+Redis缓存+Jwt认证登录，接口文档集成了Swagger，activiti7的版本为7.1.0.M4 线上地址：http://159.75.100.116:8066 ...
Activiti结合VUE实现前后端分离、权限管理、路由动态挂载、流程审批
lll0627的博客
08-16 9388
Activiti结合VUE实现前后端分离、权限管理、路由动态挂载、流程审批简介技术点后端项目目录前端代码目录预览地址：加QQ索要图片预览：购买须知购买理由疑问解惑 简介 本框架是基于十多年项目开发经验积累，用最佳实践和流行技术开发现代前后端分离的通用项目模板。适合web应用，微信、手机应用管理端及服务端。使用springboot,activiti,mybatis,vue elementui、nod...
Activiti流程图详解：Eclipse版个人学习总结
"这篇文档是关于使用Eclipse进行Activiti流程图绘制的个人总结，主要涵盖了图形符号、表达式和Eclipse绘图属性等方面的知识。 Activiti是一个流行的工作流引擎，用于实现业务流程自动化。" 文章详细内容： ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值