← 返回首页 📖 📖 Wiki知识库
📐 学习维度 本篇是 📖 📖 Wiki知识库 🏠 首页 🛤️ 学习路径 📚 全部文章

Java枚举与数学工具深度实战 - 七、枚举高级设计模式深度实战

本文是 Java枚举与数学工具深度实战 的分章阅读版。

七、枚举高级设计模式深度实战

枚举实现完整策略模式(消除大规模if-else)


// 企业级策略模式:支付方式策略
public interface PaymentStrategy {
    PaymentResult pay(PaymentOrder order);
    PaymentResult refund(PaymentOrder order);
    boolean supports(String channel);
}

public enum PaymentChannel implements PaymentStrategy {
    WECHAT_PAY {
        @Override
        public PaymentResult pay(PaymentOrder order) {
            // 微信支付逻辑:调用微信API
            return doWechatPay(order);
        }
        @Override
        public PaymentResult refund(PaymentOrder order) {
            return doWechatRefund(order);
        }
        @Override
        public boolean supports(String channel) {
            return "WECHAT".equalsIgnoreCase(channel);
        }
    },
    ALI_PAY {
        @Override
        public PaymentResult pay(PaymentOrder order) {
            return doAlipay(order);
        }
        @Override
        public PaymentResult refund(PaymentOrder order) {
            return doAlipayRefund(order);
        }
        @Override
        public boolean supports(String channel) {
            return "ALI".equalsIgnoreCase(channel);
        }
    },
    UNION_PAY {
        @Override
        public PaymentResult pay(PaymentOrder order) {
            return doUnionPay(order);
        }
        @Override
        public PaymentResult refund(PaymentOrder order) {
            return doUnionRefund(order);
        }
        @Override
        public boolean supports(String channel) {
            return "UNION".equalsIgnoreCase(channel);
        }
    };

    // 工厂方法:根据渠道获取策略(替代if-else分发)
    private static final PaymentChannel[] CHANNELS = values();
    public static PaymentChannel fromChannel(String channel) {
        for (PaymentChannel pc : CHANNELS) {
            if (pc.supports(channel)) return pc;
        }
        throw new BizException("不支持的支付渠道: " + channel);
    }
}

// 调用方:一行代码完成支付分发
PaymentResult result = PaymentChannel.fromChannel(channel).pay(order);

// 面试话术:"用枚举策略模式替代if-else,新增支付渠道只需加一个枚举值,
// 不需要修改调用方代码。符合开闭原则,编译期强制实现所有方法。"

枚举实现有限状态机(订单全生命周期)


// 完整的订单状态机:支持状态转换 + 动作校验 + 事件触发
public enum OrderState {
    CREATED(1, "已创建") {
        @Override
        public OrderState next(OrderEvent event, OrderContext ctx) {
            return switch (event) {
                case PAY -> {
                    ctx.recordEvent("用户支付");
                    yield PAID;
                }
                case CANCEL -> {
                    ctx.recordEvent("用户取消");
                    yield CANCELLED;
                }
                default -> throw new StateMachineException(
                    "CREATED状态只接受PAY/CANCEL,收到: " + event);
            };
        }
        @Override
        public boolean canTransitTo(OrderState target) {
            return target == PAID || target == CANCELLED;
        }
    },
    PAID(2, "已支付") {
        @Override
        public OrderState next(OrderEvent event, OrderContext ctx) {
            return switch (event) {
                case SHIP -> { ctx.recordEvent("商家发货"); yield SHIPPED; }
                case REFUND -> { ctx.recordEvent("申请退款"); yield REFUNDING; }
                default -> throw new StateMachineException(
                    "PAID状态只接受SHIP/REFUND");
            };
        }
        @Override
        public boolean canTransitTo(OrderState target) {
            return target == SHIPPED || target == REFUNDING;
        }
    },
    SHIPPED(3, "已发货") {
        @Override
        public OrderState next(OrderEvent event, OrderContext ctx) {
            if (event == OrderEvent.CONFIRM) {
                ctx.recordEvent("确认收货");
                return COMPLETED;
            }
            throw new StateMachineException("SHIPPED状态只接受CONFIRM");
        }
        @Override
        public boolean canTransitTo(OrderState target) {
            return target == COMPLETED;
        }
    },
    COMPLETED(4, "已完成") {
        @Override public OrderState next(OrderEvent e, OrderContext c) {
            throw new StateMachineException("终态,不可变更");
        }
        @Override public boolean canTransitTo(OrderState t) { return false; }
    },
    CANCELLED(5, "已取消") {
        @Override public OrderState next(OrderEvent e, OrderContext c) {
            throw new StateMachineException("终态,不可变更");
        }
        @Override public boolean canTransitTo(OrderState t) { return false; }
    },
    REFUNDING(6, "退款中") {
        @Override
        public OrderState next(OrderEvent event, OrderContext ctx) {
            return switch (event) {
                case REFUND_APPROVE -> { ctx.recordEvent("退款成功"); yield REFUNDED; }
                case REFUND_REJECT -> { ctx.recordEvent("退款驳回"); yield PAID; }
                default -> throw new StateMachineException("REFUNDING只接受REFUND_APPROVE/REJECT");
            };
        }
        @Override public boolean canTransitTo(OrderState t) {
            return t == REFUNDED || t == PAID;
        }
    },
    REFUNDED(7, "已退款") {
        @Override public OrderState next(OrderEvent e, OrderContext c) {
            throw new StateMachineException("终态,不可变更");
        }
        @Override public boolean canTransitTo(OrderState t) { return false; }
    };

    private final int code;
    private final String desc;

    OrderState(int code, String desc) { this.code = code; this.desc = desc; }
    public int getCode() { return code; }
    public String getDesc() { return desc; }

    public abstract OrderState next(OrderEvent event, OrderContext ctx);
    public abstract boolean canTransitTo(OrderState target);

    // 判断是否为终态
    public boolean isFinal() {
        return this == COMPLETED || this == CANCELLED || this == REFUNDED;
    }

    public enum OrderEvent { PAY, CANCEL, SHIP, CONFIRM, REFUND, REFUND_APPROVE, REFUND_REJECT }
}

// 面试话术:"枚举状态机让状态转换规则编码在枚举内部,编译期检查完整性。
// 新增状态时所有相关方法都会编译报错,不会遗漏转换逻辑。"

枚举实现责任链模式


// 审批链:主管 → 经理 → VP → CEO
public enum ApprovalLevel {
    DIRECTOR(1, "主管", 5000) {
        @Override
        protected ApprovalLevel next() { return MANAGER; }
    },
    MANAGER(2, "经理", 50000) {
        @Override
        protected ApprovalLevel next() { return VP; }
    },
    VP(3, "VP", 500000) {
        @Override
        protected ApprovalLevel next() { return CEO; }
    },
    CEO(4, "CEO", Integer.MAX_VALUE) {
        @Override
        protected ApprovalLevel next() { return null; }
    };

    private final int level;
    private final String title;
    private final int maxAmount; // 该级别可审批的最大金额

    ApprovalLevel(int level, String title, int maxAmount) {
        this.level = level;
        this.title = title;
        this.maxAmount = maxAmount;
    }

    protected abstract ApprovalLevel next();

    /**
     * 责任链核心:当前级别能处理就处理,不能就传递给下一级
     */
    public ApprovalResult approve(ApprovalRequest request) {
        if (request.getAmount() <= this.maxAmount) {
            return new ApprovalResult(true, this.title + "审批通过", this);
        }
        ApprovalLevel nextLevel = this.next();
        if (nextLevel == null) {
            return new ApprovalResult(false, "超过CEO审批权限", null);
        }
        return nextLevel.approve(request); // 递归传递给下一级
    }

    // 获取处理该金额的最低审批级别(不需要从头开始)
    public static ApprovalLevel forAmount(int amount) {
        for (ApprovalLevel al : values()) {
            if (amount <= al.maxAmount) return al;
        }
        return CEO;
    }
}

// 使用
ApprovalResult result = ApprovalLevel.DIRECTOR.approve(
    new ApprovalRequest("张三", 8000));
// 8000 > 5000(DIRECTOR的上限) → 传递给MANAGER → MANAGER审批通过

// 面试话术:"枚举责任链通过递归next()实现链式传递,
// 每个枚举值定义自己的处理逻辑和后继者,天然不可变且线程安全。"

相关页面