设计模式在框架中的应用与实践

05012

深入理解设计模式——从 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 最佳实践清单

  1. KISS 原则：能用简单类解决的问题，不要引入设计模式
  2. 组合优先于继承：装饰器、策略等模式都基于组合思想
  3. 面向接口编程：策略模式、代理模式等都要求依赖抽象而非具体
  4. 单一职责：每个模式类只做一件事
  5. 开闭原则：对扩展开放，对修改封闭——这正是大多数设计模式的追求

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
Java
喜欢就支持一下吧
点赞12 分享
as959705158的头像-林林林的博客
如何选择存储引擎-林林林的博客
如何选择存储引擎
如何选择存储引擎
1小时前 50
MySQL JSON 数据类型（5.7+）深入解析-林林林的博客
MySQL JSON 数据类型（5.7+）深入解析
MySQL JSON 数据类型（5.7+）深入解析
1小时前 50
响应式编程与 WebFlux——从 Reactor 到高并发架构-林林林的博客
响应式编程与 WebFlux——从 Reactor 到高并发架构
响应式编程与 WebFlux——从 Reactor 到高并发架构
1小时前 50
数据持久化方式-林林林的博客
数据持久化方式
数据持久化方式
1小时前 50
如何限制容器的网络带宽-林林林的博客
如何限制容器的网络带宽
如何限制容器的网络带宽
1小时前 50
MongoDB 深入解析——从文档模型到副本集与分片-林林林的博客
MongoDB 深入解析——从文档模型到副本集与分片
MongoDB 深入解析——从文档模型到副本集与分片
1小时前 50
相关推荐
MongoDB 深入解析——从文档模型到副本集与分片-林林林的博客
MongoDB 深入解析——从文档模型到副本集与分片
MongoDB 深入解析——从文档模型到副本集与分片
1小时前 50
微服务架构核心——从服务拆分解耦到服务网格-林林林的博客
微服务架构核心——从服务拆分解耦到服务网格
微服务架构核心——从服务拆分解耦到服务网格
1小时前 50
设计模式在框架中的应用与实践-林林林的博客
设计模式在框架中的应用与实践
设计模式在框架中的应用与实践
1小时前 50
响应式编程与 WebFlux——从 Reactor 到高并发架构-林林林的博客
响应式编程与 WebFlux——从 Reactor 到高并发架构
响应式编程与 WebFlux——从 Reactor 到高并发架构
1小时前 50
分布式系统核心理论——从 CAP 到 Paxos/Raft 共识算法-林林林的博客
分布式系统核心理论——从 CAP 到 Paxos/Raft 共识算法
分布式系统核心理论——从 CAP 到 Paxos/Raft 共识算法
1小时前 49
Java 高级开发核心知识体系：Spring、MyBatis 与设计模式-林林林的博客
Java 高级开发核心知识体系：Spring、MyBatis 与设计模式
Java 高级开发核心知识体系：Spring、MyBatis 与设计模式
1小时前 48
评论 抢沙发

请登录后发表评论

    暂无评论内容