1. Spring Boot与设计模式的关系解析Spring Boot作为Java生态中最流行的应用框架其成功很大程度上源于对经典设计模式的巧妙运用。框架内部大量采用了GoFGang of Four设计模式这些模式不仅解决了特定场景下的代码组织问题更为开发者提供了可复用的最佳实践方案。在实际开发中Spring Boot通过两种方式应用设计模式框架层面Spring容器自身的实现机制如依赖注入采用工厂模式应用层面开发者基于Spring特性实现的业务代码模式如使用Controller实现MVC关键认知设计模式不是Spring Boot的附属品而是框架设计的基础语言。理解这些模式能帮助我们更深入地掌握Spring Boot的工作原理。2. 创建型模式在Spring Boot中的实践2.1 单例模式Singleton的容器化实现Spring默认将Bean定义为单例但与传统单例实现有本质区别// 传统单例实现 public class ClassicSingleton { private static final ClassicSingleton instance new ClassicSingleton(); private ClassicSingleton() {} public static ClassicSingleton getInstance() { return instance; } } // Spring管理的单例 Component public class SpringSingleton { // 依赖由容器注入 Autowired private SomeDependency dependency; }核心差异生命周期管理Spring单例由容器创建/销毁传统单例伴随类加载依赖解耦Spring单例可通过DI获取依赖传统单例常需显式初始化可测试性Spring单例更易于单元测试可通过Mock替换依赖2.2 工厂模式Factory的现代演绎Spring中最典型的工厂模式实现是ApplicationContext本身。开发者可以通过多种方式创建工厂Bean方式一Configuration类中的Bean方法Configuration public class VehicleFactory { Bean Scope(prototype) public Car sportsCar() { return new Car(V8, red); } }方式二实现FactoryBean接口public class ToolFactory implements FactoryBeanTool { Override public Tool getObject() { return new SpecializedTool(); } Override public Class? getObjectType() { return Tool.class; } }实际应用场景复杂对象创建如需要多步初始化的对象动态代理生成条件化Bean创建结合Conditional2.3 建造者模式Builder在配置系统中的运用Spring Boot的自动配置大量使用了建造者模式最典型的代表是SpringApplicationBuildernew SpringApplicationBuilder() .sources(Parent.class) .child(Application.class) .profiles(cloud) .run(args);在自定义Starter开发中推荐采用建造者模式public class ServiceBuilder { private String endpoint; private int timeout 3000; public ServiceBuilder withEndpoint(String url) { this.endpoint url; return this; } public ServiceBuilder withTimeout(int ms) { this.timeout ms; return this; } public Service build() { return new RestService(endpoint, timeout); } } // 使用示例 Service public class ClientService { private final Service service; public ClientService() { this.service new ServiceBuilder() .withEndpoint(https://api.example.com) .withTimeout(5000) .build(); } }3. 结构型模式在框架中的核心应用3.1 适配器模式Adapter的统一抽象Spring MVC中的HandlerAdapter是适配器模式的经典案例它统一了不同处理器类型的调用方式// 简化版适配器接口 public interface HandlerAdapter { boolean supports(Object handler); ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception; } // 实际实现举例 public class AnnotationMethodHandlerAdapter implements HandlerAdapter { Override public boolean supports(Object handler) { return handler instanceof HandlerMethod; } Override public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { HandlerMethod hm (HandlerMethod)handler; // 反射调用实际Controller方法 return invokeHandlerMethod(request, response, hm); } }在业务代码中的应用建议第三方服务集成时创建适配器接口遗留系统改造时作为过渡方案统一不同版本的API调用3.2 装饰器模式Decorator的动态增强Spring AOP基于动态代理实现了装饰器模式典型场景如事务管理Transactional public class OrderService { public void createOrder(Order order) { // 数据库操作 } }框架实际处理流程容器启动时扫描Transactional注解为目标Bean创建代理对象方法调用时通过拦截器添加事务逻辑自定义装饰器实现方案public class CachingDecorator implements OrderService { private final OrderService delegate; private final Cache cache; public CachingDecorator(OrderService delegate, Cache cache) { this.delegate delegate; this.cache cache; } Override public Order getOrder(String id) { Order order cache.get(id); if (order null) { order delegate.getOrder(id); cache.put(id, order); } return order; } }3.3 代理模式Proxy的AOP实现Spring提供了两种代理机制JDK动态代理基于接口默认选择CGLIB代理基于类继承需配置proxyTargetClasstrue性能对比与选型建议特性JDK动态代理CGLIB代理代理方式接口实现子类继承性能创建快运行慢创建慢运行快限制需实现接口不能代理final方法适用场景轻量级代理需要类代理的情况实际配置示例# application.properties spring.aop.proxy-target-classtrue # 强制使用CGLIB4. 行为型模式的业务实践4.1 模板方法模式Template Method的优雅实践Spring的JdbcTemplate是此模式的典范其核心设计public T T execute(ConnectionCallbackT action) { Connection con DataSourceUtils.getConnection(getDataSource()); try { // 前置处理事务/连接管理 Connection conToUse prepareConnection(con); // 执行用户代码 return action.doInConnection(conToUse); } catch (SQLException ex) { // 异常转换 throw translateException(ConnectionCallback, ex); } finally { // 资源释放 releaseConnection(con, getDataSource()); } }自定义模板示例订单处理流程public abstract class OrderProcessingTemplate { public final void processOrder(Order order) { validate(order); checkInventory(order); calculatePrice(order); if (requiresApproval(order)) { approve(order); } persist(order); notifyCustomer(order); } protected abstract void checkInventory(Order order); protected abstract void calculatePrice(Order order); protected boolean requiresApproval(Order order) { return order.getTotal() 10000; } // ...其他具体步骤实现 }4.2 策略模式Strategy的多态应用Spring Security的认证机制采用策略模式public interface AuthenticationProvider { Authentication authenticate(Authentication authentication) throws AuthenticationException; boolean supports(Class? authentication); } // 具体实现示例 public class JwtAuthenticationProvider implements AuthenticationProvider { Override public Authentication authenticate(Authentication auth) { String token ((JwtAuthenticationToken)auth).getToken(); // 验证JWT逻辑 return createAuthentication(token); } Override public boolean supports(Class? authentication) { return JwtAuthenticationToken.class.isAssignableFrom(authentication); } }业务代码中的最佳实践支付渠道选择报表导出格式切换缓存策略动态调整4.3 观察者模式Observer的事件机制Spring的事件发布模型// 自定义事件 public class OrderCompletedEvent extends ApplicationEvent { private Order order; public OrderCompletedEvent(Object source, Order order) { super(source); this.order order; } // getter... } // 事件监听器 Component public class OrderEventListener { EventListener public void handleOrderCompleted(OrderCompletedEvent event) { // 发送通知、更新报表等 } } // 事件发布 Service public class OrderService { Autowired private ApplicationEventPublisher publisher; public void completeOrder(Order order) { // 业务逻辑 publisher.publishEvent(new OrderCompletedEvent(this, order)); } }性能优化建议对于耗时操作使用Async实现异步监听通过Order控制监听器执行顺序考虑使用TransactionPhase配置事务边界5. 模式组合的进阶应用5.1 组合模式Composite与责任链的融合Spring Security的过滤器链是典型示例public class VirtualFilterChain implements FilterChain { private final ListFilter additionalFilters; private final FilterChain originalChain; public void doFilter(ServletRequest request, ServletResponse response) { if (currentPosition size) { originalChain.doFilter(request, response); } else { currentPosition; Filter nextFilter additionalFilters.get(currentPosition - 1); nextFilter.doFilter(request, response, this); } } }自定义实现建议审批流程示例public interface ApprovalHandler { void handle(ApprovalContext context); void setNext(ApprovalHandler next); } public class CompositeApprovalHandler implements ApprovalHandler { private ListApprovalHandler handlers new ArrayList(); Override public void handle(ApprovalContext context) { handlers.forEach(h - h.handle(context)); } public void addHandler(ApprovalHandler handler) { handlers.add(handler); } }5.2 状态模式State与Spring状态机的结合Spring StateMachine的架构设计public interface StateMachineS, E { void sendEvent(E event); void addStateListener(StateMachineListenerS, E listener); S getState(); } // 配置示例 Configuration EnableStateMachine public class OrderStateMachineConfig extends EnumStateMachineConfigurerAdapterOrderStates, OrderEvents { Override public void configure(StateMachineStateConfigurerOrderStates, OrderEvents states) throws Exception { states.withStates() .initial(OrderStates.SUBMITTED) .states(EnumSet.allOf(OrderStates.class)); } Override public void configure(StateMachineTransitionConfigurerOrderStates, OrderEvents transitions) throws Exception { transitions .withExternal() .source(OrderStates.SUBMITTED) .target(OrderStates.PAID) .event(OrderEvents.PAY) .and() .withExternal() .source(OrderStates.PAID) .target(OrderStates.FULFILLED) .event(OrderEvents.FULFILL); } }5.3 命令模式Command在异步任务中的实践Spring的Async机制本质是命令模式的变体Service public class ReportService { Async public FutureReport generateReport(ReportRequest request) { // 耗时报表生成逻辑 return new AsyncResult(report); } } // 调用方 RestController public class ReportController { Autowired private ReportService reportService; PostMapping(/reports) public ResponseEntityString createReport() { FutureReport future reportService.generateReport(request); return ResponseEntity.accepted() .header(Location, /reports/ future.getTaskId()) .build(); } }架构建议为命令定义统一接口使用CommandExecutor集中管理考虑引入命令撤销机制6. 反模式与最佳实践6.1 Spring Boot中常见的设计模式误用单例滥用导致的状态污染Component public class StatelessService { private MapString, Object cache new HashMap(); // 危险 public void process(String key) { // 使用可变状态的业务逻辑 } }过度代理导致的调用链过长Service public class OrderService { Autowired private OrderValidator validator; // 可能被多层代理 Transactional public void createOrder(Order order) { if (validator.validate(order)) { // 每次调用都经过代理栈 // 业务逻辑 } } }模板方法模式的不合理抽象public abstract class PaymentProcessor { // 过多强制步骤限制子类灵活性 public final void process(Payment payment) { validate(payment); preProcess(payment); execute(payment); // 唯一可定制点 postProcess(payment); audit(payment); } // 多个抽象方法... }6.2 性能敏感场景的模式优化代理模式的选择策略对高频调用方法禁用AOP使用aspectj编织替代动态代理观察者模式的异步改造Configuration EnableAsync public class AsyncConfig implements AsyncConfigurer { Override public Executor getAsyncExecutor() { ThreadPoolTaskExecutor executor new ThreadPoolTaskExecutor(); executor.setCorePoolSize(5); executor.setMaxPoolSize(10); executor.setQueueCapacity(25); executor.initialize(); return executor; } } Component public class EventListener { Async EventListener public void handleAsyncEvent(SomeEvent event) { // 耗时处理 } }对象池模式补充Bean(destroyMethod close) public ObjectPoolExpensiveObject expensiveObjectPool() { return new GenericObjectPool(new BasePooledObjectFactory() { Override public ExpensiveObject create() throws Exception { return new ExpensiveObject(); } }); }6.3 测试策略与模式验证单例模式的测试隔离SpringBootTest public class SingletonTest { MockBean private SomeDependency mockDependency; Autowired private SingletonService service; Test public void testService() { when(mockDependency.someMethod()).thenReturn(...); // 测试逻辑 } }模板方法的单元测试public class TemplateTest { Test public void testCustomStep() { AbstractTemplate template new AbstractTemplate() { protected void customStep() { // 测试实现 } }; template.process(); // 验证结果 } }观察者模式的集成测试SpringBootTest public class EventTest { Autowired private ApplicationEventPublisher publisher; MockBean private EventListener listener; Test public void testEventFlow() { publisher.publishEvent(new TestEvent(this)); verify(listener, timeout(1000)).handleEvent(any()); } }