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()实现链式传递,
// 每个枚举值定义自己的处理逻辑和后继者,天然不可变且线程安全。"
相关页面