Spring中的设计模式应用

开场白：Spring与设计模式

面试官：Spring框架中用到了哪些设计模式？

我的回答：

Spring框架是设计模式的集大成者，几乎用到了所有经典的设计模式。根据我对Spring源码的理解和实际使用经验，主要有9种核心设计模式：

创建型模式（3种）：

工厂模式 - BeanFactory、FactoryBean
单例模式 - Bean默认作用域
原型模式 - prototype作用域

结构型模式（3种）：
4. 代理模式 - AOP的核心
5. 适配器模式 - SpringMVC的HandlerAdapter
6. 装饰器模式 - BeanWrapper

行为型模式（3种）：
7. 模板方法模式 - JdbcTemplate、RestTemplate等
8. 观察者模式 - 事件驱动机制
9. 策略模式 - Resource加载

我重点说说最常用的几个，特别是模板方法模式。

第一部分：创建型模式

设计模式1：工厂模式

面试官：Spring的工厂模式体现在哪里？

我的回答：

Spring的IoC容器本身就是一个超级工厂，主要体现在BeanFactory和FactoryBean。

BeanFactory（工厂接口）：

这是Spring容器的顶层接口，负责创建和管理Bean。

核心方法：

getBean() - 获取Bean实例
containsBean() - 是否包含Bean
isSingleton() - 是否单例

实际使用：

我们不直接用BeanFactory，而是用它的子类：
- ApplicationContext（最常用）
- ClassPathXmlApplicationContext
- AnnotationConfigApplicationContext

FactoryBean（工厂Bean）：

这是一个特殊的Bean，专门用来创建复杂对象。

举个例子：

我之前做数据库连接池，就实现了FactoryBean：

getObject() - 返回真正的DataSource对象
getObjectType() - 返回对象类型
isSingleton() - 是否单例

Spring会调用getObject()获取真正的Bean。

典型应用：

MyBatis的SqlSessionFactoryBean
Dubbo的ServiceBean
任何需要复杂创建逻辑的Bean

好处：

对象创建逻辑封装
符合开闭原则
便于扩展

设计模式2：单例模式

面试官：Spring的单例模式是怎么实现的？

我的回答：

Spring的Bean默认就是单例的，这是最常用的作用域。

实现方式：

Spring用一个ConcurrentHashMap来存储单例Bean：

key是beanName
value是Bean实例
容器启动时创建，整个应用生命周期共享

与传统单例的区别：

特性	传统单例（懒汉/饿汉）	Spring单例
作用域	JVM级别	Spring容器级别
创建方式	私有构造器+静态方法	容器创建
线程安全	需要自己保证	容器保证
灵活性	低（写死在代码里）	高（配置控制）

实际使用：

我们项目中90%的Bean都是单例：

Service
Repository
Controller
Configuration

只有少数场景用prototype：

每次请求需要新对象
有状态的Bean

好处：

节省内存
提高性能
便于管理

设计模式3：原型模式

面试官：原型模式在Spring中怎么体现？

我的回答：

Spring的prototype作用域就是原型模式的应用。

使用方式：

@Component
@Scope("prototype")  // 每次获取都创建新对象
public class MyBean {
}

应用场景：

我在项目中遇到过这样的场景：

处理文件上传，每个上传任务需要独立的状态
多线程处理，每个线程需要独立的对象
有状态的Bean，不能共享

与单例的对比：

特性	单例	原型
创建时机	容器启动时	每次getBean时
实例数量	1个	多个
内存占用	小	大
适用场景	无状态Bean	有状态Bean
使用比例	90%	10%

第二部分：结构型模式

设计模式4：代理模式（AOP的核心）

面试官：Spring的代理模式体现在哪里？

我的回答：

代理模式是Spring AOP的核心实现机制，也是Spring最重要的设计模式之一。

两种代理方式：

1. JDK动态代理

基于接口
通过反射和InvocationHandler
目标类有接口时使用

2. CGLIB代理

基于继承
通过生成子类
目标类没接口时使用

典型应用场景：

@Transactional（事务）：

@Service
public class UserService {
    @Transactional
    public void createUser(User user) {
        // 业务代码
    }
}

// Spring会创建代理对象：
// 代理对象.createUser() {
//   开启事务
//   执行真实对象.createUser()
//   提交或回滚事务
// }

@Cacheable（缓存）：

@Service
public class UserService {
    @Cacheable("users")
    public User getUser(Long id) {
        // Spring代理会先查缓存
        // 缓存没有才执行方法
    }
}

@Async（异步）：

@Service
public class EmailService {
    @Async
    public void sendEmail(String to) {
        // Spring代理会在新线程执行
    }
}

我的实际经验：

我们项目中大量使用代理模式：

事务管理（最多）
权限校验（自定义注解+AOP）
日志记录
性能监控

好处：

业务代码和系统功能解耦
动态增强，不修改原代码
符合开闭原则

设计模式5：适配器模式

面试官：适配器模式在Spring中的应用？

我的回答：

适配器模式在SpringMVC中用得最多，典型的是HandlerAdapter。

应用场景：SpringMVC的请求处理

SpringMVC支持多种Controller写法：

实现Controller接口
用@RequestMapping注解
实现HttpRequestHandler

不同的Controller需要不同的调用方式。Spring通过HandlerAdapter适配：

HandlerAdapter的作用：

请求来了 → DispatcherServlet
          ↓
          找到对应的Handler（Controller）
          ↓
          找到对应的HandlerAdapter
          ↓
          HandlerAdapter.handle() 执行Handler
          ↓
          返回ModelAndView

常见的HandlerAdapter：

RequestMappingHandlerAdapter - 处理@RequestMapping
SimpleControllerHandlerAdapter - 处理Controller接口
HttpRequestHandlerAdapter - 处理HttpRequestHandler

好处：

统一调用接口
支持多种Controller类型
扩展灵活

设计模式6：装饰器模式

面试官：装饰器模式在Spring中怎么用？

我的回答：

装饰器模式在Spring中主要体现在BeanWrapper、各种Wrapper类。

典型应用：BeanWrapper

BeanWrapper是对Bean的包装，提供了：

属性访问
类型转换
属性编辑

实际使用场景：

Spring的数据绑定：

表单提交的数据绑定到对象
@RequestParam到方法参数的转换
@Value注解的值注入

另一个典型：HttpServletRequestWrapper

在Filter中包装Request，添加功能：

记录请求日志
修改请求参数
添加请求头

我的实际经验：

我们项目中实现过一个RequestWrapper：

包装原始Request
读取并缓存Body（原始的只能读一次）
方便日志记录和重试

第三部分：行为型模式（重点）

设计模式7：模板方法模式（重点！）

面试官：模板方法模式在Spring中有哪些应用？

我的回答：

模板方法模式是Spring中用得最多的设计模式之一，也是我个人最喜欢的设计模式。

什么是模板方法模式？

定义一个算法的骨架，把某些步骤延迟到子类实现。父类控制流程，子类实现细节。

Spring中的典型应用：

应用1：JdbcTemplate（最经典）

这是我用得最多的，Spring对JDBC的封装。

模板方法的体现：

固定流程（模板）：
1. 获取数据库连接
2. 创建PreparedStatement
3. 设置参数
4. 执行SQL
5. 处理结果集（这步是变化的）
6. 关闭资源

JdbcTemplate帮你做1、2、3、4、6
你只需要关注第5步：怎么处理结果

实际使用：

// 查询单个对象
User user = jdbcTemplate.queryForObject(
    "SELECT * FROM user WHERE id = ?",
    new Object[]{userId},
    // 你只需要提供这个：怎么把ResultSet转成User
    (rs, rowNum) -> {
        User u = new User();
        u.setId(rs.getLong("id"));
        u.setName(rs.getString("name"));
        return u;
    }
);

好处：

我之前项目从JDBC改造成JdbcTemplate：

代码量减少了50%
不用写烦人的try-catch-finally
不用担心连接泄漏
只关注业务逻辑

模板方法的优势：

复用代码（模板部分）
便于扩展（变化部分）
符合开闭原则

应用2：RestTemplate（HTTP调用）

用来调用RESTful接口，也是模板方法。

固定流程：

创建HTTP连接
设置请求头
发送请求
接收响应
关闭连接

变化部分：

URL是什么
请求参数是什么
响应怎么处理

实际使用：

// Spring帮你处理连接、请求、关闭
// 你只需要告诉它：调用哪个URL，参数是什么，返回类型是什么
User user = restTemplate.getForObject(
    "http://api.example.com/user/{id}",
    User.class,
    userId
);

我们项目中用RestTemplate调用第三方接口，非常方便。

应用3：TransactionTemplate（事务管理）

编程式事务也是模板方法。

固定流程：

开启事务
执行业务逻辑（变化部分）
提交或回滚事务

实际使用：

transactionTemplate.execute(status -> {
    // 你只写业务逻辑
    accountMapper.deduct(accountId, 100);
    return null;
});

// Spring自动处理：
// - 开启事务
// - 异常时回滚
// - 成功时提交

应用4：RedisTemplate（Redis操作）

和JdbcTemplate类似，封装了Redis操作。

固定流程：

获取Redis连接
执行Redis命令（变化部分）
关闭连接

实际使用：

// Spring处理连接管理
// 你只关注业务逻辑
redisTemplate.opsForValue().set("key", "value");
String value = redisTemplate.opsForValue().get("key");

应用5：AbstractPlatformTransactionManager（事务管理器）

这是Spring事务管理的核心，也是模板方法的典型应用。

固定流程（模板）：

1. getTransaction() - 获取事务
2. 判断是否需要新建事务（根据传播级别）
3. doBegin() - 开启事务（子类实现）
4. 执行业务逻辑
5. commit() 或 rollback()
   ↓
6. doCommit() 或 doRollback()（子类实现）
7. 清理资源

子类实现：

DataSourceTransactionManager - JDBC事务
HibernateTransactionManager - Hibernate事务
JtaTransactionManager - JTA分布式事务

变化的部分由子类实现：

怎么开启事务（JDBC的connection.setAutoCommit(false)）
怎么提交（connection.commit()）
怎么回滚（connection.rollback()）

固定的部分由父类实现：

事务传播行为
事务隔离级别
超时控制
事务同步

这是模板方法模式的完美体现！

应用6：AbstractApplicationContext（容器初始化）

Spring容器的启动流程也是模板方法。

固定流程：

refresh() 方法定义了容器启动的标准流程：
1. prepareRefresh() - 准备刷新
2. obtainFreshBeanFactory() - 获取BeanFactory
3. prepareBeanFactory() - 准备BeanFactory
4. postProcessBeanFactory() - 后置处理（子类扩展）
5. invokeBeanFactoryPostProcessors() - 调用后置处理器
6. registerBeanPostProcessors() - 注册Bean后置处理器
7. initMessageSource() - 初始化消息源
8. initApplicationEventMulticaster() - 初始化事件广播器
9. onRefresh() - 刷新（子类扩展）
10. registerListeners() - 注册监听器
11. finishBeanFactoryInitialization() - 实例化单例Bean
12. finishRefresh() - 完成刷新

子类可以扩展的步骤：

postProcessBeanFactory()
onRefresh()

比如SpringBoot就扩展了onRefresh()来启动Web容器。

这个模板方法定义了Spring容器的标准启动流程！

模板方法模式的核心理解

面试官：能总结一下模板方法模式的精髓吗？

我的回答：

模板方法模式的精髓就是：控制反转（IoC）的一种体现。

传统方式：

你写代码：
1. 获取连接
2. 创建Statement
3. 执行SQL
4. 处理结果
5. 关闭连接

你控制整个流程

模板方法：

框架写代码：
1. 获取连接
2. 创建Statement
3. 执行SQL
4. 调用你的回调（处理结果）
5. 关闭连接

框架控制流程，你只提供变化部分

好处：

代码复用：固定流程不用重复写
防止错误：不会忘记关闭连接
专注业务：只关注业务逻辑
便于扩展：新增逻辑只要实现回调

Spring中使用模板方法的类：

类名	用途	固定流程	变化部分
JdbcTemplate	数据库操作	连接管理、资源关闭	SQL、结果处理
RestTemplate	HTTP调用	连接管理、请求发送	URL、参数、响应处理
TransactionTemplate	事务管理	开启、提交、回滚	业务逻辑
RedisTemplate	Redis操作	连接管理	Redis命令
JmsTemplate	消息队列	连接管理	消息处理
AbstractApplicationContext	容器启动	标准启动流程	子类扩展点

我的实际使用经验：

我们项目中：

90%的数据库操作用JdbcTemplate或MyBatis（内部也用了模板）
HTTP调用用RestTemplate或OpenFeign（基于RestTemplate）
这些Template类帮我们省了大量重复代码

模板方法模式是Spring"约定优于配置"理念的体现！

第三部分：其他重要模式

设计模式8：观察者模式（事件驱动）

面试官：Spring的事件机制用了什么设计模式？

我的回答：

观察者模式，Spring的事件驱动机制就是观察者模式的应用。

核心组件：

ApplicationEvent - 事件（被观察的对象）
ApplicationListener - 监听器（观察者）
ApplicationEventPublisher - 事件发布器（主题）

实际使用：

自定义事件：

// 1. 定义事件
public class OrderCreatedEvent extends ApplicationEvent {
    private Order order;
    
    public OrderCreatedEvent(Object source, Order order) {
        super(source);
        this.order = 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 OrderListener {
    @EventListener
    public void handleOrderCreated(OrderCreatedEvent event) {
        // 处理订单创建事件
        // 比如：发送通知、扣减库存等
    }
}

我的实际使用：

我们项目中用事件机制做解耦：

订单创建 → 发事件 → 多个监听器处理（库存、积分、通知）
用户注册 → 发事件 → 发送欢迎邮件、赠送优惠券

好处：

业务解耦
易于扩展（新增监听器不影响原代码）
异步处理（可以配置异步监听）

Spring内置事件：

ContextRefreshedEvent - 容器刷新完成
ContextStartedEvent - 容器启动
ContextStoppedEvent - 容器停止
ContextClosedEvent - 容器关闭

设计模式9：策略模式

面试官：策略模式在Spring中的应用？

我的回答：

策略模式主要体现在Resource加载和Bean初始化策略。

Resource加载策略：

Spring支持多种资源加载方式：

ClassPathResource - 从classpath加载
FileSystemResource - 从文件系统加载
UrlResource - 从URL加载
ServletContextResource - 从Web容器加载

统一接口：

Resource resource = resourceLoader.getResource("classpath:config.xml");
// 或
Resource resource = resourceLoader.getResource("file:/path/to/file");
// 或
Resource resource = resourceLoader.getResource("http://example.com/file");

// 统一的操作方式
InputStream is = resource.getInputStream();

好处：

统一的资源访问接口
不同的加载策略可以切换
符合开闭原则

另一个应用：Bean实例化策略

SimpleInstantiationStrategy - 简单实例化（反射）
CglibSubclassingInstantiationStrategy - CGLIB实例化

Spring根据情况选择不同策略。

第四部分：设计模式总结

面试官：能总结一下Spring中最重要的设计模式吗？

我的回答：

好的，我按使用频率和重要性排序：

使用频率排序

排名	设计模式	典型应用	使用场景	重要程度
1	代理模式	AOP、@Transactional	无处不在	⭐⭐⭐⭐⭐
2	工厂模式	BeanFactory、IoC容器	Bean创建	⭐⭐⭐⭐⭐
3	单例模式	Bean默认作用域	90%的Bean	⭐⭐⭐⭐⭐
4	模板方法	JdbcTemplate等	Template类	⭐⭐⭐⭐⭐
5	观察者模式	事件机制	业务解耦	⭐⭐⭐⭐
6	适配器模式	HandlerAdapter	SpringMVC	⭐⭐⭐⭐
7	策略模式	Resource加载	资源处理	⭐⭐⭐
8	装饰器模式	BeanWrapper	数据绑定	⭐⭐⭐
9	原型模式	prototype作用域	有状态Bean	⭐⭐

四大核心设计模式（面试重点）

1. 代理模式 - AOP的基础

应用最广泛
Spring的核心特性
面试必问

2. 工厂模式 - IoC的基础

Spring容器的核心
BeanFactory体系
面试必问

3. 模板方法模式 - 代码复用的典范

JdbcTemplate等大量应用
实际开发常用
面试常问

4. 单例模式 - Bean管理的默认方式

90%的Bean都是单例
面试常问

各设计模式的应用场景

场景1：数据库操作 → JdbcTemplate（模板方法）

固定：连接管理、异常处理
变化：SQL、结果映射

场景2：事务管理 → 代理模式 + 模板方法

代理：@Transactional拦截
模板：TransactionTemplate固定流程

场景3：Bean创建 → 工厂模式 + 单例模式

工厂：BeanFactory创建Bean
单例：默认缓存单例Bean

场景4：Web请求 → 适配器模式

适配：HandlerAdapter适配不同Controller

场景5：业务解耦 → 观察者模式

发布事件：业务操作完成
监听处理：多个监听器响应

第五部分：模板方法模式深度剖析

面试官：详细说说Spring的模板方法模式吧

我的回答：

好的，模板方法模式是我在实际开发中体会最深的设计模式。

模板方法的设计思想

核心思想：

父类定义算法骨架（不变的流程），子类实现具体步骤（变化的逻辑）。

好处：

代码复用 - 不变的流程只写一次
控制反转 - 框架调用你的代码，不是你调用框架
防止错误 - 固定流程由框架保证
便于扩展 - 只需实现变化部分

JdbcTemplate的完整流程

固定流程（JdbcTemplate提供）：

execute()方法内部：
1. 获取数据库连接（从连接池）
2. try {
3.   创建PreparedStatement
4.   设置参数（你提供）
5.   执行SQL
6.   处理结果集（你提供）
7. } catch (异常处理)
8. } finally {
9.   关闭PreparedStatement
10.  归还连接到连接池
}

你只需要提供：

SQL语句
参数
结果集处理逻辑（RowMapper）

传统JDBC vs JdbcTemplate对比

传统JDBC代码：

大概需要30-50行代码：
1. 加载驱动
2. 获取连接
3. 创建Statement
4. 设置参数
5. 执行SQL
6. 处理结果
7. 关闭ResultSet
8. 关闭Statement
9. 关闭Connection
10. 处理各种异常
11. finally确保资源关闭

容易出错：
- 忘记关闭连接（连接泄漏）
- 异常处理不当
- 代码重复

JdbcTemplate代码：

只需要3-5行代码：
jdbcTemplate.query(
    "SELECT * FROM user WHERE id = ?",
    new Object[]{userId},
    rowMapper
);

不会出错：
- 框架保证连接关闭
- 异常统一处理
- 代码简洁

我的实际经验：

我们项目从JDBC改造成JdbcTemplate后：

数据库操作代码量减少60%
连接泄漏问题完全消失
代码可读性大大提高

模板方法模式的其他应用

Spring中到处都是模板方法：

InitializingBean接口：

固定流程：
1. 实例化Bean
2. 注入属性
3. 调用afterPropertiesSet()（你实现）
4. 调用init-method（你配置）

BeanPostProcessor接口：

固定流程：
1. postProcessBeforeInitialization()（你实现）
2. Bean初始化
3. postProcessAfterInitialization()（你实现）

Filter过滤器链：

固定流程：
1. 执行过滤器1
2. 执行过滤器2
3. 执行Servlet（变化部分）
4. 返回过滤器2
5. 返回过滤器1

Interceptor拦截器：

固定流程：
1. preHandle()（你实现）
2. 执行Controller
3. postHandle()（你实现）
4. afterCompletion()（你实现）

模板方法的变体：回调机制

Spring很多地方用了回调，本质也是模板方法：

JdbcTemplate的回调：

jdbcTemplate.execute(connection -> {
    // 你的代码，框架会传入connection
    PreparedStatement ps = connection.prepareStatement(sql);
    return ps.executeUpdate();
});

TransactionTemplate的回调：

transactionTemplate.execute(status -> {
    // 你的代码，框架传入事务状态
    // 可以手动回滚：status.setRollbackOnly()
    return result;
});

SessionCallback（Hibernate）：

hibernateTemplate.execute(session -> {
    // 你的代码，框架传入session
    return session.get(User.class, userId);
});

回调和模板方法的关系：

回调是模板方法的一种实现方式
用函数式接口或匿名内部类实现变化部分
更加灵活和简洁

第六部分：面试技巧

回答这个问题的完整思路

1. 开场（30秒）

Spring用到了很多设计模式
是设计模式的集大成者

2. 分类介绍（5分钟）

创建型：工厂、单例、原型
结构型：代理、适配器、装饰器
行为型：模板方法、观察者、策略

3. 重点展开模板方法（3分钟）

JdbcTemplate的应用
其他Template类
模板方法的好处

4. 实际经验（1分钟）

自己用过哪些
带来了什么好处

面试加分项

说这些会加分：

✅ 分类清晰
"按创建型、结构型、行为型分类..."

✅ 举实际例子
"我们项目用JdbcTemplate，代码量减少60%..."

✅ 说出底层实现
"代理模式通过JDK动态代理或CGLIB实现..."

✅ 对比优缺点
"传统JDBC需要30行代码，JdbcTemplate只要3行..."

✅ 提到源码
"看过AbstractPlatformTransactionManager的源码，refresh()方法定义了12个步骤..."

千万不要说的话

说这些会减分：

❌ "Spring用了设计模式，但我不知道具体哪些"
❌ "模板方法就是父类定义方法，子类继承"（太简单）
❌ "我没看过Spring源码"
❌ "设计模式在实际开发中没什么用"

第七部分：快速记忆

口诀记忆

Spring设计模式九字诀：

工 - 工厂模式（BeanFactory）
单 - 单例模式（Bean默认）
代 - 代理模式（AOP核心）
模 - 模板方法（Template类）
观 - 观察者（事件机制）
适 - 适配器（HandlerAdapter）
策 - 策略模式（Resource）
装 - 装饰器（BeanWrapper）
原 - 原型模式（prototype）

模板方法应用记忆：

Jdbc数据库，Rest调HTTP
Transaction管事务，Redis操缓存
Jms管消息，Hibernate管持久
到处都是Template，固定流程变化填

模板方法精髓：

框架定骨架，开发填变化
复用不变的，扩展变化的
控制要反转，回调来实现

附录：高频问题清单

以下是面试常问的问题：

基础问题

✅ Spring用了哪些设计模式？
✅ 工厂模式在Spring中的应用？
✅ 单例模式在Spring中的实现？
✅ 代理模式在Spring中的应用？
✅ 模板方法模式在Spring中的应用？

深度问题

✅ JdbcTemplate是如何体现模板方法的？
✅ Spring的事件机制用了什么设计模式？
✅ SpringMVC的HandlerAdapter是什么模式？
✅ 模板方法和策略模式的区别？
✅ Spring如何选择JDK代理还是CGLIB代理？

实战问题

✅ 你在项目中用过哪些Template类？
✅ 你自己实现过FactoryBean吗？
✅ 你用过Spring的事件机制吗？
✅ 模板方法模式有什么好处？

本文档已经覆盖了所有这些问题！

总结：核心观点

面试官：最后总结一下你的理解

我的回答：

好的，我总结一下：

观点1：Spring是设计模式的最佳实践

Spring不是为了用设计模式而用设计模式，而是真正解决了实际问题。每个设计模式的使用都有其道理。

观点2：模板方法模式最能体现Spring的设计理念

"约定优于配置"、"控制反转"，这些理念都在模板方法中体现。框架控制流程，开发者只关注业务。

观点3：理解设计模式，更好地使用Spring

了解Spring用了哪些设计模式，可以：

更好地理解Spring的工作原理
写出更优雅的代码
遇到问题时知道从哪里入手

观点4：不要为了模式而模式

设计模式是为了解决问题，不是为了炫技。实际开发中：

先解决问题
再考虑用什么模式优化
保持代码简单

观点5：Template类是Spring的精髓

JdbcTemplate、RestTemplate这些Template类：

代表了Spring的设计哲学
极大地简化了开发
是我最喜欢的Spring特性

我的核心理念：理解设计模式，不死记硬背，关键是理解为什么这么设计。

posted @ 2026-01-26 12:02 菜鸟~风阅读(5) 评论(0) 收藏举报

刷新页面返回顶部