首页手记工作流引擎实战入门教程

工作流引擎实战入门教程

标签：

容器运维运维工具

概述

本文将深入探讨工作流引擎的概念、应用场景以及如何进行安装配置。文章还将详细讲解流程定义的创建和管理，并通过具体案例展示工作流引擎在实际业务中的应用。

工作流引擎简介

工作流引擎是一种软件系统，用于自动化业务流程。它通过定义和执行一系列预定任务和步骤来实现业务流程的自动化，从而提高业务处理效率和准确性。工作流引擎支持流程建模、流程执行、流程监控和流程管理。流程建模允许用户定义流程的各个步骤、分支和条件，流程执行则根据定义的规则自动执行这些步骤，而流程监控和管理则允许用户跟踪流程的状态并进行必要的调整。

工作流引擎的基本概念

工作流引擎包括以下几个基本概念：

流程定义：定义了流程的结构和规则，包括流程的步骤、分支、条件等。
流程实例：具体执行的流程实例。每个流程实例都有一个唯一标识符。
任务：流程中的一个具体步骤，代表一个工作负载。
参与者：执行任务的用户或系统。
事件：触发或影响流程执行的外部因素，如时间、消息或条件。
流程变量：流程中的数据，用于存储和传递信息。

工作流引擎的应用场景

工作流引擎的应用场景广泛，以下是一些典型的应用场景：

企业流程自动化：可以用于自动化企业内部的各种流程，如审批流程、报销流程、采购流程等。
业务流程管理：帮助企业设计、执行和改进业务流程，提高业务效率和质量。
合规性管理：确保业务流程符合法规和标准的要求。
客户服务：通过定义和自动化客户服务流程，提高客户服务的质量和响应速度。
人力资源管理：可以用于员工入职、离职、调动等流程的自动化管理。

常见工作流引擎介绍

Activiti

Activiti 是一个轻量级的工作流引擎，基于 Apache License 2.0 开源。它支持 BPMN 2.0 标准，可以与各种主流应用服务器和数据库集成。Activiti 提供了强大的流程建模、执行和监控功能，支持 Java 和 Spring 框架。

安装与配置

安装 Activiti：

下载 Activiti 最新版本和相关依赖，解压后配置环境变量。

配置数据库：

Activiti 支持多种数据库，如 MySQL、Oracle、PostgreSQL 等。以下是 MySQL 的配置示例：

<bean id="processEngineConfiguration" class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
   <property name="jdbcDriver" value="com.mysql.jdbc.Driver"/>
   <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/activiti"/>
   <property name="jdbcUsername" value="root"/>
   <property name="jdbcPassword" value="password"/>
   <property name="databaseSchemaUpdate" value="true"/>
   <property name="jobExecutorActivate" value="true"/>
</bean>

Flowable

Flowable 是一个基于 BPMN 2.0 的工作流引擎，它继承了 Activiti 的优点，并进行了重大改进。Flowable 支持多种编程语言和框架，包括 Java、Spring、Drools 等。

安装与配置

安装 Flowable：

下载 Flowable 最新版本和相关依赖，解压后配置环境变量。

配置数据库：

Flowable 支持多种数据库，如 MySQL、Oracle、PostgreSQL 等。以下是 MySQL 的配置示例：

Configuration cfg = new Configuration();
cfg.setDatabaseSchemaUpdate("true");
cfg.setJdbcDriver("com.mysql.jdbc.Driver");
cfg.setJdbcUrl("jdbc:mysql://localhost:3306/flowable");
cfg.setJdbcUsername("root");
cfg.setJdbcPassword("password");
ProcessEngine engine = new ProcessEngineImpl(cfg);

Camunda

Camunda 是一个基于 BPMN 2.0 的工作流引擎，提供了一个完整的业务流程管理平台。它支持多种编程语言和框架，包括 Java、Spring、Drools 等。Camunda 提供了丰富的功能，如流程建模、执行、监控、权限管理等。

安装与配置

安装 Camunda：

下载 Camunda 最新版本和相关依赖，解压后配置环境变量。

配置数据库：

Camunda 支持多种数据库，如 MySQL、Oracle、PostgreSQL 等。以下是 MySQL 的配置示例：

ProcessEngine engine = new StandaloneProcessEngineConfiguration()
   .setJdbcUrl("jdbc:mysql://localhost:3306/camunda")
   .setJdbcUsername("root")
   .setJdbcPassword("password")
   .setDatabaseSchemaUpdate("true")
   .buildProcessEngine();

其他常用工作流引擎简介

JBPM：JBPM 是一个开源的业务流程管理套件，支持 BPMN 2.0 标准，提供流程建模、执行、监控等功能。JBPM 支持 Java、Spring 等多种编程语言和框架。
Kogito：Kogito 是 Red Hat 提供的一个业务流程和决策管理框架，支持 BPMN 2.0 标准，提供流程建模、执行、监控等功能。Kogito 支持 Java、Spring 等多种编程语言和框架。
Zeebe：Zeebe 是一个基于事件驱动的分布式工作流引擎，支持 BPMN 2.0 标准，提供流程建模、执行、监控等功能。Zeebe 支持多种编程语言和框架。

工作流引擎的安装与配置

选择合适的开发环境

选择合适的开发环境是使用工作流引擎的基础。通常，开发环境需要满足以下要求：

操作系统：Windows、Linux、macOS
编程语言：Java、Python、JavaScript 等
集成开发环境（IDE）：Eclipse、IntelliJ IDEA、PyCharm 等
数据库：MySQL、Oracle、PostgreSQL 等
版本控制系统：Git、SVN 等

安装和配置工作流引擎

以 Flowable 为例，介绍如何安装和配置工作流引擎。

安装依赖：

下载 Flowable 的依赖包，解压后添加到项目中。可以使用 Maven 或 Gradle 管理依赖，以下是 Maven 的示例：

<dependencies>
   <dependency>
       <groupId>org.flowable</groupId>
       <artifactId>flowable-engine</artifactId>
       <version>6.7.0</version>
   </dependency>
   <dependency>
       <groupId>org.flowable</groupId>
       <artifactId>flowable-spring-boot-starter</artifactId>
       <version>6.7.0</version>
   </dependency>
</dependencies>

配置数据库连接：

在 application.properties 文件中配置数据库连接信息：

spring.datasource.url=jdbc:mysql://localhost:3306/flowable
spring.datasource.username=root
spring.datasource.password=password
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.jpa.database-platform=org.hibernate.dialect.MySQL5InnoDBDialect
spring.jpa.hibernate.ddl-auto=update

配置数据库连接

以下是如何在 Spring Boot 项目中配置数据库连接的示例：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.flowable.spring.boot.EngineConfigurationConfigurer;

@SpringBootApplication
public class FlowableApplication {

    public static void main(String[] args) {
        SpringApplication.run(FlowableApplication.class, args);
    }

    @Bean
    public EngineConfigurationConfigurer engineConfigurationConfigurer() {
        return engineConfiguration -> {
            engineConfiguration.setDatabaseSchemaUpdate("true");
            engineConfiguration.setJdbcDriver("com.mysql.jdbc.Driver");
            engineConfiguration.setJdbcUrl("jdbc:mysql://localhost:3306/flowable");
            engineConfiguration.setJdbcUsername("root");
            engineConfiguration.setJdbcPassword("password");
        };
    }
}

创建和管理流程定义

使用工具创建流程定义文件

流程定义文件通常使用 BPMN 2.0 标准的 XML 文件格式。可以使用 BPMN 软件工具如 Eclipse BPMN Modeler、Camunda Modeler 等来创建流程定义文件。这些工具提供了图形化界面，方便用户设计流程图。

以下是一个简单的 BPMN 2.0 流程定义文件示例：

<?xml version="1.0" encoding="UTF-8"?>
<process id="approveLeaveRequest" name="Approve Leave Request" isExecutable="true">
    <startEvent id="startEvent" />
    <userTask id="approveRequest" name="Approve Request" />
    <sequenceFlow id="flow1" sourceRef="startEvent" targetRef="approveRequest" />
    <endEvent id="endEvent" />
    <sequenceFlow id="flow2" sourceRef="approveRequest" targetRef="endEvent" />
</process>

通过代码配置流程定义

除了使用 BPMN 工具创建流程定义文件，还可以通过代码动态配置流程定义。以下是一个使用 Activiti 配置流程定义的示例：

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngineConfiguration;
import org.activiti.engine.RepositoryService;
import org.activiti.engine.repository.Deployment;
import org.activiti.engine.repository.ProcessDefinition;

public class ProcessDefinitionCreator {

    public static void main(String[] args) {
        ProcessEngine processEngine = ProcessEngineConfiguration
            .createStandaloneInMemoryProcessEngineConfiguration()
            .buildProcessEngine();

        RepositoryService repositoryService = processEngine.getRepositoryService();

        String processDefinitionKey = "approveLeaveRequest";
        String processDefinitionResource = "approveLeaveRequest.bpmn20.xml";

        Deployment deployment = repositoryService.createDeployment()
            .addClasspathResource(processDefinitionResource)
            .deploy();

        ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery()
            .processDefinitionKey(processDefinitionKey)
            .singleResult();

        System.out.println("Process Definition ID: " + processDefinition.getId());
    }
}

测试流程定义的正确性

测试流程定义的正确性可以通过模拟流程执行来验证。以下是一个使用 Activiti 测试流程定义的示例：

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.TaskService;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;

public class ProcessDefinitionTest {

    public static void main(String[] args) {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

        TaskService taskService = processEngine.getTaskService();
        ProcessInstance processInstance = processEngine.getRuntimeService().startProcessInstanceByKey("approveLeaveRequest");

        Task task = taskService.createTaskQuery().singleResult();
        System.out.println("Task ID: " + task.getId());
        System.out.println("Task Name: " + task.getName());

        taskService.complete(task.getId());

        ProcessInstance finishedProcessInstance = processEngine.getRuntimeService().createProcessInstanceQuery().processInstanceId(processInstance.getId()).singleResult();
        assert finishedProcessInstance == null;
    }
}

工作流引擎的应用场景实例

案例一：请假申请流程

请假申请流程是一个典型的业务流程，包括员工提交请假申请、经理审批、HR 审核等步骤。

假设流程步骤

员工提交请假申请
经理审批
HR 审核
请假结束

假设流程图

<process id="leaveRequest" name="Leave Request Process">
    <startEvent id="startEvent" />
    <userTask id="submitLeaveRequest" name="Submit Leave Request" />
    <userTask id="approveLeaveRequest" name="Approve Leave Request" />
    <userTask id="reviewLeaveRequest" name="Review Leave Request" />
    <sequenceFlow id="flow1" sourceRef="startEvent" targetRef="submitLeaveRequest" />
    <sequenceFlow id="flow2" sourceRef="submitLeaveRequest" targetRef="approveLeaveRequest" />
    <sequenceFlow id="flow3" sourceRef="approveLeaveRequest" targetRef="reviewLeaveRequest" />
    <endEvent id="endEvent" />
    <sequenceFlow id="flow4" sourceRef="reviewLeaveRequest" targetRef="endEvent" />
</process>

流程实现代码

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.RepositoryService;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;

public class LeaveRequestProcess {

    public static void main(String[] args) {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RepositoryService repositoryService = processEngine.getRepositoryService();
        RuntimeService runtimeService = processEngine.getRuntimeService();
        TaskService taskService = processEngine.getTaskService();

        // Start process instance
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("leaveRequest");

        // Complete submitLeaveRequest task
        Task submitLeaveRequestTask = taskService.createTaskQuery().taskDefinitionKey("submitLeaveRequest").singleResult();
        taskService.complete(submitLeaveRequestTask.getId());

        // Complete approveLeaveRequest task
        Task approveLeaveRequestTask = taskService.createTaskQuery().taskDefinitionKey("approveLeaveRequest").singleResult();
        taskService.complete(approveLeaveRequestTask.getId());

        // Complete reviewLeaveRequest task
        Task reviewLeaveRequestTask = taskService.createTaskQuery().taskDefinitionKey("reviewLeaveRequest").singleResult();
        taskService.complete(reviewLeaveRequestTask.getId());

        System.out.println("Leave Request Process Completed");
    }
}

案例二：报销流程

报销流程包括员工提交报销申请、部门经理审批、财务审核等步骤。

假设流程步骤

员工提交报销申请
部门经理审批
财务审核
报销结束

假设流程图

<process id="reimbursementRequest" name="Reimbursement Request Process">
    <startEvent id="startEvent" />
    <userTask id="submitReimbursementRequest" name="Submit Reimbursement Request" />
    <userTask id="approveReimbursementRequest" name="Approve Reimbursement Request" />
    <userTask id="reviewReimbursementRequest" name="Review Reimbursement Request" />
    <sequenceFlow id="flow1" sourceRef="startEvent" targetRef="submitReimbursementRequest" />
    <sequenceFlow id="flow2" sourceRef="submitReimbursementRequest" targetRef="approveReimbursementRequest" />
    <sequenceFlow id="flow3" sourceRef="approveReimbursementRequest" targetRef="reviewReimbursementRequest" />
    <endEvent id="endEvent" />
    <sequenceFlow id="flow4" sourceRef="reviewReimbursementRequest" targetRef="endEvent" />
</process>

流程实现代码

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.RepositoryService;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;

public class ReimbursementRequestProcess {

    public static void main(String[] args) {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RepositoryService repositoryService = processEngine.getRepositoryService();
        RuntimeService runtimeService = processEngine.getRuntimeService();
        TaskService taskService = processEngine.getTaskService();

        // Start process instance
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("reimbursementRequest");

        // Complete submitReimbursementRequest task
        Task submitReimbursementRequestTask = taskService.createTaskQuery().taskDefinitionKey("submitReimbursementRequest").singleResult();
        taskService.complete(submitReimbursementRequestTask.getId());

        // Complete approveReimbursementRequest task
        Task approveReimbursementRequestTask = taskService.createTaskQuery().taskDefinitionKey("approveReimbursementRequest").singleResult();
        taskService.complete(approveReimbursementRequestTask.getId());

        // Complete reviewReimbursementRequest task
        Task reviewReimbursementRequestTask = taskService.createTaskQuery().taskDefinitionKey("reviewReimbursementRequest").singleResult();
        taskService.complete(reviewReimbursementRequestTask.getId());

        System.out.println("Reimbursement Request Process Completed");
    }
}

案例三：员工入职流程

员工入职流程包括员工提交入职申请、HR 审核、部门经理审批、财务审核、员工培训等步骤。

假设流程步骤

员工提交入职申请
HR 审核
部门经理审批
财务审核
员工培训
员工入职结束

假设流程图

<process id="employeeOnboarding" name="Employee Onboarding Process">
    <startEvent id="startEvent" />
    <userTask id="submitOnboardingRequest" name="Submit Onboarding Request" />
    <userTask id="reviewOnboardingRequest" name="Review Onboarding Request" />
    <userTask id="approveOnboardingRequest" name="Approve Onboarding Request" />
    <userTask id="financialReview" name="Financial Review" />
    <userTask id="employeeTraining" name="Employee Training" />
    <sequenceFlow id="flow1" sourceRef="startEvent" targetRef="submitOnboardingRequest" />
    <sequenceFlow id="flow2" sourceRef="submitOnboardingRequest" targetRef="reviewOnboardingRequest" />
    <sequenceFlow id="flow3" sourceRef="reviewOnboardingRequest" targetRef="approveOnboardingRequest" />
    <sequenceFlow id="flow4" sourceRef="approveOnboardingRequest" targetRef="financialReview" />
    <sequenceFlow id="flow5" sourceRef="financialReview" targetRef="employeeTraining" />
    <endEvent id="endEvent" />
    <sequenceFlow id="flow6" sourceRef="employeeTraining" targetRef="endEvent" />
</process>

流程实现代码

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.RepositoryService;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;

public class EmployeeOnboardingProcess {

    public static void main(String[] args) {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RepositoryService repositoryService = processEngine.getRepositoryService();
        RuntimeService runtimeService = processEngine.getRuntimeService();
        TaskService taskService = processEngine.getTaskService();

        // Start process instance
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("employeeOnboarding");

        // Complete submitOnboardingRequest task
        Task submitOnboardingRequestTask = taskService.createTaskQuery().taskDefinitionKey("submitOnboardingRequest").singleResult();
        taskService.complete(submitOnboardingRequestTask.getId());

        // Complete reviewOnboardingRequest task
        Task reviewOnboardingRequestTask = taskService.createTaskQuery().taskDefinitionKey("reviewOnboardingRequest").singleResult();
        taskService.complete(reviewOnboardingRequestTask.getId());

        // Complete approveOnboardingRequest task
        Task approveOnboardingRequestTask = taskService.createTaskQuery().taskDefinitionKey("approveOnboardingRequest").singleResult();
        taskService.complete(approveOnboardingRequestTask.getId());

        // Complete financialReview task
        Task financialReviewTask = taskService.createTaskQuery().taskDefinitionKey("financialReview").singleResult();
        taskService.complete(financialReviewTask.getId());

        // Complete employeeTraining task
        Task employeeTrainingTask = taskService.createTaskQuery().taskDefinitionKey("employeeTraining").singleResult();
        taskService.complete(employeeTrainingTask.getId());

        System.out.println("Employee Onboarding Process Completed");
    }
}

常见问题及调试技巧

常见错误及解决方案

在使用工作流引擎时，可能会遇到一些常见的错误。以下是一些常见错误及其解决方案：

数据库连接错误：

问题：无法连接数据库。
解决方案：检查数据库连接配置是否正确，确保数据库服务已启动，并且数据库驱动已添加到项目中。

示例代码：

Configuration cfg = new Configuration();
cfg.setDatabaseSchemaUpdate("true");
cfg.setJdbcDriver("com.mysql.jdbc.Driver");
cfg.setJdbcUrl("jdbc:mysql://localhost:3306/flowable");
cfg.setJdbcUsername("root");
cfg.setJdbcPassword("password");

流程定义错误：

问题：流程定义文件不正确，导致流程无法启动。
解决方案：检查 BPMN 文件的格式是否正确，确保所有元素定义无误。

示例代码：

<process id="approveLeaveRequest" name="Approve Leave Request" isExecutable="true">
 <startEvent id="startEvent" />
 <userTask id="approveRequest" name="Approve Request" />
 <sequenceFlow id="flow1" sourceRef="startEvent" targetRef="approveRequest" />
 <endEvent id="endEvent" />
 <sequenceFlow id="flow2" sourceRef="approveRequest" targetRef="endEvent" />
</process>

流程执行错误：
- 问题：流程执行过程中出现错误。
- 解决方案：检查流程定义中的任务和分支逻辑，确保所有任务和分支的执行条件都正确。
- 示例代码：
```
Task approveLeaveRequestTask = taskService.createTaskQuery().taskDefinitionKey("approveLeaveRequest").singleResult();
taskService.complete(approveLeaveRequestTask.getId());
```

调试技巧

调试工作流引擎时，可以使用以下技巧：

日志输出：启用日志输出，以便查看流程执行的详细信息。可以配置日志级别为 DEBUG 或 TRACE 来获取更多详细信息。

示例代码：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class DebugLogger {
 private static final Logger LOGGER = LoggerFactory.getLogger(DebugLogger.class);

 public static void main(String[] args) {
     LOGGER.debug("Debug message");
     LOGGER.info("Info message");
     LOGGER.warn("Warning message");
     LOGGER.error("Error message");
 }
}

流程监控：使用工作流引擎提供的监控工具实时查看流程的状态和执行情况。

示例代码：

import org.activiti.engine.ProcessEngines;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;

public class ProcessMonitor {
 public static void main(String[] args) {
     ProcessEngines.getDefaultProcessEngine();
     RuntimeService runtimeService = ProcessEngines.getDefaultProcessEngine().getRuntimeService();
     TaskService taskService = ProcessEngines.getDefaultProcessEngine().getTaskService();
     ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processInstanceId("processInstanceId").singleResult();
     Task task = taskService.createTaskQuery().taskAssignee("user").singleResult();
     System.out.println("Process Instance ID: " + processInstance.getId());
     System.out.println("Task ID: " + task.getId());
 }
}

调试工具：使用调试工具（如 Eclipse、IntelliJ IDEA）逐行执行代码，找出错误的源头。

示例代码：

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.TaskService;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;

public class DebugFlow {
 public static void main(String[] args) {
     ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
     TaskService taskService = processEngine.getTaskService();
     ProcessInstance processInstance = processEngine.getRuntimeService().startProcessInstanceByKey("leaveRequest");
     Task task = taskService.createTaskQuery().singleResult();
     System.out.println("Task ID: " + task.getId());
     // 断点调试
     taskService.complete(task.getId());
 }
}

性能优化建议

为了提高工作流引擎的性能，可以采取以下措施：

优化数据库查询：
- 问题：频繁的数据库查询导致性能下降。
- 解决方案：优化数据库查询语句，减少不必要的数据访问。使用索引提高查询速度。
- 示例代码：
```
Task task = taskService.createTaskQuery().taskAssignee("user").orderByTaskCreateTime().asc().listPage(0, 10);
```

缓存机制：

问题：频繁的流程状态查询导致性能下降。
解决方案：使用缓存机制缓存常用的流程状态信息，减少数据库访问。

示例代码：

import org.springframework.cache.annotation.Cacheable;

public class ProcessService {
 @Cacheable(value = "processCache", key = "#processInstanceId")
 public ProcessInstance getProcessInstance(String processInstanceId) {
     return runtimeService.createProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();
 }
}

并行处理：

问题：流程处理时间长，影响系统性能。
解决方案：将流程处理任务分解为多个并行任务，提高处理速度。

示例代码：

import org.activiti.engine.delegate.DelegateTask;
import org.activiti.engine.delegate.TaskListener;

public class ParallelTaskListener implements TaskListener {
 @Override
 public void notify(DelegateTask delegateTask) {
     // 并行处理任务
     System.out.println("Parallel processing task");
 }
}

通过以上措施，可以有效地提高工作流引擎的性能，确保系统的高效运行。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

喵喔喔

手记
篇

粉丝

103

获赞与收藏

606

关注作者，订阅最新文章

阅读免费教程

Java并发工具

23个小节 19367 315

HTTP 入门教程

28个小节 37989 651

后端通用面试教程

41个小节 31204 346

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空

工作流引擎实战入门教程

安装与配置

安装与配置

安装与配置

假设流程步骤

假设流程图

流程实现代码

假设流程步骤

假设流程图

流程实现代码

假设流程步骤

假设流程图

流程实现代码

阅读免费教程