本站整理下载：

 

用户下载说明：

电子版仅供预览，下载后24小时内务必删除，支持正版，喜欢的请购买正版书籍：

http://product.dangdang.com/28994943.html

  

相关截图：



资料简介：

《设计模式就该这样学：基于经典框架源码和真实业务场景》从软件架构设计的通用技能UML开始，重点介绍常用的类图和时序图；然后介绍软件架构设计常用的七大原则；接着结合JDK、Spring、MyBatis、Tomcat、Netty等经典框架源码对GoF的23种设计模式展开分析，并结合作者多年“踩坑填坑”和“教学答疑”经验，用深刻、全面、通俗、生动、有趣、接地气的方式结合真实业务场景分析每种设计模式，治愈“设计模式选择困难症”；之后介绍4种常用的新设计模式；*后总结软件架构、设计模式与应用框架之间的区别。

如果你已经有编程经验，那么你一定要学一遍设计模式；如果你是资深工程师或者架构师，那么本书将颠覆你以前的认知；如果你觉得设计模式晦涩难懂，那么本书一定能让你醍醐灌顶；如果你看框架源码总是力不从心，那么本书就是“内功心法”

资料目录：

第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