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> {@Overridepublic MyObject getObject() throws Exception {return new MyObject(); // 复杂对象的创建逻辑}@Overridepublic 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> {@Overridepublic 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 {@Overridepublic boolean supports(Object handler) {return handler instanceof Controller;}@Overridepublic 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);}@Overridepublic String getParameter(String name) {System.out.println("获取参数: " + name);return super.getParameter(name);}
}// 在 Filter 中使用
public class LogFilter implements Filter {@Overridepublic 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();

概括

• 解耦：工厂模式、代理模式。
• 扩展性：策略模式、观察者模式。
• 复用性：模板方法模式、适配器模式。
• 控制复杂度：责任链模式、装饰器模式。