🎯 设计模式实战指南：从源码解析到Java后端架构的艺术

概述

本文档基于设计模式分类，详细介绍Java后端开发中各种设计模式的实际应用场景，结合Spring、MyBatis、Redis等主流框架的源码分析，帮助开发者深入理解设计模式在实践中的价值。

一、创建型模式

1. 单例模式（Singleton Pattern）

应用场景

数据库连接池
缓存管理器
配置管理器
日志记录器

Spring框架中的应用

Spring IoC容器本身就是单例模式的典型应用

// Spring ApplicationContext 单例实现
public class AnnotationConfigApplicationContext extends GenericApplicationContext {
    private final AnnotatedBeanDefinitionReader reader;
    private final ClassPathBeanDefinitionScanner scanner;
    
    public AnnotationConfigApplicationContext() {
        this.reader = new AnnotatedBeanDefinitionReader(this);
        this.scanner = new ClassPathBeanDefinitionScanner(this);
    }
}

Spring Bean的默认作用域就是单例

// Spring BeanFactory 中的单例管理
public class DefaultSingletonBeanRegistry extends FactoryBeanRegistrySupport {
    // 单例对象缓存
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
    
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
            // 单例创建逻辑
        }
        return singletonObject;
    }
}

Redis客户端单例应用

// JedisPool 单例模式实现
public class RedisManager {
    private static volatile JedisPool jedisPool;
    
    public static JedisPool getInstance() {
        if (jedisPool == null) {
            synchronized (RedisManager.class) {
                if (jedisPool == null) {
                    JedisPoolConfig config = new JedisPoolConfig();
                    config.setMaxTotal(100);
                    config.setMaxIdle(10);
                    jedisPool = new JedisPool(config, "localhost", 6379);
                }
            }
        }
        return jedisPool;
    }
}

2. 工厂方法模式（Factory Method Pattern）

应用场景

数据库连接工厂
消息队列工厂
缓存工厂
序列化器工厂

Spring框架中的应用

BeanFactory - Spring的核心工厂

// Spring BeanFactory 接口
public interface BeanFactory {
    Object getBean(String name) throws BeansException;
    <T> T getBean(String name, Class<T> requiredType) throws BeansException;
    <T> T getBean(Class<T> requiredType) throws BeansException;
}

// 具体实现类
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
        implements ConfigurableListableBeanFactory, BeanDefinitionRegistry {
    
    @Override
    public <T> T getBean(Class<T> requiredType) throws BeansException {
        return getBean(requiredType, (Object[]) null);
    }
}

MyBatis中的工厂应用

// MyBatis SqlSessionFactory
public interface SqlSessionFactory {
    SqlSession openSession();
    SqlSession openSession(boolean autoCommit);
    SqlSession openSession(Connection connection);
}

// 默认实现
public class DefaultSqlSessionFactory implements SqlSessionFactory {
    @Override
    public SqlSession openSession() {
        return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
    }
}

3. 抽象工厂模式（Abstract Factory Pattern）

应用场景

数据库访问层抽象
消息中间件抽象
缓存系统抽象

Spring JDBC中的应用

// 数据源抽象工厂
public interface DataSource extends CommonDataSource, Wrapper {
    Connection getConnection() throws SQLException;
    Connection getConnection(String username, String password) throws SQLException;
}

// 具体实现
public class HikariDataSource extends HikariConfig implements DataSource {
    @Override
    public Connection getConnection() throws SQLException {
        return getConnection(username, password);
    }
}

4. 建造者模式（Builder Pattern）

应用场景

复杂对象构建
配置对象构建
查询条件构建

MyBatis中的应用

// MyBatis SqlSessionFactoryBuilder
public class SqlSessionFactoryBuilder {
    public SqlSessionFactory build(InputStream inputStream) {
        return build(inputStream, null, null);
    }
    
    public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
        try {
            XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
            return build(parser.parse());
        } catch (Exception e) {
            throw ExceptionFactory.wrapException("Error building SqlSession.", e);
        }
    }
}

Spring Boot配置构建

// Spring Boot ApplicationBuilder
public class SpringApplicationBuilder {
    private final SpringApplication application;
    
    public SpringApplicationBuilder(Class<?>... sources) {
        this.application = new SpringApplication(sources);
    }
    
    public SpringApplicationBuilder properties(String... defaultProperties) {
        this.application.setDefaultProperties(StringUtils.toStringArray(defaultProperties));
        return this;
    }
}

5. 原型模式（Prototype Pattern）

应用场景

对象克隆
配置复制
模板复制

Spring中的应用

// Spring Bean的prototype作用域
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory {
    @Override
    public Object getBean(String name) throws BeansException {
        return doGetBean(name, null, null, false);
    }
    
    protected <T> T doGetBean(String name, Class<T> requiredType, Object[] args, boolean typeCheckOnly) {
        // 对于prototype作用域的bean，每次都创建新实例
        if (mbd.isPrototype()) {
            Object prototypeInstance = null;
            try {
                beforePrototypeCreation(beanName);
                prototypeInstance = createBean(beanName, mbd, args);
            } finally {
                afterPrototypeCreation(beanName);
            }
            bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
        }
    }
}

二、结构型模式

1. 适配器模式（Adapter Pattern）

应用场景

接口适配
数据格式转换
第三方库集成

Spring MVC中的应用

// HandlerAdapter 适配不同类型的处理器
public interface HandlerAdapter {
    boolean supports(Object handler);
    ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;
}

// RequestMappingHandlerAdapter 适配 @RequestMapping 注解的处理器
public class RequestMappingHandlerAdapter extends AbstractHandlerMethodAdapter {
    @Override
    public boolean supports(Object handler) {
        return handler instanceof HandlerMethod;
    }
    
    @Override
    protected ModelAndView handleInternal(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
        // 处理逻辑
    }
}

MyBatis中的适配器

// MyBatis TypeHandler 适配器
public interface TypeHandler<T> {
    void setParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException;
    T getResult(ResultSet rs, String columnName) throws SQLException;
    T getResult(ResultSet rs, int columnIndex) throws SQLException;
    T getResult(CallableStatement cs, int columnIndex) throws SQLException;
}

// 具体实现
public class StringTypeHandler extends BaseTypeHandler<String> {
    @Override
    public void setNonNullParameter(PreparedStatement ps, int i, String parameter, JdbcType jdbcType) throws SQLException {
        ps.setString(i, parameter);
    }
    
    @Override
    public String getNullableResult(ResultSet rs, String columnName) throws SQLException {
        return rs.getString(columnName);
    }
}

2. 桥接模式（Bridge Pattern）

应用场景

抽象与实现分离
多维度变化
平台无关性

JDBC桥接模式

// JDBC驱动桥接
public interface Driver {
    Connection connect(String url, Properties info) throws SQLException;
    boolean acceptsURL(String url) throws SQLException;
}

// MySQL驱动实现
public class Driver implements java.sql.Driver {
    @Override
    public Connection connect(String url, Properties info) throws SQLException {
        // MySQL连接实现
    }
}

// PostgreSQL驱动实现
public class Driver implements java.sql.Driver {
    @Override
    public Connection connect(String url, Properties info) throws SQLException {
        // PostgreSQL连接实现
    }
}

3. 组合模式（Composite Pattern）

应用场景

树形结构
菜单系统
权限管理

Spring Security中的应用

// Spring Security 权限组合
public interface GrantedAuthority extends Serializable {
    String getAuthority();
}

// 角色权限组合
public class SimpleGrantedAuthority implements GrantedAuthority {
    private final String role;
    
    public SimpleGrantedAuthority(String role) {
        this.role = role;
    }
    
    @Override
    public String getAuthority() {
        return this.role;
    }
}

4. 装饰器模式（Decorator Pattern）

应用场景

功能增强
缓存装饰
日志装饰

Spring AOP装饰器

// Spring AOP 代理装饰
public interface AopProxy {
    Object getProxy();
    Object getProxy(ClassLoader classLoader);
}

// JDK动态代理装饰
public class JdkDynamicAopProxy implements AopProxy, InvocationHandler {
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 前置增强
        // 目标方法调用
        // 后置增强
    }
}

MyBatis插件装饰器

// MyBatis Interceptor 装饰器
public interface Interceptor {
    Object intercept(Invocation invocation) throws Throwable;
    Object plugin(Object target);
    void setProperties(Properties properties);
}

// 分页插件装饰器
public class PageInterceptor implements Interceptor {
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        // 分页逻辑装饰
        return invocation.proceed();
    }
}

5. 外观模式（Facade Pattern）

应用场景

复杂子系统封装
API简化
统一接口

Spring Boot自动配置外观

// Spring Boot 自动配置外观
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

// 内部封装了复杂的配置过程
public class SpringApplication {
    public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
        return new SpringApplication(primarySources).run(args);
    }
}

6. 享元模式（Flyweight Pattern）

应用场景

对象池
缓存
字符串常量池

数据库连接池

// HikariCP 连接池享元模式
public class HikariDataSource extends HikariConfig implements DataSource {
    private final HikariPool pool;
    
    @Override
    public Connection getConnection() throws SQLException {
        return pool.getConnection();
    }
}

// 连接池管理
public class HikariPool extends PoolBase {
    private final ConcurrentBag<PoolEntry> connectionBag;
    
    public Connection getConnection() throws SQLException {
        PoolEntry poolEntry = connectionBag.borrow(connectionTimeout, MILLISECONDS);
        return poolEntry.createProxyConnection(now(), leakTaskFactory.schedule(poolEntry));
    }
}

7. 代理模式（Proxy Pattern）

应用场景

远程代理
虚拟代理
保护代理
缓存代理

Spring AOP代理

// Spring AOP 代理实现
public class ProxyFactory extends ProxyCreatorSupport {
    public Object getProxy() {
        return createAopProxy().getProxy();
    }
}

// CGLIB代理
public class CglibAopProxy implements AopProxy {
    @Override
    public Object getProxy() {
        return getProxy(null);
    }
    
    @Override
    public Object getProxy(ClassLoader classLoader) {
        // CGLIB代理创建逻辑
    }
}

MyBatis动态代理

// MyBatis Mapper代理
public class MapperProxy<T> implements InvocationHandler, Serializable {
    private final SqlSession sqlSession;
    private final Class<T> mapperInterface;
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 动态代理逻辑
        return sqlSession.selectOne(statement, args);
    }
}

三、行为型模式

1. 责任链模式（Chain of Responsibility Pattern）

应用场景

过滤器链
异常处理链
权限验证链

Spring Security过滤器链

// Spring Security 过滤器链
public class FilterChainProxy extends GenericFilterBean {
    private List<SecurityFilterChain> filterChains;
    
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        doFilterInternal(request, response, chain);
    }
    
    private void doFilterInternal(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        // 过滤器链执行逻辑
        for (Filter filter : filters) {
            filter.doFilter(request, response, chain);
        }
    }
}

MyBatis插件链

// MyBatis 插件责任链
public class Plugin implements InvocationHandler {
    private final Object target;
    private final Interceptor interceptor;
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        return interceptor.intercept(new Invocation(target, method, args));
    }
}

2. 命令模式（Command Pattern）

应用场景

操作封装
事务管理
异步处理

Spring事务命令

// Spring 事务命令模式
public interface TransactionTemplate {
    <T> T execute(TransactionCallback<T> action) throws TransactionException;
}

// 具体实现
public class TransactionTemplate extends DefaultTransactionDefinition implements TransactionOperations {
    @Override
    public <T> T execute(TransactionCallback<T> action) throws TransactionException {
        TransactionStatus status = this.transactionManager.getTransaction(this);
        T result;
        try {
            result = action.doInTransactionWithoutResult(status);
        } catch (RuntimeException | Error ex) {
            rollbackOnException(status, ex);
            throw ex;
        }
        this.transactionManager.commit(status);
        return result;
    }
}

3. 解释器模式（Interpreter Pattern）

应用场景

表达式解析
配置解析
查询语言解析

MyBatis SQL解析

// MyBatis SQL解析器
public class SqlSourceBuilder {
    public SqlSource parse(String originalSql, Class<?> parameterType, Map<String, Object> additionalParameters) {
        ParameterMappingTokenHandler handler = new ParameterMappingTokenHandler(configuration, parameterType, additionalParameters);
        GenericTokenParser parser = new GenericTokenParser("#{", "}", handler);
        String sql = parser.parse(originalSql);
        return new StaticSqlSource(configuration, sql, handler.getParameterMappings());
    }
}

4. 迭代器模式（Iterator Pattern）

应用场景

集合遍历
分页查询
流式处理

Spring Data分页迭代

// Spring Data 分页迭代器
public interface Page<T> extends Slice<T> {
    int getTotalPages();
    long getTotalElements();
    List<T> getContent();
}

// 具体实现
public class PageImpl<T> implements Page<T> {
    private final List<T> content;
    private final Pageable pageable;
    private final long total;
    
    @Override
    public Iterator<T> iterator() {
        return content.iterator();
    }
}

5. 中介者模式（Mediator Pattern）

应用场景

组件通信
事件处理
协调管理

Spring事件机制

// Spring 事件中介者
public interface ApplicationEventPublisher {
    void publishEvent(ApplicationEvent event);
    void publishEvent(Object event);
}

// 具体实现
public class SimpleApplicationEventMulticaster extends AbstractApplicationEventMulticaster {
    @Override
    public void multicastEvent(ApplicationEvent event) {
        multicastEvent(event, resolveDefaultEventType(event));
    }
    
    @Override
    public void multicastEvent(final ApplicationEvent event, ResolvableType type) {
        // 事件分发逻辑
        for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {
            invokeListener(listener, event);
        }
    }
}

6. 备忘录模式（Memento Pattern）

应用场景

状态保存
事务回滚
撤销操作

Spring事务状态管理

// Spring 事务状态备忘录
public interface TransactionStatus extends SavepointManager, Flushable {
    boolean isNewTransaction();
    boolean hasTransaction();
    boolean isRollbackOnly();
    boolean isCompleted();
}

// 具体实现
public class DefaultTransactionStatus extends AbstractTransactionStatus {
    private final Object transaction;
    private final boolean newTransaction;
    private boolean rollbackOnly;
    private boolean completed;
}

7. 观察者模式（Observer Pattern）

应用场景

事件通知
状态同步
日志记录

Spring事件机制

// Spring 观察者模式
public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {
    void onApplicationEvent(E event);
}

// 具体实现
@Component
public class UserEventListener implements ApplicationListener<UserCreatedEvent> {
    @Override
    public void onApplicationEvent(UserCreatedEvent event) {
        // 处理用户创建事件
        System.out.println("User created: " + event.getUser());
    }
}

8. 状态模式（State Pattern）

应用场景

状态机
工作流
订单状态

Spring状态机

// Spring Statemachine 状态模式
public interface StateMachine<S, E> {
    State<S, E> getState();
    void sendEvent(E event);
    void start();
    void stop();
}

// 具体实现
@Configuration
@EnableStateMachine
public class OrderStateMachineConfig extends StateMachineConfigurerAdapter<OrderState, OrderEvent> {
    @Override
    public void configure(StateMachineStateConfigurer<OrderState, OrderEvent> states) throws Exception {
        states
            .withStates()
            .initial(OrderState.CREATED)
            .state(OrderState.PAID)
            .state(OrderState.SHIPPED)
            .end(OrderState.DELIVERED);
    }
}

9. 策略模式（Strategy Pattern）

应用场景

算法选择
支付方式
缓存策略

Spring缓存策略

// Spring 缓存策略
public interface CacheManager {
    Cache getCache(String name);
    Collection<String> getCacheNames();
}

// Redis缓存策略
public class RedisCacheManager implements CacheManager {
    @Override
    public Cache getCache(String name) {
        return new RedisCache(name, redisTemplate);
    }
}

// EhCache缓存策略
public class EhCacheCacheManager implements CacheManager {
    @Override
    public Cache getCache(String name) {
        return new EhCacheCache(name, ehcache);
    }
}

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

应用场景

算法框架
流程控制
代码复用

Spring JdbcTemplate

// Spring JdbcTemplate 模板方法
public class JdbcTemplate extends JdbcAccessor implements JdbcOperations {
    @Override
    public <T> T queryForObject(String sql, Class<T> requiredType, Object... args) throws DataAccessException {
        return queryForObject(sql, args, requiredType);
    }
    
    @Override
    public <T> T queryForObject(String sql, Object[] args, Class<T> requiredType) throws DataAccessException {
        List<T> results = queryForList(sql, args, requiredType);
        return DataAccessUtils.singleResult(results);
    }
    
    // 模板方法，子类可以重写
    protected <T> List<T> queryForList(String sql, Object[] args, Class<T> elementType) throws DataAccessException {
        return query(sql, args, getSingleColumnRowMapper(elementType));
    }
}

11. 访问者模式（Visitor Pattern）

应用场景

数据结构操作
编译优化
代码生成

Spring Bean访问者

// Spring Bean访问者
public interface BeanDefinitionVisitor {
    void visitBeanDefinition(BeanDefinition beanDefinition);
}

// 具体实现
public class BeanDefinitionVisitorImpl implements BeanDefinitionVisitor {
    @Override
    public void visitBeanDefinition(BeanDefinition beanDefinition) {
        // 访问Bean定义
        String beanClassName = beanDefinition.getBeanClassName();
        // 处理逻辑
    }
}

四、设计原则在Java后端开发中的应用

1. 单一职责原则（SRP）

// 好的设计：职责分离
@Service
public class UserService {
    public User createUser(UserDTO userDTO) {
        // 只负责用户创建逻辑
    }
}

@Service
public class EmailService {
    public void sendWelcomeEmail(User user) {
        // 只负责邮件发送逻辑
    }
}

2. 开闭原则（OCP）

// 通过接口扩展，对修改关闭
public interface PaymentStrategy {
    void pay(BigDecimal amount);
}

@Component
public class AlipayStrategy implements PaymentStrategy {
    @Override
    public void pay(BigDecimal amount) {
        // 支付宝支付逻辑
    }
}

@Component
public class WechatPayStrategy implements PaymentStrategy {
    @Override
    public void pay(BigDecimal amount) {
        // 微信支付逻辑
    }
}

3. 里氏替换原则（LSP）

// 子类可以替换父类
public interface Cache {
    void put(String key, Object value);
    Object get(String key);
}

public class RedisCache implements Cache {
    @Override
    public void put(String key, Object value) {
        // Redis实现
    }
    
    @Override
    public Object get(String key) {
        // Redis实现
    }
}

public class EhCache implements Cache {
    @Override
    public void put(String key, Object value) {
        // EhCache实现
    }
    
    @Override
    public Object get(String key) {
        // EhCache实现
    }
}

4. 接口隔离原则（ISP）

// 接口分离，避免胖接口
public interface UserReader {
    User findById(Long id);
    List<User> findAll();
}

public interface UserWriter {
    User save(User user);
    void delete(Long id);
}

public interface UserService extends UserReader, UserWriter {
    // 组合多个小接口
}

5. 依赖倒置原则（DIP）

// 依赖抽象而不是具体实现
@Service
public class OrderService {
    private final PaymentStrategy paymentStrategy;
    
    public OrderService(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }
    
    public void processOrder(Order order) {
        paymentStrategy.pay(order.getAmount());
    }
}

6. 迪米特法则（LoD）

// 减少对象间的耦合
@Service
public class OrderService {
    private final UserService userService;
    
    public void createOrder(OrderDTO orderDTO) {
        // 不直接访问User的内部属性
        User user = userService.getUserById(orderDTO.getUserId());
        // 通过User的方法获取需要的信息
        if (user.canCreateOrder()) {
            // 创建订单逻辑
        }
    }
}

7. 合成复用原则（CRP）

// 优先使用组合而不是继承
@Service
public class OrderService {
    private final UserService userService;
    private final ProductService productService;
    private final PaymentService paymentService;
    
    // 通过组合复用功能，而不是继承
    public Order createOrder(OrderDTO orderDTO) {
        User user = userService.getUserById(orderDTO.getUserId());
        Product product = productService.getProductById(orderDTO.getProductId());
        // 创建订单逻辑
        return order;
    }
}

五、设计模式的最佳实践

1. 模式选择原则

优先使用组合而非继承
针对接口编程而非实现
遵循开闭原则
保持简单性

2. 常见反模式

过度设计：不要为了使用模式而使用模式
模式滥用：避免在不合适的地方使用设计模式
忽略性能：某些模式可能带来性能开销

3. 性能考虑

// 单例模式的双重检查锁定
public class Singleton {
    private static volatile Singleton instance;
    
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

4. 测试友好性

// 依赖注入便于测试
@Service
public class UserService {
    private final UserRepository userRepository;
    private final EmailService emailService;
    
    public UserService(UserRepository userRepository, EmailService emailService) {
        this.userRepository = userRepository;
        this.emailService = emailService;
    }
    
    // 方法便于单元测试
    public User createUser(UserDTO userDTO) {
        User user = new User(userDTO);
        user = userRepository.save(user);
        emailService.sendWelcomeEmail(user);
        return user;
    }
}

总结

设计模式是Java后端开发中的重要工具，它们帮助我们：

提高代码质量：通过模式化的设计，代码更加清晰、可维护
增强可扩展性：遵循开闭原则，便于功能扩展
提升开发效率：复用成熟的设计方案，避免重复造轮子
改善团队协作：统一的代码风格和架构模式

在实际开发中，应该根据具体场景选择合适的模式，避免过度设计，同时注重性能和可测试性。通过深入理解Spring、MyBatis等主流框架的源码，我们可以更好地掌握设计模式的实际应用。