深入理解设计模式——从 Java 源码到 Spring 框架的实战解析
一、引言
设计模式（Design Patterns）是软件工程中经过反复验证的、针对特定问题的可复用解决方案。1994年，GoF（Gang of Four，即 Erich Gamma、Richard Helm、Ralph Johnson 和 John Vlissides）出版了《设计模式：可复用面向对象软件的基础》一书，正式将 23 种设计模式引入软件工程领域。三十年来，这些模式已深刻影响了几乎所有主流框架和语言的设计。
理解设计模式不仅仅是背诵 UML 类图和定义的样板代码，更关键的是能够在 JDK、Spring、MyBatis 等真实项目中识别其应用，并灵活运用于日常开发。本文将从创建型、结构型、行为型三大类别出发，深入分析核心模式，并结合作者亲历的真实场景给出实战建议。
二、创建型模式（Creational Patterns）
创建型模式专注于对象创建机制，旨在将对象的创建与使用分离，提升系统的灵活性和可维护性。
2.1 单例模式（Singleton）
单例模式确保一个类仅有一个实例，并提供全局访问点。看似简单，但实现中的线程安全性、序列化问题和反射攻击等细节值得深入探讨。
饿汉式
public class EagerSingleton {
private static final EagerSingleton INSTANCE = new EagerSingleton();
private EagerSingleton() {}
public static EagerSingleton getInstance() { return INSTANCE; }
}
优点：实现简单，线程安全。缺点：类加载即初始化，可能造成资源浪费。
懒汉式（双重检查锁定）
public class LazySingleton {
private static volatile LazySingleton instance;
private LazySingleton() {}
public static LazySingleton getInstance() {
if (instance == null) {
synchronized (LazySingleton.class) {
if (instance == null) {
instance = new LazySingleton();
}
}
}
return instance;
}
}
volatile 关键字至关重要：它禁止指令重排序，确保 instance = new LazySingleton() 的写操作对其他线程立即可见。
静态内部类（推荐方式）
public class StaticInnerSingleton {
private StaticInnerSingleton() {}
private static class Holder {
static final StaticInnerSingleton INSTANCE = new StaticInnerSingleton();
}
public static StaticInnerSingleton getInstance() { return Holder.INSTANCE; }
}
JVM 的类加载机制保证了线程安全，同时实现了延迟加载。这是兼顾简洁与性能的最佳方案。
枚举实现
public enum EnumSingleton {
INSTANCE;
public void doSomething() { /* ... */ }
}
枚举实现天然防止反射攻击和序列化问题，是 Joshua Bloch 强烈推荐的方式。
Spring 中的应用：Spring 的 AbstractBeanFactory 中的单例注册表（singletonObjects）在 DefaultSingletonBeanRegistry 中实现：
// DefaultSingletonBeanRegistry
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
public Object getSingleton(String beanName, ObjectFactory singletonFactory) {
synchronized (this.singletonObjects) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
singletonObject = singletonFactory.getObject();
this.singletonObjects.put(beanName, singletonObject);
}
return singletonObject;
}
}
2.2 工厂模式（Factory Pattern）
工厂模式将对象的创建逻辑封装到专门的工厂类中，使客户端代码与具体实现类解耦。
简单工厂
public class PaymentFactory {
public static Payment create(String type) {
return switch (type) {
case "alipay" -> new Alipay();
case "wechat" -> new WechatPay();
default -> throw new IllegalArgumentException("Unknown payment type: " + type);
};
}
}
工厂方法
interface PaymentFactory {
Payment createPayment();
}
class AlipayFactory implements PaymentFactory {
public Payment createPayment() { return new Alipay(); }
}
class WechatPayFactory implements PaymentFactory {
public Payment createPayment() { return new WechatPay(); }
}
抽象工厂
抽象工厂适用于创建一组相关或相互依赖的对象：
| 产品族 | 产品A（支付） | 产品B（退款） |
|---|---|---|
| 国内支付 | AlipayPayment | AlipayRefund |
| 国际支付 | StripePayment | StripeRefund |
Spring 中的应用：Spring IoC 容器本身就是一座庞大的抽象工厂。BeanFactory 是核心工厂接口，ApplicationContext 是其扩展。Spring 通过 FactoryBean 接口允许自定义对象的创建逻辑：
public class MyServiceFactoryBean implements FactoryBean<MyService> {
@Override
public MyService getObject() { return new MyService(/* complex init */); }
@Override
public Class getObjectType() { return MyService.class; }
@Override
public boolean isSingleton() { return true; }
}
2.3 建造者模式（Builder Pattern）
建造者模式将一个复杂对象的构建与其表示分离，使同样的构建过程可以创建不同的表示。
public class HttpClientConfig {
private final String baseUrl;
private final int connectTimeout;
private final int readTimeout;
private final boolean retryEnabled;
private HttpClientConfig(Builder builder) {
this.baseUrl = builder.baseUrl;
this.connectTimeout = builder.connectTimeout;
this.readTimeout = builder.readTimeout;
this.retryEnabled = builder.retryEnabled;
}
public static class Builder {
private String baseUrl;
private int connectTimeout = 5000;
private int readTimeout = 10000;
private boolean retryEnabled = false;
public Builder baseUrl(String baseUrl) { this.baseUrl = baseUrl; return this; }
public Builder connectTimeout(int ms) { this.connectTimeout = ms; return this; }
public Builder readTimeout(int ms) { this.readTimeout = ms; return this; }
public Builder retryEnabled(boolean v) { this.retryEnabled = v; return this; }
public HttpClientConfig build() { return new HttpClientConfig(this); }
}
}
使用方式：
HttpClientConfig config = new HttpClientConfig.Builder()
.baseUrl("https://api.example.com")
.connectTimeout(3000)
.readTimeout(5000)
.retryEnabled(true)
.build();
MyBatis 中的应用：SqlSessionFactoryBuilder 是一个典型的建造者：
SqlSessionFactory factory = new SqlSessionFactoryBuilder()
.build(Resources.getResourceAsStream("mybatis-config.xml"));
Lombok 的 @Builder：现代 Java 开发中，Lombok 通过 @Builder 注解自动生成建造者模式的代码。
@Builder
@Getter
public class UserDTO {
private Long id;
private String name;
private String email;
private Integer age;
}
// 使用
UserDTO dto = UserDTO.builder().name("张三").email("zhangsan@example.com").age(28).build();
三、结构型模式（Structural Patterns）
结构型模式关注类和对象的组合，通过继承或组合形成更大的结构。
3.1 代理模式（Proxy Pattern）
代理模式为另一个对象提供一个替身，以控制对这个对象的访问。
静态代理
interface UserService {
void save(User user);
}
class UserServiceImpl implements UserService {
public void save(User user) { System.out.println("Saving user: " + user); }
}
class UserServiceProxy implements UserService {
private UserServiceImpl target;
public UserServiceProxy(UserServiceImpl target) { this.target = target; }
public void save(User user) {
System.out.println("Before: logging");
target.save(user);
System.out.println("After: transaction commit");
}
}
JDK 动态代理
JDK 动态代理要求目标对象实现接口，通过 InvocationHandler 和 Proxy 类在运行时生成代理类：
public class LoggingProxy implements InvocationHandler {
private final Object target;
public LoggingProxy(Object target) { this.target = target; }
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("[Proxy] Before: " + method.getName());
long start = System.nanoTime();
Object result = method.invoke(target, args);
long elapsed = System.nanoTime() - start;
System.out.println("[Proxy] After: " + method.getName() + " took " + elapsed/1_000_000 + "ms");
return result;
}
@SuppressWarnings("unchecked")
public static <T> T createProxy(T target, Class<T> interfaceType) {
return (T) Proxy.newProxyInstance(
target.getClass().getClassLoader(),
new Class[]{interfaceType},
new LoggingProxy(target)
);
}
}
// 使用
UserService proxy = LoggingProxy.createProxy(new UserServiceImpl(), UserService.class);
proxy.save(new User());
CGLIB 动态代理
当目标对象没有实现接口时，CGLIB 通过继承生成子类代理：
public class CglibProxy implements MethodInterceptor {
private final Enhancer enhancer = new Enhancer();
public Object createProxy(Class targetClass) {
enhancer.setSuperclass(targetClass);
enhancer.setCallback(this);
return enhancer.create();
}
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy)
throws Throwable {
System.out.println("CGLIB Before: " + method.getName());
Object result = proxy.invokeSuper(obj, args);
System.out.println("CGLIB After: " + method.getName());
return result;
}
}
| 特性 | JDK 动态代理 | CGLIB 动态代理 |
|---|---|---|
| 实现方式 | 接口代理 | 继承代理 |
| 依赖 | 需要接口 | 不需要接口 |
| 性能（JDK8+） | 较高 | 创建慢，执行略慢 |
| 适用范围 | 有接口的类 | 任意非 final 类 |
Spring AOP 中的应用：Spring 根据目标对象是否实现接口自动选择代理方式：
// 实现接口 → JDK 动态代理
@Bean
public UserService userService() { return new UserServiceImpl(); }
// 未实现接口 → CGLIB
@Bean
public UserRepository userRepository() { return new UserRepository(); }
3.2 适配器模式（Adapter Pattern）
适配器模式使接口不兼容的类能够协同工作。
// 三方支付接口
class ThirdPartyPayment {
public void doPay(String merchantId, String orderNo, double amount) {
System.out.println("Third party payment: " + amount);
}
}
// 系统标准接口
interface PaymentService {
void pay(String orderNo, double amount);
}
// 适配器
class ThirdPartyPaymentAdapter implements PaymentService {
private ThirdPartyPayment adaptee;
private String merchantId = "M12345";
public ThirdPartyPaymentAdapter() { this.adaptee = new ThirdPartyPayment(); }
@Override
public void pay(String orderNo, double amount) {
adaptee.doPay(merchantId, orderNo, amount);
}
}
Spring MVC 中的应用：HandlerAdapter 是适配器模式的经典应用：
public interface HandlerAdapter {
boolean supports(Object handler);
ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler);
}
// SimpleControllerHandlerAdapter 适配实现了 Controller 接口的处理器
public class SimpleControllerHandlerAdapter implements HandlerAdapter {
@Override
public boolean supports(Object handler) { return handler instanceof Controller; }
@Override
public ModelAndView handle(HttpServletRequest req, HttpServletResponse resp, Object handler) {
return ((Controller) handler).handleRequest(req, resp);
}
}
// HttpRequestHandlerAdapter 适配实现了 HttpRequestHandler 的处理器
public class HttpRequestHandlerAdapter implements HandlerAdapter {
@Override
public boolean supports(Object handler) { return handler instanceof HttpRequestHandler; }
// ...
}
3.3 装饰器模式（Decorator Pattern）
装饰器模式动态地给对象添加额外职责，比继承更灵活。
interface DataSource {
void writeData(String data);
String readData();
}
class FileDataSource implements DataSource {
private String filename;
public void writeData(String data) { /* write to file */ }
public String readData() { return "data from file"; }
}
abstract class DataSourceDecorator implements DataSource {
protected DataSource wrappee;
public DataSourceDecorator(DataSource ds) { this.wrappee = ds; }
public void writeData(String data) { wrappee.writeData(data); }
public String readData() { return wrappee.readData(); }
}
class EncryptionDecorator extends DataSourceDecorator {
public EncryptionDecorator(DataSource ds) { super(ds); }
@Override
public void writeData(String data) { super.writeData(encrypt(data)); }
@Override
public String readData() { return decrypt(super.readData()); }
private String encrypt(String s) { return Base64.getEncoder().encodeToString(s.getBytes()); }
private String decrypt(String s) { return new String(Base64.getDecoder().decode(s)); }
}
class CompressionDecorator extends DataSourceDecorator {
public CompressionDecorator(DataSource ds) { super(ds); }
@Override
public void writeData(String data) { super.writeData(compress(data)); }
@Override
public String readData() { return decompress(super.readData()); }
// compress/decompress implementation
}
// 使用
DataSource source = new CompressionDecorator(
new EncryptionDecorator(
new FileDataSource("test.txt")
)
);
Java I/O 中的应用：BufferedReader 装饰 FileReader：
BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("test.txt")));
Spring 中的应用：Spring 的 TransactionAwareCacheDecorator 是缓存操作上的装饰器，添加了事务感知能力。
四、行为型模式（Behavioral Patterns）
行为型模式关注对象之间的通信和责任分配。
4.1 策略模式（Strategy Pattern）
策略模式定义一系列算法，将其封装起来并使它们可以互相替换。
// 策略接口
interface CompressStrategy {
byte[] compress(byte[] data);
byte[] decompress(byte[] data);
}
// 具体策略
class GzipStrategy implements CompressStrategy {
public byte[] compress(byte[] data) {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
try (GZIPOutputStream gzip = new GZIPOutputStream(bos)) { gzip.write(data); }
return bos.toByteArray();
}
public byte[] decompress(byte[] data) { /* ... */ }
}
class ZipStrategy implements CompressStrategy {
// zip implementation
}
// 上下文
class CompressContext {
private CompressStrategy strategy;
public CompressContext(CompressStrategy strategy) { this.strategy = strategy; }
public void setStrategy(CompressStrategy strategy) { this.strategy = strategy; }
public byte[] compress(byte[] data) { return strategy.compress(data); }
}
// 使用
CompressContext ctx = new CompressContext(new GzipStrategy());
byte[] compressed = ctx.compress(data);
ctx.setStrategy(new ZipStrategy());
byte[] zipped = ctx.compress(data);
Spring 中的应用：Spring Security 中的 AuthenticationProvider 是策略模式的体现。不同的认证方式（表单、OAuth2、LDAP）对应不同的 AuthenticationProvider 实现。
4.2 观察者模式（Observer Pattern）
观察者模式定义了对象之间的一对多依赖关系，当一个对象状态发生改变时，所有依赖者都会收到通知。
// 事件
class OrderEvent {
private Long orderId;
private String status;
// getters
}
// 观察者接口
interface OrderEventListener {
void onOrderEvent(OrderEvent event);
int getOrder();
}
// 具体观察者
class SmsNotificationListener implements OrderEventListener {
@Override
public void onOrderEvent(OrderEvent event) {
System.out.println("SMS: Order " + event.getOrderId() + " is " + event.getStatus());
}
public int getOrder() { return 2; }
}
class EmailNotificationListener implements OrderEventListener {
@Override
public void onOrderEvent(OrderEvent event) {
System.out.println("Email: Order " + event.getOrderId() + " is " + event.getStatus());
}
public int getOrder() { return 3; }
}
// 被观察主体
class OrderEventMulticaster {
private List<OrderEventListener> listeners = new ArrayList<>();
public void addListener(OrderEventListener listener) { listeners.add(listener); }
public void removeListener(OrderEventListener listener) { listeners.remove(listener); }
public void multicastEvent(OrderEvent event) {
listeners.stream()
.sorted(Comparator.comparingInt(OrderEventListener::getOrder))
.forEach(l -> l.onOrderEvent(event));
}
}
Spring 中的应用：Spring 的事件发布机制是观察者模式的完整实现：
// 自定义事件
public class UserRegisteredEvent extends ApplicationEvent {
private final String email;
public UserRegisteredEvent(Object source, String email) {
super(source);
this.email = email;
}
public String getEmail() { return email; }
}
// 发布事件
@Service
public class UserService {
@Autowired private ApplicationEventPublisher publisher;
public void register(String email) {
// 保存用户...
publisher.publishEvent(new UserRegisteredEvent(this, email));
}
}
// 监听事件
@Component
public class EmailVerificationListener {
@EventListener
public void handleUserRegistered(UserRegisteredEvent event) {
System.out.println("Sending verification to: " + event.getEmail());
// 发送验证邮件
}
}
sequenceDiagram
participant Service as UserService
participant Pub as ApplicationEventPublisher
participant Multi as SimpleApplicationEventMulticaster
participant Listeners as EventListeners
Service->>Pub: publishEvent(event)
Pub->>Multi: multicastEvent(event)
Multi->>Multi: getApplicationListeners()
loop for each listener
Multi->>Listeners: onApplicationEvent(event)
Listeners-->>Multi: done
end
Multi-->>Pub: complete
Pub-->>Service: return
4.3 模板方法模式（Template Method Pattern）
模板方法模式在一个方法中定义算法骨架，将一些步骤延迟到子类中实现。
abstract class AbstractDataProcessor {
// 模板方法 - 定义了算法骨架
public final void process(String filePath) {
String data = readData(filePath);
Object parsed = parseData(data);
validateData(parsed);
saveData(parsed);
postProcess(parsed);
}
protected abstract String readData(String path);
protected abstract Object parseData(String data);
protected abstract void validateData(Object data);
protected abstract void saveData(Object data);
// 钩子方法 - 子类可选覆盖
protected void postProcess(Object data) { /* 默认空实现 */ }
}
class CsvDataProcessor extends AbstractDataProcessor {
@Override
protected String readData(String path) { return Files.readString(Path.of(path)); }
@Override
protected Object parseData(String data) {
return new BufferedReader(new StringReader(data)).lines()
.skip(1).map(line -> line.split(",")).collect(toList());
}
@Override
protected void validateData(Object data) {
List<String[]> rows = (List<String[]>) data;
if (rows.isEmpty()) throw new RuntimeException("Empty data");
}
@Override
protected void saveData(Object data) {
System.out.println("Saving " + ((List)data).size() + " rows");
}
}
Spring 中的应用：JdbcTemplate、RestTemplate 等模板类大量使用模板方法模式：
// JdbcTemplate.execute() 的核心流程
public <T> T execute(ConnectionCallback<T> action) {
Connection con = DataSourceUtils.getConnection(dataSource);
try {
applyStatementSettings(con); // 设置超时、fetchSize 等
T result = action.doInConnection(con);
return result;
} catch (SQLException ex) {
throw translateException("execute", ex);
} finally {
DataSourceUtils.releaseConnection(con, dataSource);
}
}
4.4 责任链模式（Chain of Responsibility）
责任链模式将请求沿着处理者链传递，直到某个处理者处理它为止。
abstract class AbstractHandler {
protected AbstractHandler next;
public AbstractHandler setNext(AbstractHandler next) {
this.next = next;
return next; // 便于链式调用
}
public abstract void handle(Request request);
protected void next(Request request) {
if (next != null) next.handle(request);
}
}
class AuthenticationHandler extends AbstractHandler {
@Override
public void handle(Request request) {
if (request.hasToken()) {
System.out.println("Authenticated");
next(request);
} else {
throw new SecurityException("Unauthorized");
}
}
}
class ValidationHandler extends AbstractHandler {
@Override
public void handle(Request request) {
if (request.isValid()) {
System.out.println("Validated");
next(request);
} else {
throw new IllegalArgumentException("Invalid request");
}
}
}
class LoggingHandler extends AbstractHandler {
@Override
public void handle(Request request) {
System.out.println("Logging: " + request);
next(request);
}
}
// 构建责任链
AbstractHandler chain = new AuthenticationHandler();
chain.setNext(new ValidationHandler())
.setNext(new LoggingHandler());
// 执行
chain.handle(request);
Spring 中的应用：Spring Security 的过滤器链是责任链模式的绝佳应用：
// SecurityFilterChain 的链式结构
@Configuration
@EnableWebSecurity
public class SecurityConfig {
@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
http
.authorizeHttpRequests(auth -> auth
.requestMatchers("/api/public/**").permitAll()
.requestMatchers("/api/admin/**").hasRole("ADMIN")
.anyRequest().authenticated()
)
.oauth2Login(Customizer.withDefaults())
.csrf(csrf -> csrf.ignoringRequestMatchers("/api/**"));
return http.build();
}
}
MyBatis 中的应用：MyBatis 的 Interceptor 插件机制也是责任链模式：
@Intercepts({
@Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class})
})
public class MyPlugin implements Interceptor {
@Override
public Object intercept(Invocation invocation) throws Throwable {
System.out.println("Before: " + invocation.getMethod().getName());
Object result = invocation.proceed();
System.out.println("After: " + invocation.getMethod().getName());
return result;
}
}
graph TD
A[Request] --> B[AuthenticationHandler]
B -->|token valid| C[ValidationHandler]
B -->|invalid| X[Throw Exception]
C -->|data valid| D[LoggingHandler]
C -->|invalid| Y[Throw Exception]
D --> E[Final Handler]
E --> F[Response]
style X fill:#ff4444,color:white
style Y fill:#ff4444,color:white
五、设计模式选择指南
面对实际需求，如何选择合适的设计模式是每个开发者需要不断积累的能力。
graph TD
Start[需求分析] --> Q1{对象创建复杂？}
Q1 -->|是| Q1a{需要保证唯一实例？}
Q1a -->|是| Singleton
Q1a -->|否| Q1b{需要多个相关产品？}
Q1b -->|是| AbstractFactory
Q1b -->|否| Q1c{构建过程复杂？}
Q1c -->|是| Builder
Q1c -->|否| FactoryMethod
Q1 -->|否| Q2{需要控制访问？}
Q2 -->|是| Proxy
Q2 -->|否| Q3{接口不兼容？}
Q3 -->|是| Adapter
Q3 -->|否| Q4{需要动态扩展功能？}
Q4 -->|是| Decorator
Q4 -->|否| Q5{需要封装算法变体？}
Q5 -->|是| Strategy
Q5 -->|否| Q6{需要广播通知？}
Q6 -->|是| Observer
Q6 -->|否| SimpleClass
style Singleton fill:#2196F3,color:white
style AbstractFactory fill:#2196F3,color:white
style Builder fill:#2196F3,color:white
style FactoryMethod fill:#2196F3,color:white
style Proxy fill:#4CAF50,color:white
style Adapter fill:#4CAF50,color:white
style Decorator fill:#4CAF50,color:white
style Strategy fill:#FF9800,color:white
style Observer fill:#FF9800,color:white
选择要点总结：
| 考虑维度 | 适用场景 | 推荐模式 |
|---|---|---|
| 创建复杂性 | 对象构造逻辑复杂，参数多 | Builder |
| 实例数量控制 | 全局唯一实例 | Singleton |
| 接口兼容 | 遗留系统集成 | Adapter |
| 功能扩展 | 需要动态添加职责 | Decorator |
| 算法变体 | 多种相似算法 | Strategy |
| 事件驱动 | 状态变化通知 | Observer |
| 访问控制 | 延迟加载、权限控制 | Proxy |
| 请求处理链 | 多级过滤/拦截 | Chain of Responsibility |
六、设计模式的常见误区和最佳实践
6.1 误区：模式越多越好
// ❌ 过度设计：为了用模式而用模式
public class OrderManager {
private final OrderBuilderFactory factory;
private final OrderCacheProxy proxy;
private final OrderValidatorStrategy strategy;
private final OrderEventObserver observer;
// 实际上只需要一个简单的 Service
}
// ✅ 正确做法：简单优先，需要时才引入模式
@Service
public class OrderService {
@Autowired private OrderRepository repository;
@Transactional
public Order createOrder(CreateOrderRequest request) {
Order order = new Order(request);
repository.save(order);
eventPublisher.publishEvent(new OrderCreatedEvent(order));
return order;
}
}
6.2 最佳实践清单
- KISS 原则：能用简单类解决的问题，不要引入设计模式
- 组合优先于继承：装饰器、策略等模式都基于组合思想
- 面向接口编程：策略模式、代理模式等都要求依赖抽象而非具体
- 单一职责：每个模式类只做一件事
- 开闭原则：对扩展开放，对修改封闭——这正是大多数设计模式的追求
6.3 结合现代 Java 特性
Java 8+ 的 Lambda 表达式和函数式接口可以简化某些模式的实现：
// 策略模式 - Lambda 简化
Map<String, Function<String, String>> strategies = Map.of(
"upper", String::toUpperCase,
"lower", String::toLowerCase,
"reverse", s -> new StringBuilder(s).reverse().toString()
);
// 使用
String result = strategies.get("reverse").apply("Hello World");
// 观察者模式 - Consumer 简化
List<Consumer<OrderEvent>> listeners = new ArrayList<>();
listeners.add(e -> sendEmail(e));
listeners.add(e -> sendSms(e));
listeners.forEach(l -> l.accept(new OrderEvent(orderId, "paid")));
七、总结
设计模式是前人智慧的结晶，是解决特定问题的成熟方案。GoF 的 23 种模式虽然诞生于 90 年代，但其思想在 Spring、MyBatis、JDK 等现代框架中无处不在。
掌握设计模式的核心在于：
– 理解问题域：每种模式解决了什么场景下的什么问题
– 识别代码坏味道：if-else 泛滥 → 策略模式；构造函数膨胀 → 建造者模式
– 实战应用：在真实项目中识别已有的模式应用，并在日常开发中合理运用
– 避免过度设计：设计模式是工具，不是目的
推荐的学习路径：首先精通单例、工厂、代理、策略、观察者、模板方法这 6 个最常用的模式，然后逐步扩展到创建型、结构型、行为型的其他模式。最终达到”无招胜有招”的境界——在不刻意使用模式的情况下自然写出符合设计原则的代码。
© 版权声明
文章版权归作者所有，未经允许请勿转载。
THE END
暂无评论内容