第1篇 软件设计前奏篇
第1章 重新认识UML 2
1.1 UML的定义 2
1.2 UML应用场景 2
1.3 UML基本构件简介 3
1.3.1 事物 3
1.3.2 关系 5
1.3.3 图 6
第2章 设计模式常用的UML图 7
2.1 类图 7
2.1.1 继承关系 8
2.1.2 实现关系 8
2.1.3 组合关系 9
2.1.4 聚合关系 10
2.1.5 关联关系 11
2.1.6 依赖关系 12
2.1.7 类关系记忆技巧 14
2.2 时序图 15
2.2.1 时序图的作用 15
2.2.2 时序图组成元素 16
2.2.3 时序图组合片段 17
2.2.4 时序图画法及应用实践 19
第3章 七大软件架构设计原则 22
3.1 开闭原则 22
3.1.1 开闭原则的定义 22
3.1.2 使用开闭原则解决实际问题 23
3.2 依赖倒置原则 24
3.2.1 依赖倒置原则的定义 24
3.2.2 使用依赖倒置原则解决实际问题 25
3.3 单一职责原则 28
3.3.1 单一职责原则的定义 28
3.3.2 使用单一职责原则解决实际问题 28
3.4 接口隔离原则 31
3.4.1 接口隔离原则的定义 31
3.4.2 使用接口隔离原则解决实际问题 31
3.5 迪米特法则 33
3.5.1 迪米特法则的定义 33
3.5.2 使用迪米特法则解决实际问题 33
3.6 里氏替换原则 35
3.6.1 里氏替换原则的定义 35
3.6.2 使用里氏替换原则解决实际问题 36
3.7 合成复用原则 40
3.7.1 合成复用原则的定义 40
3.7.2 使用合成复用原则解决实际问题 40
3.8 软件架构设计原则小结 42
第4章 关于设计模式的那些事儿 43
4.1 本书与GoF的《设计模式》的关系 43
4.2 为什么一定要学习设计模式 45
4.2.1 写出优雅的代码 45
4.2.2 更好地重构项目 47
4.2.3 经典框架都在用设计模式解决问题 58
第2篇 创建型设计模式
第5章 简单工厂模式 60
5.1 工厂模式的历史由来 60
5.2 简单工厂模式概述 61
5.2.1 简单工厂模式的定义 61
5.2.2 简单工厂模式的应用场景 61
5.2.3 简单工厂模式的UML类图 61
5.2.4 简单工厂模式的通用写法 62
5.3 使用简单工厂模式封装产品创建细节 63
5.4 简单工厂模式在框架源码中的应用 66
5.4.1 简单工厂模式在JDK源码中的应用 66
5.4.2 简单工厂模式在Logback源码中的应用 67
5.5 简单工厂模式扩展 67
5.5.1 简单工厂模式的优点 67
5.5.2 简单工厂模式的缺点 67
第6章 工厂方法模式 68
6.1 工厂方法模式概述 68
6.1.1 工厂方法模式的定义 68
6.1.2 工厂方法模式的应用场景 69
6.1.3 工厂方法模式的UML类图 69
6.1.4 工厂方法模式的通用写法 70
6.2 使用工厂方法模式实现产品扩展 71
6.3 工厂方法模式在Logback源码中的应用 72
6.4 工厂方法模式扩展 73
6.4.1 工厂方法模式的优点 73
6.4.2 工厂方法模式的缺点 73

第7章 抽象工厂模式 74
7.1 抽象工厂模式概述 74
7.1.1 抽象工厂模式的定义 74
7.1.2 关于产品等级结构和产品族 75
7.1.3 抽象工厂模式的应用场景 76
7.1.4 抽象工厂模式的UML类图 76
7.1.5 抽象工厂模式的通用写法 76
7.2 使用抽象工厂模式解决实际问题 78
7.2.1 使用抽象工厂模式支持产品扩展 78
7.2.2 使用抽象工厂模式重构数据库连接池 81
7.3 抽象工厂模式在Spring源码中的应用 88
7.4 抽象工厂模式扩展 89
7.4.1 抽象工厂模式的优点 89
7.4.2 抽象工厂模式的缺点 90
第8章 单例模式 91
8.1 单例模式概述 91
8.1.1 单例模式的定义 91
8.1.2 单例模式的应用场景 91
8.1.3 单例模式的UML类图 92
8.1.4 单例模式的通用写法 92
8.2 使用单例模式解决实际问题 93
8.2.1 饿汉式单例写法的弊端 93
8.2.2 还原线程破坏单例的事故现场 93
8.2.3 双重检查锁单例写法闪亮登场 97
8.2.4 看似完美的静态内部类单例写法 100
8.2.5 还原反射破坏单例模式的事故现场 101
8.2.6 更加优雅的枚举式单例写法问世 103
8.2.7 还原反序列化破坏单例模式的事故现场 108
8.2.8 使用容器式单例写法解决大规模生产单例的问题 114
8.2.9 ThreadLocal单例详解 115
8.3 单例模式在框架源码中的应用 116
8.3.1 单例模式在JDK源码中的应用 116
8.3.2 单例模式在Spring源码中的应用 117
8.4 单例模式扩展 121
8.4.1 单例模式的优点 121
8.4.2 单例模式的缺点 121
第9章 原型模式 122
9.1 原型模式概述 122
9.1.1 原型模式的定义 122
9.1.2 原型模式的应用场景 123
9.1.3 原型模式的UML类图 124
9.1.4 原型模式的通用写法 124
9.2 使用原型模式解决实际问题 126
9.2.1 分析JDK浅克隆API带来的问题 126
9.2.2 使用序列化实现深克隆 129
9.2.3 还原克隆破坏单例的事故现场 131
9.3 原型模式在框架源码中的应用 132
9.3.1 原型模式在JDK源码中的应用 132
9.3.2 原型模式在Spring源码中的应用 133
9.4 原型模式扩展 134
9.4.1 原型模式的优点 134
9.4.2 原型模式的缺点 134
第10章 建造者模式 135
10.1 建造者模式概述 135
10.1.1 建造者模式的定义 135
10.1.2 建造者模式的应用场景 136
10.1.3 建造者模式的UML类图 136
10.1.4 建造者模式的通用写法 137
10.2 使用建造者模式解决实际问题 138
10.2.1 建造者模式的链式写法 138
10.2.2 使用静态内部类实现建造者模式 140
10.2.3 使用建造者模式动态构建SQL语句 142
10.3 建造者模式在框架源码中的应用 153
10.3.1 建造者模式在JDK源码中的应用 153
10.3.2 建造者模式在MyBatis源码中的应用 154
10.3.3 建造者模式在Spring源码中的应用 154
10.4 建造者模式扩展 155
10.4.1 建造者模式与工厂模式的区别 155
10.4.2 建造者模式的优点 155
10.4.3 建造者模式的缺点 155
第3篇 结构型设计模式
第11章 代理模式 158
11.1 代理模式概述 158
11.1.1 代理模式的定义 158
11.1.2 代理模式的应用场景 158
11.1.3 代理模式的UML类图 159
11.1.4 代理模式的通用写法 159
11.2 使用代理模式解决实际问题 161
11.2.1 从静态代理到动态代理 161
11.2.2 三层架构中的静态代理 163
11.2.3 使用动态代理实现无感知切换数据源 168
11.2.4 手写JDK动态代理核心原理 169
11.2.5 CGLib动态代理API原理分析 176
11.2.6 CGLib和JDK动态代理对比分析 183
11.3 代理模式在框架源码中的应用 184
11.3.1 代理模式在Spring源码中的应用 184
11.3.2 代理模式在MyBatis源码中的应用 185
11.4 代理模式扩展 189
11.4.1 静态代理和动态代理的区别 189
11.4.2 代理模式的优点 189
11.4.3 代理模式的缺点 190
第12章 门面模式 191
12.1 门面模式概述 191
12.1.1 门面模式的定义 191
12.1.2 门面模式的应用场景 191
12.1.3 门面模式的UML类图 192
12.1.4 门面模式的通用写法 193
12.2 使用门面模式整合已知API的功能 194
12.3 门面模式在框架源码中的应用 196
12.3.1 门面模式在Spring源码中的应用 196
12.3.2 门面模式在MyBatis源码中的应用 198
12.3.3 门面模式在Tomcat源码中的应用 199
12.4 门面模式扩展 200
12.4.1 门面模式的优点 200
12.4.2 门面模式的缺点 200
第13章 装饰器模式 201
13.1 装饰器模式概述 201
13.1.1 装饰器模式的定义 201
13.1.2 装饰器模式的应用场景 201
13.1.3 装饰器模式的UML类图 202
13.1.4 装饰器模式的通用写法 203
13.2 使用装饰器模式解决实际问题 205
13.2.1 使用装饰器模式解决煎饼“加码”问题 205
13.2.2 使用装饰器模式扩展日志格式输出 209
13.3 装饰器模式在框架源码中的应用 212
13.3.1 装饰器模式在JDK源码中的应用 212
13.3.2 装饰器模式在Spring源码中的应用 212
13.3.3 装饰器模式在MyBatis源码中的应用 213
13.4 装饰器模式扩展 213
13.4.1 装饰器模式与代理模式的区别 213
13.4.2 装饰器模式的优点 214
13.4.3 装饰器模式的缺点 214
第14章 享元模式 215
14.1 享元模式概述 215
14.1.1 享元模式的定义 215
14.1.2 享元模式的应用场景 216
14.1.3 享元模式的UML类图 216
14.1.4 享元模式的通用写法 217
14.2 使用享元模式解决实际问题 218
14.2.1 使用享元模式实现资源共享池 218
14.2.2 使用享元模式实现数据库连接池 220
14.3 享元模式在框架源码中的应用 222
14.3.1 享元模式在JDK源码中的应用 222
14.3.2 享元模式在Apache Pool源码中的应用 224
14.4 享元模式扩展 225
14.4.1 享元模式的内部状态和外部状态 225
14.4.2 享元模式的优点 226
14.4.3 享元模式的缺点 226
第15章 组合模式 227
15.1 组合模式概述 227
15.1.1 组合模式的定义 227
15.1.2 组合模式的应用场景 228
15.1.3 透明组合模式的UML类图及通用写法 229
15.1.4 安全组合模式的UML类图及通用写法 232

15.2 使用组合模式解决实际问题 233
15.2.1 使用透明组合模式实现课程目录结构 233
15.2.2 使用安全组合模式实现无限级文件系统 237
15.3 组合模式在框架源码中的应用 240
15.3.1 组合模式在JDK源码中的应用 240
15.3.2 组合模式在MyBatis源码中的应用 243
15.4 组合模式扩展 244
15.4.1 组合模式的优点 244
15.4.2 组合模式的缺点 244
第16章 适配器模式 245
16.1 适配器模式概述 245
16.1.1 适配器模式的定义 245
16.1.2 适配器模式的应用场景 246
16.1.3 类适配器的UML类图及通用写法 246
16.1.4 对象适配器的UML类图及通用写法 248
16.1.5 接口适配器的UML类图及通用写法 249
16.2 使用适配器模式解决实际问题 251
16.2.1 使用类适配器重构第三方登录自由适配 251
16.2.2 使用接口适配器优化代码 254
16.3 适配器模式在Spring源码中的应用 258
16.4 适配器模式扩展 261
16.4.1 适配器模式与装饰器模式的区别 261
16.4.2 适配器模式的优点 262
16.4.3 适配器模式的缺点 262
第17章 桥接模式 263
17.1　桥接模式概述 263
17.1.1　桥接模式的定义 263
17.1.2　桥接模式的应用场景 263
17.1.3　桥接模式的UML类图 264
17.1.4　桥接模式的通用写法 265
17.2　使用桥接模式设计复杂消息系统 266
17.3　桥接模式在JDK源码中的应用 270
17.4　桥接模式扩展 274
17.4.1　桥接模式的优点 274
17.4.2　桥接模式的缺点 274
第4篇 行为型设计模式
第18章 委派模式 276
18.1　委派模式概述 276
18.1.1　委派模式的定义 276
18.1.2　委派模式的应用场景 276
18.1.3　委派模式的UML类图 277
18.1.4　委派模式的通用写法 277
18.2　使用委派模式模拟任务分配场景 278
18.3　委派模式在框架源码中的应用 280
18.3.1　委派模式在JDK源码中的应用 280
18.3.2　委派模式在Spring源码中的应用 282
18.4　委派模式扩展 285
18.4.1　委派模式的优点 285
18.4.2　委派模式的缺点 285
第19章 模板方法模式 286
19.1　模板方法模式概述 286
19.1.1　模板方法模式的定义 286
19.1.2　模板方法模式的应用场景 286
19.1.3　模板方法模式的UML类图 287
19.1.4　模板方法模式的通用写法 288
19.2　使用模板方法模式解决实际问题 289
19.2.1　模板方法模式中的钩子方法 289
19.2.2　使用模板方法模式重构JDBC业务操作 291
19.3　模板方法模式在框架源码中的应用 295
19.3.1　模板方法模式在JDK源码中的应用 295
19.3.2　模板方法模式在MyBatis源码中的应用 295
19.4　模板方法模式扩展 297
19.4.1　模板方法模式的优点 297
19.4.2　模板方法模式的缺点 297
第20章 策略模式 298
20.1　策略模式概述 298
20.1.1　策略模式的定义 298
20.1.2　策略模式的应用场景 298
20.1.3　策略模式的UML类图 299
20.1.4　策略模式的通用写法 300
20.2　使用策略模式解决实际问题 301
20.2.1　使用策略模式实现促销优惠方案选择 301
20.2.2　使用策略模式重构支付方式选择场景 304
20.2.3　策略模式和委派模式结合使用 308
20.3　策略模式在框架源码中的应用 311
20.3.1　策略模式在JDK源码中的应用 311
20.3.2　策略模式在Spring源码中的应用 312
20.4　策略模式扩展 314
20.4.1　策略模式的优点 314
20.4.2　策略模式的缺点 315
第21章 责任链模式 316
21.1　责任链模式概述 316
21.1.1　责任链模式的定义 316
21.1.2　责任链模式的应用场景 316
21.1.3　责任链模式的UML类图 317
21.1.4　责任链模式的通用写法 318
21.2　使用责任链模式解决实际问题 319
21.2.1　使用责任链模式设计热插拔权限控制 319
21.2.2　责任链模式和建造者模式结合使用 323
21.3　责任链模式在框架源码中的应用 324
21.3.1　责任链模式在JDK源码中的应用 324
21.3.2　责任链模式在Netty源码中的应用 326
21.4　责任链模式扩展 328
21.4.1　责任链模式的优点 328
21.4.2　责任链模式的缺点 328
第22章 迭代器模式 329
22.1　迭代器模式概述 329
22.1.1　迭代器模式的定义 329
22.1.2　迭代器模式的应用场景 329
22.1.3　迭代器模式的UML类图 330
22.1.4　迭代器模式的通用写法 331
22.2　手写自定义的集合迭代器 332
22.3　迭代器模式在框架源码中的应用 336
22.3.1　迭代器模式在JDK源码中的应用 336
22.3.2　迭代器模式在MyBatis源码中的应用 338
22.4　迭代器模式扩展 338
22.4.1　迭代器模式的优点 338
22.4.2　迭代器模式的缺点 338
第23章 命令模式 339
23.1　命令模式概述 339
23.1.1　命令模式的定义 339
23.1.2　命令模式的应用场景 340
23.1.3　命令模式的UML类图 340
23.1.4　命令模式的通用写法 341

23.2　使用命令模式重构播放器控制条 342
23.3　命令模式在框架源码中的应用 345
23.3.1　命令模式在JDK源码中的应用 345
23.3.2　命令模式在JUnit源码中的应用 346
23.4　命令模式扩展 346
23.4.1　命令模式的优点 346
23.4.2　命令模式的缺点 347
第24章 状态模式 348
24.1　状态模式概述 348
24.1.1　状态模式的定义 348
24.1.2　状态模式的应用场景 348
24.1.3　状态模式的UML类图 349
24.1.4　状态模式的通用写法 350
24.2　使用状态模式解决实际问题 352
24.2.1　使用状态模式实现登录状态自由切换 352
24.2.2　使用状态机实现订单状态流转控制 355
24.3　状态模式在JSF源码中的应用 361
24.4　状态模式扩展 362
24.4.1　状态模式与责任链模式的区别 362
24.4.2　状态模式与策略模式的区别 362
24.4.3　状态模式的优点 362
24.4.4　状态模式的缺点 363
第25章 备忘录模式 364
25.1　备忘录模式概述 364
25.1.1　备忘录模式的定义 364
25.1.2　备忘录模式的应用场景 365
25.1.3　备忘录模式的UML类图 365
25.1.4　备忘录模式的通用写法 366
25.2　使用备忘录模式实现草稿箱功能 368
25.3　备忘录模式在Spring源码中的应用 373
25.4　备忘录模式扩展 375
25.4.1　备忘录模式的优点 375
25.4.2　备忘录模式的缺点 375
第26章 中介者模式 376
26.1　中介者模式概述 376
26.1.1　中介者模式的定义 376
26.1.2　中介者模式的应用场景 377
26.1.3　中介者模式的UML类图 378
26.1.4　中介者模式的通用写法 379
26.2　使用中介者模式设计群聊场景 381
26.3　中介者模式在JDK源码中的应用 382
26.4　中介者模式扩展 384
26.4.1　中介者模式的优点 384
26.4.2　中介者模式的缺点 384
第27章 解释器模式 385
27.1　解释器模式概述 385
27.1.1　解释器模式的定义 385
27.1.2　解释器模式的应用场景 386
27.1.3　解释器模式的UML类图 386
27.1.4　解释器模式的通用写法 387
27.2　使用解释器模式解析数学表达式 389
27.3　解释器模式在框架源码中的应用 397
27.3.1　解释器模式在JDK源码中的应用 397
27.3.2　解释器模式在Spring源码中的应用 397
27.4　解释器模式扩展 398
27.4.1　解释器模式的优点 398
27.4.2　解释器模式的缺点 399

第28章 观察者模式 400
28.1　观察者模式概述 400
28.1.1　观察者模式的定义 400
28.1.2　观察者模式的应用场景 400
28.1.3　观察者模式的UML类图 401
28.1.4　观察者模式的通用写法 402
28.2　使用观察者模式解决实际问题 403
28.2.1　基于Java API实现通知机制 403
28.2.2　基于Guava API轻松落地观察者模式 406
28.2.3　使用观察者模式设计鼠标事件响应API 406
28.3　观察者模式在Spring源码中的应用 412
28.4　观察者模式扩展 413
28.4.1　观察者模式的优点 413
28.4.2　观察者模式的缺点 414
第29章 访问者模式 415
29.1　访问者模式概述 415
29.1.1　访问者模式的定义 415
29.1.2　访问者模式的应用场景 416
29.1.3　访问者模式的UML类图 416
29.1.4　访问者模式的通用写法 417
29.2　使用访问者模式解决实际问题 419
29.2.1　使用访问者模式实现KPI考核的场景 419
29.2.2　从静态分派到动态分派 424
29.2.3　访问者模式中的伪动态分派 425
29.3　访问者模式在框架源码中的应用 427
29.3.1　访问者模式在JDK源码中的应用 427
29.3.2　访问者模式在Spring源码中的应用 428
29.4　访问者模式扩展 429
29.4.1　访问者模式的优点 429
29.4.2　访问者模式的缺点 430

第5篇 设计模式总结篇
第30章 专治设计模式选择困难症 432
30.1　设计模式到底如何落地 432
30.2　各种设计模式使用频率总结 435
30.2.1　创建型设计模式 435
30.2.2　结构型设计模式 435
30.2.3　行为型设计模式 436
30.3　一句话归纳设计模式 437
第31章 容易混淆的设计模式对比 439
31.1　创建型设计模式对比 439
31.1.1　工厂方法模式与抽象工厂模式对比 439
31.1.2　简单工厂模式与单例模式对比 440
31.1.3　简单工厂模式与建造者模式对比 441
31.2　结构型设计模式对比 441
31.2.1　装饰器模式与代理模式对比 441
31.2.2　装饰器模式与门面模式对比 442
31.2.3　装饰器模式与适配器模式对比 443
31.2.4　适配器模式与代理模式对比 443
31.3　行为型设计模式对比 444
31.3.1　策略模式与模板方法模式对比 444
31.3.2　策略模式与命令模式对比 445
31.3.3　策略模式与委派模式对比 445
31.3.4　桥接模式与适配器模式对比 446
31.3.5　桥接模式与组合模式对比 446
31.4　跨类综合对比 447
31.4.1　享元模式与容器式单例模式对比 447
31.4.2　建造者模式与装饰器模式对比 448
31.4.3　策略模式与简单工厂模式对比 449
31.4.4　策略模式与适配器模式对比 449
31.4.5　中介者模式与适配器模式对比 450
31.4.6　中介者模式与代理模式对比 451
31.4.7　中介者模式与桥接模式对比 451
31.4.8　桥接模式与命令模式对比 452
31.4.9　委派模式与门面模式对比 453
31.4.10　委派模式与代理模式对比 453
第6篇 架构设计扩展篇
第32章 新设计模式 456
32.1　对象池模式 456
32.1.1　对象池模式的定义 456
32.1.2　对象池模式的应用场景 456
32.1.3　对象池模式的UML类图 457
32.1.4　对象池模式的通用写法 458
32.1.5　对象池模式的优缺点 459
32.2　规格模式 460
32.2.1　规格模式的定义 460
32.2.2　规格模式的应用场景 460
32.2.3　规格模式的UML类图 460
32.2.4　规格模式的通用写法 461
32.2.5　规格模式的优缺点 464
32.3　空对象模式 464
32.3.1　空对象模式的定义 464
32.3.2　空对象模式的应用场景 465
32.3.3　空对象模式的UML类图 465
32.3.4　空对象模式的通用写法 466
32.3.5　空对象模式的优缺点 467
32.4　雇工模式 467
32.4.1　雇工模式的定义 467
32.4.2　雇工模式的应用场景 467
32.4.3　雇工模式的UML类图 468
32.4.4　雇工模式的通用写法 468
32.4.5　雇工模式的优缺点 469
第33章 软件架构与设计模式 470
33.1　软件架构和设计模式的区别 470
33.2　三层架构 471
33.2.1　三层架构概述 471
33.2.2　三层架构的编程模型 471
33.2.3　三层架构的优缺点 472
33.3　ORM架构 473
33.3.1　ORM架构概述 473
33.3.2　ORM架构的编程模型 473
33.3.3　ORM架构的优缺点 474
33.4　MVC架构 474
33.4.1　MVC架构概述 474
33.4.2　MVC架构的编程模型 475
33.4.3　MVC架构的优缺点 476
33.5　RPC架构 477
33.5.1　RPC架构概述 477
33.5.2　RPC架构的编程模型 477
33.5.3　RPC架构的优缺点 478
33.6　未来软件架构演进之路 478