软考-软件评测师：知识点整理（七）——软件工程

1 软件需求

（1） 业务需求：高层目标，比如减少财务工作量、提升了多少倍工作效率。

（2） 用户需求：用户想要什么，比如要能查缴费记录。

（3） 功能需求：系统具体做什么，比如登录验证，查询欠费金额。

（4） 质量需求 ：做得怎么样，包含性能需求，比如支付安全不泄露信息、页面3秒内打开。

（5） 系统需求：技术详细说明，把用户需求具体怎么实现讲出来，比如用户输入学号，系统返回该用户所有成绩，按学科排序。

（6） 设计约束：用什么技术/环境，比如必须使用Java开发，数据库必须使用mysql。

2 软件工程流水线

（1） 需求分析 ->结构化分析SA->输出：DFD数据流图、数据字典

（2） 概要设计 ->结构化设计SD->输出：模块结构图SC（结构图）

（3） 详细设计->程序流程图、盒图、PAD图（问题分析图，树型二维结构）

（4）如果有，外部设计评审，在这一阶段进行。（概要设计、详细设计之后）

（5）编码、测试、维护

3 详细设计任务

（1）对每个模块进行详细的算法设计

（2）对模块内的数据结构进行设计

（3）对数据库进行物理设计

（4）代码设计、输入输出设计、用户界面设计

（5）编写详细设计说明书

（6）评审

4 面向对象系统分析

5 软件工程三要素

三要素：

（1）方法：完成软件开发的各项任务的技术方法。如结构化方法、面向对象方法、瀑布模型思想。

（2）工具：运用方法提供的软件工程支持环境。辅助开发的软件。

（3）过程：为获得高质量的软件所需要完成的一系列任务框架。开发的步骤、流程。

6 类库、类属、函数库、框架

框架：framework，半成品应用+规则/骨架，定义了程序的整体流程和架构，如MVC，比如Spring、React、Vue。

函数库：function library，面向过程/结构化编程，一堆独立函数的集合。无类、无对象、无继承，可以直接调用的功能函数。比如C语言的stdio.h里面的printf等。

类库：class library，面向对象，以静态或动态的连接方式，为应用程序提供类、属性、方法，一堆预定义的类。比如主动用类和对象。

类属：generic/template，也叫泛型，是类/函数的模板，实现参数多态，让类/函数能适配多种数据类型，不用重复写代码。模板≠具体类，编译时才生成具体类，比如C++的template <typename T>，如下代码。

cpp 复制代码

#include <vector>
#include <stdexcept>

template <typename T>
class Stack {
private:
   std::vector<T> elems;

public:
   void push(const T& elem) {
       elems.push_back(elem);
  }
   void pop() {
       if (elems.empty())
           throw std::out_of_range("Stack<>::pop(): empty stack");
       elems.pop_back();
  }
   T top() const {
       if (elems.empty())
           throw std::out_of_range("Stack<>::top(): empty stack");
       return elems.back();
  }
   bool empty() const {
       return elems.empty();
  }
   size_t size() const {
       return elems.size();
  }
};
//使用
Stack<int> intStack;
intStack.push(10);
std::cout << intStack.top(); // 输出 10

7 基于构建的开发

基于构件的开发 ：利用现有组件拼接软件 。Component-Based Software Engineering，CBSE。有很多螺旋模型的特点，本质上是演化模型，需要以迭代方式构建软件。

构件：可以是组织内部开发，也可以是商品化的软件构件。成本比较高。

特点：

（1）组件是独立、可替换、可复用的模块。

（2）强调组装，不是从零开始开发。

（3）降低成本、缩短周期、提高可靠性。

8 设计模式

8.1 创建型模式（5种）

创建型模式：管怎么new对象、怎么生成实例，怎么让创建更灵活、更解耦。

8.1.1 单例模式Singleton

核心：全局只有一个实例，私有化构造。日志管理器、配置类、硬件驱动。

cpp 复制代码

#include <iostream>
using namespace std;

class Singleton {
private:
   static Singleton* ins;
   Singleton(){}  // 私有构造
public:
   static Singleton* getInstance() {
       if(!ins) ins = new Singleton();
       return ins;
  }
   void show(){ cout << "单例实例\n"; }
};
Singleton* Singleton::ins = nullptr;

int main(){
   Singleton* s1 = Singleton::getInstance();
   Singleton* s2 = Singleton::getInstance();
   cout << (s1 == s2) << endl; // 1 同一个对象
   s1->show();
   return 0;

8.1.2 工厂模式factory method

核心：定义创建接口，子类决定实例化哪个类。同一系列产品，不同子类生产。

cpp 复制代码

#include <iostream>
using namespace std;

// 产品
class Product {
public:
   virtual void use() = 0;
};
class Phone : public Product{
public:
   void use(){ cout << "使用手机\n"; }
};

// 工厂基类
class Factory{
public:
   virtual Product* create() = 0;
};
class PhoneFactory : public Factory{
public:
   Product* create(){ return new Phone(); }
};

int main(){
   Factory* f = new PhoneFactory();
   Product* p = f->create();
   p->use();
   delete p; delete f;
   return 0;
}

8.1.3 抽象工厂abstract factory

核心：工厂方法升级，多产品类。整套产品组合。

cpp 复制代码

#include <iostream>
using namespace std;
class Phone{public: virtual void call()=0;};
class Headset{public: virtual void play()=0;};

class ApplePhone:public Phone{void call(){cout<<"苹果通话\n";}};
class AppleHeadset:public Headset{void play(){cout<<"苹果耳机\n";}};

class AbsFactory{
public:
   virtual Phone* createPhone()=0;
   virtual Headset* createHeadset()=0;
};
class AppleFactory:public AbsFactory{
   Phone* createPhone(){return new ApplePhone;}
   Headset* createHeadset(){return new AppleHeadset;}
};

8.1.4 建造者模式Builder

核心：复杂对象分步构建，拆分构造步骤。适合复杂对象，比如电脑、订单、报文。

cpp 复制代码

#include <iostream>
#include <string>
using namespace std;

class Computer{
public:
   string cpu, gpu;
   void show(){cout<<cpu<<" + "<<gpu<<endl;}
};
class Builder{
protected:
   Computer* pc;
public:
   Builder(){pc=new Computer;}
   virtual void buildCPU()=0;
   virtual void buildGPU()=0;
   Computer* getResult(){return pc;}
};
class GameBuilder:public Builder{
   void buildCPU(){pc->cpu="i9";}
   void buildGPU(){pc->gpu="RTX4090";}
};

int main(){
   Builder* b = new GameBuilder;
   b->buildCPU(); b->buildGPU();
   b->getResult()->show();
   return 0;
}

8.1.5 原型模式prototype

核心：克隆已有对象创建新对象，不new。适合对象创建成本高、配置重复。

cpp 复制代码

#include <iostream>
using namespace std;

class Prototype{
public:
   virtual Prototype* clone() = 0;
   virtual void info() = 0;
};
class Cat : public Prototype{
public:
   Prototype* clone(){ return new Cat(*this); }
   void info(){ cout << "一只小猫\n"; }
};

int main(){
   Cat* c1 = new Cat;
   Cat* c2 = (Cat*)c1->clone();
   c2->info();
   delete c1; delete c2;
   return 0;
}

8.2 结构型模式（7种）

结构型模式：管类和对象怎么组合、怎么搭架子，类怎么继承、组合，多个小功能拼成大结构。

8.2.1 适配器模式adapter

核心：接口转换，兼容老代码/第三方库。将一个类的接口适配成用户所期待的。一个适配允许通常因为接口不兼容而不能在一起工作的类在一起，做法是将类自己的接口包裹在一个已存在的类中。适合新旧接口不统一、硬件协议适配。

cpp 复制代码

#include <iostream>
using namespace std;

// 旧接口
class OldUSB{
public:
   void oldSend(){cout<<"旧USB传输\n";}
};
// 目标新接口
class NewUSB{
public:
   virtual void send()=0;
};
// 适配器
class USBAdapter:public NewUSB{
private:
   OldUSB* old;
public:
   USBAdapter(){old=new OldUSB;}
   void send(){old->oldSend();}
};

int main(){
   NewUSB* usb = new USBAdapter;
   usb->send();
   return 0;
}

8.2.2 桥接模式bridge

核心：抽象与现实解耦，抽象部分和实现部分分离，使它们都可以独立地变化，多维度独立扩展。适合跨平台、多设备+多功能组合。

cpp 复制代码

#include <iostream>
using namespace std;

// 实现维度：颜色
class Color{
public:
   virtual void paint()=0;
};
class Red:public Color{void paint(){cout<<"红色\n";}};

// 抽象维度：形状
class Shape{
protected:
   Color* c;
public:
   Shape(Color* col):c(col){}
   virtual void draw()=0;
};
class Circle:public Shape{
public:
   Circle(Color* col):Shape(col){}
   void draw(){cout<<"圆形 + "; c->paint();}
};

int main(){
   Color* r = new Red;
   Shape* cir = new Circle(r);
   cir->draw();
   return 0;
}

8.2.3 装饰器模式decorator

核心：动态给一个对象加额外的功能，不修改原类。通过创建一个包装对象，也就是装饰来包裹真实的对象。适合IO流、权限叠加、UI空间增强。

cpp 复制代码

#include <iostream>
using namespace std;

class Coffee{
public:
   virtual void drink()=0;
};
class SimpleCoffee:public Coffee{
   void drink(){cout<<"纯咖啡\n";}
};
// 装饰器
class CoffeeDecorator:public Coffee{
protected:
   Coffee* cof;
public:
   CoffeeDecorator(Coffee* c):cof(c){}
};
class Milk:public CoffeeDecorator{
public:
   Milk(Coffee* c):CoffeeDecorator(c){}
   void drink(){cof->drink(); cout<<"加牛奶\n";}
};

int main(){
   Coffee* c = new Milk(new SimpleCoffee);
   c->drink();
   return 0;
}

8.2.4 组合模式composite

核心：树形结构，统一处理单个对象和组合对象。适合菜单、文件目录、组织架构。

cpp 复制代码

#include <iostream>
#include <vector>
using namespace std;

class Component{
public:
   virtual void show()=0;
};
// 叶子
class Leaf:public Component{
   void show(){cout<<"叶子节点\n";}
};
// 容器
class Composite:public Component{
private:
   vector<Component*> list;
public:
   void add(Component* c){list.push_back(c);}
   void show(){for(auto& x:list)x->show();}
};

8.2.5 外观模式facade

核心：对外提供统一入口，隐藏复杂子系统。适合老旧复杂模块封装、接口简化。

cpp 复制代码

#include <iostream>
using namespace std;
class SubA{void a(){cout<<"子系统A\n";}};
class SubB{void b(){cout<<"子系统B\n";}};
// 外观类
class Facade{
private:
   SubA a; SubB b;
public:
   void run(){a.a(); b.b();}
};

8.2.6 享元模式flyweight

核心：共享小对象，重复不变的抽出来做共享对象，复用重复对象，减少内存开销。适合大量重复对象，比如文字、棋子、连接池。

cpp 复制代码

#include <iostream>
#include <map>
using namespace std;

class Flyweight{
public:
   virtual void use()=0;
};
class Chess:public Flyweight{
private:
   string color;
public:
   Chess(string c):color(c){}
   void use(){cout<<color<<"棋子\n";}
};
class Factory{
private:
   map<string,Flyweight*> mp;
public:
   Flyweight* get(string key){
       if(!mp[key]) mp[key]=new Chess(key);
       return mp[key];
  }
};

8.2.7 代理模式proxy

核心：为一个对象提供代理用来控制对象访问，增加前置/后置逻辑。适合远程调用、权限控制、缓存、延迟加载。

cpp 复制代码

#include <iostream>
using namespace std;

class Subject{
public:
   virtual void req()=0;
};
class RealSubject:public Subject{
   void req(){cout<<"真实业务请求\n";}
};
class Proxy:public Subject{
private:
   RealSubject* real;
public:
   void before(){cout<<"权限校验\n";}
   void req(){
       before;
       if(!real) real=new RealSubject;
       real->req();
  }
};

8.3 行为型模式（11种）

行为型模式：对象间怎么互动、通信、协作，方法怎么调用，算法怎么封装，消息怎么传递。

8.3.1 模版方法模式template method

核心：固定算法骨架，子类重写具体步骤。适合流程固定、步骤可制定。

cpp 复制代码

#include <iostream>
using namespace std;
class Template{
public:
   void run(){step1(); step2();}
   virtual void step1()=0;
   virtual void step2(){cout<<"默认步骤2\n";}
};
class Demo:public Template{
   void step1(){cout<<"自定义步骤1\n";}
};

8.3.2 命令模式command

核心：请求封装为对象，可撤销/排队/日志。适合按钮指令、操作回滚、宏命令。

cpp 复制代码

#include <iostream>
using namespace std;
class Command{public:virtual void exec()=0;};
class Light{public:void on(){cout<<"开灯\n";}};
class LightCmd:public Command{
private:
   Light* l;
public:
   LightCmd(Light* p):l(p){}
   void exec(){l->on();}
};

8.3.3 迭代器模式iterator

核心：统一遍历集合，隐藏内部结构。适合容器遍历、自定义数据结构。

cpp 复制代码

#include <iostream>
#include <vector>
using namespace std;
template<class T>
class Iterator{
private:
   vector<T>& v; int idx;
public:
   Iterator(vector<T>& vec):v(vec),idx(0){}
   bool hasNext(){return idx<v.size();}
   T next(){return v[idx++];}
};

8.3.4 观察者模式observer

核心：一对多，状态变化自动通知订阅者。适合消息推送、事件监听、Qt信号槽底层思想。

cpp 复制代码

#include <iostream>
#include <vector>
using namespace std;
class Observer{public:virtual void update()=0;};
class Subject{
private:
   vector<Observer*> obs;
public:
   void attach(Observer* o){obs.push_back(o);}
   void notify(){for(auto& x:obs)x->update();}
};

8.3.5 中介者模式mediator

核心：多对象解耦，通过中介通信。适合聊天室、模块中转、复杂多对象交互。

cpp 复制代码

#include <iostream>
using namespace std;
class Mediator;
class Colleague{
protected:
   Mediator* m;
public:
   Colleague(Mediator* me):m(me){}
};

8.3.6 备忘录模式memento

核心：在不破坏封装性的前提下捕获一个对象的内部状态，并在对象之外保存这个状态。这样就可以将对象恢复到原先保存的状态。保存对象状态，支持回滚。适合编辑器撤销、游戏存档。

cpp 复制代码

#include <string>
using namespace std;
class Memento{public:string state;};
class Originator{
public:
   string state;
   Memento* save(){
       Memento* m=new Memento;
       m->state=state;
       return m;
  }
   void rollback(Memento* m){state=m->state;}
};

8.3.7 解释器模式interpreter

核心：定义文法，解析自定义表达式。适合表达式计算、脚本解析、规则引擎。

8.3.8 状态模式state

核心：根据内部状态切换行为，消除大量if-else。适合订单状态、设备状态、有限状态机。

cpp 复制代码

#include <iostream>
using namespace std;
class State{public:virtual void handle()=0;};
class Context{
public:
   State* st;
   void setState(State* s){st=s;}
   void action(){st->handle();}
};

8.3.9 策略模式strategy

核心：算法独立，可自由切换。适合支付方式、排序算法、计价规则。

cpp 复制代码

#include <iostream>
using namespace std;
class Strategy{public:virtual void calc()=0;};
class Add:public Strategy{void calc(){cout<<"加法计算\n";}};
class Context{
private:
   Strategy* s;
public:
   void set(Strategy* st){s=st;}
   void exec(){s->calc();}
};

8.3.10 职责链模式chain of responsibility

核心：请求逐级传递，每个节点选择性处理。适合审批流、权限拦截、异常处理。

cpp 复制代码

#include <iostream>
using namespace std;
class Handler{
protected:
   Handler* next;
public:
   void setNext(Handler* h){next=h;}
   virtual void handle(int num)=0;
};

8.3.11 访问者模式visitor

核心：分离数据结构与数据操作。适合固定数据结构、频繁新增操作。

cpp 复制代码

class Element;
class Visitor{public:virtual void visit(Element*)=0;};
class Element{public:virtual void accept(Visitor*)=0;};

9 软件模型

（1） 瀑布模型：线性，按照顺序一步一步走，不能回头。编码完再测试，问题容易后期发现，修改成本高。

（2） V模型：左边开发，右边测试，每个阶段都有对应测试。适合需求明确的项目。

（3） 敏捷模型：快速迭代，测试全程参与。如果需求变得快，后续容易乱。

（4） 迭代增量模型：分多次小版本开发，每次迭代交付一部分功能。如果设计不好，后期架构容易乱。

（5） 演化模型：一开始需求没有定死，先做一个核心版本软件，一直修改迭代，直到满意。用户早起可以看到产品。原型模型、增量模型、迭代模型都属于演化模型这一大类。

（6） 螺旋模型 ：在演化模型的基础上，每个轮添加了"风险分析"。

每一阶段都重复：

（7） 原型模型：逐步演化成最终软件产品的过程，特别适用于对软件需求缺乏准确认识的情况。

（8） 喷泉模型：用于描述面向对象的开发过程，体现了面向对象开发的迭代和无间隙特征。一边做、一边改、一边回头（回头迭代，修改，补充）、一边往上喷（向前开发）。做设计的时候还可以改需求，写代码的时候还可以改设计。

（9） 快速应用开发模型 ：简称RAD，是一个增量型的软件开发过程模型，强调极短的开发周期，是瀑布模型的高速变种，通过大量可复用构件，采用基于构建的建造方法赢得了快速开发。流程是是业务建模开始，随后是数据建模、过程建模、应用程序生成、测试及交付。

（10） 管道-过滤器模式 ：把复杂处理拆成一串独立小模块（过滤器），数据像水流一样经过管道，依次处理，最后输出结果。数据流驱动，过滤器相互独立。高内聚、低耦合；多过滤器简单合成；功能模块重用；便于维护；支持特定分析；支持并行操作；导致系统成批处理；需要协调数据流；性能下降，实现复杂**。**

10 极限编程XP

极限编程XP：激发开发人员创造性、是的管理负担最小的一组。由价值观、原则、实践和行为四部分组成。有四个价值观，即沟通、简单性、反馈和勇气。由五个大原则，即快速反馈、简单性假设、逐步修改、提倡更该和优质工作。

12个最佳实践：规划策略（计划游戏）、小型发布、隐喻、简单设计、测试先行、重构、结对编程、集体代码所有制、持续集成、每周工作四十小时、现场客户、编码标准。

Pair Programming：结对编程，指的是两名程序员共同使用一台计算机，一起编写代码，其中一名程序员负责编写代码，另一名程序员则负责对代码进行审查和提供实时反馈。

11 水晶法Crystal

按照项目规模和关键程度，灵活裁剪流程和纪律，强调人>流程>工具，每一个项目都需要不同的策略、约定和方法论。

12 并列争球法Scrum

使用迭代的方法，把每30天一次的迭代成为一个冲刺，并按照需求的优先级实现产品多个自组织和自治小组并行地递增实现产品，协调是通过简短的日常情况会议进行。

Scrum活动：

（1） Sprint Retrospective冲刺回顾会议，是Scrum框架中的一个关键活动，在每个Sprint结束之后，团队成员会聚集在一起，对刚刚完成的Sprint进行总结和烦死，大家会讨论在这个Sprint中哪些地方做得好，哪些地方需要改进并且制定出相应的改进计划，以便让后续的Sprint能够更高效地进行。

（2） Daily Standup：每日站会，每天都会举行的一个简短会议，团队成员需要站着开会，以保证会议的高效性，在这个会议上，每个成员都要回答三个问题：自己昨天完成了什么工作、今天计划做什么工作以及在工作中遇到了哪些阻碍。通过这种方式团队成员可以及时了解彼此的工作进展情况，快速发现并解决问题。

（3） Sprint Review：冲刺评审会议，在sprint结束时召开的会议，目的是让团队向利益相关者展示这个在Sprint中完成的工作成果。利益相关者可以对这些成果进行评估，提出反馈意见和建议。团队会根据这些反馈来调整产品的Backlog，为下一个Sprint做好准备。

13 Jackson系统开发方法

Jackson系统开发方法：面向数据结构的分析和设计方法，以活动为中心，一连串活动的顺序组合成一个完整的工程进程。全称为Jackson Structure Programing（JSP），后期扩展为JSD（Jackson System Development）。

Jackson图：只有三种基本结构，包括顺序、选择、重复。

JSP五步流程：

（1）画输入、输出的数据结构图（Jackson图）

（2）找出输入/输出中有对应关系的数据单元

（3）按规则导出程序结构图（按数据结构一一映射）

（4）列出所有的操作和条件，分配到结构图中对应的位置

（5）写成伪代码/程序

适用场景：输入/输出数据结构非常明确的中小型系统，比如报表、文件处理、简单批处理。

14 Booch方法

Booch方法：面相对象的软件开发方法。由Grady Booch提出，UML重要前身，核心是迭代+增量，有丰富的多视图建模（静态、动态、物理）。重视类图（抽象）和对象图（实例），既看宏观（模块/进程），也看微观设计（类内部）。，迭代螺旋，反复细化。

四大步骤：

（1） 标识类与对象：从问题域找概念，抽象为类或对象。

（2） 定义类/对象含义：确定属性和方法，职责。

（3） 标识关系：继承、关联、聚合、组合、消息交互

（4） 说明接口与实现：类的接口设计、内部实现、模块划分。

Booch的六种图（UML前身）：

（1） 静态模型（逻辑）：类图、对象图

（2） 动态模型：状态图、交互图（时序）

（3） 物理模型：模块图、进程图

15 自适应软件开发ASD

六个基本原则：

（1）在自适应软件开发中，有一个使命作为指导，它设立了项目的目标，但不描述如何达到这个目标

（2）特征被视为客户键值的关键，因此项目是围绕着构造的构建来组织并实现特征

（3）过程中的迭代是很重要的，因此重做与做同样重要，变化也包含其中

（4）变化不视为是一种更正，而是对软件开发实际情况的调整

（5）确定的交付时间被迫使开发人员认真考虑每一个生产版本的关键需求

（6）风险包含其中，它是开发人员首先跟踪最艰难的问题

16 JavaEE分层体系结构

17 结构化开发

结构化开发思想：自顶向下、逐步分解、模块化、面向过程。

对比：

面向对象：以对象/实体为核心。

结构化：以功能/流程为核心。

结构化开发三大阶段：

（1）结构化分析SA

（2）结构化设计SD

（3）结构化程序设计SP

17.1 结构化分析SA

结构化分析 ：Structured Analysis，SA。面向数据流、自顶向下、逐步求精 的需求分析方法，用来分析需求、建模系统的逻辑功能，不涉及怎么编程、怎么设计模块结构。主要工具包括数据流图、数据字典、加工逻辑说明。核心是数据字典，只描述数据流、数据存储、加工内部的数据项和组合数据。基本思想是分解和抽象。包括三种图，实体联系（ER）图、数据流图、状态迁移（STD）图。

数据流图四大基础元素：

（1）数据流

（2）数据存储

（3）加工

（4）外部实体

结构化分析的产物：数据流图DFD（需求分析阶段）

内容：

（1） 自顶向下逐层分解系统

（2）使用分层数据流图DFD描述数据流动、处理逻辑

（3）用数据字典DD定义所有数据流、数据项、数据存储

（4）用**加工逻辑说明（结构化语言/判定表/判定树）**描述每个处理步骤

数据字典的4类条目：

（1） 数据流条目：给出了DFD中数据流的定义，通常列出该数据流的各组成数据像。

（2） 数据像条目：是组成数据流和数据存储的最小元素，是不可再分解的数据单位。

（3） 数据存储条目：对DFD中数据存储的定义。

（4） 基本加工条目：用来说明DFD中基本加工的处理逻辑。

17.2 结构化设计SD

设计：

（1） 概要设计（总体设计/体系结构设计）：划分系统模块；定义模块调用关系、接口；设计整体架构。

（2） 详细设计（过程设计、模块内部设计）：每个模块的内部流程；算法、步骤、变量、逻辑。

（3） 接口设计：模块与模块之间、系统与外部系统、用户与系统的交互规则，如通信协议。

（4） 数据设计：数据结构和数据存储。

核心：模块化设计与模块独立性。高内聚，低耦合。详细看 $内聚和耦合$ 。

结构化设计工具：

（1） 流程结构图（SC图）：模块层级、调用关系

（2） 流程图、N-S图、PAD图：详细设计逻辑

17.3 结构化程序设计SP

原则：

（1）不使用goto语句

（2）只用三种基本控制结构：顺序、选择、循环

特点：

（1）代码线性、流程清晰

（2）适合小型、流程固定的系统

（3）缺点：复用性差、维护难、不适合大型复杂项目

18 统一软件开发过程

统一软件开发过程：RUP，Rational Unified Process，是IBM Rational推出的一套重量级、迭代式、面向对象的软件工程框架。

用例驱动、架构为中心、迭代增量、四个阶段、九个核心工作流。

模型元素：角色（谁做）、制品（做什么）、活动（怎么做）、工作流（什么时候做）。

三大核心：

（1） 以用例驱动：Use-Case Driven，用例是需求的核心，全程驱动分析、设计、实现、测试，保证功能不跑偏。

（2） 以架构为中心：Architecture-Centric，早期先搭好稳定的系统架构，后续迭代都围绕这个架构展开。

（3） 迭代+增量开发：Iterative & Incremental，分成多次小迭代，每次都做一个"需求->设计->实现->测试"，每次都增加一点功能、解决最高风险，逐步长成最终系统。

四个阶段（生命周期）：

（1） 初始阶段 ：定目标、愿景、核心需求、可行性、大致成本；里程碑是生命周期目标。

（2） 细化阶段 ：定架构、解高风险、做详细计划；里程碑是生命周期架构。

（3） 构建阶段 ：增量实现所有功能、完成测试、准备交付；里程碑是初始运行能力。

（4） 移交阶段 ：部署、用户培训、上线、售后支持；里程碑是产品发布。

九个核心工作流：

（1） 6个工作流：业务建模、需求、分析与设计、实现、测试、部署

（2） 3个管理支持流：项目管理、配置与变更管理、环境

特点：

（1）比瀑布模型灵活、抗需求变更、风险暴露早。

（2）比敏捷更重，文档多、适合大型企业级项目；敏捷轻量、文档少、小团队迭代。

19 分布式架构

分布式架构导致接口数量的爆炸增加。

19.1 优点

（1）高性能、高吞吐

多台机器同时处理，支持大量并发用户

（2）可扩展性强

流量变大，直接加机器，不用重构整个系统

（3）高可用、容错性好

某一台机器挂了，其他机器可以顶上，系统不整体崩溃，容错和灾备能力

（4）资源合理利用

不同模块部署在不同服务器上，按需分配，不浪费资源

（5）模块解耦，便于维护

业务拆分成独立的服务，修改一个模块不影响其他模块

（6）支持异地多活

可以跨地部署，就近访问，提升用户体验

19.2 缺点

（1）由于信息资源分散，系统开发、维护和管理的标准、规范不易统一

（2）配置在不同地点的信息资源一般分数系统的各个子系统，不同子系统之间往往存在利益冲突，管理上协调有一定难度

（3）各地计算机系统工作条件与环境不一，不利于完全保密措施的统一实施

20 MVC模式框架

MVC模式框架：模型（Model）-视图（View）-控制器（Controller）。常用框架有Struts、Spring、ZF、.NET MVC等。

模型：实体与实体对象的业务逻辑，数据+业务逻辑 ，ER图、实体类、数据库表属于这一层，和数据打交道。可以提高可重复性、可维护性、降低耦合等优点。

视图：界面、页面，只负责显示不处逻辑。

控制器：之间调度、处理请求，用户点击按钮->控制器接收，调用模型拿数据，再把数据交给视图显示。

优点：耦合低、重用性高、生命周期成本低、部署快、可维护性高、有利于软件工程化管理。

缺点：

（1）没有明确的定义

（2）不适合小型、中等规模的应用程序

（3）增加系统结构和实现的复杂度

（4）视图与控制器间过于紧密的连接

（5）视图对模型数据的低效率访问

（6）一般高级的界面工具或构造器不支持该模式

Hibenate：不属于MVC模型框架，而是一种关系映射框架。

21 内聚和耦合

内聚：同一个模块内部，功能联系紧不紧，越转专一越好。

耦合：模块和模块之间，关系紧不紧，越独立越好。

目标：高内聚，低耦合。

内聚（从好->差）：

（1） 功能内聚（最好）：模块里面所有元素只完成一个功能。

（2） 顺序内聚：处理步骤必须按顺序，A的输出是B的输入。

（3） 通信内聚（信息内聚）：使用同一组数据，但功能不一定连续。

（4） 过程内聚：按照固定流程执行，但是数据不一定相关。比如，先登录->打印->退出。

（5） 时间内聚：因为同一时间段执行，放在一起，比如初始化一堆变量、模块启动时候做的事情。

（6） 逻辑内聚：逻辑相似放在一起，但是功能没有关系。

（7） 偶然内聚（巧合内聚）：完全没关系，随便放在一起。

耦合（从好->差）：

（1） 非直接耦合（最好）：两个模块几乎没有关系，只是属于同一系统。

（2） 数据耦合：只通过参数传递数据，不互改内部，比如A调用B，就传一个数字使用。

（3） 标记耦合：传递整个数据结构，比如对象、结构体。

（4） 控制耦合：传一个控制标志，让对方按照不同逻辑执行。

（5） 外部耦合：共享外部约定，比如格式、协议、硬件。

（6） 公共耦合：共享全局数据区。

（7） 内容耦合：一个模块直接使用另一个模块的内部代码/变量，高度纠缠，容易改一点全部崩。

22 系统维护

（1） 正确性维护：改正系统开发阶段已经发生而系统测试阶段没有发现的错误。

（2） 适应性维护：是软件适应信息技术变化和管理需求变化而进行的修改。

（3） 完善性维护：为了扩充功能和改善性能而进行修改。

（4） 预防性维护：为了适应未来的软硬件环境变化，应主动增加预防性的新功能。

23 软件复杂性

软件复杂性：度量软件的一种重要指标，包括规模、难度、结构、智能度等。

（1）规模：总指令数或源程序行数。

（2）难度：由程序中出现的操作数数目所决定的量表示。

（3）结构：通常用与程序结构有关的度量来表示。

（4） 智能度：算法的难易程度。

24 复审

（1） 系统分析阶段的复审：应该指出软件的可移植性问题已经可能影响软件维护的系统界面。

（2） 系统设计阶段的复审：应该从容易修改、模块化和功能独立的目的出发，评价软件的结构和过程。

（3） 系统实施阶段的复审：代码复审应该强调编码风格和内部说明文档这两个影响可维护性的因素。

25 软件配置管理

内容：

（1） 配置项标识：为了控制和管理，必须单独为每个配置项命名，然后用面向对象方法组织。

（2） 版本控制：控制代码与文档版本迭代，维护不同版本差异与历史记录。

（3） 变更控制：对需求、代码、设计的修改进行审批、管控，防止随意变更。

（4） 配置审计：检查配置项完整性、一致性，确保版本与文档匹配。

（5） 发布与交付管理：统一打包、版本发布、归档管理，保障交付产物可控。

（6） 配置库管理：建立配置仓库，统一存放、管理所有配置产物。

流程：

（1） 配置项识别：确认需要管理的所有文档、代码、程序、等配置项

（2） 建立配置库：搭建版本仓库，划分开发、测试、发布分支。

（3） 版本控制与检出：开发人员检出配置型，进行编辑开发

（4） 变更申请与审批：如需要修改，提交变更申请，经过评审后执行修改

（5） 提交更新与版本升级：修改完后提交入库，生成新版本记录

（6） 配置审计与基线管理：定期审计，建立稳定基线，冻结重要版本

（7） 产品发布与归档：正式版本打包，所有配置资料统一归档保存。

26 风险分析

（1） 风险识别：识别潜在的预算、进度、个体、资源、用户和需求等方面的问题以及对整个项目的影响，并建立风险条目检查表，列出所有可能得风险事项。

（2） 风险预测/风险设计：建立一个标识风险可能性的参考标准，描述风险条目的结果，估计风险对项目的影响等。风险值=风险发生概率×风险影响程度。

（3） 风险评估：判断风险的严重程度，划分风险等级，确定优先处理顺序。

（4） 风险控制：针对评估后的高优先级风险，制定措施、落地执行、持续监控，降低风险危害。

27 产品质量

包括功能性、性能效率、兼容性、可靠性、信息安全性、维护性、易用性、可移植性。

28 软件能力成熟度模型（CMM）

（1） 初始化（Initail）：混乱无序，没流程，不稳定。

（2） 可重复级（Repeatable）：有基本流程，项目能够重复成功。

（3） 已定义级（Defined）：有标准化、文档化的软件过程，全公司统一。

（4） 已管理级（Managed）：对过量化管理，有详细度量标准，有数据、可预测、可控制。

（5） 优化级（Optimizing）：持续过程改进，预防缺陷，不断优化。

29 UML图

29.1 用例图(User case Diagram)

定义：用于描述系统功能需求，是对系统语境建模。

名称	绘制
用例	椭圆
关联	小人到椭圆的实线箭头
包含（include）	虚线+<<include>>
扩展（extend）	虚线+<<extend>>

29.2 类图

定义：静态结构图，描述系统中的类、类的属性和类之间的关系。

矩形：

名称	图形	图例
类	矩形，分三层（类名、属性、方法）
接口	小圆圈或带有<<interface>>的矩形
抽象类	类名斜体
枚举	矩形+<<enumeration>>

箭头：

名称	图形	图例
依赖（Dependency）	临时用一下，比如方法里用到另一个类
关联（Association）	普通关联，长期持有、成员变量
聚合（Aggregation）	整体与部分，可分离，比如班级（整体）和学生（部分），班级没了学生还在
组合/复合（Composition）	整体与部分，同生共死
泛化（继承）	子类继承父类
实现（接口实现）	类实现接口，如class A implements Interface B