代码优化！

2026-04-29 19:18:07 +08:00
parent bc045fbe58
commit 7eec0e5b32
9 changed files with 226 additions and 381 deletions
@@ -3,8 +3,12 @@ package com.example.workutils.demo.disburse.enums;
 import lombok.AllArgsConstructor;
 import lombok.Getter;

+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
 /**
- * @Description: 放款操作规则枚举
+ * @Description: 放款操作规则枚举（决策表）
 * @Author:zhaoyuhang
 * @Date: 2026/4/28
 **/
@@ -13,83 +17,156 @@ import lombok.Getter;
 public enum DisburseActionRuleEnum {

    /**
-     * 提交
+     * 挂起：初始化/待确认/待审核 + 未挂起 → 挂起标识置true，状态不变
+     *
+     * 操作：挂起
+     * 允许操作的放款状态：初始化、待确认、
     */
-    COMMIT(DisburseActionEnum.COMMIT, StateTransitionStrategyEnum.DISBURSE_TRANSITION_STRATEGY, false, false, true),
+    SUSPEND(DisburseActionEnum.SUSPEND,
+            Arrays.asList(DisburseStateEnum.INIT,
+                    DisburseStateEnum.PENDING_CONFIRM,
+                    DisburseStateEnum.PENDING_AUDIT),
+            false,
+            null,
+            null,
+            null,
+            "初始化/待确认/待审核可挂起"),

    /**
-     * 确认
+     * 挂起恢复：已挂起 → 挂起标识置false，状态不变
     */
-    CONFIRM(DisburseActionEnum.CONFIRM, StateTransitionStrategyEnum.DISBURSE_TRANSITION_STRATEGY, false, false, null),
+    SUSPEND_RESUME(DisburseActionEnum.SUSPEND_RESUME,
+            null,
+            true,
+            null,
+            null,
+            null,
+            "已挂起可恢复"),

    /**
-     * 审核
+     * 提交：初始化 + 未挂起 + 未撤销 + 已达到冷静期 → 待确认
     */
-    AUDIT(DisburseActionEnum.AUDIT, StateTransitionStrategyEnum.DISBURSE_TRANSITION_STRATEGY, false, false, null),
+    COMMIT(DisburseActionEnum.COMMIT,
+            Arrays.asList(DisburseStateEnum.INIT),
+            false,
+            false,
+            true,
+            DisburseStateEnum.PENDING_CONFIRM,
+            "全部条件必须满足"),

    /**
-     * 放款成功
+     * 确认：待确认 + 未挂起 + 未撤销 → 待审核
     */
-    DISBURSE_SUCCESS(DisburseActionEnum.DISBURSE_SUCCESS, StateTransitionStrategyEnum.DISBURSE_TRANSITION_STRATEGY,
-            null, null, null),
+    CONFIRM(DisburseActionEnum.CONFIRM,
+            Arrays.asList(DisburseStateEnum.PENDING_CONFIRM),
+            false,
+            false,
+            null,
+            DisburseStateEnum.PENDING_AUDIT,
+            "全部条件必须满足"),

    /**
-     * 放款失败
+     * 审核：待审核 + 未挂起 + 未撤销 → 放款中
     */
-    DISBURSE_FAIL(DisburseActionEnum.DISBURSE_FAIL, StateTransitionStrategyEnum.DISBURSE_TRANSITION_STRATEGY,
-            null, null, null),
+    AUDIT(DisburseActionEnum.AUDIT,
+            Arrays.asList(DisburseStateEnum.PENDING_AUDIT),
+            false,
+            false,
+            null,
+            DisburseStateEnum.DISBURSING,
+            "全部条件必须匹配"),

    /**
-     * 挂起
+     * 放款成功：放款中 → 放款成功
     */
-    SUSPEND(DisburseActionEnum.SUSPEND, StateTransitionStrategyEnum.SUSPEND_TRANSITION_STRATEGY, false, null, null),
+    DISBURSE_SUCCESS(DisburseActionEnum.DISBURSE_SUCCESS,
+            Arrays.asList(DisburseStateEnum.DISBURSING),
+            null,
+            null,
+            null,
+            DisburseStateEnum.DISBURSE_SUCCESS,
+            "放款中→放款成功"),

    /**
-     * 挂起恢复
+     * 放款失败：放款中 → 放款失败
     */
-    SUSPEND_RESUME(DisburseActionEnum.SUSPEND_RESUME, StateTransitionStrategyEnum.SUSPEND_TRANSITION_STRATEGY,
-            true, null, null),
+    DISBURSE_FAIL(DisburseActionEnum.DISBURSE_FAIL,
+            Arrays.asList(DisburseStateEnum.DISBURSING),
+            null,
+            null,
+            null,
+            DisburseStateEnum.DISBURSE_FAILED,
+            "放款中→放款失败"),

    /**
-     * 撤销
+     * 撤销（放款前）：初始化/待确认/待审核 + 未撤销 → 放款失败
     */
-    REVOKE(DisburseActionEnum.REVOKE, StateTransitionStrategyEnum.REVOKE_TRANSITION_STRATEGY, null, false, null);
+    REVOKE_BEFORE_DISBURSE(DisburseActionEnum.REVOKE,
+            Arrays.asList(DisburseStateEnum.INIT, DisburseStateEnum.PENDING_CONFIRM, DisburseStateEnum.PENDING_AUDIT),
+            null,
+            false,
+            null,
+            DisburseStateEnum.DISBURSE_FAILED,
+            "未发起交易前撤销直接阻止放款"),
+
+    /**
+     * 撤销（放款后）：放款中/放款成功 + 未撤销 → 状态不变
+     */
+    REVOKE_AFTER_DISBURSE(DisburseActionEnum.REVOKE,
+            Arrays.asList(DisburseStateEnum.DISBURSING, DisburseStateEnum.DISBURSE_SUCCESS),
+            null,
+            false,
+            null,
+            null,
+            "发起结算后轧差处理"),
+
+    ;

    /**
     * 放款操作枚举
     */
-    private DisburseActionEnum disburseActionEnum;
+    private final DisburseActionEnum disburseActionEnum;

    /**
-     * 状态流转策略枚举
+     * 允许的当前放款状态列表，null表示任意状态
     */
-    private StateTransitionStrategyEnum stateTransitionStrategy;
+    private final List<DisburseStateEnum> allowDisburseStates;

    /**
-     * 要求挂起状态标识
-     * false:未挂起，true：已挂起
+     * 期望挂起状态
+     * false:未挂起，true：已挂起，null：不检查
     */
-    public Boolean requireSuspendFlag;
+    private final Boolean expectSuspended;

    /**
-     * 要求撤销状态标识
-     * false:未撤销，true：已撤销
+     * 期望撤销状态
+     * false:未撤销，true：已撤销，null：不检查
     */
-    public Boolean requireRevokeFlag;
+    private final Boolean expectRevoked;

    /**
-     * 要求达到冷静期标识
-     * false:未达到冷静期，true：已达到冷静期
+     * 期望达到冷静期
+     * false:未达到冷静期，true：已达到冷静期，null：不检查
     */
-    public Boolean requireCoolingReachedFlag;
+    private final Boolean expectCoolingReached;
+
+    /**
+     * 目标放款状态，null表示保持当前状态不变
+     */
+    private final DisburseStateEnum targetDisburseState;
+
+    /**
+     * 约束说明
+     */
+    private final String constraintDesc;


-    public static DisburseActionRuleEnum getDisburseActionValidateEnum(DisburseActionEnum disburseActionEnum){
-        for (DisburseActionRuleEnum ruleEnum : DisburseActionRuleEnum.values()) {
-            if (ruleEnum.getDisburseActionEnum().equals(disburseActionEnum)){
-                return ruleEnum;
-            }
-        }
-        return null;
+    /**
+     * 根据操作枚举获取匹配的规则列表（同一操作可能有多条规则）
+     */
+    public static List<DisburseActionRuleEnum> getRulesByAction(DisburseActionEnum action) {
+        return Arrays.stream(values())
+                .filter(rule -> rule.getDisburseActionEnum() == action)
+                .collect(Collectors.toList());
    }
 }
@@ -1,69 +0,0 @@
-package com.example.workutils.demo.disburse.enums;
-
-import lombok.AllArgsConstructor;
-import lombok.Getter;
-
-/**
- * @Description:放款状态流转规则枚举
- * @Author:zhaoyuhang
- * @Date: 2026/4/28
- **/
-@Getter
-@AllArgsConstructor
-public enum DisburseStateTransitionRuleEnum {
-
-    /**
-     * 提交操作状态流转规则
-     */
-    COMMIT_STATE_TRANSITION_RULE(DisburseActionEnum.COMMIT, DisburseStateEnum.INIT, DisburseStateEnum.PENDING_CONFIRM),
-
-    /**
-     * 确认操作状态流转规则
-     */
-    CONFIRM_STATE_TRANSITION_RULE(DisburseActionEnum.CONFIRM, DisburseStateEnum.PENDING_CONFIRM,
-            DisburseStateEnum.PENDING_AUDIT),
-
-    /**
-     * 审核操作状态流转规则
-     */
-    AUDIT_STATE_TRANSITION_RULE(DisburseActionEnum.AUDIT,DisburseStateEnum.PENDING_AUDIT, DisburseStateEnum.DISBURSING),
-
-    /**
-     * 放款成功操作状态流转规则
-     */
-    DISBURSE_SUCCESS_STATE_TRANSITION_RULE(DisburseActionEnum.DISBURSE_SUCCESS, DisburseStateEnum.DISBURSING,
-            DisburseStateEnum.DISBURSE_SUCCESS),
-
-    /**
-     * 放款失败操作状态流转规则
-     */
-    DISBURSE_FAIL_STATE_TRANSITION_RULE(DisburseActionEnum.DISBURSE_FAIL, DisburseStateEnum.DISBURSING,
-            DisburseStateEnum.DISBURSE_FAILED),
-    ;
-
-    /**
-     * 放款操作枚举
-     */
-    private DisburseActionEnum disburseActionEnum;
-
-    /**
-     * 允许放款状态
-     */
-    private DisburseStateEnum allowDisburseState;
-
-    /**
-     * 目标放款状态
-     */
-    private DisburseStateEnum targetDisburseState;
-
-
-    public static DisburseStateTransitionRuleEnum getDisburseActionRule(DisburseActionEnum disburseActionEnum){
-        for (DisburseStateTransitionRuleEnum ruleEnum : DisburseStateTransitionRuleEnum.values()) {
-            if (ruleEnum.getDisburseActionEnum().equals(disburseActionEnum)){
-                return ruleEnum;
-            }
-        }
-        return null;
-    }
-
-}
@@ -1,24 +0,0 @@
-package com.example.workutils.demo.disburse.enums;
-
-import lombok.AllArgsConstructor;
-import lombok.Getter;
-
-/**
- * @Description: 状态流转策略枚举
- * @Author:zhaoyuhang
- * @Date: 2026/4/29
- **/
-@Getter
-@AllArgsConstructor
-public enum StateTransitionStrategyEnum {
-
-    DISBURSE_TRANSITION_STRATEGY("放款状态流转规则策略"),
-
-    SUSPEND_TRANSITION_STRATEGY("挂起状态流转规则策略"),
-
-    REVOKE_TRANSITION_STRATEGY("撤销状态流转规则策略"),
-    ;
-
-    private String desc;
-
-}
@@ -4,11 +4,10 @@ import com.example.workutils.demo.disburse.bo.StateTransitionResult;
 import com.example.workutils.demo.disburse.context.DisburseStatusTransitionContext;
 import com.example.workutils.demo.disburse.enums.DisburseActionEnum;
 import com.example.workutils.demo.disburse.enums.DisburseActionRuleEnum;
-import com.example.workutils.demo.disburse.executor.service.StateTransitionRule;
+import com.example.workutils.demo.disburse.enums.DisburseStateEnum;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Component;

-import javax.annotation.Resource;
 import java.util.List;

 /**
@@ -20,39 +19,124 @@ import java.util.List;
@Component
 public class StateTransitionExecutor {

-    @Resource
-    private List<StateTransitionRule> stateTransitionRules;
-

    public StateTransitionResult transitionState(DisburseStatusTransitionContext context, DisburseActionEnum action) {
-        //根据操作匹配处理规则
-        DisburseActionRuleEnum disburseActionRuleEnum = DisburseActionRuleEnum.getDisburseActionValidateEnum(action);
-        if (disburseActionRuleEnum == null){
+        // 1. 查找该操作的所有规则
+        List<DisburseActionRuleEnum> rules = DisburseActionRuleEnum.getRulesByAction(action);
+        if (rules.isEmpty()) {
            log.error("放款操作未命中任何决策规则，放款操作：{}不合法!", action.name());
            return StateTransitionResult.deny("放款操作未命中任何决策规则!");
        }

-        //根据处理规则匹配处理策略
-        StateTransitionRule decisionRule = stateTransitionRules.stream()
-                .filter(filter -> filter.getStateDecisionRule().equals(
-                        disburseActionRuleEnum.getStateTransitionStrategy().name()))
-                .findFirst().orElse(null);
-        if (decisionRule == null) {
-            log.error("操作处理规则未命中任何决策处理策略，操作规则：{}不合理!",
-                    disburseActionRuleEnum.getStateTransitionStrategy().name());
-            return StateTransitionResult.deny("操作处理规则未命中任何决策处理策略");
+        // 2. 前置条件检查（挂起/撤销/冷静期），同一操作的所有规则前置条件一致，取第一条校验即可
+        DisburseActionRuleEnum referenceRule = rules.get(0);
+        StateTransitionResult preCheckResult = checkPreConditions(context, referenceRule);
+        if (preCheckResult != null) {
+            return preCheckResult;
        }

-        //执行处理策略
-        StateTransitionResult result = decisionRule.execute(context, disburseActionRuleEnum);
-        if (result == null) {
-            log.error("执行操作决策结果为空！");
-            return StateTransitionResult.deny("执行操作决策结果为空");
+        // 3. 状态匹配：遍历规则，找到allowDisburseStates匹配的规则
+        for (DisburseActionRuleEnum rule : rules) {
+            if (isStateAllowed(rule, context.getCurrentDisburseState())) {
+                return executeRule(context, rule);
+            }
        }

-        //TODO 是否修改Context参数
-        context.setCurrentDisburseState(result.getTransitionAfterState());
-        return result;
+        // 4. 无匹配规则 → 拒绝
+        return handleNoMatchedRule(context, action);
    }

+    /**
+     * 前置条件检查：挂起/撤销/冷静期
+     */
+    private StateTransitionResult checkPreConditions(DisburseStatusTransitionContext context,
+                                                     DisburseActionRuleEnum rule) {
+        // 挂起状态检查
+        if (rule.getExpectSuspended() != null
+                && !rule.getExpectSuspended().equals(context.isSuspendedFlag())) {
+            log.info("期望挂起状态：{}，实际挂起状态：{}，状态不可推进！",
+                    rule.getExpectSuspended(), context.isSuspendedFlag());
+            return context.isSuspendedFlag()
+                    ? StateTransitionResult.deny("挂起时不可推进")
+                    : StateTransitionResult.deny("未挂起不可执行该操作");
+        }
+
+        // 撤销状态检查
+        if (rule.getExpectRevoked() != null
+                && !rule.getExpectRevoked().equals(context.isRevokeFlag())) {
+            log.info("期望撤销状态：{}，实际撤销状态：{}，状态不可推进！",
+                    rule.getExpectRevoked(), context.isRevokeFlag());
+            return context.isRevokeFlag()
+                    ? StateTransitionResult.deny("撤销后不可推进")
+                    : StateTransitionResult.deny("未撤销不可执行该操作");
+        }
+
+        // 冷静期检查
+        if (rule.getExpectCoolingReached() != null
+                && !rule.getExpectCoolingReached().equals(context.isCoolingReachedFlag())) {
+            log.info("期望达到冷静期：{}，实际达到冷静期状态：{}，冷静期未到！",
+                    rule.getExpectCoolingReached(), context.isCoolingReachedFlag());
+            return StateTransitionResult.deny("冷静期未到");
+        }
+
+        return null;
+    }
+
+    /**
+     * 判断当前状态是否在规则的允许状态列表中
+     */
+    private boolean isStateAllowed(DisburseActionRuleEnum rule, DisburseStateEnum currentState) {
+        return rule.getAllowDisburseStates() == null
+                || rule.getAllowDisburseStates().contains(currentState);
+    }
+
+    /**
+     * 执行匹配的规则，计算目标状态
+     */
+    private StateTransitionResult executeRule(DisburseStatusTransitionContext context,
+                                              DisburseActionRuleEnum rule) {
+        DisburseStateEnum targetState = rule.getTargetDisburseState() != null
+                ? rule.getTargetDisburseState()
+                : context.getCurrentDisburseState();
+
+        // 目标挂起标识从操作类型推导：SUSPEND→true，SUSPEND_RESUME→false，其余保持当前
+        Boolean targetSuspended = resolveTargetSuspended(context, rule.getDisburseActionEnum());
+
+        // 目标撤销标识从操作类型推导：REVOKE→true，其余保持当前
+        Boolean targetRevoke = rule.getDisburseActionEnum() == DisburseActionEnum.REVOKE
+                ? true
+                : context.isRevokeFlag();
+
+        return StateTransitionResult.allow(targetState, targetSuspended, targetRevoke);
+    }
+
+    /**
+     * 根据操作类型推导目标挂起标识
+     */
+    private Boolean resolveTargetSuspended(DisburseStatusTransitionContext context,
+                                           DisburseActionEnum action) {
+        if (action == DisburseActionEnum.SUSPEND) {
+            return true;
+        }
+        if (action == DisburseActionEnum.SUSPEND_RESUME) {
+            return false;
+        }
+        return context.isSuspendedFlag();
+    }
+
+    /**
+     * 无匹配规则时的拒绝处理
+     */
+    private StateTransitionResult handleNoMatchedRule(DisburseStatusTransitionContext context,
+                                                      DisburseActionEnum action) {
+        // 撤销 + 放款失败 → 特殊提示
+        if (action == DisburseActionEnum.REVOKE
+                && context.getCurrentDisburseState() == DisburseStateEnum.DISBURSE_FAILED) {
+            log.info("放款状态：{}已经放款失败，无需撤销！", context.getCurrentDisburseState());
+            return StateTransitionResult.deny("放款单据已经放款失败，无需撤销");
+        }
+
+        log.info("当前放款状态：{}不允许执行操作：{}", context.getCurrentDisburseState(), action.getDesc());
+        return StateTransitionResult.deny("当前状态不允许该操作");
+    }
 }
@@ -1,28 +0,0 @@
-package com.example.workutils.demo.disburse.executor.service;
-
-
-import com.example.workutils.demo.disburse.bo.StateTransitionResult;
-import com.example.workutils.demo.disburse.context.DisburseStatusTransitionContext;
-import com.example.workutils.demo.disburse.enums.DisburseActionRuleEnum;
-
-/**
- * @desc: 状态决策规则接口
- * @author: zhaoyuhang
- * @date: 2026-04-28 10:03:32
- */
-public interface StateTransitionRule {
-
-    /**
-     * 决策接口
-     * @param context
-     * @param ruleEnum
-     * @return
-     */
-    StateTransitionResult execute(DisburseStatusTransitionContext context, DisburseActionRuleEnum ruleEnum);
-
-    /**
-     * 获取状态决策规则
-     * @return
-     */
-    String getStateDecisionRule();
-}
@@ -1,51 +0,0 @@
-package com.example.workutils.demo.disburse.executor.service.impl;
-
-
-import com.example.workutils.demo.disburse.bo.StateTransitionResult;
-import com.example.workutils.demo.disburse.context.DisburseStatusTransitionContext;
-import com.example.workutils.demo.disburse.enums.DisburseActionRuleEnum;
-import com.example.workutils.demo.disburse.executor.service.StateTransitionRule;
-import lombok.extern.slf4j.Slf4j;
-
-
-/**
- * @desc: 抽象状态流转规则类
- * @author: zhaoyuhang
- * @date: 2026-04-28 15:12:24
- */
-@Slf4j
-public abstract class AbstractStateTransitionRule implements StateTransitionRule {
-
-
-    @Override
-    public final StateTransitionResult execute(DisburseStatusTransitionContext context,
-                                               DisburseActionRuleEnum ruleEnum) {
-        //挂起状态检查
-        if (ruleEnum.getRequireSuspendFlag() != null &&
-                !ruleEnum.getRequireSuspendFlag().equals(context.suspendedFlag)){
-            log.info("目标挂起状态：{}，实际挂起状态：{}，状态不可推进！",ruleEnum.getRequireSuspendFlag(),context.suspendedFlag);
-            return StateTransitionResult.deny("挂起时不可推进");
-        }
-
-        //撤销状态检查
-        if (ruleEnum.getRequireRevokeFlag() != null &&
-                !ruleEnum.getRequireRevokeFlag().equals(context.revokeFlag)) {
-            log.info("目标撤销状态：{}实际撤销状态：{}，状态不可推进！", ruleEnum.getRequireRevokeFlag(), context.revokeFlag);
-            return StateTransitionResult.deny("撤销后不可推进");
-        }
-
-        //冷静期检查
-        if (ruleEnum.getRequireCoolingReachedFlag() != null &&
-                !ruleEnum.getRequireCoolingReachedFlag().equals(context.coolingReachedFlag)) {
-            log.info("目标达到冷静期标识：{}，实际达到冷静期状态：{}，冷静期未到！",
-                    ruleEnum.getRequireCoolingReachedFlag(), context.coolingReachedFlag);
-            return StateTransitionResult.deny("冷静期未到");
-        }
-
-        return doEvaluate(context, ruleEnum);
-    }
-
-
-    protected abstract StateTransitionResult doEvaluate(DisburseStatusTransitionContext context,
-                                                        DisburseActionRuleEnum action);
-}
@@ -1,49 +0,0 @@
-package com.example.workutils.demo.disburse.executor.service.impl;
-
-
-import com.example.workutils.demo.disburse.bo.StateTransitionResult;
-import com.example.workutils.demo.disburse.context.DisburseStatusTransitionContext;
-import com.example.workutils.demo.disburse.enums.DisburseActionRuleEnum;
-import com.example.workutils.demo.disburse.enums.DisburseStateTransitionRuleEnum;
-import com.example.workutils.demo.disburse.enums.StateTransitionStrategyEnum;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.stereotype.Component;
-
-/**
- * @desc: 放款状态操作处理器
- * @author: zhaoyuhang
- * @date: 2026-04-29 10:39:40
- */
-@Slf4j
-@Component
-public class DisburseStateTransitionRuleStrategy extends AbstractStateTransitionRule {
-
-
-    @Override
-    public StateTransitionResult doEvaluate(DisburseStatusTransitionContext context,
-                                            DisburseActionRuleEnum actionRuleEnum) {
-        DisburseStateTransitionRuleEnum ruleEnum =
-                DisburseStateTransitionRuleEnum.getDisburseActionRule(actionRuleEnum.getDisburseActionEnum());
-        if (ruleEnum == null){
-            log.error("放款操作未匹配到放款状态流转规则！放款类型：{}", actionRuleEnum.getDisburseActionEnum().getDesc());
-            return StateTransitionResult.deny("放款操作未匹配到放款状态流转规则");
-        }
-
-        if (ruleEnum.getAllowDisburseState() != context.getCurrentDisburseState()){
-            log.error("当前放款状态与要求放款状态不匹配，无法流转状态！放款操作：{}当前放款状态：{}，要求放款状态：{}",
-                    actionRuleEnum.getDisburseActionEnum().getDesc(), context.getCurrentDisburseState(),
-                    ruleEnum.getAllowDisburseState());
-            return StateTransitionResult.deny("当前放款状态与要求放款状态不匹配,当前放款状态："+ context.getCurrentDisburseState()
-                    + "不可推进为：" + ruleEnum.getTargetDisburseState());
-        }
-
-        return StateTransitionResult.allow(ruleEnum.getTargetDisburseState(),
-                context.isSuspendedFlag(), context.isRevokeFlag());
-    }
-
-    @Override
-    public String getStateDecisionRule() {
-        return StateTransitionStrategyEnum.DISBURSE_TRANSITION_STRATEGY.name();
-    }
-
-}
@@ -1,56 +0,0 @@
-package com.example.workutils.demo.disburse.executor.service.impl;
-
-import com.example.workutils.demo.disburse.bo.StateTransitionResult;
-import com.example.workutils.demo.disburse.context.DisburseStatusTransitionContext;
-import com.example.workutils.demo.disburse.enums.DisburseActionRuleEnum;
-import com.example.workutils.demo.disburse.enums.DisburseStateEnum;
-import com.example.workutils.demo.disburse.enums.StateTransitionStrategyEnum;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.stereotype.Component;
-
-import java.util.Arrays;
-import java.util.List;
-
-/**
- * @desc: 撤销状态操作处理器
- * @author: zhaoyuhang
- * @date: 2026-04-29 10:36:34
- */
-@Slf4j
-@Component
-public class RevokeStateTransitionTransitionRuleStrategy extends AbstractStateTransitionRule {
-
-
-    private static final List<DisburseStateEnum> BEFORE_DISBURSE_STATE = Arrays.asList(
-            DisburseStateEnum.INIT,
-            DisburseStateEnum.PENDING_CONFIRM,
-            DisburseStateEnum.PENDING_AUDIT
-    );
-
-    /**
-     * 执行决策接口
-     *
-     * @param context
-     * @param ruleEnum
-     * @return
-     */
-    @Override
-    public StateTransitionResult doEvaluate(DisburseStatusTransitionContext context,
-                                            DisburseActionRuleEnum ruleEnum) {
-        if (DisburseStateEnum.DISBURSE_FAILED.name().equals(context.getCurrentDisburseState())){
-            log.info("放款状态：{}已经放款失败，无需撤销！");
-            return StateTransitionResult.deny("放款状态已经为放款失败，无需撤销");
-        }
-
-        DisburseStateEnum newStatus = BEFORE_DISBURSE_STATE.contains(context.getCurrentDisburseState())
-                ? DisburseStateEnum.DISBURSE_FAILED
-                : context.getCurrentDisburseState();
-
-        return StateTransitionResult.allow(newStatus, context.isSuspendedFlag(), true);
-    }
-
-    @Override
-    public String getStateDecisionRule() {
-        return StateTransitionStrategyEnum.REVOKE_TRANSITION_STRATEGY.name();
-    }
-}
@@ -1,39 +0,0 @@
-package com.example.workutils.demo.disburse.executor.service.impl;
-
-
-import com.example.workutils.demo.disburse.bo.StateTransitionResult;
-import com.example.workutils.demo.disburse.context.DisburseStatusTransitionContext;
-import com.example.workutils.demo.disburse.enums.DisburseActionEnum;
-import com.example.workutils.demo.disburse.enums.DisburseActionRuleEnum;
-import com.example.workutils.demo.disburse.enums.StateTransitionStrategyEnum;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.stereotype.Component;
-
-/**
- * @desc: 挂起状态操作处理器
- * @author: zhaoyuhang
- * @date: 2026-04-29 10:28:00
- */
-@Slf4j
-@Component
-public class SuspendStateTransitionTransitionRuleStrategy extends AbstractStateTransitionRule {
-
-    /**
-     * 决策接口
-     *
-     * @param context
-     * @param ruleEnum
-     * @return
-     */
-    @Override
-    public StateTransitionResult doEvaluate(DisburseStatusTransitionContext context, DisburseActionRuleEnum ruleEnum) {
-        boolean newSuspended = ruleEnum.getDisburseActionEnum() == DisburseActionEnum.SUSPEND;
-
-        return StateTransitionResult.allow(context.getCurrentDisburseState(), newSuspended, context.isRevokeFlag());
-    }
-
-    @Override
-    public String getStateDecisionRule() {
-        return StateTransitionStrategyEnum.SUSPEND_TRANSITION_STRATEGY.name();
-    }
-}