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

发布于:2025-06-21 ⋅ 阅读:(10) ⋅ 点赞:(0)

🎯 设计模式实战指南:从源码解析到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 

网站公告

今日签到

点亮在社区的每一天
去签到