精华内容
下载资源
问答
  • 软件体系结构
    千次阅读
    2022-02-24 11:22:45

    绪论与杂谈

    1.软件危机

    软件危机是指计算机软件开发和维护过程中遇到的一系列严重问题。包括两方面的问题:
    (1)如何开发软件以满足日趋复杂的需求
    (2)如何维护数量不断膨胀的软件产品


    2.软件工程

    (1)将系统化的、规范化的可量化的方法应用于软件的开发运行和维护,即将工程应用于软件
    (2)对(1)中所述方法的研究

    (1)软件质量

    • SE的目标是软件质量(运行时质量、非运行时质量、体系结构质量)
    • 影响质量的因素:
      功能、正确、性能、安全、鲁棒性、可信性、健壮性、易用性、适应性、移植性、重用性、集成性、可测性、兼容性、经济效益

    (2)软件的非功能特性

    • 可变性:包括可维护性、可扩展性、可重构性、可移植性
    • 互操作性:不同系统之间相互操作
    • 效率:资源占用、响应时间
    • 可靠性:分为容错性和健壮性,容错性指在发生错误时可以确保正确的系统响应。健壮性不要求错误发生时能够继续运行,而是保证软件能以明确的可接受的方式终止。
    • 可测试性
    • 可重用性:重用其他构件,以及提供给其他构件使用



    3.软件工程的发展阶段

    传统软件工程、面向对象的软件工程、构件软件工程、面向服务的软件工程

    4.软件工程的基本方法

    复用、分而治之、优化折中


    SA对SE的贡献
    1. 开发团队的组织结构
    2. 需求获取
    3. 设计方案的选择
    4. 分析和描述复杂系统的高层属性
    5. 人员交流
    6. 技术进步

    软件设计

    当前的软件设计

    (1)体系结构的设计选择对软件的长远成功是至关重要的
    (2)体系结构描述具有不规范性
    (3)软件体系结构理论和工具是解决软件复杂性和工程设计的必由之路

    软件设计的层次_​_

    • 结构级
    • 代码级
    • 执行级
    软件设计目标

    在时间和各类资源限制下,最大程度地满足用户需求。

    1. 便于维护和升级,因此应该是模块化的
    2. 设计应该是便于移植的(移植比重新设计花费要小很多)
    3. 设计具有适应性
    4. 设计过程应该收到理性的控制
    5. 设计应该表现出概念的完整性
    软件设计中出现的问题
    1. 对于需求变化缺乏配合
    2. 过程控制对于维持软件设计的正确性缺乏保证
    3. 软件产品缺乏概念完整性

    软件体系结构的基本概念

    软件体系结构

    (1)定义

    • 软件体系结构定义了软件的局部与总体计算部件的构成,以及他们之间的相互关系。
    • 总的来说,软件体系结构是由结构和功能各异、相互作用的部件集合,按照层次构成的。
    • 体系结构=部件 + 连接件 + 约束
    • 体系的核心模型由5种元素组成:构建、连接体、配置、端口和角色
    (2)体系结构的类别
    • 概略型
    • 需求型
    • 设计型

    理解软件体系结构

    软件体系结构(Software Architecture)包括构成系统的设计元素的描述、 设计元素
    之间的交互、 设计元素的组合模式以及在这些模式中的约束。


    元素以及元素的分类 素分为了两大类:构件 & 连接件
    元素的组合模式,及模式中的约束


    简而言之**,软件体系结构 = 构件 + 连接件 + 约束 **

    构件与连接件

    构件
    构件是具有某种功能的可复用的软件结构单元,表示系统中主要的计算元素 数据存储
    构件是一个抽象的概念,在程序中可以指程序函数、模块、对象、类等。
    连接件
    连接是构件间建立和维护行为关联与信息传递的途径。连接包含下面两种要素:
    其中,机制指的实际中的
    消息传递方式

    而协议则决定了 消息的语义理解
    ![image.png](https://img-blog.csdnimg.cn/img_convert/94340ee1d8266c22669646a3ee478813.png#clientId=u2d9c7292-1417-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=234&id=ua7af18dc&margin=[object Object]&name=image.png&originHeight=294&originWidth=696&originalType=binary&ratio=1&rotation=0&showTitle=false&size=183742&status=done&style=none&taskId=uab0d571d-4dbb-4d07-9462-9842600a9c4&title=&width=554)
    ![image.png](https://img-blog.csdnimg.cn/img_convert/34491feec9983b86f6b1c3008e69339d.png#clientId=u2d9c7292-1417-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=201&id=u8817de60&margin=[object Object]&name=image.png&originHeight=221&originWidth=697&originalType=binary&ratio=1&rotation=0&showTitle=false&size=132330&status=done&style=none&taskId=u5529e448-6455-4d7a-b4f2-7da2208dbc7&title=&width=632.5)


    当前对软件体系结构的认识

    软件体系结构的知识体系

    • 软件的体系结构应该是一个关于软件构成方面的具有层次性的知识体系
    • 软件硬件层、基础控制描述层、资源和管理调度层、系统结构模式层、领域应用层

    软件结构与软件工程

    • 实现体系结构指导下的软件工程设计,关键在于建立软件构件的分析和构造的方法
    • 软件复用是技术的范畴
    • 软件体系结构风格为大粒度的软件重用提供机会。

    软件体系结构的认识

    • 体系结构是关于软件的系统级层次上的组成和行为的,是设计过程中不可缺少的一个阶段,对复杂软件的后期设计活动起着重要决定作用。
    • 体系结构是由软部件和部件之间的联系组成,软部件又有自身的体系结构。
    • 部件描述有3个方面:计算功能、结构特性、其他特性。
    • 目前,没有哪个关于软件体系结构的描述可以说是完整的。关于什么是部件,什么是部件之间的联系并没和明确的界定。



    软件体系结构的意义和目标

    软件体系结构在软件开发中的意义

    1. 软件体系结构是软件开发过程初期的产品,对于开发进度和软件质量的一切资金和劳务投入,可以获得最好的回报。
    2. 体系结构设计是形成的投资高汇报的重要因素。
    3. 正确有效的体系结构设计会给软件开发带来极大的便利。
    软件体系结构的目标
    • 外向目标:建立满足终端用户要求的系统需求。
    • 内向目标:建立满足后期设计者需要以及易于系统实现、维护和扩展的系统部件构成


    所有的设计原则等理论基本上都可以映射到下面一个或几个目标上。
    ![image.png](https://img-blog.csdnimg.cn/img_convert/f96a995f1b834349d7d12130a564fd35.png#clientId=u2d9c7292-1417-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=259&id=u8fe83c9d&margin=[object Object]&name=image.png&originHeight=511&originWidth=949&originalType=url&ratio=1&rotation=0&showTitle=false&size=396997&status=done&style=none&taskId=ub642777b-a494-421b-8f48-34738975a17&title=&width=481)

    体系结构的发展

    ![image.png](https://img-blog.csdnimg.cn/img_convert/2ba8de6277094eea1e060b5683e5e30e.png#clientId=u2d9c7292-1417-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=235&id=u32b19423&margin=[object Object]&name=image.png&originHeight=336&originWidth=720&originalType=url&ratio=1&rotation=0&showTitle=false&size=171809&status=done&style=none&taskId=u49803d55-9123-419f-92e7-fccb7f5099a&title=&width=504)

    软件体系机构的研究范畴

    1. 软件体系结构描述语言和工具(ADL)
    2. 产品线和标准:企业 -> 需求 -> 架构 -> 系统
    3. 软件体系结构风格以及风格的应用
    4. 体系结构文档化

    体系结构的基础和层次特性

    构造软件同样需要基础。
    计算机硬件结构、软件的基本组成、构成软件的可用组块三个方面。

    软件体系结构的层次结构模型

    (1)任何软件的完整结构都具有层次关系:
    • 特定的软件需要特定的硬件环境运行
    • 不存在不需要下层支持的抽象的上层结构或框架
    • 层次性是软件体系结构的不变性质,是软件构成的共同规律
    (2)软件体系结构的层次结构模型(6层):

    ![image.png](https://img-blog.csdnimg.cn/img_convert/3f25e3866f3214aa9fb6dc11d69ef8b0.png#clientId=u2d9c7292-1417-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=232&id=ua1a1795b&margin=[object Object]&name=image.png&originHeight=362&originWidth=408&originalType=url&ratio=1&rotation=0&showTitle=false&size=77248&status=done&style=none&taskId=uca97a7a6-07af-48c3-8eb2-19306a6461f&title=&width=261)

    从层次模型看软件体系结构

    • 数据库、网络、存储器,JavaEE、Spring ,etc.
    • 层次模型对软件体系结构的认识:
      • 体系结构是关于软件的构成部件及其连接的分层的结构框架
      • 体系结构包括软件的内在概念和外在操作结构
      • 体系结构分析与设计涵盖并指导着从逻辑结构设计到运行实现的软件工程的全部过程

    软件体系结构集成环境

    目标:
    • 能够描述各种风格的软件系统结构
    • 支持自顶向下(自下而上)的分层细化体系结构元素
    • 确保接口一致
    • 提供一个体系结构知识库存放与体系结构设计相关的设计模式、设计要素、设计需求
    • 具有一个提供数据和控制模型代码的模板生成器
    • 提供体系结构的图形化描述工具,从不同的视角反映体系结构
    元素:
    • 体系结构配置文档编辑器
    • 体系结构配置图形编辑器
    • 体系结构视图:文本视图、交互视图、层次视图
    • 体系结构语法分析器
    • 代码模板生成器

    (1)UniCon

    体系结构描述语言和环境。
    UnicCon是基于部件和连接器的

    (2)Wright

    可以描述体系结构的风格、系统族、体系结构实例和单个系统
    Wright体系结构描述语言基于交互

    (3)Darwin

    构件说明定义了可以创建一个或多个实例的构件类型
    Darwin系统的设计验证工具为设计人员提供了一种“What-If”的测试机制。

    (4)ACME
    • 采用图形化编辑方式直接描述构件和连接件

    软件体系结构的设计原理+体系结构的一般描述

    1.体系结构设计中遵循的原理

    • 抽象:数据抽象、实体抽象、行为抽象、过程抽象、对象抽象、虚拟机抽象
    • 封装:将抽象的属性和行为结合一起,隔离不同的抽象。
    • 数据隐藏:对用户隐藏部件的实现细节。
    • 模块化:代码结构物理分块
    • 关注点分离:不同和无关联的责任应该在软件系统中分离开来,让他们出现在不同的部件中相互协作。
    • 内聚和耦合
    • 充分性、完备性、原始性:
      充分性是指部件应该把握住与其进行有意义和高效交互抽象的所有特性;
      完整性是指一个部件应该把握住所有与其抽象相关的特性;
      原始性是指部件应该完成的操作都可以容易地得到实现(人的价值是最大的);
    • 策略和实现分离:策略部件负责处理上下文决策、参数选择等,实现部分专注算法的实现。
    • 接口和实现分离:接口规范功能的使用方法,实现部分提供功能的具体方法。
    • 分而治之:将复杂的问题分解为若干个小问题,自上而下的分析,自下而上的实现
    • 层次化



    2.通用的一般的描述方法

    (1)主程序与子程序

    • 这是软件设计最直接、最基本的结构关系。
    • 更复杂的设计包含了库、包、模块、程序覆盖等概念。
    • 主程序与子程序优点:
      1. 是一切软件结构的最本质、最基础的形式
      2. 代码的效率可以得到最大限度的发挥和提高

    (2)数据抽象和面向对象

    • 数据抽象和面向对象设计是在主程序和子过程设计基础上建立和发展起来的重要的软件描述方法。

    • 数据抽象是面向对象设计的理论基础

    • 类和对象是该描述方法的基础粒度,而非模块或者包。

    • 本质上没有逃出主子程序的思想

    • 面向对象的优点

       信息隐藏保证了对象行为的可靠性<br />       系统更容易分解成相互作用又相互独立的对象集合<br />       为系统的维护和升级提供了良好的条件。<br />**       **继承性和封装性提高了复用的可能性和方便性。
      

    (3)层次结构

    • 层次化是一种复杂系统设计的带普遍性的设计原则。

    ** 层次结构的优点**

    1. 层次的复用性
    2. 对标准化的支持,允许在不同层使用来自不同商家的产品
    3. 依赖本地化,层次间的标准接口通常把代码变化的影响限制在其所在的层次之内,这样做便于支持系统的可移植性和可测试性
    4. 可替换性,独立层次的实现能够被功能相同的模块替换。(例如,硬件的可替换性)享用互操作性好处的代价是增加了程序开销。

    ** 层次结构的缺点**

    1. 改变行为的连锁效应。例如,在维护升级时,必须在许多层次上做大量的工作。
    2. 低效率。分层结构通常比单一层次的结构效率更低。例如,通信协议在从高层传送信息时需要增加信息头和尾。
    3. 包含过多不必要的工作。如果低层次执行某些高层次并不需要的重复的工作,对于软件的整体性能就有消极的影响。高层请求通常会导致多次对低层次的同样的请求,层次数太多还会在层次间传送变量和返回值时带来额外的开销。



    理论的形式化方法(体系结构的描述)

    • 形式化的定义:用于计算机系统的形式化方法是描述系统性质的基于数学的技术
    • 如果一个方法有良好的数学基础,那么它就是形式化的。
    • 规约方法的目标:无二性、一致性、完整性

    (1)体系结构描述语言

    • ADL建立在形式化的理论基础之上
    • ADL的功能:能够描述体系结构的组成要素,并能对系统体系结构、体系结构风格进行建模和分析验证的描述语言。
    • ADL分类:
    • 描述软件体系结构配置的ADL:CHAM
    • 描述软件体系结构实例的ADL:Rapide
    • 描述软件体系结构风格的ADL:Wright
    • ADL的目标:
    1. 精确的语义描述
    2. 支持分析推理

    (2)类属理论

    是一种表达对象关系的数学语言:

    1. 提供了概念划分的统一性
      • 类属是由一个对象集合和一个关联两个对象的箭头集合构成的。
      • 对象是以某种逻辑表达的形式规范,箭头定义了这些规范之间的关系。
    2. 软件研究者把他看成是表达抽象和依赖关系的工具
    3. 在体系结构的部件和连接器描述中都被广泛采用

    (3)Z Notation

    Z Notation使用标准的逻辑操作符和集合操作符以及他们标准的常规语义

    (4)CSP(通信顺序进程)

    (5)化学抽象机制CHAM

    体系结构设计风格

    设计模式

    • 体系结构的设计模式是构成负责软件的基础和常用单元,解决的是软件的底层或接近底层的结构问题。
    • 设计模式使人们可以更加简单方便地复用成功的设计和体系结构,帮助设计者更好更快地完成系统设计。

    常见风格分类

    1. 数据流风格:批处理和管道/过滤器。
    2. 调用/返回风格:主程序/子程序、层次结构和C/S。
    3. 面向对象风格。
    4. 独立部件风格:进程通信和事件驱动。
    5. 虚拟机风格:解释器和基于规则的系统。
    6. 数据共享风格:数据库系统和黑板系统。



    1.管道/过滤器 体系结构风格

    主要包括过滤器和管道两种元素。在这种结构中,构件被称为过滤器,负责对数据进行加工处理。每个过滤器都有一组输入端口和输出端口,从输入端口接收数据,经过内部加工处理之后,传送到输出端口上。数据通过相邻过滤器之间的连接件进行传输,连接件可以看作输入数据流和输出数据流之间的通路,这就是管道。
    ![image.png](https://img-blog.csdnimg.cn/img_convert/001539064c00c15a4d739546a35d50f3.png#clientId=u2d9c7292-1417-4&crop=0&crop=0&crop=1&crop=1&from=paste&id=u248ac0b6&margin=[object Object]&name=image.png&originHeight=187&originWidth=655&originalType=url&ratio=1&rotation=0&showTitle=false&size=21135&status=done&style=none&taskId=u7ed3037c-298a-4015-bb63-bbc2b3f9963&title=)
    优点:
    简单性。
    支持复用。
    系统具有可扩展性和可进化型。
    系统并发性(每个过滤器可以独立运行,不同子任务可以并行执行,提高效率)。
    便于系统分析。
    缺点:
    系统处理工程是批处理方式。
    不适合用来设计交互式应用系统。
    由于没有通用的数据传输标准,因此每个过滤器都需要解析输入数据和合成数据。
    难以进行错误处理。

    _传统的编译器就是管道/过滤器体系结构风格的一个实例。_编译器由词法分析、语法分析、语义分析、中间代码生成、中间代码优化和目标代码生成几个模块组成,一个模块的输出是另一个模块的输入。源程序经过各个模块的独立处理之后,最终将产生目标程序。

    2.面向对象 体系结构风格

    在面向对象体系结构中,软件工程的模块化、信息隐藏、抽象和重用原则得到了充分的体现。在这种体系结构中,数据表示和相关原语操作都被封装在抽象数据类型中。在这种风格中,对象是构件,也成为抽象数据类型的实例。对象与对象之间,通过函数调用和过程调用来进行交互。
    ![image.png](https://img-blog.csdnimg.cn/img_convert/2b741e46c94daf9612b7ed0d8e03e124.png#clientId=u2d9c7292-1417-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=250&id=ub9abd5e1&margin=[object Object]&name=image.png&originHeight=266&originWidth=451&originalType=url&ratio=1&rotation=0&showTitle=false&size=30542&status=done&style=none&taskId=u4ac597e7-55a4-46b3-995b-300b70e5b20&title=&width=424)
    优点:

    1. 一个对象对外隐藏了自己的详细信息
    2. 对象将数据和操作封装在一起
    3. 继承和封装方法为对象服用提供了技术支持

    缺点:

    1. 如果一个对象要调用另一个对象,则必须知道它的标识和名称
    2. 会产生连锁反应

    3.事件驱动 体系结构风格

    事件驱动就是在当前系统的基础之上,根据事件声明和发展状况来驱动整个应用程序运行。
    事件驱动体系结构的基本思想是:系统对外部的行为表现可以通过它对事件的处理来实现。在这种体系结构中,构件不再直接调用过程,而是声明事件。系统其他构件的过程可以在这些事件中进行注册。当触发一个事件的时候,系统会自动调用这个事件中注册的所有过程。因此,触发一个事件会引起其他构件的过程调用。
    ![image.png](https://img-blog.csdnimg.cn/img_convert/7dc83c8cd1b1060f6ab0155465ef8d41.png#clientId=u2d9c7292-1417-4&crop=0&crop=0&crop=1&crop=1&from=paste&id=uf0192c1f&margin=[object Object]&name=image.png&originHeight=122&originWidth=370&originalType=url&ratio=1&rotation=0&showTitle=false&size=9274&status=done&style=none&taskId=uf14b145c-38e1-4ca9-81e1-211b9ff97a4&title=)
    优点:

    1. 事件声明者不需要知道哪些构件会响应事
    2. 提高了软件复用能力
    3. 便于系统升级

    缺点:

    1. 构件放弃了对计算的控制权,完全由系统来决定
    2. 存在数据·传输问题

    4.分层 体系结构风格

    在分层风格中,系统将划分为一个层次结构。
    每一层都具有高度的内聚性,包含抽象程度一致的各种构件,支持信息隐藏。
    分层有助于将复杂系统划分为独立的模块,从而简化程序的设计和实现。
    通过分解,可以将系统功能划分为一些具有明确定义的层,较高层是面对特定问题,较低层具有一般性。
    每层都为上层提供服务,同时又利用了下层的逻辑功能。在分层体系结构中,每一层只对相邻层可见。层次之间的连接件是协议和过程调用。用以实现各层之间的交互。
    ![image.png](https://img-blog.csdnimg.cn/img_convert/3e91d31e9e91d5dc4579cd885e01068e.png#clientId=u2d9c7292-1417-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=269&id=ua52f9214&margin=[object Object]&name=image.png&originHeight=478&originWidth=471&originalType=url&ratio=1&rotation=0&showTitle=false&size=43505&status=done&style=none&taskId=ub9a94a24-922d-4892-8dc5-29a8cbf1bea&title=&width=265)![image.png](https://img-blog.csdnimg.cn/img_convert/16e702c9d92882ecb509cf74e4968cfa.png#clientId=u2d9c7292-1417-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=226&id=CGpbf&margin=[object Object]&name=image.png&originHeight=424&originWidth=641&originalType=url&ratio=1&rotation=0&showTitle=false&size=307469&status=done&style=none&taskId=ua06b0a1a-3c3b-47c7-aa26-86ef9552fbe&title=&width=342)
    优点:
    设计者可以将系统分解为一个增量的步骤序列从而完成复杂的业务逻辑。
    每一层之多和相邻的上下两层进行交互。
    只要给相邻层提供相同的接口。
    缺点:
    并非所有系统都能够按照层次来进行划分。
    很难找到一种合适和正确的层次划分方法。
    在传输数据是,需要经过多个层次。
    多层结构难以调试。


    5.C2 体系结构风格

    C2结构是一个层次网络,包括构件和连接件两种软件元素。构件和连接键都是包含顶部和底部的软件元素。构件和构件之间只能通过连接件进行连接,而连接件之间则可以直接进行连接。构件的顶部、底部分别与连接件的底部、顶部连接,连接件的顶部、底部也分别与连接件的底部、顶部连接。
    在C2体系结构中,构件之间的所有通信必须使用消息传递机制来实现。构件之间所有传递的信息可以分为两种,一种是向上层构件发出服务请求的请求消息,另一种是向下层构件发出指示状态变化的通知消息。连接件负责消息的过滤、路由、广播、通信和相关处理。
    ![image.png](https://img-blog.csdnimg.cn/img_convert/3905dfe4947a3b4644a42f1c8ed1ec35.png#clientId=u2d9c7292-1417-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=264&id=ube127902&margin=[object Object]&name=image.png&originHeight=336&originWidth=629&originalType=url&ratio=1&rotation=0&showTitle=false&size=36244&status=done&style=none&taskId=uf49ccffd-7a8f-473f-a9e2-049e77cb24b&title=&width=494)
    优点:
    可以使用任何编程语言来开发构件,构件重用和替换比较容易实现
    具有一定的扩展能力,可以有多种不同粒度的构件
    构件不需要共享地址空间,避免了共享全局变量所造成的复杂关系
    具有良好的适应性
    在C2体系结构中,可以使用多个工具集和多种媒体类型,能够动态地更新系统的框架结构
    缺点:
    构件和构件之间不允许直接相连
    与某一个连接件相关联的构件和连接件的数目没有限制


    6.数据共享 体系结构风格

    数据共享风格也成为仓库风格。
    在这种风格中,有两种不同类型的软件元素:一种是中央数据单元,也成为资源库,用于表示系统的当前状态;另一种是相互依赖的构件组,这些构件可以对中央数据单元实施操作。中央数据单元和构件之间可以进行信息交换,这是数据共享体系结构的技术实现基础。
    根据所使用的控制策略不同,数据共享体系结构可以分为两种类型,一种是传统的数据库,另一种是黑板。
    如果由输入流中的事件来驱动系统进行信息处理,把执行结构存储到中央数据单元,则这个系统就是数据库应用系统。
    如果由中央数据单元的当前状态来驱动系统运行,则这个系统就是黑板应用系统。
    黑板是数据共享体系结构的一个特例,用以解决状态冲突并处理可能存在的不确定性知识源。
    黑板常用于信号处理,如语音和模式识别,同时在自然语言处理领域中也有广泛的应用,如机器翻译和句法分析
    ![image.png](https://img-blog.csdnimg.cn/img_convert/bdd3520293d29a9106de7ce14726545b.png#clientId=u2d9c7292-1417-4&crop=0&crop=0&crop=1&crop=1&from=paste&id=uf426999f&margin=[object Object]&name=image.png&originHeight=295&originWidth=438&originalType=url&ratio=1&rotation=0&showTitle=false&size=35834&status=done&style=none&taskId=u10a192c5-599b-4888-9a77-6ff050457af&title=)
    优点:

    1. 便于多客户共享大量数据,而不必关心数据是何时产生的、由谁提供的及通过何种途径来提供
    2. 便于将构件作为知识源添加到系统中来

    缺点:

    1. 对共享数据结构,不同知识源要达成一致
    2. 需要同步机制和加锁机制来保证数据的完整性和一致性,增大了系统设计的复杂度



    7.解释器 体系结构风格

    解释器作为一种体系结构,主要用于构建虚拟机,用以弥合程序语义和计算机硬件之间的间隙。实际上,解释器是利用软件来创建的一种虚拟机,因此,解释器风格又被称为虚拟机风格。
    ![image.png](https://img-blog.csdnimg.cn/img_convert/ec186e758c23a3e08e77826a4d65ce7d.png#clientId=u2d9c7292-1417-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=282&id=u2d652284&margin=[object Object]&name=image.png&originHeight=323&originWidth=608&originalType=url&ratio=1&rotation=0&showTitle=false&size=39948&status=done&style=none&taskId=u3f819905-71bf-41be-bf3a-b2d25abde8e&title=&width=531)
    优点:

    1. 能够提高应用程序的抑制能力和变成语言的跨平台移植能力。
    2. 实际测试工作可能费城复杂,测试代价极其昂贵,具有一定的风险性。

    缺点:

    1. 由于使用了特定了语言和自定义操作规则,因此增加了系统运行的开销。
    2. 解释器系统难以设计和测试。



    8.C/S 体系结构风格


    ![image.png](https://img-blog.csdnimg.cn/img_convert/d984fad460ff4480fb789b56b9c94d28.png#clientId=u2d9c7292-1417-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=253&id=u87e64fe6&margin=[object Object]&name=image.png&originHeight=378&originWidth=461&originalType=url&ratio=1&rotation=0&showTitle=false&size=51842&status=done&style=none&taskId=ub55c1001-0d88-4c9b-b5c9-0c6cf9f27c6&title=&width=308)![image.png](https://img-blog.csdnimg.cn/img_convert/61e7d45de929365e62edb3fd778ac66c.png#clientId=u2d9c7292-1417-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=246&id=lxKIM&margin=[object Object]&name=image.png&originHeight=318&originWidth=492&originalType=url&ratio=1&rotation=0&showTitle=false&size=46259&status=done&style=none&taskId=u820b3e0f-31eb-4365-9ae5-80ffcf610f5&title=&width=381)
    优点:
    客户机构件和服务器构件分别运行在不同的计算机上,有利于分布式数据的组织和处理。
    构件之间的位置是相互透明的,客户机程序和服务器程序都不必考虑对方的实际存储位置。
    客户机侧重数据的显示和分析,服务器则注重数据的管理。
    构件之间是彼此独立和充分隔离的。
    将大规模的业务逻辑分布到多个通过网络连接的低成本的计算机,降低了系统的整体开销。
    缺点:
    开发成本较高。
    在开发C/S结构系统时,大部分工作都都集中在客户机程序的设计上,增加了设计的复杂度。
    信息内容和形式单一。
    如果对C/S体系结构的系统进行升级,开发人员需要到现场来更新客户机程序,同时需要对运行环境进行重新配置,增加了维护费用。
    两层C/S结构采用了单一的服务器,同时以局域网为中心,因此难以扩展到Intranet和Internet。
    数据安全性不高。


    9.B/S 体系结构风格

    B/S结构是三层C/S体系结构的一种实现方式,主要包括浏览器,Web服务器和数据库服务器。B/S结构主要利用不断成熟的WWW技术,结合浏览器的多脚本语言,采用通用浏览器来实现原来需要复杂的专用软件才能实现的强大功能,节约了开发成本。
    当用户运行某个应用程序时,只需要在可以断的浏览器中输入响应的 URL,向 Web 服务器提出 HTTP 请求。
    当Web 服务器接收 HTTP 请求之后,会调用相关的应用程序(Servlets),同时向数据库服务器发送数据操作请求。
    数据库服务器对数据操作请求进行响应,将结果返回给Web服务器的应用程序。
    ![image.png](https://img-blog.csdnimg.cn/img_convert/f0aad1c3475a7af18d49570d16ae9440.png#clientId=u2d9c7292-1417-4&crop=0&crop=0&crop=1&crop=1&from=paste&id=uad35dfed&margin=[object Object]&name=image.png&originHeight=243&originWidth=304&originalType=url&ratio=1&rotation=0&showTitle=false&size=23886&status=done&style=none&taskId=u39eb66b8-8d69-4ad7-a4f7-328c78e0866&title=)
    优点:
    客户端只需要安装浏览器,操作简单。
    运用HTTP标准协议和统一客户端软件,能够实现跨平台通信。
    开发成本比较低,只需要维护Web服务器程序和中心数据库。
    缺点:
    个性化程度比较低,所有客户端程序的功能都是一样的。
    客户端数据处理能力比较差。
    在B/S结构的系统中,数据提交一般以页面为单位,动态交互性不强,不利于在线事务处理。
    B/S体系结构的可扩展性比较差,系统安全性难以保障。
    B/S结构的应用系统查询中心数据库,其速度要远低于C/S体系结构。


    10.公共对象请求代理(CORBA)体系结构风格

    公共对象请求代理(Common Object Request Broker Architecture,CORBA)是由对象管理组织(Object Management Group,OMG)提出来的,是一套完整的对象技术规范,其核心包括标准语言、接口和协议。

    在异构分布式环境下,可以利用CORBA来实现应用程序之间的交互操作,同时,CORBA也提供了独立于开发平台的编程语言的对象重用方法。
    ![image.png](https://img-blog.csdnimg.cn/img_convert/95d2fdb0906e6af288e8cbcbc36f385a.png#clientId=u2d9c7292-1417-4&crop=0&crop=0&crop=1&crop=1&from=paste&id=u15387c7b&margin=[object Object]&name=image.png&originHeight=229&originWidth=484&originalType=url&ratio=1&rotation=0&showTitle=false&size=27310&status=done&style=none&taskId=ua864b6b4-0123-4a05-884b-ae58d3d84c3&title=)
    优点:

    1. 实现了客户端程序与服务器程序的分析。
    2. 将分布式计算模式与面向对象技术结合起来,提高了软件复用率。
    3. 提供了软件总线机制,软件总线是指一组定义的完整的接口规范。
    4. CORBA能够支持不同的编程语言和操作系统,在更大的范围内,开发人员能够相互利用已有的开发成果。

    缺点:



    11.正交 体系结构风格

    正交体系结构是一种以 垂直线索构件族 为基础的层次化结构,包括组织层和线索。
    在每一个组织层中,都包含具有相同抽象级别的构件。
    线索是子系统的实例,是由完成不同层次功能的构件通过相互调用而形成的,每一条线索完成系统的一部分相对独立的功能。
    在正交体系结构中,每条线索的实现与其他线索的实现无关或关联很少。在同一层次中,构件之间不存在相互调用关系。
    ![image.png](https://img-blog.csdnimg.cn/img_convert/1fdeed8c44d83b486c1a4ee2a2c78767.png#clientId=u2d9c7292-1417-4&crop=0&crop=0&crop=1&crop=1&from=paste&id=u46be5500&margin=[object Object]&name=image.png&originHeight=219&originWidth=536&originalType=url&ratio=1&rotation=0&showTitle=false&size=26651&status=done&style=none&taskId=ue09b9028-1898-4551-a465-77f9cda54a4&title=)
    优点:

    1. 结构清晰。
    2. 便于修改和维护。
    3. 易于重用。

    缺点:



    12.MVC 体系结构风格

    模型-视图-控制器(Model-View-Controller,MVC)是一种常见的体系结构风格。MVC被广泛应用与用户交互程序的设计中。![image.png](https://img-blog.csdnimg.cn/img_convert/2e140934cdb9cbf5d4b11408a9620ab6.png#clientId=u2d9c7292-1417-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=396&id=uc2e5b6c2&margin=[object Object]&name=image.png&originHeight=461&originWidth=716&originalType=url&ratio=1&rotation=0&showTitle=false&size=69696&status=done&style=none&taskId=u07c36e59-b01b-48ce-b07d-a953bf73f0c&title=&width=615)
    优点:

    1. 多个视图与一个模型相对应
    2. 具有良好的移植性。
    3. 系统被分割为三个独立的部分,当功能发生变化时,改变其中的一个部分就能够满足要求。

    缺点:

    1. 增加了系统设计和运行复杂性。
    2. 视图与控制器连接过于紧密,妨碍两者的独立复用。
    3. 视图访问模型的效率比较低。



    13.反馈控制环 体系结构风格

    更多相关内容
  • 10个常见软件体系结构模式

    万次阅读 多人点赞 2018-05-07 14:06:04
    根据维基百科,架构模式是在特定环境下软件体系结构常见问题的通用可重用解决方案。架构模式类似于软件设计模式,但具有更广的范围。在本文中,我将简要地解释以下10种常见架构模式及其用法,优缺点。分层模式...

    有没有想过如何设计大型企业级系统? 在开始主要软件开发之前,我们必须选择一个合适的架构来为我们提供所需的功能和质量属性。 因此,在将它们应用于我们的设计之前,我们应该了解不同的体系结构。

    什么是建筑模式?

    根据维基百科,

    架构模式是在特定环境下软件体系结构中常见问题的通用可重用解决方案。 架构模式类似于软件设计模式,但具有更广的范围。

    在本文中,我将简要地解释以下10种常见架构模式及其用法,优缺点。

    1. 分层模式
    2. 客户端 - 服务器模式
    3. 主从模式
    4. 管道过滤器模式
    5. 经纪人模式
    6. 点对点模式
    7. 事件总线模式
    8. 模型 - 视图 - 控制器模式
    9. 黑板模式
    10. 解释器模式

    1.分层模式

    这种模式可以用来构建可以分解为子任务组的程序,每个子任务都处于特定的抽象层次。 每层为下一个更高层提供服务。

    一般信息系统最常见的4层如下。

    • 表示层 (也称为UI层 )
    • 应用程序层 (也称为服务层 )
    • 业务逻辑层 (也称为域层 )
    • 数据访问层 (也称为持久层 )

    用法

    • 一般桌面应用程序
    • 电子商务Web应用程序。
    分层模式

    2.客户端 - 服务器模式

    这种模式由两方组成; 一个服务器和多个客户端 。 服务器组件将向多个客户端组件提供服务。 客户端向服务器请求服务,服务器向这些客户端提供相关服务。 此外,服务器继续侦听客户端请求。

    用法

    • 在线应用程序,如电子邮件,文件共享和银行业务
    客户端 - 服务器模式

    3.主从模式

    这种模式由两方组成; 主人奴隶 。 主组件将工作分配给相同的从组件,并根据从组件返回的结果计算最终结果。

    用法

    • 在数据库复制中,主数据库被视为权威来源,并且从属数据库与其同步。
    • 在计算机系统中连接到总线的外设(主从驱动器)。
    主从模式

    4.管道过滤器模式

    这种模式可以用来构造产生和处理数据流的系统。 每个处理步骤都包含在一个过滤器组件中。 要处理的数据通过管道传递。 这些管道可用于缓冲或同步目的。

    用法

    • 编译器。 连续的过滤器执行词法分析,解析,语义分析和代码生成。
    • 生物信息学工作流程。
    管道过滤器模式

    5.经纪人模式

    这种模式用于构建具有解耦组件的分布式系统。 这些组件可以通过远程服务调用相互交互。 代理组件负责协调组件之间的通信。

    服务器将其功能(服务和特性)发布给代理。 客户向经纪人请求服务,然后经纪人将客户重定向到其注册中心的适当服务。

    用法

    经纪人模式

    6.点对点模式

    在这种模式中,单个组件被称为同级 。 同事可能既作为客户端 ,向其他同行请求服务,又作为服务器向其他同行提供服务。 对等体可以充当客户端或服务器或两者兼而有之,并且可以随着时间动态地改变其角色。

    用法

    点对点模式

    7.事件总线模式

    这种模式主要处理事件,并有四个主要组成部分; 事件源 , 事件监听器 , 通道事件总线 。 信息源将消息发布到事件总线上的特定频道。 听众订阅特定频道。 听众会收到发布到他们之前订阅的频道的消息。

    用法

    • Android开发
    • 通知服务
    事件总线模式

    8.模型 - 视图 - 控制器模式

    这种模式也称为MVC模式,将交互式应用程序分为三部分,

    1. 模型 - 包含核心功能和数据
    2. 视图 - 将信息显示给用户(可以定义多个视图)
    3. 控制器 - 处理来自用户的输入

    这样做是为了将信息的内部表示与信息呈现给用户并从用户接受的方式分开。 它将组件分离并允许有效的代码重用。

    用法

    • 主要编程语言的万维网应用程序体系结构。
    • Web框架,如DjangoRails 。
    模型 - 视图 - 控制器模式

    9.黑板模式

    这种模式对于没有确定性解决策略的问题是有用的。 黑板图案由3个主要组件组成。

    • 黑板 - 包含来自解决方案空间的对象的结构化全局内存
    • 知识源 - 具有自己表示的专用模块
    • 控制组件 - 选择,配置和执行模块。

    所有组件都可以访问黑板。 组件可能产生添加到黑板的新数据对象。 组件在黑板上查找特定类型的数据,并可能通过与现有知识源的模式匹配找到这些数据。

    用法

    • 语音识别
    • 车辆识别和跟踪
    • 蛋白质结构鉴定
    • 声纳信号解释。
    黑板模式

    10.解释器模式

    此模式用于设计解释用专用语言编写的程序的组件。 它主要指定如何评估程序行,称为用特定语言编写的句子或表达式。 基本思想是为语言的每个符号设置一个类。

    用法

    • 数据库查询语言,如SQL。
    • 用于描述通信协议的语言。
    解释器模式

    建筑模式的比较

    下面的表格总结了每种架构模式的优缺点。

    建筑模式的比较

    希望你发现这篇文章有用。

    原文:https://towardsdatascience.com/10-common-software-architectural-patterns-in-a-nutshell-a0b47a1e9013

    展开全文
  • 软件体系结构设计模式的java运行代码案例,包括各种模式的简单代码。 包括使用UML插件刻画类图
  • 下篇:软件体系结构例子代码  【例6.4】结构化设计-文件更新-C源代码  【例6.5】面向对象设计架构-文件更新  【例6.7】顺序批处理架构-文件更新  【例6.8】顺序批处理架构-图像处理  【例6.9】管道过滤器...
  • 软件设计模式体系结构课后习题代码,孙玉山版本
  • 本书展示了如何在解决实际问题的过程中应用COMET(协作式对象建模和体系结构设计方法)这种基于UML的建模和设计方法,介绍了针对各种体系结构的模式,包括客户端/服务器和基于构件的软件体系结构中的客户端/服务模式,...
  • 本资源可以作为《软件设计模式体系结构》的期末复习提纲,需要的朋友可以下载哦!
  • 给出了来自不同应用领域的8个软件体系结构模式;还给出了8个设计模式,这些模式分别针对在定义了软件系统的整体结构之后遇到的典型问题;对惯用法模式进行了阐述;论述了将模式组织成模式系统的重要性;讨论了模式...
  • 第一篇分为8章,介绍了软件体系结构的基础理论,包括软件体系结构的概念及演化、软件建模基础、软件体系结构的形式化、软件体系结构的风格、体系结构的描述语言、软件质量建模、设计模式等内容。第二篇分为4章,首先...
  • 根据上课内容整理的设计模式软件体系结构思维导图
  • 本资源可以作为《软件设计模式体系结构》的复习使用,包含几种常见的设计模式的样例及其代码,需要的朋友可以下载哦!
  • 软件体系结构与设计模式第一章.pdf软件体系结构与设计模式第一章.pdf软件体系结构与设计模式第一章.pdf软件体系结构与设计模式第一章.pdf软件体系结构与设计模式第一章.pdf
  • 软件建模与设计 UML、用例、模式软件体系结构,系统性学习系统开发建模
  • 软件设计模式体系结构孙云山课后习题234章答案+光盘全内容
  • 软件设计模式体系结构的课堂练习的一点小题目的资源
  • 第5章介绍了软件体系结构设计过程中使用的一般原理和设计模式,以及常用的体系结构设计方法;第6章对Bass等人提出的一种基于体系结构的软件开发过程做了详细介绍;第7章介绍了软件体系结构评估方法,重点介绍SAAM和...
  • 设计模式课四次实验源代码,仅供交流学习,不得用于抄袭或者其他用途,eclipse导出类图插件是ModelGoon
  • 学习软件架构的好书籍,千万不要错过,学习软件架构的好书籍,千万不要错过,学习软件架构的好书籍,千万不要错过
  • 面向模式软件体系结构(卷1):模式系统.pdf 个人收集电子书,仅用学习使用,不可用于商业用途,如有版权问题,请联系删除!
  • 软件体系结构2软件体系结构风格与模式918409726.pptx
  • 软件体系结构实验报告(设计模式):包含策略模式,代理模式,观察者模式,外观模式,组合模式,抽象工厂,单例,工厂方法,简单工厂,适配器模式,附有代码实例和类图
  • 软件体系结构与架构五大设计模式

    千次阅读 2019-11-28 20:22:50
    最关键的软件开发工具是受过良好设计原则训练的思维 一、单例模式 Singleton类定义一个个getInstance()操作,允许客户端访问他的唯一实例,getInstance()是一个静态的方法,主要创建自己的一个唯一实例。 比如...

    五大设计模式

    最关键的软件开发工具是受过良好设计原则训练的思维

    一、单例模式

    Singleton类定义一个个getInstance()操作,允许客户端访问他的唯一实例,getInstance()是一个静态的方法,主要创建自己的一个唯一实例。

    比如我们希望整个应用程序只有一个连接数据库connection实例。

    又比如要求一个应用程序中只存在某个用户数据结构的唯一结构。
    某个类只有一个实例,具体的代码实现:

    class ClassicSingleton {
    	private static ClassicSingleton instance;
    	private ClassicSingleton(){
    		//构造方法为“私有”,阻止了外界用new创建本类实例的可能
    	}
    	public static synchronized ClassicSingleton getInstance(){
    		if(instance==null){
    		instance = new ClassicSingleton();
    		//return new ClassicSingleton();  
    		}
    		return instance;
    	}
    }
    
    /**
     * 
     * @author Yue
     * @version 0.1
     *
     */
    public class TestSingleton {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		ClassicSingleton s1 = ClassicSingleton.getInstance();
    		ClassicSingleton s2 = ClassicSingleton.getInstance();
    		System.out.println(s1==s2);//这个是相等的
    	}
    }
    

    二、工厂模式(简单工厂、工厂模式、抽象工厂)

    所有的产品和产品接口组成一个产品群,这个就是“简单工厂”,只有一个工厂。

    工厂和产品最好在一个包里,产品类就可以不是public的,这样只有工厂才可以访问产品,其他不在这个包里就无法直接访问这些产品,起到屏蔽产品类的作用。

    可以看着下面的代码来理解一下简单工厂模式具体代码说明

    //产品接口(如果在接口这个抽象类中需要包含属性数据,则将接口改为抽象类Abstract)
    public interface ProductInterface   {
    	public void method();
    }
    //衣服产品
    public class Clothes implements ProductInterface   {
    	public void method(){
    	
    	}
    }
    //裤子产品
    public class Trousers implements ProductInterface {
    	public void method(){
    	
    	}
    }
    //帽子产品
    public class Cap implements ProductInterface   {
    	public void method(){
    	
    	}
    }
    
    public class Factory {
    	public ProductInterface createProduct(String productname){
    		ProductInterface product = null;
    		if(productname == "clothes"){
    			product = new Clothes();
    		}
    		if(productname == "trousers"){
    			product = new Trousers();
    		}		
    		if(productname == "cap"){
    			product = new Cap();
    		}
    		return product;
    	}
    }
    //要生产哪种产品,需要告诉工厂,即给工厂方法传递一个参数“productname”,
    //工厂方法变为有参数的方法。
    //工厂类不管是生产一种产品还是生产几种产品,都只有一个工厂,这种工厂叫“简单工厂”。
    public class XYZ {  // 客户端代码
    	private ProductInterface product;
    	private Factory factory;
    	public void work(){
    		factory = new Factory();
    		product = factory.createProduct("clothes");
    		product.method();
    	}
    }
    

    这样做的优点:我们可以对创建的对象进行一些 “加工” ,而且客户端并不知道,因为工厂隐藏了这些细节。如果,没有工厂的话,那我们是不是就得自己在客户端上写这些代码,这就好比本来可以在工厂里生产的东西,拿来自己手工制作,不仅麻烦以后还不好维护。

    但是缺点也很明显:如果需要在方法里写很多与对象创建有关的业务代码,而且需要的创建的对象还不少的话,我们要在这个简单工厂类里编写很多个方法,每个方法里都得写很多相应的业务代码,而每次增加子类或者删除子类对象的创建都需要打开这简单工厂类来进行修改。这会导致这个简单工厂类很庞大臃肿、耦合性高,而且增加、删除某个子类对象的创建都需要打开简单工厂类来进行修改代码也违反了开-闭原则。

    这时候就需要工厂模式
    工厂模式实现如下
    1.首先,先定义一个工厂接口

    public interface Factory {
     
        public ProductInterface createProduct() ;
     
    }
    

    2.然后是具体的工厂类

    
    // 衣服类工厂
    public class ClothesFactory implements Factory{
     
        public ProductInterface createProduct() {
            System.out.println("生产衣服");
            return new Clothes();
        }
    }
     
    // 鞋类工厂
    public class ShoeFactory implements Factory{
     
        public ProductInterface createProduct() {
            System.out.println("生产鞋子");
            return new Shoes();
        }
    }
    ........
    

    3.工厂接口与产品的内容与简单一样
    4.客户端

    public class Client {
     
        public static void main(String[] args) throws Exception {
     
            // 使用反射机制实例化工厂对象,因为字符串是可以通过变量改变的
            Factory ClothesFactory = (Factory) Class.forName("org.zero01.factory.ClothesFactory ").newInstance();
            Factory ShoseFactory=(Factory) Class.forName("org.zero01.factory.ShoseFactory").newInstance();
     
            // 通过工厂对象创建相应的实例对象
            ProductInterface clothes= ClothesFactory .createProduct();
            ProductInterface shoes= ShoseFactory.createProduct();
     
            System.out.println(clothes.methods());
            System.out.println(shoes.methods());
        }
    }
    

    工厂模式中,要增加产品类时也要相应地增加工厂类,客户端的代码也增加了不少。工厂方法把简单工厂的内部逻辑判断转移到了客户端代码来进行。

    你想要加功能,本来是改工厂类的,而现在是修改客户端。而且各个不同功能的实例对象的创建代码,也没有耦合在同一个工厂类里,这也是工厂方法模式对简单工厂模式解耦的一个体现。工厂方法模式克服了简单工厂会违背开-闭原则的缺点,又保持了封装对象创建过程的优点。

    但工厂方法模式的缺点是每增加一个产品类,就需要增加一个对应的工厂类,增加了额外的开发量。

    有兴趣的可以参考这个文件深入了解简单工厂模式,工厂模式以及抽象工厂模式(具体)

    三、适配器模式

    适配器模式主要应用于希望复用一些现存的类,但是接口又与复用环境要求不一致的情况。当希望复用的类接口不对时,采用适配器使控制之外的一个原有对象与某个接口匹配。
    在这里插入图片描述

    代码实现

    //客户端:
    public class XYZ {
    	public void work()
    	{
    		Target tag = new RealizeClass();
    		tag.Request(); 
    	}
    }
    //服务接口:
    public interface Target 
    {
    	public void Request();
    }
    // 客户端想要的服务:
    public class Service 
    {
    	public void SpecificRequest()     //但是接口不匹配
    	{
    		//具体操作方法
    	}
    }
    
    //重写服务端实现类,作为适配器,代码为:
    public class RealizeClass implements Target
    {
    	private Service service;
    	public void Request()
    	{
    		service = new Service();
    		service.SpecificRequest();   //进行适配
    	}
    }
    
    // 例子2
    public interface Duck{     //鸭子具有呱呱叫和飞行功能
    	public void quack();
    	public void fly();
    } 
    
    Public class MallardDuck implements Duck{
    	public void quack(){
    		System.out.println(“Quack”);
    	}
    	 public void fly(){
    		System.out.println(“I am flying”);
    	}
    }
    
    public interface Turkey{     //火鸡具有咯咯叫和飞行功能
    	public void gobble();
    	public void fly();
    } 
    
    Public class WildTurkey implements Turkey{
    	public void gobble(){
    		System.out.println(“Gobble gobble”);
    	}
    	 public void fly(){
    		System.out.println(“I am flying a short distance”);
    	}
    }
    
    /**
    * 假设你缺少鸭子对象,想用一些火鸡对象来冒充
    * 因为火鸡的接口不同,所以我们不能公然拿来用,写个适配器	
    **/
    public class TurkeyAdapter implements Duck{ //实现想转化的类型
    	Turkey turkey;
    	//利用构造器取得适配器的构造引用
    	public TurkeyAdapter (Turkey turkey){
    		this.turkey = turkey;
    	}
    	public void quack(){ 
    		 turkey.gobble();
    	}
    	public void fly(){  //火鸡飞行距离短,所以需要5次飞行对应鸭子的飞行
    		forint i=0;i<5;i++{
    			turkey.fly();
    		}
    	}
    
    }
    
    public class DuckTestDrive{
    	public static void main(String[] args){
    		MallardDuck duck = new MallardDuck();
    		WildTurkey turkey = new WildTurkey();
    		// 把火鸡放进火鸡适配器,让它看起来像个鸭子
    		Duck turkeyAdapter = new TurkeyAdapter(turkey);
    		
    		System.out.println(“The turkey says…”);
    		turkey.gobble();
    		turkey.fiy();
    
    		System.out.println(“\nThe Duck says…”);
    		testDuck(duck);
    
    		System.out.println(“\nThe TurkeyAdapter says…”);
    		testDuck(turkeyAdapter);
    
    	}
    	static void testDuck(Duck duck){
    		duck.quack();
    		duck.fly();
    	}
    }
    
    结果:
    The turkey says…
    Gobble gobble 
    I am flying a short distance 
    
    The Duck says…
    Quack
    I am flying 
    
    The TurkeyAdapter says…
    Gobble gobble
    I am flying a short distance
    I am flying a short distance
    I am flying a short distance
    I am flying a short distance
    I am flying a short distance 	
    

    四、模板模式

    模板模式 :解决某类事情的步骤有些是固定的,有些是会发生变化的,那么这时候我们可以为这类事情提供一个模板代码,从而提高效率。
    通过定义一个算法骨架,而将算法中的步骤延迟到子类,这样子类就可以复写这些步骤的实现来实现特定的算法。

    是类的一种行为,只需要准备一个抽象类,将逻辑用具体方法和构造函数的形式来表现,后声明一些抽象方法来迫使子类必须实现其逻辑,不同的子类可以实现不同的方法,从而可以让剩余的逻辑有不同的实现。即可以定义抽象的方法,让子类实现剩余的逻辑。

    分类:

    抽象模版:定义的数量和类型,定义了一个抽象操作让子类实现,定义并实现了一个模版方法,该模版方法一般是一个具体方法,同时给出了顶层逻辑的框架,具体的步骤在相应的抽象操作中,具体的业务逻辑延迟到子类实现。(只有一个抽象基类)
    具体模版:模版方法的数量,实现父类定义的一个或多个抽象方法,每个抽象模版的角色都可以由任意多个具体模版角色与之对应。即不是一对一,而是多对多。

    例如:
    1.办理银行业务:

    • 进门取号
    • 填写单据(每个客户填写的单据都不一样,因业务不同而不同)
    • 等待叫号
    • 窗口办理

    2.使用场景

    • 多个子类公有的方法,并且逻辑基本相同时
    • 重要、复杂的算法,可以把核心算法设计为模版方法
    • 重构时,模版方法模式是一个经常使用的模式

    3.UML结构图:

    在这里插入图片描述
    详情可以参考这个文档

    来一个例子:

    
    public class Coffce{
    	void prepareRecipe(){
    		boilWater();
    		brewCoffeeGrinds(); // 冲泡咖啡
    		pourInCup();
    		addSugarAndMilk();
    	}
    	public void boilWater(){
    		// …
    	}
    	public void brewCoffeeGrinds(){
    		//…
    	}
    	public void pourInCup(){
    		//…
    	}
    	public void addSugarAndMilk(){
    		//…
    	}
    } 
    public class Tea{
    	void prepareRecipe(){
    		boilWater();
    		steepTeaBag(); //浸泡茶包
    		pourInCup();
    		addLemon();
    	}
    	public void boilWater(){
    		// …
    	}
    	public void steepTeaBag(){
    		//…
    	}
    	public void pourInCup(){
    		//…
    	}
    	public void addLemon(){
    		//…
    	}
    } 
    

    有公共函数,该如何设计?

    void prepareRecipe(){
    		boilWater();
    		brewCoffeeGrinds();
    		pourInCup();
    		addSugarAndMilk();
    	}
    void prepareRecipe(){
    	boilWater();
    	steepTeaBag();
    	pourInCup();
    	addLemon();
    }
    //生成抽象类CaffeineBeverage
    Public abstract class CaffeineBeverage{ //咖啡因饮料
    	final void prepareRecipe(){
    		boilWater();
    		brew();
    		pourInCup();
    		addCondiments();
    	}
    	public void boilWater(){ // 此处是否还可以改进?
    		// …
    	}
    	abstract void brew();
    	public void pourInCup(){
    		//…
    	}
    	abstract void addCondiments();
    } 
    //实现抽象类
    public class Tea extends CaffeineBeverage{
    	public void brew(){
    		// …
    	}
    	public void addCondiments(){
    		//…
    	}
    } 
    
    
    public class Coffee extends CaffeineBeverage{
    	public void brew(){
    		// …
    	}
    	public void addCondiments(){
    		//…
    	}
    } 
    
    

    如果我不想加任何添加,怎么办?

    //   引入钩子方法   
    Public abstract class CaffeineBeverage{ //咖啡因饮料
    	public final void prepareRecipe(){
    		boilWater();
    		brew();
    		pourInCup();
    		if(isCustomerWantsCondiments()){
    			 addCondiments(); 
    		}	
    	}
    	private void boilWater(){ 
    		// …
    	}
    	protected abstract void brew();
    	private void pourInCup(){
    		//…
    	}
    	protected abstract void addCondiments();
    	// 询问用户是否加入调料 Hook方法(钩子方法)
    	// 有一个默认输出,子类决定是否挂钩(覆盖其父类的方法)
    	protected boolean isCustomerWantsCondiments(){
    		return true;
    	}
    } 
    
    //   使用钩子
    Public class CoffeeWithHook extends CaffeineBeverage{ //咖啡因饮料
    	//…省略子类中覆盖的其他方法
    	public boolean isCustomerWantsCondiments(){
    		String answer = getUserInput();
    		if(answer.toLowerCase().startsWith(“y”)){
    			return true;
    		}else{
    			return false;
    		}
    	}
    	private String getUserInput(){
    		String answer = null;
    		BufferedReader in = new BufferedReader
    					(new InputStreamReader(System.in));
    		try{
    			answer = in.readLine();
    		}catch(IOException ioe){
    			// 做io异常处理
    		}	
    		if(answer == null){return “no”;}
    		return answer;
    	}
    } 
    

    五、(代理、门面)

    利用门面模式实现各层之间的关联与协作。

    如:某层中的各个组件需要访问另一层中的不同组件,导致层与层之间出现“多对多”的关联形式

    在这里插入图片描述
    解决办法: 用“门面架构模式”分离“多对多”的关联。

    在这里插入图片描述
    门面模块与中介的区别:
    门面模块:门面组件之后的各个组件之间有可能仍有相互之间的关联。
    中介模块:中介模块引入后,使与中介关联的各个组件之间的关联被断绝,他们都只与中介打交道,如下面中介模式的图所示在这里插入图片描述

    展开全文
  • 软件体系结构课后作业及答案 很不错 的 ,大家可以下载过了看看
  • 分层体系结构模式是n层模式,其中组件被组织在水平层中。这是设计大多数软件的传统方法,并且具有独立性。这意味着所有组件都是互连的,但彼此之间不依赖。 图1:分层架构 在此体系结构中有四层,其中...

    分层体系结构模式是n层模式,其中组件被组织在水平层中。这是设计大多数软件的传统方法,并且具有独立性。这意味着所有组件都是互连的,但彼此之间不依赖。

     

    图1:分层架构

    在此体系结构中有四层,其中每一层在模块和其中的组件之间都有联系。从上到下分别是:

    表示层:它包含与表示层相关的所有类别。

    业务层:包含业务逻辑。

    持久层:用于处理对象关系映射之类的功能

    数据库层:这是所有数据的存储位置。

    在这种情况下,层是关闭的,这意味着请求必须从上到下遍历所有层。这样做有两个原因,一个是所有“相似”组件都在一起,另一个是它提供了隔离层。

    详细地说,将“相似”的组件放在一起意味着与某个层相关的所有内容都停留在该单个层中。这样一来,就可以在组件的类型之间进行清晰的分隔,并且还可以将类似的编程代码集中在一个位置。通过隔离各层,它们变得彼此独立。因此,例如,如果我们要将数据库从Oracle服务器更改为SQL服务器,这将对数据库层产生很大的影响,但不会影响其他任何层。同样,假设您有一个自定义的书面业务层,并想为业务规则引擎进行更改。如果我们拥有定义良好的分层体系结构,则更改不会影响其他层。

     

    图2:分层架构中的数据传播

    可以对分层体系结构模式进行修改,以在提到的层之外增加其他层。这称为混合分层体系结构。例如,在业务层和持久层之间可以有一个服务层。但是,这不是理想的方案,因为现在业务层必须经过服务层才能到达持久层。通过服务层,此请求不会获得任何价值。我们将其称为架构漏洞反模式。请求通过层,而在每个层中执行的逻辑很少或没有逻辑。

     

    图3:分层架构模式中的开放层

    解决此问题的唯一方法是将可选层设置为开放层。这意味着,如果可选层将任何值添加到正在发送的请求中,那么请求将通过它。如果不是,那么它将简单地绕过该层,然后转到相关层。从上图中可以看出,请求绕过了服务层,并从业务层移到了持久层。

    但是请注意,通过使用开放层,可以消除使用隔离层的好处。如果要交换持久层,则必须考虑开放服务层以及业务层。这两个层现在都耦合到持久层。因此,尽管很容易向系统中添加开放层,但不应允许它发生。我们必须设法解决问题而不损害体系结构。


    结论

    分层架构是软件架构模式的最简单形式。如果您要设计一个基本的应用程序,其中用户数量很少(<100–200),并且您确定上线后不会有太多的需求变更,那么这是最好的软件架构模式。与其他模式相比,此体系结构模式的实现成本非常低。

    以下是分层架构模式的利弊分析。

    优点

    由于组件属于特定层,因此易于测试。因此,它们可以单独进行测试。

    它很容易实现,因为自然而然,大多数应用程序都是分层工作的。

    缺点

    尽管可以对特定的层进行更改,但这并不容易,因为应用程序是单个单元。而且,层之间的耦合趋于使其变硬。这也使得难以扩展。

    必须将其部署为单个单元,因此更改为特定层意味着必须重新部署整个系统。

    它越大,请求通过多个层所需的资源就越多,因此将导致性能问题。

    原文:https://medium.com/@priyalwalpita

    展开全文
  • 软件设计模式体系结构的光盘,买来发现光盘里的内容打不开,在CSDN上下载了一个,居然要10分,坑爹啊
  • 软件体系结构与设计模式笔记专门摘录重点
  • 软件体系结构设计模式作业

    热门讨论 2009-06-01 00:35:16
    软件体系结构设计模式作业。作业程序,设计模式。。。
  • 南京邮电大学 软件体系结构实验报告 实验题目基于软件体系结构软件设计开发 姓名xxx 学号xxx 院系计算机软件学院 指导老师周国强 12月23日 一 实验目的和要求 实验目的 经过常见的基于体系结构和设计模式的软件开发...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 176,395
精华内容 70,558
关键字:

常见的软件体系结构模式