设计模式入门：从 GoF 分类到 SOLID 原则实战

一、设计模式的起源与核心价值

1.1 为什么需要设计模式？

在软件开发中，重复解决相似问题会导致：

代码冗余：相同逻辑重复实现（如日志模块）
维护困难：修改一处影响多处（如硬编码策略）
扩展性差：新增功能需大幅改动现有代码

设计模式通过可复用的解决方案模板，帮助开发者：

提升代码可维护性（遵循开闭原则）
降低模块耦合度（依赖倒置原则）
加速设计决策（直接应用成熟方案）

1.2 GoF 23 种模式分类

1994 年《设计模式：可复用面向对象软件的基础》提出经典分类，形成设计模式的 "瑞士军刀"：
创建型模式单例工厂建造者原型结构型模式代理装饰器适配器组合行为型模式策略模板方法观察者责任链

二、面向对象设计五大核心原则（SOLID）

2.1 单一职责原则（SRP）

定义：一个类只负责一项职责反例：

java 复制代码

// 反模式：同时处理用户认证和日志记录  
public class UserService {  
    public boolean login(String username, String password) {  
        // 认证逻辑  
        log("用户登录:" + username);  
        return true;  
    }  
    private void log(String msg) {  
        // 日志写入文件  
    }  
}

重构：

java 复制代码

// 拆分认证服务与日志服务  
public class UserAuthService { /* 认证逻辑 */ }  
public class LoggerService { /* 日志写入 */ }

2.2 开闭原则（OCP）

定义：对扩展开放，对修改关闭实现方式：

通过接口定义行为（Logger接口）
具体实现类继承接口（FileLogger, ConsoleLogger）
客户端依赖接口而非实现

实战：

java 复制代码

// 定义日志接口  
public interface Logger {  
    void log(String message);  
}  
// 扩展实现（无需修改原有代码）  
public class FileLogger implements Logger { /* 文件日志 */ }  
public class ConsoleLogger implements Logger { /* 控制台日志 */ }  
// 客户端注入接口（Spring依赖注入）  
@Service  
public class OrderService {  
    private final Logger logger;  
    public OrderService(Logger logger) { this.logger = logger; }  
}

2.3 依赖倒置原则（DIP）

定义：高层模块不依赖低层模块，共同依赖抽象错误实践：

java 复制代码

// 高层模块直接依赖具体实现（数据库操作）  
public class UserRepository {  
    private MySQLConnection conn; // 低层模块  
}

正确实践：

java 复制代码

// 定义抽象接口  
public interface DatabaseConnection { /* 数据库连接 */ }  
// 具体实现（MySQL/Oracle）  
public class MySQLConnection implements DatabaseConnection { /* ... */ }  
// 高层模块依赖抽象  
public class UserRepository {  
    private final DatabaseConnection conn;  
    public UserRepository(DatabaseConnection conn) { this.conn = conn; }  
}

2.4 里氏替换原则（LSP）

定义：子类可替换父类而不影响程序逻辑案例：

java 复制代码

// 正方形不应继承长方形（违反面积计算逻辑）  
class Rectangle {  
    protected int width, height;  
    public void setWidth(int w) { width = w; }  
    public void setHeight(int h) { height = h; }  
}  
// 反模式：正方形强制要求width=height  
class Square extends Rectangle {  
    @Override  
    public void setWidth(int w) {  
        width = w;  
        height = w; // 破坏里氏替换原则  
    }  
}

2.5 接口隔离原则（ISP）

定义：客户端不依赖不需要的接口方法反模式：

java 复制代码

// 胖接口包含无关方法  
public interface Animal {  
    void eat();  
    void fly(); // 非所有动物都会飞  
}  
class Pig implements Animal {  
    @Override public void eat() { /* ... */ }  
    @Override public void fly() { throw new UnsupportedOperationException(); } // 强制实现无用方法  
}

重构：

java 复制代码

// 拆分为独立接口  
public interface EatAble { void eat(); }  
public interface FlyAble { void fly(); }  
class Pig implements EatAble { /* 仅实现进食 */ }  
class Bird implements EatAble, FlyAble { /* 实现两种能力 */ }

三、设计模式在 Java 生态中的典型应用

3.1 JDK 中的模式实践

模式	JDK 类 / 方法	应用场景
工厂模式	Calendar.getInstance()	创建不同时区的日历实例
单例模式	Runtime.getRuntime()	全局唯一运行时环境
观察者模式	Observable/Observer	AWT 事件监听机制

3.2 Spring 框架中的模式应用

工厂模式：

java 复制代码

// BeanFactory创建Bean实例  
ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");  
UserService userService = context.getBean("userService", UserService.class);

代理模式：

java 复制代码

// AOP实现方法增强  
@Transactional  
public void createOrder() { /* 订单创建 */ }

模板方法：

java 复制代码

// JdbcTemplate简化数据库操作  
jdbcTemplate.query("SELECT * FROM USER", (rs) -> new User(rs.getInt("id")));

3.3 Spring 框架深度模式解析

3.3.1 装饰器模式（Decorator Pattern）

框架应用：

BeanPostProcessor：增强 Bean 功能（如 AOP 代理生成）
HandlerInterceptor：请求处理链增强（日志记录、权限校验）

源码解析：

java 复制代码

// BeanPostProcessor装饰器链  
public interface BeanPostProcessor {  
    Object postProcessBeforeInitialization(Object bean, String beanName);  
    Object postProcessAfterInitialization(Object bean, String beanName);  
}  
// 典型实现：ProxyProcessorSupport（生成AOP代理）  
protected Object postProcessAfterInitialization(Object bean, String beanName) {  
    if (!this.targetSourcedBeans.contains(beanName)) {  
        return createProxy(bean, beanName, specificInterceptors, new SingletonTargetSource(bean));  
    }  
    return bean;  
}

3.3.2 策略模式（Strategy Pattern）

应用场景：

事务管理策略：PlatformTransactionManager支持不同事务源（JTA/DataSource）
消息转换器：HttpMessageConverter支持多种数据格式（JSON/XML）

配置示例：

java 复制代码

// 声明不同事务策略  
@Bean  
public PlatformTransactionManager jtaTransactionManager() {  
    return new JtaTransactionManager();  
}  
@Bean  
public PlatformTransactionManager dataSourceTransactionManager(DataSource dataSource) {  
    return new DataSourceTransactionManager(dataSource);  
}  
// 根据环境选择策略  
@Service  
public class OrderService {  
    @Autowired  
    private PlatformTransactionManager transactionManager;  
}

3.3.3 责任链模式（Chain of Responsibility Pattern）

核心实现：

Filter 链：DispatcherServlet处理请求的过滤器链（DelegatingFilterProxy）
异常处理链：HandlerExceptionResolver处理不同类型异常

请求处理流程：
客户端请求 DispatcherServlet HandlerMapping HandlerAdapter HandlerInterceptor.preHandle 目标Controller HandlerInterceptor.postHandle ViewResolver

3.4 Spring Boot 自动配置中的模式应用

3.4.1 工厂模式（Factory Pattern）

自动配置原理：

EnableAutoConfiguration通过AutoConfigurationImportSelector加载配置类
@ConditionalOnMissingBean避免重复创建 Bean

案例：数据库连接池自动配置

java 复制代码

// DataSourceAutoConfiguration  
@Bean  
@ConditionalOnMissingBean  
public DataSource dataSource(DataSourceProperties properties) {  
    return properties.initializeDataSourceBuilder().type(this::getDataSourceType).build();  
}

3.4.2 模板方法（Template Method）

核心抽象类：

AbstractApplicationContext：模板方法refresh()定义容器启动流程
RepositoryRestConfigurer：提供扩展点供用户自定义

容器启动模板：

java 复制代码

public abstract class AbstractApplicationContext extends DefaultResourceLoader  
        implements ConfigurableApplicationContext {  
    @Override  
    public void refresh() throws BeansException, IllegalStateException {  
        synchronized (this.startupShutdownMonitor) {  
            prepareRefresh();  
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();  
            prepareBeanFactory(beanFactory);  
            // 模板方法扩展点  
            onRefresh();  
        }  
    }  
    protected void onRefresh() { /* 子类实现 */ }  
}

3.5 Spring Cloud 中的模式实践

3.5.1 代理模式（Proxy Pattern）

OpenFeign 远程调用：

通过动态代理生成 HTTP 客户端
整合 Ribbon 负载均衡与 Sentinel 熔断

代理生成逻辑：

java 复制代码

// FeignClientFactoryBean  
public Object getObject() throws Exception {  
    return getTarget();  
}  
<T> T getTarget() {  
    FeignContext context = applicationContext.getBean(FeignContext.class);  
    Feign.Builder builder = feign(context);  
    // 生成代理对象  
    return (T) builder.target(type, getUrl());  
}

3.5.2 责任链模式（Filter Chain）

Spring Cloud Gateway：

路由过滤器链实现请求转换（鉴权 / 限流 / 参数校验）
支持自定义过滤器顺序（Ordered接口）

配置示例：

yml 复制代码

spring:  
  cloud:  
    gateway:  
      routes:  
      - id: order-service  
        uri: lb://order-service  
        predicates:  
        - Path=/api/order/**  
        filters:  
        - name: RequestRateLimiter  
          args:  
            key-resolver: "#{@ipKeyResolver}"  
        - name: HeaderFilter  
          args:  
            request-headers-to-add:  
              - name: X-Request-Id  
                value: "#{UUID.randomUUID().toString()}"

四、企业级框架模式应用对比（新增章节）

4.1 主流框架模式使用频率统计

模式类型	Spring Framework	Spring Boot	Spring Cloud	MyBatis
工厂模式	★★★★☆	★★★★★	★★★★☆	★★★☆☆
代理模式	★★★★★	★★★☆☆	★★★★★	★★★★☆
模板方法	★★★☆☆	★★★☆☆	★★☆☆☆	★★★★☆
责任链模式	★★★☆☆	★★☆☆☆	★★★★☆	★★☆☆☆

4.2 模式选择决策树（Spring 场景）

是是复杂创建否是否是否是是否需要对象创建逻辑封装? 简单创建? 工厂模式建造者模式是否需要功能增强? 代理/装饰器模式是否需要算法动态切换? 策略模式是否需要流程控制? 责任链/模板方法

4.3 常见误区

过度设计：简单场景滥用模式（如单例用于无状态工具类）
忽视原则：优先满足模式结构而违背 SOLID 原则
脱离场景：不结合业务需求选择模式（如用工厂模式处理简单对象创建）

五、模式应用最佳实践（Spring 场景）

5.1 避免模式误用的三个原则

优先原则而非模式：先满足 SOLID 原则，再考虑模式实现
- 反例：为使用工厂模式而强行拆分简单类
结合框架特性：利用 Spring 现有模式扩展点（如@Conditional替代硬编码条件判断）
控制复杂度：单个类模式应用不超过 2 种（避免过度设计）

5.2 模式组合使用案例

场景：实现可扩展的日志系统

工厂模式：创建不同日志处理器（文件 / 数据库 / 控制台）
策略模式：动态切换日志级别（DEBUG/INFO/ERROR）
装饰器模式：为日志处理器添加加密 / 压缩功能

实现架构：

java 复制代码

// 工厂创建策略实例  
LoggerFactory.getLogger(Strategy.LOCAL_FILE);  
// 装饰器增强功能  
Logger logger = new EncryptDecorator(new CompressDecorator(logger));

通过补充 Spring 及扩展框架中的模式应用，开发者能更深入理解设计模式在实际框架中的落地方式。这些案例不仅展示了模式的具体实现，更体现了如何通过模式组合解决复杂问题。下一篇我们将进入创建型模式专题，详细解析单例模式的线程安全实现与工厂模式的扩展应用。

设计模式的核心不是记忆 23 种模板，而是培养 "识别问题→匹配方案→验证原则" 的思维方式：

识别重复问题：发现代码中相似的设计痛点（如硬编码策略）

匹配成熟方案：从模式库中选择最适合的解决方案（如策略模式替代大量条件判断）

验证设计原则：确保实现符合 SOLID 原则（如依赖倒置保证扩展性）
通过后续系列博客，我们将深入每种模式的实现细节，并结合 Spring、微服务等实战场景，演示如何用模式思维解决复杂系统设计问题。