設計模式實戰指南：從源碼解析到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;}
}