设计模式总结：23种GOF设计模式完整指南与对比分析

1
2
3
4
5

需要控制实例数量？           → 单例模式
需要根据条件创建不同对象？    → 工厂方法模式
需要创建相关对象家族？       → 抽象工厂模式
需要分步骤构建复杂对象？     → 建造者模式
需要基于现有对象创建新对象？  → 原型模式

1
2
3
4
5
6
7

需要适配不兼容的接口？       → 适配器模式
需要分离抽象和实现？        → 桥接模式
需要处理树形结构？          → 组合模式
需要动态添加功能？          → 装饰器模式
需要简化复杂系统接口？      → 外观模式
需要节省内存使用？          → 享元模式
需要控制对象访问？          → 代理模式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

需要处理请求链？            → 责任链模式
需要封装操作请求？          → 命令模式
需要解释自定义语言？        → 解释器模式
需要遍历聚合对象？          → 迭代器模式
需要协调对象间交互？        → 中介者模式
需要保存和恢复状态？        → 备忘录模式
需要通知状态变化？          → 观察者模式
需要根据状态改变行为？      → 状态模式
需要在运行时选择算法？      → 策略模式
需要定义算法模板？          → 模板方法模式
需要在不修改类的情况下增加操作？ → 访问者模式

1
2
3

Model（模型）      ← 观察者模式 → View（视图）
   ↑                                ↓
   └── 策略模式 ←→ Controller（控制器）

1
2
3
4
5

抽象工厂（创建组件族）
    ↓
组合模式（组件树） + 装饰器（功能增强）
    ↓
观察者模式（事件处理） + 命令模式（操作封装）

1
2
3
4
5
6
7

单例模式（游戏管理器）
    ↓
工厂方法（角色创建） + 原型模式（角色复制）
    ↓
状态模式（AI行为） + 策略模式（技能选择）
    ↓
备忘录模式（存档系统） + 观察者模式（事件系统）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// ❌ 错误：简单问题复杂化
class SimpleCalculator {
    // 为简单加法使用策略模式是过度设计
    private CalculationStrategy strategy;
}

// ✅ 正确：简单问题简单解决
class SimpleCalculator {
    public int add(int a, int b) {
        return a + b;
    }
}

1
2
3
4
5
6
7
8
9

// ✅ 正确的思路：
// 1. 识别问题：需要根据不同类型创建不同对象
// 2. 选择模式：工厂方法模式适合这个问题
// 3. 实现模式：编写具体的工厂类

// ❌ 错误的思路：
// 1. 想用某个模式
// 2. 强行套用到代码中
// 3. 代码变得复杂难懂

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 理解单例模式的本质：控制实例数量
// 不仅可以实现"只有一个实例"
// 也可以实现"最多N个实例"

class ConnectionPool {
    private static final int MAX_CONNECTIONS = 10;
    private static final List<Connection> pool = new ArrayList<>();

    // 这也是单例模式思想的应用
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

遇到设计问题时：

1. 这是创建对象的问题吗？
   ├─ 是 → 考虑创建型模式
   │   ├─ 需要控制实例数量？ → 单例模式
   │   ├─ 需要根据条件创建？ → 工厂方法模式
   │   ├─ 需要创建对象家族？ → 抽象工厂模式
   │   ├─ 需要分步构建？ → 建造者模式
   │   └─ 需要复制对象？ → 原型模式
   └─ 否 → 继续判断

2. 这是对象结构的问题吗？
   ├─ 是 → 考虑结构型模式
   │   ├─ 接口不兼容？ → 适配器模式
   │   ├─ 需要分离抽象实现？ → 桥接模式
   │   ├─ 树形结构？ → 组合模式
   │   ├─ 动态增加功能？ → 装饰器模式
   │   ├─ 简化复杂接口？ → 外观模式
   │   ├─ 内存优化？ → 享元模式
   │   └─ 控制访问？ → 代理模式
   └─ 否 → 考虑行为型模式

3. 这是对象交互的问题吗？
   └─ 是 → 根据具体交互方式选择行为型模式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

// 单例模式：Spring Bean默认是单例
@Component
public class UserService { }

// 工厂方法模式：BeanFactory
@Bean
public DataSource dataSource() {
    return new HikariDataSource();
}

// 代理模式：AOP
@Transactional
public void saveUser(User user) { }

// 观察者模式：事件监听
@EventListener
public void handleUserCreated(UserCreatedEvent event) { }

// 模板方法模式：JdbcTemplate
jdbcTemplate.query(sql, rowMapper);

 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

// 观察者模式：状态管理
const [state, setState] = useState(initialState);

// 组合模式：组件树
function App() {
    return (
        <Layout>
            <Header />
            <Content>
                <UserList />
            </Content>
        </Layout>
    );
}

// 策略模式：条件渲染
const renderContent = () => {
    switch(viewType) {
        case 'list': return <ListView />;
        case 'grid': return <GridView />;
        default: return <DefaultView />;
    }
};

// 装饰器模式：高阶组件
const withAuth = (Component) => {
    return (props) => {
        if (!isAuthenticated) return <Login />;
        return <Component {...props} />;
    };
};

1
2
3

// 发现代码中的问题，然后应用设计模式重构
// 例如：发现大量的if-else，考虑策略模式
// 例如：发现重复的创建逻辑，考虑工厂模式

1
2
3

// Spring源码中的设计模式
// JDK源码中的设计模式
// 开源框架中的设计模式应用

1
2
3

// 不要为了使用模式而使用模式
// 当遇到问题时，思考哪种模式能优雅地解决
// 逐步积累使用经验

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// 传统的策略模式
class PaymentContext {
    constructor(strategy) {
        this.strategy = strategy;
    }
    pay(amount) {
        return this.strategy.pay(amount);
    }
}

// 函数式的"策略模式"
const payWithStrategy = (strategy) => (amount) => strategy(amount);
const payWithCredit = payWithStrategy((amount) => `Credit: ${amount}`);
const payWithPaypal = payWithStrategy((amount) => `PayPal: ${amount}`);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// Java的Lambda简化了很多模式
// 传统的观察者模式
list.addObserver(new Observer() {
    public void update(Observable o, Object arg) {
        System.out.println("Updated: " + arg);
    }
});

// Lambda简化后
list.addObserver((o, arg) -> System.out.println("Updated: " + arg));