Java应用架构设计 模块化模式与OSGiPDF电子书下载

第一部分 模块化的理由 2

第1章 模块定义 2

1.1定义模块 2

1.1.1可部署 3

1.1.2可管理 3

1.1.3可测试 3

1.1.4原生可重用 3

1.1.5可组合 4

1.1.6无状态 4

1.2软件模块的简洁定义 4

1.3结论 4

第2章 模块化的两个方面 5

2.1运行时模型 5

2.2开发模型 5

2.2.1编程模型 6

2.2.2设计范式 6

2.3模块化现状 8

2.4结论 10

第3章 架构与模块化 11

3.1定义架构 11

3.2关于软件架构的一个故事 12

3.2.1象牙塔 12

3.2.2乌龟和塔 13

3.3架构的目标 15

3.3.1.悖论 15

3.3.2消除架构 16

3.4模块化：被忽视的部分 17

3.5回答我们的问题 23

3.6结论 23

3.7参考文献 24

第4章 征服复杂性 25

4.1企业级复杂性 25

4.2技术债 26

4.3设计腐化 27

4.3.1干扰可维护性 27

4.3.2阻止可扩展性 28

4.3.3抑制可重用性 28

4.3.4限制可测试性 28

4.3.5 妨碍集成 28

4.3.6 阻碍理解 29

4.4循环依赖 29

4.4.1循环类型 29

4.4.2悄然引入的循环 32

4.4.3管理循环 33

4.4.4循环总是不好的吗 33

4.5结合点、模块和SOLID 34

4.6管理复杂性 35

4.7模块化的益处 37

4.8结论 37

4.9参考文献 38

第5章 实现重用 39

5.1可用/重用悖论 39

5.2关于重用的免责声明 40

5.2.1粒度 40

5.2.2重量级 41

5.3重用还是可用 42

5.4模块化权衡 42

5.5模块化设计 43

5.6结论 44

5.7参考文献 45

第6章 模块化与SOA 46

6.1重新审视“自上而下” 46

6.2粒度——架构师的强大对手 48

6.2.1现实世界的一个例子 48

6.2.2提升一个等级 49

6.2.3另一个维度 50

6.2.4全景图 51

6.2.5服务样例 52

6.3另一个视图 54

6.4结论 55

第7章 参考实现 56

7.1为什么不用OSGi 56

7.2这个练习的背景：构建系统 57

7.3初始版本 57

7.4第一次重构 59

7.5第二次重构 61

7.6第三次重构 63

7.7第四次重构 66

7.7.1关于OSGi的好处 67

7.7.2小结并准备下一次重构 68

7.8第五次重构 68

7.9第六次重构 69

7.10第七次重构 72

7.11事后剖析 72

7.11.1关于模块测试 74

7.11.2关于管理模块依赖 74

7.11.3关于模块重用 76

7.11.4关于构建 77

7.11.5关于面向对象 77

7.12结论 78

7.13参考文献 78

第二部分 模式 81

第8章 基本模式 81

8.1管理关系 81

8.1.1表述 81

8.1.2描述 81

8.1.3多种实现 82

8.1.4影响 85

8.1.5样例 86

8.1.6小结 88

8.2模块重用 89

8.2.1表述 89

8.2.2描述 89

8.2.3多种实现 91

8.2.4效果 92

8.2.5样例 93

8.2.6小结 99

8.3模块内聚 99

8.3.1表述 99

8.3.2描述 100

8.3.3多种实现 100

8.3.4效果 101

8.3.5样例 101

8.3.6小结 104

第9章 依赖模式 105

9.1非循环关系 105

9.1.1表述 105

9.1.2描述 105

9.1.3多种实现 106

9.1.4效果 107

9.1.5样例 107

9.1.6小结 113

9.2等级化模块 113

9.2.1表述 113

9.2.2描述 113

9.2.3多种实现 115

9.2.4效果 115

9.2.5样例 116

9.2.6 小、结 117

9.3物理分层 118

9.3.1表述 118

9.3.2描述 118

9.3.3多种实现 119

9.3.4效果 119

9.3.5样例 120

9.3.6小结 123

9.4容器独立 124

9.4.1表述 124

9.4.2描述 124

9.4.3多种实现 125

9.4.4效果 125

9.4.5样例 126

9.4.6小结 129

9.5独立部署 129

9.5.1表述 129

9.5.2描述 130

9.5.3多种实现 130

9.5.4效果 131

9.5.5样例 132

9.5.6小结 135

9.6参考文献 136

第10章 可用性模式 137

10.1发布接口 137

10.1.1表述 137

10.1.2描述 137

10.1.3多种实现 138

10.1.4效果 140

10.1.5样例 141

10.1.6 小、结 146

10.2外部配置 147

10.2.1表述 147

10.2.2描述 147

10.2.3多种实现 147

10.2.4效果 148

10.2.5样例 149

10.2.6小结 151

10.3默认实现 151

10.3.1表述 151

10.3.2描述 151

10.3.3多种实现 151

10.3.4效果 153

10.3.5样例 153

10.3.6小结 156

10.4模块门面 156

10.4.1表述 156

10.4.2描述 156

10.4.3多种实现 156

10.4.4效果 158

10.4.5样例 158

10.4.6 小、结 162

第11章 扩展性模式 163

11.1抽象化模块 163

11.1.1表述 163

11.1.2描述 163

11.1.3多种实现 164

11.1.4效果 165

11.1.5样例 165

11.1.6小结 168

11.2实现工厂 168

11.2.1表述 168

11.2.2描述 169

11.2.3多种实现 169

11.2.4效果 171

11.2.5样例 171

11.2.6小结 175

11.3分离抽象 175

11.3.1表述 175

11.3.2描述 175

11.3.3多种实现 175

11.3.4效果 178

11.3.5样例 178

11.3.6小结 180

11.4参考文献 181

第12章 通用模式 182

12.1就近异常 182

12.1.1表述 182

12.1.2描述 182

12.1.3多种实现 182

12.1.4效果 183

12.1.5样例 184

12.1.6小结 187

12.2等级化构建 187

12.2.1表述 187

12.2.2描述 187

12.2.3多种实现 189

12.2.4效果 190

12.2.5样例 191

12.2.6小结 195

12.3测试模块 195

12.3.1表述 195

12.3.2描述 195

12.3.3多种实现 196

12.3.4效果 197

12.3.5样例 198

12.3.6小结 201

第三部分 模块化架构模式与OSGi 204

第13章 OSGi简介 204

13.1一点历史 204

13.2 OSGi所能带来的收益 204

13.2.1模块化开发 205

13.2.2管理依赖 205

13.2.3模块平台 205

13.2.4版本化的bundle 206

13.2.5动态（重）部署 206

13.2.6环境相关的控制 206

13.3深入理解OSGi 206

13.4 OSGi bundle 207

13.4.1 bundle状态 207

13.4.2 OSGi μService 208

13.5 OSGi运行时管理 209

13.6重新查看模块化的两个方面 209

13.7 OSGi与模式 209

13.7.1管理依赖 210

13.7.2动态性 210

13.7.3 Blueprint规范 211

第14章 贷款样例与OSGi 212

14.1起步 212

14.2清单文件 214

14.3 μService 215

14.3.1 Blueprint服务 215

14.3.2贷款样例配置 215

14.3.3 OSGi μService声明 218

14.4安装与执行 219

14.5结论 220

第15章 OSGi与Scala 221

15.1起步 221

15.2 Scala代码 221

15.3 Scala bean配置 224

15.4 Scala μService配置 224

15.5构建Scala模块 225

15.6安装与执行 225

15.7结论 226

第16章 OSGi与Groovy 227

16.1起步 227

16.2 Groovy代码 227

16.3 Groovy bean配置 230

16.4 Groovyμ Service配置 230

16.5构建Groovy模块 230

16.6安装与执行 231

16.7结论 232

第17章 OSGi的未来 233

17.1将OSGi作为推动者 233

17.2颠覆性 234

17.3生态系统的威力 236

17.3.1生态系统与模块化的两个方面 236

17.3.2基于组件的开发（CBD）不是已经成功了吗 236

17.4生态系统 237

17.5结论 238

附录A 类设计的SOLID原则 239