精华内容
下载资源
问答
  • 软件体系结构与架构五大设计模式

    千次阅读 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;
    	}
    } 
    

    五、(代理、门面)

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

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

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

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

    展开全文
  • 第三章 软件体系结构风格 一、基本概念 1. 软件体系结构设计的一个核心问题是能否使用重复的体系结构模式,即能够达到体系结构级的复用。 2. 软件体系结构风格是描述某一特定应用领域中系统组织方式的惯用模式。...

    第三章 软件体系结构风格

    一、基本概念

    1. 软件体系结构设计的一个核心问题是能否使用重复的体系结构模式,即能够达到体系结构级的复用。

    2. 软件体系结构风格是描述某一特定应用领域中系统组织方式的惯用模式。体系结构风格定义了一个系统家族,即一个体系结构定义一个词汇表和一组约束。词汇表中包含一些构件和连接件类型,而这组约束指出系统是如何将这些构件和连接件组合起来的

    3. 对软件体系结构风格的研究和实践促进对设计的重用,一些经过实践证明的解决方案也可以可靠地用于解决新的问题。

    4. 软件体系结构风格为大粒度软件重用提供了可能。

    5. 讨论体系结构风格时要回答的问题

        ◎构件和连接件的类型是什么?

        ◎ 可容许的结构模式是什么?

        ◎ 基本的计算模型是什么?

        ◎ 风格的基本不变性是什么?

        ◎ 其使用的常见例子是什么?

        ◎ 使用此风格的优缺点是什么?

        ◎ 其常见的特例是什么?

    6. 软件体系结构风格关键四要素

            提供一个词汇表、定义一套配置规则、定义一套语义解释原则、定义对基于这种风格的系统所进行的分析。

    7.体系结构风格分类

        ◎ 数据流风格:批处理序列;管道/过滤器。

        ◎ 调用/返回风格:主程序/子程序;面向对象风格;层次结构。

        ◎ 独立构件风格:进程通讯;事件系统。

        ◎ 虚拟机风格:解释器;基于规则的系统。

        ◎ 仓库风格:数据库系统;超文本系统;黑板系统

    二、管道和过滤器

    1.优点

        ◎ 使得软构件具有良好的隐蔽性和高内聚、低耦合的特点;

        ◎ 允许设计者将整个系统的输入/输出行为看成是多个过滤器的行为的简单合成;

        ◎ 支持软件重用。只要提供适合在两个过滤器之间传送的数据,任何两个过滤器都可被连接起来;

        ◎ 系统维护和增强系统性能简单。新的过滤器可以添加到现有系统中来;旧的可以被改进的过滤器替换掉;

        ◎ 允许对一些如吞吐量、死锁等属性的分析;

        ◎ 支持并行执行。每个过滤器是作为一个单独的任务完成,因此可与其它任务并行执行。

    2.缺点

        ◎ 通常导致进程成为批处理的结构。这是因为虽然过滤器可增量式地处理数据,但它们是独立的,所以设计者必须将每个过滤器看成一个完整的从输入到输出的转换;

        ◎ 不适合处理交互的应用。当需要增量地显示改变时,这个问题尤为严重;

        ◎ 因为在数据传输上没有通用的标准,每个过滤器都增加了解析和合成数据的工作,这样就导致了系统性能下降,并增加了编写过滤器的复杂性。

    三、分层系统

        层次系统组织成一个层次结构,每一层为上层服务,并作为下层客户。在一些层次系统中,除了一些精心挑选的输出函数外,内部的层只对相邻的层可见。

    1.优点

        ◎ 支持基于抽象程度递增的系统设计,使设计者可以把一个复杂系统按递增的步骤进行分解;

        ◎ 支持功能增强,因为每一层至多和相邻的上下层交互,因此功能的改变最多影响相邻的上下层;

        ◎ 支持重用。只要提供的服务接口定义不变,同一层的不同实现可以交换使用。这样,就可以定义一组标准的接口,而允许各种不同的实现方法。

    2.缺点

        ◎ 并不是每个系统都可以很容易地划分为分层的模式,甚至即使一个系统的逻辑结构是层次化的,出于对系统性能的考虑,系统设计师不得不把一些低级或高级的功能综合起来;

        ◎ 很难找到一个合适的、正确的层次抽象方法。

    四、C2风格:通过连接件绑定在一起的按照一组规则运作的并行构件网络

    1.组织规则

        ◎ 系统中的构件和连接件都有一个顶部和一个底部;

        ◎ 构件的顶部应连接到某连接件的底部,构件的底部则应连接到某连接件的顶部,而构件与构件之间的直接连接是不允许的;

        ◎ 一个连接件可以和任意数目的其它构件和连接件连接;

        ◎ 当两个连接件进行直接连接时,必须由其中一个的底部到另一个的顶部

    2.示意图

    3.特点

        ◎ 系统中的构件可实现应用需求,并能将任意复杂度的功能封装在一起;

        ◎ 所有构件之间的通讯是通过以连接件为中介的异步消息交换机制来实现的;

        ◎ 构件相对独立,构件之间依赖性较少。系统中不存在某些构件将在同一地址空间内执行,或某些构件共享特定控制线程之类的相关性假设。

    五、客户/服务器风格、三层客户/服务器风格、浏览器/服务器风格

        各自优缺点、区别(详见作业)

    六、正交软件体系结构

    1.定义

            正交软件体系结构由组织层和线索的构件构成。层是由一组具有相同抽象级别的构件构成。线索是子系统的特例,它是由完成不同层次功能的构件组成(通过相互调用来关联),每一条线索完成整个系统中相对独立的一部分功能。每一条线索的实现与其他线索的实现无关或关联很少,在同一层中的构件之间是不存在相互调用的。

            如果线索是相互独立的,即不同线索中的构件之间没有相互调用,那么这个结构就是完全正交的。

    2.特点

        ◎ 正交软件体系结构由完成不同功能的n(n > 1)个线索(子系统)组成;

        ◎ 系统具有m(m > 1)个不同抽象级别的层;
        ◎ 线索之间是相互独立的(正交的);

        ◎ 系统有一个公共驱动层(一般为最高层)和公共数据结构(一般为最低层)。

    3.优点

        ◎ 结构清晰,易于理解。由于线索功能相互独立,不进行互相调用,结构简单、清晰,构件在结构图中的位置已经说明它所实现的是哪一级抽象,担负的是什么功能。

        ◎易修改,可维护性强。由于线索之间是相互独立的,所以对一个线索的修改不会影响到其他线索。系统功能的增加或减少,只需相应的增删线索构件族,而不影响整个正交体系结构,因此能方便地实现结构调整。

        ◎可移植性强,重用粒度大。因为正交结构可以为一个领域内的所有应用程序所共享,这些软件有着相同或类似的层次和线索,可以实现体系结构级的重用。

    七、基于层次消息总线的体系结构 HMB (国内)

    1.消息总线结构

    八、异构结构风格

    1.使用原因

        ◎ 不同的结构有不同的处理能力的强项和弱点,一个系统的体系结构应该根据实际需要进行选择,以解决实际问题。

        ◎ 关于软件包、框架、通信以及其他一些体系结构上的问题,目前存在多种标准。即使在某段时间内某一种标准占统治地位,但变动最终是绝对的。

        ◎ 实际工作中,我们总会遇到一些遗留下来的代码,它们仍有效用,但是却与新系统有某种程度上的不协调。然而在许多场合,将技术与经济综合进行考虑时,总是决定不再重写它们。

        ◎ 即使在某一单位中,规定了共享共同的软件包或相互关系的一些标准,仍会存在解释或表示习惯上的不同。

    2.使用实例

    (1)内外有别模型  

    (2)查改有别模型

    九、特定领域软件体系结构 DSSA

    1.定义

        DSSA就是专用于一类特定类型的任务(领域)的、在整个领域中能有效地使用的、为成功构造应用系统限定了标准的组合结构的软件构件的集合

    2.必备特征

    (1)一个严格定义的问题域和(或)解决域

    (2)具有普遍性,使其可以用于某个特定领域中的某个特定应用的开发

    (3)对整个领域的合适程度的抽象

    (4)具备该领域固定的、典型的在开发过程中可重用的元素。

    3.基本活动

        领域分析、领域设计、领域实现

    4.参与人员

        领域专家、领域分析师、领域设计人员和领域实现人员。

    5.阶段

        DSSA的建立过程分为五个阶段,每个阶段可以进一步划分为一些步骤或者子阶段,每个阶段包括一组需要回答的问题,一组需要的输入,一组将产生的输出和验证标准。本过程是并发的、递归的、反复的、或者可以说,它是螺旋形。完成本过程可能需要对每个阶段经历几遍,每次增加更多的细节。

        DSSA的建立过程是并发的、递归的、反复进行的。DSSA的建立需要设计人员对所在特定应用领域必须精通,找到合适的抽象方式来实现DSSA的通用性和可重用性。以一种逐渐演化的方式发展。

        ◎ 定义领域范围:确定什么在感兴趣的领域中以及本过程到何时结束。

        ◎ 定义领域特定的元素:编译领域字典和领域术语的同义词词典。识别领域中应用间的共同性和差异性;

        ◎ 定义领域特定的设计和实现需求约束:描述解空间中有差别的特性。不仅要识别出约束,并且要记录约束对设计和实现决定造成的后果,还要记录对处理这些问题时产生的所有问题的讨论;

        ◎ 定义领域模型和体系结构:产生一般的体系结构,并说明构成它们的模块或构件的语法和语义;

        ◎  产生、搜集可重用的产品单元:为DSSA增加构件使得它可以被用来产生问题域中的新应用。

    6.DSSA和体系结构风格的比较  

        ◎ DSSA以问题域为出发点,体系结构风格以解决域为出发点。DSSA只对某一个领域进行设计专家知识的提取、存储和组织,但可以同时使用多种体系结构风格;而在某个体系结构风格中进行体系结构设计专家知识的组织时,可以将提取的公共结构和设计方法扩展到多个应用领域。

        ◎ DSSA通常选用一个或多个适合所研究领域的体系结构风格,并设计一个该领域专用的体系结构分析设计工具。体系结构风格的定义和该风格应用的领域是直交的,提取的设计知识比用DSSA提取的设计专家知识的应用范围要广。

        ◎ DSSA和体系结构风格是互为补充的两种技术。

    展开全文
  • 、动态软件体系结构

    千次阅读 2020-04-27 14:03:37
    一、动态软件体系结构概述 软件体系结构动态性: 软件体系结构(Software Architecture,简称: SA)是对软件系统整体组织结构和控制结构的刻画,包括系统中各计算单元(构件)的功能分配、各单元之间的高层交互说明(连接...

    一、动态软件体系结构概述

    软件体系结构动态性:

    软件体系结构(Software Architecture,简称: SA)是对软件系统整体组织结构和控制结构的刻画,包括系统中各计算单元(构件)的功能分配、各单元之间的高层交互说明(连接件)以及SA的约束。当前,SA研究主要集中在静态体系结构上,这种体系结构在运行时不能发生改变。而对于一些需要长期运行且具有特殊使命的系统(如航空航天、生命维持、金融、交通等),如果系统需求或环境发生了变化,此时停止系统运行进行更新或维护,将会产生高额的费用和巨大的风险,对系统的安全性也会产生很大的影响。静态体系结构缺乏表示动态更新的机制,很难用其分析、描述这样的系统,更不能用它来指导系统进行动态演化。因此,动态软件体系结构(Dynamic Software Architecture, 简称: DSA)的研究应运而生。允许在系统运行时发生更新的软件体系结构称为动态软件体系结构,动态体系结构在系统创建后可以动态更新。其动态性主要分为三类:交互式,动态性,结构化动态性和体系结构动态性。

    软件体系结构动态性分三类:

    1. 交互式动态性

    2. 结构化动态性

    3. 体系结构动态性

    动态体系结构的研究分两个方面:

    1. 模拟和描述体系结构动态更新
    • ADL提供了一种形式化机制来描述软件体系结构,主要通过提供语法和语义描述来模拟构件、连接件和配置。
    • 近年的研究主要集中在对现有的一些ADL扩 展以支持体系结构的动态性。
    • 现已研究出一-些支持动态体系结构的ADL.
    1. 体系结构动态更新的执行

    目前支持动态体系结构机制的主要有Ar chStudio工具集和软件体系结构助理( Software Arch itectureAss istant, SAA)

    • ArchStudio.具集由加州大学Irwine分校提出,支持交互式图形化描述和C2风格描述的体系结构的动态修改。
    • SAA由伦敦皇家学院提出,也是一种交互式图形工具,可以用来描述、分析和建立动态体系结构。

    下图为ArchStud io概念模型,运行系统的改变通过一系列工具反映到体系结构模型上,例如脚本语言的改变和交互式的图形设计环境。体系结构的改变包括增加删除或更新构件、连接件,以及系统拓扑结构发生改变。
    在这里插入图片描述

    二、软件体系结构动态模型

    基于构件的动态系统结构模型:
    在这里插入图片描述
    模型简介:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    三、动态体系结构的描述

    动态体系结构描述语言:
    1.Dynamic Wright

    • Wright的一个扩展,试图模拟、标记和解决软件系统的动态性
    • 增加描述描述体系结构动态变化的新符号,配置Configuror©: .
      何时应该重新配置?
      什么原因需要重新配置?
      重新配置如何进行?

    静态描述:
    在这里插入图片描述
    动态描述:
    在这里插入图片描述
    2. Darwin

    • 一个用于描述系统配置规划的ADL,把.一个程序看成是由不同级别的构件进行相应配置的结果;
    • 可对一个构件所需要的和所提供的服务进行指定;
      在这里插入图片描述
    • 每一个服务需要局部指定,每y一个构件可进行独立测试。

    动态软件体系结构的形式化描述:

    1. 图形化方法
      在这里插入图片描述

    2. 进程代数方法
      在这里插入图片描述

    3. 逻辑化描述方法
      在这里插入图片描述

    四、动态体系结构特征

    1、可构造性动态特征

    可构造性动态特征迪常可以迪过结合动态描述语言、动态修改语言和一个动态更新系统来实
    现。(近年来,已经开发出了很多动态体系结构描述语言,如Darwin、 Dynamic ACMED、Dynamic Wright、Rapide等 )

    动态描述语言用于描述应用系统软件体系结构的初始配置:当体系结构发生改变的时候,这种改变可以通过动态修改语言进行描述,该语言支持增加或删除、激活或取消体系结构元素和系统遗留元素:而动态更新可以通过体系结构框架或者中间件实现。

    在这里插入图片描述

    2、适应性动态特征

    某些应用程序必须有立即反映当前事件的能力,此时程序不能进行等待,必须把初始化、选择和执行整合到体系结构框架或中间件里面。

    适应性动态特征是基于一系列预定义配置而且所有事件在开发期间已经进行了评估。执行期间,动态改变是通过一-些预定义的事件集触发,体系结构选择-一个可选的配置来执行系统的重配置。

    在这里插入图片描述

    3、智能性动态特征

    智能性动态特征是用一个有限的预配置集来移除约束。
    在这里插入图片描述
    对比适应性体系结构特征,智能性体系结构特征改善了选择转变的功能,适应性特征是从一系列固定的配置中选择一个适应性体系结构的配置,而智能性特征是包括了动态构造候选配置的功能。但是由于智能特征的复杂性,在实际的软件体系结构中并不是太多的系统能够用到这种方法。

    展开全文
  • 软件体系结构风格

    千次阅读 2017-06-28 13:52:56
    首先,我们需要先明确一个概念,什么叫软件体系结构的风格?定义便是:描述某一特定应用领域中系统组织方式的惯用。即,定义了用于描述系统的术语表和一组指导构建系统的规则。这方便了软件粒度的重用。因此,当...
    原文地址
    

    首先,我们需要先明确一个概念,什么叫软件体系结构的风格?定义便是:描述某一特定应用领域中系统组织方式的惯用。即,定义了用于描述系统的术语表和一组指导构建系统的规则。这方便了软件大粒度的重用。因此,当人们使用常用的,规范的方式来组织时,即可使别的设计师很容易理解系统的体系结构。下面是一些常用的软件体系结构风格


      (一)经典软件体系结构风格

        1.数据流风格:批处理序列,管道与过滤器

        2.调用/返回风格:主程序与子程序,面向对象风格,层次结构

        3.独立构件风格:进程通信,事件系统

        4.虚拟机风格:解释器,基于规则的系统

        5.仓库风格:数据库系统,超文本系统,黑板系统

      (二)客户/服务器风格

        通过一台物理上与宿主机相连接的非智能终端来实现宿主机上的应用程序。C/S软件体系结构是基于资源不对等,且为实现共享而提出的

      (三)三层C/S结构风格

        表示层负责处理用户的输入和向用户输出;

        功能层负责建立数据库的连接,根据用户的请求生成访问数据库的SQL语句,并把结构返回给客户端

        数据层负责实际的数据库存储和检索,相应功能层的数据处理请求,并将结构返回给功能层

      (四)浏览/服务器风格

        是上述三层C/S应用结构的一种实现方式,其具体结构为:浏览器/Web服务器/数据库服务器

      (五)公共对象请求代理体系结构

        使对象可以透明地发出请求和获得应答,从而建立起一个异质的分布式应用环境

      (六)正交软件体系结构

        由组织曾和线索的构件构成。层是由一组具有相同抽象级别的构件构成。线索是子系统的特例,由完成不同层次功能的构件组成。每一条线索完成整个系统中相对独立的一部分功能。每条线索的实现与其他线索的实现无关或关联很少,在同一层中不存在相互调用

    展开全文
  • 软件体系结构风格介绍

    千次阅读 2020-02-18 12:46:38
    文章目录软件体系结构风格介绍(一)管道和过滤器风格(二)数据抽象与面向对象风格(三)基于事件的隐式调用风格(四)层次系统风格()仓库风格(六)C2风格(七)基于层次消息总线的架构风格 软件体系结构风格...
  • 软件体系结构风格整理

    万次阅读 多人点赞 2019-01-06 15:17:36
    什么是软件体系结构风格? 软件体系结构风格(Architectural Styles)是描述特定系统组织方式的惯用范例,强调了软件系统中通用的组织结构。 风格这个词是个模糊的概念,不同的人有不同的理解,这有时候就让人很...
  • 软件体系结构

    万次阅读 2018-12-18 20:37:41
    原文作者:Petter Liu ... 架构风格是一组原则。你可以把它看成是一组为系统家族提供抽象框架的粗粒度模式。... 常见的软件体系结构风格涉及: 设计词汇表是什么?或者构件和连接器的类型是什么? 可容许...
  • 软件体系结构期末考试总结

    千次阅读 多人点赞 2019-12-30 23:19:35
    今天刚考完软件体系结构,把考前的知识点总结发到群里,仅供自己参考,但是里面的内容确实有用也是面试会问到的基础,所以这门课很重要的还是,只可惜我是预习了一两天就参加考试了 对了我们的教材是《软件工程体系...
  • Garlan和Shaw将通用软件体系结构风格总结为类:数据流风格、调用/返回风格、独立构件风格、虚拟机风格、仓库风格。 其中数据流风格有:批处理序列、管道/过滤器; 调用/返回风格有:主程序/子程序、面向对象...
  • 软件体系结构风格及其应用

    千次阅读 2019-04-19 11:53:41
    软件体系结构设计的一个核心问题是如何有效地使用重复的体系结构模式,即达到软件体系结构级的软件重用。软件体系结构风格(Software ArchitectureStyle)是描述软件系统组织方式的常用模式,在实践中已经被多次应用...
  • 软件体系结构期末复习

    千次阅读 多人点赞 2019-12-29 00:08:58
    软件体系结构期末复习 标签(空格分隔): 未分类 回顾课本和TTP课件 内容总概 章节回顾 第1章、软件体系结构概论 0.软件体系结构的发展过程经历了四个阶段: (1)无体系结构阶段、(2)萌芽阶段、(3)初期阶段、(4)...
  • 软件体系结构》 练习题

    千次阅读 2018-07-10 10:32:50
    就在刚才,提心吊胆的《软件体系结构》考试结束了,好久没有嗓子疼过了(昨天背知识点背的),脑袋里面又装下了很多知识,虽然不知道什么时候还能再用到,但一直相信,学到的就是自己的东西。分享一下备考过程中搜集...
  • 软件体系结构期末复习题

    千次阅读 2019-06-11 15:05:54
    1.软件体系结构主要包括哪3个部分? 答:软件体系结构=构件+连接件+约束。软件体系结构是具有一定形式的结构化元素,即构件的集合,包括处理构件、数据构件和连接构件。处理构件负责对数据进行加工,数据构件是被...
  • 软件体系结构是具有一定形式的结构化元素,即构件的集合,包括处理构件、数据构件和连接构件。 处理构件负责对数据进行加工; 数据构件是被加工的信息; 连接构件把体系结构的不同部分组组合连接起来。 这一定义注重...
  • 10个常见软件体系结构模式

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

    千次阅读 2020-08-13 11:05:17
    目录绪论第一章 软件工程和软件设计概述第二章 软件模型和描述第三章 软件体系结构建模和UML第四章 软件设计过程第软件体系结构风格 绪论 案例一:圣·玛丽亚教堂 案例二:瑞典瓦萨战舰 由建筑体系架构——&...
  • 软件体系结构的风格

    千次阅读 2009-02-28 21:33:00
    作者:张友生 来源:程序员 http://www.csai.cn 2005年2月1日 在上两篇文章中,我们介绍了软件体系结构的概念、现状及发展方向,读者可能会觉得"软件体系结构太抽象、太理论化,没有什么实际的东西"。...
  • 软件体系结构】考点整理

    千次阅读 2017-01-04 19:52:44
    一、填空题 1、软件元素包括 、 、 、 、 甚至领域知识。 软件工程包括3个要素: 、 和 。 软件重用过程中需要重用的开发组织结构予以支持,它...8、软件体系结构的生命周期模型主要分为需求分析阶段,建立软件体
  • 四、软件体系结构描述

    千次阅读 2020-04-02 23:05:05
    软件体系结构描述方法 描述方法的种类: 非形式化→形式化→ 标准化 图形表达工具 采用由矩形框和有向线段组合而成的图形表达工具。 矩形表示抽象构件 框内文字为抽象构件的名称 有向线段代表辅助各构件进行通信、...
  • 软件体系结构期末考试复习题(题中页码 与软件体系结构原理、方法与实践第2版 张友生编著 匹配) 一、选择题← 不属于软件体系结构的核心模型的最基本的元素是 A构件B连接件 C配置 D角色 2、选项中不属 于“4+1...
  • 软件体系结构期末备考资料整理

    千次阅读 2018-06-30 22:07:04
    软件体系结构期末备考资料整理名词解释:软件重用:软件重用,也称为软件复用,就是利用已开发的且对应用有贡献的软件元素来构建新软件系统。从软件工程角度看,软件重用发生在构造新的软件系统的过程中。软件重用...
  • 软件体系结构复习整理

    千次阅读 2018-11-06 23:18:39
    一、 认识软件架构 本书的主旨: 阐明企业目标、产品需求、设计师的经验、构架和最终系统之间的关系——它们构成带有回路的、可由开发组织实施管理的周期 架构商业周期(ABC): 软件架构是技术、商业和社会等诸多...
  • 计算机网络体系结构简述

    千次阅读 2020-04-29 23:11:42
    为什么采用层协议体系结构?各层的作用是什么?1. 应用层:2. 运输层:TCPUDP网络层IP数据链路层三个基本问题两种协议物理层如何更好的理解整个体系结构? 简述 我们把计算机网络的各层及其协议的集合,称为网络的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 88,042
精华内容 35,216
关键字:

五大软件体系结构