精华内容
下载资源
问答
  • 经典软件体系结构风格(三)

    千次阅读 2017-05-09 21:27:40
    MVC 软件体系结构风格   #模型-视图-控制器风格常被简称为MVC风格  --组件:模型、视图、控制器  --连接件:显式调用、隐式调用、其他机制(例如:Http协议) #工作机制:  Model:  --...
     MVC 软件体系结构风格
     

    #模型-视图-控制器风格常被简称为MVC风格

      --组件:模型、视图、控制器

      --连接件:显式调用、隐式调用、其他机制(例如:Http协议)

    #工作机制:

     Model:

     --模型的职责

       1.负责数据存取

       2.负责业务逻辑实现

       3.负责数据验证

    #模型:模型是应用程序的核心。它封装内核数据与状态,对模型的修改将扩散到所有视图中。所有需要从模型获取信息的对象都必须注册为模型的视图。

     在事件驱动系统,当信息发生改变,模型通知观察者(observers) (通常是视图),从而引起视图反应。

    #View:

     视图的职责:

    –获取用户输入

    –向controller发送处理请求

    –接收来自Controller的反馈

    –将model的处理结果显示给用户

      一个model可能有多个View

    #Controller:

      控制器职责:

    –接收来自客户的请求

    –调用model执行

    –调用View显示执行结果

      控制器:控制器是提供给用户进行操作的接口。每个视图与一个控制器组件相关联。控制器接收用户的输入,通常是鼠标移动、键盘输入等。输入事件翻译成服务请求,送到模型或视图。用户只通过控制器与系统交互。

    #两个主要分离:

    –模型与界面分离

    –控制器与视图分离

    #优点:

    –将各方面问题分解开来考虑,简化了系统设计,保证了系统的可扩展性。

    –改变界面不影响应用程序的功能内核,使得系统易于演化开发,可维护性好。

    –同一信息可以有不同的展现方式。

    –业务逻辑更易测试


     # 案例



     代码:

    CarModel.java(模型层)

    package com.medel;
    import java.io.*;
    import java.net.URL;
    import java.net.URI;
    import javax.swing.*;
    
    import com.view.View;
    
    import java.util.*;
    
    public class CarModel{
        private String[] carNameList;
        private URL imgURL;
        private URL carFileUrl;
        private ImageIcon imgIcon;
    	private String carSelected;
        private String bitPrice;
        static final String CARFILES = "CarFiles/";
        static final String CARIMAGES = "CarImages/";
    
        public CarModel(){
            carNameList=new String[200];
      	}
        public void setCarList(String[] cars){
    		  carNameList = cars;
    	}
        public String[] getCarList(){
    	       return  carNameList;
        }
        public void setSelectedCar(String sCar){
            carSelected = sCar;
      	}
      	public String getSelectedCar(){
    	     return carSelected;
      	}
      	public void setBitPrice(String bPrice){
    		bitPrice = "";
    		bitPrice = bitPrice + bPrice;
    	}
    	public String getBitPrice(){
    			return bitPrice;
    	}
    	public void setupImageIcon(){
    		    String iconStr = CARIMAGES + carSelected+".jpg";
    	        imgIcon = createImageIcon(iconStr);
    		}
        public ImageIcon getImageIcon(){
    		    return imgIcon;
    	}
    	public void setCarFileURL(){
    	    try{
    		    String fileURLStr = CARFILES + carSelected+ ".html";
    		    URI uri = (new File(fileURLStr)).toURI();
    		    carFileUrl= uri.toURL();
    		}
    		catch (IOException e){
    		    e.printStackTrace();
    		}
    	}
    	public URL getCarFileURL(){
    		return carFileUrl;
    	}
    
        protected ImageIcon createImageIcon(String path){
           imgURL = getClass().getResource(path);
           if (imgURL != null) {
               return new ImageIcon(imgURL);
           } else {
               System.err.println("Couldn't find file: " + path);
               return null;
           }
       }
       public void tell(View view ){
    	   view.update();
       }
    } 
    

     视图层:

    View.java

    package com.view;
    
    public interface View {
      public abstract void update();
    }

    CarBitView.java

    package com.view;
    import java.awt.*;
    import javax.swing.*;
    import com.medel.CarModel;
    public class CarBitView extends JFrame implements View{
        private JPanel showPanel;
        private JLabel bitOfferedLabel;
        private JTextArea bitText;
        private CarModel model;
        
    	public CarBitView(CarModel cmodel) {
           super("Car Bit Info View- Observer 2");
           model = cmodel;
    
           bitOfferedLabel = new JLabel("Latest bit offered:");
           bitText = new JTextArea(4, 20);
           bitText.setFont(new Font("Serif", Font.PLAIN, 14));
           bitText.setLineWrap(true);
           bitText.setWrapStyleWord(true);
    
           Container contentPane = getContentPane();
           contentPane.add(bitOfferedLabel, BorderLayout.NORTH);
           contentPane.add(bitText, BorderLayout.CENTER);
    
           setSize(400, 150);
           setVisible(true);
         }
    
    	 public void update(){
           System.out.println("Car bit has been called.");
           String sCar= model.getSelectedCar();
           String pr = model.getBitPrice();
           bitText.append("\n Bit price for "+ sCar + "="+ pr);
         }
    }
    

    CarGUIView.java

    package com.view;
    import java.awt.*;
    import javax.swing.*;
    import java.io.*;
    import java.net.URL;
    import com.medel.CarModel;
    public class CarGUIView extends JFrame implements View{
       private JEditorPane editorPane;
       private JScrollPane imagePane;
       private JScrollPane textPane;
       private JSplitPane splitPane;
       private JLabel imgLabel;
       private CarModel model;
    
       public CarGUIView(CarModel cmodel){
          super("窗口1--车的信息");
    	  model = cmodel;
          buildUpScrollGUI();
       }
       private void buildUpScrollGUI(){
          imgLabel = new JLabel();
          imgLabel.setBackground(Color.green);
    	  imgLabel.setMinimumSize(new Dimension(250, 200));
    
          editorPane = new JEditorPane();
    	  editorPane.setEditable(false);
    
          imagePane = new JScrollPane(imgLabel);
    	  imagePane.getViewport().setBackground(Color.green);
    
    	  textPane = new JScrollPane(editorPane);
    	  textPane.setMinimumSize(new Dimension(250, 200));
    
    	  splitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT);
    	  splitPane.setLeftComponent(imagePane);
    	  splitPane.setRightComponent(textPane);
    
    	  Dimension minimumSize = new Dimension(130, 100);
    	  imagePane.setMinimumSize(minimumSize);
    	  textPane.setMinimumSize(new Dimension(100, 100));
    	  splitPane.setDividerLocation(160);
    	  splitPane.setPreferredSize(new Dimension(500, 300));
    
    	  Container contentPane = getContentPane();
    	  contentPane.add(splitPane);
    	  setSize(400, 150);
    	  setVisible(true);
       }
    
        public void update(){
           try{
    	      URL url = model.getCarFileURL();
              editorPane.setPage(url);
              System.out.println("We have been called.");
    	   }
    	   catch (IOException e){
    	      e.printStackTrace();
           }
           ImageIcon imIcon = model.getImageIcon();
           imgLabel.setIcon(imIcon);
    	   imgLabel.validate();
        }
    }
    

     控制层:

    Controller.java

    package com.control;
    import java.awt.event.*;
    import javax.swing.*;
    
    import com.medel.CarModel;
    import com.view.CarBitView;
    import com.view.CarGUIView;
    
    import java.net.URL;
    public class Controller implements ActionListener{
       private CarAuctionGUI objCarGui;
       private CarModel cm;
       private CarGUIView civ;
       private CarBitView cb;
       private String carPrice;
       private String[] carList;
    
       public Controller(CarAuctionGUI objCarGui,CarModel cm,
                         CarGUIView civ,CarBitView cb){
          this.objCarGui = objCarGui;
          this.cm=cm;
          this.civ=civ;
          this.cb=cb;
    
    	  carList = objCarGui.getCarList();
    	  cm.setCarList(carList);
       }
       public void actionPerformed(ActionEvent e){ 
          String searchResult = null;
    
          if (e.getActionCommand().equals(CarAuctionGUI.EXIT)){
             System.exit(1);
          }
          if (e.getActionCommand().equals(CarAuctionGUI.SEARCH)){
             String selectedCar = objCarGui.getSelectedCar();
             cm.setSelectedCar(selectedCar);
             cm.setCarFileURL();
             cm.setupImageIcon();
             cm.tell(civ);	//civ.update();
          }
          if (e.getActionCommand().equals(CarAuctionGUI.BIT)){
    	     carPrice = objCarGui.getBitPrice();
    		 cm.setBitPrice(carPrice);
             cm.tell(cb);		//cb.update();
    	  }
       }
    } 
    

    CarAuctionGUI.java

    package com.control;
    import java.awt.*;
    import javax.swing.*;
    import java.io.*;
    import java.awt.event.*;
    import com.medel.CarModel;
    import com.view.CarBitView;
    import com.view.CarGUIView;
    public class CarAuctionGUI extends JPanel {
       private JTextField bitInputText;
       private JLabel lblCarModel;
       private JPanel buttonPanel;
       private String[] carList;
       private JComboBox cmbCarList;
       private static CarModel cm;
       private static CarGUIView civ;
       private static CarBitView cb;
       public static final String SEARCH = "寻找";
       public static final String BIT = "确定";
       public static final String EXIT = "退出";
    
       public CarAuctionGUI(){
       	   super(new GridLayout(1,0));
    	   setUpGUI();
       }
       private void setUpGUI(){
          cmbCarList = new JComboBox();
          String[] cl = getCarList();
          setUpCarList(cl);
          lblCarModel = new JLabel("二手车种类及年份:");
    
          //Create the open button
          JButton srchButton = new JButton(SEARCH);
          srchButton.setMnemonic(KeyEvent.VK_S);
          JButton exitButton = new JButton(EXIT);
          exitButton.setMnemonic(KeyEvent.VK_X);
          JButton bitButton = new JButton(BIT);
          bitButton.setMnemonic(KeyEvent.VK_X);
          bitInputText = new JTextField("请输入你想要的价格:",12);
          buttonPanel = new JPanel();
    
          //****************************************************
          GridBagLayout gridbag = new GridBagLayout();
          buttonPanel.setLayout(gridbag);
          GridBagConstraints gbc = new GridBagConstraints();
    
          buttonPanel.add(lblCarModel);
          buttonPanel.add(cmbCarList);
          buttonPanel.add(srchButton);
          buttonPanel.add(bitButton);
          buttonPanel.add(exitButton);
          buttonPanel.add(bitInputText);
    
          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(lblCarModel, gbc);
          gbc.anchor = GridBagConstraints.WEST;
          gbc.gridx = 1;
          gbc.gridy = 0;
          gridbag.setConstraints(cmbCarList, 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 = 3;
          gridbag.setConstraints(srchButton, gbc);
          gbc.anchor = GridBagConstraints.WEST;
          gbc.gridx = 1;
          gbc.gridy = 3;
          gridbag.setConstraints(exitButton, gbc);
          gbc.gridx = 0;
    	  gbc.gridy = 4;
          gridbag.setConstraints(bitButton, gbc);
          gbc.gridx = 1;
    	  gbc.gridy = 4;
          gridbag.setConstraints(bitInputText, gbc);
          Controller objButtonHandler = new Controller(this,cm,civ,cb);
          srchButton.addActionListener(objButtonHandler);
          exitButton.addActionListener(objButtonHandler);
          bitButton.addActionListener(objButtonHandler);
    
          add(buttonPanel);
    	  setSize(new Dimension(800, 450));
          setVisible(true);
        }
    
        public String getSelectedCar() {
    	   return (String) cmbCarList.getSelectedItem();
    	}
    
    	public String getBitPrice(){
    	   return	bitInputText.getText();
    	}
    
    	// get the names of all the .html files in a directory
    	public String[] getCarList(){
    	   File f = new File("CarFiles");
    	   String [] fileNames = f.list();
    
    	   for(int i=0; i<fileNames.length; i++ ){
    	      int len = fileNames[i].length();
    		  fileNames[i]=fileNames[i].substring(0,len-5);
    	   }
    	   return fileNames;
       }
    
    	public void setUpCarList(String[] carList){
    	   for(int k=0; k<carList.length; k++) {
    	      cmbCarList.addItem(carList[k]);
    	   }
    	}
    
      private static void createAndShowGUI() {
         JFrame.setDefaultLookAndFeelDecorated(true);
         JFrame frame = new JFrame("MVC pattern demo");
         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    
         CarAuctionGUI newContentPane = new CarAuctionGUI();
         newContentPane.setOpaque(true);
         frame.setContentPane(newContentPane);
    
         //Display the window.
         frame.pack();
         frame.setVisible(true);
      }
    
      static public void main(String argv[]) {
    	 javax.swing.SwingUtilities.invokeLater(new Runnable() {
         public void run() {
    	    cm = new CarModel();
    	    civ= new CarGUIView(cm);
    	    cb = new CarBitView(cm);
            createAndShowGUI();
    	 }
          });
      }
    }
    



    展开全文
  • 经典软件体系结构风格(一)

    千次阅读 2017-03-13 18:23:17
    1.主程序-子程序软件体系结构  组件–主程序、子程序 连接件–调用-返回机制 拓扑结构–层次化结构 主程序-子过程风格的优点与缺点 §优点: –有效地将一个较复杂的程序系统设计任务分解成许多易于控制和...

    1.主程序-子程序软件体系结构   

    组件–主程序、子程序

    连接件–调用-返回机制

    拓扑结构–层次化结构

    主程序-子过程风格的优点与缺点

    §优点:

    –有效地将一个较复杂的程序系统设计任务分解成许多易于控制和处理的子任务,便于开发和维护–已被证明是成功的设计方法,可以被用于较大程序

    缺点:

    –规模:程序超过10万行,表现不好;程序太大,开发太慢,测试越来越困难

    –可重用性差、数据安全性差,难以开发大型软件和图形界面的应用软件

    –把数据和处理数据的过程分离为相互独立的实体,当数据结构改变时,所有相关的处理过程都要进行相应的修改

    –图形用户界面的应用程序,很难用过程来描述和实现,开发和维护也都很困难。


    *代码段一

    #include <iostream>
    using namespace std;
    int max(int x,int y)
    {
     int z;
     z=x>y?x:y;
     return (z);
    }
    int main()
    {
        int a,b,c;
        cin>>a>>b;
        c=max(a,b);
        cout<<"最大的数是:"<<c<<endl;
        return 0;
    }


    *代码段二

    #include <iostream>
    using namespace std;
    int jie(int num)
    {
        int sum=1;
        for(int i=1; i<=num; i++)
        {
            sum*=i;
        }
        return sum;
    }
    int main()
    {
        int num;
        cin>>num;
        cout<<"num的阶乘是:"<<jie(num)<<endl;
        return 0;
    }
    

    2.数据抽象和面向对象体系结构

    组件是:类和对象

    连接件:对象之间通过功能与函数调用实现交互。

    OO风格优点

    §复用和维护:利用封装和聚合提高生产力

    –因为对象对其它对象隐藏它的表示,所以可以改变一个对象的表示,而不影响其它的对象。

    –某一组件的算法与数据结构的修改不会影响其他组件

    –组件之间依赖性降低,提高了复用度

    §反映现实世界

    §容易分解一个系统

    –设计者可将一些数据存取操作的问题分解成一些交互的代理程序的集合

    OO风格缺点

    §管理大量的对象:怎样确立大量对象的结构

    §继承引起复杂度,关键系统中慎用

    §必须知道对象的身份

    –为了使一个对象和另一个对象通过过程调用等进行交互,必须知道对象的标识。只要一个对象的标识改变了,就必须修改所有其他明确显式调用它的对象,并消除由此带来的一些副作用(例如,如果A使用了对象B,C也使用了对象B,那么,C对B的使用所造成的对A的影响可能是料想不到的)


    *代码段一

    class Spot{
    	private int x,y;
    	Spot(int u,int v){
    		setX(u);
    		setY(v);
    	}
    	public int getX() {
    		return x;
    	}
    	public void setX(int x) {
    		this.x = x;
    	}
    	public int getY() {
    		return y;
    	}
    	public void setY(int y) {
    		this.y = y;
    	}
    }
    class Trans{
    	void move(Spot p,int h, int k){
    		p.setX(p.getX()+h);
    		p.setY(p.getY()+k);
    	}
    }
    public class Test {
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
          Spot s=new Spot(2, 3);
          System.out.println("s的坐标为:"+s.getX()+","+s.getY());
          Trans ts=new Trans();
          ts.move(s, 4, 5);
          System.out.println("移动后s的坐标为:"+s.getX()+","+s.getY());
    	}
    
    }

    *代码段二

    class reg{
    	private int length;
    	private int width;
    	public reg() {
    		super();
    		// TODO Auto-generated constructor stub
    	}
    	reg(int l,int w){
    	 setLength(l);
    	 setWidth(w);
    	}
    	public int getLength() {
    		return length;
    	}
    	public void setLength(int length) {
    		this.length = length;
    	}
    	public int getWidth() {
    		return width;
    	}
    	public void setWidth(int width) {
    		this.width = width;
    	}
    	int area(int l,int w){
    		int area;
    		area=l*w;
    		return area;
    	}
    }
    class regZhu{
    	  int Vol(reg R,int h){
    		int Vol;
    		Vol=R.getLength()*R.getWidth()*h;
    		return Vol;
    	}
    }
    public class Test { 
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
          reg R=new reg(5,6);
          int S=R.area(5, 6);
          System.out.println("长方形的面积为:"+S);
          regZhu RZ=new regZhu();
          int vol=RZ.Vol(R, 5);
          System.out.println("长方柱的体积为:"+vol);
    	}
    
    }
    


    展开全文
  • 经典软件体系结构风格(五)

    千次阅读 2017-05-29 16:33:35
    分布式软件体系结构风格(C/S,B/S)  1、 三层C/S结构 2、 三层B/S结构   三层C/S结构(3-Tier C/S Architecture) §第1层:用户界面GUI—表示层——客户机 §第2层:业务逻辑—功能层——应用服务器 §第3...
     分布式软件体系结构风格(C/S,B/S)  

    1、  三层C/S结构

    2、  三层B/S结构

     

    三层C/S结构(3-Tier C/S Architecture)

    §第1层:用户界面GUI—表示层——客户机

    §第2层:业务逻辑—功能层——应用服务器

    §第3层:数据库—数据层——数据库服务器

    基本组件:

    –数据库服务器

    • 存放数据的数据库、负责数据处理的业务逻辑;

    –应用服务器

    • 业务逻辑:对数据进行处理;

    –客户机应用程序

    • GUI:用户界面

    §连接件:经由网络的调用-返回机制或隐式调用机制

    –客户机ßà应用服务器:客户机向应用服务器发送请求,并接收返回结果。

    –应用服务器ßà数据服务器:应用服务器向数据服务器发送请求,并接收返回结果。

    表示层:

    §应用的用户接口部分,担负着用户与应用之间的对话功能;

    §检查用户从键盘等输入的数据,显示应用输出的数据;检查的内容也只限于数据的形式和取值的范围,不包括有关业务本身的处理逻辑。

    §为使用户能直观地进行操作,通常使用图形用户界面GUI ,操作简单、易学易用;

    §在变更时,只需要改写显示控制和数据检查程序,而不影响其他层;

    §不包含或包含一部分业务逻辑。

    功能层:

    §应用系统的主体,包括大部分业务处理逻辑(通常以业务组件的形式存在,如JavaBean/EJB/COM等);例如,在制作订购合同时要计算合同金额,按照定好的格式配置数据、打印订购合同。

    §从表示层获取用户的输入数据并加以处理;

    §处理过程中需要从数据层获取数据或向数据层更新数据;

    §处理结果返回给表示层。

    §用户检索数据时,要设法将有关检索要求的信息一次性地传送给功能层,而由功能层处理过的检索结果数据也一次性地传送给表示层。

    §通常,在功能层中包含有确认用户对应用和数据库存取权限的功能以及记录系统处理日志的功能。

    数据层:

    §数据库管理系统DMBS,负责管理对数据库数据的读写;

    §接受功能层的数据查询请求,执行请求,并将查询结果返回给功能层;

    §从功能层接受数据存取请求,并将数据写入数据库,请求的执行结果也要返回给功能层。

    §数据库管理系统必须能迅速执行大量数据的更新和检索。现在的主流是关系型数据库管理系统,因此,一般从功能层传送到数据层的要求大都使用SQL语言。

    优点:

    §在用户数目较多的情况下,三层C/S结构将极大改善性能与灵活性(通常可支持数百并发用户,通过集群可达数万并发用户);

    §允许合理地划分三层结构的功能,使之在逻辑上保持相对独立性,能提高系统和软件的可维护性和可扩展性——UI、BL、DB可以分别加以复用

    §允许更灵活有效地选用相应的平台和硬件系统,使之在处理负荷能力上与处理特性上分别适应于结构清晰的三层; 并且这些平台和各个组成部分可以具有良好的可升级性和开放性。

    §应用的各层可以并行开发,可以选择各自最适合的开发平台和开发语言。

    §利用功能层有效地隔离开表示层与数据层,未授权的用户难以绕过功能层而非法的访问数据层,为严格的安全管理奠定了坚实的基础。

    §将遗留系统(旧版本的系统)移植到三层C/S下将非常容易;

    缺点:

    §三层C/S结构各层间的通信效率若不高,即使分配给各层的硬件能力很强,其作为整体来说也达不到所要求的性能。

    §设计时必须慎重考虑三层间的通信方法、通信频度及数据量,这和提高各层的独立性一样是三层C/S结构的关键问题——分层风格的固有缺点。


     客户端程序 : tcpServer.java
    import java.io.*;
    import java.net.*;
    public class tcpServer {
     	public static final int PORT=8888;
     	public static void main(String[] args) throws IOException{
      	  //建立ServerSocket
      	  ServerSocket s=new ServerSocket(PORT);
      	  System.out.println("ServerSocket:"+s);
      	  try{
      	    /*程序阻塞,等待连接。即直到有一个客户请求到达,程序方能继续执行*/
            Socket ss=s.accept();
            System.out.println("Socket accept:"+ss);
            try {
    	      //连接成功,建立相应的I/O数据流
              DataInputStream dis=new DataInputStream(ss.getInputStream());
              DataOutputStream dos=new DataOutputStream(ss.getOutputStream());
    	  	  //在循环中,与客户机通信
          	  while(true){
                String str=dis.readUTF();	//从客户机中读数据
            	if(str.equals("end"))break;	//当读到end时,程序终止
            	System.out.println(str);
           		dos.writeUTF("Echoing:"+str);	//向客户机中写数据
          	  }
          	  dos.close();
          	  dis.close();
        	}finally{
          	  ss.close();
        	}
      	  }finally{
            s.close();
      	  }
     	}
    }

    客户机端程序 tcpClient.java

    import java.io.*;
    import java.net.*;
    public class tcpClient {
    public static void main(String[] args) throws IOException{
    //建立Socket,服务器在本机的8888端口处进行“侦听”
    Socket ss=new Socket("127.0.0.1",8888);
    System.out.println("Socket:"+ss);
    try{
    //套接字建立成功,建立I/O流进行通信
    DataInputStream dis=new DataInputStream(ss.getInputStream());
    DataOutputStream dos=new DataOutputStream(ss.getOutputStream());
    for(int i=0;i<6;i++){
              dos.writeUTF("测试:"+i);	//向服务器发数据
              dos.flush();			//刷新输出缓冲区,以便立即发送
              System.out.println(dis.readUTF());	//将从服务器接收的数据输出
    }
    dos.writeUTF("end");		//向服务器发送终止标志
    dos.flush();				//刷新输出缓冲区,以便立即发送
    dos.close();
    dis.close();
    }finally{
    ss.close();
          }
        }
    }

    B/S三层架构

    浏览器/服务器(B/S)是三层C/S风格的一种实现方式

    –表现层:浏览器

    –逻辑层:• Web服务器• 应用服务器

    –数据层:数据库服务器

    基本组件:

    –数据库服务器• 存放数据的数据库、负责数据处理的业务逻辑;

    –Web服务器/应用服务器• 业务逻辑:对数据进行处理;• 客户端应用程序以网页形式存放于Web服务器上;

    –浏览器• 在客户端上的浏览器中键入相应的网址

    连接件:经由网络的调用-返回机制或隐式调用机制

    –浏览器ßàWeb服务器/应用服务器:浏览器向Web服务器/应用服务器发送请求,并接收返回结果。

    –Web服务器/应用服务器ßà数据服务器: Web服务器/应用服务器向数据服务器发送请求,并接收返回结果。

    优点:

    基于B/S体系结构的软件,系统安装、修改和维护全在服务器端解决,系统维护成本低:

    –客户端无任何业务逻辑,用户在使用系统时,仅仅需要一个浏览器就可运行全部的模块,真正达到了“零客户端”的功能,很容易在运行时自动升级。

    –良好的灵活性和可扩展性:对于环境和应用条件经常变动的情况,只要对业务逻辑层实施相应的改变,就能够达到目的。

    § B/S体系结构还提供了异种机、异种网、异种应用服务的联机、联网、统一服务的最现实的开放性基础。

    §较好的安全性:在这种结构中,客户应用程序不能直接访问数据,应用服务器不仅可控制哪些数据被改变和被访问,而且还可控制数据的改变和访问方式。

    §三层模式成为真正意义上的“瘦客户端”,从而具备了很高的稳定性、延展性和执行效率。

    §三层模式可以将服务集中在一起管理,统一服务于客户端,从而具备了良好的容错能力和负载平衡能力。

    §扩大了组织计算机应用系统功能覆盖范围,可以更加充

    分利用网络上的各种资源,同时应用程序维护的工作量也大大减少

    – B/S结构出现之前,管理信息系统的功能覆盖范围主要是组织内部。

    – B/S结构“零客户端”方式使组织的供应商和客户(这些供应商和客户有可能是潜在的,也就是说可能是事先未知的)的计算机方便地成为管理信息系统的客户端,进而在限定的功能范围内查询组织相关信息,完成与组织的各种业务往来的数据交换和处理工作。

    § B/S结构的计算机应用系统与Internet的结合也使新近提出的一些新的企业计算机应用(如电子商务,客户关系管理)的实现成为可能。

    缺点:

    §客户端浏览器以同步的请求/响应模式交换数据,每请求一次服务器就要刷新一次页面;

    §受HTTP协议“基于文本的数据交换”的限制,在数据查询等响应速度上,要远远低于C/S体系结构;

    §数据提交一般以页面为单位,数据的动态交互性不强,不利于在线事务处理(OLTP)应用;

    §受限于HTML的表达能力,难以支持复杂GUI(如报表等)。


    程序:

    详见博客其他网页文章


    C/S+B/S混合体系结构:

    –混合原则一:“内外有别”的原则

    –混合原则二:“查改有别”的原则

    §混合原则一:“内外有别”的原则:

    –企业内部用户通过局域网直接访问数据库服务器

    • C/S结构;

    • 交互性增强;

    • 数据查询与修改的响应速度高;

    –企业外部用户通过Internet访问Web服务器/应用服务器

    • B/S结构;

    • 用户不直接访问数据,数据安全;

    § “内外有别”模型的缺点是企业外部用户修改和维护数据时,速度较慢,较繁锁,数据的动态交互性不强

    §混合原则二:“查改有别”的原则:

    –不管用户处于企业内外什么位置(局域网或Internet),凡是需要对数据进行更新(维护和修改数据)操作的(Add, Delete, Update),都需要使用C/S结构;

    –如果只是执行一般的查询与浏览操作(Read/Query),则使用B/S结构。

    § “查改有别”模型体现了B/S体系结构和C/S体系结构的共同优点。

    §但因为外部用户能直接通过Internet连接到数据库服务器,企业数据容易暴露给外部用户,给数据安全造成了一定的威胁。




    展开全文
  • 在仓库风格中,有两种不同的构件:中央数据结构说明当前状态,独立构件在中央数据存贮上执行,仓库与外构件间的相互作用在系统中会有大的变化。按控制策略的选取分类,可以产生两个主要的子类。若输人流中某类时间...

      在仓库风格中,有两种不同的构件:中央数据结构说明当前状态,独立构件在中央数据存贮上执行,仓库与外构件间的相互作用在系统中会有大的变化。按控制策略的选取分类,可以产生两个主要的子类。若输人流中某类时间触发进程执行的选择,则仓库是传统型数据库;另一方面,若中央数据结构的当前状态触发进程执行的选择,则仓库是黑板系统。

    这种风格的优点:

    (1)善于管理数据信息,适合大量数据的应用场合;

    (2)适用于复杂的逻辑系统;

    (3)黑板系统模型能更容易地处理任务间的协作,系统更加灵活。数据库系统一直得到广泛应用,如企业中使用的管理信息系统、ERP软件等;黑板系统主要应用在需要复杂翻译解释的系统中,如信号处理领域中的语音和模式识别。

     

     

    转载于:https://www.cnblogs.com/stopfalling/p/5429034.html

    展开全文
  • 经典软件体系结构风格及DSSA

    万次阅读 2006-02-16 17:20:00
    软件体系结构风格是描述某一特定应用领域中系统组织方式的惯用模式(idiomatic paradigm)。体系结构风格定义了一个系统家族,即一个体系结构定义了一个词汇表和一组约束。词汇表中包含一些构件和连接件类型,而这组...
  • 软件体系结构风格

    千次阅读 2017-06-28 13:52:56
    原文地址 首先,我们需要先明确一个概念,什么叫软件体系结构的风格?定义便是:描述某一特定应用领域中系统组织方式的惯用。即,定义了用于描述系统的术语表和一组指导构建... (一)经典软件体系结构风格  1.
  • 文章目录一、引言:类比建筑风格二、软件体系结构风格 一、引言:类比建筑风格 例子: 像是中国古代的榫卯结构,像是脑海中体育馆和游泳馆的刻板映像 风格的定义: 具有良好的可行性、性能和实用性,可以直接用来...
  • 《软件体系结构》第三章 软件体系结构风格

    万次阅读 多人点赞 2018-07-01 13:56:42
    第三章 软件体系结构风格 一、基本概念 1. 软件体系结构设计的一个核心问题是能否使用重复的体系结构模式,即能够达到体系结构级的复用。 2. 软件体系结构风格是描述某一特定应用领域中系统组织方式的惯用模式。...
  • Chapter 3 软件体系结构风格1. 软件体系结构风格概述:●软件体系结构设计的一个核心问题是能否使用重复的体系结构模式,即能否达到体系结构级的软件重用。●软件体系结构风格是描述某一特定应用领域中系统组织方式...
  • 软件体系结构风格介绍

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

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

    千次阅读 2019-04-19 11:53:41
    软件体系结构风格(Software ArchitectureStyle)是描述软件系统组织方式的常用模式,在实践中已经被多次应用。按照Shaw和Garlan的说法,"一种体系结构风格定义了构件类型和连接件类型的词汇表,以及它们如何组合的...
  • 几种软件体系结构风格分析 文对传统的软件体系结构和新型的软件体系结构做了比较详细的分析。阐明了各种结构的优点.同时也指出丁存在的问题和不足。
  • 软件体系结构风格研究分析 软件体系结构风格研究分析了各种风格的特点优缺点最 后重点介绍了三层 C/S 软件体系结构 20 世纪 60 年代中期的软件危机使得人们开始重视软件工程的 研究起初人们把软件设计的重点放在数据...
  • 软件体系结构风格 教学用的课件软件体系结构风格 教学用的课件
  • 软件体系结构风格 ppt

    2010-09-10 16:21:06
    软件体系结构风格的参考资料,非常有价值,值得一看
  • 针对现有软件体系结构风格定义在客观性和全面性方面存在的不足,从客观角度出发,站在软件工程的高度从多个方面对软件体系结构风格进行定义;同时通过研究分析软件体系结构风格的研究现状,发现并指出其四个重点研究...
  • 1、什么是体系结构风格 2、常见的体系结构风格 3、Pipes and Filters 4、Data Abstraction and Object-Oriented Organization 5、Event-Based Implicit Invocation 6、Layered systems 7、Repositories 8、...
  • 这是软件体系结构风格——管道过滤器的专题课件,内容典型
  •  一、软件体系结构风格分析  最初的软件体系结构是Mainframe结构——客户、数据和程序都被集中在主机上,通常只有少量的GUI界面,对远程数据库的访问比较困难。随着PC的广泛应用,该结构逐渐被淘汰。在20世纪80...
  • 一、概述 软件体系结构表示系统的框架结构,用于从较高的层次上来描述各部分之间的关系和接口,主要包括构件、构件性质和构件之间的关系。 通过使用软件体系结构,...由此,产生了软件体系结构风格的概念。 ...
  • 软件体系结构 消息总线风格 文档管理

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 34,821
精华内容 13,928
关键字:

经典软件体系结构风格