设计模式就该这样学：基于经典框架源码和真实业务场景电子书

作者简介

内容简介

序言

关于本书

关于我

第1篇　软件设计前奏篇

第1章　重新认识UML

1.1　UML的定义

1.2　UML应用场景

1.3　UML基本构件简介

1.3.1　事物

1.3.2　关系

1.3.3　图

第2章　设计模式常用的UML图

2.1　类图

2.1.1　继承关系

2.1.2　实现关系

2.1.3　组合关系

2.1.4　聚合关系

2.1.5　关联关系

2.1.6　依赖关系

2.1.7　类关系记忆技巧

2.2　时序图

2.2.1　时序图的作用

2.2.2　时序图组成元素

2.2.3　时序图组合片段

2.2.4　时序图画法及应用实践

第3章　七大软件架构设计原则

3.1　开闭原则

3.1.1　开闭原则的定义

3.1.2　使用开闭原则解决实际问题

3.2　依赖倒置原则

3.2.1　依赖倒置原则的定义

3.2.2　使用依赖倒置原则解决实际问题

3.3　单一职责原则

3.3.1　单一职责原则的定义

3.3.2　使用单一职责原则解决实际问题

3.4　接口隔离原则

3.4.1　接口隔离原则的定义

3.4.2　使用接口隔离原则解决实际问题

3.5　迪米特法则

3.5.1　迪米特法则的定义

3.5.2　使用迪米特法则解决实际问题

3.6　里氏替换原则

3.6.1　里氏替换原则的定义

3.6.2　使用里氏替换原则解决实际问题

3.7　合成复用原则

3.7.1　合成复用原则的定义

3.7.2　使用合成复用原则解决实际问题

3.8　软件架构设计原则小结

第4章　关于设计模式的那些事儿

4.1　本书与GoF的《设计模式》的关系

4.2　为什么一定要学习设计模式

4.2.1　写出优雅的代码

4.2.2　更好地重构项目

4.2.3　经典框架都在用设计模式解决问题

第2篇　创建型设计模式

第5章　简单工厂模式

5.1　工厂模式的历史由来

5.2　简单工厂模式概述

5.2.1　简单工厂模式的定义

5.2.2　简单工厂模式的应用场景

5.2.3　简单工厂模式的UML类图

5.2.4　简单工厂模式的通用写法

5.3　使用简单工厂模式封装产品创建细节

5.4　简单工厂模式在框架源码中的应用

5.4.1　简单工厂模式在JDK源码中的应用

5.4.2　简单工厂模式在Logback源码中的应用

5.5　简单工厂模式扩展

5.5.1　简单工厂模式的优点

5.5.2　简单工厂模式的缺点

第6章　工厂方法模式

6.1　工厂方法模式概述

6.1.1　工厂方法模式的定义

6.1.2　工厂方法模式的应用场景

6.1.3　工厂方法模式的UML类图

6.1.4　工厂方法模式的通用写法

6.2　使用工厂方法模式实现产品扩展

6.3　工厂方法模式在Logback源码中的应用

6.4　工厂方法模式扩展

6.4.1　工厂方法模式的优点

6.4.2　工厂方法模式的缺点

第7章　抽象工厂模式

7.1　抽象工厂模式概述

7.1.1　抽象工厂模式的定义

7.1.2　关于产品等级结构和产品族

7.1.3　抽象工厂模式的应用场景

7.1.4　抽象工厂模式的UML类图

7.1.5　抽象工厂模式的通用写法

7.2　使用抽象工厂模式解决实际问题

7.2.1　使用抽象工厂模式支持产品扩展

7.2.2　使用抽象工厂模式重构数据库连接池

7.3　抽象工厂模式在Spring源码中的应用

7.4　抽象工厂模式扩展

7.4.1　抽象工厂模式的优点

7.4.2　抽象工厂模式的缺点

第8章　单例模式

8.1　单例模式概述

8.1.1　单例模式的定义

8.1.2　单例模式的应用场景

8.1.3　单例模式的UML类图

8.1.4　单例模式的通用写法

8.2　使用单例模式解决实际问题

8.2.1　饿汉式单例写法的弊端

8.2.2　还原线程破坏单例的事故现场

8.2.3　双重检查锁单例写法闪亮登场

8.2.4　看似完美的静态内部类单例写法

8.2.5　还原反射破坏单例模式的事故现场

8.2.6　更加优雅的枚举式单例写法问世

8.2.7　还原反序列化破坏单例模式的事故现场

8.2.8　使用容器式单例写法解决大规模生产单例的问题

8.2.9　ThreadLocal单例详解

8.3　单例模式在框架源码中的应用

8.3.1　单例模式在JDK源码中的应用

8.3.2　单例模式在Spring源码中的应用

8.4　单例模式扩展

8.4.1　单例模式的优点

8.4.2　单例模式的缺点

第9章　原型模式

9.1　原型模式概述

9.1.1　原型模式的定义

9.1.2　原型模式的应用场景

9.1.3　原型模式的UML类图

9.1.4　原型模式的通用写法

9.2　使用原型模式解决实际问题

9.2.1　分析JDK浅克隆API带来的问题

9.2.2　使用序列化实现深克隆

9.2.3　还原克隆破坏单例的事故现场

9.3　原型模式在框架源码中的应用

9.3.1　原型模式在JDK源码中的应用

9.3.2　原型模式在Spring源码中的应用

9.4　原型模式扩展

9.4.1　原型模式的优点

9.4.2　原型模式的缺点

第10章　建造者模式

10.1　建造者模式概述

10.1.1　建造者模式的定义

10.1.2　建造者模式的应用场景

10.1.3　建造者模式的UML类图

10.1.4　建造者模式的通用写法

10.2　使用建造者模式解决实际问题

10.2.1　建造者模式的链式写法

10.2.2　使用静态内部类实现建造者模式

10.2.3　使用建造者模式动态构建SQL语句

10.3　建造者模式在框架源码中的应用

10.3.1　建造者模式在JDK源码中的应用

10.3.2　建造者模式在MyBatis源码中的应用

10.3.3　建造者模式在Spring源码中的应用

10.4　建造者模式扩展

10.4.1　建造者模式与工厂模式的区别

10.4.2　建造者模式的优点

10.4.3　建造者模式的缺点

第3篇　结构型设计模式

第11章　代理模式

11.1　代理模式概述

11.1.1　代理模式的定义

11.1.2　代理模式的应用场景

11.1.3　代理模式的UML类图

11.1.4　代理模式的通用写法

11.2　使用代理模式解决实际问题

11.2.1　从静态代理到动态代理

11.2.2　三层架构中的静态代理

11.2.3　使用动态代理实现无感知切换数据源

11.2.4　手写JDK动态代理核心原理

11.2.5　CGLib动态代理API原理分析

11.2.6　CGLib和JDK动态代理对比分析

11.3　代理模式在框架源码中的应用

11.3.1　代理模式在Spring源码中的应用

11.3.2　代理模式在MyBatis源码中的应用

11.4　代理模式扩展

11.4.1　静态代理和动态代理的区别

11.4.2　代理模式的优点

11.4.3　代理模式的缺点

第12章　门面模式

12.1　门面模式概述

12.1.1　门面模式的定义

12.1.2　门面模式的应用场景

12.1.3　门面模式的UML类图

12.1.4　门面模式的通用写法

12.2　使用门面模式整合已知API的功能

12.3　门面模式在框架源码中的应用

12.3.1　门面模式在Spring源码中的应用

12.3.2　门面模式在MyBatis源码中的应用

12.3.3　门面模式在Tomcat源码中的应用

12.4　门面模式扩展

12.4.1　门面模式的优点

12.4.2　门面模式的缺点

第13章　装饰器模式

13.1　装饰器模式概述

13.1.1　装饰器模式的定义

13.1.2　装饰器模式的应用场景

13.1.3　装饰器模式的UML类图

13.1.4　装饰器模式的通用写法

13.2　使用装饰器模式解决实际问题

13.2.1　使用装饰器模式解决煎饼“加码”问题

13.2.2　使用装饰器模式扩展日志格式输出

13.3　装饰器模式在框架源码中的应用

13.3.1　装饰器模式在JDK源码中的应用

13.3.2　装饰器模式在Spring源码中的应用

13.3.3　装饰器模式在MyBatis源码中的应用

13.4　装饰器模式扩展

13.4.1　装饰器模式与代理模式的区别

13.4.2　装饰器模式的优点

13.4.3　装饰器模式的缺点

第14章　享元模式

14.1　享元模式概述

14.1.1　享元模式的定义

14.1.2　享元模式的应用场景

14.1.3　享元模式的UML类图

14.1.4　享元模式的通用写法

14.2　使用享元模式解决实际问题

14.2.1　使用享元模式实现资源共享池

14.2.2　使用享元模式实现数据库连接池

14.3　享元模式在框架源码中的应用

14.3.1　享元模式在JDK源码中的应用

14.3.2　享元模式在Apache Pool源码中的应用

14.4　享元模式扩展

14.4.1　享元模式的内部状态和外部状态

14.4.2　享元模式的优点

14.4.3　享元模式的缺点

第15章　组合模式

15.1　组合模式概述

15.1.1　组合模式的定义

15.1.2　组合模式的应用场景

15.1.3　透明组合模式的UML类图及通用写法

15.1.4　安全组合模式的UML类图及通用写法

15.2　使用组合模式解决实际问题

15.2.1　使用透明组合模式实现课程目录结构

15.2.2　使用安全组合模式实现无限级文件系统

15.3　组合模式在框架源码中的应用

15.3.1　组合模式在JDK源码中的应用

15.3.2　组合模式在MyBatis源码中的应用

15.4　组合模式扩展

15.4.1　组合模式的优点

15.4.2　组合模式的缺点

第16章　适配器模式

16.1　适配器模式概述

16.1.1　适配器模式的定义

16.1.2　适配器模式的应用场景

16.1.3　类适配器的UML类图及通用写法

16.1.4　对象适配器的UML类图及通用写法

16.1.5　接口适配器的UML类图及通用写法

16.2　使用适配器模式解决实际问题

16.2.1　使用类适配器重构第三方登录自由适配

16.2.2　使用接口适配器优化代码

16.3　适配器模式在Spring源码中的应用

16.4　适配器模式扩展

16.4.1　适配器模式与装饰器模式的区别

16.4.2　适配器模式的优点

16.4.3　适配器模式的缺点

第17章　桥接模式

17.1　桥接模式概述

17.1.1　桥接模式的定义

17.1.2　桥接模式的应用场景

17.1.3　桥接模式的UML类图

17.1.4　桥接模式的通用写法

17.2　使用桥接模式设计复杂消息系统

17.3　桥接模式在JDK源码中的应用

17.4　桥接模式扩展

17.4.1　桥接模式的优点

17.4.2　桥接模式的缺点

第4篇　行为型设计模式

第18章　委派模式

18.1　委派模式概述

18.1.1　委派模式的定义

18.1.2　委派模式的应用场景

18.1.3　委派模式的UML类图

18.1.4　委派模式的通用写法

18.2　使用委派模式模拟任务分配场景

18.3　委派模式在框架源码中的应用

18.3.1　委派模式在JDK源码中的应用

18.3.2　委派模式在Spring源码中的应用

18.4　委派模式扩展

18.4.1　委派模式的优点

18.4.2　委派模式的缺点

第19章　模板方法模式

19.1　模板方法模式概述

19.1.1　模板方法模式的定义

19.1.2　模板方法模式的应用场景

19.1.3　模板方法模式的UML类图

19.1.4　模板方法模式的通用写法

19.2　使用模板方法模式解决实际问题

19.2.1　模板方法模式中的钩子方法

19.2.2　使用模板方法模式重构JDBC业务操作

19.3　模板方法模式在框架源码中的应用

19.3.1　模板方法模式在JDK源码中的应用

19.3.2　模板方法模式在MyBatis源码中的应用

19.4　模板方法模式扩展

19.4.1　模板方法模式的优点

19.4.2　模板方法模式的缺点

第20章　策略模式

20.1　策略模式概述

20.1.1　策略模式的定义

20.1.2　策略模式的应用场景

20.1.3　策略模式的UML类图

20.1.4　策略模式的通用写法

20.2　使用策略模式解决实际问题

20.2.1　使用策略模式实现促销优惠方案选择

20.2.2　使用策略模式重构支付方式选择场景

20.2.3　策略模式和委派模式结合使用

20.3　策略模式在框架源码中的应用

20.3.1　策略模式在JDK源码中的应用

20.3.2　策略模式在Spring源码中的应用

20.4　策略模式扩展

20.4.1　策略模式的优点

20.4.2　策略模式的缺点

第21章　责任链模式

21.1　责任链模式概述

21.1.1　责任链模式的定义

21.1.2　责任链模式的应用场景

21.1.3　责任链模式的UML类图

21.1.4　责任链模式的通用写法

21.2　使用责任链模式解决实际问题

21.2.1　使用责任链模式设计热插拔权限控制

21.2.2　责任链模式和建造者模式结合使用

21.3　责任链模式在框架源码中的应用

21.3.1　责任链模式在JDK源码中的应用

21.3.2　责任链模式在Netty源码中的应用

21.4　责任链模式扩展

21.4.1　责任链模式的优点

21.4.2　责任链模式的缺点

第22章　迭代器模式

22.1　迭代器模式概述

22.1.1　迭代器模式的定义

22.1.2　迭代器模式的应用场景

22.1.3　迭代器模式的UML类图

22.1.4　迭代器模式的通用写法

22.2　手写自定义的集合迭代器

22.3　迭代器模式在框架源码中的应用

22.3.1　迭代器模式在JDK源码中的应用

22.3.2　迭代器模式在MyBatis源码中的应用

22.4　迭代器模式扩展

22.4.1　迭代器模式的优点

22.4.2　迭代器模式的缺点

第23章　命令模式

23.1　命令模式概述

23.1.1　命令模式的定义

23.1.2　命令模式的应用场景

23.1.3　命令模式的UML类图

23.1.4　命令模式的通用写法

23.2　使用命令模式重构播放器控制条

23.3　命令模式在框架源码中的应用

23.3.1　命令模式在JDK源码中的应用

23.3.2　命令模式在JUnit源码中的应用

23.4　命令模式扩展

23.4.1　命令模式的优点

23.4.2　命令模式的缺点

第24章　状态模式

24.1　状态模式概述

24.1.1　状态模式的定义

24.1.2　状态模式的应用场景

24.1.3　状态模式的UML类图

24.1.4　状态模式的通用写法

24.2　使用状态模式解决实际问题

24.2.1　使用状态模式实现登录状态自由切换

24.2.2　使用状态机实现订单状态流转控制

24.3　状态模式在JSF源码中的应用

24.4　状态模式扩展

24.4.1　状态模式与责任链模式的区别

24.4.2　状态模式与策略模式的区别

24.4.3　状态模式的优点

24.4.4　状态模式的缺点

第25章　备忘录模式

25.1　备忘录模式概述

25.1.1　备忘录模式的定义

25.1.2　备忘录模式的应用场景

25.1.3　备忘录模式的UML类图

25.1.4　备忘录模式的通用写法

25.2　使用备忘录模式实现草稿箱功能

25.3　备忘录模式在Spring源码中的应用

25.4　备忘录模式扩展

25.4.1　备忘录模式的优点

25.4.2　备忘录模式的缺点

第26章　中介者模式

26.1　中介者模式概述

26.1.1　中介者模式的定义

26.1.2　中介者模式的应用场景

26.1.3　中介者模式的UML类图

26.1.4　中介者模式的通用写法

26.2　使用中介者模式设计群聊场景

26.3　中介者模式在JDK源码中的应用

26.4　中介者模式扩展

26.4.1　中介者模式的优点

26.4.2　中介者模式的缺点

第27章　解释器模式

27.1　解释器模式概述

27.1.1　解释器模式的定义

27.1.2　解释器模式的应用场景

27.1.3　解释器模式的UML类图

27.1.4　解释器模式的通用写法

27.2　使用解释器模式解析数学表达式

27.3　解释器模式在框架源码中的应用

27.3.1　解释器模式在JDK源码中的应用

27.3.2　解释器模式在Spring源码中的应用

27.4　解释器模式扩展

27.4.1　解释器模式的优点

27.4.2　解释器模式的缺点

第28章　观察者模式

28.1　观察者模式概述

28.1.1　观察者模式的定义

28.1.2　观察者模式的应用场景

28.1.3　观察者模式的UML类图

28.1.4　观察者模式的通用写法

28.2　使用观察者模式解决实际问题

28.2.1　基于Java API实现通知机制

28.2.2　基于Guava API轻松落地观察者模式

28.2.3　使用观察者模式设计鼠标事件响应API

28.3　观察者模式在Spring源码中的应用

28.4　观察者模式扩展

28.4.1　观察者模式的优点

28.4.2　观察者模式的缺点

第29章　访问者模式

29.1　访问者模式概述

29.1.1　访问者模式的定义

29.1.2　访问者模式的应用场景

29.1.3　访问者模式的UML类图

29.1.4　访问者模式的通用写法

29.2　使用访问者模式解决实际问题

29.2.1　使用访问者模式实现KPI考核的场景

29.2.2　从静态分派到动态分派

29.2.3　访问者模式中的伪动态分派

29.3　访问者模式在框架源码中的应用

29.3.1　访问者模式在JDK源码中的应用

29.3.2　访问者模式在Spring源码中的应用

29.4　访问者模式扩展

29.4.1　访问者模式的优点

29.4.2　访问者模式的缺点

第5篇　设计模式总结篇

第30章　专治设计模式选择困难症

30.1　设计模式到底如何落地

30.2　各种设计模式使用频率总结

30.2.1　创建型设计模式

30.2.2　结构型设计模式

30.2.3　行为型设计模式

30.3　一句话归纳设计模式

第31章　容易混淆的设计模式对比

31.1　创建型设计模式对比

31.1.1　工厂方法模式与抽象工厂模式对比

31.1.2　简单工厂模式与单例模式对比

31.1.3　简单工厂模式与建造者模式对比

31.2　结构型设计模式对比

31.2.1　装饰器模式与代理模式对比

31.2.2　装饰器模式与门面模式对比

31.2.3　装饰器模式与适配器模式对比

31.2.4　适配器模式与代理模式对比

31.3　行为型设计模式对比

31.3.1　策略模式与模板方法模式对比

31.3.2　策略模式与命令模式对比

31.3.3　策略模式与委派模式对比

31.3.4　桥接模式与适配器模式对比

31.3.5　桥接模式与组合模式对比

31.4　跨类综合对比

31.4.1　享元模式与容器式单例模式对比

31.4.2　建造者模式与装饰器模式对比

31.4.3　策略模式与简单工厂模式对比

31.4.4　策略模式与适配器模式对比

31.4.5　中介者模式与适配器模式对比

31.4.6　中介者模式与代理模式对比

31.4.7　中介者模式与桥接模式对比

31.4.8　桥接模式与命令模式对比

31.4.9　委派模式与门面模式对比

31.4.10　委派模式与代理模式对比

第6篇　架构设计扩展篇

第32章　新设计模式

32.1　对象池模式

32.1.1　对象池模式的定义

32.1.2　对象池模式的应用场景

32.1.3　对象池模式的UML类图

32.1.4　对象池模式的通用写法

32.1.5　对象池模式的优缺点

32.2　规格模式

32.2.1　规格模式的定义

32.2.2　规格模式的应用场景

32.2.3　规格模式的UML类图

32.2.4　规格模式的通用写法

32.2.5　规格模式的优缺点

32.3　空对象模式

32.3.1　空对象模式的定义

32.3.2　空对象模式的应用场景

32.3.3　空对象模式的UML类图

32.3.4　空对象模式的通用写法

32.3.5　空对象模式的优缺点

32.4　雇工模式

32.4.1　雇工模式的定义

32.4.2　雇工模式的应用场景

32.4.3　雇工模式的UML类图

32.4.4　雇工模式的通用写法

32.4.5　雇工模式的优缺点

第33章　软件架构与设计模式

33.1　软件架构和设计模式的区别

33.2　三层架构

33.2.1　三层架构概述

33.2.2　三层架构的编程模型

33.2.3　三层架构的优缺点

33.3　ORM架构

33.3.1　ORM架构概述

33.3.2　ORM架构的编程模型

33.3.3　ORM架构的优缺点

33.4　MVC架构

33.4.1　MVC架构概述

33.4.2　MVC架构的编程模型

33.4.3　MVC架构的优缺点

33.5　RPC架构

33.5.1　RPC架构概述

33.5.2　RPC架构的编程模型

33.5.3　RPC架构的优缺点

33.6　未来软件架构演进之路

反侵权盗版声明

后折页