当前位置：首页 > news >正文

设计模式在Spring中的应用

news 2026/5/28 19:57:45

设计模式在Spring中的应用

引言

Spring框架是Java企业级开发的事实标准，其设计本身就大量运用了经典设计模式。深入理解这些设计模式，不仅能帮助我们更好地使用Spring，还能提升整体架构设计能力。本文将从创建型、结构型、行为型三个维度，系统分析设计模式在Spring框架中的具体应用场景和实现原理。

一、创建型模式

1.1 单例模式

Spring默认将所有Bean作为单例管理，通过BeanFactory实现单例Bean的创建和缓存。

// Spring通过DefaultSingletonBeanRegistry实现单例 public class DefaultSingletonBeanRegistry { // 单例缓存 private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(); // 获取单例Bean protected Object getSingleton(String beanName) { Object singleton = singletonObjects.get(beanName); if (singleton == null) { singleton = createSingleton(beanName); singletonObjects.put(beanName, singleton); } return singleton; } } // Spring配置单例 @Configuration public class SingletonConfig { @Bean @Scope("singleton") // 默认就是单例 public UserService userService() { return new UserService(); } }

1.2 工厂模式

Spring的BeanFactory是工厂模式的典型应用，BeanDefinitionRegistry负责Bean的注册管理。

// 抽象工厂 public interface BeanFactory { Object getBean(String name); <T> T getBean(Class<T> requiredType); <T> T getBean(String name, Class<T> type); } // 工厂Bean接口 public interface FactoryBean<T> { T getObject(); Class<?> getObjectType(); boolean isSingleton(); } // 自定义工厂Bean @Component public class ConnectionFactoryBean implements FactoryBean<Connection> { @Override public Connection getObject() { return createConnection(); } @Override public Class<Connection> getObjectType() { return Connection.class; } }

1.3 建造者模式

Spring的EmbeddedDatabaseBuilder、MockMvcBuilders等使用了建造者模式。

// Spring的建造者模式示例 @Bean public DataSource dataSource() { return new EmbeddedDatabaseBuilder() .setType(EmbeddedDatabaseType.H2) .setName("testdb") .addScript("classpath:schema.sql") .addScript("classpath:data.sql") .build(); } // MockMvcBuilders的建造者模式 private MockMvc mockMvc = MockMvcBuilders .webAppContextSetup(webApplicationContext) .filters(new CharacterEncodingFilter("UTF-8", true)) .apply(springSecurity()) .build();

二、结构型模式

2.1 代理模式

Spring AOP基于代理模式实现，提供了JDK动态代理和CGLIB两种代理方式。

// JDK动态代理接口 public interface UserService { void createUser(User user); } // JDK动态代理实现 public class JdkProxyHandler implements InvocationHandler { private final Object target; public JdkProxyHandler(Object target) { this.target = target; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // 前置增强 before(method); Object result = method.invoke(target, args); // 后置增强 after(method); return result; } } // 代理工厂 public class ProxyFactory { public static <T> T createProxy(T target, Class<T> interface_) { return (T) Proxy.newProxyInstance( interface_.getClassLoader(), new Class[]{interface_}, new JdkProxyHandler(target) ); } }

2.2 装饰器模式

Spring的IOUtils、HttpInputMessage等使用了装饰器模式增强功能。

// 装饰器模式示例：缓存装饰器 public class CachedUserRepository implements UserRepository { private final UserRepository target; private final Cache cache; public CachedUserRepository(UserRepository target, Cache cache) { this.target = target; this.cache = cache; } @Override public Optional<User> findById(Long id) { String key = "user:" + id; return cache.get(key, () -> target.findById(id)); } @Override public User save(User user) { User saved = target.save(user); cache.evict("user:" + saved.getId()); return saved; } }

2.3 适配器模式

Spring MVC的HandlerAdapter和Spring Security的AuthenticationProvider都使用了适配器模式。

// 通用处理器接口 public interface HandlerAdapter { boolean supports(Object handler); ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler); } // Spring MVC的适配器实现 public class RequestMappingHandlerAdapter implements HandlerAdapter { @Override public boolean supports(Object handler) { return handler instanceof HandlerMethod; } @Override public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) { HandlerMethod handlerMethod = (HandlerMethod) handler; // 适配处理 return invokeHandlerMethod(request, response, handlerMethod); } }

三、行为型模式

3.1 模板方法模式

Spring的JdbcTemplate、HibernateTemplate等使用模板方法封装重复逻辑。

// JdbcTemplate的模板方法模式 public abstract class JdbcAccessor { protected DataSource dataSource; public void setDataSource(DataSource dataSource) { this.dataSource = dataSource; } } public class JdbcTemplate extends JdbcAccessor { public <T> T execute(ConnectionCallback<T> action) { Connection conn = DataSourceUtils.getConnection(dataSource); try { return action.doInConnection(conn); } finally { DataSourceUtils.releaseConnection(conn, dataSource); } } public <T> T query(String sql, RowMapper<T> rowMapper) { return execute(conn -> { PreparedStatement ps = conn.prepareStatement(sql); ResultSet rs = ps.executeQuery(); return extractData(rs, rowMapper); }); } }

3.2 策略模式

Spring的TransactionManager、ViewResolver等使用策略模式支持多种实现。

// 事务策略接口 public interface TransactionManager { TransactionStatus getTransaction( TransactionDefinition definition); void commit(TransactionStatus status); void rollback(TransactionStatus status); } // 具体策略实现 public class DataSourceTransactionManager implements TransactionManager { @Override public TransactionStatus getTransaction( TransactionDefinition definition) { // 获取数据库连接，开始事务 } } public class JpaTransactionManager implements TransactionManager { @Override public TransactionStatus getTransaction( TransactionDefinition definition) { // 获取EntityManager，开始JPA事务 } }

3.3 观察者模式

Spring的ApplicationEvent和ApplicationListener是观察者模式的实现。

// 事件 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; } } // 监听器 @Component public class OrderEventListener { @EventListener public void handleOrderCreated(OrderCreatedEvent event) { Order order = event.getOrder(); // 处理订单创建事件 sendNotification(order); updateInventory(order); recordMetrics(order); } } // 发布事件 @Service public class OrderService { private final ApplicationEventPublisher publisher; public Order createOrder(Order order) { Order saved = orderRepository.save(order); publisher.publishEvent(new OrderCreatedEvent(this, saved)); return saved; } }

3.4 责任链模式

Spring Security的FilterChain和Spring Web的HandlerInterceptor使用责任链模式。

// Spring Security的过滤器链 public interface Filter { void doFilter(ServletRequest request, ServletResponse response, FilterChain chain); } public class FilterChainProxy { private List<Filter> filters; public void doFilter(ServletRequest request, ServletResponse response) { new VirtualFilterChain(request, response, filters).doFilter(); } private static class VirtualFilterChain implements FilterChain { private final ServletRequest request; private final ServletResponse response; private final List<Filter> filters; private int currentPosition = 0; @Override public void doFilter(ServletRequest request, ServletResponse response) { if (currentPosition < filters.size()) { Filter filter = filters.get(currentPosition++); filter.doFilter(request, response, this); } } } }

四、Spring Boot中的设计模式

4.1 自动配置中的策略模式

// 条件选择器 @Configuration @ConditionalOnClass(RedisTemplate.class) public class RedisAutoConfiguration { @Bean @ConditionalOnMissingBean(StringRedisTemplate.class) public StringRedisTemplate stringRedisTemplate() { return new StringRedisTemplate(); } } @Configuration @ConditionalOnClass(CacheManager.class) @ConditionalOnProperty(name = "spring.cache.type", havingValue = "redis") public class RedisCacheConfiguration { // Redis缓存配置 }

4.2 多数据源路由

// 动态数据源路由 public class RoutingDataSource extends AbstractDataSource { private final Map<Object, DataSource> targetDataSources; private DataSource determineDataSource() { String key = RoutingDataSourceHolder.getDataSourceKey(); return targetDataSources.getOrDefault(key, targetDataSources.values().iterator().next()); } } // 数据源选择策略 public interface DataSourceStrategy { String getDataSourceKey(); } @Service public class ReadWriteStrategy implements DataSourceStrategy { @Override public String getDataSourceKey() { return isReadOnly() ? "read" : "write"; } private boolean isReadOnly() { // 根据方法名或注解判断 return true; } }