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

🎯 设计模式实战指南：从源码解析到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 AbstractAutowireCapableBeanFactoryimplements ConfigurableListableBeanFactory, BeanDefinitionRegistry {@Overridepublic <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 {@Overridepublic 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 {@Overridepublic 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 {@Overridepublic 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 {@Overridepublic boolean supports(Object handler) {return handler instanceof HandlerMethod;}@Overrideprotected 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> {@Overridepublic void setNonNullParameter(PreparedStatement ps, int i, String parameter, JdbcType jdbcType) throws SQLException {ps.setString(i, parameter);}@Overridepublic 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 {@Overridepublic Connection connect(String url, Properties info) throws SQLException {// MySQL连接实现}
}// PostgreSQL驱动实现
public class Driver implements java.sql.Driver {@Overridepublic 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;}@Overridepublic 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 {@Overridepublic 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 {@Overridepublic 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;@Overridepublic 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 {@Overridepublic Object getProxy() {return getProxy(null);}@Overridepublic Object getProxy(ClassLoader classLoader) {// CGLIB代理创建逻辑}
}

MyBatis动态代理

// MyBatis Mapper代理
public class MapperProxy<T> implements InvocationHandler, Serializable {private final SqlSession sqlSession;private final Class<T> mapperInterface;@Overridepublic 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;@Overridepublic 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;@Overridepublic 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 {@Overridepublic <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;@Overridepublic 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 {@Overridepublic void multicastEvent(ApplicationEvent event) {multicastEvent(event, resolveDefaultEventType(event));}@Overridepublic 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> {@Overridepublic 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> {@Overridepublic 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 {@Overridepublic Cache getCache(String name) {return new RedisCache(name, redisTemplate);}
}// EhCache缓存策略
public class EhCacheCacheManager implements CacheManager {@Overridepublic Cache getCache(String name) {return new EhCacheCache(name, ehcache);}
}

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

应用场景

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

Spring JdbcTemplate

// Spring JdbcTemplate 模板方法
public class JdbcTemplate extends JdbcAccessor implements JdbcOperations {@Overridepublic <T> T queryForObject(String sql, Class<T> requiredType, Object... args) throws DataAccessException {return queryForObject(sql, args, requiredType);}@Overridepublic <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 {@Overridepublic 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 {@Overridepublic void pay(BigDecimal amount) {// 支付宝支付逻辑}
}@Component
public class WechatPayStrategy implements PaymentStrategy {@Overridepublic void pay(BigDecimal amount) {// 微信支付逻辑}
}

3. 里氏替换原则（LSP）

// 子类可以替换父类
public interface Cache {void put(String key, Object value);Object get(String key);
}public class RedisCache implements Cache {@Overridepublic void put(String key, Object value) {// Redis实现}@Overridepublic Object get(String key) {// Redis实现}
}public class EhCache implements Cache {@Overridepublic void put(String key, Object value) {// EhCache实现}@Overridepublic 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;}
}