面试必会设计模式：单例、工厂、策略、观察者、模板方法

public class EagerSingleton {
    private static final EagerSingleton INSTANCE = new EagerSingleton();
    private EagerSingleton() {}
    public static EagerSingleton getInstance() {
        return INSTANCE;
    }
}

public class LazySingleton {
    private static LazySingleton instance;
    private LazySingleton() {}
    public static synchronized LazySingleton getInstance() {
        if (instance == null) instance = new LazySingleton();
        return instance;
    }
}

public class DCLSingleton {
    private static volatile DCLSingleton instance;  // volatile 禁止指令重排
    private DCLSingleton() {}
    public static DCLSingleton getInstance() {
        if (instance == null) {
            synchronized (DCLSingleton.class) {
                if (instance == null)
                    instance = new DCLSingleton();
            }
        }
        return instance;
    }
}

public class StaticInnerSingleton {
    private StaticInnerSingleton() {}
    private static class Holder {
        static final StaticInnerSingleton INSTANCE = new StaticInnerSingleton();
    }
    public static StaticInnerSingleton getInstance() {
        return Holder.INSTANCE;
    }
}

public enum EnumSingleton {
    INSTANCE;
    public void doSomething() { /* 业务逻辑 */ }
}

public class PaymentFactory {
    public static Payment create(String type) {
        switch (type) {
            case "alipay":  return new AlipayPayment();
            case "wechat":  return new WechatPayment();
            default: throw new IllegalArgumentException(type);
        }
    }
}

// Spring IoC 容器本身就是最大的工厂
ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);
UserService userService = ctx.getBean(UserService.class);

// BeanFactory 接口定义了工厂方法的抽象
public interface BeanFactory {
    Object getBean(String name);       // 按名称获取
    <T> T getBean(Class<T> type);    // 按类型获取
}

// Comparator 就是策略接口，不同排序规则就是不同策略实现
List<Student> students = getStudents();

// 策略 A：按成绩排序
students.sort(Comparator.comparing(Student::getScore).reversed());

// 策略 B：按年龄排序
students.sort(Comparator.comparingInt(Student::getAge));

// Collections.sort(list, comparator) 中，Context 是 sort 方法
// comparator 参数就是可替换的策略

// RejectedExecutionHandler 是策略接口
new ThreadPoolExecutor(coreSize, maxSize, keepAlive, TimeUnit.SECONDS,
    queue,
    new ThreadPoolExecutor.CallerRunsPolicy()  // 可换成 4 种内置策略
);
// 内置策略：AbortPolicy | CallerRunsPolicy | DiscardPolicy | DiscardOldestPolicy

// Spring MVC 中 DispatcherServlet 持有多个 HandlerMapping 实现
// 每个 HandlerMapping 就是一种"找到 Handler"的策略：
//   RequestMappingHandlerMapping  → @RequestMapping 注解
//   BeanNameUrlHandlerMapping    → Bean 名称以 / 开头
//   SimpleUrlHandlerMapping      → 显式 URL → Handler 映射
// DispatcherServlet 遍历所有 HandlerMapping，第一个匹配的就处理请求

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

// 2. 发布者——注入 ApplicationEventPublisher
@Service
public class OrderService {
    @Autowired private ApplicationEventPublisher publisher;

    public void createOrder(String orderId) {
        // ... 业务逻辑
        publisher.publishEvent(new OrderCreatedEvent(this, orderId));
    }
}

// 3. 监听者
@Component
public class InventoryListener {
    @EventListener
    public void onOrderCreated(OrderCreatedEvent event) {
        // 扣减库存
        log.info("扣减库存: {}", event.getOrderId());
    }
}

// 4. 异步监听（新线程执行）
@Component
public class NotifyListener {
    @Async
    @EventListener
    public void sendNotification(OrderCreatedEvent event) {
        // 发送通知，不影响主流程
    }
}

EventBus bus = new EventBus("order-bus");

// 注册监听者
bus.register(new Object() {
    @Subscribe
    public void onOrder(OrderCreatedEvent event) {
        // 处理事件
    }
});

// 发布事件
bus.post(new OrderCreatedEvent("ORD-001"));

// HttpServlet.service() 定义了算法骨架
protected void service(HttpServletRequest req, HttpServletResponse resp) {
    String method = req.getMethod();
    if (method.equals("GET"))  doGet(req, resp);      // ← 子类实现
    if (method.equals("POST")) doPost(req, resp);     // ← 子类实现
    // ... PUT, DELETE, etc.
}
// doGet() / doPost() 默认返回 405，子类覆盖即可

// JdbcTemplate 内部 execute() 的简化逻辑（模板方法）
public <T> T execute(ConnectionCallback<T> action) {
    Connection con = DataSourceUtils.getConnection(dataSource);  // 步骤 1
    try {
        return action.doInConnection(con);  // 步骤 2：回调（用户代码）
    }
    catch (SQLException ex) {
        // 步骤 3：异常转换
        throw getExceptionTranslator().translate(ex);
    }
    finally {
        DataSourceUtils.releaseConnection(con, dataSource);  // 步骤 4
    }
}

// 用户只需关心业务逻辑
List<User> users = jdbcTemplate.query(
    "SELECT * FROM user WHERE age > ?",
    new Object[]{18},
    new BeanPropertyRowMapper<>(User.class)
);

// RestTemplate.execute() 封装了 HTTP 调用全流程
// 1. 创建 ClientHttpRequest（选择底层 HttpClient）
// 2. 设置请求头、请求体（HttpMessageConverter）
// 3. 执行请求
// 4. ResponseExtractor 处理响应（用户自定义）
// 5. 关闭连接、错误处理

// 用户只需关注结果处理
User user = restTemplate.getForObject(
    "http://api/users/{id}", User.class, 123
);