我的笔记

Appearance

UML类图 ​

UML(Unified Modeling Language) 统一建模语言,是一个支持模型化和软件系统开发的图形化语言,为软件开发的所有阶段提供模型化和可视化支持。

  • 特点：uml运用统一的、标准化的标记和定义组合了当今最好的面向对象软件建模方法。

uml常用图 ​

类图-程序员用的 ​

描述类与类之间关系。架构师或者开发人员。

用例图 ​

描述需求。 谁能做什么。。。 一般是产品进行需求分析使用

顺序图（时序图） ​

时序图是以时间为序的表示方法，主要用来描述对象之间的时间顺序。将交互关系表示为二维图的。**纵轴为时间，横轴为在协作中各个独立的对象。**对象存在时用一条虚线表示，当对象的过程处于激活状态是，生命线是一个双道线。消息用从一个对象的生命线到另一个对象生命线的箭头表示。箭头以时间顺序在图中从上到下排列。如下图：

构件图 ​

  • 组件（构件图）和配置图（部署图）是面向对象系统的物理建模时使用的两种图。

部署图 ​

描述系统硬件的物理结构以及如何将软件部署在硬件上。用于对系统的实现视图建模，主要是为了描述系统各个物理组成部分的分布、提交、安装过程。 -架构师

画图工具

设计模式 ​

单例模式 ​

  • 一个类确保它只有一个对象，称为单例模式。
  • 作用：不用重复创建对象和释放对象。节约了时间和效率。没有线程安全都用单例
  • tcpSocket,request,response,requestResult,这些要用多例 . 剩余的都要用单例.
  • 实现方式
    • 构造函数私有化
    • 禁用拷贝构造函数，让其他类中不能建
    • 禁用赋值运算符
    • 自己创建一个静态实例
    • 提供一个静态方法获取创建好的实例

懒汉式单例 ​

  • 第一次使用的时候创建
c++
#include<iostream>
//懒汉式单例
class SingletonDemo{
private:
    SingletonDemo() = default;
public:

    SingletonDemo(const SingletonDemo&) = delete;
    SingletonDemo& operator=(const SingletonDemo&) = delete;
    //外部获取实例的方法
    static SingletonDemo& getInstance(){
        //局部静态变量
        static SingletonDemo instance;
        return instance;
    }
};

int main(int argc, char const *argv[])

{
    SingletonDemo& s1 = SingletonDemo::getInstance();
    SingletonDemo& s2 = SingletonDemo::getInstance();
    std::cout << &s1 << std::endl;
    std::cout << &s2 << std::endl;
    return 0;
}

饿汉式单例 ​

  • 默认创建一个对象实例
c++
#include<iostream>
//饿汉式单例
class SingletonDemo{
private:
    SingletonDemo() = default;
    static SingletonDemo instance;
public:
    SingletonDemo(const SingletonDemo&) = delete;
    SingletonDemo& operator=(const SingletonDemo&) = delete;

    static SingletonDemo& getInstance(){
        return instance;
    }
};
//静态成员需要类外定义一次，程序启动时创建
SingletonDemo SingletonDemo::instance;
int main(int argc, char const *argv[])
{
    SingletonDemo& s1 = SingletonDemo::getInstance();
    SingletonDemo& s2 = SingletonDemo::getInstance();
    std::cout << &s1 << std::endl;
    std::cout << &s2 << std::endl;
    return 0;
}

工厂模式 ​

简单工厂 ​

  • 一个静态方法根据参数返回不同类型
c++
#include <iostream>
//简单工厂
class Car
{
private:
public:
    // 纯虚函数
    virtual void run() = 0;
    //虚析构函数必须有，否则 delete 基类指针时派生类析构不执行
    virtual ~Car() = default;
};
class BYD : public Car
{
    void run() override
    {
        std::cout << "BYD.run().." << std::endl;
    }
};
class Mi : public Car
{
    void run() override
    {
        std::cout << "Mi.run()..." << std::endl;
    }
};
class Factory{
public:
    static Car* create(const std::string& type){
        if (type == "Mi")
        {
            return new Mi();
        }
        if (type == "BYD")
        {
            return new BYD();
        }
        return nullptr;
    }
};
int main()
{
    Car* byd = Factory::create("BYD");
    Car* mi = Factory::create("Mi");
    if (byd)
    {
        byd->run();
    }
    if (mi)
    {
        mi->run();
    }
    delete byd;
    delete mi;
    return 0;
}

工厂方法 ​

  • 把创建逻辑放到子类，由子类决定实例化哪个类
c++
#include<iostream>
//工厂方法
class Car
{
private:
public:
    // 纯虚函数
    virtual void run() = 0;
    //虚析构函数必须有，否则 delete 基类指针时派生类析构不执行
    virtual ~Car() = default;
};
class BYD : public Car
{
    void run() override
    {
        std::cout << "BYD.run().." << std::endl;
    }
};
class Mi : public Car
{
    void run() override
    {
        std::cout << "Mi.run()..." << std::endl;
    }
};
class Factory{
public:
    //纯虚工厂方法
    virtual Car* create() = 0;
    virtual ~Factory() = default;
};
class MiFactory : public Factory{
public:
    Car* create(){
        return new Mi();
    }
};
class BYDFactory:public Factory{
public:
    Car* create(){
        return new BYD();
    }
};
int main(){
    Factory* f1 = new MiFactory();
    Factory* f2 = new BYDFactory();
    Car* mi = f1->create();
    Car* byd = f2->create();
    mi->run();
    byd->run();
    delete mi;
    delete byd;
    delete f1;
    delete f2;
}

抽象工厂 ​

— 创建一族相关对象，每个工厂生产一组产品。

  • 解耦：客户端依赖接口而非具体类
  • 可扩展：加新产品只需新增类，不改现有代码（开闭原则）
  • 集中管理：统一创建/销毁逻辑
c++
#include <iostream>

//抽象工厂
class Car
{
public:
    virtual void run() = 0;
    virtual ~Car() = default;
};
class Battery
{
public:
    virtual void charge() = 0;
    virtual ~Battery() = default;
};

class BYD_Car : public Car
{
    void run() override
    {
        std::cout << "BYD Car.run().." << std::endl;
    }
};
class BYD_Battery : public Battery
{
    void charge() override
    {
        std::cout << "BYD Battery.charge().." << std::endl;
    }
};
class Mi_Car : public Car
{
    void run() override
    {
        std::cout << "Mi Car.run()..." << std::endl;
    }
};
class Mi_Battery : public Battery
{
    void charge() override
    {
        std::cout << "Mi Battery.charge()..." << std::endl;
    }
};

class AbstractFactory
{
public:
    virtual Car* createCar() = 0;
    virtual Battery* createBattery() = 0;
    virtual ~AbstractFactory() = default;
};

class BYDFactory : public AbstractFactory
{
public:
    Car* createCar() override
    {
        return new BYD_Car();
    }
    Battery* createBattery() override
    {
        return new BYD_Battery();
    }
};
class MiFactory : public AbstractFactory
{
public:
    Car* createCar() override
    {
        return new Mi_Car();
    }
    Battery* createBattery() override
    {
        return new Mi_Battery();
    }
};

void build(AbstractFactory& f)
{
    Car* c = f.createCar();
    Battery* b = f.createBattery();
    c->run();
    b->charge();
    delete c;
    delete b;
}

int main()
{
    BYDFactory byd;
    MiFactory mi;
    build(byd);
    build(mi);
    return 0;
}

策略模式 ​

策略模式（Strategy Pattern）是一种行为型设计模式：定义一组算法，把它们封装成独立的类，并让它们在运行时可以互相替换，从而让算法可以独立于使用它的客户端变化。

在代码中，如果不使用策略模式，你可能会写大量的 if-else 或 switch 语句来判断用户选了哪种交通方式。 使用了策略模式后，你把“飞机”、“火车”、“自行车”分别封装成独立的类。客户端只需要在运行时决定“注入”哪个策略对象，而不需要关心具体的实现细节。

核心思想

  • 策略接口（Strategy）：定义算法族的公共接口。
  • 具体策略（ConcreteStrategy）：实现不同的算法。
  • 上下文（Context）：持有一个策略对象，调用它执行算法，可以在运行时切换。
  • 策略 A：坐飞机（快，贵）
  • 策略 B：坐火车（中等速度，中等价格）
  • 策略 C：骑自行车（慢，便宜，环保）
c++
#include <iostream>
#include <memory>
// c++策略模式实现
// 策略接口
class PaymentStrategy
{
public:
    // 虚函数
    virtual ~PaymentStrategy() = default;
    virtual void pay(double amount) = 0;
};
// 具体策略Alipay
class Alipay : public PaymentStrategy
{
public:
    void pay(double amount) override
    {
        std::cout << "alipay..." << amount << std::endl;
    }
};
// 具体策略cash
class Cash : public PaymentStrategy
{
public:
    void pay(double amount) override
    {
        std::cout << "cash..." << amount << std::endl;
    }
};
// 上下文
// 上下文持有策略的指针，并提供一个接口让客户端设置策略和执行操作。
class Payer
{
private:
    // 使用智能指针管理策略生命周期
    std::shared_ptr<PaymentStrategy> strategy;
public:
    //设置或切换策略
    void setPaymentStrategy(std::shared_ptr<PaymentStrategy> newStrategy){
        strategy = newStrategy;
    }
    //执行策略
    void checkout(double amount){
        if (!strategy)
        {
            std::cerr << "未选择支付方式!" << std::endl;
            return;
        }
        std::cout << "开始支付" << std::endl;
        strategy->pay(amount);
    }
};
int main()
{
    Payer payer;
    double amount = 19.99;
    payer.setPaymentStrategy(std::make_shared<Alipay>());
    payer.checkout(amount);

    payer.setPaymentStrategy(std::make_shared<Cash>());
    payer.checkout(amount);
}

http协议 ​

HTTP（HyperText Transfer Protocol，超文本传输协议）,是浏览器与服务器之间通信的应用层协议,基于TCP,采用[请求-响应]模型.

核心特点:

  • 无状态: 每次请求相互独立,服务器不记住之前的请求(靠Cookie/Session弥补)
  • 灵活: 可传输HTML、json、图片等任意类型数据
  • 常见方法：GET、POST、PUT、DELETE等
  • 状态码： 2xx 成功、3xx 重定向、 4xx 客户端错误、5xx 服务端错误

报文 ​

http报文是客户端和服务端之间实际传输的数据格式，分为请求报文和响应报文，结构相同，都由三部分组成

  1. 起始行（Start Line）请求行或状态行
  2. 头部（Headers）键值对，描述报文信息
  3. 空行（\r\n）
  4. 消息体（Body） 实际数据，可有可无

请求报文示例（浏览器发给服务器）：

http
GET /api/users?id=1 HTTP/1.1     ← 请求行：方法 + 路径 + 协议版本
Host: example.com                ← 头部：必须的
User-Agent: Chrome/120.0
Accept: application/json
Content-Type: application/json   ← 正文类型

{"name": "tom"}                  ← 消息体（GET 一般没有）

响应报文示例：

http
HTTP/1.1 200 OK                  ← 状态行：协议版本 + 状态码 + 描述
Content-Type: application/json
Content-Length: 27

{"id": 1, "name": "tom"}         ← 消息体
  • 起始行决定报文类型（请求方法or状态码）
  • 头部携带元信息：认证（Authorization）、缓存（Cache-Control）、内容类型（Content-Type）等
  • Body只有POST/PUT等方法或响应有数据时才存在

响应内容 ​

响应内容就是报文里的Body，服务器真正要给客户端的数据，具体格式由Content-Type头声明

  • 返回HTML页面
http
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8

<!DOCTYPE html>
<html><body><h1>Hello</h1></body></html>   ← 浏览器会渲染成页面
  • 返回JSON
http
HTTP/1.1 200 OK
Content-Type: application/json

{"code": 0, "data": {"id": 1, "name": "tom"}}
  • 返回图片文件
http
HTTP/1.1 200 OK
Content-Type: image/png
Content-Length: 10240

<二进制图片数据>          ← 浏览器直接显示图片
  • 常见Content-Type
类型值
网页text/html
JSONapplication/json
纯文本text/plain
图片image/png、image/jpeg
文件下载application/octet-stream
表单application/x-www-form-urlencoded、multipart/form-data

常见的web服务器 ​