Java后端场景实录：同一需求，不同实现路径

// ❌ 问题1：魔法字符串满天飞，"PAID"拼错成"PIAD"编译器不报错 // ❌ 问题2：新增一个状态（比如"待审核"），要改所有相关if-else // ❌ 问题3：状态流转规则散落在代码里，产品经理看不懂 // ❌ 问题4：无法可视化，新人接手要读280行才知道有哪些状态 // 测试时更崩溃：要覆盖8×7=56种状态变更组合 @Test void testAllTransitions() { // 写到第30个测试用例时，心态已经崩了... }

// 第1步：定义状态枚举，消灭魔法字符串 public enum OrderStatus { UNPAID(1, "待支付"), PAID(2, "已支付"), SHIPPING(3, "待发货"), DELIVERED(4, "已发货"), COMPLETED(5, "已完成"), CANCELLED(6, "已取消"), REFUNDING(7, "退款中"), REFUNDED(8, "已退款"); private final int code; private final String desc; // 构造器、getter省略... // 每个状态定义允许流转的下一步（核心！） public Set<OrderStatus> allowedNext() { return switch (this) { case UNPAID -> Set.of(PAID, CANCELLED); case PAID -> Set.of(SHIPPING, REFUNDING); case SHIPPING -> Set.of(DELIVERED); case DELIVERED -> Set.of(COMPLETED); case REFUNDING -> Set.of(REFUNDED); default -> Set.of(); }; } }

// 第2步：定义状态变更策略接口 public interface OrderStatusHandler { OrderStatus getSourceStatus(); void handle(Order order, OrderStatus target); } // 第3步：每个状态一个处理器实现 @Component public class UnpaidHandler implements OrderStatusHandler { @Autowired private PayService payService; @Override public OrderStatus getSourceStatus() { return OrderStatus.UNPAID; } @Override public void handle(Order order, OrderStatus target) { if (!getSourceStatus().allowedNext().contains(target)) { throw new BizException("非法状态变更: " + target); } if (target == OrderStatus.PAID) { payService.confirmPay(order.getId()); } order.setStatus(target.name()); } } // 同理：PaidHandler、ShippingHandler... 每个状态一个类

// 第4步：Service层——策略调度器 @Service public class OrderStatusService { // Spring自动注入所有实现，按key存入Map private final Map<OrderStatus, OrderStatusHandler> handlerMap; public OrderStatusService(List<OrderStatusHandler> handlers) { this.handlerMap = handlers.stream() .collect(Collectors.toMap( OrderStatusHandler::getSourceStatus, h -> h)); } public void changeStatus(Long orderId, OrderStatus target) { Order order = orderMapper.selectById(orderId); OrderStatus current = OrderStatus.valueOf(order.getStatus()); OrderStatusHandler handler = handlerMap.get(current); if (handler == null) { throw new BizException("无可用处理器"); } handler.handle(order, target); orderMapper.updateById(order); } }

// Spring StateMachine 配置类——状态流转全在这里 @Configuration @EnableStateMachineFactory public class OrderStateMachineConfig extends EnumStateMachineConfigurerAdapter<OrderState, OrderEvent> { // 定义所有状态 @Override public void configure(StateMachineStateConfigurer<OrderState, OrderEvent> states) throws Exception { states .withStates() .initial(OrderState.UNPAID) .states(EnumSet.allOf(OrderState.class)) .end(OrderState.COMPLETED) .end(OrderState.CANCELLED) .end(OrderState.REFUNDED); } // 定义状态流转规则（状态 + 事件 → 下一个状态） @Override public void configure(StateMachineTransitionConfigurer<OrderState, OrderEvent> transitions) throws Exception { transitions .withExternal() .source(UNPAID).target(PAID).event(PAY) .and() .withExternal() .source(UNPAID).target(CANCELLED).event(CANCEL) .and() .withExternal() .source(PAID).target(SHIPPING).event(SHIP) .and() .withExternal() .source(SHIPPING).target(DELIVERED).event(DELIVER) .and() .withExternal() .source(DELIVERED).target(COMPLETED).event(CONFIRM); } }

// 业务代码——只管发事件，状态机自动处理 @Service public class OrderService { @Autowired private StateMachineFactory<OrderState, OrderEvent> factory; public void pay(Long orderId) { StateMachine<OrderState, OrderEvent> sm = buildStateMachine(orderId); sm.sendEvent(OrderEvent.PAY); // 发个事件就行了！ // 状态机自动校验：当前是UNPAID吗？PAID事件合法吗？ // 合法则自动流转到PAID，非法则拒绝 } }

// 第1步：定义策略接口 public interface PayStrategy { PayResult pay(Order order); } // 第2步：每种支付方式一个实现 @Service public class AlipayStrategy implements PayStrategy { @Override public PayResult pay(Order order) { // 只关注支付宝逻辑 return alipayClient.pay(order); } } @Service public class WechatPayStrategy implements PayStrategy { @Override public PayResult pay(Order order) { return wxPayService.pay(order); } } // 第3步：工厂类——根据payType返回对应策略 @Component public class PayStrategyFactory { @Autowired private AlipayStrategy alipayStrategy; @Autowired private WechatPayStrategy wechatPayStrategy; @Autowired private BankCardStrategy bankCardStrategy; public PayStrategy getStrategy(String payType) { return switch (payType) { case "alipay" -> alipayStrategy; case "wechat" -> wechatPayStrategy; case "bank" -> bankCardStrategy; default -> throw new BizException("不支持的支付方式"); }; } } // 第4步：调用端清爽了 @Service public class PayService { @Autowired private PayStrategyFactory factory; public PayResult pay(Order order, String payType) { PayStrategy strategy = factory.getStrategy(payType); return strategy.pay(order); // 干净！ } }

@Service public class PayService { // 🔥 Spring 魔法：自动注入所有 PayStrategy 实现，key是Bean名字 @Autowired private Map<String, PayStrategy> payStrategyMap; public PayResult pay(Order order, String payType) { PayStrategy strategy = payStrategyMap.get(payType); if (strategy == null) { throw new BizException("不支持的支付方式: " + payType); } return strategy.pay(order); } } /* 新增"花呗"支付？只需要： 1. 写一个 class HuabeiPayStrategy implements PayStrategy 2. 标注 @Component("huabei") 完了！不用改 PayService，不用改 Factory，零侵入！ 这就是真正的开闭原则——对扩展开放，对修改封闭 */

@Component public class OrderSyncTask { @Autowired private OrderMapper orderMapper; // MySQL @Autowired private OrderEsRepository esRepository; // ES // 每5分钟全量同步一次 @Scheduled(cron = "0 */5 * * * ?") public void syncOrders() { List<Order> allOrders = orderMapper.selectList(null); esRepository.saveAll(allOrders); // 全量覆盖 } }

// 生产者：订单变更时发消息 @Service public class OrderService { @Autowired private RocketMQTemplate mqTemplate; @Transactional public void createOrder(OrderDTO dto) { Order order = new Order(dto); orderMapper.insert(order); // 发送增量同步消息（注意：发送要在事务提交后） OrderSyncMessage msg = new OrderSyncMessage(order.getId(), "CREATE"); mqTemplate.asyncSend("order-sync-topic", msg, new SendCallback() { @Override public void onSuccess() { log.info("同步消息发送成功"); } @Override public void onException(Throwable e) { log.error("同步消息发送失败", e); } }); } } // 消费者：监听消息，写入ES @Component @RocketMQMessageListener(topic = "order-sync-topic", consumerGroup = "es-sync-group") public class OrderEsSyncConsumer implements RocketMQListener<OrderSyncMessage> { @Override public void onMessage(OrderSyncMessage message) { Order order = orderMapper.selectById(message.getOrderId()); switch (message.getAction()) { case CREATE, UPDATE -> esRepository.save(order); case DELETE -> esRepository.deleteById(order.getId()); } } }

// DTO上声明校验规则——一次定义，处处复用 @Data public class UserDTO { @NotBlank(message = "用户名不能为空") @Size(min = 3, max = 20, message = "用户名长度3-20位") private String username; @NotBlank(message = "密码不能为空") @Size(min = 6, message = "密码至少6位") private String password; @Email(message = "邮箱格式不正确") @NotBlank(message = "邮箱不能为空") private String email; @Pattern(regexp = "^1[3-9]\\d{9}$", message = "手机号格式不正确") private String phone; @NotNull(message = "年龄不能为空") @Min(value = 18, message = "年龄不能小于18") @Max(value = 100, message = "年龄不能超过100") private Integer age; } // Controller——只需一个 @Valid 注解！ @PostMapping("/register") public Result register(@Valid @RequestBody UserDTO dto) { // 走到这里说明校验已通过，直接写业务逻辑 return userService.register(dto); } // 全局异常处理器：统一处理校验失败 @RestControllerAdvice public class GlobalExceptionHandler { @ExceptionHandler(MethodArgumentNotValidException.class) public Result handleValidation(MethodArgumentNotValidException e) { String msg = e.getBindingResult().getFieldErrors().stream() .map(err -> err.getField() + ": " + err.getDefaultMessage()) .collect(Collectors.joining("; ")); return Result.fail(msg); } }

// 自定义注解：业务规则校验 @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) public @interface BizValidate { Class<?>[] value(); // 校验器类 } // 校验器接口 public interface BizValidator<T> { void validate(T param); } // 具体校验器：注册业务校验 @Component public class RegisterValidator implements BizValidator<UserDTO> { @Autowired private UserMapper userMapper; @Override public void validate(UserDTO dto) { // 复杂业务校验——查数据库 if (userMapper.existsByUsername(dto.getUsername())) { throw new BizException("用户名已存在"); } if (userMapper.existsByPhone(dto.getPhone())) { throw new BizException("手机号已注册"); } } } // 使用：一个注解搞定所有校验 @BizValidate(RegisterValidator.class) public Result register(@Valid UserDTO dto) { // @Valid 处理格式校验，@BizValidate 处理业务校验 return userService.doRegister(dto); }

// 第1步：自定义注解 @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) public @interface OperationLog { String value(); // 操作描述，如"创建订单" String bizType() default ""; // 业务类型 } // 第2步：AOP切面——自动拦截、自动记录 @Aspect @Component public class OperationLogAspect { @Autowired private OperationLogMapper logMapper; @Around("@annotation(operationLog)") public Object around(ProceedingJoinPoint pjp, OperationLog operationLog) throws Throwable { // 方法执行前 long startTime = System.currentTimeMillis(); String operator = SecurityUtils.getCurrentUser(); String input = JSON.toJSONString(pjp.getArgs()); Object result; String status = "SUCCESS"; String errorMsg = null; try { result = pjp.proceed(); // 执行业务方法 return result; } catch (Throwable e) { status = "FAIL"; errorMsg = e.getMessage(); throw e; } finally { // 异步保存日志（不阻塞业务） OperationLogEntity entity = new OperationLogEntity(); entity.setOperator(operator); entity.setOperation(operationLog.value()); entity.setBizType(operationLog.bizType()); entity.setInput(input); entity.setOutput(JSON.toJSONString(result)); entity.setStatus(status); entity.setErrorMsg(errorMsg); entity.setCostMs(System.currentTimeMillis() - startTime); entity.setCreateTime(new Date()); logMapper.insert(entity); } } } // 第3步：业务方法——加个注解就完事！ @Service public class OrderService { @OperationLog(value = "创建订单", bizType = "ORDER") public Order createOrder(OrderDTO dto) { // 纯业务逻辑，零日志代码！ Order order = new Order(dto); return orderMapper.insert(order); } @OperationLog(value = "修改价格", bizType = "ORDER") public void updatePrice(Long id, BigDecimal newPrice) { Order order = orderMapper.selectById(id); order.setAmount(newPrice); orderMapper.updateById(order); } }

// 第1步：定义事件 public class OperationLogEvent { private final String operator; private final String operation; private final String inputData; private final String resultData; private final long costMs; // 构造器、getter省略 } // 第2步：AOP切面改为发事件，不直接写DB @Aspect @Component public class OperationLogAspect { @Autowired private ApplicationEventPublisher eventPublisher; @Around("@annotation(opLog)") public Object around(ProceedingJoinPoint pjp, OperationLog opLog) throws Throwable { long start = System.currentTimeMillis(); Object result = pjp.proceed(); // 不写DB，只发事件——瞬间返回 eventPublisher.publishEvent(new OperationLogEvent( SecurityUtils.getCurrentUser(), opLog.value(), JSON.toJSONString(pjp.getArgs()), JSON.toJSONString(result), System.currentTimeMillis() - start )); return result; } } // 第3步：异步监听器——真正写日志的地方 @Component public class OperationLogListener { @Autowired private OperationLogMapper logMapper; @Async // 异步执行，不阻塞业务 @EventListener public void handleLog(OperationLogEvent event) { OperationLogEntity entity = new OperationLogEntity(); entity.setOperator(event.getOperator()); entity.setOperation(event.getOperation()); entity.setInput(event.getInputData()); entity.setOutput(event.getResultData()); entity.setCostMs(event.getCostMs()); entity.setCreateTime(new Date()); logMapper.insert(entity); } } /* 优势： 1. 业务方法毫秒级返回（事件发布 <1ms） 2. 日志DB挂了不影响业务（事件可堆积在内存队列） 3. 可以有多个监听器：写DB + 发告警 + 推送分析平台 4. 业务和日志彻底解耦，各自独立演进 */