Spring框架核心设计模式与实践应用

发布时间：2025-03-09 05:02:06
本文热度：浏览 20 赞 0 评论 0
文章标签： Spring框架设计模式 Java开发
全文共1字，阅读约需1分钟

1. 单例模式（Singleton Pattern）

应用场景：Bean作用域管理、线程池配置、缓存系统
实现方式：通过IoC容器托管对象生命周期

@Component // 默认即为单例
public class DatabaseConfig {
    private String url = "jdbc:mysql://localhost:3306/mydb";
    
    public String getConnection() {
        return "Connected to: " + url;
    }
}

// 测试验证
@SpringBootTest
class SingletonTest {
    @Autowired
    DatabaseConfig config1;
    
    @Autowired
    DatabaseConfig config2;
    
    @Test
    void testSingleton() {
        assertSame(config1, config2); // 通过测试
    }
}

优势特征：

容器级单例（非JVM级）
支持延迟初始化
自动处理并发访问

2. 工厂模式（Factory Pattern）

核心实现：BeanFactory与ApplicationContext
典型应用：

静态工厂方法

public class PaymentFactory {
    public static Payment create(String type) {
        switch(type) {
            case "ALIPAY": return new Alipay();
            case "WECHAT": return new WechatPay();
            default: throw new IllegalArgumentException();
        }
    }
}

// 配置类
@Configuration
public class PaymentConfig {
    @Bean
    public Payment alipay() {
        return PaymentFactory.create("ALIPAY");
    }
}

工厂Bean接口

public class CustomBeanFactory implements FactoryBean<SpecialService> {
    @Override
    public SpecialService getObject() {
        return new SpecialService("v2.0");
    }
}

3. 代理模式（Proxy Pattern）

AOP实现原理：

JDK动态代理（接口代理）
CGLIB字节码增强（类代理）

切面配置示例：

@Aspect
@Component
public class LoggingAspect {
    private static final Logger logger = LoggerFactory.getLogger(LoggingAspect.class);

    @Around("execution(* com.example.service.*.*(..))")
    public Object logMethod(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        Object result = joinPoint.proceed();
        long duration = System.currentTimeMillis() - start;
        
        logger.info("Method {} executed in {} ms", 
            joinPoint.getSignature(), duration);
        return result;
    }
}

动态代理选择策略：

目标类实现接口 → JDK代理
未实现接口 → CGLIB代理
可通过@EnableAspectJAutoProxy(proxyTargetClass=true)强制CGLIB

4. 模板方法模式（Template Method Pattern）

经典应用：JdbcTemplate

public class UserDao {
    private final JdbcTemplate jdbcTemplate;

    public User findById(Long id) {
        return jdbcTemplate.queryForObject(
            "SELECT * FROM users WHERE id = ?",
            new Object[]{id},
            (rs, rowNum) -> new User(
                rs.getLong("id"),
                rs.getString("name"),
                rs.getString("email")
            )
        );
    }
}

设计优势：

消除重复代码（连接管理/异常处理）
分离可变与不可变部分
支持回调定制

5. 观察者模式（Observer Pattern）

事件驱动模型：

// 自定义事件
public class OrderEvent extends ApplicationEvent {
    private String orderId;
    public OrderEvent(Object source, String orderId) {
        super(source);
        this.orderId = orderId;
    }
}

// 事件发布
@Service
public class OrderService {
    @Autowired
    private ApplicationEventPublisher publisher;
    
    public void createOrder(Order order) {
        // 创建订单逻辑
        publisher.publishEvent(new OrderEvent(this, order.getId()));
    }
}

// 事件监听
@Component
public class NotificationListener {
    @EventListener
    public void handleOrderEvent(OrderEvent event) {
        // 发送通知逻辑
    }
}

6. 适配器模式（Adapter Pattern）

典型应用：HandlerAdapter

// 自定义Controller
public class LegacyController {
    public ModelAndView handleRequest(HttpServletRequest request) {
        // 传统处理逻辑
    }
}

// 适配器实现
public class LegacyHandlerAdapter implements HandlerAdapter {
    @Override
    public boolean supports(Object handler) {
        return handler instanceof LegacyController;
    }

    @Override
    public ModelAndView handle(HttpServletRequest request, 
                             HttpServletResponse response, 
                             Object handler) {
        LegacyController controller = (LegacyController) handler;
        return controller.handleRequest(request);
    }
}

7. 装饰器模式（Decorator Pattern）

应用实例：HttpServletRequestWrapper

public class CachingRequestWrapper extends HttpServletRequestWrapper {
    private byte[] cachedBody;

    public CachingRequestWrapper(HttpServletRequest request) throws IOException {
        super(request);
        this.cachedBody = StreamUtils.copyToByteArray(request.getInputStream());
    }

    @Override
    public ServletInputStream getInputStream() {
        return new CachedServletInputStream(cachedBody);
    }
}

// 过滤器中使用
@Component
public class CachingFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(HttpServletRequest request, 
                                  HttpServletResponse response,
                                  FilterChain filterChain) throws ServletException, IOException {
        CachingRequestWrapper wrappedRequest = new CachingRequestWrapper(request);
        filterChain.doFilter(wrappedRequest, response);
    }
}

8. 策略模式（Strategy Pattern）

事务管理实现：PlatformTransactionManager

@Configuration
@EnableTransactionManagement
public class TransactionConfig {
    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
}

// 使用示例
@Service
public class AccountService {
    @Transactional(propagation = Propagation.REQUIRED)
    public void transfer(Account from, Account to, BigDecimal amount) {
        // 转账业务逻辑
    }
}

9. 责任链模式（Chain of Responsibility）

过滤器链实现：

@Component
public class AuthFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(HttpServletRequest request,
                                  HttpServletResponse response,
                                  FilterChain chain) throws ServletException, IOException {
        if (!checkAuth(request)) {
            response.sendError(401);
            return;
        }
        chain.doFilter(request, response);
    }
}

// 配置过滤器顺序
@Configuration
public class FilterConfig {
    @Bean
    public FilterRegistrationBean<AuthFilter> authFilter() {
        FilterRegistrationBean<AuthFilter> reg = new FilterRegistrationBean<>();
        reg.setFilter(new AuthFilter());
        reg.setOrder(1);
        return reg;
    }
}

10. 建造者模式（Builder Pattern）

Spring Boot自动配置：

@SpringBootApplication
public class MyApp {
    public static void main(String[] args) {
        SpringApplication app = new SpringApplicationBuilder(MyApp.class)
            .bannerMode(Banner.Mode.OFF)
            .lazyInitialization(true)
            .build();
        app.run(args);
    }
}

// 自定义配置类
@Configuration
public class CacheConfig {
    @Bean
    public CacheManager cacheManager() {
        return new ConcurrentMapCacheManager.Builder()
            .withCache("users")
            .withCache("products")
            .build();
    }
}

模式综合应用分析

案例：声明式事务实现

代理模式（AOP增强）
模板方法（事务模板）
策略模式（事务管理器选择）
工厂模式（TransactionManager创建）

// 事务拦截器核心逻辑
public class TransactionInterceptor implements MethodInterceptor {
    private PlatformTransactionManager transactionManager;

    public Object invoke(MethodInvocation invocation) throws Throwable {
        TransactionStatus status = transactionManager.getTransaction(
            new DefaultTransactionDefinition());
        
        try {
            Object result = invocation.proceed();
            transactionManager.commit(status);
            return result;
        } catch (Exception ex) {
            transactionManager.rollback(status);
            throw ex;
        }
    }
}

设计模式选用原则

开闭原则：通过代理模式实现功能扩展
依赖倒置：面向接口编程（如PlatformTransactionManager）
最小知识原则：通过外观模式封装复杂子系统
组合优于继承：多数模式采用对象组合方式

正文到此结束

所属分类：Spring家族

本文链接： https://refblogs.com/article/939
版权声明： 本文由老牛原创发布，转载或复制请以超链接形式转载,并注明出处搬砖的码农。