Activiti 工作流简介

已于 2023-03-24 11:33:52 修改
阅读量6.8k 收藏 30
点赞数 5
文章标签： intellij-idea java ide
于 2023-03-16 21:59:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33371766/article/details/129600250
版权

1、什么是工作流

        工作流(Workflow)，就是通过计算机对业务流程自动化执行管理。它主要解决的是“使在多个参与者之间按照某种预定义的规则自动进行传递文档、信息或任务的过程，从而实现某个预期的业务目标，或者促使此目标的实现”。

1.2、工作流系统

        一个软件系统中具有工作流的功能，我们把它称为工作流系统，一个系统中工作流的功能是什么？就是对系统的业务流程进行自动化管理，所以工作流是建立在业务流程的基础上，所以一个软件的系统核心根本上还是系统的业务流程，工作流只是协助进行业务流程管理。即使没有工作流业务系统也可以开发运行，只不过有了工作流可以更好的管理业务流程，提高系统的可扩展性。

1.3、Activiti概述

        Activiti是一个工作流引擎， activiti可以将业务系统中复杂的业务流程抽取出来，使用专门的建模语言BPMN2.0进行定义，业务流程按照预先定义的流程进行执行，实现了系统的流程由activiti进行管理，减少业务系统由于流程变更进行系统升级改造的工作量，从而提高系统的健壮性，同时也减少了系统开发维护成本。

1.4、BPM

        BPM即业务流程管理，是一种规范化的构造端到端的业务流程，以持续的提高组织业务效率。 idea插件安装：https://plugins.jetbrains.com/plugin/7429-actibpm/versions 将下载的jar包插件直接整到idea当中，在settings当中的插件当中，导入本地插件，导入插件之后重启idea即可。


2、Activiti工作流环境搭建

引入相关依赖：（主要MySQL的版本和自己本地需要一致）

<properties>
    <slf4j.version>1.6.6</slf4j.version>
    <log4j.version>1.2.12</log4j.version>
    <activiti.version>7.0.0.Beta1</activiti.version>
</properties>
<dependencies>
    <dependency>
        <groupId>org.activiti</groupId>
        <artifactId>activiti-engine</artifactId>
        <version>${activiti.version}</version>
    </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>
    <!-- activiti 云支持 -->
    <dependency>
        <groupId>org.activiti.cloud</groupId>
        <artifactId>activiti-cloud-services-api</artifactId>
        <version>${activiti.version}</version>
    </dependency>
    <!-- mysql驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.23</version>
    </dependency>
    <!-- mybatis -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.4.5</version>
    </dependency>
    <!-- 链接池 -->
    <dependency>
        <groupId>commons-dbcp</groupId>
        <artifactId>commons-dbcp</artifactId>
        <version>1.4</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
    <!-- log start -->
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>${log4j.version}</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>${slf4j.version}</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>${slf4j.version}</version>
    </dependency>
</dependencies>
 

 使用log4j日志，直接在resources下创建log4j.properties：日志文件路径根据实际路径修改

# Set root category priority to INFO and its only appender to CONSOLE.
#log4j.rootCategory=INFO, CONSOLE debug info warn error fatal
log4j.rootCategory=debug, CONSOLE, LOGFILE
# Set the enterprise logger category to FATAL and its only appender to CONSOLE.
log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE
# CONSOLE is set to be a ConsoleAppender using a PatternLayout.
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{ISO8601} %-6r[%15.15t] %-5p %30.30c %x - %m\n
# LOGFILE is set to be a File appender using a PatternLayout.
log4j.appender.LOGFILE=org.apache.log4j.FileAppender
log4j.appender.LOGFILE.File=E:\\workFile\\log4jLog\\activiti.log
log4j.appender.LOGFILE.Append=true
log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
log4j.appender.LOGFILE.layout.ConversionPattern=%d{ISO8601} %-6r[%15.15t] %-5p %30.30c %x - %m\n

添加activiti配置文件，使用activiti提供的默认方式来创建mysql的表。默认方式是在 resources 下创建 activiti.cfg.xml 文件，注意：默认方式目录和文件名不能修改，因为activiti的源码中已经设置，到固定的目录读取固定文件名的文件。默认要在在activiti.cfg.xml中bean的名字叫processEngineConfiguration，名字不可修改，在这里直接连接到本地数据库activiti这个库。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                    http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/contex
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
    <!-- 默认id对应的值 为processEngineConfiguration -->
    <!-- processEngine Activiti的流程引擎 -->
<!--    <bean id="processEngineConfiguration"-->
<!--          class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">-->
<!--        <property name="jdbcDriver" value="com.mysql.cj.jdbc.Driver"/>-->
<!--        <property name="jdbcUrl" value="jdbc:mysql:///activiti?autoReconnect=true"/>-->
<!--        <property name="jdbcUsername" value="root"/>-->
<!--        <property name="jdbcPassword" value="123456"/>-->
<!--        <property name="databaseSchemaUpdate" value="true"/>-->
<!--    </bean>-->

    <!-- 这里可以使用 链接池 dbcp-->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver" />
        <property name="url" value="jdbc:mysql:///activiti?autoReconnect=true" />
        <property name="username" value="root" />
        <property name="password" value="123456" />
        <property name="maxActive" value="3" />
        <property name="maxIdle" value="1" />
    </bean>

    <bean id="processEngineConfiguration"
          class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
        <!-- 引用数据源 上面已经设置好了-->
        <property name="dataSource" ref="dataSource" />
        <!-- activiti数据库表处理策略 -->
        <property name="databaseSchemaUpdate" value="true"/>
    </bean>

</beans>

 创建一个测试类，调用activiti的工具类，生成acitivti需要的数据库表。直接使用activiti提供的工具类ProcessEngines，会默认读取classpath下的activiti.cfg.xml文件，读取其中的数据库配置，创建 ProcessEngine，在创建ProcessEngine 时会自动创建表。代码执行完成之后在数据库当中进行查看对应的表是否都创建出来了。
 

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngineConfiguration;
import org.activiti.engine.ProcessEngines;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class SpringbootHelloApplicationTests {

    @Test
    void contextLoads() {
        //使用classpath下的activiti.cfg.xml中的配置创建processEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        System.out.println(processEngine);
        // 而除了使用默认配置进行创建工作流引擎对象，还可以通过自定义的方式进行创建。
        // 自定义配置文件名
        ProcessEngineConfiguration processEngineConfigurationFromResource = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cfg.xml");
        System.out.println(processEngineConfigurationFromResource);
        // 自定义配置文件名 bean对象id
        ProcessEngineConfiguration processEngineConfigurationFromResource1 = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cfg.xml", "processEngineConfiguration");
        System.out.println(processEngineConfigurationFromResource1);
    }

}

执行完数据库生成25张表。

 3、Activiti 类、配置文件之间的关系


3.1、activiti.cfg.xml
        activiti的引擎配置文件，包括：ProcessEngineConfiguration的定义、数据源定义、事务管理器等，此文件其实就是一个spring配置文件。

3.2、流程引擎配置类
        流程引擎的配置类（ProcessEngineConfiguration），通过ProcessEngineConfiguration可以创建工作流引擎ProceccEngine，常用的两种方法如下：

        3.2.1、StandaloneProcessEngineConfiguration
使用StandaloneProcessEngineConfigurationActiviti可以单独运行，来创建ProcessEngine，Activiti会自己处理事务。配置文件方式：通常在activiti.cfg.xml配置文件中定义一个id为 processEngineConfiguration 的bean，见环境搭建模块，就是使用这种方式进行配置的。

        3.2.2、SpringProcessEngineConfiguration
通过org.activiti.spring.SpringProcessEngineConfiguration 与Spring整合。

3.3、Servcie服务接口
        Service是工作流引擎提供用于进行工作流部署、执行、管理的服务接口，我们使用这些接口可以就是操作服务对应的数据表，并且在这里通过processEngine对象get对应的service就可以获取到service对象了。

 4、流程的创建与操作

4.1 流程图的绘制，安装bpmn插件

 将文件后缀bpmn改为xml，打开文件如下

 4.2.1 单个文件部署方式

将上面的流程部署到activiti的数据库中，就是流程定义部署。

/**
     * 单个文件部署流程
     */
    @Test
    public void develop() {
        // 创建流程对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        // 获取service对象
        RepositoryService repositoryService = processEngine.getRepositoryService();
        // 流程部署 设置名字 将bpmn和png部署进去
        Deployment deploy = repositoryService.createDeployment()
                .addClasspathResource("bpmn/hello.bpmn")
                .addClasspathResource("bpmn/hello.png")
                .name("请假流程")
                .deploy();
        System.out.println("id = " + deploy.getId());
        System.out.println("name = " + deploy.getName());
    }

之后直接启动这个测试方法进行流程部署，可以观察日志，整个部署的过程当中总共操作了三张表

  1. act_re_deployment 流程定义部署表，每部署一次增加一条记录
  2. act_re_procdef 流程定义表，部署每个新的流程定义都会在这张表中增加一条记录
  3. act_ge_bytearray 流程资源表

        act_re_deployment 和 act_re_procdef一对多关系，一次部署在流程部署表生成一条记录，但一次部署可以部署多个流程定义，每个流程定义在流程定义表生成一条记录。每一个流程定义在act_ge_bytearray会存在两个资源记录，bpmn和png。

4.2.2 使用压缩包的方式

/**
     * 压缩包的方式部署
     */
    @Test
    public void devoZip(){
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RepositoryService repositoryService = processEngine.getRepositoryService();
        InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream("bpmn/hello.zip");
        ZipInputStream zipInputStream = new ZipInputStream(inputStream);
        Deployment deploy = repositoryService.createDeployment().addZipInputStream(zipInputStream).deploy();
        System.out.println("id = " + deploy.getId());
        System.out.println("name = " + deploy.getName());
    }

4.3 开始流程

        启动一个流程表示发起一个新的请假申请，这就相当于java类与java对象的关系，类定义好后需要new创建一个对象使用，当然可以new多个对象。对于请出差申请流程，发起一个请假申请单需要启动一个流程实例，请假申请单发起请假也需要启动一个流程实例。

流程实例的key查看数据库

/**
     * 开始流程
     */
    @Test
    public void start(){
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RuntimeService runtimeService = processEngine.getRuntimeService();
        // 根据流程id启动流程 act_re_procdef表里的key
        ProcessInstance instance = runtimeService.startProcessInstanceByKey("myProcess_1");
        System.out.println("流程id = " + instance.getProcessDefinitionId());
        System.out.println("实例id = " + instance.getId());
        System.out.println("活动id = " + instance.getActivityId());
    }

 流程开始成功。

4.4 任务查询

        流程启动后，任务的负责人就可以查询自己当前需要处理的任务，查询出来的任务都是该用户的待办任务。

/**
     * 查找任务
     */
    @Test
    public void findTask(){
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();

        // act_ru_task表里的assignee字段就是处理人 可以手动设置
        List<Task> list = taskService.createTaskQuery().processDefinitionKey("myProcess_1").taskAssignee("cxb").list();
        for (Task task : list){
            System.out.println("流程id = " + task.getProcessInstanceId());
            System.out.println("任务id = " + task.getId());
            System.out.println("任务负责人 = " + task.getAssignee());
            System.out.println("任务名称 = " + task.getName());
        }
    }

而对应的查询语句也是：根据流程的Key以及负责人去task当中查询任务。

SELECT DISTINCT RES.* FROM ACT_RU_TASK RES INNER JOIN ACT_RE_PROCDEF D ON RES.PROC_DEF_ID_ = D.ID_ 
WHERE RES.ASSIGNEE_ = 'yueyue' AND D.KEY_ = 'myLeave' ORDER BY RES.ID_ ASC LIMIT 2147483647 OFFSET 0

这里设置处理人。

 

 4.5 任务推动

        在前面我们可以获取到负责人所有的任务，并且可以获取到相对应的任务id，这里只需要获取id进行推动流程即可。

/**
     * 任务推动
     */
    @Test
    public void next(){
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();

        taskService.complete("5005");
        // 获取单个流程数据进行操作，替换掉上面的2505
        // Task task = taskService.createTaskQuery().processDefinitionKey("myProcess_1").taskAssignee("zhangsan").singleResult();
        // taskService.complete(task.getId());
        System.out.println("任务完成");
    }

         任务推动之后还是和查询任务一致的查询语句获取当前负责人的数据，也可以直接查看 act_ru_task这张表的流程数据推动了没，而之前的流程会保存在 act_hi_taskinst 这张表当中。而这里对后续的几个流程的推动也是相同的道理，就不继续进行流程推动了，当最后一步的流程走完之后，整个流程已经结束，在act_ru_task这张表就不会存在当前这个流程的数据了。


4.6 流程定义信息查询

        查询流程相关信息，包含流程定义，流程部署，流程定义版本

/**
     * 流程定义信息查询
     */
    @Test
    public void processInfo() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RepositoryService repositoryService = processEngine.getRepositoryService();
        ProcessDefinitionQuery processDefinitionQuery = repositoryService.createProcessDefinitionQuery();
        List<ProcessDefinition> list = processDefinitionQuery.processDefinitionKey("myProcess_1").orderByProcessDefinitionVersion().desc().list();
        for (ProcessDefinition definition : list) {
            System.out.println("id = " + definition.getId());
            System.out.println("name = " + definition.getName());
            System.out.println("key = " + definition.getKey());
            System.out.println("version = " + definition.getVersion());
        }
    }

 4.7 流程删除

/**
     * 删除流程
     */
    @Test
    public void deleteProcess() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RepositoryService repositoryService = processEngine.getRepositoryService();
//        repositoryService.deleteDeployment("1");
        // 如果该流程定义下存在已经运行的流程，使用普通删除报错，可用级联删除方法将流程及相关记录全部删除。
        // 先删除没有完成流程节点，最后就可以完全删除流程定义信息
         repositoryService.deleteDeployment("1", true);
    }

 4.8 下载资源文件

        首先可以知道资源文件存在 act_ge_bytearray 这张表当中，而对于流程的数据bpmn和png文件的DEPLOYMENT_ID这个字段是相同的，因此只需要获取到这个id就能得到相对应的数据，这个id如何获取呢？在前面4.6获取流程信息当中就可以获取到这个id，因此把之前获取全部改为获取单个，就能拿到这个id了。而后续根据repositoryService来进行获取需要两个参数，一个就是这个id，另外一个就是文件的路径，文件的路径可以在 act_re_procdef 当中进行获取。
 

/**
     * 下载资源文件
     * @throws IOException
     */
    @Test
    public void getBolb() throws IOException {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RepositoryService repositoryService = processEngine.getRepositoryService();
        ProcessDefinitionQuery processDefinitionQuery = repositoryService.createProcessDefinitionQuery();
        ProcessDefinition definition = processDefinitionQuery.processDefinitionKey("myProcess_1").orderByProcessDefinitionVersion().desc().singleResult();

        // 获取流程id 文件名
        String deploymentId = definition.getDeploymentId();
        String diagramResourceName = definition.getDiagramResourceName();
        String resourceName = definition.getResourceName();

        // 得到input流
        InputStream pngInput = repositoryService.getResourceAsStream(deploymentId, diagramResourceName);
        InputStream bpmnInput = repositoryService.getResourceAsStream(deploymentId, resourceName);

        File pngFile = new File("d:/leave.png");
        File bpmnFile = new File("d:/leave.bpmn");

        FileOutputStream pngOutputStream = new FileOutputStream(pngFile);
        FileOutputStream bpmnOutputStream = new FileOutputStream(bpmnFile);

        // 输入输出转换
        IOUtils.copy(pngInput, pngOutputStream);
        IOUtils.copy(bpmnInput, bpmnOutputStream);

        pngInput.close();
        pngOutputStream.close();
        bpmnInput.close();
        bpmnOutputStream.close();
    }

并且这里使用到的IOUtils工具类是apache提供的，需要引入新的依赖

<dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.6</version>
        </dependency>

4.9 流程历史信息查看

        即使流程定义已经删除了，流程执行的历史信息通过前面的分析，依然保存在activiti的act_hi_*相关的表中。所以我们还是可以查询流程执行的历史信息，可以通过HistoryService来查看相关的历史记录。

/**
     * 查看流程历史信息
     */
    @Test
    public void findHistory() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        HistoryService historyService = processEngine.getHistoryService();
        // 设置查询条件进行查询
        List<HistoricActivityInstance> list = historyService.createHistoricActivityInstanceQuery()
                .orderByHistoricActivityInstanceStartTime().asc()
                .processInstanceId("12501").list();
        for (HistoricActivityInstance historiy : list) {
            System.out.println("activiti id = " + historiy.getActivityId());
            System.out.println("activiti name = " + historiy.getActivityName());
            System.out.println("process definition id = " + historiy.getProcessDefinitionId());
            System.out.println("process instance id = " + historiy.getProcessInstanceId());
            System.out.println("start time = " + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(historiy.getStartTime()));
            System.out.println("===============================================");
        }
    }

4.10、给流程实例添加Businesskey（业务标识）

        启动流程实例时，指定的businesskey，就会在act_ru_execution #流程实例的执行表中存储businesskey。
Businesskey：业务标识，通常为业务表的主键，业务标识和流程实例一一对应。业务标识来源于业务系统。存储业务标识就是根据业务标识来关联查询业务系统的数据。

/**
     * 增加业务标识
     */
    @Test
    public void addLeaveKey() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RuntimeService runtimeService = processEngine.getRuntimeService();
        ProcessInstance myLevel = runtimeService.startProcessInstanceByKey("myProcess_1", "1001");
        System.out.println(myLevel.getBusinessKey());
    }

4.11 流程的挂起与激活

4.11.1、全部流程实例挂起

        操作流程定义为挂起状态，该流程定义下边所有的流程实例全部暂停：流程定义为挂起状态该流程定义将不允许启动新的流程实例，同时该流程定义下所有的流程实例将全部挂起暂停执行。

/**
     * 全部流程实例挂起
     */
    @Test
    public void suspendAll() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RepositoryService repositoryService = processEngine.getRepositoryService();

        ProcessDefinition definition = repositoryService.createProcessDefinitionQuery().processDefinitionKey("myProcess_1").singleResult();
        // 是否暂停
        boolean suspended = definition.isSuspended();
        String id = definition.getId();
        if (suspended) {
            repositoryService.activateProcessDefinitionById(id, true, null);
            System.out.println("id = " + id + " 激活");
        } else {
            repositoryService.suspendProcessDefinitionById(id, true, null);
            System.out.println("id = " + id + " 挂起");
        }
    }

4.11.2、单个流程实例挂起

         操作流程实例对象，针对单个流程执行挂起操作，某个流程实例挂起则此流程不再继续执行，完成该流程实例的当前任务将报异常。

    @Test
    public void suspendOne() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RuntimeService runtimeService = processEngine.getRuntimeService();

        ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processInstanceId("12501").singleResult();
        boolean suspended = processInstance.isSuspended();
        String id = processInstance.getId();

        if (suspended) {
            runtimeService.activateProcessInstanceById(id);
            System.out.println("id = " + id + " 激活");
        } else {
            runtimeService.suspendProcessInstanceById(id);
            System.out.println("id = " + id + " 挂起");
        }
    }

4.11.3 流程实例推动

        在前面我们对一个整个的流程以及单个流程进行了激活和挂起操作，之后可以编写一段代码来进行推动流程操作，主要是用来当流程被挂起后流程还能否被继续推动。很显然，当挂起的流程去进行流程推动是不允许推动流程的，必须是流程是激活状态下才能够被推动。

具体的实例id和assignee值根据自己数据库的值来进行处理。

/**
     * 流程实例推动
     */
    @Test
    public void complete() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        Task task = taskService.createTaskQuery().processInstanceId("15001").taskAssignee("cxb").singleResult();
        System.out.println("id = " + task.getId());
        System.out.println("name = " + task.getName());
        System.out.println("assignee = " + task.getAssignee());
        taskService.complete(task.getId());
    }

5、个人任务

5.1、分配任务责任人

5.1.1、固定负责人

        在进行业务流程建模时指定固定的任务负责人，直接在bpmn当中指定assignee。

5.1.2、表达式分配

        由于固定分配方式，任务只管一步一步执行任务，执行到每一个任务将按照 bpmn 的配置去分配任务负责人。和前面一样进行指定，使用${变量名}的方式进行指定。而指定之后的这些变量在流程启动的时候可以通过一个map对象来进行赋值。

/**
     * 表达式分配
     */
    @Test
    public void startDistribution () {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RuntimeService runtimeService = processEngine.getRuntimeService();
        // 根据流程id启动流程
        Map<String, Object> map = new HashMap();
        map.put("assignee", "huangyueyue");
        map.put("director", "yueyueniao");
        map.put("manager", "zhangsan");
        ProcessInstance instance = runtimeService.startProcessInstanceByKey("myProcess_1", map);
    }

 5.1.3、监听器分配

        任务监听器的Event的选项包含：

  • Create：任务创建后触发
  • Assignment：任务分配后触发
  • Delete：任务完成后触发
  • All：所有事件发生都触发

定义任务监听类，且类必须实现 org.activiti.engine.delegate.TaskListener 接口

package com.cxb.springboot.listener;

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

public class MyTaskListener implements TaskListener {
    @Override
    public void notify(DelegateTask delegateTask) {
        if (delegateTask.getName().equals("请假申请") &&
                delegateTask.getEventName().equals("create")) {
            // 这里指定任务负责人
            delegateTask.setAssignee("黄阅阅");
        }
    }
}


<userTask activiti:exclusive="true" id="_3" name="请假申请">
      <extensionElements>
        <activiti:taskListener class="com.cxb.springboot.listener.MyTaskListener" event="all"/>
      </extensionElements>
    </userTask>

 5.2、查询任务

        在前面就已经可以通过流程key和负责人就可以查询出这个人负责的流程单，而实际应用时，查询待办任务可能要显示出业务系统的一些相关信息。这里可以通过 businessKey（业务标识 ）关联查询业务系统的数据。

/**
     * 查询任务
     */
    @Test
    public void findProcessInstance() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        RuntimeService runtimeService = processEngine.getRuntimeService();
        Task task = taskService.createTaskQuery()
                .processDefinitionKey("myProcess_1")
                .taskAssignee("cxb")
                .singleResult();
        String processInstanceId = task.getProcessInstanceId();
        ProcessInstance processInstance = runtimeService.createProcessInstanceQuery()
                .processInstanceId(processInstanceId)
                .singleResult();
        String businessKey = processInstance.getBusinessKey();
        System.out.println("businessKey==" + businessKey);
    }

 查询业务标识码

 5.3、任务推动

        在之前可以通过TaskService这个类的complate方法推动任务的流动，而在这里我们还需要对当前用户是否拥有推动该流程的权限，只需要先通过查询当前负责人的所有流程进行判断即可。有该流程即可推动，反之无法推动流程。

@Test
    public void completeTask() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        Task task = taskService.createTaskQuery()
                .taskId("20005")
                .taskAssignee("cxb")
                .singleResult();
        if (task != null) {
            taskService.complete("20005");
            System.out.println("完成任务");
        }
    }

6、流程变量与组任务

6.1、流程变量概述

6.1.1、流程变量是什么

        流程变量在 activiti 中是一个非常重要的角色，流程运转有时需要靠流程变量，业务系统和 activiti 结合时少不了流程变量，流程变量就是 activiti 在管理工作流时根据管理需要而设置的变量。

        虽然流程变量中可以存储业务数据可以通过activiti的api查询流程变量从而实现查询业务数据，但是不建议这样使用，因为业务数据查询由业务系统负责，activiti设置流程变量是为了流程执行需要而创建。

6.1.2、流程变量作用域

        流程变量的作用域可以是一个流程实例，或一个任务，或一个执行实例

1、global变量

        流程变量的默认作用域是流程实例。当一个流程变量的作用域为流程实例时，可以称为 global 变量。
        global 变量中变量名不允许重复，设置相同名称的变量，后设置的值会覆盖前设置的变量值。
2、local变量

        任务和执行实例仅仅是针对一个任务和一个执行实例范围，范围没有流程实例大， 称为 local 变量。
        Local 变量由于在不同的任务或不同的执行实例中，作用域互不影响，变量名可以相同没有影响。
        Local 变量名也可以和 global 变量名相同，没有影响。

6.2、使用global变量控制流程

         还是和前面的整个流程一样，现在对流程的分支进行控制，通过流程变量来进行控制，当天数大于或等于三天还需要通过经理审批，反之直接通过主管审批就结束了整个流程。

         这里的话使用的UEL表达式使用的是uel-method来进行赋值，所以在这里需要一个实体类来进行值的给予，先定义一个类。该类当中必须包含这个day变量，也就是在bpmn文件当中指定的变量，以及该类必须实例化。并且加上getset方法。

public class Leave implements Serializable {
    private Double day;
}

6.2.1、启动流程时设置变量

        在启动流程时设置流程变量，变量的作用域是整个流程实例。通过Map<key,value>设置流程变量，map中可以设置多个变量，这个key就是流程变量的名字。后续通过TaskService的compele方法来进行推动流程实例的代码就不给出了，直接获取taskid进行推动，查看流程的走向。

 /**
     * 单个文件部署流程
     */
    @Test
    public void developGlobal() {
        // 创建流程对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        // 获取service对象
        RepositoryService repositoryService = processEngine.getRepositoryService();
        // 流程部署 设置名字 将bpmn和png部署进去
        Deployment deploy = repositoryService.createDeployment()
                .addClasspathResource("bpmn/hello-global.bpmn")
                .addClasspathResource("bpmn/hello-global.png")
                .name("请假流程全局设置变量")
                .deploy();
        System.out.println("id = " + deploy.getId());
        System.out.println("name = " + deploy.getName());
    }

    /**
     * 启动流程时设置变量
     */
    @Test
    public void startSetGlobal() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RuntimeService runtimeService = processEngine.getRuntimeService();
        Leave leave = new Leave();
        leave.setDay(4d);
        Map map = new HashMap();
        map.put("leave", leave);
        map.put("assignee", "yueyueniao");
        map.put("director", "张三");
        map.put("manager", "黄阅阅");
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("myProcess_1", map);
        System.out.println(processInstance);
    }

6.2.2 任务办理时设置变量

        在完成任务时设置流程变量，该流程变量只有在该任务完成后其它结点才可使用该变量，它的作用域是整个流程实例，如果设置的流程变量的key在流程实例中已存在相同的名字则后设置的变量替换前边设置的变量。这样对前面6.2.1的代码当中往map对象当中添加leave的代码注掉。

/**
     * 任务办理时设置变量
     */
    @Test
    public void completeSet() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        Leave leave = new Leave();
        leave.setDay(4d);
        Map map = new HashMap();
        map.put("leave", leave);
        Task task = taskService.createTaskQuery().processDefinitionKeyLike("myLeaveGlabal").taskAssignee("张三").singleResult();
        if (task != null) {
            taskService.complete(task.getId(), map);
        }
    }

 6.2.3 通过当前流程实例设置

        通过流程实例id设置全局变量，该流程实例必须未执行完成。

    @Test
    public void setGlobalVariableByExecutionId() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RuntimeService runtimeService = processEngine.getRuntimeService();
        Leave leave = new Leave();
        leave.setDay(4d);
        runtimeService.setVariable("75001", "leave", leave);
    }

6.2.4 通过当前任务设置

    @Test
    public void setGlobalVariableByTaskId() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        Leave leave = new Leave();
        leave.setDay(4d);
        taskService.setVariable("75001", "leave", leave);
    }

6.3 组任务办理流程***

1）查询组任务
指定候选人，查询该候选人当前的待办任务。候选人不能立即办理任务。

2）拾取任务
该组任务的所有候选人都能拾取。将候选人的组任务，变成个人任务。原来候选人就变成了该任务的负责人。如果拾取后不想办理该任务，需要将已经拾取的个人任务归还到组里边，将个人任务变成了组任务。

3）查询个人任务
查询方式同个人任务部分，根据assignee查询用户负责的个人任务。

4）办理个人任务
首先创建一个bpmn文件，在user当中可以对candidateUsers进行设置多个人员，之间用都好进行隔开，而对应的xml如下：

    <userTask activiti:candidateUsers="zhangsan,lisi" activiti:exclusive="true" id="_3" name="申请-group"/>
    <userTask activiti:candidateUsers="wangwu,zhaoliu" activiti:exclusive="true" id="_4" name="审核-group"/>

之后将该bpmn进行部署，并且启动任务。

6.3.1 查询组任务

        根据候选人查询组任务，可以看到这个task在act_ru_task这张表当中的assignee却是一个null，也就是该用户虽然可以查询出该任务，却无法对该任务进行处理。

    @Test
    public void findGroup() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        List<Task> list = taskService.createTaskQuery().processDefinitionKey("myLeaveGroup").taskCandidateUser("zhangsan").list();
        for (Task task : list) {
            System.out.println("instance id = " + task.getProcessInstanceId());
            System.out.println("id = " + task.getId());
            System.out.println("assignee = " + task.getAssignee());
            System.out.println("name = " + task.getName());
        }
    }

6.3.2 拾取任务

        候选人员拾取组任务后该任务变为自己的个人任务。用户拾取任务之后，对应的act_ru_task表对应的行数据的assignee就会变成相对应的人员。

    @Test
    public void getTask() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();

        Task task = taskService.createTaskQuery().taskId("87505").taskCandidateUser("zhangsan").singleResult();
        if (task != null) {
            taskService.claim("87505", "zhangsan");
            System.out.println("用户拾取");
        }
    }

6.3.3 归还组任务

        直接通过assignee进行查询，查询到数据再将assignee置空也就表示归还了任务。同理任务的交接就不用设置为空了，直接设置给另一个用户即可。

    @Test
    public void returnTask() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();

        Task task = taskService.createTaskQuery().taskId("87505").taskAssignee("zhangsan").singleResult();
        if (task != null) {
            taskService.setAssignee("87505", null);
            System.out.println("用户归还");
        }
    }

7、网关

7.1 排他网关

        排他网关，用来在流程中实现决策。 当流程执行到这个网关，所有分支都会判断条件是否为true，如果为true则执行该分支，注意：排他网关只会选择一个为true的分支执行。如果有两个分支条件都为true，排他网关会选择id值较小的一条分支去执行。

 在这里对A流程后设置一个排他网关进行流程分支，这两条分支线也就对应两个uel表达式进行判断，而后就可以直接把这个流程进行部署，部署之后在启动流程的时候就给这个day进行设置值，直接进行推动流程，查看流程的流转。

    @Test
    public void startSet() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RuntimeService runtimeService = processEngine.getRuntimeService();
        Leave leave = new Leave();
        leave.setDay(-4d);
        Map map = new HashMap();
        map.put("leave", leave);
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("gateway-pt", map);
    }

    @Test
    public void compete() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        Task task = taskService.createTaskQuery().processDefinitionKey("gateway-pt").taskAssignee("张三").singleResult();
        if (task != null) {
            taskService.complete(task.getId());
        }
    }

7.2 并行网关

        并行网关允许将流程分成多条分支，也可以把多条分支汇聚到一起，并行网关的功能是基于进入和外出顺序流的：

        fork分支：并行后的所有外出顺序流，为每个顺序流都创建一个并发分支。

        join汇聚：所有到达并行网关，在此等待的进入分支， 直到所有进入顺序流的分支都到达以后， 流程就会通过汇聚网关。

        并行网关的测试代码和前面排他网关的代码基本一致，在首先进行部署之后启动流程，给流程设置一个天数，而之后推动任务之后，首先进入到并行网关，这里并不会进行判断，这里的意思是表示B和C都可以进行对该任务流程进行操作，并且只有到B和C都做了相关的操作流程才会继续往后流转，后面接的排他网关直接通过最开始设置的值再进行判断做流程的流转。


7.3 包含网关

        包含网关可以看做是排他网关和并行网关的结合体。和排他网关一样，可以在外出顺序流上定义条件，包含网关会解析它们。 但是主要的区别是包含网关可以选择多于一条顺序流，这和并行网关一样。

        1、分支：所有外出顺序流的条件都会被解析，结果为true的顺序流会以并行方式继续执行， 会为每个顺序流创建一个分支。
        2、汇聚：所有并行分支到达包含网关，会进入等待状态， 直到每个包含流程token的进入顺序流的分支都到达。 这是与并行网关的最大不同。换句话说，包含网关只会等待被选中执行了的进入顺序流。 在汇聚之后，流程会穿过包含网关继续执行。
        和之前的网关一样进行部署推动流程，可以发现在进入到包含网关的时候，网关会对条件进行判断再进行流转。二里面的包含又相当于并行网关，当并行的流程都执行完成之后再由包含网关进行汇聚。之后走排他网关进行判断流转。

7.4 事件网关

        事件网关允许根据事件判断流向。网关的每个外出顺序流都要连接到一个中间捕获事件。 当流程到达一个基于事件网关，网关会进入等待状态：会暂停执行。与此同时，会为每个外出顺序流创建相对的事件订阅。

        事件网关的外出顺序流和普通顺序流不同，这些顺序流不会真的"执行"， 相反它们让流程引擎去决定执行到事件网关的流程需要订阅哪些事件。 要考虑以下条件：

        1、事件网关必须有两条或以上外出顺序流；
        2、事件网关后，只能使用intermediateCatchEvent类型（activiti不支持基于事件网关后连接ReceiveTask）
        3、连接到事件网关的中间捕获事件必须只有一个入口顺序流。

参考

小石潭记丶
关注
  • 5
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
极简 Java 工作流概念入门
mfmfmfo的博客
08-26 1366
这个流程比较简单，我们很容易想到解决方案，不用工作流也能解决，有一个专门的请假表，当 A 要请假的时候，就往请假表中添加一条记录，这条记录的内容包含了请假的天数、原因、请假的审批人 B 以及一个名为 status 的字段，这个 status 字段表示这个请假申请目前的状态（待审批、已批准还是已拒绝），然后 B 登录系统之后，在请假表中查询到了 A 的请假信息，然后选择批准，此时将 status 字段的值改一下就行了。举个中间定时事件的例子，比如用户下单之后，可以有一个中间定时事件，延迟 5 分钟发货。..
activiti工作流
06-15
Activiti项目是一项新的基于Apache许可的开源BPM平台，从基础开始构建，旨在提供支持新的BPMN 2.0标准，包括支持对象管理组（OMG），面对新技术的机遇，诸如互操作性和云架构，提供技术实现。
activiti工作流（超详细）
04-07
activiti工作流文档，超详细，从0基础开始入门，包括数据库介绍、核心api等介绍，满足日常开发所需
SpringBoot + Activiti 工作流搭建与实现【附源码和配套文档】
2301_81867536的博客
03-12 806
springboot+vue+activiti集成了activiti在线编辑器，流行的前后端分离部署开发模式，快速开发平台，可插拔工作流服务。工作流表单可平滑的接入自定义表单，接入后进行业务审批流转。本项目集成了工作流所有的功能，并做了一个测试的表单进行审批演示。工作流部分功能含：流程图在线绘制，在线发布，工作流权限设置，审批节点设置（角色，直接指定人，部门等），业务表单关联，提交，撤回，与签或签，同意，驳回（支持驳回到任意岗），审批委托，流程挂起，流程图实时跟踪，审批提醒，可接入钉钉进行钉钉通知，企业微信
工作流和Activiti框架的简单概念
Crazy_young_man的博客
07-13 1871
工作流和工作流框架概念 activiti Activiti的核心API
Activiti工作流介绍及使用
anyisure的博客
06-19 2957
工作流(Workflow)，就是“业务过程的部分或整体在计算机应用环境下的自动化”，它主要解决的是“使在多个参与者之间按照某种预定义的规则传递文档、信息或任务的过程自动进行，从而实现某个预期的业务目标，或者促使此目标的实现”。工作流管理系统(Workflow Management System, WfMS)是一个软件系统，它完成工作量的定义和管理，并按照在系统中预先定义好的工作流规则进行工作流实例的执行。工作流管理系统不是企业的业务系统，而是为企业的业务系统的运行提供了一个软件的支撑环境。
activiti工作流引擎入门教程
GarfieldEr007的专栏
03-02 1万+
activiti简介 Activiti项目是一项新的基于Apache许可的开源BPM平台，从基础开始构建，旨在提供支持新的BPMN 2.0标准。 Activiti是一种轻量级，可嵌入的BPM引擎，而且还设计适用于可扩展的云架构。 Activiti将提供宽松的Apache许可2.0，同时促进Activiti BPM引擎和BPMN 2.0的匹配。 activiti的7大马车 1.Repos...
Activity工作流入门篇
热门推荐
weixin_42073629的博客
09-06 2万+
什么是 Activity 工作流引擎 ? 什么是工作流，比如说，我们在公司请假，可能要走审批的流程，从你自己到 Leader,然后从 Leader 到部门经理，然后部门经理再到人事部门，这一系列的流程实际上就相当于是一个工作流程，而这个就是一个工作流的最容易理解的模型。 这肯定官方解读肯定不是这样，不然也太接地气了点，那么什么是 Activity 工作流呢？ 工作流（Workflow），指“业务过程的部分或整体在计算机应用环境下的自动化”。是对工作流程及其各操作步骤之间业务规则的抽象、概括描述。在计算
Activiti工作流入门到实战
07-27
Activiti是一个项目的名称，Alfresco软件在2010年5月17日宣布Activiti业务流程管理（BPM）开源项目的正式启动，其首席架构师由业务流程管理BPM的专家 Tom Baeyens担任。本套课程为Activiti基于SpringBoot下的教程 1、Activiti简介2、 Activiti安装eclipse插件3、 Activiti部署流程4、 Activiti启动流程实例5、 Activiti执行任务6、 Activiti操作流程定义7、 Activiti删除任务、流程定义8、 Activiti查看流程图9、 Activiti查看历史流程实例10、 Activiti查看流程实例状态11、 Activiti设置获取变量12、 Activiti查询历史数据13、 Activiti排他网关14、 Activiti并行网关15、 Activiti流程实例16、 Activiti获取执行对象17、 Activiti动态设置任务处理人18、 Activiti任务认领、转发19、 Activiti创建角色、用户20、 Activiti任务拾取、回退
工作流引擎Activiti--＞基础篇
chenghan的博客
04-09 1791
目录一、工作流介绍1.1、概念1.2、工作流系统1.3、适用行业1.4、具体应用1.5、实现方式二、Activiti7概述2.1、介绍2.2、BPM2.3、BPM软件2.4、BPMN![在这里插入图片描述](https://img-blog.csdnimg.cn/20210407235443302.png)2.5、使用步骤三、Activiti环境3.1、开发环境3.2、Activiti环境3.3、Activiti的数据库支持四、Activiti类关系图五、Activiti入门六、流程定义 一、工作流介绍 1
什么是工作流?
IccBoY_超越
07-06 1万+
工作流，是把业务之间的各个步骤以及规则进行抽象和概括性的描述。使用特定的语言为业务流程建模，让其运行在计算机上，并让计算机进行计算和推动。
Activiti工作流引擎简介
08-15
Activiti工作流引擎简介 1.俯瞰Activiti 2.Activiti开发之旅 3.Why Activiti? 4.Activiti的现状与未来
Activiti工作流面试相关知识
02-27
Activiti 工作流面试相关知识 RepositoryService、RuntimeService、TaskService、HistoryService分别表示什么操作
Activiti工作流引擎入门
12-20
activiti是一个工作流引擎，可以将业务系统中复杂的业务流程抽取出来，使用专门的建模语言BPMN进行定义，业务流程按照预先定义的流程进行执行。实现了系统的流程由activiti进行管理，减少业务系统由于流程变更进行...
【解决NodeJS项目无法在IDEA中调试的问题】使用JetBrains IDEA 2023 调试nodejs项目
宅斗士的博客
04-23 369
项目采用Ant Design Pro + React，使用前后端分离开发方式，后端可以很容易的打断点调试，但是前端用到了React脚手架，在IDEA中加了调试断点，但是没有什么用处。
# IDEA2019 如何打开 Run Dashboard 运行仪表面板
段子手168的博客
04-20 543
IDEA2019 如何打开 Run Dashboard 运行仪表面板
如何解决升级IntelliJ IDEA 2024后 打开项目就自动闪退关闭问题的终极指南
猫头虎：授渔优于赠鱼，兴趣引领智慧，探索之乐尤显珍贵。商务合作：Libin9iOak，共赴知识与乐趣的探索之旅！
04-23 8627
随着 IntelliJ IDEA 2024 版本的推出，许多开发者在升级后遇到了项目自动关闭的问题。本文将深入分析此问题的根本原因，主要包括插件兼容性问题，并提供详细的解决步骤。通过本文，无论是编程新手还是资深开发者，都可以轻松解决这一技术难题。文章关键词包括：IntelliJ IDEA 2024, 项目自动关闭问题, 插件兼容性, 技术解决方案，IDEA 2024闪退,IDEA 2024打不开。
IDEA 中如何通过连接数据库自动生成代码
最新发布
跟着飞哥学编程（全栈联盟）
04-26 274
MybatisPlus 插件在 IDEA 中连接数据库，自动生成代码的操作讲解。
activiti工作流教程
05-12
Activiti 是一个基于 Java 的开源工作流引擎，可以用来设计、部署和执行各种工作流和业务流程。以下是 Activiti 工作流的基础教程： 1. 安装 Activiti 首先，你需要下载 Activiti 的安装包，并按照安装指南进行安装。你可以在 Activiti 官网上下载最新版本的安装包。 2. 创建工作流 使用 Activiti Designer 工具来创建工作流。Activiti Designer 是一个 Eclipse 插件，可以轻松地创建 BPMN 2.0 标准的工作流。 3. 部署工作流 使用 Activiti Explorer 工具来部署工作流。Activiti Explorer 是一个基于 Web 的用户界面，可以帮助你管理工作流程定义和实例，以及任务列表和历史记录。 4. 执行工作流 使用 Activiti Engine 来执行工作流。Activiti Engine 是一个 Java 库，可以用来启动和执行工作流实例。 5. 监控工作流 使用 Activiti Explorer 或 Activiti Engine 来监控工作流。你可以查看工作流程实例的状态和活动，以及任务列表和历史记录。 以上是 Activiti 工作流的基础教程，你可以通过阅读 Activiti 官方文档来深入了解 Activiti 工作流的更多功能和用法。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值