← 返回首页 ❓ 面试题库
📑 本篇章节导航 (共7章,点击直达)
一、创建型模式(5种)二、结构型模式(7种)三、行为型模式(11种)四、Spring源码中的设计模式综合五、实战场景题六、面试高频综合题面试速记口诀

Q107 设计模式与Spring源码深度实战

20K Java+AI 岗位高频考点 — 设计模式是写出优雅代码的基础,Spring源码中大量运用了23种设计模式。覆盖创建型/结构型/行为型模式、Spring中的设计模式应用、实战场景选型。

一、创建型模式(5种)

1. 单例模式的几种实现?

五种经典实现及对比:

实现方式线程安全延迟加载防反射防序列化
饿汉式✅❌❌❌
DCL懒汉✅✅❌❌
静态内部类✅✅❌❌
枚举✅❌✅✅
Spring单例Bean✅✅--

// 1. 饿汉式(类加载即创建)
public class EagerSingleton {
    private static final EagerSingleton INSTANCE = new EagerSingleton();
    private EagerSingleton() {}
    public static EagerSingleton getInstance() { return INSTANCE; }
}

// 2. DCL懒汉式(Double-Checked Locking)
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;
    }
}

// 3. 静态内部类(利用类加载机制保证线程安全)
public class InnerClassSingleton {
    private InnerClassSingleton() {}
    private static class Holder {
        static final InnerClassSingleton INSTANCE = new InnerClassSingleton();
    }
    public static InnerClassSingleton getInstance() { return Holder.INSTANCE; }
}

// 4. 枚举(Effective Java推荐,最安全)
public enum EnumSingleton {
    INSTANCE;
    public void doSomething() { }
}

Spring单例Bean:Spring IoC容器保证每个BeanDefinition只创建一个实例,存储在DefaultSingletonBeanRegistry.singletonObjects ConcurrentHashMap中。

2. Spring的单例Bean线程安全吗?

结论:Spring的单例Bean本身不是线程安全的,但无状态Bean是安全的。


// ❌ 不安全:有状态的Singleton Bean
@Component
public class UnsafeService {
    private int counter = 0; // 共享可变状态
    public void increment() { counter++; } // 线程不安全
}

// ✅ 安全:无状态Singleton Bean(推荐)
@Component
public class SafeService {
    public String process(String input) { // 无共享可变状态
        return input.toUpperCase();
    }
}

// ✅ 安全:ThreadLocal方案
@Component
public class ThreadSafeService {
    private ThreadLocal<Integer> counter = ThreadLocal.withInitial(() -> 0);
    public void increment() { counter.set(counter.get() + 1); }
}

解决有状态单例的方案:

3. 工厂方法模式 vs 抽象工厂模式?

模式结构产品扩展性
简单工厂1个工厂类1种产品族违反OCP
工厂方法每个产品1个工厂1种产品新增产品加工厂
抽象工厂每个族1个工厂多种产品族新增族加工厂

// 工厂方法模式
public interface LoggerFactory { Logger createLogger(); }
public class FileLoggerFactory implements LoggerFactory {
    public Logger createLogger() { return new FileLogger(); }
}
public class ConsoleLoggerFactory implements LoggerFactory {
    public Logger createLogger() { return new ConsoleLogger(); }
}

// 抽象工厂模式(跨产品族)
public interface UIFactory {
    Button createButton();
    TextField createTextField();
}
public class WindowsUIFactory implements UIFactory {
    public Button createButton() { return new WindowsButton(); }
    public TextField createTextField() { return new WindowsTextField(); }
}
public class MacUIFactory implements UIFactory {
    public Button createButton() { return new MacButton(); }
    public TextField createTextField() { return new MacTextField(); }
}

Spring中的工厂:BeanFactory / ApplicationContext是最顶层的工厂,FactoryBean是工厂方法的具体应用。

4. Spring中FactoryBean的应用?

FactoryBean:用来创建复杂Bean的特殊工厂Bean,Spring容器获取时调用getObject()返回实际对象。


// FactoryBean接口
public interface FactoryBean<T> {
    T getObject() throws Exception;    // 返回实际Bean实例
    Class<?> getObjectType();           // 返回Bean类型
    default boolean isSingleton() { return true; }
}

// 自定义FactoryBean示例
public class MyFactoryBean implements FactoryBean<MyService> {
    @Override
    public MyService getObject() {
        return new MyService("complex-config");
    }
    @Override
    public Class<?> getObjectType() {
        return MyService.class;
    }
}

// 获取FactoryBean本身:加 & 前缀
Object factory = applicationContext.getBean("&myFactoryBean");
// 获取FactoryBean创建的对象:不加前缀
MyService service = applicationContext.getBean("myFactoryBean");

典型应用:

5. 建造者模式的应用场景?

适用:构造参数多(>4个)、很多可选参数、需要分步构建的复杂对象。


// Lombok @Builder
@Data
@Builder
public class HttpRequest {
    private String url;
    private String method;
    @Builder.Default private int timeout = 5000;
    private Map<String, String> headers;
    private String body;
}

// 使用
HttpRequest request = HttpRequest.builder()
    .url("https://api.example.com")
    .method("POST")
    .header("Content-Type", "application/json")
    .body("{\"name\":\"test\"}")
    .build();

Spring中的建造者模式:


// Spring Security链式配置 = 建造者模式
@Configuration
@EnableWebSecurity
public class SecurityConfig {
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http.csrf().disable()
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/public/**").permitAll()
                .anyRequest().authenticated())
            .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
            .and().addFilterBefore(jwtFilter, UsernamePasswordAuthenticationFilter.class);
        return http.build();
    }
}

6. 原型模式的应用?

核心:通过拷贝已有实例创建新对象,避免重新初始化的开销。


// 浅拷贝 vs 深拷贝
@Data
public class Order implements Cloneable {
    private String orderId;
    private List<String> items; // 引用类型
    private Address address;     // 引用类型

    @Override
    public Order clone() {
        try {
            return (Order) super.clone(); // 浅拷贝:items和address仍是同一引用
        } catch (CloneNotSupportedException e) {
            throw new RuntimeException(e);
        }
    }

    // 深拷贝方案1:手动clone所有引用
    public Order deepClone() {
        Order cloned = this.clone();
        cloned.setItems(new ArrayList<>(this.items));
        cloned.setAddress(this.address.clone());
        return cloned;
    }
}

// 深拷贝方案2:序列化
@SuppressWarnings("unchecked")
public <T> T deepCopy(T obj) {
    try (ByteArrayOutputStream bos = new ByteArrayOutputStream();
         ObjectOutputStream oos = new ObjectOutputStream(bos)) {
        oos.writeObject(obj);
        try (ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
             ObjectInputStream ois = new ObjectInputStream(bis)) {
            return (T) ois.readObject();
        }
    }
}

Spring原型Bean:@Scope("prototype")每次获取都创建新实例,AbstractBeanFactory.doGetBean()中判断scope为prototype时直接创建,不走缓存。


二、结构型模式(7种)

7. 代理模式在Spring中的应用?

代理模式三要素:接口(Subject)、真实对象(RealSubject)、代理对象(Proxy)。


// 静态代理
public interface UserService {
    User getUser(Long id);
}
public class UserServiceImpl implements UserService {
    public User getUser(Long id) { return userMapper.selectById(id); }
}
public class UserServiceProxy implements UserService {
    private UserService target;
    public User getUser(Long id) {
        log.info("before getUser");
        User result = target.getUser(id);
        log.info("after getUser");
        return result;
    }
}

Spring AOP代理创建流程:


@EnableAspectJAutoProxy
  → 导入 AspectJAutoProxyRegistrar
    → 注册 AnnotationAwareAspectJAutoProxyCreator (BeanPostProcessor)
      → postProcessAfterInitialization()
        → wrapIfNecessary() 创建代理
          → AopProxyFactory.getAopProxy()
            → JdkDynamicAopProxy 或 ObjenesisCglibAopProxy

8. JDK动态代理 vs CGLIB的区别?

维度JDK动态代理CGLIB
代理方式基于接口基于子类继承
要求目标类实现接口目标类不能final
性能生成快,调用略慢生成慢,调用快
Spring默认Spring 5.x之前默认Spring Boot 2.x+默认
原理Proxy.newProxyInstance()Enhancer.create() 生成子类

// JDK动态代理
public class JdkProxyDemo implements InvocationHandler {
    private Object target;
    public Object createProxy(Object target) {
        this.target = target;
        return Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            this);
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log.info("before: {}", method.getName());
        Object result = method.invoke(target, args);
        log.info("after: {}", method.getName());
        return result;
    }
}

// CGLIB代理
public class CglibProxyDemo implements MethodInterceptor {
    public Object createProxy(Class<?> targetClass) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(targetClass);
        enhancer.setCallback(this);
        return enhancer.create();
    }
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        log.info("before: {}", method.getName());
        Object result = proxy.invokeSuper(obj, args); // 调用父类方法
        log.info("after: {}", method.getName());
        return result;
    }
}

Spring Boot 2.x默认使用CGLIB(spring.aop.proxy-target-class=true),因为大部分场景不强制要求接口。

9. 装饰器模式 vs 代理模式的区别?

维度装饰器模式代理模式
目的增强功能控制访问
对象创建由调用方组合由代理内部创建
层数可多层装饰通常一层
典型应用Java IO流Spring AOP

// 装饰器模式:Java IO流(可层层包装)
InputStream in = new FileInputStream("data.txt");           // 被装饰者
in = new BufferedInputStream(in);                          // 装饰器1:缓冲
in = new GZIPInputStream(in);                              // 装饰器2:解压
Reader reader = new InputStreamReader(in, "UTF-8");        // 装饰器3:编码

// Spring中BeanWrapper是装饰器的应用
// BeanWrapperImpl包装Bean实例,增强属性访问能力
BeanWrapper wrapper = new BeanWrapperImpl(new User());
wrapper.setPropertyValue("name", "张三"); // 通过反射设置属性

10. 适配器模式在Spring MVC中的应用?

适配器模式:将一个类的接口转换成客户端期望的另一种接口,使不兼容的类可以协同工作。


// Spring MVC的HandlerAdapter
// DispatcherServlet不直接调用Handler,而是通过适配器
public interface HandlerAdapter {
    boolean supports(Object handler);
    ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler);
}

// 适配不同类型的Handler
RequestMappingHandlerAdapter  → 适配 @Controller 方法
HttpRequestHandlerAdapter     → 适配 HttpRequestHandler
SimpleControllerHandlerAdapter → 适配 Controller 接口

// DispatcherServlet核心分发逻辑(简化)
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) {
    Object handler = handlerMapping.getHandler(request);       // 找到Handler
    HandlerAdapter adapter = handlerAdapter.getAdapter(handler); // 找到适配器
    adapter.handle(request, response, handler);                 // 统一调用
}

11. Spring MVC的HandlerAdapter设计?

为什么用适配器:DispatcherServlet不需要知道具体Handler的类型,只通过HandlerAdapter统一调用。


客户端请求 → DispatcherServlet
                ├── HandlerMapping → 找到Handler
                ├── HandlerAdapter → 适配调用
                │     ├── RequestMappingHandlerAdapter → @RequestMapping方法
                │     ├── HttpRequestHandlerAdapter    → HttpRequestHandler
                │     └── SimpleControllerHandlerAdapter → Controller接口
                ├── ViewResolver → 视图解析
                └── 返回响应

Spring AOP中的适配器:AdvisorAdapter将不同类型的Advice适配为MethodInterceptor。


// AdvisorAdapter适配器
public interface AdvisorAdapter {
    boolean supports(Advice advice);
    MethodInterceptor getInterceptor(Advisor advisor);
}
// 实现类:MethodBeforeAdviceAdapter、AfterReturningAdviceAdapter、ThrowsAdviceAdapter

12. 桥接模式的应用?

桥接模式:将抽象部分与实现部分分离,使它们可以独立变化。


// JDBC是经典的桥接模式
// 抽象层:Java API(Connection/Statement/ResultSet)
// 实现层:各数据库Driver
// 桥接点:DriverManager

// 切换数据库只需换Driver,应用代码不变
Class.forName("com.mysql.cj.jdbc.Driver");        // MySQL
Class.forName("org.postgresql.Driver");           // PostgreSQL
Connection conn = DriverManager.getConnection(url, user, password);

// SLF4J日志桥接
// 抽象层:SLF4J API(Logger/LoggerFactory)
// 实现层:Logback / Log4j2 / JUL
// 桥接点:SLF4JServiceProvider
private static final Logger log = LoggerFactory.getLogger(MyService.class);
// 运行时由classpath中的实现决定用哪个日志框架

13. 组合模式的应用?

组合模式:将对象组合成树形结构以表示"部分-整体"的层次结构。


// Spring Cache的组合模式
// CacheManager(整体)→ 管理多个Cache(部分)
public interface CacheManager {
    Cache getCache(String name);        // 获取子节点
    Collection<String> getCacheNames(); // 获取所有子节点名称
}
// CompositeCacheManager可以组合多个CacheManager
public class CompositeCacheManager implements CacheManager {
    private final List<CacheManager> cacheManagers; // 组合子节点
}

// Spring Security的组合模式
// CompositeGrantedAuthority → 组合多个权限
// ProviderManager → 组合多个AuthenticationProvider
public class ProviderManager implements AuthenticationManager {
    private List<AuthenticationProvider> providers; // 组合多个Provider
}

14. 外观模式的应用?

外观模式:为子系统中的一组接口提供统一的入口,简化调用。


// JdbcTemplate = JDBC的外观(封装Connection/Statement/ResultSet)
@Repository
public class UserDao {
    @Autowired private JdbcTemplate jdbc;

    public User findById(Long id) {
        // 外观:一行代码隐藏了Connection创建、Statement执行、ResultSet处理、异常转换、资源关闭
        return jdbc.queryForObject("SELECT * FROM user WHERE id = ?",
            (rs, rowNum) -> {
                User u = new User();
                u.setId(rs.getLong("id"));
                u.setName(rs.getString("name"));
                return u;
            }, id);
    }
}

// SpringApplication.run() = Spring Boot启动的外观
// 内部封装了:创建ApplicationContext、注册Bean、刷新容器、启动内嵌服务器
SpringApplication.run(MyApp.class, args);

// RestTemplate = HTTP客户端的外观(封装URLConnection/HttpClient)
// 简化了HTTP连接创建、请求构建、响应解析、异常处理

三、行为型模式(11种)

15. 策略模式在Spring中的应用?

策略模式:定义一系列算法,将每一个算法封装起来,并使它们可以互相替换。


// Spring的Resource接口 = 策略模式
// 不同策略处理不同来源的资源
Resource r1 = new ClassPathResource("config.xml");     // classpath策略
Resource r2 = new FileSystemResource("/etc/app.xml");  // 文件系统策略
Resource r3 = new UrlResource("https://example.com");  // URL策略

// Spring的InstantiationStrategy = 策略模式
// CglibSubclassingInstantiationStrategy vs SimpleInstantiationStrategy

// @Qualifier = 运行时选择策略
@Service
public class PaymentService {
    @Autowired
    @Qualifier("wechatPayStrategy")  // 指定具体策略
    private PayStrategy payStrategy;
}

16. 如何用策略模式消除if-else?

经典场景:支付方式选择,用策略模式替代大量if-else分支。


// 策略接口
public interface PayStrategy {
    String getType();           // 策略标识
    PayResult pay(PayOrder order); // 执行逻辑
}

// 具体策略
@Service("alipayStrategy")
public class AlipayStrategy implements PayStrategy {
    public String getType() { return "ALIPAY"; }
    public PayResult pay(PayOrder order) { /* 支付宝支付 */ }
}

@Service("wechatPayStrategy")
public class WechatPayStrategy implements PayStrategy {
    public String getType() { return "WECHAT"; }
    public PayResult pay(PayOrder order) { /* 微信支付 */ }
}

// Spring自动收集策略 → Map注入
@Service
public class PayService {
    // Spring自动将所有PayStrategy实现注入Map,key为Bean名称
    @Autowired
    private Map<String, PayStrategy> strategyMap;

    // 也可以用List注入
    @Autowired
    private List<PayStrategy> strategyList;

    public PayResult pay(String type, PayOrder order) {
        PayStrategy strategy = strategyList.stream()
            .filter(s -> s.getType().equals(type))
            .findFirst()
            .orElseThrow(() -> new IllegalArgumentException("不支持的支付方式: " + type));
        return strategy.pay(order);
    }
}

17. 观察者模式在Spring中的应用?

观察者模式:定义对象间一对多的依赖关系,当一个对象状态改变时,所有依赖者收到通知。


// Spring Event机制 = 观察者模式
// 1. 定义事件
public class OrderCreatedEvent extends ApplicationEvent {
    private final Order order;
    public OrderCreatedEvent(Object source, Order order) {
        super(source);
        this.order = order;
    }
    public Order getOrder() { return order; }
}

// 2. 发布事件
@Service
public class OrderService {
    @Autowired private ApplicationEventPublisher publisher;
    public void createOrder(Order order) {
        orderMapper.insert(order);
        publisher.publishEvent(new OrderCreatedEvent(this, order)); // 发布
    }
}

// 3. 监听事件
@Component
public class StockListener {
    @EventListener
    public void onOrderCreated(OrderCreatedEvent event) {
        stockService.deduct(event.getOrder()); // 扣减库存
    }
}

// Spring Boot内置事件
// ApplicationContextInitializedEvent → ApplicationPreparedEvent → ContextRefreshedEvent → ApplicationStartedEvent → ApplicationReadyEvent

18. Spring Event如何实现业务解耦?


// 自定义事件 + @TransactionalEventListener(事务提交后才处理)
@Component
public class OrderEventListener {

    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
    public void handleOrderCreated(OrderCreatedEvent event) {
        // 事务提交后才执行,保证数据一致性
        smsService.sendNotification(event.getOrder());
        pointsService.addPoints(event.getOrder());
        logisticsService.createDelivery(event.getOrder());
    }

    // 异步事件处理
    @Async
    @EventListener
    public void handleAsync(OrderCreatedEvent event) {
        reportService.updateStatistics(event.getOrder()); // 耗时统计
    }
}

// 启用异步支持
@Configuration
@EnableAsync
public class AsyncConfig {
    @Bean
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(4);
        executor.setMaxPoolSize(8);
        executor.setQueueCapacity(100);
        return executor;
    }
}

19. 模板方法模式在Spring中的应用?

模板方法:父类定义算法骨架,子类实现具体步骤,不改变算法结构。


// Spring的xxTemplate全家桶
JdbcTemplate      → 封装JDBC操作骨架
RedisTemplate     → 封装Redis操作骨架
RestTemplate      → 封装HTTP操作骨架
TransactionTemplate → 封装事务操作骨架

// AbstractApplicationContext.refresh() = 模板方法
// 定义了容器刷新的骨架流程,子类可覆盖具体步骤
public void refresh() {
    prepareRefresh();                          // 1. 准备
    obtainFreshBeanFactory();                  // 2. 创建BeanFactory
    prepareBeanFactory(beanFactory);           // 3. 配置BeanFactory
    postProcessBeanFactory(beanFactory);       // 4. 子类扩展点
    invokeBeanFactoryPostProcessors(beanFactory); // 5. 执行BeanFactory后置处理
    registerBeanPostProcessors(beanFactory);   // 6. 注册Bean后置处理器
    initMessageSource();                       // 7. 国际化
    initApplicationEventMulticaster();         // 8. 事件广播
    onRefresh();                               // 9. 子类扩展点(模板方法)
    registerListeners();                       // 10. 注册监听器
    finishBeanFactoryInitialization(beanFactory); // 11. 初始化单例Bean
    finishRefresh();                           // 12. 完成刷新
}

20. JdbcTemplate的模板方法设计?


// JdbcTemplate.execute() 定义了操作骨架
public <T> T execute(StatementCallback<T> action) {
    Connection con = DataSourceUtils.getConnection(dataSource); // 1. 获取连接
    Statement stmt = null;
    try {
        stmt = con.createStatement();                // 2. 创建Statement
        T result = action.doInStatement(stmt);        // 3. 回调(变化的部分)
        return result;
    } catch (SQLException ex) {
        throw translateException(ex);                 // 4. 统一异常转换
    } finally {
        JdbcUtils.closeStatement(stmt);               // 5. 关资源
        DataSourceUtils.releaseConnection(con, dataSource);
    }
}

// 使用:只需关注变化的部分
jdbcTemplate.execute(conn -> {
    // 回调:只写业务SQL,其余(连接/关闭/异常)由模板处理
    CallableStatement cs = conn.prepareCall("{call update_salary(?,?)}");
    cs.setLong(1, empId);
    cs.setDouble(2, newSalary);
    return cs.executeUpdate();
});

// RowMapper也是回调策略
List<User> users = jdbc.query("SELECT * FROM user",
    (rs, rowNum) -> new User(rs.getLong("id"), rs.getString("name")));

21. 责任链模式在Spring中的应用?

责任链:将请求沿着处理者链传递,每个处理者决定是否处理及是否传递。


请求 → Filter1 → Filter2 → Filter3 → Servlet
         ↓          ↓          ↓
       日志记录   身份认证   权限校验
框架责任链实现
ServletFilterChain + Filter
Spring SecuritySecurityFilterChain
Spring MVCHandlerInterceptor链
MyBatisInterceptorChain + Interceptor

// Spring MVC Interceptor链
@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new AuthInterceptor()).addPathPatterns("/api/**");
        registry.addInterceptor(new LogInterceptor()).addPathPatterns("/api/**");
        registry.addInterceptor(new RateLimitInterceptor()).addPathPatterns("/api/**");
    }
}

// Interceptor调用链路(DispatcherServlet中)
// applyPreHandle → 逐个调用preHandle → 任一返回false则停止
// 执行Handler
// applyPostHandle → 逐个调用postHandle(逆序)
// triggerAfterCompletion → 逐个调用afterCompletion(逆序)

22. Spring Security的过滤器链设计?


// SecurityFilterChain:安全过滤器责任链
// DelegatingFilterProxy桥接Servlet Filter和Spring Bean

@Configuration
@EnableWebSecurity
public class SecurityConfig {
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .addFilterBefore(new JwtAuthFilter(), UsernamePasswordAuthenticationFilter.class)
            .csrf(csrf -> csrf.disable())
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/public/**").permitAll()
                .anyRequest().authenticated());
        return http.build();
    }
}

// 默认过滤器链顺序(FilterOrderRegistration)
// ChannelProcessingFilter → ConcurrentSessionFilter → SecurityContextPersistenceFilter
// → LogoutFilter → UsernamePasswordAuthenticationFilter → DefaultLoginPageGeneratingFilter
// → BasicAuthenticationFilter → ... → ExceptionTranslationFilter → FilterSecurityInterceptor

自定义Filter注册方式:

23. MyBatis的插件(Interceptor)责任链?


// MyBatis四大对象的拦截链
// Executor → StatementHandler → ParameterHandler → ResultSetHandler

@Intercepts({
    @Signature(type = StatementHandler.class, method = "prepare", args = {Connection.class, Integer.class}),
    @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})
})
@Component
public class SqlLogInterceptor implements Interceptor {
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        long start = System.currentTimeMillis();
        Object result = invocation.proceed(); // 传递给下一个拦截器
        long cost = System.currentTimeMillis() - start;
        log.info("SQL执行耗时: {}ms", cost);
        return result;
    }

    @Override
    public Object plugin(Object target) {
        // 使用Plugin.wrap()创建代理(动态代理实现拦截)
        return Plugin.wrap(target, this);
    }
}

// 插件注册顺序:mybatis-config.xml或Spring Bean
// InterceptorChain.pluginAll()依次调用plugin(),形成多层代理

24. 命令模式的应用?

命令模式:将请求封装为对象,实现请求的参数化、排队、日志和撤销。


// Runnable = 最经典的命令接口
Runnable command = () -> System.out.println("执行任务");
Thread thread = new Thread(command); // 命令对象传入Thread
thread.start();

// 命令模式实现操作撤销
public interface Command {
    void execute();
    void undo();
}

public class TextEditor {
    private StringBuilder text = new StringBuilder();
    private Stack<Command> history = new Stack<>();

    public void write(String content) {
        Command cmd = new WriteCommand(text, content);
        cmd.execute();
        history.push(cmd);
    }

    public void undo() {
        if (!history.isEmpty()) {
            history.pop().undo();
        }
    }
}

// Spring Batch Tasklet = 命令模式
public class ImportTasklet implements Tasklet {
    public RepeatStatus execute(StepContribution contribution, ChunkContext context) {
        // 执行数据导入任务
        return RepeatStatus.FINISHED;
    }
}

25. 迭代器模式的应用?


// Collection.iterator() = 最基本的迭代器模式
List<String> list = Arrays.asList("a", "b", "c");
Iterator<String> it = list.iterator();
while (it.hasNext()) {
    System.out.println(it.next());
}

// Java Stream = 迭代器 + 策略模式 + 函数式编程
list.stream()
    .filter(s -> s.startsWith("a"))  // 策略:过滤条件
    .map(String::toUpperCase)         // 策略:转换逻辑
    .forEach(System.out::println);    // 迭代消费

// Spring的CompositeIterator(组合+迭代器)
public class CompositeIterator<E> implements Iterator<E> {
    private final List<Iterator<E>> iterators;
    // 组合多个迭代器,统一遍历
}

26. 中介者模式的应用?

中介者:用一个中介对象封装一系列对象交互,使对象不需要显式引用彼此。


// DispatcherServlet = 典型的中介者
// 它协调HandlerMapping、HandlerAdapter、ViewResolver等多个组件
// 各组件之间不直接通信,都通过DispatcherServlet交互

客户端请求 → DispatcherServlet(中介者)
               ├── 咨询 HandlerMapping → 得到Handler
               ├── 咨询 HandlerAdapter → 执行Handler
               ├── 咨询 ViewResolver → 解析视图
               └── 返回响应

// 聊天室场景
public class ChatRoom { // 中介者
    public static void showMessage(User user, String message) {
        System.out.println(user.getName() + ": " + message);
    }
}
public class User {
    public void sendMessage(String msg) {
        ChatRoom.showMessage(this, msg); // 通过中介者发送
    }
}

27. 备忘录模式的应用?

备忘录:在不破坏封装的前提下,捕获对象内部状态,以便之后恢复。


// 备忘录模式实现撤销功能
public class EditorMemento { // 备忘录
    private final String content;
    public EditorMemento(String content) { this.content = content; }
    public String getContent() { return content; }
}

public class TextEditor {
    private StringBuilder content = new StringBuilder();
    private Stack<EditorMemento> history = new Stack<>();

    public void write(String text) {
        history.push(new EditorMemento(content.toString())); // 保存快照
        content.append(text);
    }

    public void undo() {
        if (!history.isEmpty()) {
            content = new StringBuilder(history.pop().getContent()); // 恢复快照
        }
    }
}

// Spring WebFlow的FlowExecution = 备忘录模式
// FlowExecutionSnapshot保存流程执行状态,支持流程恢复和重试

28. 状态模式的应用?

状态模式:允许对象在内部状态改变时改变行为,对象看起来像是修改了类。


// 订单状态机(不用状态模式 → 大量if-else)
// 用状态模式:
public interface OrderState {
    void handle(OrderContext context);
}

public class PaidState implements OrderState {
    public void handle(OrderContext context) {
        context.setState(new ShippedState());
        logisticsService.ship(context.getOrder());
    }
}

// Spring StateMachine
@Configuration
@EnableStateMachine
public class OrderStateMachineConfig extends EnumStateMachineConfigurerAdapter<OrderStatus, OrderEvent> {
    @Override
    public void configure(StateMachineStateConfigurer<OrderStatus, OrderEvent> states) throws Exception {
        states.withStates()
            .initial(OrderStatus.CREATED)
            .states(EnumSet.allOf(OrderStatus.class));
    }

    @Override
    public void configure(StateMachineTransitionConfigurer<OrderStatus, OrderEvent> transitions) throws Exception {
        transitions
            .withExternal().source(CREATED).target(PAID).event(PAY)
            .and()
            .withExternal().source(PAID).target(SHIPPED).event(SHIP)
            .and()
            .withExternal().source(SHIPPED).target(COMPLETED).event(COMPLETE);
    }
}

29. 访问者模式的应用?

访问者模式:表示一个作用于某对象结构中各元素的操作,使你可以在不改变各元素类的前提下定义新操作(Double Dispatch)。


// Java ASM字节码操作 = 访问者模式
// ClassReader读取字节码 → ClassVisitor访问各种结构
public class MyClassVisitor extends ClassVisitor {
    @Override
    public MethodVisitor visitMethod(int access, String name, String desc,
                                      String signature, String[] exceptions) {
        // 访问方法
        return super.visitMethod(access, name, desc, signature, exceptions);
    }
}

// Spring的BeanDefinitionVisitor
// 访问BeanDefinition中的各种属性值(用于属性占位符替换)
public class BeanDefinitionVisitor {
    public void visitBeanDefinition(BeanDefinition beanDefinition) {
        visitParentName(beanDefinition.getParentName());     // 访问父名称
        visitBeanClassName(beanDefinition.getBeanClassName()); // 访问类名
        // ... 访问所有属性
    }
}

30. 解释器模式的应用?

解释器模式:给定一个语言,定义其文法的一种表示,并定义一个解释器来解释句子。


// Spring EL表达式(SpEL)= 解释器模式
ExpressionParser parser = new SpelExpressionParser();

// 基本表达式
Expression exp = parser.parseExpression("'Hello ' + name");
StandardEvaluationContext context = new StandardEvaluationContext();
context.setVariable("name", "World");
String result = exp.getValue(context, String.class); // "Hello World"

// 方法调用
parser.parseExpression("#service.process(#data)").getValue(context);

// 安全表达式(@PreAuthorize)
@PreAuthorize("hasRole('ADMIN') and @securityService.canAccess(#id)")
public User getUser(Long id) { ... }

// SpEL内部实现
// ExpressionParser → 词法分析 → 语法分析 → AST(抽象语法树)→ 解释执行
// SpelExpression → CompositeExpression → OpAnd/OpOr/Literal/MethodReference等节点

四、Spring源码中的设计模式综合

31. Spring IoC容器用到了哪些设计模式?


┌─────────────────────────────────────────────────────────┐
│              Spring IoC容器设计模式全景                     │
├─────────────┬───────────────────────────────────────────┤
│ 工厂模式     │ BeanFactory / ApplicationContext创建Bean   │
│ 单例模式     │ 默认scope=singleton                       │
│ 观察者模式   │ ApplicationEvent + EventListener           │
│ 模板方法     │ AbstractApplicationContext.refresh()       │
│ 策略模式     │ Resource接口不同实现                        │
│ 装饰器模式   │ BeanWrapper增强属性访问                    │
│ 适配器模式   │ BeanDefinitionReader适配不同配置源          │
│ 外观模式     │ ApplicationContext统一入口                 │
└─────────────┴───────────────────────────────────────────┘

Bean生命周期中的设计模式:


解析(策略) → 注册(工厂) → 实例化(工厂+策略) → 属性填充(装饰器)
→ 初始化(模板方法+观察者) → 使用 → 销毁(模板方法)

32. Spring AOP用到了哪些设计模式?


// AOP核心设计模式
// 1. 代理模式:JDK动态代理 / CGLIB
//    AopProxy接口 → JdkDynamicAopProxy / CglibAopProxy
public interface AopProxy {
    Object getProxy();
    Object getProxy(ClassLoader classLoader);
}

// 2. 责任链模式:Advice链(InterceptorChain)
//    MethodInvocation.proceed() 递归调用拦截器链
public interface MethodInterceptor {
    Object invoke(MethodInvocation invocation) throws Throwable;
}

// 3. 策略模式:AopProxyFactory选择代理策略
public interface AopProxyFactory {
    AopProxy createAopProxy(AdvisedSupport config);
}
// DefaultAopProxyFactory:有接口用JDK,无接口用CGLIB

// 4. 工厂模式:ProxyFactoryBean创建代理
ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();
proxyFactoryBean.setTarget(new MyService());
proxyFactoryBean.addAdvice(new MyAdvice());
MyService proxy = (MyService) proxyFactoryBean.getObject();

33. Spring事务管理用到了哪些设计模式?


// 1. 代理模式:TransactionInterceptor代理目标方法
// @Transactional注解 → AOP代理 → TransactionInterceptor拦截

// 2. 模板方法模式:TransactionTemplate
@Autowired private TransactionTemplate txTemplate;
public void transfer() {
    txTemplate.execute(status -> {
        accountMapper.deduct(fromId, amount);
        accountMapper.add(toId, amount);
        return null;
    });
}

// 3. 策略模式:PlatformTransactionManager
// 不同数据源使用不同的事务管理策略
public interface PlatformTransactionManager {
    TransactionStatus getTransaction(TransactionDefinition definition);
    void commit(TransactionStatus status);
    void rollback(TransactionStatus status);
}
// DataSourceTransactionManager   → JDBC/MyBatis
// JpaTransactionManager          → JPA
// JtaTransactionManager          → 分布式事务

// 4. 装饰器模式:事务连接包装
// TransactionAwareCacheDecorator / TransactionSynchronizationManager

34. BeanDefinition的解析过程用了哪些模式?


配置文件/注解 → BeanDefinitionReader(策略)
                  ├── XmlBeanDefinitionReader     → XML解析策略
                  ├── PropertiesBeanDefinitionReader → Properties解析
                  ├── AnnotatedBeanDefinitionReader → 注解解析
                  └── GroovyBeanDefinitionReader   → Groovy解析
                       ↓
                  BeanDefinitionBuilder(建造者)
                  → 构建BeanDefinition对象
                       ↓
                  BeanDefinitionRegistry(工厂)
                  → 注册到IoC容器

// BeanDefinitionBuilder = 建造者模式
BeanDefinition bd = BeanDefinitionBuilder
    .genericBeanDefinition(UserService.class)
    .addPropertyValue("name", "张三")
    .addPropertyReference("dao", "userDao")
    .setScope(BeanDefinition.SCOPE_SINGLETON)
    .setInitMethodName("init")
    .getBeanDefinition();

35. Spring Boot自动配置用到了哪些模式?


// 1. 工厂模式:SpringFactoriesLoader / ImportCandidates
// 加载META-INF/spring.factories或META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
List<String> configs = SpringFactoriesLoader.loadFactoryNames(
    EnableAutoConfiguration.class, classLoader);

// 2. 条件模式(策略变体):@Conditional系列
@ConditionalOnClass(DataSource.class)       // 类路径条件
@ConditionalOnMissingBean(DataSource.class)  // Bean不存在条件
@ConditionalOnProperty("spring.datasource.url") // 配置条件
@ConditionalOnWebApplication                  // 应用类型条件

// 3. 建造者模式:SpringApplicationBuilder
new SpringApplicationBuilder(MyApp.class)
    .profiles("dev")
    .bannerMode(Banner.Mode.OFF)
    .logStartupInfo(false)
    .run(args);

// 4. 模板方法:AutoConfigurationImportSelector.selectImports()
// 定义自动配置的选择和过滤骨架流程

五、实战场景题

36. 如何用策略模式+工厂模式重构支付系统?


// 策略接口
public interface PayStrategy {
    String getType();
    PayResult pay(PayOrder order);
    PayResult refund(PayOrder order);
}

// 微信支付策略
@Service
public class WechatPayStrategy implements PayStrategy {
    public String getType() { return "WECHAT"; }
    public PayResult pay(PayOrder order) { /* 调用微信支付API */ }
    public PayResult refund(PayOrder order) { /* 调用微信退款API */ }
}

// 支付宝策略
@Service
public class AlipayStrategy implements PayStrategy {
    public String getType() { return "ALIPAY"; }
    public PayResult pay(PayOrder order) { /* 调用支付宝API */ }
    public PayResult refund(PayOrder order) { /* 调用支付宝退款API */ }
}

// 工厂 + Spring自动收集
@Service
public class PayStrategyFactory {
    private final Map<String, PayStrategy> strategyMap;

    // Spring自动注入所有PayStrategy实现,key为Bean名称
    public PayStrategyFactory(List<PayStrategy> strategies) {
        this.strategyMap = strategies.stream()
            .collect(Collectors.toMap(PayStrategy::getType, Function.identity()));
    }

    public PayStrategy getStrategy(String type) {
        PayStrategy strategy = strategyMap.get(type);
        if (strategy == null) throw new IllegalArgumentException("不支持的支付方式: " + type);
        return strategy;
    }
}

// 扩展新支付方式:只需新增一个Strategy实现类,零修改现有代码(OCP)

37. 如何用责任链模式实现参数校验?


// 校验器接口
public interface Validator<T> {
    ValidationResult validate(T target);
    Validator<T> next();
}

// 抽象校验器
public abstract class AbstractValidator<T> implements Validator<T> {
    private Validator<T> next;
    public Validator<T> next() { return next; }
    public AbstractValidator<T> setNext(Validator<T> next) {
        this.next = next;
        return this;
    }

    public ValidationResult chain(T target) {
        ValidationResult result = validate(target);
        if (!result.isValid()) return result;
        return next != null ? next.validate(target) : ValidationResult.ok();
    }
}

// 具体校验器
public class NotNullValidator<T> extends AbstractValidator<T> {
    private String field;
    public ValidationResult validate(T target) {
        Object value = ReflectUtil.getFieldValue(target, field);
        return value != null ? ValidationResult.ok()
            : ValidationResult.fail(field + "不能为空");
    }
}

// 使用:链式构建
Validator<User> chain = new NotNullValidator<>("name")
    .setNext(new LengthValidator<>("name", 2, 20))
    .setNext(new PatternValidator<>("phone", "^1[3-9]\\d{9}$"));
ValidationResult result = chain.chain(user);

38. 如何用观察者模式实现订单状态变更通知?


// 事件定义
public class OrderStatusEvent extends ApplicationEvent {
    private final Long orderId;
    private final OrderStatus fromStatus;
    private final OrderStatus toStatus;
    // constructor, getters
}

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

    @Transactional
    public void updateStatus(Long orderId, OrderStatus newStatus) {
        Order order = orderMapper.selectById(orderId);
        OrderStatus oldStatus = order.getStatus();
        order.setStatus(newStatus);
        orderMapper.updateById(order);
        // 发布事件
        publisher.publishEvent(new OrderStatusEvent(this, orderId, oldStatus, newStatus));
    }
}

// 多个监听者解耦
@Component
public class StockListener {
    @TransactionalEventListener(phase = AFTER_COMMIT)
    public void onOrderPaid(OrderStatusEvent event) {
        if (event.getToStatus() == PAID) {
            stockService.deduct(event.getOrderId());
        }
    }
}

@Component
public class PointsListener {
    @Async
    @TransactionalEventListener(phase = AFTER_COMMIT)
    public void onOrderCompleted(OrderStatusEvent event) {
        if (event.getToStatus() == COMPLETED) {
            pointsService.addPoints(event.getOrderId());
        }
    }
}

@Component
public class NotificationListener {
    @EventListener
    public void onStatusChange(OrderStatusEvent event) {
        smsService.notify(event.getOrderId(), event.getToStatus());
    }
}

39. 如何用模板方法模式实现报表导出?


// 抽象模板
public abstract class AbstractReportExporter {

    // 模板方法:定义导出骨架
    public final byte[] export(ReportQuery query) {
        List<?> data = fetchData(query);       // 1. 查询数据
        Object processed = processData(data);   // 2. 处理数据
        byte[] content = generateFile(processed); // 3. 生成文件
        postProcess(query, content);            // 4. 后处理(日志/审计)
        return content;
    }

    protected abstract List<?> fetchData(ReportQuery query);       // 子类实现
    protected abstract byte[] generateFile(Object data);            // 子类实现

    protected Object processData(List<?> data) { return data; }    // 可选覆盖
    protected void postProcess(ReportQuery query, byte[] content) { // 钩子方法
        log.info("导出报表: {}条数据", content.length);
    }
}

// Excel导出
@Service
public class ExcelReportExporter extends AbstractReportExporter {
    protected List<?> fetchData(ReportQuery query) {
        return reportMapper.queryList(query);
    }
    protected byte[] generateFile(Object data) {
        return EasyExcel.write().sheet("报表").doWrite((List<?>) data).getBytes();
    }
}

// PDF导出
@Service
public class PdfReportExporter extends AbstractReportExporter {
    protected List<?> fetchData(ReportQuery query) {
        return reportMapper.queryList(query);
    }
    protected byte[] generateFile(Object data) {
        return pdfGenerator.generate((List<?>) data);
    }
}

40. 如何用代理模式实现缓存?


// JDK动态代理实现方法级缓存
public class CacheProxy implements InvocationHandler {
    private final Object target;
    private final CacheManager cacheManager;

    public <T> T createProxy(T target) {
        return (T) Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            new CacheProxy(target, cacheManager));
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 检查缓存注解
        Cacheable cacheable = method.getAnnotation(Cacheable.class);
        if (cacheable == null) {
            return method.invoke(target, args); // 无缓存注解,直接调用
        }

        String key = generateKey(cacheable.key(), method, args);
        Object cached = cacheManager.getCache(cacheable.cacheName()).get(key);
        if (cached != null) return cached; // 缓存命中

        Object result = method.invoke(target, args); // 执行原方法
        cacheManager.getCache(cacheable.cacheName()).put(key, result); // 写入缓存
        return result;
    }
}

// Spring Cache @Cacheable原理类似
// CacheInterceptor → CacheOperationInvocationHandler → 代理目标方法
@Cacheable(value = "users", key = "#id")
public User getUser(Long id) { return userMapper.selectById(id); }

41. 如何用装饰器模式增强日志?


// 装饰器:在Service外层包日志
public interface OrderService {
    Order createOrder(OrderRequest request);
    Order getOrder(Long id);
}

// 原始实现
@Service
public class OrderServiceImpl implements OrderService {
    public Order createOrder(OrderRequest request) { /* 业务逻辑 */ }
    public Order getOrder(Long id) { /* 业务逻辑 */ }
}

// 日志装饰器
@Component
public class LoggingOrderServiceDecorator implements OrderService {
    private final OrderService delegate;

    public LoggingOrderServiceDecorator(OrderServiceImpl delegate) {
        this.delegate = delegate;
    }

    @Override
    public Order createOrder(OrderRequest request) {
        log.info("创建订单: {}", request);
        long start = System.currentTimeMillis();
        try {
            Order result = delegate.createOrder(request);
            log.info("创建订单成功: {}, 耗时: {}ms", result.getId(),
                System.currentTimeMillis() - start);
            return result;
        } catch (Exception e) {
            log.error("创建订单失败: {}", e.getMessage(), e);
            throw e;
        }
    }

    // getOrder()类似...
}

// 与静态代理区别:装饰器侧重增强功能、可多层叠加、由调用方组合
// 装饰器可以叠加:Logging → Metrics → Caching → 实际Service

42. 如何用工厂方法模式实现多数据源?


// 数据源工厂接口
public interface DataSourceFactory {
    DataSource createDataSource(DataSourceConfig config);
}

// MySQL工厂
public class MySQLDataSourceFactory implements DataSourceFactory {
    public DataSource createDataSource(DataSourceConfig config) {
        HikariDataSource ds = new HikariDataSource();
        ds.setJdbcUrl("jdbc:mysql://" + config.getHost() + ":" + config.getPort() + "/" + config.getDatabase());
        ds.setDriverClassName("com.mysql.cj.jdbc.Driver");
        ds.setUsername(config.getUsername());
        ds.setPassword(config.getPassword());
        return ds;
    }
}

// PostgreSQL工厂
public class PostgreSQLDataSourceFactory implements DataSourceFactory {
    public DataSource createDataSource(DataSourceConfig config) {
        HikariDataSource ds = new HikariDataSource();
        ds.setJdbcUrl("jdbc:postgresql://" + config.getHost() + ":" + config.getPort() + "/" + config.getDatabase());
        ds.setDriverClassName("org.postgresql.Driver");
        ds.setUsername(config.getUsername());
        ds.setPassword(config.getPassword());
        return ds;
    }
}

// 动态数据源路由(AbstractRoutingDataSource = 策略模式)
public class DynamicDataSource extends AbstractRoutingDataSource {
    @Override
    protected Object determineCurrentLookupKey() {
        return DataSourceContextHolder.get(); // 从ThreadLocal获取当前数据源key
    }
}

43. 如何用命令模式实现操作撤销?


// 命令接口
public interface Command {
    void execute();
    void undo();
    String getDescription();
}

// 文本编辑命令
public class InsertCommand implements Command {
    private TextEditor editor;
    private int position;
    private String text;

    public void execute() { editor.insert(position, text); }
    public void undo() { editor.delete(position, text.length()); }
    public String getDescription() { return "插入: " + text; }
}

// 命令管理器
public class CommandManager {
    private Stack<Command> undoStack = new Stack<>();
    private Stack<Command> redoStack = new Stack<>();

    public void execute(Command command) {
        command.execute();
        undoStack.push(command);
        redoStack.clear();
    }

    public void undo() {
        if (undoStack.isEmpty()) return;
        Command cmd = undoStack.pop();
        cmd.undo();
        redoStack.push(cmd);
    }

    public void redo() {
        if (redoStack.isEmpty()) return;
        Command cmd = redoStack.pop();
        cmd.execute();
        undoStack.push(cmd);
    }
}

44. 如何用状态模式实现工作流引擎?


// 状态接口
public interface WorkState {
    void approve(WorkItemContext context);
    void reject(WorkItemContext context);
    String getName();
}

// 具体状态
public class DraftState implements WorkState {
    public void approve(WorkItemContext context) {
        context.setState(new PendingState()); // 草稿 → 待审核
    }
    public void reject(WorkItemContext context) {
        // 草稿不可驳回
        throw new IllegalStateException("草稿状态不可驳回");
    }
    public String getName() { return "DRAFT"; }
}

public class PendingState implements WorkState {
    public void approve(WorkItemContext context) {
        context.setState(new ApprovedState()); // 待审核 → 已审批
    }
    public void reject(WorkItemContext context) {
        context.setState(new RejectedState()); // 待审核 → 已驳回
    }
    public String getName() { return "PENDING"; }
}

// 上下文
public class WorkItemContext {
    private WorkState state;
    public void approve() { state.approve(this); }
    public void reject() { state.reject(this); }
    public void setState(WorkState state) { this.state = state; }
}

// 对比if-else方案:
// if-else: 每次新增状态都要修改所有方法,违反OCP
// 状态模式: 新增状态只需新建State实现类,零修改现有代码

45. 如何用建造者模式构建复杂查询?


// 查询建造者
public class QueryBuilder {
    private String table;
    private List<String> selectColumns = new ArrayList<>();
    private List<String> conditions = new ArrayList<>();
    private List<String> orderBy = new ArrayList<>();
    private Integer limit;

    public QueryBuilder table(String table) { this.table = table; return this; }
    public QueryBuilder select(String... columns) {
        selectColumns.addAll(Arrays.asList(columns)); return this;
    }
    public QueryBuilder where(String condition) { conditions.add(condition); return this; }
    public QueryBuilder orderBy(String column) { orderBy.add(column); return this; }
    public QueryBuilder limit(int limit) { this.limit = limit; return this; }

    public String build() {
        StringBuilder sql = new StringBuilder("SELECT ");
        sql.append(selectColumns.isEmpty() ? "*" : String.join(", ", selectColumns));
        sql.append(" FROM ").append(table);
        if (!conditions.isEmpty()) sql.append(" WHERE ").append(String.join(" AND ", conditions));
        if (!orderBy.isEmpty()) sql.append(" ORDER BY ").append(String.join(", ", orderBy));
        if (limit != null) sql.append(" LIMIT ").append(limit);
        return sql.toString();
    }
}

// 使用
String sql = new QueryBuilder()
    .table("orders")
    .select("id", "user_id", "amount")
    .where("status = 'PAID'")
    .where("create_time > '2025-01-01'")
    .orderBy("create_time DESC")
    .limit(100)
    .build();
// SELECT id, user_id, amount FROM orders WHERE status = 'PAID' AND create_time > '2025-01-01' ORDER BY create_time DESC LIMIT 100

// MyBatis-Plus Wrapper也是建造者模式
QueryWrapper<User> wrapper = new QueryWrapper<User>()
    .select("id", "name", "age")
    .eq("status", 1)
    .between("age", 18, 60)
    .orderByDesc("create_time")
    .last("LIMIT 100");

六、面试高频综合题

46. 读过Spring源码吗?说说你的理解?

建议从IoC/AOP切入,结合设计模式讲解:


1. IoC容器启动流程(AbstractApplicationContext.refresh())
   ├── BeanDefinition解析(策略模式:XML/注解/Groovy)
   ├── BeanFactoryPostProcessor扩展点
   ├── BeanPostProcessor注册
   └── 单例Bean实例化(工厂+单例模式)

2. Bean生命周期
   实例化 → 属性注入 → Aware回调 → BeanPostProcessor前置处理
   → InitializingBean → @PostConstruct → 自定义init
   → BeanPostProcessor后置处理(AOP代理在此创建)
   → 使用 → DisposableBean → @PreDestroy → 自定义destroy

3. AOP实现(代理+责任链)
   AnnotationAwareAspectJAutoProxyCreator → 创建代理
   → MethodInterceptor责任链 → 依次执行Before/After/Around/AfterThrowing

4. 设计模式贯穿始终
   工厂、单例、代理、策略、模板方法、观察者、适配器、装饰器

47. 设计模式的过度使用问题?

原则:不要为了设计模式而设计模式,先有问题再有模式。


过度设计的信号:
├── 3个类解决的问题用了10个类
├── 简单if-else被拆成策略工厂+反射
├── 只有一个实现的接口
├── 为了"未来扩展"预留了用不到的抽象
└── 团队成员看不懂代码在做什么

何时用设计模式:
├── if-else超过3层且持续增长 → 策略模式
├── 新增类型需要改多处代码 → 开闭原则
├── 多个子系统需要统一入口 → 外观模式
├── 需要动态增减功能 → 装饰器/责任链
└── 业务流程固定但步骤可变 → 模板方法

YAGNI原则(You Aren't Gonna Need It):
不确定会不会用到,就别提前抽象。
先写简单代码,等变化出现时再重构引入模式。

48. 设计模式在JDK中的应用总结?

设计模式JDK应用
工厂模式Collections.singleton()、Executors.newFixedThreadPool()、URL.openConnection()
装饰器模式java.io流全家桶(BufferedInputStream装饰FileInputStream)
代理模式java.lang.reflect.Proxy
适配器模式java.util.Arrays.asList()、InputStreamReader(字节→字符)
桥接模式JDBC Driver / DriverManager
迭代器模式Collection.iterator()、Scanner
策略模式Comparator、Comparator.comparing()、Collections.sort(list, comparator)
模板方法HttpServlet.doGet()/doPost()、AbstractList
观察者模式java.util.Observable(已废弃)/ java.beans.PropertyChangeListener
命令模式Runnable
享元模式Integer.valueOf()缓存-128~127、String常量池
单例模式Runtime.getRuntime()

49. 如何在代码Review中识别设计模式的应用?

四步识别法:


1. 看接口抽象
   ├── 有接口+多个实现 → 可能是策略/工厂
   ├── 接口只有一个实现 → 可能过度设计
   └── 回调接口(一个方法)→ 可能是策略/命令/观察者

2. 看继承关系
   ├── 子类覆盖父类的某些方法但保持骨架 → 模板方法
   ├── 继承只为了扩展功能 → 装饰器
   └── 继承只为了重写行为 → 状态/策略

3. 看对象创建方式
   ├── 通过工厂方法创建 → 工厂模式
   ├── 通过clone/序列化创建 → 原型模式
   ├── 通过建造者链式调用 → 建造者模式
   └── 全局唯一实例 → 单例模式

4. 看调用链路
   ├── A包含B的引用且类型相同 → 组合/装饰器
   ├── 链式传递请求 → 责任链
   ├── 通过中介者交互 → 中介者
   └── 事件驱动通知 → 观察者

50. 开闭原则(OCP)的实战体现?

开闭原则:对扩展开放,对修改关闭。


// ❌ 违反OCP:每新增一种通知方式都要修改此类
public class NotificationService {
    public void notify(String type, String message) {
        if (type.equals("SMS")) { smsService.send(message); }
        else if (type.equals("EMAIL")) { emailService.send(message); }
        else if (type.equals("WECHAT")) { wechatService.send(message); }
        // 新增PUSH?又要改这里...
    }
}

// ✅ 符合OCP:策略模式 + Spring自动收集
public interface NotifyStrategy {
    String getType();
    void send(String message);
}
@Service public class SmsNotify implements NotifyStrategy { /* ... */ }
@Service public class EmailNotify implements NotifyStrategy { /* ... */ }
// 新增通知方式:只需新建实现类,零修改现有代码

// OCP的实战体现总结:
// 1. 策略模式 → 新增策略不改代码
// 2. 观察者模式 → 新增监听器不改主题
// 3. 模板方法 → 新增子类不改骨架
// 4. 责任链 → 新增处理器不改链路
// 5. Spring @Conditional → 自动配置的条件化扩展
// 6. Spring SPI(spring.factories) → 框架扩展点

面试速记口诀

创建型5种:单例、工厂方法、抽象工厂、建造者、原型

>

结构型7种:代理、适配器、装饰器、外观、桥接、组合、享元

>

行为型11种:策略、观察者、模板方法、责任链、命令、迭代器、中介者、备忘录、状态、访问者、解释器

>

Spring核心四模式:工厂(BeanFactory)、代理(AOP)、模板(xxTemplate)、观察者(Event)

>

消除if-else三件套:策略模式(类型分支)、责任链(校验链)、状态模式(状态流转)

>

面试回答公式:模式定义 + 应用场景 + Spring源码出处 + 手写代码 + 对比区别