面向方面的软件开发PDF电子书下载

目录译者序关于主编关于撰稿人前言第1章 概览 1

1.1　本书的组织 1

1.2　常用术语 2

1.3　历史背景 3

第一部分　语言和基础传统工程 5

软件开发是工程 6

章节说明 7

方面语言设计的角度 10

参考文献 11

2.2　局部性和单一性语句 12

2.1 引言 12

第2章 面向方面编程的多量化和不知觉性 12

2.4　多量化 13

2.3　不知觉性 13

2.4.2　动态多量化 14

2.4.1　静态多量化 14

2.6　面向方面的语言 15

2.5　实现问题 15

2.8　结束语 16

2.7　相关工作 16

参考文献 17

致谢 17

3.1 引言 21

第3章 N度分离：关注点的多维分离 21

3.2.1　第一轮 22

3.2　动机 22

3.2.2　进化SEE：环境灾难 23

3.2.3　事后分析 24

3.3.1　传统软件模型 25

3.3　关注点的多维分解 25

3.2.4　打破统治地位 25

3.3.2　多维分解：超切片 26

3.3.3　使用超模块组合超切片 28

3.3.4　使用模型 30

3.4.1　映射到单元和模块 31

3.4　实例化 31

3.5　相关工作 32

3.4.3　支持组合 32

3.4.2　超切片表示 32

3.6　结论和将来的工作 33

参考文献 34

致谢 34

4.1 引言 37

第4章 组合过滤器的原理和设计原理 37

4.2.2　软件系统 38

4.2.1　应用的概述 38

4.2　例子：社会安全服务 38

4.3　用组合过滤器进行对象内横切 39

4.3.1　关注点实例＝对象＋过滤器 40

4.3.3　组合过滤器解决方案 41

4.3.2　演化步骤1：保护文档 41

4.3.4　消息处理 43

4.4　对象间横切 45

4.3.5　对象内部横切 45

4.4.1　演化步骤2：添加工作流管理 46

4.4.2　演化步骤3：添加日志 49

4.5.1 CF模型的实现 51

4.5　评估 51

4.5.2　内置式组合过滤器 52

4.6　结论 53

参考文献 54

5.1　风格问题 58

第5章 从历史视角探讨AOP（名称的由来） 58

5.2.2　对问题和专门解决方案的分析 59

5.2.1　问题的描述 59

5.2　20世纪90年代早期的研究趋势 59

5.2.4　分离技术 60

5.2.3　识别可以被分离的关注点 60

5.3.1　RG 62

5.3 AOP在PARC的诞生 62

5.3.4　DJ 63

5.3.3 ETCML 63

5.3.2 AML 63

5.3.6　AspectJ 65

5.3.5　Djava 65

5.4.2　实践者 67

5.4.1　研究者 67

5.4　建立团体 67

5.5 回顾 68

5.7　将来的挑战 69

5.6 AOP的本质 69

参考文献 70

致谢 70

6.1.2　基于编程语言的直接支持 74

6.1.1　通用目的 74

第6章 AspectJ 74

6.1　AspectJ的目标 74

6.2　AspectJ语言 75

6.1.6　适合真实的应用 75

6.1.3　易于学习 75

6.1.4　增量式应用 75

6.1.5　易于集成 75

6.2.1　联结点 76

6.2.2　切入点 77

6.2.3　通知 78

6.2.4　类型间声明 80

6.2.5　方面 81

6.3.1　历史 82

6.3　AspectJ工具 82

6.2.6　进一步阅读 82

6.3.2　编译器 83

6.3.3　AspectJ的IDE支持 84

6.4　将来的方向 86

6.3.5　Ant任务 86

6.3.4　使用ajdoc生成文档 86

6.5　结束语 87

参考文献 88

致谢 88

7.1.2　结构含蓄的编程 89

7.1.1　关注点含蓄的编程 89

第7章 耦合面向方面和自适应编程 89

7.1　概述 89

7.2.1　含蓄性怎样关联到AP 90

7.2　含蓄性作为自适应行为的隐喻 90

7.3　使用DJ的反射自适应编程 91

7.2.4　针对关注点的Demeter法则 91

7.2.2 含蓄性怎样关联到AOP 91

7.2.3　Demeter法则 91

7.4.2　访问者类 97

7.4.1　策略图交叉 97

7.4　使用DAJ的方面自适应编程 97

7.6　结论 98

7.5　相关工作 98

参考文献 99

8.1　引言 102

第8章 使用CAESAR解开横切模型 102

8.1.1　对语言支持的需求 104

8.2　联结点介入 106

8.1.2　本章的贡献和结构 106

8.2.1　缺乏对多抽象方面的支持 108

8.2.4　缺乏对方面多态的支持 109

8.2.3　缺乏对可重用方面联编的支持 109

8.2.2　缺乏对复杂映射的支持 109

8.3　CAESAR模型 110

8.3.2　方面实现 111

8.3.1　方面合作接口 111

8.3.4　封装器再利用 112

8.3.3　方面联编 112

8.3.5　最专用的封装器 113

8.3.6　切入点和通知 114

8.3.7　编织片和部署 115

8.3.8　虚类和静态类型 117

8.4.1　问题再现 118

8.4　评估 118

8.4.2　显式与隐含方面的实例化／部署 119

8.6.1　开放类 120

8.6　相关工作 120

8.5 实现 120

8.6.3　基于合作的分解 121

8.6.2 自适应性即插即用组件 121

参考文献 122

8.7　总结和将来的工作 122

8.6.4　动态部署的实现 122

9.1　引言 125

第9章 基于跟踪的方面 125

9.2.2　方面语言 126

9.2.1　可观察的执行跟踪 126

9.2　基于跟踪的方面的特征 126

9.3　表达性方面和等价推导 127

9.2.3　编织 127

9.4　方面交互的检测和消解 128

9.4.2　对冲突消解的支持 129

9.4.1　方面交互 129

9.5.1　例子 130

9.5　安全属性的静态编织 130

9.5.2　编织阶段 131

9.5.3　即时编织 132

9.6　结论 133

参考文献 134

10.1　介绍 136

第10章 使用Mixin技术提高模块化特性 136

10.2.1　Mixin 137

10.2　MIXIN技术 137

10.2.3　Mixin层 138

10.2.2　逐步细化 138

10.3.1　体系结构 139

10.3　FIDGET的设计 139

10.3.2　组件 140

10.3.3　同胞模式 141

10.3.4　JL的隐含的this类型参数 142

10.4 FIDGET的使用 143

10.6.1　语义检测 144

10.6　将来的工作 144

10.5 MIXIN的编程支持 144

10.5.1　构造器传播 144

10.5.2　深度一致性 144

10.6.3　Mixin作为类型 145

10.6.2　类层次优化 145

10.6.4　实现参数化多态 146

参考文献 147

致谢 147

10.7　相关工作 147

10.8　结论 147

11.1　引言 150

第11章 用首类名字空间分离关注点 150

11.2.1　Piccola层 151

11.2　Piccola 151

11.2.2　通用封装器 153

11.3　例子：Mixin层组合 154

11.3.1　Piccola 中的Mixin层 155

11.3.2　使用Mixin层的软件演化 156

11.4　用形式结构描述组合风格 157

致谢 158

11.5　结论 158

参考文献 159

12.1.1　基础级和元级 161

12.1　什么是反射 161

第12章 使用反射支持AOP 161

12.1.4　反射编程语言及其MOP的例子 162

12.1.3　元链和元对象协作 162

12.1.2　元对象及其协议 162

12.2　使用反射的AOP 165

12.2.3　分离方面 166

12.2.2　使用多个方面的应用例子 166

12.2.1 从反射到AOP 166

12.2.4　编织方面 168

12.3.2　性能 170

12.3.1　灵活性 170

12.3　讨论 170

12.4　结论 171

12.3.5　重用性 171

12.3.3　复杂性 171

12.3.4 工具 171

参考文献 172

13.1　通过控制通信实现Ility 175

第13章 通过控制通信插入Ility 175

13.2　对象基础框架 176

13.2.2　注解 177

13.2.1　注入器 177

13.2.3　Pragma 178

13.3.3　可管理性 180

13.3.2　服务质量 180

13.3　已应用Ility 180

13.3.1　可靠性 180

13.5　结论 181

13.4　相关工作 181

13.3.4　安全 181

参考文献 182

14.1　方面和转换 184

第14章 使用字节码转换集成新特征 184

14.2.2　动态转换 185

14.2.1　静态转换 185

14.2　字节码转换概述 185

14.3.1　选择 186

14.3　编程转换 186

14.4.1　接口设计 187

14.4　学到的经验 187

14.3.2　在AOSD中的使用 187

14.4.2　安全、可靠和正确 188

14.4.6　调试转换代码 189

14.4.5　处理转换的功能 189

14.4.3　多个名字空间 189

14.4.4 反射 189

参考文献 190

14.5　结论 190

15.1.1　方面编织的挑战 192

15.1　引言 192

第15章 JMangler——一个面向方面编程的强大后端平台 192

15.1.3　面向方面的LAT和JMangler 193

15.1.2　加载时间分析和转换（LAT）的保证 193

15.2.1　Java的类加载体系结构 194

15.2　通用拦截 194

15.3　开放式体系结构 195

15.2.5　可移植的通用拦截 195

15.2.2　依赖类加载器的拦截 195

15.2.3　依赖JVM的拦截 195

15.2.4　依赖于平台的拦截 195

15.4　对非本地转换的支持 196

15.5　BCEL编织器 197

15.5.4　非预期的转换器组合 198

15.5.3　转换器的使用 198

15.5.1　转换和方面 198

15.5.2　转换器 198

15.5.5　转换过程 199

15.5.7　接口转换器的创建 200

15.5.6　例子 200

15.6.1　使用JMangler的加载时编织 201

15.6　使用场景 201

15.5.8　代码转换器的创建 201

15.6.3　先进特征 202

15.6.2　使用JMangler的运行时编织 202

15.7　相关工作 203

致谢 204

15.8　结论和将来的工作 204

本章附录：简单的代码覆盖 205

CodeCoverTransformer的实现 207

激活 208

参考文献 209

16.2　设计符号 213

16.1　JAC框架和编程模型 213

第16章 使用Java方面组件的面向方面软件开发 213

16.2.2　切入点定义 214

16.2.1　方面组件类 214

16.2.3　第一个简单的例子 217

16.2.4　为分布扩展的设计符号 218

16.3.2　分布式应用的例子 220

16.3.1　方面部署和分布 220

16.3 分布式的JAC体系结构 220

16.4.1　JAC的实现 224

16.4　JAC的实现和性能问题 224

16.4.2　性能衡量 225

16.5.1 面向方面的语言和工具 226

16.5　相关技术和工具 226

16.5.2　方面设计符号对比 227

参考文献 228

16.6　结论 228

第二部分　软件工程关键软件工程术语 231

章节介绍 232

参考文献 235

17.1　需求工程 236

第17章 工程化面向方面系统 236

17.2　描述 238

17.3　设计 240

17.4　实现 242

17.5　演化 243

17.6　方面交互 245

参考文献 246

17.7　结论 246

18.1　引言 253

第18章 软件生命周期中的面向方面：事实和想像 253

18.2.1　示例动机 254

18.2　在实现层次的方面 254

18.2.2　AOP：事实和想像 256

18.3.1　采用UML的方面 257

18.3　在设计层次的方面 257

18.3.2　基于软件体系结构观点的方面 259

18.4　结论 261

参考文献 262

致谢 262

19.1　引言 264

第19章 采用主题／UML的通用面向方面设计 264

19.3　横切主题：模型 265

19.2　动机 265

19.3.2　描述横切行为 266

19.3.1　描述模板 266

19.3.3　绑定描述的组合 267

19.4　作为主题的方面：例子 268

19.3.4　组合输出 268

19.4.2　例1：同步方面 269

19.4.1　图书馆基本设计 269

19.4.3　例2：观察者方面 270

19.5.1　Hyper/J编程元素 273

19.5　到Hyper/J的映射 273

19.5.2　基于Hyper/J的观察者模式 275

19.6　到AspectJ的映射 277

19.6.2　到AspectJ的映射算法 278

19.6.1　AspectJ编程元素 278

19.6.3　基于AspectJ的观察者模式 280

19.8　相关工作 282

19.7　映射到编程模型 282

19.9　结论 283

参考文献 284

20.1　引言 286

第20章 使用UML行为图和结构图来表示方面 286

20.2.1 面向方面编程 287

20.2　概念、术语和建模语言 287

20.2.2　统一建模语言（UML） 288

20.3　我们的方法体系规定的处理过程 289

20.3.3　分析和设计 290

20.3.2　并发限定缓存问题 290

20.3.1　AO建模步骤 290

20.3.4　使用类图的结构化描述 292

20.3.5　建模横切关注点（步骤6～8） 293

20.4.3　扩展性 295

20.4.2　松散耦合 295

20.4　实现我们的方法体系的益处 295

20.4.1　隐含编织 295

20.4.6 自动代码生成和循环开发 296

20.4.5　CASE工具对我们的方法体系的支持 296

20.4.4 可跟踪性 296

参考文献 297

致谢 297

20.5　结论 297

21.1 引言 299

第21章 面向方面软件开发的关注点建模 299

21.4　为什么需要关注点建模 300

21.3　关注点的一种视点 300

21.2　什么是关注点 300

21.4.3　AOSD的支持 301

21.4.2　对传统开发任务的增强 301

21.4.1 对贯穿于开发生命周期和构件之中的关注点描述和分析 301

21.5.1　关注点建模模式的需求 302

21.5　作为头等事务的关注点建模 302

21.5.2　处理考虑 303

21.6　COSMOS：一种关注点空间建模模式 304

21.7　关注点模型示例 305

21.8.1　传统的（非面向方面）建模 307

21.8　相关工作 307

21.8.2　面向方面建模 309

21.9.1　关注点概念的形式化表示 310

21.9　附加的讨论 310

21.10　结论 311

21.9.2 对AOSD贡献的本质 311

参考文献 312

致谢 312

第22章 关注点描述工具的设计建议 316

22.1.1　AspectBrowser 317

22.1　工具的研究 317

22.1.3　FEAT 318

22.1.2 AMT 318

22.2　研究形式 320

22.2.3　AspectBrowser示例 321

22.2.2　AMT示例 321

22.2.1　Jex示例 321

22.3.1　使用的策略 322

22.3　数据 322

22.3.2　标识出的关注点代码 323

22.4.2　关注点刻画 325

22.4.1　工具设计建议 325

22.4　结果 325

22.5　相关工作 326

22.4.3　研究工作的有效性 326

22.5.2　特征定位方法 327

22.5.1　关于程序修改任务的研究 327

参考文献 328

致谢 328

22.5.3　影响分析方法 328

22.6　结论 328

第23章 面向方面编程的初始评估 331

23.2　实验 332

23.1　AspectJ 332

23.2.1　通用的形式 333

23.2.3　形式 334

23.2.2　实验1：调试的易用性 334

23.2.4　结果 335

23.2.5　实验2：修改的容易性 336

23.3.1　方面内核接口事宜 338

23.3　从组合分析中获知的理解 338

23.4　实验评价 340

23.3.2　方面可能替换任务策略 340

23.6　总结 341

23.5　相关工作 341

本章附录 342

致谢 342

参考文献 344

24.1.1　依赖关系 346

24.1　依赖关系管理的原则 346

第24章 面向方面的依赖关系管理 346

24.1.3　原理 347

24.1.2　依赖关系的强度 347

24.2.1　超越指针概念 348

24.2　作为通用原则的间接性：从指针到设计模式及更多 348

24.2.3　设计模式和间接层 349

24.2.2　面向对象间接层 349

24.3　对于设计模式的面向方面的替代者 350

24.2.4　面向方面间接层 350

24.3.1　访问者模式 351

24.3.2　观察者模式 352

24.3.3　扩展对象模式 355

24.3.4　虚拟的构建 357

24.4.2　面向方面间接层 361

24.4.1　面向对象间接层 361

24.4 面向方面依赖关系管理的指导方针 361

24.5　从面向方面依赖关系管理中得到的建模益处 362

24.4.3　组合面向对象和面向方面间接层 362

参考文献 364

25.1　引言 366

第25章 应用方面开发软件组件：某些问题和经验 366

25.2　动机 367

25.4　采用方面的组件描述和设计 368

25.3　我们的方法 368

25.5　采用方面的组件实现 370

25.6　在运行时使用方面 372

25.7　相关工作 373

25.9　未来的研究方向 375

25.8　评估 375

参考文献 376

25.10　结论 376

26.1　知识驱动的编织 379

第26章 智能编织器：一种针对方面组合的知识驱动方法 379

26.1.2　在Smartbooks中的编程任务 380

26.1.1　Smartbooks归档方法 380

26.1.3　Smartbooks的引擎 381

26.2　一个工作流应用示例 382

26.3.2　与任务管理器的交互 383

26.3.1 目标应用的设计 383

26.3　应用智能编织器：开发者的视点 383

26.4　定义编织知识：设计者视点 385

26.4.2　加入编织信息 386

26.4.1　支持技术的归档卷册 386

26.4.3　方面需求的内部表示 388

26.5　相关工作 390

26.6　结论 391

参考文献 392

第三部分　应用管理C3 395

章节 396

管理不知觉性 396

管理多量化 396

27.2　应用层次安全性领域 398

27.1 引言 398

第27章 通过面向方面编程开发安全应用 398

27.3.1　一个个人的信息管理系统 399

27.3　一份实验报告 399

27.3.3　朝向一个方面框架 402

27.3.2 一个FTP服务器 402

27.4.1　正面的经验 403

27.4　讨论 403

27.4.2　AOP环境的需求 404

27.5　相关工作 405

参考文献 406

致谢 406

27.6　结论 406

28.1　AspectC 409

第28章 结构化操作系统方面 409

28.1.2　切入点声明 410

28.1.1　使用AspectC的标准行为预取 410

参考文献 412

28.2　结论 412

28.1.3　通知声明 412

28.1.4　实现比较 412

29.2　在面向对象数据库系统中横切关注点 414

29.1 引言 414

第29章 数据库系统的面向方面编程 414

29.2.1　在DBMS层次横切关注点 415

29.2.2　在数据库层次的横切关注点 417

29.3 面向对象数据库系统中的AOP 418

29.3.1　DBMS层次的方面 419

29.3.2　数据库层次的方面 422

29.4　面向方面方法的评价 423

29.6　结束语 425

29.5　模块化数据库中的横切关注点的其他方法 425

参考文献 426

第30章 两层次方面编织，以支持模型驱动合成中的演化 429

30.1.1　模型集成计算 430

30.1　模型集成计算和AOSD 430

30.1.2　在领域建模中横切关注点 432

30.1.3　模型编织器 433

30.2.1　在GME中建模Bold Stroke组件 435

30.2　例子：饥饿／懒惰评测约束条件的模型编织 435

30.2.2　饥饿／懒惰评估的策略 437

30.3　从领域专有模型中产生方面代码 439

30.4.2　相关工作 443

30.4.1　未来工作 443

30.4　结论 443

参考文献 444

致谢 444

31.2　应用场景 448

31.1　引言 448

第31章 动态面向方面的基础架构 448

31.3　使用面向方面的应用感知 450

31.4.1　在PROSE中处理应用感知 452

31.4　使用PROSE满足应用感知的需求 452

31.4.2　PROSE体系结构 453

31.6.1 为机器人技术实现的位置专有功能 455

31.6 在应用感知中的AOP的使用示例 455

31.5　在节点群中编织方面 455

31.5.1　方面的分布 455

31.5.2　方面的生命周期 455

31.5.3　软件体系结构问题 455

31.7　结论 457

31.6.2　其他应用感知的例子 457

参考文献 458

致谢 458