精华内容
下载资源
问答
  • 体系结构设计

    2020-10-27 20:16:18
    相对于面向对象的方法而言,结构化软件工程方法更关注系统的功能,采用自顶向下、逐步求精的设计过程,以模块为中心来解决问题。采用结构化软件工程方法开发出来的软件系统可以看成是一组函数或过程的集合。结构化软件...

    相对于面向对象的方法而言,结构化软件工程方法更关注系统的功能,采用自顶向下、逐步求精的设计过程,以模块为中心来解决问题。采用结构化软件工程方法开发出来的软件系统可以看成是一组函数或过程的集合。结构化软件设计从系统的功能入手,按照工程标准和严格的规范将目标系统划分为若干功能模块。
    结构化设计方法可以划分为面向数据流的设计方法和面向数据结构的设计方法。
    1.面向数据流的设计方法
    面向数据流的设计方法是常用的结构化设计方法,多在概要设计阶段使用。它主要是指依据一定的映射规则,将需求分析阶段得到的数据描述从系统的输入端到输出端所经历的一系列变换或处理的数据流图转换为目标系统的结构描述。
    在数据流图中,数据流分为变换型数据流和事务型数据流两种。所谓变换,是指把输入的数据处理后转变成另外的输出数据。信息沿输入路径流入系统,在系统中经过加工处理后又离开系统,当信息流具备这种特征时就是变换流。
    谓事务,是指非数据变换的处理,它将输入的数据流分散成许多数据流,形成若干个加工, 然后选择其中一个路径来执行。比如,对于一个邮件分发中心,把收进的邮件根据地址进行分发, 有的用飞机邮送,有的用汽车邮送。信息沿输入路径流入系统,到达一个事务中心,这个事务中心根据输入数据的特征和类型在若干个动作序列中选择一个执行方式,这种情况下的数据流称为事务流,它是以事务为中心的。变换型数据流和事务型数据流的示意图如下。
    在这里插入图片描述
    通常,在一个大型系统中,可能同时存在变换型数据流和事务型数据流。对于变换型数据流,设计人员应该重点区分其输入和输出分支,通过变换分析将数据流图映射为变换结构,从而构造出目标系统的结构图。针对变换型数据流的设计可以分为以下几个步骤。
    1)区分变换型数据流中的输入数据、变换中心和输出数据,并在数据流图上用虚线标明分界线。
    2)分析得到系统的初始结构图。
    3)对系统结构图进行优化。
    2.面向数据结构的设计方法
    面向数据结构的设计方法,顾名思义,就是根据数据结构设计程序处理过程的方法。具体地说,面向数据结构的设计方法按输入、输出及计算机内部存储信息的数据结构进行软件结构设计,从而把对数据结构的描述转换为对软件结构的描述。使用面向数据结构的设计方法时,分析目标系统的数据结构是关键。
    面向数据结构的设计方法通常在详细设计阶段使用。比较流行的面向数据结构的计方法包括 Jackson方法和 Warnier方法。这里主要介绍 Jackson方法。
    Jackson方法把数据结构分为3种基本类型:顺序型结构、选择型结构和循环型结构。
    它的基本思想是:在充分理解问题的基础上,找出输入数据和输出数据的层次结构的对应关系,将数据结构的层次关系映射为软件控制层次结构,然后对问题的细节进行过程性描述。 Jackson图是 Jackson方法的描述工具, Jackson方法的基本逻辑结构如图9-14所示
    在顺序型结构中,数据由一个或多个元素组成,每个元素按照确定的次序出现一次。在如图9-14a所示的顺序型图示中,数据A由B、C和D共3个元素顺序组成。在选择型结构中,数据包含两个或多个元素,每次使用该数据时,按照一定的条件从罗列的多个数据元素中选择个。在如图9-14所示的选择型图示中,数据A根据条件从B、C或D中选择一个,元素右上方的符号“。”表示从中选择一个。在循环型结构中,数据根据使用时的条件由一个数据元素出现零次或多次构成。在如图9-14b所示的循环型图示中,数据A根据条件由元素B出现零次或多次组成。元素B后加符号“*”表示重复。
    在这里插入图片描述
    运用 Jackson图表达选择型或循环型结构时,选择条件或循环结束条件不能在图上直接表现出来,并且框间的连线为斜线,不易在打印机上输出,所以产生了改进的 Jackson图,其基本逻辑符号如图9-15所示。
    在这里插入图片描述
    选择型结构图上S右边括号中的i代表分支条件的编号。在可选型结构中,A或者是元素B,或者不出现。在循环型结构图中,i代表循环结束条件的编号。
    运用 Jackson图进行程序设计的优点如下。
    可以清晰地表示层次结构,易于对自顶向下的结构进行描述。
    结构易懂、易用,并且比较直观、形象。
    不仅可以表示数据结构,也可以表示程序结构。
    运用 Jackson方法进行程序设计的步骤可以归纳为以下几点。
    1)分析并确定输入数据和输出数据的逻辑结构,并用 Jackson结构来表示这些数据结构。
    2)找出输入数据结构和输出数据结构中有对应关系的数据单元。
    3)按照一定的规则,从描绘数据结构的 Jackson图导出描绘程序结构的 Jackson图。
    4)列出基本操作与条件,并把它们分配到程序结构图的适当位置
    5)用伪代码表示程序。
    3.面向数据结构的设计和面向数据流的设计的区别
    在这里插入图片描述

    展开全文
  • J2EE体系结构设计

    2021-02-04 15:07:36
    目前大多数企业采用J2EE技术的结构设计与解决方案。对于我们学习和研究J2EE体系结构来说,了解与掌握J2EE体系结构的设计方法及一些常用模式是必须的;模型-视图-控制(model-view-control,简称MVC)结构是目前最常见...
  • 体系结构设计作用 对设计在满足既定需求方面的有效性进行分析 在设计变更相对容易的阶段,考虑体系结构可能的选择方案 降低与软件构建相关的风险 体系结构风格 以数据为中心的体系结构???? 数据存储(如文件或...

    体系结构设计作用

    • 对设计在满足既定需求方面的有效性进行分析
    • 在设计变更相对容易的阶段,考虑体系结构可能的选择方案
    • 降低与软件构建相关的风险

    体系结构风格

    以数据为中心的体系结构📈

    数据存储(如文件或数据库)位于这种体系结构的中心,其他构件会经常访问该数据存储,并对存储中的数据进行更新、增加、删除或者修改。

    在这里插入图片描述

    客户软件访问中心存储库

    数据流体系结构📈

    当输入数据经过一系列计算构件和操作构件的变换形成输出数据时,可以应用这种体系结构。

    在这里插入图片描述

    管道-过滤器模式拥有一组称为过滤器的构件,这些构件通过管道连接,管道将数据从一个构件传送到下一个构件。每个过滤器独立于其上游和下游的构件而工作,过滤器的设计要针对某种形式的数据输入,并且产生某种特定形式的数据输出(到下一个过滤器)。然而,过滤器没有必要了解与之相邻的其他过滤器的工作。

    调用和返回体系结构📈

    • 主程序/子程序体系结构

    在这里插入图片描述

    • 远程过程调用体系结构

    面向对象体系结构

    层次体系结构📈

    在这里插入图片描述

    图中定义了一系列不同的层次,每个层次各自完成操作,这些操作逐渐接近机器的指令集。在外层,构件完成建立用户界面的操作;在内层,构件完成建立操作系统接口的操作;中间层提供各种实用工具服务和应用软件功能

    体系结构考虑要素

    • 经济性
    • 易见性
    • 隔离性
    • 对称性
    • 应急性

    体系结构设计

    系统环境表示📈

    • 上级系统———这些系统把目标系统作为某些高层处理方案的一部分。
    • 下级系统——这些系统被目标系统使用,并为完成目标系统的功能提供必要的数据和处理。
    • 同级系统——这些系统在对等的基础上相互作用(即信息或者由同级系统和目标系统产生,或者被目标系统和同级系统使用)。
    • 参与者——通过产生和消耗必要处理所需的信息,实现与目标系统交互的实体(人、设备)。

    在这里插入图片描述

    • 示例:

    在这里插入图片描述

    定义原型(archetype)

    每一个设计类就是一个archetype

    将体系结构细化为构件📈

    在这里插入图片描述

    描述系统示例(进一步细化)📈

    在这里插入图片描述

    展开全文
  • 体系结构设计说明书

    2012-10-10 19:05:11
    本文档描述软件体系结构设计说明书的目的、范围、相关术语、参考资料和本文档的摘要性介绍。软件体系结构设计属于高层设计文档,是符合现代软件工程要求的概要设计
  • 体系结构设计建议

    2019-10-07 09:09:21
    即使没有做到下列建议中的任何一点,也并不代表体系结构设计一定会出现致命失误。但是这些可以作为设计中的参考(或者说警戒线)。 过程建议 保持概念完整性和技术一致性。这意味着需要加强设计者之间的沟通,或者...

    内容来自《Software Architecture in Practice》,尽量遵守原文,但很多部分采(jia)用(dai)意(si)译(huo)。

    以下只是建议,而非强制要求;即使没有做到下列建议中的任何一点,也并不代表体系结构设计一定会出现致命失误。但是这些可以作为设计中的参考(或者说警戒线)。

    过程建议

    1. 保持概念完整性和技术一致性。这意味着需要加强设计者之间的沟通,或者极端一点,整个系统由一个人进行设计。但在做到这一点的同时,要避免设计脱离实际,导致无法实现。

      这一点来自Brooks的《人月神话》。前一点很好理解,概念的不完整会导致沟通成本的急剧上升,严重的话甚至会无法集成,造成整个项目的失败。但后一点不太好理解,我个人觉得,作者想表达的是,过分追求设计和技术的一致,导致技术无法落地,最后也会失败;这一点往往出现在技术水平较低的团队里。

      比如,主系统决定采用Vue开发,然后就拍脑袋决定所有子系统都用Vue开发,但有些业务场景Vue是不太合适的(移动端当中重量级的应用场景,比如混合应用开发,Vue本身专注于视图,比较轻量,在这方面比较乏力,缺少完善的解决方案),如果硬要上必须进行改造,但技术积累不足,无法落地,就会导致项目的失败。同样的,如果为了刻意追求某个pattern,在不合适的场景下生搬硬套而不加以改造,也会导致失败。

      为什么我想到了马谡……

    2. 体系结构设计应该基于明确的质量属性需求。

      强调质量属性在体系结构设计中的重要作用。同时,我们也应该意识到,提高一个质量属性往往意味着降低另一个质量属性,需要进行权衡。Tradeoffs always occur.

    3. 体系结构应该通过视图(view)进行文档化。视图应当能够回应最重要的利益相关者(stakeholder)的关切,以获取他们对项目进度的支持。

      原文:The views should address the concerns of most important stakeholders in support of the project timeline.

      如果利益相关者没法感受到项目进度,就很难让他们全力支持。因为软件系统固有的复杂性,并且不同的利益相关者的关注点是不同的,整个系统很难通过一张图来刻画,就需要有多个视图来从各个方面展示系统,比如著名的4 + 1视图:过程视图、逻辑视图、开发视图、物理视图、用例。

      体系结构由结构组成,视图是结构的表现形式。结构就是结构(元素 + 关系,但本身是个抽象概念),视图是将结构实例化了。或者说,结构是体系结构在特定上下文(context)中的一个快照(snapshot),类似于胶卷;而视图是把结构可视化之后呈现出来,类似于冲洗之后的照片。

    4. 体系结构应该持续进行评估,以确认能满足质量需求。

      这里的“持续”指的不是一直进行,而是指在合适的时间进行,并且贯穿整个生命周期。

      因为设计可能会过时,并且每次变更都可能对整个架构产生影响,所以需要持续进行评估。此外,我觉得这一点还有螺旋模型的意思在里面:如果已经可以预见不能满足质量需求,就应当及时止损。

    5. 体系结构应该支持增量集成以尽早发现问题,避免后期的大爆炸集成(大爆炸集成一般不会成功)。一种实践方案是使用骨架系统(skeletal system)。骨架系统指的是已经搭建好的,能够完成内部交互并且已经实现了最小功能(minimal functionality)的系统。

      我感觉骨架系统就是我们平时所说的“项目脚手架”,比如vue-cli和create-react-app。注意,是最小功能,而非最少功能。最少功能一般是满足需求规格,能够正常交付的最少功能,类似于演化模型中的第一个迭代实现的功能。

      越早发现和解决问题,成本越低。

    结构建议

    1. 体系结构的模块应该符合信息隐藏和关注点分离的原则。

      模块本身就应该符合这两条,不然叫什么模块呢?

    2. 尽量采用成熟的解决方案,除非需要解决的问题没有先例。

      一般来说,自己开发的方案,比起经过业界打磨的成熟方案,总是存在差距的,至少在优化上有所不足。除非,自己就是“业界”……大厂请自动忽略。

    3. 体系结构不应当依赖于某个商业产品或工具的特定版本。如果必须要依赖于特定版本,那么要把它单独分离出一个结构以应对变更。

      要依赖于抽象,而不是依赖于具体。

    4. 提供数据的模块和使用数据的模块应该分离。

      这样可以实现解耦。如果提供和使用数据的是同一个模块,一旦发生变更,两边都要修改;分开之后就只需要修改一个了。

    5. 模块(module)和组件(component)没有一一对应关系。比如,一个并行的系统,可能有多个组件同时运行,但这些组件都是由同一个模块构建的。

      模块是静态的、开发时的概念,组件是动态的、运行时的概念,从一开始就不一样,自然也没有必然的联系。如果举一个更极端的例子,在一个使用map-reduce pattern的系统中,只有一个模块(因为只有一个职责,就是完成这个计算任务),但在运行时会有很多个component分配到不同的计算节点上。

    6. 应该编写每个进程,这样即使是在运行时,也可以轻松更改它在特定处理器上的分配。

      原文:Every process should be written so that its assignment to a specific processor can be easily changed, perhaps even at runtime.

      我觉得,不显式分开编写也就没有进行分配的机会吧。

      An application is required to perform a variety of tasks of varying complexity on the information that it processes. A straightforward but inflexible approach to implementing an application is to perform this processing as a monolithic module. However, this approach is likely to reduce the opportunities for refactoring the code, optimizing it, or reusing it if parts of the same processing are required elsewhere within the application.

    7. 体系结构只应该具有少量的组件交互方式。也就是说,系统应该始终用同样的方式做同样的事。这样有助于提高可理解性,缩短开发时间,增强可靠性;同时提高了可修改性。

      再简单一点,大概就是尽量用同样的方式去实现同样的功能。这应该是之前提到的概念完整性的一个细化。如果同样的功能有不同的实现方式,很容易让人迷惑,使用提高了可理解性。相当于复用,缩短了开发时间。之前的同样的功能已经经过相对完善的测试,能够可靠地使用,增强了可靠性。至于提高了可修改性,这个马上说。

      同样的方式去实现同样的功能(和复用)并不代表直接复制粘贴,而是抽出可复用的核心部分,然后其他部分都依赖于这个部分。这是allocation patterns中的一种(platform pattern);所以从某种意义上,也可以提高可修改性。

    8. 体系结构应该包含一组特定(并且较小)的资源竞争区域,并且应该明确指定和维护其解决方案。举例来说,如果网络利用率是一个关注点,那么应该给每个开发组提供指导,以达成最小的网络通信量。

      原文:The architecture should contain a specific(and small) set of resource contention areas, the resolution of which is clearly specified and maintained.

    展开全文
  • 体系结构设计文档;北邮:软件工程作业——体系结构设计文档
  • 体系结构设计 案例 1-Software Architecture Document,软件体系结构设计的标准文档 英文版
  • 嵌入式Linux网络体系结构设计与TCPIP协议栈嵌入式Linux网络体系结构设计与TCPIP协议栈嵌入式Linux网络体系结构设计与TCPIP协议栈嵌入式Linux网络体系结构设计与TCPIP协议栈嵌入式Linux网络体系结构设计与TCPIP协议栈
  • 软件体系结构设计模式 一【实验目的】 理解设计模式基本概念 掌握主要的设计模式 二【实验内容】 1. 简单工厂模式 1)理解案例1,然后完成2)部分的实验 我们将创建一个 Shape 接口和实现 Shape 接口的实体类。下...

    软件体系结构设计模式

    一【实验目的】

    1. 理解设计模式基本概念
    2. 掌握主要的设计模式
      二【实验内容】
      1. 简单工厂模式
      1)理解案例1,然后完成2)部分的实验
      我们将创建一个 Shape 接口和实现 Shape 接口的实体类。下一步是定义工厂类 ShapeFactory。
      FactoryPatternDemo,我们的演示类使用 ShapeFactory 来获取 Shape 对象。它将向 ShapeFactory 传递信息(CIRCLE / RECTANGLE / SQUARE),以便获取它所需对象的类型。

    步骤 1
    创建一个接口:
    Shape.java

    public interface Shape { 
    void draw();
     }
    

    步骤 2
    创建实现接口的实体类。
    Rectangle.java

    public class Rectangle implements Shape {
     @Override 
    public void draw() { 
    System.out.println("Inside Rectangle::draw() method."); 
    	} 
    }
    

    Square.java

    public class Square implements Shape {
     @Override 
    public void draw() {
     System.out.println("Inside Square::draw() method."); 
    } 
    }
    

    Circle.java

    public class Circle implements Shape { 
    @Override 
    public void draw() { 
    System.out.println("Inside Circle::draw() method."); 
    } 
    }
    

    步骤 3
    创建一个工厂,生成基于给定信息的实体类的对象。
    ShapeFactory.java

    public class ShapeFactory { 
    //使用 getShape 方法获取形状类型的对象 
    public Shape getShape(String shapeType){ 
    if(shapeType == null){
     return null; 
    } 
    if(shapeType.equalsIgnoreCase("CIRCLE")){ 
    return new Circle(); 
    } 
    else if(shapeType.equalsIgnoreCase("RECTANGLE")){ 
    return new Rectangle(); 
    } 
    else if(shapeType.equalsIgnoreCase("SQUARE")){ 
    return new Square(); 
    } 
    return null;
     } 
    } 
    

    步骤 4
    使用该工厂,通过传递类型信息来获取实体类的对象。
    FactoryPatternDemo.java

    public class FactoryPatternDemo { 
    public static void main(String[] args) { 
    ShapeFactory shapeFactory = new ShapeFactory(); 
    //获取 Circle 的对象,并调用它的 draw 方法 
    Shape shape1 = shapeFactory.getShape("CIRCLE"); 
    //调用 Circle 的 draw 方法 shape1.draw(); //获取 Rectangle 的对象,并调用它的 draw 方法 
    Shape shape2 = shapeFactory.getShape("RECTANGLE"); 
    //调用 Rectangle 的 draw 方法 shape2.draw(); //获取 Square 的对象,并调用它的 draw 方法 Shape shape3 = shapeFactory.getShape("SQUARE"); 
    //调用 Square 的 draw 方法 
    shape3.draw()
     } 
    }
    

    步骤 5
    执行程序,输出结果:
    Inside Circle::draw() method.
    Inside Rectangle::draw() method.
    Inside Square::draw() method.

    2、工厂方法

    2)以案例1简单工厂模式为启发,利用工厂方法模式思想,编程实现 下面例子的工厂模式
    工厂模式也就是鼠标工厂是个父类,有生产鼠标这个接口。
    戴尔鼠标工厂,惠普鼠标工厂继承它,可以分别生产戴尔鼠标,惠普鼠标。

    步骤一:
    创建一个接口

    public interface Mouse {
        void sayHi();
    }
    

    步骤二:
    创建实体类实现接口

    public class HpMouse implements Mouse{
        @Override
        public void sayHi() {
            System.out.println("sayHi:惠普鼠标");
        }
    }
    
    public class DellMouse implements Mouse{
        @Override
        public void sayHi() {
            System.out.println("sayHi:戴尔鼠标"); }
    }
    

    步骤三:
    创建鼠标工厂抽象类

    步骤四:
    创建实体类工厂继承抽象类并实现抽象方法

    public class DellMouseFactory extends MouseFactory{
        @Override
        public Mouse creatMouse() {
            return new DellMouse();
        }
    }
    
    public class HpMouseFactory extends MouseFactory{
        @Override
        public Mouse creatMouse() {
            return new HpMouse();}
    }
     
    

    步骤五:
    使用该工厂创建对应的实体对象

    public class MouseFactoryDemo {
        public static void main(String[] args) {
            MouseFactory DellMouseFactory=new DellMouseFactory();
            Mouse dellMouse=DellMouseFactory.creatMouse();
            dellMouse.sayHi();
            MouseFactory HpMouseFactory=new HpMouseFactory();
            Mouse HpMouse=HpMouseFactory.creatMouse();
            HpMouse.sayHi();
        }
    }
    

    2.理解抽象工厂思想,然后用一个例子来体现抽象工厂模式,并编程实现
    例子说明:
    假如我们要创建红色圆形、红色三角形、蓝色圆形、蓝色三角形四个对象,如果我们用工厂方法模式的话,这样一来我们系统中会增多非常多的工厂类,那么通过抽象工厂方法就可以解决这个问题,抽象工厂方法就是将对象等级和族进行分类,比如所有正方形为一个等级,所有红色形状为一个族。
    下面是实现抽象工厂方法代码:
    步骤一:
    定义公共抽象接口并定义不同形状的具体实现类

    public interface Shape {
        public void draw();
    }
     
    

    将不同的形状声明为抽象类(等级划分)并实现公共的抽象接口(Shape)

    public abstract class Circle implements Shape{
        @Override
        public abstract void draw();
    }
    
    public abstract class Rectangle implements Shape{
        @Override
        public abstract void draw();
    }
    

    实现各自的抽象类

    public class RedCircle extends Circle{
        @Override
        public void draw() {
            System.out.println("创建红色圆形对象!");
        }
    }
    
    public class BlueCircle extends Circle{
        @Override
        public void draw() {
            System.out.println("创建蓝色圆形对象!");
        }
    }
    
    
    public class RedRectangle extends Rectangle{
        @Override
        public void draw() {
            System.out.println("创建红色长方形对象!");
        }
    }
    
    
    public class BlueRectangle extends Rectangle{
        @Override
        public void draw() {
            System.out.println("创建蓝色长方形对象!");
        }
    }
    
    

    步骤二:
    定义抽象工厂接口,并根据族(颜色)实现抽象工厂接口

    public interface ShapeFactory {
        Shape getCircle();
        Shape getRectangle();
    }
    
    
    public class RedShapeFactory implements ShapeFactory{
        @Override
        public Shape getCircle() {
            return new RedCircle();
        }
        @Override
        public Shape getRectangle() {
            return new RedRectangle();
        }
    }
    
    
    public class BlueShapeFactory implements ShapeFactory{
        @Override
        public Shape getCircle() {
            return new BlueCircle();
        }
        @Override
        public Shape getRectangle() {
            return new BlueRectangle();
        }
    }
    
    

    步骤四:
    测试代码

    public class AbstractFactoryDemo {
        public static void main(String[] args) {
            ShapeFactory redShapeFactory=new RedShapeFactory();
            redShapeFactory.getCircle().draw(); //创建红色圆对象并执行方法
            redShapeFactory.getRectangle().draw();//创建红色长方形对象并执行方法
            ShapeFactory blueShapeFactory=new BlueShapeFactory();
            blueShapeFactory.getCircle().draw();//创建蓝色圆对象并执行方法
            blueShapeFactory.getRectangle().draw();//创建蓝色长方形对象并执行方法
        }
    }
    

    说明 简单工厂,工厂方法和抽象工厂 的特点
    简单工厂:
    优点:1、不需要关心类的创建细节。
    2、减轻类之间的耦合依赖,具体类的实现只是依赖于工厂,而不依赖于其他类。
    缺点:1、扩展复杂,当简单工厂需要生产出另外一种产品的时候,需要扩展工厂的内部创建逻辑,比较有可能引起大的故障。
    2、由于工厂类集中了所有实例的创建逻辑,违反了高内聚责任分配原则,将全部创建逻集中到了一个工厂类中。
    工厂方法:
    优点:创建一个工厂接口和创建多个工厂实现类,这样一旦需要增加新的功能,直接增加新的工厂类就可以了,不需要修改之前的代码。这样就实现了开闭原则。首先完全实现‘开-闭 原则’,实现了可扩展。其次实现更复杂的层次结构,可以应用于产品结果复杂的场合。工厂方法模式是对简单工厂模式进行了抽象。有一个抽象的Factory类(可以是抽象类和接口),这个类将不在负责具体的产品生产,而是只制定一些规范,具体的生产工作由其子类去完成。在这个模式中,工厂类和产品类往往可以依次对应。即一个抽象工厂对应一个抽象产品,一个具体工厂对应一个具体产品,这个具体的工厂就负责生产对应的产品。
    抽象工厂模式:
    抽象工厂模式中我们可以定义实现不止一个接口,一个工厂也可以生成不止一个产品类,抽象工厂模式较好的实现了“开放-封闭”原则,是三个模式中较为抽象,并具一般性的模式。
    优点:抽象工厂模式除了具有工厂方法模式的优点外,最主要的优点就是可以在类的内部对产品族进行约束。所谓的产品族,一般或多或少的都存在一定的关联,抽象工厂模式就可以在类内部对产品族的关联关系进行定义和描述,而不必专门引入一个新的类来进行管理。
    缺点:产品族的扩展将是一件十分费力的事情,假如产品族中需要增加一个新的产品,则几乎所有的工厂类都需要进行修改。所以使用抽象工厂模式时,对产品等级结构的划分是非常重要的。

    3. 观察者模式

    当对象间存在一对多关系时,则使用观察者模式(Observer Pattern)。比如,当一个对象被修改时,则会自动通知它的依赖对象。观察者模式属于行为型模式。
    主要解决:一个对象状态改变给其他对象通知的问题,而且要考虑到易用和低耦合,保证高度的协作。
    何时使用:一个对象(目标对象)的状态发生改变,所有的依赖对象(观察者对象)都将得到通知,进行广播通知。
    如何解决:使用面向对象技术,可以将这种依赖关系弱化。
    关键代码:在抽象类里有一个 ArrayList 存放观察者们

    理解观察者模式思想,然后用一个例子来体现观察者模式,并编程实现
    例子说明:
    微信公众号中订阅了公众号,当公众号所有者发送推文的时候,会通知所有订阅了该公众号的所有用户,这个情景可以用观察者模式实现。
    代码如下:
    1、首先创建抽象观察者抽象接口,并创建具体观察者实现接口

    public interface Observer {
        void getInfo(String str);
    }
    
    public class User1 implements Observer{
        private String name;
        public User1(String name){
            this.name=name;
        }
        //定义订阅者1
        @Override
        public void getInfo(String text) {
            System.out.println(name+"收到推文:"+text);
        }
    }
    
    
    public class User2 implements Observer{
        private String name;
        public User2(String name){
            this.name=name;
        }
        //定义订阅者2
        @Override
        public void getInfo(String str) {
            System.out.println(name+"收到推文:"+str);
        }
    }
    
    

    2、创建被观察者抽象方法,并创建实体类继承抽象方法,定义添加观察者方法和移除观察者方法,定义通知观察者方法

    import java.util.ArrayList;
    import java.util.List;
    
    public abstract class Subject {
        public List<Observer> users=new ArrayList<>();
        public void addUser(Observer user){
            users.add(user);
        }
        public void removeUser(Observer user){
            users.remove(user);
        }
        public abstract void notifyObserver(String str);
    }
    
    

    定义实体类继承抽象目标,并实现抽象方法,使得所有观察者接收到信息

    public class Manager extends Subject{
        //管理员发送推文,各个订阅者接收到推文
        @Override
        public void notifyObserver(String str) {
            for(Observer user:users){
                user.getInfo(str);
            }
        }
    }
    
    

    测试代码

    public class WeiXinObserverDemo {
        public static void main(String[] args) {
            Subject manager=new Manager(); //创建被观察者
            User1 user1=new User1("渣渣林"); //创建观察者1
            User2 user2=new User2("波波波"); //创建观察者2
            manager.addUser(user1); //添加观察者1
            manager.addUser(user2); //添加观察者2
            manager.notifyObserver("推文:今天是个好日子!"); //观察者做出反应
        }
    }
    
    

    遇到的问题:在写工厂的三种模式时候,搞不清三种工厂模式的区别以及各自的优缺点,并且不熟悉三种方法的代码具体该怎么写。对抽象工厂模式比较陌生,对抽象工厂模式的分类以及分族不是很了解。
    解决方法:不了解工厂方法的三种模式,就去网上分别看了三种方法的解释以及具体代码实现,并且熟练敲了很多遍,基本已经熟练掌握。
    实验感想:在学了设计模式之后,我发现代码不能只是简单地实现功能了,而是代码要能够轻松地实现扩展功能,而不能改变其中已经定义好的内部逻辑。可以增加代码而要尽量避免修改代码。学习了设计模式之后虽然代码的复杂度变高了,但是对于代码以后的功能扩展确实铺了一条好路。

    展开全文
  • 软件体系结构设计模式 一【实验目的】 理解面向对象设计原则的基本概念 掌握主要设计原则的概念、实现方法和实例 二【实验内容】 1.里氏替换原则 举一个符合里氏替换原则的例子,用代码实现 里氏替换原则: • 子类...
  • 第7章 软件体系结构设计.pdf
  • 姿轨控计算机系统引言软件体系结构是对软件各高层抽象的理解,必须在较早阶段对软件进行体系结构层的分析,其中算法和数据结构的选择处在软件体系结构的较低层次上。系统结构的问题包括:用一系列组件来组织一个系统...
  • 《软件工程》第6章体系结构设计

    千次阅读 2020-06-02 09:33:24
    体系结构设计关注理解一个软件系统应当如何组织,以及设计该系统的整体结构。体系结构设计是设计和需求工程之间的关键性衔接环节,因为它会确定组成一个系统的主要结构构件以及它们之间的关系。体系结构设计过程的...
  • 软件体系结构课的大作业,对一个电商系统进行了架构设计文档化
  • 12.1.4 体系结构决策12.2 体系结构的类型12.3 体系结构风格12.3.1 体系结构风格的简单分类12.4 体系结构考虑的要素12.5 体系结构设计--系统环境表示12.6 体系结构设计--定义原型12.7 体系结构设计--细化为构件12.8 ...
  • 工作流管理系统体系结构设计工作流管理系统体系结构设计
  • 软件体系结构设计说明书,有需要可以下载,谢谢
  • 软件体系结构设计模式作业

    热门讨论 2009-06-01 00:35:16
    软件体系结构设计模式作业。作业程序,设计模式。。。
  • 软件体系结构设计|描述与架构风格

    千次阅读 2017-05-15 16:16:52
    软件体系结构设计软件体系结构设计 什么是体系结构 架构描述 AD 架构风格计算机硬件系统中包含的两个重要因素: 基本硬件模块:控制器、运算器、内存储器、外存储器、输入设备…… 硬件模块之间的连接关系:总线...
  • 以下知识点摘录自:《Java软件体系结构设计模式标准指南》一书。其中可能包含本人的一些感悟。  Java软件体系结构设计模式之结构模式(11种)  结构模式主要用来: 1)处理把责任委托给其他对象的对象。这样一来就...
  • 属于软件体系结构,其中的内容为设计原则。
  • 本节书摘来自华章计算机《软件建模与设计: UML、用例、模式和软件体系结构》一书中的第1章,第1....1.3 软件体系结构设计 软件体系结构(Bass,Clements,and Kazman 2003;Shaw and Garlan 1996)将系统的总体结构...
  • 新书推荐《当计算机体系结构遇到深度学习:面向计算机体系结构设计师的深度学习概论》长按二维码了解及购买计算机体系结构新黄金时代赋能深度学习革命的入门书。基于美国哈佛大学在深度学习和体系结构...
  • 软件体系结构设计

    2014-11-16 16:40:25
    软件体系结构
  • 体系结构设计风格

    千次阅读 2016-04-05 17:28:07
    一、常用的软件体系结构风格数据流风格:批处理和管道/过滤器 调用/返回风格:主程序/子程序、层次结构,客户机/服务器,面向对象风格 独立部件风格:进程通讯、事件驱动 虚拟机风格:解释器、基于规则的系统 ...
  • 此文档的编写目的是为了让设计以及运行人员能通过该文档以明确的软件构造体系设计方案规划来实现软件开发的要求,方于客户、软件设计人员、软件开发人员和整合测试人员了解体系结构具体设计方案,为其制作功能实现...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 24,479
精华内容 9,791
关键字:

体系结构设计