203｜常用设计模式：工厂、策略、模板、责任链、观察者、代理的工程应用

// ApplicationContext 就是最大的工厂
ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
UserService userService = ctx.getBean("userService", UserService.class);

// 支付工厂
public class PaymentFactory {
    private static final Map<String, PaymentService> paymentMap = new HashMap<>();

    static {
        paymentMap.put("WECHAT", new WechatPaymentService());
        paymentMap.put("ALIPAY", new AlipayPaymentService());
        paymentMap.put("UNIONPAY", new UnionPayPaymentService());
    }

    public static PaymentService getPayment(String channel) {
        PaymentService service = paymentMap.get(channel);
        if (service == null) {
            throw new IllegalArgumentException("Unsupported payment channel: " + channel);
        }
        return service;
    }
}

// Spring 根据路径前缀选择不同的 Resource 策略
Resource res1 = ctx.getResource("classpath:config.xml");    // ClassPathResource
Resource res2 = ctx.getResource("file:/path/to/file.txt");  // FileSystemResource
Resource res3 = ctx.getResource("https://example.com");     // UrlResource

// 策略接口
public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal originalPrice);
    String getType();
}

// 满减策略
@Component
public class FullReductionStrategy implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal price) {
        return price.compareTo(new BigDecimal("200")) >= 0
            ? price.subtract(new BigDecimal("30")) : price;
    }
    public String getType() { return "FULL_REDUCTION"; }
}

// 折扣策略
@Component
public class PercentDiscountStrategy implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal price) {
        return price.multiply(new BigDecimal("0.85"));
    }
    public String getType() { return "PERCENT_DISCOUNT"; }
}

// 上下文（Spring 自动注入所有策略实现）
@Service
public class DiscountContext {
    private final Map<String, DiscountStrategy> strategyMap;

    public DiscountContext(List<DiscountStrategy> strategies) {
        this.strategyMap = strategies.stream()
            .collect(Collectors.toMap(DiscountStrategy::getType, s -> s));
    }

    public BigDecimal applyDiscount(String type, BigDecimal price) {
        DiscountStrategy strategy = strategyMap.get(type);
        if (strategy == null) {
            return price;
        }
        return strategy.calculate(price);
    }
}

public void refresh() throws BeansException, IllegalStateException {
    // 1. 准备刷新
    prepareRefresh();
    // 2. 获取 BeanFactory
    ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    // 3. 准备 BeanFactory
    prepareBeanFactory(beanFactory);
    // 4. BeanFactory 后置处理（钩子方法）
    postProcessBeanFactory(beanFactory);
    // 5. 调用 BeanFactory 后置处理器
    invokeBeanFactoryPostProcessors(beanFactory);
    // 6. 注册 Bean 后置处理器
    registerBeanPostProcessors(beanFactory);
    // 7. 初始化消息源
    initMessageSource();
    // 8. 初始化事件广播器
    initApplicationEventMulticaster();
    // 9. 模板方法——留给子类扩展
    onRefresh();
    // 10. 注册监听器
    registerListeners();
    // 11. 实例化所有非懒加载单例
    finishBeanFactoryInitialization(beanFactory);
    // 12. 完成刷新
    finishRefresh();
}

// JdbcTemplate 定义了查询的骨架：获取连接 → 创建 Statement → 执行 SQL → 处理 ResultSet → 释放资源
jdbcTemplate.query("SELECT * FROM users WHERE id = ?", ps -> ps.setLong(1, userId), rs -> {
    User user = new User();
    user.setId(rs.getLong("id"));
    user.setName(rs.getString("name"));
    return user;
});

public abstract class DataExporter<T> {
    // 模板方法——定义导出骨架
    public final void export(List<T> data, OutputStream outputStream) {
        validate(data);                    // 1. 校验数据
        List<T> filtered = filter(data);   // 2. 过滤（钩子方法）

        byte[ ] content = convert(filtered); // 3. 转换（抽象方法）

        write(outputStream, content);      // 4. 写入
        afterExport(outputStream);         // 5. 后置处理（钩子方法）
    }

    private void validate(List<T> data) {
        if (data == null || data.isEmpty()) {
            throw new IllegalArgumentException("Export data cannot be empty");
        }
    }

    protected List<T> filter(List<T> data) { return data; }  // 钩子：默认不过滤

    protected abstract byte[ ] convert(List<T> data);         // 子类实现


    private void write(OutputStream os, byte[ ] content) { /* 写入 */ }

    protected void afterExport(OutputStream os) {}           // 钩子：默认空
}

public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) {
    // 前置处理
    logRequest(request);
    // 传递给下一个过滤器
    chain.doFilter(request, response);
    // 后置处理
    logResponse(response);
}

UsernamePasswordAuthenticationFilter → BasicAuthenticationFilter → ... → FilterSecurityInterceptor

public class AuthInterceptor implements HandlerInterceptor {
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        String token = request.getHeader("Authorization");
        if (!isValidToken(token)) {
            throw new UnauthorizedException();
        }
        return true;  // 返回 true 继续传递，false 则中断
    }
}

// 审批处理器抽象
public abstract class ApprovalHandler {
    protected ApprovalHandler next;

    public ApprovalHandler setNext(ApprovalHandler next) {
        this.next = next;
        return next;  // 链式构建
    }

    public void handle(Order order) {
        if (canApprove(order)) {
            doApprove(order);
        } else if (next != null) {
            next.handle(order);
        } else {
            throw new RuntimeException("订单审批链已到尽头，无法处理");
        }
    }

    protected abstract boolean canApprove(Order order);
    protected abstract void doApprove(Order order);
}

// 构建链
ApprovalHandler chain = new ManagerHandler();
chain.setNext(new DirectorHandler())
     .setNext(new VPHandler())
     .setNext(new CEOHandler());
chain.handle(order);

// 1. 定义事件
public class OrderCreatedEvent extends ApplicationEvent {
    private final Long orderId;
    public OrderCreatedEvent(Object source, Long orderId) {
        super(source);
        this.orderId = orderId;
    }
    public Long getOrderId() { return orderId; }
}

// 2. 发布事件
@Service
public class OrderService {
    @Autowired
    private ApplicationEventPublisher publisher;

    @Transactional
    public void createOrder(Order order) {
        // 保存订单...
        // 发布事件
        publisher.publishEvent(new OrderCreatedEvent(this, order.getId()));
    }
}

// 3. 观察者1：发送通知
@Component
public class OrderNotificationListener {
    @EventListener
    @Async  // 异步处理，不阻塞主流程
    public void handleOrderCreated(OrderCreatedEvent event) {
        // 发送短信/推送通知
    }
}

// 4. 观察者2：更新统计
@Component
public class OrderStatisticsListener {
    @EventListener
    @Order(2)  // 控制执行顺序
    public void handleOrderCreated(OrderCreatedEvent event) {
        // 更新销量统计
    }
}

// @Transactional 注解的背后就是代理模式
@Service
public class UserService {
    @Transactional
    public void createUser(User user) {
        userMapper.insert(user);
        // 如果这里抛异常，事务自动回滚
    }
}

// Spring 实际执行的是：
// 1. 创建 UserService 的代理对象
// 2. 调用 createUser() 时，代理对象先执行事务拦截器
// 3. 事务拦截器：开启事务 → 调用目标方法 → 提交/回滚事务

// 你只定义了一个接口，MyBatis 通过动态代理为你生成实现
@Mapper
public interface UserMapper {
    User selectById(Long id);
}

// MyBatis 内部做的事情：
// 1. 通过 JDK 动态代理创建 Mapper 接口的代理对象
// 2. 调用方法时，代理对象拦截调用
// 3. 根据方法名查找对应的 SQL（XML 或注解）
// 4. 执行 SQL，映射结果，返回

请求到达 → DispatcherServlet（前端控制器）
  → HandlerMapping（策略模式：根据请求选择 Handler）
  → HandlerInterceptor 链（责任链模式：preHandle → handler → postHandle）
  → HandlerAdapter（适配器模式：调用真正的 Controller）
    → Controller 中注入的 Service（代理模式：AOP 增强）
      → Service 中的业务逻辑（策略模式/模板方法模式）
  → 返回结果

// 不要把所有策略塞进一个 Map
// 而是按领域拆分
Map<String, PaymentStrategy> paymentStrategies;
Map<String, DiscountStrategy> discountStrategies;

public interface DiscountStrategy {
    boolean supports(Order order);  // 策略自己声明适用条件
    BigDecimal calculate(Order order);
}
// 路由时自动匹配
DiscountStrategy s = strategies.stream()
    .filter(st -> st.supports(order))
    .findFirst().orElse(defaultStrategy);

// 1. 定义处理器接口
public interface ChainHandler<T> {
    void handle(T context, Chain<T> chain);
    int order();  // 排序用
    default boolean enabled() { return true; }  // 动态开关
}

// 2. 链的实现
public class Chain<T> {
    private final List<ChainHandler<T>> handlers;
    private int index = 0;

    public Chain(List<ChainHandler<T>> handlers) {
        this.handlers = handlers;
    }

    public void proceed(T context) {
        while (index < handlers.size()) {
            ChainHandler<T> handler = handlers.get(index);
            if (handler.enabled()) {
                index++;
                handler.handle(context, this);  // handler 内部决定是否调用 chain.proceed()
                return;
            }
            index++;
        }
    }

    // 动态增删
    public void addHandler(ChainHandler<T> handler) {
        handlers.add(handler);
        handlers.sort(Comparator.comparingInt(ChainHandler::order));
    }
    public void removeHandler(Class<?> handlerType) {
        handlers.removeIf(h -> handlerType.isInstance(h));
    }
}

@EventListener
@Async
public void handleOrderCreated(OrderCreatedEvent event) { ... }

@Bean("eventExecutor")
public Executor eventExecutor() {
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    executor.setCorePoolSize(10);
    executor.setMaxPoolSize(50);
    executor.setQueueCapacity(500);
    executor.setRejectedExecutionHandler(new CallerRunsPolicy());
    return executor;
}

public AopProxy createAopProxy(AdvisedSupport config) {
    if (config.isProxyTargetClass() || !hasUserSuppliedInterfaces(config)) {
        // proxyTargetClass=true 或目标类没有实现接口 → CGLIB
        return new ObjenesisCglibAopProxy(config);
    }
    // 默认：有接口 → JDK 动态代理
    return new JdkDynamicAopProxy(config);
}

@Service
public class OrderService {
    @Transactional
    public void createOrder(Order order) {
        // ... 事务生效
        this.updateInventory(order);  // ← 自调用，事务不生效！
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void updateInventory(Order order) {
        // 这里的事务注解不会生效
    }
}

// 审批链：金额 < 1000 → 经理审批
//         1000 ≤ 金额 < 10000 → 经理 → 总监
//         金额 ≥ 10000 → 经理 → 总监 → VP
ApprovalChain chain = new ApprovalChain();
chain.addHandler(new ManagerHandler())    // 所有订单经理先审批
     .addHandler(new DirectorHandler())   // >= 1000 总监审批
     .addHandler(new VPHandler());        // >= 10000 VP 审批

订单创建请求
  → OrderController（接收请求）
    → OrderService.createOrder()
      ◆ 代理模式：@Transactional 事务代理
      ◆ 工厂模式 + 策略模式：PaymentStrategy 支付
      ◆ 观察者模式：发布 OrderCreatedEvent
        → @Async 通知监听器（发短信/推送）
        → @TransactionalEventListener 统计监听器（更新销量）
        → MQ 消息（跨服务通知）
      ◆ 责任链模式：根据金额走审批链
      ◆ 观察者模式：状态变更发布 OrderStatusChangedEvent
        → 日志监听器（记录操作日志）
        → 后置操作监听器（释放优惠券、更新库存等）