Java应用架构设计：模块化模式与OSGi

组合重用原则

接口隔离原则

依赖倒置原则

Liskov替换原则

开放-封闭原则

单一职责原则

附录A 类设计的SOLID原则

17.5 结论

17.4 生态系统

17.3 生态系统的威力

17.2 颠覆性

17.1 将OSGi作为推动者

第17章 OSGi的未来

16.7 结论

16.6 安装与执行

16.5 构建Groovy模块

16.4 Groovy μService配置

16.3 Groovy bean配置

16.2 Groovy代码

16.1 起步

第16章 OSGi与Groovy

15.7 结论

15.6 安装与执行

15.5 构建Scala模块

15.4 Scala μService配置

15.3 Scala bean配置

15.2 Scala代码

15.1 起步

第15章 OSGi与Scala

14.5 结论

14.4 安装与执行

14.3 μService

14.2 清单文件

14.1 起步

第14章 贷款样例与OSGi

13.7 OSGi与模式

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

13.5 OSGi运行时管理

13.4 OSGi bundle

13.3 深入理解OSGi

13.2 OSGi所能带来的收益

13.1 一点历史

第13章 OSGi简介

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

12.3 测试模块

12.2 等级化构建

12.1 就近异常

第12章 通用模式

11.4 参考文献

11.3 分离抽象

11.2 实现工厂

11.1 抽象化模块

第11章 扩展性模式

10.4 模块门面

10.3 默认实现

10.2 外部配置

10.1 发布接口

第10章 可用性模式

9.6 参考文献

9.5 独立部署

9.4 容器独立

9.3 物理分层

9.2 等级化模块

9.1 非循环关系

第9章 依赖模式

8.3 模块内聚

8.2 模块重用

8.1 管理关系

第8章 基本模式

第二部分 模式

7.13 参考文献

7.12 结论

7.11 事后剖析

7.10 第七次重构

7.9 第六次重构

7.8 第五次重构

7.7 第四次重构

7.6 第三次重构

7.5 第二次重构

7.4 第一次重构

7.3 初始版本

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

7.1 为什么不用OSGi

第7章 参考实现

6.4 结论

6.3 另一个视图

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

6.1 重新审视“自上而下”

第6章 模块化与SOA

5.7 参考文献

5.6 结论

5.5 模块化设计

5.4 模块化权衡

5.3 重用还是可用

5.2 关于重用的免责声明

5.1 可用/重用悖论

第5章 实现重用

4.9 参考文献

4.8 结论

4.7 模块化的益处

4.6 管理复杂性

4.5 结合点、模块和SOLID

4.4 循环依赖

4.3 设计腐化

4.2 技术债

4.1 企业级复杂性

第4章 征服复杂性

3.7 参考文献

3.6 结论

3.5 回答我们的问题

3.4 模块化：被忽视的部分

3.3 架构的目标

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

3.1 定义架构

第3章 架构与模块化

2.4 结论

2.3 模块化现状

2.2 开发模型

2.1 运行时模型

第2章 模块化的两个方面

1.3 结论

1.2 软件模块的简洁定义

1.1 定义模块

第1章 模块定义

第一部分 模块化的理由

致谢

参考文献

模式化模式的开放式想法

代码

模式目录

小结

样例

效果

多种实现

描述

图示

模式表述

模式名称

模式形式

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

第二部分：模式

第一部分：模块化的理由

本书是如何组织的

本书所面向的读者

OSGi

模块化单元：JAR文件

模块化

逻辑设计与物理设计

面向对象的设计

前言

序2

序1

译者序

本书赞誉

版权信息

封面

封面

版权信息

本书赞誉

译者序

序1

序2

前言

面向对象的设计

逻辑设计与物理设计

模块化

模块化单元：JAR文件

OSGi

本书所面向的读者

本书是如何组织的

第一部分：模块化的理由

第二部分：模式

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

模式形式

模式名称

模式表述

图示

描述

多种实现

效果

样例

小结

模式目录

代码

模式化模式的开放式想法

参考文献

致谢

第一部分 模块化的理由

第1章 模块定义

1.1 定义模块

1.2 软件模块的简洁定义

1.3 结论

第2章 模块化的两个方面

2.1 运行时模型

2.2 开发模型

2.3 模块化现状

2.4 结论

第3章 架构与模块化

3.1 定义架构

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

3.3 架构的目标

3.4 模块化：被忽视的部分

3.5 回答我们的问题

3.6 结论

3.7 参考文献

第4章 征服复杂性

4.1 企业级复杂性

4.2 技术债

4.3 设计腐化

4.4 循环依赖

4.5 结合点、模块和SOLID

4.6 管理复杂性

4.7 模块化的益处

4.8 结论

4.9 参考文献

第5章 实现重用

5.1 可用/重用悖论

5.2 关于重用的免责声明

5.3 重用还是可用

5.4 模块化权衡

5.5 模块化设计

5.6 结论

5.7 参考文献

第6章 模块化与SOA

6.1 重新审视“自上而下”

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

6.3 另一个视图

6.4 结论

第7章 参考实现

7.1 为什么不用OSGi

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

7.3 初始版本

7.4 第一次重构

7.5 第二次重构

7.6 第三次重构

7.7 第四次重构

7.8 第五次重构

7.9 第六次重构

7.10 第七次重构

7.11 事后剖析

7.12 结论

7.13 参考文献

第二部分 模式

第8章 基本模式

8.1 管理关系

8.2 模块重用

8.3 模块内聚

第9章 依赖模式

9.1 非循环关系

9.2 等级化模块

9.3 物理分层

9.4 容器独立

9.5 独立部署

9.6 参考文献

第10章 可用性模式

10.1 发布接口

10.2 外部配置

10.3 默认实现

10.4 模块门面

第11章 扩展性模式

11.1 抽象化模块

11.2 实现工厂

11.3 分离抽象

11.4 参考文献

第12章 通用模式

12.1 就近异常

12.2 等级化构建

12.3 测试模块

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

第13章 OSGi简介

13.1 一点历史

13.2 OSGi所能带来的收益

13.3 深入理解OSGi

13.4 OSGi bundle

13.5 OSGi运行时管理

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

13.7 OSGi与模式

第14章 贷款样例与OSGi

14.1 起步

14.2 清单文件

14.3 μService

14.4 安装与执行

14.5 结论

第15章 OSGi与Scala

15.1 起步

15.2 Scala代码

15.3 Scala bean配置

15.4 Scala μService配置

15.5 构建Scala模块

15.6 安装与执行

15.7 结论

第16章 OSGi与Groovy

16.1 起步

16.2 Groovy代码

16.3 Groovy bean配置

16.4 Groovy μService配置

16.5 构建Groovy模块

16.6 安装与执行

16.7 结论

第17章 OSGi的未来

17.1 将OSGi作为推动者

17.2 颠覆性

17.3 生态系统的威力

17.4 生态系统

17.5 结论

附录A 类设计的SOLID原则

单一职责原则

开放-封闭原则

Liskov替换原则

依赖倒置原则

接口隔离原则

组合重用原则