说码解字
0%

设计模式

发表于 更新于 分类于

分类

分类 设计模式 简单说明
创建型模式
Creational Patterns		 单例模式（Singleton） 确保类只有一个实例，并提供全局访问点。
工厂方法（Factory Method） 定义创建对象的接口，由子类决定实例化。
抽象工厂（Abstract Factory） 创建一系列相关对象的工厂。
建造者（Builder） 分步构造复杂对象。
原型模式（Prototype） 通过克隆创建新对象。
结构型模式
Structural Patterns		 适配器（Adapter） 将不兼容的接口转换为兼容接口。
桥接（Bridge） 将抽象与实现分离。
组合（Composite） 将对象组织成树形结构。
装饰者（Decorator） 动态扩展对象功能。
外观（Facade） 为复杂子系统提供简单接口。
享元（Flyweight） 共享细粒度对象以节省资源。
代理（Proxy） 控制对对象的访问。
行为型模式
Behavioral Patterns		 责任链（Chain of Responsibility） 将请求沿处理链传递。
命令（Command） 将请求封装为对象。
解释器（Interpreter） 定义语言的解释规则。
迭代器（Iterator） 顺序访问集合元素。
中介者（Mediator） 通过中介协调对象交互。
备忘录（Memento） 保存和恢复对象状态。
观察者（Observer） 对象状态变化时通知依赖者。
状态（State） 根据状态改变对象行为。
策略（Strategy） 定义可互换的算法家族。
模板方法（Template Method） 定义算法骨架，子类实现细节。
访问者（Visitor） 在不修改类的情况下增加新操作。
扩展模式
Extended Patterns		 依赖注入（Dependency Injection） 通过外部注入依赖，解耦组件。
发布-订阅（Publish-Subscribe） 事件驱动的观察者变种。
模块模式（Module Pattern） 封装代码，管理私有/公有成员。
MVC（Model-View-Controller） 分离数据（Model）、界面（View）和逻辑（Controller）。
MVP（Model-View-Presenter） View 和 Presenter 交互，Model 隔离数据。
MVVM（Model-View-ViewModel） 通过 ViewModel 绑定 Model 和 View。
仓储模式（Repository Pattern） 封装数据访问逻辑。
服务定位器（Service Locator） 集中管理服务实例的获取。
事件溯源（Event Sourcing） 通过事件记录对象状态。

图示

graph LR
    A[设计模式
Design Patterns]
    
    A --> B[创建型模式
Creational Patterns]
    B --> B1[单例模式
Singleton]
    B --> B2[工厂方法
Factory Method]
    B --> B3[抽象工厂
Abstract Factory]
    B --> B4[建造者
Builder]
    B --> B5[原型模式
Prototype]
    
    A --> C[结构型模式
Structural Patterns]
    C --> C1[适配器
Adapter]
    C --> C2[桥接
Bridge]
    C --> C3[组合
Composite]
    C --> C4[装饰者
Decorator]
    C --> C5[外观
Facade]
    C --> C6[享元
Flyweight]
    C --> C7[代理
Proxy]
    
    A --> D[行为型模式
Behavioral Patterns]
    D --> D1[责任链
Chain of Responsibility]
    D --> D2[命令
Command]
    D --> D3[解释器
Interpreter]
    D --> D4[迭代器
Iterator]
    D --> D5[中介者
Mediator]
    D --> D6[备忘录
Memento]
    D --> D7[观察者
Observer]
    D --> D8[状态
State]
    D --> D9[策略
Strategy]
    D --> D10[模板方法
Template Method]
    D --> D11[访问者
Visitor]
    
    A --> E[扩展模式
Extended Patterns]
    E --> E1[依赖注入
Dependency Injection]
    E --> E2[发布-订阅
Publish-Subscribe]
    E --> E3[模块模式
Module Pattern]
    E --> E4[MVC
Model-View-Controller]
    E --> E5[MVP
Model-View-Presenter]
    E --> E6[MVVM
Model-View-ViewModel]
    E --> E7[仓储模式
Repository Pattern]
    E --> E8[服务定位器
Service Locator]
    E --> E9[事件溯源
Event Sourcing]

详解

创建型模式（Creational Patterns）

单例模式（Singleton）

单例模式（Singleton Pattern）是一种创建型设计模式，确保一个类只有一个实例，并提供全局访问点。以下是单例模式的各种实现方式，包括线程安全的版本，用 Java 编写。每种实现都会标注其特点、优缺点及适用场景。

1. 饿汉式（Eager Initialization）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class SingletonEager {
    // 类加载时就创建实例
    private static final SingletonEager INSTANCE = new SingletonEager();
    
    // 私有构造方法，防止外部实例化
    private SingletonEager() {
        // 防止反射创建实例
        if (INSTANCE != null) {
            throw new RuntimeException("Singleton instance already exists");
        }
    }
    
    // 全局访问点
    public static SingletonEager getInstance() {
        return INSTANCE;
    }
}
  • 特点：类加载时即创建实例，线程安全。
  • 优点：简单，无需同步，天然线程安全。
  • 缺点：无论是否使用，都会创建实例，可能浪费资源。
  • 适用场景：实例开销小，且肯定会被使用。

2. 懒汉式（Lazy Initialization，非线程安全）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class SingletonLazy {
    private static SingletonLazy instance;
    
    private SingletonLazy() {
        // 防止反射创建实例
        if (instance != null) {
            throw new RuntimeException("Singleton instance already exists");
        }
    }
    
    public static SingletonLazy getInstance() {
        if (instance == null) {
            instance = new SingletonLazy();
        }
        return instance;
    }
}
  • 特点：延迟加载，第一次调用时创建实例。
  • 优点：节省资源，懒加载。
  • 缺点：非线程安全，多线程下可能创建多个实例。
  • 适用场景：单线程环境，或不在意线程安全。

3. 线程安全的懒汉式（Synchronized 方法）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class SingletonSyncMethod {
    private static SingletonSyncMethod instance;
    
    private SingletonSyncMethod() {
        if (instance != null) {
            throw new RuntimeException("Singleton instance already exists");
        }
    }
    
    // 使用 synchronized 同步方法
    public static synchronized SingletonSyncMethod getInstance() {
        if (instance == null) {
            instance = new SingletonSyncMethod();
        }
        return instance;
    }
}
  • 特点：通过同步方法实现线程安全。
  • 优点：简单，保证线程安全。
  • 缺点：每次调用 getInstance 都要加锁，性能开销大。
  • 适用场景：多线程环境，但调用频率不高。

4. 双重检查锁（Double-Checked Locking, DCL）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class SingletonDCL {
    // 使用 volatile 防止指令重排
    private static volatile SingletonDCL instance;
    
    private SingletonDCL() {
        if (instance != null) {
            throw new RuntimeException("Singleton instance already exists");
        }
    }
    
    public static SingletonDCL getInstance() {
        if (instance == null) {  // 第一次检查（无锁）
            synchronized (SingletonDCL.class) {
                if (instance == null) {  // 第二次检查（加锁）
                    instance = new SingletonDCL();
                }
            }
        }
        return instance;
    }
}
  • 特点：结合懒加载和线程安全，双重检查减少同步开销。
  • 优点：高效，只有在实例未创建时加锁。
  • 缺点：实现复杂，需使用 volatile（Java 5+）防止指令重排。
  • 适用场景：多线程环境，追求性能优化。

5. 静态内部类（Static Inner Class）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class SingletonStaticInner {
    private SingletonStaticInner() {
        if (SingletonHolder.INSTANCE != null) {
            throw new RuntimeException("Singleton instance already exists");
        }
    }
    
    // 静态内部类持有实例
    private static class SingletonHolder {
        private static final SingletonStaticInner INSTANCE = new SingletonStaticInner();
    }
    
    public static SingletonStaticInner getInstance() {
        return SingletonHolder.INSTANCE;
    }
}
  • 特点：利用类加载机制实现懒加载和线程安全。
  • 优点：简单、高效，JVM 保证线程安全，无需显式同步。
  • 缺点：无法传递构造参数。
  • 适用场景：多线程环境，推荐的懒加载方式。

6. 枚举单例（Enum Singleton）

1
2
3
4
5
6
7
8
public enum SingletonEnum {
    INSTANCE;  // 唯一实例
    
    // 可以添加方法
    public void doSomething() {
        System.out.println("SingletonEnum is working");
    }
}
  • 用法：
1
2
SingletonEnum singleton = SingletonEnum.INSTANCE;
singleton.doSomething();
  • 特点：使用枚举实现单例，JVM 保证唯一性。
  • 优点：最简单，天然线程安全，防止反射和序列化破坏。
  • 缺点：无法懒加载，枚举类加载时即创建。
  • 适用场景：需要绝对安全（如防止反射攻击）的场景。

7. ThreadLocal 单例（线程局部单例）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class SingletonThreadLocal {
    private static final ThreadLocal<SingletonThreadLocal> THREAD_LOCAL = 
        ThreadLocal.withInitial(SingletonThreadLocal::new);
    
    private SingletonThreadLocal() {
    }
    
    public static SingletonThreadLocal getInstance() {
        return THREAD_LOCAL.get();
    }
    
    // 清理 ThreadLocal，防止内存泄漏
    public static void remove() {
        THREAD_LOCAL.remove();
    }
}
  • 特点：每个线程拥有独立的单例实例。
  • 优点：线程隔离，适合线程特定的单例需求。
  • 缺点：不是全局单例，需注意 ThreadLocal 的内存管理。
  • 适用场景：线程私有单例，如线程上下文管理。

测试代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public class Main {
    public static void main(String[] args) {
        // 测试饿汉式
        SingletonEager s1 = SingletonEager.getInstance();
        SingletonEager s2 = SingletonEager.getInstance();
        System.out.println("Eager: " + (s1 == s2));  // true
        
        // 测试双重检查锁（多线程）
        Runnable task = () -> System.out.println("DCL: " + SingletonDCL.getInstance());
        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        t1.start();
        t2.start();
        
        // 测试枚举
        SingletonEnum e1 = SingletonEnum.INSTANCE;
        SingletonEnum e2 = SingletonEnum.INSTANCE;
        System.out.println("Enum: " + (e1 == e2));  // true
        
        // 测试 ThreadLocal
        Thread thread1 = new Thread(() -> {
            SingletonThreadLocal stl1 = SingletonThreadLocal.getInstance();
            System.out.println("ThreadLocal Thread1: " + stl1);
        });
        Thread thread2 = new Thread(() -> {
            SingletonThreadLocal stl2 = SingletonThreadLocal.getInstance();
            System.out.println("ThreadLocal Thread2: " + stl2);
        });
        thread1.start();
        thread2.start();
    }
}

说明

  • 线程安全：
    • 饿汉式、静态内部类、枚举天然线程安全。
    • 懒汉式需加锁（同步方法或 DCL）实现线程安全。
    • ThreadLocal 为每个线程提供独立实例。
  • 反射和序列化防护：
    • 枚举单例天然防止反射和序列化破坏。
    • 其他实现通过检查实例是否存在（构造方法抛异常）防御反射。
    • 序列化需实现 readResolve 方法：
      1
      2
      3
      private Object readResolve() {
          return getInstance();
      }
  • 性能：
    • 饿汉式和枚举无延迟，静态内部类和 DCL 高效懒加载。
    • 同步方法性能较低。
  • 复杂度：
    • 枚举最简单，DCL 最复杂。

总结表

实现方式 懒加载 线程安全 复杂度 防止反射 防止序列化 适用场景
饿汉式 否 是 低 是 需额外实现 简单实例
懒汉式 是 否 低 是 需额外实现 单线程
同步方法 是 是 中 是 需额外实现 调用不频繁
双重检查锁 是 是 高 是 需额外实现 高性能多线程
静态内部类 是 是 中 是 需额外实现 推荐的多线程懒加载
枚举 否 是 低 是 是 最高安全性
ThreadLocal 是 线程内 中 是 需额外实现 线程私有单例

工厂方法（Factory Method）

  • 描述：定义创建对象的接口，由子类决定实例化。

  • 代码示例：

    1
    2
    3
    4
    5
    6
    7
    8
    interface Product {}
    class ConcreteProduct implements Product {}
    abstract class Creator {
      abstract Product factoryMethod();
    }
    class ConcreteCreator extends Creator {
      Product factoryMethod() { return new ConcreteProduct(); }
    }

  • Mermaid 示意图：

      graph TB
  A[Client] --> B[Creator]
  B -->|factoryMethod| C[Product]
  B --> D[ConcreteCreator]
  D -->|实现| E[ConcreteProduct]

抽象工厂（Abstract Factory）

  • 描述：创建一系列相关对象的工厂。
  • 代码示例：
    1
    2
    3
    4
    5
    6
    7
    interface Button {}
    interface GUIFactory {
      Button createButton();
    }
    class WinFactory implements GUIFactory {
      Button createButton() { return new WinButton(); }
    }
  • Mermaid 示意图：
      graph TB
  A[Client] --> B[GUIFactory]
  B --> C[WinFactory]
  B --> D[MacFactory]
  C -->|createButton| E[WinButton]
  D -->|createButton| F[MacButton]

建造者（Builder）

  • 描述：分步构造复杂对象。
  • 代码示例：
    1
    2
    3
    4
    5
    6
    7
    8
    class Product {
      String partA, partB;
    }
    class Builder {
      Product p = new Product();
      Builder setPartA(String a) { p.partA = a; return this; }
      Product build() { return p; }
    }
  • Mermaid 示意图：
      graph TB
  A[Client] --> B[Builder]
  B -->|setPartA| B
  B -->|build| C[Product]

原型模式（Prototype）

  • 描述：通过克隆创建新对象。
  • 代码示例：
    1
    2
    3
    4
    5
    6
    class Prototype implements Cloneable {
      @Override
      public Prototype clone() throws CloneNotSupportedException {
        return (Prototype) super.clone();
      }
    }
  • Mermaid 示意图：
      graph TB
  A[Client] --> B[Prototype]
  B -->|clone| C[新实例]

结构型模式（Structural Patterns）

适配器（Adapter）

  • 描述：将不兼容的接口转换为兼容接口。
  • 代码示例：
    1
    2
    3
    4
    5
    6
    interface Target { void request(); }
    class Adaptee { void specificRequest() {} }
    class Adapter implements Target {
      Adaptee adaptee;
      public void request() { adaptee.specificRequest(); }
    }
  • Mermaid 示意图：
      graph TB
  A[Client] -->|request| B[Adapter]
  B -->|specificRequest| C[Adaptee]

桥接（Bridge）

  • 描述：将抽象与实现分离。
  • 代码示例：
    1
    2
    3
    4
    5
    interface Implementor { void operationImpl(); }
    abstract class Abstraction {
      Implementor impl;
      void operation() { impl.operationImpl(); }
    }
  • Mermaid 示意图：
      graph TB
  A[Client] --> B[Abstraction]
  B -->|operationImpl| C[Implementor]
  C --> D[ConcreteImplementor]

组合（Composite）

  • 描述：将对象组织成树形结构。
  • 代码示例：
    1
    2
    3
    4
    5
    6
    interface Component { void operation(); }
    class Leaf implements Component { void operation() {} }
    class Composite implements Component {
      List<Component> children;
      void operation() { for (Component c : children) c.operation(); }
    }
  • Mermaid 示意图：
      graph TB
  A[Client] --> B[Composite]
  B --> C[Leaf1]
  B --> D[Leaf2]
  B --> E[Composite]
  E --> F[Leaf3]

装饰者（Decorator）

  • 描述：动态扩展对象功能。
  • 代码示例：
    1
    2
    3
    4
    5
    6
    interface Component { void operation(); }
    class ConcreteComponent implements Component { void operation() {} }
    class Decorator implements Component {
      Component component;
      void operation() { component.operation(); }
    }
  • Mermaid 示意图：
      graph TB
  A[Client] --> B[Decorator]
  B -->|operation| C[ConcreteComponent]

外观（Facade）

  • 描述：为复杂子系统提供简单接口。
  • 代码示例：
    1
    2
    3
    4
    5
    class Subsystem { void complexOperation() {} }
    class Facade {
      Subsystem subsystem;
      void simpleOperation() { subsystem.complexOperation(); }
    }
  • Mermaid 示意图：
      graph TB
  A[Client] -->|simpleOperation| B[Facade]
  B -->|complexOperation| C[Subsystem]

享元（Flyweight）

  • 描述：共享细粒度对象以节省资源。
  • 代码示例：
    1
    2
    3
    4
    5
    class Flyweight { String intrinsicState; void operation(String extrinsicState) {} }
    class FlyweightFactory {
      Map<String, Flyweight> flyweights;
      Flyweight getFlyweight(String key) { return flyweights.getOrDefault(key, new Flyweight()); }
    }
  • Mermaid 示意图：
      graph TB
  A[Client] --> B[FlyweightFactory]
  B -->|getFlyweight| C[Flyweight]

代理（Proxy）

  • 描述：控制对对象的访问。
  • 代码示例：
    1
    2
    3
    4
    5
    6
    interface Subject { void request(); }
    class RealSubject implements Subject { void request() {} }
    class Proxy implements Subject {
      RealSubject real;
      void request() { real.request(); }
    }
  • Mermaid 示意图：
      graph TB
  A[Client] -->|request| B[Proxy]
  B -->|request| C[RealSubject]

行为型模式（Behavioral Patterns）

责任链（Chain of Responsibility）

  • 描述：将请求沿处理链传递。
  • 代码示例：
    1
    2
    3
    4
    5
    6
    7
    abstract class Handler {
      Handler next;
      void handleRequest(String request) { if (next != null) next.handleRequest(request); }
    }
    class ConcreteHandler extends Handler {
      void handleRequest(String request) { /* 处理 */ }
    }
  • Mermaid 示意图：
      graph TB
  A[Client] --> B[Handler1]
  B -->|next| C[Handler2]
  C -->|next| D[Handler3]

命令（Command）

  • 描述：将请求封装为对象。
  • 代码示例：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    interface Command { void execute(); }
    class ConcreteCommand implements Command {
      Receiver receiver;
      void execute() { receiver.action(); }
    }
    class Invoker {
      Command command;
      void invoke() { command.execute(); }
    }
  • Mermaid 示意图：
      graph TB
  A[Client] --> B[Invoker]
  B -->|execute| C[Command]
  C -->|action| D[Receiver]

解释器（Interpreter）

  • 描述：定义语言的解释规则。
  • 代码示例：
    1
    2
    3
    4
    5
    6
    interface Expression { int interpret(); }
    class Number implements Expression { int value; int interpret() { return value; } }
    class Plus implements Expression {
      Expression left, right;
      int interpret() { return left.interpret() + right.interpret(); }
    }
  • Mermaid 示意图：
      graph TB
  A[Client] --> B[Plus]
  B --> C[Number1]
  B --> D[Number2]

迭代器（Iterator）

  • 描述：顺序访问集合元素。
  • 代码示例：
    1
    2
    3
    4
    5
    6
    7
    interface Iterator { boolean hasNext(); Object next(); }
    class ConcreteIterator implements Iterator {
      List items;
      int pos;
      boolean hasNext() { return pos < items.size(); }
      Object next() { return items.get(pos++); }
    }
  • Mermaid 示意图：
      graph TB
  A[Client] --> B[Iterator]
  B -->|next| C[Collection]

中介者（Mediator）

  • 描述：通过中介协调对象交互。
  • 代码示例：
    1
    2
    3
    4
    5
    6
    interface Mediator { void notify(Object sender); }
    class ConcreteMediator implements Mediator {
      Colleague a, b;
      void notify(Object sender) { /* 协调 */ }
    }
    class Colleague { Mediator mediator; }
  • Mermaid 示意图：
      graph TB
  A[Colleague1] -->|notify| B[Mediator]
  B --> C[Colleague2]

备忘录（Memento）

  • 描述：保存和恢复对象状态。
  • 代码示例：
    1
    2
    3
    4
    5
    6
    class Memento { String state; }
    class Originator {
      String state;
      Memento createMemento() { return new Memento(state); }
      void restore(Memento m) { state = m.state; }
    }
  • Mermaid 示意图：
      graph TB
  A[Client] --> B[Originator]
  B -->|createMemento| C[Memento]
  C -->|restore| B

观察者（Observer）

  • 描述：对象状态变化时通知依赖者。
  • 代码示例：
    1
    2
    3
    4
    5
    interface Observer { void update(); }
    class Subject {
      List<Observer> observers;
      void notify() { for (Observer o : observers) o.update(); }
    }
  • Mermaid 示意图：
      graph TB
  A[Subject] -->|notify| B[Observer1]
  A -->|notify| C[Observer2]

状态（State）

  • 描述：根据状态改变对象行为。
  • 代码示例：
    1
    2
    3
    interface State { void handle(); }
    class Context { State state; void request() { state.handle(); } }
    class ConcreteState implements State { void handle() {} }
  • Mermaid 示意图：
      graph TB
  A[Client] --> B[Context]
  B -->|handle| C[State]

策略（Strategy）

  • 描述：定义可互换的算法家族。
  • 代码示例：
    1
    2
    interface Strategy { void execute(); }
    class Context { Strategy strategy; void executeStrategy() { strategy.execute(); } }
  • Mermaid 示意图：
      graph TB
  A[Client] --> B[Context]
  B -->|execute| C[Strategy]

模板方法（Template Method）

  • 描述：定义算法骨架，子类实现细节。
  • 代码示例：
    1
    2
    3
    4
    5
    abstract class AbstractClass {
      void templateMethod() { step1(); step2(); }
      abstract void step1();
      abstract void step2();
    }
  • Mermaid 示意图：
      graph TB
  A[Client] --> B[AbstractClass]
  B --> C[ConcreteClass]

访问者（Visitor）

  • 描述：在不修改类的情况下增加新操作。
  • 代码示例：
    1
    2
    3
    4
    5
    interface Visitor { void visit(Element e); }
    interface Element { void accept(Visitor v); }
    class ConcreteElement implements Element {
      void accept(Visitor v) { v.visit(this); }
    }
  • Mermaid 示意图：
      graph TB
  A[Client] --> B[Element]
  B -->|accept| C[Visitor]

扩展模式（Extended Patterns）

依赖注入（Dependency Injection）

  • 描述：通过外部注入依赖，解耦组件。
  • 代码示例：
    1
    2
    3
    4
    5
    6
    interface Service {}
    class ServiceImpl implements Service {}
    class Client {
      Service service;
      Client(Service service) { this.service = service; }
    }
  • Mermaid 示意图：
      graph TB
  A[Client] -->|注入| B[Service]
  B --> C[ServiceImpl]

发布-订阅（Publish-Subscribe）

  • 描述：事件驱动的观察者变种。
  • 代码示例：
    1
    2
    3
    4
    5
    class Publisher {
      List<Subscriber> subscribers;
      void publish(String msg) { for (Subscriber s : subscribers) s.receive(msg); }
    }
    interface Subscriber { void receive(String msg); }
  • Mermaid 示意图：
      graph TB
  A[Publisher] -->|publish| B[Subscriber1]
  A -->|publish| C[Subscriber2]

模块模式（Module Pattern）

  • 描述：封装代码，管理私有/公有成员。
  • 代码示例：
    1
    2
    3
    4
    var Module = (function() {
      var privateVar = 'secret';
      return { publicMethod: function() { return privateVar; } };
    })();
  • Mermaid 示意图：
      graph TB
  A[Client] --> B[Module]
  B --> C[Public API]
  B --> D[Private Data]

MVC（Model-View-Controller）

  • 描述：分离数据（Model）、界面（View）和逻辑（Controller）。
  • 代码示例：
    1
    2
    3
    4
    5
    6
    7
    class Model { String data; }
    class View { void display(String data) {} }
    class Controller {
      Model model;
      View view;
      void updateView() { view.display(model.data); }
    }
  • Mermaid 示意图：
      graph TB
  A[Controller] -->|更新| B[Model]
  A -->|显示| C[View]
  B -->|通知| A

MVP（Model-View-Presenter）

  • 描述：View 和 Presenter 交互，Model 隔离数据。
  • 代码示例：
    1
    2
    3
    4
    5
    6
    interface View { void showData(String data); }
    class Presenter {
      Model model;
      View view;
      void loadData() { view.showData(model.getData()); }
    }
  • Mermaid 示意图：
      graph TB
  A[View] -->|调用| B[Presenter]
  B -->|获取| C[Model]
  B -->|显示| A

MVVM（Model-View-ViewModel）

  • 描述：通过 ViewModel 绑定 Model 和 View。
  • 代码示例：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    class ViewModel {
      Model model;
      String data;
      void refresh() { data = model.getData(); }
    }
    class View {
      ViewModel vm;
      void bind() { display(vm.data); }
    }
  • Mermaid 示意图：
      graph TB
  A[View] -->|绑定| B[ViewModel]
  B -->|获取| C[Model]

仓储模式（Repository Pattern）

  • 描述：封装数据访问逻辑。
  • 代码示例：
    1
    2
    3
    4
    interface Repository { List<Entity> findAll(); }
    class SqlRepository implements Repository {
      List<Entity> findAll() { /* SQL 查询 */ return list; }
    }
  • Mermaid 示意图：
      graph TB
  A[Client] -->|调用| B[Repository]
  B --> C[Data Source]

服务定位器（Service Locator）

  • 描述：集中管理服务实例的获取。
  • 代码示例：
    1
    2
    3
    4
    class ServiceLocator {
      static Map<String, Service> services;
      static Service getService(String key) { return services.get(key); }
    }
  • Mermaid 示意图：
      graph TB
  A[Client] -->|获取| B[ServiceLocator]
  B --> C[Service]

事件溯源（Event Sourcing）

  • 描述：通过事件记录对象状态。
  • 代码示例：
    1
    2
    3
    4
    5
    class Event { String type; Object data; }
    class Aggregate {
      List<Event> events;
      void apply(Event e) { events.add(e); }
    }
  • Mermaid 示意图：
      graph TB
  A[Client] --> B[Aggregate]
  B -->|记录| C[Event Store]