精华内容
下载资源
问答
  • 软件体系结构大作业

    2018-11-25 10:53:43
    软件体系结构大作业,学生选课系统,其中包括uml建模的类图,活动图等等
  • 老师布置的两次作业和自己的答案,做的时候参考了网上的一部分答案。软件体系结构作业和答案 2019级中科大软件学院。软件体系结构作业和答案 2019级中科大软件学院。
  • 吉林大学19级软件学生所做,压缩包中有中加英文的的大作业报告,非常详细(24页)。是笔者通过慕课上/b站上自学以及查阅大量CSDN资料/论文所著。为了造福学弟学妹,欢迎下载
  • 南京大学软件学院2009级软件体系结构大作业,分为6项,包括项目的开发视图,部署试图
  • 东南大学软件学院的课程 上传了软件体系结构这门课的期末项目大作业,包括什么研讨会报告啊还有实验项目和报告
  • 软件体系结构大作业报告

    热门讨论 2008-06-15 12:59:38
    软件体系结构大作业报告,赏面的不妨看一下。
  • 设计模式课四次实验源代码,仅供交流学习,不得用于抄袭或者其他用途,eclipse导出类图插件是ModelGoon
  • 中国科学技术大学软件学院《软件体系结构》课程课后作业答案及分析
  • 软件体系结构课后作业及答案 很不错 的 ,大家可以下载过了看看
  • 代码采用java语言,使用了C/S结构、工厂方法模式、开闭原则、依赖倒置原则。实现的程序是一个记事本
  • 大软件体系结构: 数据流 data flow 批处理 batch sequential 管道-过滤器 pipes and filters 调用-返回 call/return 主程序-子程序 main program and subroutine 面向对象 object-oriented 分层 layered 以数据为...
  • 软件体系结构课的大作业,对一个电商系统进行了架构设计文档化
  • 软件体系结构大作业,以支付宝为例的支付软件体系结构演变。分为三章,第一章包括软件体系结构定义、组成、风格及特定领域的软件体系结构;第二章为支付软件的系统架构演变,对每一阶段的架构都进行了介绍和分析;第...
  • 根据丁老师3000页英文PPT翻译过来的笔记,摘抄的时候有所取舍,不过翻译成中文以后能比PPT的英文好看一点
  • 体系结构设计文档;北邮:软件工程作业——体系结构设计文档
  • 中科大软院《软件体系结构》授课课件、书籍等相关资料
  • 软件设计模式与体系结构课后习题代码,孙玉山版本
  • 本书系统介绍了软件体系结构的基本原理、方法和实践,全面反映了软件体系结构研究和应用的最新进展。既讨论了软件体系结构的基本理论知识,又介绍了软件体系结构的设计和工业界应用实例,强调理论与实践相结合。 ...
  • 三种加密算法和其解密算法的Java实现(篇幅限制,无法具体解释三种加密算法,可能会对理解造成一定的困难)加密算法1(折叠算法)。前提条件:要加密的文本文件仅包含英文字符和数字。加密算法2(分组互换算法)。...
  • 软件体系结构设计模式作业

    热门讨论 2009-06-01 00:35:16
    软件体系结构设计模式作业作业程序,设计模式。。。
  • 西安电子科技大学软件体系结构大作业CRM代码下载资料参考
  • 精品文档 一次 就项目管理方面而言软件重用项目与非重用项目有哪些不同之处 答 使用软件重用技术可减少重复工作 , 提高软件生产率 , 缩短开发周期同时由于软 构建大多经过严格的质量认证 因此有助于改善软件质量 ...
  • 很好。可以看一下。关于网上商城系统。自己做的。只是为了积分。所以才上传的。
  • 软件体系结构

    2016-10-27 10:34:17
    软件体系结构--------作业
  • (1)理解基于事件的隐式调用软件体系结构、层次软件体系结构的原理 (2)掌握事件的隐式调用软件体系结构、层次软件体系结构的实例 (3)事件的隐式调用软件体系结构、层次软件体系结构的编程实现 实现内容 2....

    实验内容截取

    实验目的

    (1)理解基于事件的隐式调用软件体系结构、层次软件体系结构的原理

    (2)掌握事件的隐式调用软件体系结构、层次软件体系结构的实例

    (3)事件的隐式调用软件体系结构、层次软件体系结构的编程实现

    实现内容

    2.层次软件体系结构

    基于层次软件体系结构的软件测试系统。

    第一层为用户图形界面层

    public class TestingGUI extends JPanel {
    	private JTextArea txtTestInfo, txtTestcase;
    	private JLabel lblTestcases;
    	private JPanel buttonPanel;
    	private JComboBox cmbTestcases;
    
    	private static final String CASE_BUBBLE = "TC1-Test Bubble Sort";
    	private static final String CASE_HEAP = "TC2-Test Heap Sort";
    	private static final String CASE_INSERTION = "TC3-Test Insertion Sort";
    	private static final String EXECUTE = "Execute";
    	private static final String EXIT = "Exit";
    
    	public TestingGUI() {
    		txtTestInfo = new JTextArea("Test output from source shown here\n", 6, 20);
    		txtTestInfo.setLineWrap(true);
    		txtTestcase = new JTextArea("Testcase info and test validation shown here\n", 4, 15);
    		txtTestcase.setLineWrap(true);
    		buildUpScrollGUI();
    	}
    
    	private void buildUpScrollGUI() {
    		setUpButtonPanel();
    		JScrollPane btnPane = new JScrollPane(buttonPanel);
    		JScrollPane textPane = new JScrollPane(txtTestcase);
    		textPane.setMinimumSize(new Dimension(250, 150));
    		JScrollPane testDataPane = new JScrollPane(txtTestInfo);
    
    		JSplitPane upSplitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT);
    		upSplitPane.setLeftComponent(btnPane);
    		upSplitPane.setRightComponent(testDataPane);
    		JScrollPane downPane = new JScrollPane(textPane);
    
    		Dimension minimumSize = new Dimension(130, 100);
    		btnPane.setMinimumSize(minimumSize);
    		textPane.setMinimumSize(new Dimension(100, 100));
    		upSplitPane.setDividerLocation(270);
    		upSplitPane.setPreferredSize(new Dimension(500, 300));
    
    		JSplitPane bigSplitPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT, upSplitPane, downPane);
    		bigSplitPane.setDividerLocation(190);
    
    		add(bigSplitPane);
    		setSize(new Dimension(500, 400));
    		setVisible(true);
    	}
        
        // ......
        // ......
        // 略 
    }

    还有其他一些代码,我这里就不放出来了。。。

    效果图和功能

    选择排序算法,点击Execute,会随机生成指定长度的序列。并使用指定的排序算法进行排序。输出排序后的序列,排序耗时等信息。

    这是软件体系结构这门课程的一个实验作业。给出例程的目的原本是让我们调试程序,从而理解程序隐含的软件体系结构。😂我比较强迫症,看着这多多少少有点毛病的代码,想把它改成自己满意的样子。至于软件体系结构嘛,随便吹一吹水。。。。😂

    例程的问题

    (1)每一个Testcase的实现类的代码存在大量的重复

    (2)随机生成序列、排序、校验排序结果3个操作都是耗时操作,然而这3个操作都以同步的方式放在主线程中。当数据量较大,经我测试,当数组元素个数为10万时,点击一次执行,会造成较长时间的阻塞。当快速多次点击执行,程序崩溃,界面卡住不动。

    优化方案

    (1)将重复代码抽离出来放到父类,只需要将实例化算法对象的操作交由子类实现即可。

    (2)每一次execute操作都有独立的线程异步操作。然而这时会遇到两个问题:

    ①异步线程何时返回结果,返回的结果如何更新到界面?

       通过事件回调的方式,解决异步线程的结果返回。

    ②当多次点击execute后,多个线程异步操作。当某个线程已经完成,从而回调到界面,正在在界面渲染数据,此时又一个线程完成,同时又向界面渲染数据。界面的耗时渲染,让我们看到了多线程并发的界面数据错乱现象。

       只需要将渲染界面的操作放在同步代码块之内即可

    修改后的代码

    我只贴出我有更改的类的代码。

    Testcase

    package demo2.test;
    
    public interface Testcase {
    	
    	void execute(int len, EventCallback callback);
    	
    	interface EventCallback {
    		/**
    		 * 包含了3个操作:生成指定长度的随机数列,排序,校验排序结果是否正确
    		 * @param sortedArr		排序好的数组
    		 * @param costTime		排序所花费的时间(不包括生成随机数列的时间和校验排序结果的时间)
    		 * @param isCorrect		排序结果是否正确
    		 */
    		void onExecuted(int[] sortedArr, long costTime, boolean isCorrect);
    	}
    }

    AlgorithmTestCase

    package demo2.test;
    
    import demo2.IntegerArrGenerator;
    import demo2.ResultVerification;
    import demo2.algorithm.SortAlgorithm;
    
    /**
     * Testcase接口的实现类,但是个抽象类。
     * 实例化算法对象的操作通过抽象方法抛给子类实现
     * 
     * @author	passerbyYSQ
     * @date	2020-9-15 20:47:09
     */
    public abstract class AlgorithmTestCase<T extends SortAlgorithm> implements Testcase {
    	
    	protected T algorithm;
    	protected Context context;
    	
    	protected abstract T crateAlgorithm();
    	
    	@Override
    	public void execute(int len, EventCallback callback) {
    		Thread th = new Thread(new GenerateAndSortInt(len, callback));
    		th.start();
    	}
    
    	class GenerateAndSortInt implements Runnable {
    		long startTime;
    		long timeTaken = 0;
    		int len;
    		int[] arr;
    		EventCallback callback;
    		
    		public GenerateAndSortInt(int len, EventCallback callback) {
    			this.len = len;
    			this.callback = callback;
    		}
    		
    		@Override
    		public void run() {
    			// 耗时
    			arr = IntegerArrGenerator.generateInput(len);
    
    			algorithm = crateAlgorithm();
    			context = new Context(algorithm);
    			
    			// 排序。耗时
    			startTime = System.currentTimeMillis();
    			arr = context.sortIntArray(arr);
    			long costTime = System.currentTimeMillis() - startTime;
    			
    			// 校验排序结果。耗时
    			boolean isCorrect = ResultVerification.isResultCorrect(arr);
    			
    			callback.onExecuted(arr, costTime, isCorrect);
    		}
    	}
    
    }
    

    TestcaseBubble

    package demo2.test;
    
    import demo2.algorithm.BubbleSort;
    
    public class TestcaseBubble extends AlgorithmTestCase<BubbleSort> {
    
    	@Override
    	protected BubbleSort crateAlgorithm() {
    		return new BubbleSort();
    	}
    	
    }
    

    TestcaseHeap

    package demo2.test;
    
    import demo2.algorithm.HeapSort;
    
    public class TestcaseHeap extends AlgorithmTestCase<HeapSort> {
    
    	@Override
    	protected HeapSort crateAlgorithm() {
    		return new HeapSort();
    	}
    
    }
    

    TestcaseInsertion

    package demo2.test;
    
    import demo2.algorithm.InsertSort;
    
    public class TestcaseInsertion extends AlgorithmTestCase<InsertSort> {
    
    	@Override
    	protected InsertSort crateAlgorithm() {
    		return new InsertSort();
    	}
    
    }
    

    TestingGUI

    package demo2;
    
    import java.awt.Dimension;
    import java.awt.GridBagConstraints;
    import java.awt.GridBagLayout;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    import java.awt.event.KeyEvent;
    
    import javax.swing.JButton;
    import javax.swing.JComboBox;
    import javax.swing.JFrame;
    import javax.swing.JLabel;
    import javax.swing.JPanel;
    import javax.swing.JScrollPane;
    import javax.swing.JSplitPane;
    import javax.swing.JTextArea;
    
    import demo2.test.Testcase;
    import demo2.test.Testcase.EventCallback;
    import demo2.test.TestcaseBubble;
    import demo2.test.TestcaseHeap;
    import demo2.test.TestcaseInsertion;
    
    public class TestingGUI extends JPanel {
    	private JTextArea txtTestInfo, txtTestcase;
    	private JLabel lblTestcases;
    	private JPanel buttonPanel;
    	private JComboBox cmbTestcases;
    
    	private static final String CASE_BUBBLE = "TC1-Test Bubble Sort";
    	private static final String CASE_HEAP = "TC2-Test Heap Sort";
    	private static final String CASE_INSERTION = "TC3-Test Insertion Sort";
    	private static final String EXECUTE = "Execute";
    	private static final String EXIT = "Exit";
    
    	public TestingGUI() {
    		txtTestInfo = new JTextArea("Test output from source shown here\n", 6, 20);
    		txtTestInfo.setLineWrap(true);
    		txtTestcase = new JTextArea("Testcase info and test validation shown here\n", 4, 15);
    		txtTestcase.setLineWrap(true);
    		buildUpScrollGUI();
    	}
    
    	private void buildUpScrollGUI() {
    		setUpButtonPanel();
    		JScrollPane btnPane = new JScrollPane(buttonPanel);
    		JScrollPane textPane = new JScrollPane(txtTestcase);
    		textPane.setMinimumSize(new Dimension(250, 150));
    		JScrollPane testDataPane = new JScrollPane(txtTestInfo);
    
    		JSplitPane upSplitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT);
    		upSplitPane.setLeftComponent(btnPane);
    		upSplitPane.setRightComponent(testDataPane);
    		JScrollPane downPane = new JScrollPane(textPane);
    
    		Dimension minimumSize = new Dimension(130, 100);
    		btnPane.setMinimumSize(minimumSize);
    		textPane.setMinimumSize(new Dimension(100, 100));
    		upSplitPane.setDividerLocation(270);
    		upSplitPane.setPreferredSize(new Dimension(500, 300));
    
    		JSplitPane bigSplitPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT, upSplitPane, downPane);
    		bigSplitPane.setDividerLocation(190);
    
    		add(bigSplitPane);
    		setSize(new Dimension(500, 400));
    		setVisible(true);
    	}
    
    	private void setUpButtonPanel() {
    		lblTestcases = new JLabel("Test Cases:");
    		cmbTestcases = new JComboBox();
    		cmbTestcases.addItem(CASE_BUBBLE);
    		cmbTestcases.addItem(CASE_HEAP);
    		cmbTestcases.addItem(CASE_INSERTION);
    
    		// Create the open button
    		JButton executeBtn = new JButton(EXECUTE);
    		executeBtn.setMnemonic(KeyEvent.VK_S);
    		JButton exitButton = new JButton(EXIT);
    		exitButton.setMnemonic(KeyEvent.VK_X);
    
    		BtnListener objButtonHandler = new BtnListener();
    		// add action Listener
    		executeBtn.addActionListener(objButtonHandler);
    		exitButton.addActionListener(objButtonHandler);
    		buttonPanel = new JPanel();
    
    		GridBagLayout gridbag = new GridBagLayout();
    		buttonPanel.setLayout(gridbag);
    		GridBagConstraints gbc = new GridBagConstraints();
    
    		buttonPanel.add(lblTestcases);
    		buttonPanel.add(cmbTestcases);
    		buttonPanel.add(executeBtn);
    		buttonPanel.add(exitButton);
    		gbc.insets.top = 5;
    		gbc.insets.bottom = 5;
    		gbc.insets.left = 5;
    		gbc.insets.right = 5;
    
    		gbc.anchor = GridBagConstraints.EAST;
    		gbc.gridx = 0;
    		gbc.gridy = 0;
    		gridbag.setConstraints(lblTestcases, gbc);
    		gbc.anchor = GridBagConstraints.WEST;
    		gbc.gridx = 1;
    		gbc.gridy = 0;
    		gridbag.setConstraints(cmbTestcases, gbc);
    		gbc.anchor = GridBagConstraints.EAST;
    		gbc.insets.left = 2;
    		gbc.insets.right = 2;
    		gbc.insets.top = 25;
    		gbc.anchor = GridBagConstraints.EAST;
    		gbc.gridx = 0;
    		gbc.gridy = 7;
    		gridbag.setConstraints(executeBtn, gbc);
    		gbc.anchor = GridBagConstraints.WEST;
    		gbc.gridx = 1;
    		gbc.gridy = 7;
    		gridbag.setConstraints(exitButton, gbc);
    	}
    
    	public void showTestInfo(int[] str) {
    		txtTestInfo.setText("");
    		for (int n = 0; n < str.length; n++)
    			txtTestInfo.append("" + str[n] + " ");
    //		StringBuilder sbd = new StringBuilder("");
    //		for (int n = 0; n < str.length; n++) {
    //			sbd.append(str[n]).append(" ");
    //		}
    //		txtTestInfo.setText(sbd.toString());	
    	}
    
    	public void showText(String err) {
    		txtTestcase.append(err + "\n");
    	}
    
    	public String getSelectedTestcase() {
    		return (String) cmbTestcases.getSelectedItem();
    	}
    
    	/**
    	 * 实现了EventCallback接口。当异步线程执行完成,会回调到这里的 onExecuted()方法
    	 * @author	passerbyYSQ
    	 * @date	2020-9-15 20:56:02
    	 */
    	class BtnListener implements ActionListener, EventCallback {
    		private Testcase test;
    		private String selectedTestcase;
    
    		public void actionPerformed(ActionEvent e) {
    			
    
    			if (e.getActionCommand().equals(EXIT)) {
    				System.exit(1);
    			}
    			if (e.getActionCommand().equals(EXECUTE)) {
    				selectedTestcase = getSelectedTestcase();
    				
    				if (selectedTestcase.equals(CASE_BUBBLE))
    					test = new TestcaseBubble();
    				else if (selectedTestcase.equals(CASE_HEAP))
    					test = new TestcaseHeap();
    				else if (selectedTestcase.equals(CASE_INSERTION))
    					test = new TestcaseInsertion();
    				
    				test.execute(100000, this);
    			}
    		}
    
    		/**
    		 * 多线程并发问题:
    		 * 假如频繁操作,导致多个数组陆续排序好。前一个数组还没操作完界面,另一个数组
    		 * 又开始更新界面。会导致界面的数组输出错乱。
    		 *所以操作ui的方法需要加上synchronized限定
    		 */
    		@Override
    		public synchronized void onExecuted(int[] sortedArr, long costTime, boolean isCorrect) {
    			// 更新ui最好也不要使用主线程。
    			int[] output = sortedArr;
    			showTestInfo(output);
    			showText(selectedTestcase);
    			// 结果检验也是个费时操作,不应该放到ui更新里面做。否则会出现卡顿现象
    			showText("No Error found = " + isCorrect);
    			showText("Testing Time takes = " + costTime + "\n");
    		}
    	}
    
    	private static void createAndShowGUI() {
    		JFrame.setDefaultLookAndFeelDecorated(true);
    		JFrame frame = new JFrame("Layered Architecture- Software Testing");
    		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    		TestingGUI newContentPane = new TestingGUI();
    		newContentPane.setOpaque(true);
    		frame.setContentPane(newContentPane);
    		frame.pack();
    		frame.setVisible(true);
    	}
    
    	public static void main(String argv[]) {
    		javax.swing.SwingUtilities.invokeLater(new Runnable() {
    			public void run() {
    				createAndShowGUI();
    			}
    		});
    	}
    
    }
    

     

    展开全文
  • 软件设计模式与体系结构的课堂练习的一点小题目的资源
  • 软件体系结构》第三章 软件体系结构风格

    万次阅读 多人点赞 2018-07-01 13:56:42
    第三章 软件体系结构风格 一、基本概念 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和体系结构风格是互为补充的两种技术。

    展开全文
  • KWIC 软件体系结构

    2013-07-05 07:13:27
    软件体系结构作业,用了比较经典的KWIC系统,一步步让你体会到软件体系结构设计的重要性,由刚开始的面向过程,到面向对象,再到基于事件的系统,再到管道过滤器模式,系统的灵活性一步步提升,做完试验之后,还有...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 26,267
精华内容 10,506
关键字:

软件体系结构大作业

友情链接: ADS7843_CHINA.rar