Flowable12基础流程实战资金申请------------持续更新中

最新推荐文章于 2025-07-03 17:32:34 发布
最新推荐文章于 2025-07-03 17:32:34 发布
阅读量216 收藏
点赞数 5
CC 4.0 BY-SA版权
分类专栏： flowable 文章标签： flowable spring boot java 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/CodeTom/article/details/149095314

现在根据我们前11章学的内容，练习一个小Demo来串通一下
如下是一个资金申请.bpmn20.xml，我们将要完善后端代码

<?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:flowable="http://flowable.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.flowable.org/processdef">
  <process id="money_apply_optimized" name="资金申请流程(优化版)" isExecutable="true">
    <startEvent id="startEvent" name="开始"></startEvent>
    <userTask id="task_submit_application" name="填写资金申请单" flowable:assignee="${initiator}">
      <documentation>申请人填写并提交资金申请，需提供事由、金额(amount)等信息。</documentation>
    </userTask>
    <sequenceFlow id="flow_start_to_submit" sourceRef="startEvent" targetRef="task_submit_application"></sequenceFlow>
    <userTask id="task_manager_approval" name="部门经理审批" flowable:assignee="${manager}">
      <documentation>部门经理审批。审批时需设置流程变量 approved (true/false)。</documentation>
    </userTask>
    <sequenceFlow id="flow_submit_to_manager" sourceRef="task_submit_application" targetRef="task_manager_approval"></sequenceFlow>
    <exclusiveGateway id="gateway_manager_decision" name="经理审批是否通过?"></exclusiveGateway>
    <sequenceFlow id="flow_manager_to_gateway" sourceRef="task_manager_approval" targetRef="gateway_manager_decision"></sequenceFlow>
    <exclusiveGateway id="gateway_check_amount" name="金额是否超过10000?" default="flow_amount_low"></exclusiveGateway>
    <sequenceFlow id="flow_manager_approved" name="通过" sourceRef="gateway_manager_decision" targetRef="gateway_check_amount">
      <conditionExpression xsi:type="tFormalExpression"><![CDATA[${approved == true}]]></conditionExpression>
    </sequenceFlow>
    <userTask id="task_modify_application" name="修改申请单" flowable:assignee="${initiator}">
      <documentation>申请被驳回，请根据审批意见修改后重新提交。</documentation>
    </userTask>
    <sequenceFlow id="flow_manager_rejected" name="驳回修改" sourceRef="gateway_manager_decision" targetRef="task_modify_application">
      <conditionExpression xsi:type="tFormalExpression"><![CDATA[${approved == false}]]></conditionExpression>
    </sequenceFlow>
    <sequenceFlow id="flow_modify_to_manager" sourceRef="task_modify_application" targetRef="task_manager_approval"></sequenceFlow>
    <userTask id="task_director_approval" name="部门总监审批" flowable:assignee="${director}">
      <documentation>金额大于10000，需总监审批。审批时需设置流程变量 approved (true/false)。</documentation>
    </userTask>
    <sequenceFlow id="flow_amount_high" name="是 (>10000)" sourceRef="gateway_check_amount" targetRef="task_director_approval">
      <conditionExpression xsi:type="tFormalExpression"><![CDATA[${amount > 10000}]]></conditionExpression>
    </sequenceFlow>
    <exclusiveGateway id="gateway_director_decision" name="总监审批是否通过?"></exclusiveGateway>
    <sequenceFlow id="flow_director_to_gateway" sourceRef="task_director_approval" targetRef="gateway_director_decision"></sequenceFlow>
    <userTask id="task_finance_review" name="财务复核" flowable:assignee="${finance_reviewer}">
      <documentation>财务复核申请的合规性、票据等。复核时需设置流程变量 approved (true/false)。</documentation>
    </userTask>
    <sequenceFlow id="flow_director_approved" name="通过" sourceRef="gateway_director_decision" targetRef="task_finance_review">
      <conditionExpression xsi:type="tFormalExpression"><![CDATA[${approved == true}]]></conditionExpression>
    </sequenceFlow>
    <sequenceFlow id="flow_director_rejected" name="驳回修改" sourceRef="gateway_director_decision" targetRef="task_modify_application">
      <conditionExpression xsi:type="tFormalExpression"><![CDATA[${approved == false}]]></conditionExpression>
    </sequenceFlow>
    <sequenceFlow id="flow_amount_low" name="否 (默认)" sourceRef="gateway_check_amount" targetRef="task_finance_review"></sequenceFlow>
    <exclusiveGateway id="gateway_finance_decision" name="财务复核是否通过?"></exclusiveGateway>
    <sequenceFlow id="flow_finance_review_to_gateway" sourceRef="task_finance_review" targetRef="gateway_finance_decision"></sequenceFlow>
    <userTask id="task_finance_payment" name="财务出纳付款" flowable:assignee="${finance_cashier}">
      <documentation>所有审批完成，执行打款操作。</documentation>
    </userTask>
    <sequenceFlow id="flow_finance_approved" name="通过" sourceRef="gateway_finance_decision" targetRef="task_finance_payment">
      <conditionExpression xsi:type="tFormalExpression"><![CDATA[${approved == true}]]></conditionExpression>
    </sequenceFlow>
    <sequenceFlow id="flow_finance_rejected" name="驳回修改" sourceRef="gateway_finance_decision" targetRef="task_modify_application">
      <conditionExpression xsi:type="tFormalExpression"><![CDATA[${approved == false}]]></conditionExpression>
    </sequenceFlow>
    <endEvent id="endEvent" name="结束"></endEvent>
    <sequenceFlow id="flow_payment_to_end" sourceRef="task_finance_payment" targetRef="endEvent"></sequenceFlow>
  </process>
  <bpmndi:BPMNDiagram id="BPMNDiagram_money_apply_optimized">
    <bpmndi:BPMNPlane bpmnElement="money_apply_optimized" id="BPMNPlane_money_apply_optimized">
      <bpmndi:BPMNShape bpmnElement="startEvent" id="BPMNShape_startEvent">
        <omgdc:Bounds height="30.0" width="30.0" x="200.0" y="50.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="task_submit_application" id="BPMNShape_task_submit_application">
        <omgdc:Bounds height="80.0" width="100.0" x="165.0" y="120.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="task_manager_approval" id="BPMNShape_task_manager_approval">
        <omgdc:Bounds height="80.0" width="100.0" x="165.0" y="240.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="gateway_manager_decision" id="BPMNShape_gateway_manager_decision">
        <omgdc:Bounds height="40.0" width="40.0" x="195.0" y="360.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="task_modify_application" id="BPMNShape_task_modify_application">
        <omgdc:Bounds height="80.0" width="100.0" x="350.0" y="240.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="gateway_check_amount" id="BPMNShape_gateway_check_amount">
        <omgdc:Bounds height="40.0" width="40.0" x="195.0" y="440.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="task_director_approval" id="BPMNShape_task_director_approval">
        <omgdc:Bounds height="80.0" width="100.0" x="165.0" y="520.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="gateway_director_decision" id="BPMNShape_gateway_director_decision">
        <omgdc:Bounds height="40.0" width="40.0" x="195.0" y="640.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="task_finance_review" id="BPMNShape_task_finance_review">
        <omgdc:Bounds height="80.0" width="100.0" x="165.0" y="720.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="gateway_finance_decision" id="BPMNShape_gateway_finance_decision">
        <omgdc:Bounds height="40.0" width="40.0" x="195.0" y="840.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="task_finance_payment" id="BPMNShape_task_finance_payment">
        <omgdc:Bounds height="80.0" width="100.0" x="165.0" y="920.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="endEvent" id="BPMNShape_endEvent">
        <omgdc:Bounds height="30.0" width="30.0" x="200.0" y="1040.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNEdge bpmnElement="flow_start_to_submit" id="BPMNEdge_flow_start_to_submit">
        <omgdi:waypoint x="215.0" y="80.0"></omgdi:waypoint>
        <omgdi:waypoint x="215.0" y="120.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="flow_submit_to_manager" id="BPMNEdge_flow_submit_to_manager">
        <omgdi:waypoint x="215.0" y="200.0"></omgdi:waypoint>
        <omgdi:waypoint x="215.0" y="240.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="flow_manager_to_gateway" id="BPMNEdge_flow_manager_to_gateway">
        <omgdi:waypoint x="215.0" y="320.0"></omgdi:waypoint>
        <omgdi:waypoint x="215.0" y="360.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="flow_manager_approved" id="BPMNEdge_flow_manager_approved">
        <omgdi:waypoint x="215.0" y="400.0"></omgdi:waypoint>
        <omgdi:waypoint x="215.0" y="440.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="flow_manager_rejected" id="BPMNEdge_flow_manager_rejected">
        <omgdi:waypoint x="235.0" y="380.0"></omgdi:waypoint>
        <omgdi:waypoint x="400.0" y="380.0"></omgdi:waypoint>
        <omgdi:waypoint x="400.0" y="320.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="flow_modify_to_manager" id="BPMNEdge_flow_modify_to_manager">
        <omgdi:waypoint x="350.0" y="280.0"></omgdi:waypoint>
        <omgdi:waypoint x="265.0" y="280.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="flow_amount_high" id="BPMNEdge_flow_amount_high">
        <omgdi:waypoint x="215.0" y="480.0"></omgdi:waypoint>
        <omgdi:waypoint x="215.0" y="520.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="flow_director_to_gateway" id="BPMNEdge_flow_director_to_gateway">
        <omgdi:waypoint x="215.0" y="600.0"></omgdi:waypoint>
        <omgdi:waypoint x="215.0" y="640.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="flow_director_approved" id="BPMNEdge_flow_director_approved">
        <omgdi:waypoint x="215.0" y="680.0"></omgdi:waypoint>
        <omgdi:waypoint x="215.0" y="720.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="flow_director_rejected" id="BPMNEdge_flow_director_rejected">
        <omgdi:waypoint x="235.0" y="660.0"></omgdi:waypoint>
        <omgdi:waypoint x="400.0" y="660.0"></omgdi:waypoint>
        <omgdi:waypoint x="400.0" y="320.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="flow_amount_low" id="BPMNEdge_flow_amount_low">
        <omgdi:waypoint x="195.0" y="460.0"></omgdi:waypoint>
        <omgdi:waypoint x="90.0" y="460.0"></omgdi:waypoint>
        <omgdi:waypoint x="90.0" y="760.0"></omgdi:waypoint>
        <omgdi:waypoint x="165.0" y="760.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="flow_finance_review_to_gateway" id="BPMNEdge_flow_finance_review_to_gateway">
        <omgdi:waypoint x="215.0" y="800.0"></omgdi:waypoint>
        <omgdi:waypoint x="215.0" y="840.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="flow_finance_approved" id="BPMNEdge_flow_finance_approved">
        <omgdi:waypoint x="215.0" y="880.0"></omgdi:waypoint>
        <omgdi:waypoint x="215.0" y="920.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="flow_finance_rejected" id="BPMNEdge_flow_finance_rejected">
        <omgdi:waypoint x="235.0" y="860.0"></omgdi:waypoint>
        <omgdi:waypoint x="400.0" y="860.0"></omgdi:waypoint>
        <omgdi:waypoint x="400.0" y="320.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="flow_payment_to_end" id="BPMNEdge_flow_payment_to_end">
        <omgdi:waypoint x="215.0" y="1000.0"></omgdi:waypoint>
        <omgdi:waypoint x="215.0" y="1040.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
    </bpmndi:BPMNPlane>
  </bpmndi:BPMNDiagram>
</definitions>

那么接下来将要完善一下后台代码是如何实现的。
1、首先创建出对应的实体类以及DB表，完善一下Mapper

-- 资金申请业务表，用于存储与流程无关但又必须持久化的业务数据。
CREATE TABLE money_application (
    -- 业务主键，自增ID
    `id` BIGINT AUTO_INCREMENT PRIMARY KEY,
    -- 申请人ID或用户名，与流程中的`initiator`变量对应
    `applicant` VARCHAR(255) NOT NULL,
    -- 申请事由，这是纯业务数据
    `reason` VARCHAR(500) NOT NULL,
    -- 申请金额，这是驱动流程走向的关键业务数据
    `amount` DECIMAL(10, 2) NOT NULL,
    -- 流程实例ID，这是业务表与Flowable流程实例建立关联的关键外键
    `process_instance_id` VARCHAR(64) NULL,
    -- 记录创建时间
    `create_time` TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    -- 流程状态
    `status` VARCHAR(50) DEFAULT 'PROCESSING'
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

实体类

package com.example.flowabledemo.entity;

import lombok.Data; // 使用Lombok简化getter, setter, toString等方法的编写
import java.math.BigDecimal;
import java.util.Date;

/**
 * @description: 资金申请实体类，映射数据库中的 `money_application` 表。
 * 这个类是纯粹的业务领域模型(Domain Model)，负责承载业务数据。
 */
@Data
public class MoneyApplication {
    /**
     * 业务主键ID
     */
    private Long id;

    /**
     * 申请人
     */
    private String applicant;

    /**
     * 申请事由
     */
    private String reason;

    /**
     * 申请金额，使用BigDecimal以保证精度
     */
    private BigDecimal amount;

    /**
     * 关联的Flowable流程实例ID
     */
    private String processInstanceId;

    /**
     * 申请创建时间
     */
    private Date createTime;
    /**
    * 流程状态
    * /
    private String status;
}

mapper类

package com.example.flowabledemo.mapper;

import com.example.flowabledemo.entity.MoneyApplication;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;

/**
 * @description: 资金申请表的MyBatis Mapper接口。
 * Spring Boot会自动扫描带有@Mapper注解的接口并为其创建代理实现。
 */
@Mapper
public interface MoneyApplicationMapper {
    /**
     * 插入一条新的资金申请记录到业务表中。
     *
     * @param application 包含申请信息的实体对象。
     */
    void insert(MoneyApplication application);

    /**
     * 当流程启动后，将获取到的流程实例ID更新回对应的业务数据行。
     * 这是建立业务数据与流程数据双向关联的关键步骤。
     *
     * @param id 业务数据的主键ID。
     * @param processInstanceId Flowable返回的流程实例ID。
     */
    void updateProcessInstanceId(@Param("id") Long id, @Param("processInstanceId") String processInstanceId);

 /**
     * 根据流程实例ID更新业务表的状态。
     * @param processInstanceId 流程实例ID
     * @param status 新的状态
     */
    void updateStatusByProcessInstanceId(@Param("processInstanceId") String processInstanceId, @Param("status") String status);
 /**
     * 根据流程实例ID查询对应的业务申请详情。
     *
     * @param processInstanceId 流程实例ID
     * @return 资金申请的业务实体对象
     */
    MoneyApplication selectByProcessInstanceId(@Param("processInstanceId") String processInstanceId);
}

xml文件就不写了，纯纯的crud。
2、设置请求DTO

package com.example.flowabledemo.dto;

import lombok.Data;
import java.math.BigDecimal;

/**
 * @description: 用于封装“启动流程”请求的数据传输对象 (Data Transfer Object)。
 * 使用DTO可以使Controller接口的定义更清晰，与领域模型解耦，并且便于API文档生成。
 */
@Data
public class StartRequest {
    /**
     * 申请人ID
     */
    private String applicant;
    /**
     * 申请事由
     */
    private String reason;
    /**
     * 申请金额
     */
    private BigDecimal amount;
}

3、设置service编写具体业务
ps:由于只写了一个工作流业务所以很多代码没有提取成公共代码，若是你的项目中引入工作流，简易先写一个service封装一下基本的工作流操作。

package com.example.flowabledemo.service;

import com.example.flowabledemo.entity.MoneyApplication;
import com.example.flowabledemo.mapper.MoneyApplicationMapper;
import org.flowable.engine.HistoryService;
import org.flowable.engine.RuntimeService;
import org.flowable.engine.TaskService;
import org.flowable.engine.runtime.ProcessInstance;
import org.flowable.task.api.Task;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * @description: 资金申请的核心业务服务类。
 * 该类封装了所有与Flowable引擎的交互逻辑，以及相关的业务数据操作。
 * Controller层只调用这个Service，不直接接触Flowable API。
 */
@Service
public class MoneyApplicationService {

    // --- 注入Flowable核心服务API和MyBatis Mapper ---
    @Autowired
    private RuntimeService runtimeService; // 负责流程实例的启动和管理
    @Autowired
    private TaskService taskService;       // 负责任务的查询、办理和完成
    @Autowired
    private HistoryService historyService; // 负责查询流程历史记录
    @Autowired
    private IdentityService identityService; // 注入IdentityService
    @Autowired
    private MoneyApplicationMapper applicationMapper; // 注入我们自己的MyBatis Mapper

    /**
     * 启动资金申请流程。
     * 这是一个事务性操作，确保业务数据插入和流程启动要么都成功，要么都失败。
     *
     * @param applicant 申请人
     * @param reason    申请事由
     * @param amount    申请金额
     * @return 启动的流程实例ID
     */
    @Transactional
    public String startProcess(String applicant, String reason, BigDecimal amount) {

        // =================================================================
        // 步骤1: 持久化业务数据 (使用MyBatis)
        // =================================================================
        MoneyApplication application = new MoneyApplication();
        application.setApplicant(applicant);
        application.setReason(reason);
        application.setAmount(amount);
        // 调用Mapper将业务数据插入到`money_application`表中
        applicationMapper.insert(application); // 插入后，application.getId()将获得数据库生成的自增ID

        // =================================================================
        // 步骤2: 启动Flowable流程实例
        // =================================================================
        // 准备流程变量，这些变量将用于驱动流程的逻辑判断
        Map<String, Object> variables = new HashMap<>();
        // 'initiator' 是BPMN中定义的申请人变量 (e.g., flowable:assignee="${initiator}")
        variables.put("initiator", applicant);
        // 'amount' 是BPMN中定义的金额变量，用于金额判断网关 (e.g., ${amount > 10000})
        // 注意：BPMN表达式通常使用标准Java类型，将BigDecimal转为Double
        variables.put("amount", amount.doubleValue()); 

        // 使用BPMN文件中的process id ("money_apply_optimized") 来启动流程。
        // 第二个参数是 "businessKey"，这是Flowable提供的用于关联业务数据的标准方式。
        // 我们将业务表的主键ID作为businessKey，建立了从流程到业务数据的直接关联。
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("money_apply_optimized", String.valueOf(application.getId()), variables);

        // =================================================================
        // 步骤3: 将流程实例ID更新回业务表，建立双向关联
        // =================================================================
        applicationMapper.updateProcessInstanceId(application.getId(), processInstance.getId());
        
        // =================================================================
        // 步骤4 (可选但推荐): 自动完成第一个任务 "填写资金申请单"
        // 因为启动API本身就代表了申请的提交，所以这个任务可以直接完成。
        // 需要注意的是flowable6.7发起人跟第一个流程审批的人是同一个的话会自动完成，若是已经配置了true
        //=================================================================
        Task firstTask = taskService.createTaskQuery()
                .processInstanceId(processInstance.getId()) // 限定在刚启动的流程实例中
                .taskAssignee(applicant) // 任务的办理人是申请人
                .singleResult(); // 确定只有一个结果
        
        if(firstTask != null){
            // 准备下一个任务（经理审批）所需的变量。
            // 在实际项目中，审批人应根据申请人的部门、角色等动态查询得到。
            // 这里为简化演示，我们硬编码。
            Map<String, Object> taskVariables = new HashMap<>();
            taskVariables.put("manager", "manager"); // 经理审批人
            taskVariables.put("director", "director"); // 总监审批人
            taskVariables.put("finance_reviewer", "finance_reviewer"); // 财务复核人
            taskVariables.put("finance_cashier", "finance_cashier"); // 财务出纳
            
            // 完成任务，并传入变量，这些变量会被设置到流程实例中
            taskService.complete(firstTask.getId(), taskVariables);
        }

        // 返回流程实例ID给调用方
        return processInstance.getId();
    }

    /**
     * 根据办理人ID查询其名下的待办任务列表。
     *
     * @param assignee 办理人ID (例如: "manager", "director", "finance_reviewer")
     * @return 一个简化的任务信息列表，方便前端展示。
     */
    public List<Map<String, String>> getTasks(String assignee) {
        // 使用TaskService创建一个任务查询
        List<Task> tasks = taskService.createTaskQuery()
                .taskAssignee(assignee) // 按办理人过滤
                .orderByTaskCreateTime().desc() // 按创建时间降序排序
                .list(); // 获取列表

        // 将原始的Task对象转换为更简洁的Map结构，便于序列化为JSON
        return tasks.stream()
                .map(task -> {
                    Map<String, String> map = new HashMap<>();
                    map.put("taskId", task.getId());
                    map.put("taskName", task.getName());
                    map.put("processInstanceId", task.getProcessInstanceId());
                    // 也可以从流程变量中获取业务信息展示给审批人
                    // Map<String, Object> processVariables = taskService.getVariables(task.getId());
                    // map.put("applicant", (String) processVariables.get("initiator"));
                    // map.put("amount", String.valueOf(processVariables.get("amount")));
                    return map;
                })
                .collect(Collectors.toList());
    }

    /**
     * 完成一个审批任务 (如经理审批, 总监审批, 财务复核)。
     *
     * @param taskId   要完成的任务的ID。
     * @param approved 审批结果 (true=通过, false=驳回)。
     */
    @Transactional
    public void completeTask(String taskId, Boolean approved) {
        // 准备流程变量，用于驱动审批网关的走向
        Map<String, Object> variables = new HashMap<>();
        // 'approved' 是我们在BPMN中定义的审批结果变量 (e.g., ${approved == true})
        variables.put("approved", approved);
        // 完成任务，Flowable引擎会自动根据传入的变量和BPMN定义，决定下一步流向哪里。
        taskService.complete(taskId, variables);
    }

    /**
     * 完成“修改申请单”这个特殊任务。
     *
     * @param taskId     “修改申请单”任务的ID。
     * @param newAmount  (可选) 用户修改后的新金额。
     */
    @Transactional
    public void completeModifyTask(String taskId, BigDecimal newAmount) {
        // 如果用户在修改时更新了金额，我们需要将这个变化同步到流程变量中
        if (newAmount != null) {
            // 先通过taskId找到任务对象，进而获取到流程实例ID
            Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
            // 使用RuntimeService更新流程实例的'amount'变量
            runtimeService.setVariable(task.getProcessInstanceId(), "amount", newAmount.doubleValue());
        }
        // 完成修改任务，流程将根据BPMN定义自动回到之前的审批节点
        taskService.complete(taskId);
    }

    /**
     * 获取指定流程实例的执行历史记录。
     *
     * @param processInstanceId 流程实例ID
     * @return 一个包含历史活动信息的字符串列表。
     */
    public List<String> getHistory(String processInstanceId) {
        // 使用HistoryService创建一个历史活动实例查询
        return historyService.createHistoricActivityInstanceQuery()
                .processInstanceId(processInstanceId) // 按流程实例ID过滤
                .orderByHistoricActivityInstanceStartTime().asc() // 按开始时间升序排序
                .list()
                .stream()
                // 格式化输出，便于查看
                .map(activity -> String.format("【%s】(节点类型: %s) 在 %s 完成",
                        activity.getActivityName(),
                        activity.getActivityType(),
                        activity.getEndTime() != null ? activity.getEndTime() : "进行中"))
                .collect(Collectors.toList());
    }
      /**
     * 撤回流程。
     * 只有流程发起人可以撤回，且流程必须处于活动状态。
     *
     * @param processInstanceId 要撤回的流程实例ID
     * @param operatorId        操作人ID，用于权限校验
     * @param reason            撤回原因
     */
    @Transactional
    public void withdrawProcess(String processInstanceId, String operatorId, String reason) {
        // 1. 校验流程实例是否存在且处于活动状态
        ProcessInstance processInstance = runtimeService.createProcessInstanceQuery()
                .processInstanceId(processInstanceId)
                .active() // 关键：确保流程是活动的
                .singleResult();

        if (processInstance == null) {
            throw new IllegalStateException("流程不存在或已结束，无法撤回。");
        }
          // =================================================================
        // 步骤2: 【【【【【 核心修改 】】】】】
        // 从我们自己的业务表中查询申请信息，以获取发起人ID
        // =================================================================

  MoneyApplication application = applicationMapper.selectByProcessInstanceId(processInstanceId);

        if (application == null) {
            // 这是一个数据不一致的异常情况，理论上不应发生
            throw new IllegalStateException("数据异常：找不到与该流程关联的业务申请记录。");
        }

        // =================================================================
        // 步骤3: 权限校验：使用业务表中的发起人信息进行判断
        // =================================================================
        if (!application.getApplicant().equals(operatorId)) {
            throw new SecurityException("无权操作：只有流程发起人 (" + application.getApplicant() + ") 可以撤回。");
        }
        
        // 4. 删除Flowable流程实例
        // deleteProcessInstance会删除所有运行时数据，并触发PROCESS_CANCELLED事件
        // 历史记录默认是保留的
        runtimeService.deleteProcessInstance(processInstanceId, reason);

        // 5. 更新我们自己的业务表状态为“已撤回”
        applicationMapper.updateStatusByProcessInstanceId(processInstanceId, "WITHDRAWN");

        // 这里的日志可以通过全局监听器观察到 PROCESS_CANCELLED 事件
        log.info("流程已撤回: 实例ID='{}', 操作人='{}', 原因='{}'", processInstanceId, operatorId, reason);
    }


 /**
     * 获取指定任务之前的所有历史用户任务节点，作为可退回的目标。
     *
     * @param taskId 当前任务ID
     * @return 一个包含节点ID和名称的Map列表
     */
    public List<Map<String, String>> getReturnableNodes(String taskId) {
        // 1. 获取当前任务信息
        Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
        if (task == null) {
            throw new IllegalStateException("任务不存在: " + taskId);
        }

        // 2. 获取该流程实例所有已完成的历史活动节点
        List<HistoricActivityInstance> historyNodes = historyService.createHistoricActivityInstanceQuery()
                .processInstanceId(task.getProcessInstanceId())
                .finished() // 只查询已完成的
                .orderByHistoricActivityInstanceEndTime().asc() // 按时间排序
                .list();

        // 3. 过滤出用户任务节点，并且排除当前节点自身
        return historyNodes.stream()
                .filter(activity -> "userTask".equals(activity.getActivityType()) && !activity.getActivityId().equals(task.getTaskDefinitionKey()))
                .map(activity -> {
                    Map<String, String> node = new HashMap<>();
                    node.put("activityId", activity.getActivityId()); // 节点ID
                    node.put("activityName", activity.getActivityName()); // 节点名称
                    return node;
                })
                .collect(Collectors.toList());
    }
/**
 * 将任务退回到指定的历史活动节点。
 *
 * @param taskId          当前任务ID
 * @param targetActivityId 目标活动节点的ID (从getReturnableNodes获取)
 * @param reason          退回原因
 */
@Transactional
public void returnTask(String taskId, String targetActivityId, String reason) {
    // 1. 校验当前任务是否存在
    Task currentTask = taskService.createTaskQuery().taskId(taskId).singleResult();
    if (currentTask == null) {
        throw new IllegalStateException("当前任务不存在: " + taskId);
    }
    
    // 2. 使用Flowable强大的 `ChangeActivityStateBuilder` API
    // 这是实现“自由跳转”或“退回”等操作的核心
    runtimeService.createChangeActivityStateBuilder()
            .processInstanceId(currentTask.getProcessInstanceId()) // 指定流程实例
            .moveActivityIdTo(currentTask.getTaskDefinitionKey(), targetActivityId) // 将当前活动节点移动到目标节点
            // .moveExecutionToActivityId(...) 如果有并行网关会更复杂，这里用简单版
            .changeState();

    // 3. （可选但推荐）在退回后，为当前已完成的任务添加评论，说明退回原因
    taskService.addComment(taskId, currentTask.getProcessInstanceId(), "RETURN", "【退回】" + reason);

    log.info("任务已退回: 从任务ID='{}' 退回到活动ID='{}', 原因='{}'", taskId, targetActivityId, reason);
}

}

4、最后再写一下Controller

package com.example.flowabledemo.controller;

import com.example.flowabledemo.dto.StartRequest;
import com.example.flowabledemo.service.MoneyApplicationService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.math.BigDecimal;
import java.util.Collections;
import java.util.List;
import java.util.Map;

/**
 * @description: 资金申请流程的RESTful API接口。
 * 这是暴露给前端或第三方系统调用的入口，负责接收HTTP请求并将其委托给Service层处理。
 */
@RestController
@RequestMapping("/api/process") // 所有接口的基础路径
public class MoneyApplicationController {

    @Autowired
    private MoneyApplicationService moneyApplicationService;

    /**
     * API: 启动一个新的资金申请流程。
     *
     * @param request 包含申请人、事由和金额的JSON请求体。
     * @return 包含新创建的流程实例ID的JSON响应。
     * @example POST /api/process/start
     *          Body: {"applicant": "zhangsan", "reason": "购买办公用品", "amount": 5000}
     */
    @PostMapping("/start")
    public ResponseEntity<Map<String, String>> startProcessInstance(@RequestBody StartRequest request) {
        String processInstanceId = moneyApplicationService.startProcess(
            request.getApplicant(), 
            request.getReason(), 
            request.getAmount()
        );
        // 返回一个包含流程实例ID的JSON对象，状态码200 OK
        return ResponseEntity.ok(Collections.singletonMap("processInstanceId", processInstanceId));
    }

    /**
     * API: 获取指定用户的待办任务列表。
     *
     * @param assignee 用户的ID。
     * @return 任务列表的JSON数组。
     * @example GET /api/process/tasks?assignee=manager
     */
    @GetMapping("/tasks")
    public ResponseEntity<List<Map<String, String>>> getTasks(@RequestParam String assignee) {
        return ResponseEntity.ok(moneyApplicationService.getTasks(assignee));
    }

    /**
     * API: 完成一个审批任务 (通过或驳回)。
     *
     * @param taskId   任务ID
     * @param approved 审批结果 (true/false)
     * @return 成功时返回200 OK，无响应体。
     * @example POST /api/process/approve?taskId=12345&approved=true
     */
    @PostMapping("/approve")
    public ResponseEntity<Void> approveTask(@RequestParam String taskId, @RequestParam Boolean approved) {
        moneyApplicationService.completeTask(taskId, approved);
        return ResponseEntity.ok().build();
    }
    
    /**
     * API: 提交修改后的申请单。
     *
     * @param taskId     “修改申请单”任务的ID
     * @param newAmount (可选) 修改后的金额
     * @return 成功时返回200 OK，无响应体。
     * @example POST /api/process/modify?taskId=67890&newAmount=9500
     */
    @PostMapping("/modify")
    public ResponseEntity<Void> modifyTask(@RequestParam String taskId, @RequestParam(required = false) BigDecimal newAmount) {
        moneyApplicationService.completeModifyTask(taskId, newAmount);
        return ResponseEntity.ok().build();
    }
    
    /**
     * API: 查看指定流程实例的执行历史。
     *
     * @param processInstanceId 流程实例ID
     * @return 历史记录的JSON数组。
     * @example GET /api/process/history/abcdef-12345
     */
    @GetMapping("/history/{processInstanceId}")
    public ResponseEntity<List<String>> getHistory(@PathVariable String processInstanceId) {
        return ResponseEntity.ok(moneyApplicationService.getHistory(processInstanceId));
    }
    /**
 * API: 撤回流程。
 *
 * @param processInstanceId 流程实例ID
 * @param operatorId        操作人ID (模拟登录用户)
 * @param reason            撤回原因
 * @return 成功时返回200 OK
 * @example POST /api/process/withdraw?processInstanceId=12345&operatorId=zhangsan&reason=信息填写错误
 */
@PostMapping("/withdraw")
public ResponseEntity<Void> withdrawProcess(
        @RequestParam String processInstanceId,
        @RequestParam String operatorId,
        @RequestParam String reason) {
    moneyApplicationService.withdrawProcess(processInstanceId, operatorId, reason);
    return ResponseEntity.ok().build();
}
/**
 * API: 获取可退回的历史节点列表。
 *
 * @param taskId 当前任务ID
 * @return 节点列表
 * @example GET /api/process/returnable-nodes?taskId=12345
 */
@GetMapping("/returnable-nodes")
public ResponseEntity<List<Map<String, String>>> getReturnableNodes(@RequestParam String taskId) {
    return ResponseEntity.ok(moneyApplicationService.getReturnableNodes(taskId));
}

/**
 * API: 执行退回操作。
 *
 * @param taskId          当前任务ID
 * @param targetActivityId 目标节点ID
 * @param reason          退回原因
 * @return 成功时返回200 OK
 * @example POST /api/process/return?taskId=12345&targetActivityId=task_manager_approval&reason=审批意见不明确
 */
@PostMapping("/return")
public ResponseEntity<Void> returnTask(
        @RequestParam String taskId,
        @RequestParam String targetActivityId,
        @RequestParam String reason) {
    moneyApplicationService.returnTask(taskId, targetActivityId, reason);
    return ResponseEntity.ok().build();
}
}

当然也可以加上一个监听器来控制一下日志的输出或者根据业务干一些其他的事情。

package com.example.flowabledemo.listener;

import org.flowable.common.engine.api.delegate.event.FlowableEngineEntityEvent;
import org.flowable.common.engine.api.delegate.event.FlowableEvent;
import org.flowable.common.engine.api.delegate.event.FlowableEventListener;
import org.flowable.engine.delegate.event.impl.FlowableActivityEventImpl;
import org.flowable.task.api.Task;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @description: 全局Flowable事件监听器，用于记录详细的流程日志。
 * 实现了FlowableEventListener接口，可以捕获引擎触发的所有事件。
 * 这是一个非常强大的工具，用于审计、监控和调试。
 */
public class FlowableGlobalEventListener implements FlowableEventListener {

    // 获取一个SLF4J的Logger实例，用于记录日志
    private static final Logger log = LoggerFactory.getLogger(FlowableGlobalEventListener.class);

    @Override
    public void onEvent(FlowableEvent event) {
        // 使用switch语句根据事件类型进行不同的处理
        switch (event.getType()) {

            // 流程启动事件
            case PROCESS_STARTED:
                log.info("▶▶▶ 流程启动: 流程实例ID='{}', 流程定义ID='{}'",
                        event.getExecution().getProcessInstanceId(),
                        event.getExecution().getProcessDefinitionId());
                break;

            // 流程完成事件
            case PROCESS_COMPLETED:
                log.info("◀◀◀ 流程结束: 流程实例ID='{}', 流程定义ID='{}'",
                        event.getExecution().getProcessInstanceId(),
                        event.getExecution().getProcessDefinitionId());
                break;

            // 流程取消事件
            case PROCESS_CANCELLED:
                log.info("◀◀◀ 流程取消: 流程实例ID='{}'", event.getExecution().getProcessInstanceId());
                break;

            // 一个活动（流程中的一个节点）开始
            case ACTIVITY_STARTED:
                FlowableActivityEventImpl activityStartedEvent = (FlowableActivityEventImpl) event;
                log.info("    → 活动开始: ID='{}', 名称='{}', 类型='{}'",
                        activityStartedEvent.getActivityId(),
                        activityStartedEvent.getActivityName(),
                        activityStartedEvent.getActivityType());
                break;

            // 一个活动（流程中的一个节点）完成
            case ACTIVITY_COMPLETED:
                FlowableActivityEventImpl activityCompletedEvent = (FlowableActivityEventImpl) event;
                log.info("    ← 活动完成: ID='{}', 名称='{}', 类型='{}'",
                        activityCompletedEvent.getActivityId(),
                        activityCompletedEvent.getActivityName(),
                        activityCompletedEvent.getActivityType());
                break;

            // 一个用户任务被创建
            case TASK_CREATED:
                FlowableEngineEntityEvent taskCreatedEvent = (FlowableEngineEntityEvent) event;
                Task task = (Task) taskCreatedEvent.getEntity();
                log.info("        ◈ 任务创建: 任务ID='{}', 任务名称='{}', 办理人='{}'",
                        task.getId(),
                        task.getName(),
                        task.getAssignee());
                break;

            // 一个用户任务被分配给某人
            case TASK_ASSIGNED:
                 FlowableEngineEntityEvent taskAssignedEvent = (FlowableEngineEntityEvent) event;
                 Task assignedTask = (Task) taskAssignedEvent.getEntity();
                 log.info("        ◈ 任务分配: 任务ID='{}', 任务名称='{}', 新办理人='{}'",
                         assignedTask.getId(),
                         assignedTask.getName(),
                         assignedTask.getAssignee());
                break;

            // 一个用户任务被完成
            case TASK_COMPLETED:
                FlowableEngineEntityEvent taskCompletedEvent = (FlowableEngineEntityEvent) event;
                Task completedTask = (Task) taskCompletedEvent.getEntity();
                log.info("        ✔ 任务完成: 任务ID='{}', 任务名称='{}', 办理人='{}'",
                        completedTask.getId(),
                        completedTask.getName(),
                        completedTask.getAssignee());
                break;

            default:
                // 对于其他不关心的事件，可以忽略
                // log.debug("捕获到其他事件: {}", event.getType());
        }
    }

    @Override
    public boolean isFailOnException() {
        // 当监听器中的逻辑抛出异常时，是否希望它影响主流程的事务。
        // false表示即使日志记录失败，也不要回滚主流程。这对于非关键的日志记录是安全的。
        return false;
    }

    @Override
    public boolean isFireOnTransactionLifecycleEvent() {
        // 这个监听器是否应该在事务生命周期的特定点触发。
        // null表示使用引擎的默认设置。
        return false;
    }

    @Override
    public String getOnTransaction() {
        // 指定监听器应该在哪个事务状态下触发。
        // null表示使用引擎的默认设置。
        return null;
    }
}

然后将其注册到流程引擎中去

package com.example.flowabledemo.config;

import com.example.flowabledemo.listener.FlowableGlobalEventListener;
import org.flowable.engine.RuntimeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;

import javax.annotation.PostConstruct;

/**
 * @description: Flowable配置类，用于在应用启动后进行额外的配置，如此处的监听器注册。
 */
@Configuration
public class FlowableListenerConfiguration {

    // 注入Flowable的RuntimeService，我们需要用它来添加监听器
    @Autowired
    private RuntimeService runtimeService;

    /**
     * 使用@PostConstruct注解，这个方法会在Spring容器完成所有bean的初始化之后自动执行。
     * 这是注册全局监听器的理想时机。
     */
    @PostConstruct
    public void addGlobalEventListener() {
        // 向Flowable引擎添加一个全局事件监听器。
        // 从现在开始，引擎触发的任何事件都会通知这个监听器。
        runtimeService.addEventListener(new FlowableGlobalEventListener());
        System.out.println("Flowable全局日志监听器已成功注册!");
    }
}

到这就完事了，目前功能只是简单的操作，基本可以完成大部分线性业务。

flowable-bpmn---idea的插件--超级好用
09-07
"flowable-bpmn---idea的插件"正是这样一个工具，旨在提升Flowable BPMN流程设计在IntelliJ IDEA中的体验。 这个插件的安装和使用非常简单，只需在IDEA的插件市场中搜索“flowable”即可找到并安装。安装完成后，...
flowable-designer-5.22.rar
06-25
和一个flowable-designer的zip包 emf的包 安装好eclipse后，把三个emf的jar包拷贝到eclipse的plugin目录下 比如，我电脑的目录是：/Applications/Eclipse oxygen.app/Contents/Eclipse/plugins/ 三个jar包分别是： ...
【企业经营管理】企业内部控制
weixin_49199313的博客
06-22 892
​：COSO ERM的本质是 ​。
基于RuoYi-vue和flowable 6.x的流程管理平台设计源码
09-26
基于RuoYi-vue和flowable 6.x构建的流程管理解决方案源码，是一款全面集成的业务流程管理平台。它采用Java语言编写，利用RuoYi-vue作为前端展示框架，并以flowable 6.x作为工作流引擎，实现了流程设计、监控、任务...
flowable-bpmn-intellij-plugin:可流动的Activiti（6.x）BPMN引擎IntelliJ的流程编辑器插件
05-04
除*.bpmn20.xml扩展名外，还支持*.xml 为了阐明当专用建模者仅支持*.bpmn20.xml时，如何将*.xml用于BPMN图以及为什么将其用于BPMN图，请在此*.bpmn20.xml添加... BPMN流程“调试”，允许直接在插件中查看最新流程执行
资源从官网下载的【flowable-7.1.0.zip】资源
04-18
资源从官网下载的【flowable-7.1.0.zip】资源
Spring Boot 集成 Dufs 通过 WebDAV 实现文件管理
weixin_45626288的博客
07-01 851
本文介绍了在Spring Boot中集成Dufs文件服务器通过WebDAV协议实现文件管理的方法。主要内容包括：添加Sardine WebDAV客户端依赖，配置Dufs连接参数，实现文件上传下载功能（支持多种下载方式），以及目录列表查询。文章提供了完整的配置类和服务层实现代码，其中文件下载特别设计了三种方案：ByteArrayResource适合小文件、StreamingResponseBody适合大文件、以及推荐的AbstractResource实现。通过WebDAV协议，开发者可以方便地在Spring
Spring Boot 集成 MinIO 实现分布式文件存储与管理
weixin_45626288的博客
07-02 558
Spring Boot集成MinIO实现文件存储方案 本文介绍了如何在Spring Boot项目中集成MinIO分布式对象存储服务。MinIO是一个高性能、兼容S3 API的开源存储方案，具有轻量级、易部署等特点。 实现步骤： 添加MinIO Java SDK依赖 配置MinIO连接参数 创建MinioClient Bean 实现文件服务类，包含： 存储桶管理（创建、检查、列出） 文件上传下载 文件删除 获取文件URL 自动生成唯一文件名等功能 该方案提供了一套完整的文件存储管理实现，可用于企业级应用的分布
Spring Boot项目开发实战销售管理系统——数据库设计！
IT_1024的博客
06-29 919
基于以上的系统设计和需求分析进行数据库设计。数据库设计是将应用涉及的数据实体与这些数据实体之间的关系进行规划和结构化的过程。数据库设计分以下几个步骤：（1）收集信息。创建数据库之前，必须充分理解项目的需求，了解数据库需要存储哪些数据、实现哪些功能。（2）设计数据库的表实体。收集信息后，标识数据库要管理的关键对象或数据库表实体。（3）设计每个表需要存储的详细信息。数据库中的主要表实体标示为表以后，就要设计每个表存储的详细信息，也称为表的属性，这些属性将组成表中的字段。（4）标识实体之间的关系。
基于Spring Boot + MyBatis-Plus + Thymeleaf的评论管理系统深度解析
你羡慕的生活都是你没熬过的苦。
07-03 529
本系统通过Spring Boot + MyBatis-Plus + Thymeleaf的技术组合，构建了一个高效、安全的博客评论管理系统。动态SQL与分页优化：通过MyBatis-Plus的简化条件构造，结合分页插件提升查询性能。响应式布局：基于媒体查询和Flex布局，实现PC与移动端的无缝切换。批量操作与事务安全：通过MyBatis-Plus的批量API和Spring的事务管理，保证数据一致性。多层安全防护：输入验证、XSS过滤、CSRF防护构建全方位安全体系。
Spring Boot 多 ActiveMQ 通道配置与多连接消息发送实战（含完整示例与踩坑记录）
m0_46421522的博客
07-03 704
本文详细介绍了如何在Spring Boot项目中配置多个ActiveMQ连接通道并实现消息发送。主要内容包括：单ActiveMQ基础配置、多实例独立配置、多JmsMessagingTemplate注入使用、多队列定义等核心实现。文章还针对常见的NoUniqueBeanDefinitionException和Could not resolve placeholder异常提供了解决方案。该项目适用于多业务系统对接不同MQ、数据需同时发送到多个MQ等场景，实现了不同MQ消息分发功能。
Spring Boot 高并发框架实现方案：数字城市的奇妙之旅
hugejiletuhugejiltu的博客
07-02 1069
本文以数字城市为比喻，形象化地介绍了Spring Boot高并发框架的实现方案。首先，通过服务器配置和数据库连接池构建城市基础设施；其次，利用异步处理和线程池实现高效任务调度；第三，通过Sentinel限流和熔断机制保障系统安全；第四，借助Redis缓存提升数据访问效率；第五，采用分布式锁保护共享资源；最后，基于Actuator实现性能监控与调优。每个技术组件都被生动比喻为城市的不同功能模块，共同构建了一个稳定高效的高并发处理系统。
解决 Spring Boot 对 Elasticsearch 字段没有小驼峰映射的问题
m0_72945550的博客
07-03 542
本文针对用户处理Elasticsearch时字段命名不一致问题，提出五种解决方案：1）使用ObjectMapper手动转换字段命名（推荐）；2）利用Elasticsearch 7.0+的field_alias功能；3）自定义ES客户端（不推荐）；4）通过DTO类+@JsonProperty注解映射；5）使用第三方插件（不推荐）。建议优先考虑field_alias或ObjectMapper方案，前者最优雅但需版本支持，后者灵活易用；DTO注解适合固定数据结构场景。
【Java21】在spring boot中使用ScopedValue
qq_45362415的博客
07-03 813
本文介绍了Java 21预览功能ScopedValue在Spring Boot Web项目中的应用。ScopedValue具有不可变性和作用域限制的特点，适合在虚拟线程环境中替代ThreadLocal。文章通过具体示例演示了如何配置Maven启用预览功能，并实现通过HTTP过滤器将请求头信息存入ScopedValue上下文，在Controller和Service层读取该上下文数据。测试结果表明，ScopedValue能有效传递上下文信息，且在虚拟线程环境下同样适用。代码示例已开源在GitHub上。
Spring Boot 集成 GeoTools 详解
hugejiletuhugejiltu的博客
07-02 538
什么是 Spring Boot？Spring Boot 是由 Pivotal 团队开发的基于 Spring 框架的快速开发工具，它通过自动配置、起步依赖等特性简化了 Java 应用的搭建和开发过程，使开发者能够专注于业务逻辑而非配置细节。什么是 GeoTools？
Spring Boot 应用开发实战指南：从入门到实战（内含实用技巧+项目案例）
yiridancan的博客
06-27 871
Spring Boot 是 Spring 团队推出的快速开发框架，简化了传统 Spring 应用的开发和部署流程，具备以下几个特点： 🌱 零配置启动：通过约定优于配置，大幅减少样板代码。 ⚡ 内嵌容器：无需部署到 Tomcat，可直接运行。 🔌 自动配置：根据类路径中的类自动配置 Bean。 📦 丰富的 Starter：快速引入常用依赖，如 spring-boot-starter-web、spring-boot-starter-data-jpa 等。 🧪 天然支持测试与监控。
spring boot如何只修改配置文件就解决swagger漏洞
最新发布
爱米酱的博客
07-03 52
【代码】spring boot如何只修改配置文件就解决swagger漏洞。
Spring Boot + Screw 一键生成数据库设计文档
weixin_46619605的博客
07-03 646
Spring Boot + Screw 一键生成数据库设计文档
分布式锁实现方式：基于Redis的分布式锁实现（Spring Boot + Redis）
weixin_43833540的博客
07-01 176
Spring Boot中使用Redis实现分布式锁。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值