Spring涉及的设计模式以及实际使用场景(含代码)
1.工厂模式（Factory Pattern）
作用: 隐藏对象创建的细节，通过工厂类统一管理对象的实例化。
场景：Spring的BeanFactory和ApplicationContext是工厂模式的典型实现。
// 通过ApplicationContext获取Bean
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = context.getBean("userService", UserService.class);
// 自定义 FactoryBean
public class MyFactoryBean implements FactoryBean<MyObject> {
@Override
public MyObject getObject() throws Exception {
return new MyObject(); // 复杂对象的创建逻辑
}
@Override
public Class<?> getObjectType() {
return MyObject.class;
}
}
2.单例模式（Singleton Pattern）
作用:确保一个类只有一个实例，并提供全局访问点。
场景:Spring默认的Bean的作用域为单例。
@Service // 默认 singleton
public class OrderService {
// ...
}
// 测试单例
OrderService bean1 = context.getBean(OrderService.class);
OrderService bean2 = context.getBean(OrderService.class);
System.out.println(bean1 == bean2); // 输出 true
3.代理模式(Proxy Pattern)
作用：通过代理对象控制对目标对象的访问，用于增强功能(AOP)
场景：Spring AOP通过动态代理实现日志，事务等功能。
@Aspect
@Component
public class LogAspect {
@Before("execution(* com.example.service.*.*(..))")
public void logBefore(JoinPoint joinPoint) {
System.out.println("方法调用前: " + joinPoint.getSignature().getName());
}
}
// 使用 @Transactional 注解（基于代理实现事务）
@Transactional
public void transferMoney(Account from, Account to, double amount) {
// 转账逻辑
}
4.模版方法模式(Template Method Pattern)
作用:定义算法的骨架，将某些步骤延迟到子类中实现
场景：JdbcTemplate封装了JDBC的固定流程
@Autowired
private JdbcTemplate jdbcTemplate;
public List<User> getUsers() {
return jdbcTemplate.query(
"SELECT * FROM users",
(rs, rowNum) -> new User(rs.getString("name"), rs.getInt("age"))
);
}
5.观察者模式(Observer Pattern)
作用:定义对象间的一对多依赖，当一个对象状态变化时，自动通知依赖它的对象。
场景：Spring事件监听机制
// 自定义事件
public class OrderEvent extends ApplicationEvent {
public OrderEvent(String orderId) {
super(orderId);
}
}
// 监听器
@Component
public class OrderEventListener implements ApplicationListener<OrderEvent> {
@Override
public void onApplicationEvent(OrderEvent event) {
System.out.println("处理订单事件: " + event.getSource());
}
}
// 发布事件
@Autowired
private ApplicationEventPublisher publisher;
public void createOrder() {
publisher.publishEvent(new OrderEvent("ORDER_123"));
}
6.策略模式(Strategy Pattern)
作用:定义一系列算法，使其可以互相替换，独立于客户端发生变化
场景:Spring的ResourceLoader根据前缀选择资源加载策略
ResourceLoader loader = new DefaultResourceLoader();
Resource fileResource = loader.getResource("file:/tmp/test.txt");
Resource classpathResource = loader.getResource("classpath:application.yml");
7.适配器模式(Adapter Pattern)
作用：将一个接口转换成客户期待的接口
场景:Spring MVC 的 HandlerAdapter 适配不同 Controller。
// 模拟 SimpleControllerHandlerAdapter 的适配逻辑
public class SimpleControllerHandlerAdapter implements HandlerAdapter {
@Override
public boolean supports(Object handler) {
return handler instanceof Controller;
}
@Override
public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) {
return ((Controller) handler).handleRequest(request, response);
}
}
8.装饰器模式(Decorator Pattern）
作用：动态为对象添加额外职责
场景：Spring对HttpServletRequest的包装
// 自定义装饰器
public class LoggingRequestWrapper extends HttpServletRequestWrapper {
public LoggingRequestWrapper(HttpServletRequest request) {
super(request);
}
@Override
public String getParameter(String name) {
System.out.println("获取参数: " + name);
return super.getParameter(name);
}
}
// 在 Filter 中使用
public class LogFilter implements Filter {
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) {
chain.doFilter(new LoggingRequestWrapper((HttpServletRequest) request), response);
}
}
9.责任链模式（Chain of Responsibility Pattern）
作用:将请求的发送者和接收者解耦，通过链式处理请求。
场景:Spring Security 的过滤器链。
// 模拟过滤器链
public class FilterChainDemo {
private List<Filter> filters = new ArrayList<>();
public void addFilter(Filter filter) {
filters.add(filter);
}
public void doFilter(HttpServletRequest request) {
for (Filter filter : filters) {
filter.execute(request);
}
}
}
// 使用
FilterChainDemo chain = new FilterChainDemo();
chain.addFilter(new AuthFilter());
chain.addFilter(new LoggingFilter());
chain.doFilter(request);
10.原型模式（prototype Pattern）
作用:通过复制现有对象来创建新对象，避免重复初始化开销
场景:Spring 的 prototype 作用域 Bean。
@Component
@Scope("prototype")
public class PaymentService {
// 每次获取都是新实例
}
// 测试
PaymentService bean1 = context.getBean(PaymentService.class);
PaymentService bean2 = context.getBean(PaymentService.class);
System.out.println(bean1 == bean2); // 输出 false
11.建造者模式(Builder Pattern)
作用:分步骤构建复杂对象
场景:RestTemplateBuilder构建复杂对象
RestTemplate restTemplate = new RestTemplateBuilder()
.rootUri("https://api.example.com")
.defaultHeader("Authorization", "Bearer token")
.build();
概括
- 解耦：工厂模式、代理模式。
- 扩展性：策略模式、观察者模式。
- 复用性：模板方法模式、适配器模式。
- 控制复杂度：责任链模式、装饰器模式。