activitiy学习 (动态加签，动态流程图，指定节点跳转，指定多人节点跳转)

已于 2023-02-15 15:47:50 修改
阅读量4.3k 收藏 19
点赞数 2
分类专栏： 学习 文章标签： 学习 流程图 java
于 2023-02-15 15:45:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37335177/article/details/129044364
版权

activitiy学习 动态加签，动态流程图，指定节点跳转，指定多人节点跳转

Demo: https://gitee.com/makino_a_mu_silk/activitiydemo.git

POM.XML

<properties>
        <java.version>1.8</java.version>
        <activiti.version>7.0.0.SR1</activiti.version>
        <mysql.version>8.0.22</mysql.version>
        <slf4j.version>2.0.5</slf4j.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web-services</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-engine</artifactId>
            <version>${activiti.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>org.mybatis</groupId>
                    <artifactId>mybatis</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-spring</artifactId>
            <version>${activiti.version}</version>
        </dependency>
        <!-- bpmn 模型处理 -->
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-bpmn-model</artifactId>
            <version>${activiti.version}</version>
        </dependency>
        <!-- bpmn 转换 -->
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-bpmn-converter</artifactId>
            <version>${activiti.version}</version>
        </dependency>
        <!-- bpmn json数据转换 -->
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-json-converter</artifactId>
            <version>${activiti.version}</version>
        </dependency>
        <!-- bpmn 布局 -->
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-bpmn-layout</artifactId>
            <version>${activiti.version}</version>
        </dependency>
        <!-- mysql驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>
        <!-- 链接池 -->
        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>1.4</version>
        </dependency>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.6</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.75</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-image-generator</artifactId>
            <version>${activiti.version}</version>
        </dependency>
        <!--mybatis-plus（springboot版）-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.1</version>
        </dependency>
    </dependencies>

部署流程

@Test
	public void testDeployment(){
//        1、创建ProcessEngine
		ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//        2、得到RepositoryService实例
		RepositoryService repositoryService = processEngine.getRepositoryService();
//        3、使用RepositoryService进行部署
		Deployment deployment = repositoryService.createDeployment()
				.addClasspathResource("bpmn/test.bpmn") // 添加bpmn资源
				//png资源命名是有规范的。Leave.myLeave.png|jpg|gif|svg  或者Leave.png|jpg|gif|svg
				.addClasspathResource("bpmn/test.png")  // 添加png资源
				.name("请假申请流程")
				.deploy();
//        4、输出部署信息
		System.out.println("流程部署id：" + deployment.getId());
		System.out.println("流程部署名称：" + deployment.getName());
	}

启动流程

@GetMapping("/startTask")
//	@ApiOperation("启动任务:目前只有test;helloword;")
	public Object startTask(String taskName) {
		return service.startTask(taskName);
	}
@Override
	public Object startTask(String taskName) {
		//        1、创建ProcessEngine
		ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//        2、获取RunTimeService
		RuntimeService runtimeService = processEngine.getRuntimeService();
//        3、根据流程定义Id启动流程
		ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(taskName);
//        输出内容
		System.out.println("流程定义id：" + processInstance.getProcessDefinitionId());
		System.out.println("流程实例id：" + processInstance.getId());
		System.out.println("当前活动Id：" + processInstance.getActivityId());
		final ProcessInstanceVo processInstanceVo = new ProcessInstanceVo();
		processInstanceVo.setProcessDefinitionId(processInstance.getProcessDefinitionId());
		processInstanceVo.setId(processInstance.getId());
		processInstanceVo.setActivityId(processInstance.getActivityId());
		return processInstanceVo;
	}

查询待执行任务

@GetMapping("/getTask")
//	@ApiOperation("查询人员待执行任务")
	public Object getTask(String assignee) {
		return service.getTask(assignee);
	}
@Override
	public Object getTask(String assignee) {
		//        任务负责人
		ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//        创建TaskService
		TaskService taskService = processEngine.getTaskService();
//        根据流程key 和 任务负责人 查询任务
		List<Task> list = taskService.createTaskQuery()
//				.processDefinitionKey("test") //流程Key
				.taskAssignee(assignee)//只查询该任务负责人的任务
				.list();
		for (Task task : list) {
			System.out.println("----------------------------");
			System.out.println("流程实例id：" + task.getProcessInstanceId());
			System.out.println("任务id：" + task.getId());
			System.out.println("任务负责人：" + task.getAssignee());
			System.out.println("任务名称：" + task.getName());
		}
		final List<TaskVo> data = list.stream().map(item -> {
			TaskVo vo = new TaskVo();
			vo.setProcessInstanceId(item.getProcessInstanceId());
			vo.setId(item.getId());
			vo.setAssignee(item.getAssignee());
			vo.setName(item.getName());
			return vo;
		}).collect(Collectors.toList());
		return JSONObject.toJSONString(data, true);
	}

查询任务历史

	@GetMapping("/getTaskHistory")
//	@ApiOperation("查询任务历史")
	public Object getTaskHistory(String proInsId) {
		return service.getTaskHistory(proInsId);
	}
@Override
	public Object getTaskHistory(String proInsId) {
		//      获取引擎
		ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//        获取HistoryService
		HistoryService historyService = processEngine.getHistoryService();
//        获取 actinst表的查询对象
		HistoricActivityInstanceQuery instanceQuery = historyService.createHistoricActivityInstanceQuery();
//        查询 actinst表，条件：根据 InstanceId 查询，查询一个流程的所有历史信息
		instanceQuery.processInstanceId(proInsId);
//        查询 actinst表，条件：根据 DefinitionId 查询，查询一种流程的所有历史信息
//        instanceQuery.processDefinitionId("myLeave:1:22504");
//        增加排序操作,orderByHistoricActivityInstanceStartTime 根据开始时间排序 asc 升序
		instanceQuery.orderByHistoricActivityInstanceStartTime().asc();
//        查询所有内容
		List<HistoricActivityInstance> activityInstanceList = instanceQuery.list();
//        输出
		for (HistoricActivityInstance hi : activityInstanceList) {
			if (hi.getActivityName() != null) {
				System.out.println(hi.getActivityId());
				System.out.println(hi.getActivityName());
				System.out.println(hi.getProcessDefinitionId());
				System.out.println(hi.getProcessInstanceId());
				System.out.println("<==========================>");
			}
		}
		final List<HistoricActivityInstanceVo> data = activityInstanceList.stream().filter(item -> item.getActivityName() != null)
				.map(item -> {
					HistoricActivityInstanceVo vo = new HistoricActivityInstanceVo();
					vo.setActivityId(item.getActivityId());
					vo.setActivityName(item.getActivityName());
					vo.setProcessDefinitionId(item.getProcessDefinitionId());
					vo.setProcessInstanceId(item.getProcessInstanceId());
					return vo;
				}).collect(Collectors.toList());
		return JSONObject.toJSONString(data, true);
	}

完成任务

	@GetMapping("/completeTask")
//	@ApiOperation("完成任务")
	public Object completeTask(String taskId, String assignee) {
		return service.completeTask(taskId, assignee);
	}
	@Override
	public Object completeTask(String taskId, String assignee) {
		//        流程定义的Key
//		String key = "test";
//        任务负责人
//		String assingee = "张三";
//		String assingee = "李四";
//		String assingee = "王五";

//        String assingee = "张财务";
		//        获取流程引擎
		ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//        获取taskservice
		TaskService taskService = processEngine.getTaskService();
//        查询任务
		Task task = taskService.createTaskQuery()
				.taskId(taskId)
				.taskAssignee(assignee)
				.singleResult();
		if(task != null){
			//     根据任务id来   完成任务
			taskService.complete(task.getId());
		}
		return "成功";
	}

多人会签节点的退回指定节点

	@GetMapping("/rollBackToAppointNode")
//	@ApiOperation("多人会签节点的退回指定节点")
	public Object returnAppointNode(String taskId, String assignee) {
		return service.returnAppointNode(taskId, assignee);
	}
@Override
public Object returnAppointNode(String taskId, String assignee) {
		//        1、创建ProcessEngine
		ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
		final TaskService taskService = processEngine.getTaskService();
		final HistoryService historyService = processEngine.getHistoryService();
		final RepositoryService repositoryService = processEngine.getRepositoryService();
		final RuntimeService runtimeService = processEngine.getRuntimeService();
		Task task1 = taskService.createTaskQuery()
				.taskId(taskId)
				.taskAssignee(assignee)
				.singleResult();
		String processInstanceId = task1.getProcessInstanceId();
		String nowUserId = assignee;
		String tarActivityId = "Task_0wj3769";
		//获取待执行的任务节点
		List<Task> task = taskService.createTaskQuery().processInstanceId(processInstanceId).list();
		if(ObjectUtils.isEmpty(task)){
			// throw new Exception("sorry,the process is not started or has finished, cannot be withdrawn");
			System.out.println("sorry,the process is not started or has finished, cannot be withdrawn");
		}
		//找到当前运行的节点
		HistoricProcessInstance processInstance = historyService.createHistoricProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();
		String processDefinitionId = processInstance.getProcessDefinitionId();
		//获取流程模型
		BpmnModel bpmnModel = repositoryService.getBpmnModel(processDefinitionId);
		//想要回退到的节点位置
		System.out.println(tarActivityId);
		FlowNode myFlowNode = (FlowNode) bpmnModel.getMainProcess().getFlowElement(tarActivityId);
		//原本的活动方向
		Execution execution = runtimeService.createExecutionQuery().executionId(task.get(0).getExecutionId()).singleResult();
		String activityId = execution.getActivityId();
		FlowNode flowNode = (FlowNode) bpmnModel.getMainProcess().getFlowElement(activityId);
		//记录原活动方向
		List<SequenceFlow> oriSequenceFlows = new ArrayList<SequenceFlow>();
		oriSequenceFlows.addAll(flowNode.getOutgoingFlows());
		//清理活动方向
		flowNode.getOutgoingFlows().clear();
		//建立新方向
		List<SequenceFlow> newSequenceFlowList = new ArrayList<SequenceFlow>();
		SequenceFlow newSequenceFlow = new SequenceFlow();
		newSequenceFlow.setId("newSequenceFlowId"+" ROLLBACK: "+ LocalDateTime.now());
		//新方向的源头---当前节点
		newSequenceFlow.setSourceFlowElement(flowNode);
		System.out.println("--------------new flow-----------------"+flowNode);
		//新方向的目标---要回退的节点
		System.out.println("--------------target flow-----------------"+myFlowNode);
		newSequenceFlow.setTargetFlowElement(myFlowNode);
		newSequenceFlowList.add(newSequenceFlow);
		flowNode.setOutgoingFlows(newSequenceFlowList);

		Authentication.setAuthenticatedUserId(nowUserId);
		for (int i = 0; i < task.size(); i++) {
			// TODO 多人会签节点退回 所有节点回退即可
//			taskService.deleteTask(task.get(i).getId(), "回退", Boolean.TRUE);
			taskService.addComment(task.get(i).getId(), task.get(i).getProcessInstanceId(), "回退");
			//完成任务
			System.out.println("========================完成任务====================");
			taskService.complete(task.get(i).getId());
		}

		//恢复原方向
		flowNode.setOutgoingFlows(oriSequenceFlows);
		System.out.println("------------------RollBack successfully！！----------------------------");
        return "成功";
	}

退回到指定多人会签节点

	@GetMapping("/rollBackToAppointNode1")
//	@ApiOperation("退回到指定多人会签节点")
	public Object returnAppointNode1(String taskId, String assignee) {
		return service.returnAppointNode1(taskId, assignee);
	}
@Override
	public Object returnAppointNode1(String taskId, String assignee) {
		//        1、创建ProcessEngine
		ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
		final TaskService taskService = processEngine.getTaskService();
		final HistoryService historyService = processEngine.getHistoryService();
		final RepositoryService repositoryService = processEngine.getRepositoryService();
		final RuntimeService runtimeService = processEngine.getRuntimeService();
		Task task1 = taskService.createTaskQuery()
				.taskId(taskId)
				.taskAssignee(assignee)
				.singleResult();
		String processInstanceId = task1.getProcessInstanceId();
		String nowUserId = assignee;
		//TODO 退回上一节点为 会签节点时 指向上一节点的网关节点
		String tarActivityId = "Gateway_1bdorji";
		//获取待执行的任务节点
		Task task = taskService.createTaskQuery().processInstanceId(processInstanceId).singleResult();
		if(task == null){
			// throw new Exception("sorry,the process is not started or has finished, cannot be withdrawn");
			System.out.println("sorry,the process is not started or has finished, cannot be withdrawn");
		}
		//通过processInstanceId查询历史节点
		List<HistoricTaskInstance> htiList = historyService.createHistoricTaskInstanceQuery()
				.processInstanceId(processInstanceId)
				.orderByTaskCreateTime()
				.asc()
				.list();
		String myTaskId = null;
		HistoricTaskInstance myTask = null;
		//找到当前运行的节点
		HistoricProcessInstance processInstance = historyService.createHistoricProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();
		String processDefinitionId = processInstance.getProcessDefinitionId();
		//获取流程模型
		BpmnModel bpmnModel = repositoryService.getBpmnModel(processDefinitionId);
		//想要回退到的节点位置
		System.out.println(tarActivityId);
		FlowNode myFlowNode = (FlowNode) bpmnModel.getMainProcess().getFlowElement(tarActivityId);
		//原本的活动方向
		Execution execution = runtimeService.createExecutionQuery().executionId(task.getExecutionId()).singleResult();
		String activityId = execution.getActivityId();
		FlowNode flowNode = (FlowNode) bpmnModel.getMainProcess().getFlowElement(activityId);
		//记录原活动方向
		List<SequenceFlow> oriSequenceFlows = new ArrayList<SequenceFlow>();
		oriSequenceFlows.addAll(flowNode.getOutgoingFlows());
		//清理活动方向
		flowNode.getOutgoingFlows().clear();
		//建立新方向
		List<SequenceFlow> newSequenceFlowList = new ArrayList<SequenceFlow>();
		SequenceFlow newSequenceFlow = new SequenceFlow();
		newSequenceFlow.setId("newSequenceFlowId"+" ROLLBACK: "+ LocalDateTime.now());
		//新方向的源头---当前节点
		newSequenceFlow.setSourceFlowElement(flowNode);
		System.out.println("--------------new flow-----------------"+flowNode);
		//新方向的目标---要回退的节点
		System.out.println("--------------target flow-----------------"+myFlowNode);
		newSequenceFlow.setTargetFlowElement(myFlowNode);
		newSequenceFlowList.add(newSequenceFlow);
		flowNode.setOutgoingFlows(newSequenceFlowList);

		Authentication.setAuthenticatedUserId(nowUserId);
		taskService.addComment(task.getId(), task.getProcessInstanceId(), "回退");
		//完成任务
		System.out.println("========================完成任务====================");
		taskService.complete(task.getId());

		//恢复原方向
		flowNode.setOutgoingFlows(oriSequenceFlows);
		System.out.println("------------------RollBack successfully！！----------------------------");
		//将退回完成后的当前节点的task返回
//        HistoricActivityInstance historicActivityInstance = historyService.createHistoricActivityInstanceQuery().activityId(tarActivityId).singleResult();
//
//        return historicActivityInstance.getTaskId();
		return "成功";
	}

动态新增节点

	@GetMapping("/addTask")
//	@ApiOperation("新增节点")
	public Object addTask(String taskId, String assignee) {
		return service.addTask(taskId,assignee);
	}
	
	@Resource
	ActGeBytearrayMapper actGeBytearrayMapper;

	@Override
	public Object addTask(String taskId, String assignee) {
		//        1、创建ProcessEngine
		ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
		final TaskService taskService = processEngine.getTaskService();
		final RepositoryService repositoryService = processEngine.getRepositoryService();
		Task userTask = taskService.createTaskQuery()
				.taskId(taskId)
//				.taskAssignee(assignee)
				.singleResult();

		final BpmnModel bpmnModel = repositoryService.getBpmnModel(userTask.getProcessDefinitionId());
		final Process process = bpmnModel.getMainProcess();
		process.removeFlowElement("flow4");//移除最终节点连线
		process.addFlowElement(createUserTask("add", "First task", "fred"));//新增节点
		process.addFlowElement(createSequenceFlow("usertask3", "add"));//新增节点 于原节点连线
		process.addFlowElement(createSequenceFlow("add", "endevent1"));//新增节点 于原节点连线
		//重新绘画图形
		new BpmnAutoLayout(bpmnModel).execute();
		BpmnXMLConverter converter = new BpmnXMLConverter();
//把bpmnModel对象转换成字符
		byte[] bytes = converter.convertToXML(bpmnModel);
		//清除缓存
		ProcessEngineConfigurationImpl configuration = (ProcessEngineConfigurationImpl) processEngine.getProcessEngineConfiguration();
		DeploymentManager deploymentManager = configuration.getDeploymentManager();
		deploymentManager.getProcessDefinitionCache().remove(userTask.getProcessDefinitionId());

//		String xmlContenxt = new String(bytes);
		List<ActGeBytearray> actGeBytearrayList = actGeBytearrayMapper.getActGeBytearrayList(userTask.getProcessDefinitionId());
		actGeBytearrayList = actGeBytearrayList.stream().filter(item -> item.getName().endsWith(".bpmn")).peek(item -> {
			item.setBytes(bytes);
		}).collect(Collectors.toList());
		if (ObjectUtils.isNotEmpty(actGeBytearrayList)) actGeBytearrayMapper.updateById(actGeBytearrayList.get(0));
		return null;
	}

	protected static UserTask createUserTask(String id, String name, String assignee) {
		UserTask userTask = new UserTask();
		userTask.setName(name);
		userTask.setId(id);
		userTask.setAssignee(assignee);
		return userTask;
	}

	protected static SequenceFlow createSequenceFlow(String from, String to) {
		SequenceFlow flow = new SequenceFlow();
		flow.setSourceRef(from);
		flow.setTargetRef(to);
		return flow;
	}

mapperxml

    <select id="getActGeBytearrayList" resultType="com.example.activitiydemo.entity.ActGeBytearray">
        select a.*
        from act_ge_bytearray a
        inner join act_re_procdef b ON a.DEPLOYMENT_ID_ = b.DEPLOYMENT_ID_
        where b.ID_ = #{processDefinitionId}
    </select>

查看实例流程图，根据流程实例ID获取流程图

@Resource
	FlowUtils flowUtils;


	/**
	 * 查看实例流程图，根据流程实例ID获取流程图
	 */
	@RequestMapping(value="traceprocess",method= RequestMethod.GET)
	public void traceprocess(HttpServletResponse response, @RequestParam("proInsId")String proInsId,@RequestParam("fileName") String fileName) throws Exception{
		InputStream in = flowUtils.getResourceDiagramInputStream(proInsId);
		File file = new File("C:\\Users\\wangshuai9776\\"+ fileName +".svg");
		OutputStream output = new FileOutputStream(file);
//		ServletOutputStream output = response.getOutputStream();
		IOUtils.copy(in, output);
	}

**FlowUtils**

@Component
public class FlowUtils {

	/**
	 * 获取历史节点流程图
	 *
	 * @param id
	 * @return
	 */
	public InputStream getResourceDiagramInputStream(String id) {
		try {
			//        1、创建ProcessEngine
			ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
			final HistoryService historyService = processEngine.getHistoryService();
			final RepositoryService repositoryService = processEngine.getRepositoryService();
			// 获取历史流程实例
			HistoricProcessInstance historicProcessInstance = historyService.createHistoricProcessInstanceQuery().processInstanceId(id).singleResult();
			// 获取流程中已经执行的节点，按照执行先后顺序排序
			List<HistoricActivityInstance> historicActivityInstanceList = historyService.createHistoricActivityInstanceQuery().processInstanceId(id).orderByHistoricActivityInstanceId().asc().list();
			// 构造已执行的节点ID集合
			List<String> executedActivityIdList = new ArrayList<String>();
			for (HistoricActivityInstance activityInstance : historicActivityInstanceList) {
				executedActivityIdList.add(activityInstance.getActivityId());
			}
			// 获取bpmnModel
			BpmnModel bpmnModel = repositoryService.getBpmnModel(historicProcessInstance.getProcessDefinitionId());
			// 获取流程已发生流转的线ID集合
			List<String> flowIds = this.getExecutedFlows(bpmnModel, historicActivityInstanceList);
			// 使用默认配置获得流程图表生成器，并生成追踪图片字符流
//			ProcessDiagramGenerator processDiagramGenerator = processEngine.getProcessEngineConfiguration().getProcessDiagramGenerator();
			//你也可以 new 一个
			DefaultProcessDiagramGenerator processDiagramGenerator = new DefaultProcessDiagramGenerator();
			InputStream imageStream = processDiagramGenerator.generateDiagram(bpmnModel, executedActivityIdList, flowIds, "宋体", "微软雅黑", "黑体", true, "demo");
			return imageStream;
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}

	private List<String> getExecutedFlows(BpmnModel bpmnModel,
	                                      List<HistoricActivityInstance> historicActivityInstanceList) {
		List<String> executedFlowIdList = new ArrayList<>();
		for (int i = 0; i < historicActivityInstanceList.size() - 1; i++) {
			HistoricActivityInstance hai = historicActivityInstanceList.get(i);
			FlowNode flowNode = (FlowNode) bpmnModel.getFlowElement(hai.getActivityId());
			List<SequenceFlow> sequenceFlows = flowNode.getOutgoingFlows();
			if (sequenceFlows.size() > 1) {
				HistoricActivityInstance nextHai = historicActivityInstanceList.get(i + 1);
				sequenceFlows.forEach(sequenceFlow -> {
					if (sequenceFlow.getTargetFlowElement().getId().equals(nextHai.getActivityId())) {
						executedFlowIdList.add(sequenceFlow.getId());
					}
				});
			} else if (sequenceFlows.size() == 1) {
				executedFlowIdList.add(sequenceFlows.get(0).getId());
			}
		}
		return executedFlowIdList;
	}
}

BPMN& PNG

diagram

<?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:activiti="http://activiti.org/bpmn" xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI" xmlns:omgdc="http://www.omg.org/spec/DD/20100524/DC" xmlns:omgdi="http://www.omg.org/spec/DD/20100524/DI" typeLanguage="http://www.w3.org/2001/XMLSchema" expressionLanguage="http://www.w3.org/1999/XPath" targetNamespace="http://www.activiti.org/test">
  <process id="helloworld" name="helloworldProcess" isExecutable="true">
    <startEvent id="startevent1" name="Start"></startEvent>
    <endEvent id="endevent1" name="End"></endEvent>
    <userTask id="applyTask" name="提交申请" activiti:assignee="张三"></userTask>
    <userTask id="usertask2" name="审批【部门经理】" activiti:assignee="李四"></userTask>
    <userTask id="usertask3" name="审批【总经理】" activiti:assignee="王五"></userTask>
    <sequenceFlow id="flow1" sourceRef="startevent1" targetRef="applyTask"></sequenceFlow>
    <sequenceFlow id="flow2" sourceRef="applyTask" targetRef="usertask2"></sequenceFlow>
    <sequenceFlow id="flow3" sourceRef="usertask2" targetRef="usertask3"></sequenceFlow>
    <sequenceFlow id="flow4" sourceRef="usertask3" targetRef="endevent1"></sequenceFlow>
  </process>
  <bpmndi:BPMNDiagram id="BPMNDiagram_helloworld">
    <bpmndi:BPMNPlane bpmnElement="helloworld" id="BPMNPlane_helloworld">
      <bpmndi:BPMNShape bpmnElement="startevent1" id="BPMNShape_startevent1">
        <omgdc:Bounds height="35.0" width="35.0" x="330.0" y="20.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="endevent1" id="BPMNShape_endevent1">
        <omgdc:Bounds height="35.0" width="35.0" x="330.0" y="380.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="applyTask" id="BPMNShape_applyTask">
        <omgdc:Bounds height="55.0" width="105.0" x="295.0" y="100.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="usertask2" id="BPMNShape_usertask2">
        <omgdc:Bounds height="55.0" width="105.0" x="295.0" y="200.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="usertask3" id="BPMNShape_usertask3">
        <omgdc:Bounds height="55.0" width="105.0" x="295.0" y="290.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNEdge bpmnElement="flow1" id="BPMNEdge_flow1">
        <omgdi:waypoint x="347.0" y="55.0"></omgdi:waypoint>
        <omgdi:waypoint x="347.0" y="100.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="flow2" id="BPMNEdge_flow2">
        <omgdi:waypoint x="347.0" y="155.0"></omgdi:waypoint>
        <omgdi:waypoint x="347.0" y="200.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="flow3" id="BPMNEdge_flow3">
        <omgdi:waypoint x="347.0" y="255.0"></omgdi:waypoint>
        <omgdi:waypoint x="347.0" y="290.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="flow4" id="BPMNEdge_flow4">
        <omgdi:waypoint x="347.0" y="345.0"></omgdi:waypoint>
        <omgdi:waypoint x="347.0" y="380.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
    </bpmndi:BPMNPlane>
  </bpmndi:BPMNDiagram>
</definitions>

test

<?xml version="1.0" encoding="UTF-8"?>
<bpmn:definitions xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:activiti="http://activiti.org/bpmn" xmlns:bpmn="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI" xmlns:dc="http://www.omg.org/spec/DD/20100524/DC" xmlns:di="http://www.omg.org/spec/DD/20100524/DI" id="Definitions_11qdn8c" targetNamespace="http://bpmn.io/schema/bpmn" exporter="bpmn-js (https://demo.bpmn.io)" exporterVersion="11.3.1">
  <bpmn:process id="test" name="testProcess" isExecutable="true">
    <bpmn:parallelGateway id="Gateway_1bdorji">
      <bpmn:incoming>Flow_0fdd1s5</bpmn:incoming>
      <bpmn:outgoing>Flow_112ta1r</bpmn:outgoing>
      <bpmn:outgoing>Flow_17fz0xe</bpmn:outgoing>
      <bpmn:outgoing>Flow_1krh17g</bpmn:outgoing>
    </bpmn:parallelGateway>
    <bpmn:userTask id="Task_032ht9n" name="会签1" activiti:assignee="李四1">
      <bpmn:incoming>Flow_112ta1r</bpmn:incoming>
      <bpmn:outgoing>Flow_0umiwqj</bpmn:outgoing>
    </bpmn:userTask>
    <bpmn:sequenceFlow id="Flow_112ta1r" sourceRef="Gateway_1bdorji" targetRef="Task_032ht9n" />
    <bpmn:userTask id="Task_1tl20uk" name="会签2" activiti:assignee="李四2">
      <bpmn:incoming>Flow_17fz0xe</bpmn:incoming>
      <bpmn:outgoing>Flow_1tconop</bpmn:outgoing>
    </bpmn:userTask>
    <bpmn:sequenceFlow id="Flow_17fz0xe" sourceRef="Gateway_1bdorji" targetRef="Task_1tl20uk" />
    <bpmn:userTask id="Task_0nha4ou" name="会签3" activiti:assignee="李四3">
      <bpmn:incoming>Flow_1krh17g</bpmn:incoming>
      <bpmn:outgoing>Flow_1bgxt99</bpmn:outgoing>
    </bpmn:userTask>
    <bpmn:sequenceFlow id="Flow_1krh17g" sourceRef="Gateway_1bdorji" targetRef="Task_0nha4ou" />
    <bpmn:parallelGateway id="Gateway_0lpn6xd">
      <bpmn:incoming>Flow_0umiwqj</bpmn:incoming>
      <bpmn:incoming>Flow_1tconop</bpmn:incoming>
      <bpmn:incoming>Flow_1bgxt99</bpmn:incoming>
      <bpmn:outgoing>Flow_1hav98t</bpmn:outgoing>
    </bpmn:parallelGateway>
    <bpmn:sequenceFlow id="Flow_0umiwqj" sourceRef="Task_032ht9n" targetRef="Gateway_0lpn6xd" />
    <bpmn:sequenceFlow id="Flow_1tconop" sourceRef="Task_1tl20uk" targetRef="Gateway_0lpn6xd" />
    <bpmn:sequenceFlow id="Flow_1bgxt99" sourceRef="Task_0nha4ou" targetRef="Gateway_0lpn6xd" />
    <bpmn:userTask id="Task_0ixmhzp" name="总经理" activiti:assignee="王五">
      <bpmn:incoming>Flow_1hav98t</bpmn:incoming>
      <bpmn:outgoing>Flow_0i9kc1u</bpmn:outgoing>
    </bpmn:userTask>
    <bpmn:sequenceFlow id="Flow_1hav98t" sourceRef="Gateway_0lpn6xd" targetRef="Task_0ixmhzp" />
    <bpmn:userTask id="Task_0wj3769" name="提交人" activiti:assignee="张三">
      <bpmn:incoming>Flow_1ggtxt8</bpmn:incoming>
      <bpmn:outgoing>Flow_0fdd1s5</bpmn:outgoing>
    </bpmn:userTask>
    <bpmn:sequenceFlow id="Flow_0fdd1s5" sourceRef="Task_0wj3769" targetRef="Gateway_1bdorji" />
    <bpmn:startEvent id="Event_0dr1q86">
      <bpmn:outgoing>Flow_1ggtxt8</bpmn:outgoing>
    </bpmn:startEvent>
    <bpmn:sequenceFlow id="Flow_1ggtxt8" sourceRef="Event_0dr1q86" targetRef="Task_0wj3769" />
    <bpmn:endEvent id="Event_027przs">
      <bpmn:incoming>Flow_0i9kc1u</bpmn:incoming>
    </bpmn:endEvent>
    <bpmn:sequenceFlow id="Flow_0i9kc1u" sourceRef="Task_0ixmhzp" targetRef="Event_027przs" />
  </bpmn:process>
  <bpmndi:BPMNDiagram id="BPMNDiagram_1">
    <bpmndi:BPMNPlane id="BPMNPlane_1" bpmnElement="Process_00frahi">
      <bpmndi:BPMNEdge id="Flow_0i9kc1u_di" bpmnElement="Flow_0i9kc1u">
        <di:waypoint x="1190" y="210" />
        <di:waypoint x="1312" y="210" />
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge id="Flow_1ggtxt8_di" bpmnElement="Flow_1ggtxt8">
        <di:waypoint x="188" y="210" />
        <di:waypoint x="300" y="210" />
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge id="Flow_0fdd1s5_di" bpmnElement="Flow_0fdd1s5">
        <di:waypoint x="400" y="210" />
        <di:waypoint x="545" y="210" />
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge id="Flow_1hav98t_di" bpmnElement="Flow_1hav98t">
        <di:waypoint x="975" y="210" />
        <di:waypoint x="1090" y="210" />
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge id="Flow_1bgxt99_di" bpmnElement="Flow_1bgxt99">
        <di:waypoint x="810" y="320" />
        <di:waypoint x="950" y="320" />
        <di:waypoint x="950" y="235" />
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge id="Flow_1tconop_di" bpmnElement="Flow_1tconop">
        <di:waypoint x="810" y="210" />
        <di:waypoint x="925" y="210" />
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge id="Flow_0umiwqj_di" bpmnElement="Flow_0umiwqj">
        <di:waypoint x="810" y="100" />
        <di:waypoint x="950" y="100" />
        <di:waypoint x="950" y="185" />
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge id="Flow_1krh17g_di" bpmnElement="Flow_1krh17g">
        <di:waypoint x="570" y="235" />
        <di:waypoint x="570" y="320" />
        <di:waypoint x="710" y="320" />
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge id="Flow_17fz0xe_di" bpmnElement="Flow_17fz0xe">
        <di:waypoint x="595" y="210" />
        <di:waypoint x="710" y="210" />
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge id="Flow_112ta1r_di" bpmnElement="Flow_112ta1r">
        <di:waypoint x="570" y="185" />
        <di:waypoint x="570" y="100" />
        <di:waypoint x="710" y="100" />
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNShape id="Gateway_1bdorji_di" bpmnElement="Gateway_1bdorji">
        <dc:Bounds x="545" y="185" width="50" height="50" />
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape id="Activity_032ht9n_di" bpmnElement="Task_032ht9n">
        <dc:Bounds x="710" y="60" width="100" height="80" />
        <bpmndi:BPMNLabel />
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape id="Activity_1tl20uk_di" bpmnElement="Task_1tl20uk">
        <dc:Bounds x="710" y="170" width="100" height="80" />
        <bpmndi:BPMNLabel />
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape id="Activity_0nha4ou_di" bpmnElement="Task_0nha4ou">
        <dc:Bounds x="710" y="280" width="100" height="80" />
        <bpmndi:BPMNLabel />
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape id="Gateway_0lpn6xd_di" bpmnElement="Gateway_0lpn6xd">
        <dc:Bounds x="925" y="185" width="50" height="50" />
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape id="Activity_0ixmhzp_di" bpmnElement="Task_0ixmhzp">
        <dc:Bounds x="1090" y="170" width="100" height="80" />
        <bpmndi:BPMNLabel />
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape id="Activity_0wj3769_di" bpmnElement="Task_0wj3769">
        <dc:Bounds x="300" y="170" width="100" height="80" />
        <bpmndi:BPMNLabel />
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape id="Event_0dr1q86_di" bpmnElement="Event_0dr1q86">
        <dc:Bounds x="152" y="192" width="36" height="36" />
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape id="Event_027przs_di" bpmnElement="Event_027przs">
        <dc:Bounds x="1312" y="192" width="36" height="36" />
      </bpmndi:BPMNShape>
    </bpmndi:BPMNPlane>
  </bpmndi:BPMNDiagram>
</bpmn:definitions>

雨夜星空丶月
关注
  • 2
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
activity动态加签任意节点
congge
07-04 8万+
前言 设想这么一种场景，一个流程有3级审批，其中第一级审批完毕后本应该到达二级审批的，但是可能觉得这个流程模板设置的不尽合理，需要再在上面增加一级审批人，即变成4级审批，这个需求该怎么做呢？ 按照我们初步的设想，解决办法大概有这么两种思路： 第一，修改流程模板 这是一种大家很容易想到的方法，即重新更新一下流程定义文件，更改审批节点的审批人，所谓直接修改模板。在模板中添加节点以及连线，并修改实例的走向。 第二，修改流程定义对应的缓存数据 即不修改模板，新增的节点与当前需要加签的实例挂钩，关于缓存数据，我们可以
eclipse activity 插件安装 Activiti Designer.docx
08-02
eclipse activity 插件安装 Activiti Designer能够更好的开发相关的软件
优雅的实现Activiti动态调整流程（自由跳转、前进、后退、分裂、前加签、后加签等），含范例代码！...
weixin_30865427的博客
12-29 6306
最近对Activiti做了一些深入的研究，对Activiti的流程机制有了些理解，对动态调整流程也有了一些实践方法。现在好好总结一下，一来是对这段时间自己辛苦探索的一个记录，二来也是为后来者指指路~~~如下内容准备采用QA的方式写，很多问题都是当初自己极疑惑的问题，希望能为大家解惑！Q：可以动态调整流程吗？A：可以！可以动态更改流程指向，或者创建新的节点，等等。。。Q: 更改流程还需要注意什么...
activiti新增自定义节点的几个步骤
最新发布
u012724101的博客
02-05 481
最近在搞一个工作流的程序，需要添加审批节点，不需要用户添加排他网关设置条件就能进行回退至上一节点或进入下一节点。
基于springboot+mybatis+ mvc + activitiy+quarts+quartz 写的一个办公企业OA系统
01-14
java毕设 1. # OA #### 项目介绍 基于springboot+mybatis+ mvc + activitiy+quarts+quartz 写的一个办公企业OA系统 #### 软件架构 springboot+mybatis+ mvc + activitiy+quarts+quartz #### 说明 ##### 功能： 用户模块 日志模块 考勤模块 工作流模块 请假 岗位 会议申请 菜单 。。。 定时任务月末统计考勤状况 等功能 前端页面出致于：若依管理系统（https://github.com/WuJunJie521/RuoYiu） ##### 在线体验 地址：<http://106.14.226.138:8880/OA/> 管理员 账号：admin 密码：admin 领导角色演示账号/密码：manager、123456 员工角色演示账号密码：employee /123456
最新Activiti视频教程，包含视频、源码、IDE集成Activiti插件、Activiti-5.22.0的pdm数据库表结构文件、教程菜单
08-17
在原有Activiti的教程资源上对零散的源码进行了集中整理，并增加了pdm、IDE集成Activiti插件等文件，附上部分菜单，整理不易，给分支持，后期继续分享其他资源 01 - 问候Activiti他大爷 1.Activiti简介 2.Activiti的HelloWorld实现 1.Activiti的25张表； 2.引入Activiti配置文件activiti.cfg.xml； 3.在Eclipse 上安装Activiti插件； 4.初识Activiti流程设计工具； 5.了解Activiti bpmn图表对应的 XML 文件 6.Activiti HelloWorld实现（代码层次） 7.Activiti HelloWorld实现（表数据发生的变化） 02 - Activiti流程定义 1.流程定义添加（部署） 1.Classpath加载方式； 2.Zip加载方式； 2.流程定义查询 1.查询流程定义； 2.查询某个流程定义的流程设计图片； 3.查询最新版本的流程定义集合； 3.流程定义删除 1.删除key相同的所有流程定义 4.流程定义的‘修改’ 03 - Activiti流程实例 1.构建学生请假审批流程 2.执行对象概念 3.判断流程实例状态 4.历史流程实例查询 5.历史活动查询 04 - Activiti流程变量 1.流程变量的概念 2.使用TaskService设置和获取流程变量 3.局部流程变量 4.使用RuntimeService设置和获取流程变量 5.启动流程的时候设置流程变量 6.完成任务的时候设置流程变量 05 - Activiti流程控制网关 1.连线 2.排它网关 3.并行网关 06 - Activiti任务分配 1.个人任务分配 2.多用户任务分配 3.内置用户组设计表以及IdentityService 4.组任务分配
Activity 工作流节点新增节点和获取节点属性修改底层文件
08-11
原创博客：https://blog.csdn.net/a704020443/article/details/107939512 里面有介绍
Activiti7笔记（八）activiti加签，转签，会签，任务监听器，添加查询审批意见
一天不写代码难受的博客
04-08 9012
目录1 加签功能2转签功能3 会签3.1 什么是会签3.2 会签实现流程4 任务监听器4.1 实现5 Activiti添加和查询审批意见 1 加签功能 我们已经定义好一个bump，并且已经将这个流程保存到数据库中，比如申请请假，有个人申请了请假，经理已经审批完成，总经理改审批了，本来应该是总经理审批完成，这个流程就走完了，这个就是我们在bump里面定义好的，但是这个时候，总经理想让董事长知道这个，想看看董事长的看法，所以需要将这个请假申请加签到董事长，这个董事长审批是不在这个bump里面的，这个要知道；
activiti学习（二十八）——加签
sadoshi的专栏
07-28 9626
设计思路 加签本质上就是让多实例任务增加一个处理任务和新增处理人。实现其实很简单，无非是增加一个task，另外内置变量里的nrOfInstances、nrOfActiveInstances各加一。 实现
多实例节点加签
weixin_42617164的博客
12-02 1257
activiti加签实现，activiti中命令模式，责任链模式的使用，activiti事务，日志拦截器。 springProcessEngineConfiguration，CommandExecutor，CommandInvoker
activity新增节点（包含多实例）
weixin_43830468的博客
05-06 3147
实现思路 1、从缓存里获取流程，这样修改流程，不会破坏原来的流程定义； 2、新增流程节点，不是在原来流程上，而是以新增节点为开始节点，重新构建一个流程。
简单的Fragment动态添加.zip
11-03
右侧图片中展示的就是一个典型的顶部标签栏，当点击标签栏上的标签时，下方会显示所对应的页面；当滑动下方页面时，标签栏上对应标签会显示出与其他标签不一样的效果。下面就以此为例分析顶部标签栏的基本实现思路及方法，虽然在实际开发中顶部标签栏的效果会有所不同，但实现上都是大同小异。 1.界面分析及实现 我们可以将整个页面分为2大部分，上面是顶部标签栏，下方是一个ViewPager。 上方的顶部标签栏可进一步分为2部分，上方文字部分需要能够点击发生变化，并且每次只能选中一个，因此可以用RadioButton、Button、TextView来实现；下方横线部分可以使用TextView实现。在这里我们采用RadioButton来实现标签栏文字部分，关键代码如下所示。
ActivitiDemo
07-08
簡單activiti demo 整全SPRING
openwebflow：基于Activiti的工作流引擎扩展，接管了Activiti对活动权限以及用户表的管理，并提供了催办，代办，加签（包括前加签后加签），自由迁移，划分分组等功能
02-03
什么是OpenWebFlow OpenWebFlow是基于Activiti（官方网站 ，代码托管在 ）扩展的工作流引擎，其扩展的功能包括： 完全接管了Activiti对活动（activity）权限的管理。Activiti允许在设计模型的时候指定每个活动的执行权限，但是，业务系统可能需要根据实际情况动态设置这些任务的执行权限（如：动态的组）。OpenWebFlow完全实现了与流程定义阶段的解压缩，即用户对活动的访问控制信息单独管理（而不是在流程定义中预先写死），这样有利于动态调整权限，详见； 完全接管了Activiti对用户表（IDENTITY_XXX表）的管理。在标准的工作流定义中，每个队列
七下Unit 4 After School Activitiy测试题及答案含听力精选.doc
09-26
七下Unit 4 After School Activitiy测试题及答案含听力精选.doc
七下Unit 4 After School Activitiy测试题及答案含听力2精选.doc
09-26
七下Unit 4 After School Activitiy测试题及答案含听力2精选.doc
ElasticSearch 集群搭建及相关原理解析
星空下的博客
07-10 1263
分布式系统的可用性与扩展性ES集群架构的优势：至关重要的作用 blogs对应的架构 对于生产环境中分片的设定，需要提前做好容量规划 集群 status Green: 主分片与副本都正常分配 Yellow: 主分片全部正常分配，有副本分片未能正常分配 Red: 有主分片未能分配。例如，当服务器的磁盘容量超过85%时,去创建了一个新的索引 CAT API查看集群信息： 搭建三节点ES集群 系统环境 操作系统: CentOS7，准备用户es elasticsearch：elasticsearch-7.17.
ElasticSearch 高级查询语法
星空下的博客
06-27 1228
ElasticSearch 高级查询语法Query DSL
activiti动态流程图
07-27
在Activiti中，可以通过使用ProcessInstanceDiagramCmd命令来生成动态流程图。这个命令是继承了Activiti的Command接口的，它可以获取当前任务流程图。具体的实现方法是通过传入流程实例ID，然后调用runtimeService、repositoryService、processEngine和historyService等服务来生成流程图。\[3\]这个方法返回的是一个InputStream，可以将其转换为图片或者直接展示在页面上。这样就可以实现在任何一条已启动的流程实例中查看流程状态，并以流程图片的形式展示出来。\[1\]这样的实现方式也受到了国内临远大师的影响，虽然完全可以使用纯Service方法来实现，但是采用命令模式可以更好地封装和管理流程图的生成过程。\[2\] #### 引用[.reference_title] - *1* *2* *3* [activiti动态生成流程图](https://blog.csdn.net/qq279071978/article/details/74332690)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值