日志系统项目——准备工作了解类的设计模式如单例模式、工厂模式、代理模式

1.六大原则

1.1 单一职责原则

类的职责应该单⼀，⼀个⽅法只做⼀件事。职责划分清晰了，每次改动到最⼩单位的⽅法或类。

使⽤建议：两个完全不⼀样的功能不应该放⼀个类中，⼀个类中应该是⼀组相关性很⾼的函数、数据的封装

⽤例：⽹络聊天：⽹络通信 & 聊天，应该分割成为⽹络通信类 & 聊天类

1.2 开闭原则

对扩展开放，对修改封闭

使⽤建议：对软件实体的改动，最好⽤扩展⽽⾮修改的⽅式。◦

⽤例：超时卖货：商品价格---不是修改商品的原来价格，⽽是新增促销价格。

1.3 里氏替换原则

通俗点讲，就是只要⽗类能出现的地⽅，⼦类就可以出现，⽽且替换为⼦类也不会产⽣任何错误或异常。

在继承类时，务必重写⽗类中所有的⽅法，尤其需要注意⽗类的protected⽅法，⼦类尽量不要暴露⾃⼰的public⽅法供外界调⽤。

使⽤建议：⼦类必须完全实现⽗类的⽅法，孩⼦类可以有⾃⼰的个性。覆盖或实现⽗类的⽅法时，输⼊参数可以被放⼤，输出可以缩⼩

⽤例：跑步运动员类-会跑步，⼦类⻓跑运动员-会跑步且擅⻓⻓跑，⼦类短跑运动员-会跑步且擅⻓短跑

1.4 依赖倒置原则

⾼层模块不应该依赖低层模块，两者都应该依赖其抽象. 不可分割的原⼦逻辑就是低层模式，原⼦逻辑组装成的就是⾼层模块。

模块间依赖通过抽象（接⼝）发⽣，具体类之间不直接依赖

使⽤建议：每个类都尽量有抽象类，任何类都不应该从具体类派⽣。尽量不要重写基类的⽅法。结合⾥⽒替换原则使⽤。

⽤例：奔驰⻋司机类--只能开奔驰；司机类 -- 给什么⻋，就开什么⻋；开⻋的⼈：司机--依赖于抽象

1.5 迪米特原则

尽量减少对象之间的交互，从⽽减⼩类之间的耦合。⼀个对象应该对其他对象有最少的了解。

对类的低耦合提出了明确的要求：只和直接的朋友交流，朋友之间也是有距离的。⾃⼰的就是⾃⼰的（如果⼀个⽅法放在本类中，既不增加类间关系，也对本类不产⽣负⾯影响，那就放置在本类中）。

⽤例：⽼师让班⻓点名--⽼师给班⻓⼀个名单，班⻓完成点名勾选，返回结果，⽽不是班⻓点名，⽼师勾选

1.6 接口隔离原则

客⼾端不应该依赖它不需要的接⼝，类间的依赖关系应该建⽴在最⼩的接⼝上

使⽤建议：接⼝设计尽量精简单⼀，但是不要对外暴露没有实际意义的接⼝。

⽤例：修改密码，不应该提供修改⽤⼾信息接⼝，⽽就是单⼀的最⼩修改密码接⼝，更不要暴露数据库操作

从整体上来理解六⼤设计原则，可以简要的概括为⼀句话，⽤抽象构建框架，⽤实现扩展细节，具体到每⼀条设计原则，则对应⼀条注意事项：

单⼀职责原则告诉我们实现类要职责单⼀；

⾥⽒替换原则告诉我们不要破坏继承体系；

依赖倒置原则告诉我们要⾯向接⼝编程；

接口隔离原则告诉我们在设计接口时要精简单一

迪米特原则告诉我们要降低类的耦合度

开闭原则告诉我们要对外开放拓展，关闭修改

2 单例模式

单例模式：⼀个类只能创建⼀个对象，即单例模式，该设计模式可以保证系统中该类只有⼀个实例，并提供⼀个访问它的全局访问点，该实例被所有程序模块共享。⽐如在某个服务器程序中，该服务器的配置信息存放在⼀个⽂件中，这些配置数据由⼀个单例对象统⼀读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息，这种⽅式简化了在复杂环境下的配置管理。

2.1 饿汉模式

饿汉模式: 程序启动时就会创建⼀个唯⼀的实例对象。因为单例对象已经确定，所以⽐较适⽤于多线程环境中，多线程获取单例对象不需要加锁，可以有效的避免资源竞争，提⾼性能。

cpp 复制代码

//饿汉模式
template<class T>
class server{
    private:
        server(){};
        ~server(){};
    public:
        server(const server&) = delete;
        server& operator=(const server&) = delete;
        server& getinstens()
        {
            return _etc;
        }
    private:
        static server<T> _etc;
};

template<class T>
server<T> server<T>::_etc;

2.2 懒汉模式

懒汉模式:第⼀次使⽤要使⽤单例对象的时候创建实例对象。如果单例对象构造特别耗时或者耗费济源(加载插件、加载⽹络资源等)，可以选择懒汉模式，在第⼀次使⽤的时候才创建对象。

cpp 复制代码

/ 懒汉模式
class Myclient{
    private:
        Myclient();
        ~Myclient();
    public:
        Myclient(const Myclient&) = delete;
        Myclient& operator=(const Myclient&) = delete;
        Myclient* getinsten()
        {
            //线程不安全
            if(_cli == nullptr) _cli = new Myclient();
            return _cli;
        }
    private:
        static Myclient* _cli;
};

第一种方法写的懒汉模式明显线程不安全，我们可以通过加锁来让这个过程是线程安全的但是会增加额外的开销，这里并不提倡这种加锁的方式，我们这里采用Effective C++中提供的一个方式

cpp 复制代码

Myclient* Myclient::_cli = nullptr;
template<class T>
class Myclient {
private:
    Myclient() {}
    ~Myclient() {}

public:
    Myclient(const Myclient&) = delete;
    Myclient& operator=(const Myclient&) = delete;

    static Myclient<T>& getInstance() {
        static Myclient<T> instance_;
        return instance_;
    }
};

3 工厂模式

⼯⼚模式是⼀种创建型设计模式，它提供了⼀种创建对象的最佳⽅式。在⼯⼚模式中，我们创建对象时不会对上层暴露创建逻辑，⽽是通过使⽤⼀个共同结构来指向新创建的对象，以此实现创建-使⽤的分离。

3.1 简单工厂模式

简单⼯⼚模式: 简单⼯⼚模式实现由⼀个⼯⼚对象通过类型决定创建出来指定产品类的实例。假设有个⼯⼚能⽣产出⽔果，当客⼾需要产品的时候明确告知⼯⼚⽣产哪类⽔果，⼯⼚需要接收⽤⼾提供的类别信息，当新增产品的时候，⼯⼚内部去添加新产品的⽣产⽅式。

cpp 复制代码

#include <iostream>
#include <string>
#include <memory>
class Fruit
{
public:
    Fruit() {}
    virtual void show() = 0;
};
class Apple : public Fruit
{
public:
    Apple() {}
    virtual void show()
    {
        std::cout << "我是⼀个苹果" << std::endl;
    }
};
class Banana : public Fruit
{
public:
    Banana() {}
    virtual void show()
    {
        std::cout << "我是⼀个⾹蕉" << std::endl;
    }
};
class FruitFactory
{
public:
    static std::shared_ptr<Fruit> create(const std::string &name)
    {
        if (name == "苹果")
        {
            return std::make_shared<Apple>();
        }
        else if (name == "⾹蕉")
        {
            return std::make_shared<Banana>();
        }
        return std::shared_ptr<Fruit>();
    }
};
int main()
{
    std::shared_ptr<Fruit> fruit = FruitFactory::create("苹果");
    fruit->show();
    fruit = FruitFactory::create("⾹蕉");
    fruit->show();
    return 0;
}

这个模式的结构和管理产品对象的⽅式⼗分简单，但是它的扩展性⾮常差，当我们需要新增产品的时候，就需要去修改⼯⼚类新增⼀个类型的产品创建逻辑，违背了开闭原则。

3.2 工厂方法模式

⼯⼚⽅法模式: 在简单⼯⼚模式下新增多个⼯⼚，多个产品，每个产品对应⼀个⼯⼚。假设现在有A、B 两种产品，则开两个⼯⼚，⼯⼚ A 负责⽣产产品 A，⼯⼚ B 负责⽣产产品 B，⽤⼾只知道产品的⼯⼚名，⽽不知道具体的产品信息，⼯⼚不需要再接收客⼾的产品类别，⽽只负责⽣产产品。

cpp 复制代码

#include <iostream>
#include <string>
#include <memory>
class Fruit
{
public:
    Fruit() {}
    virtual void show() = 0;
};
class Apple : public Fruit
{
public:
    Apple() {}
    virtual void show()
    {
        std::cout << "我是⼀个苹果" << std::endl;
    }

private:
    std::string _color;
};
class Banana : public Fruit
{
public:
    Banana() {}
    virtual void show()
    {
        std::cout << "我是⼀个⾹蕉" << std::endl;
    }
};
class FruitFactory
{
public:
    virtual std::shared_ptr<Fruit> create() = 0;
};
class AppleFactory : public FruitFactory
{
public:
    virtual std::shared_ptr<Fruit> create()
    {
        return std::make_shared<Apple>();
    }
};
class BananaFactory : public FruitFactory
{
public:
    virtual std::shared_ptr<Fruit> create()
    {
        return std::make_shared<Banana>();
    }
};

int main()
{
    std::shared_ptr<FruitFactory> factory(new AppleFactory());
    std::shared_ptr<Fruit> fruit = factory->create();
    fruit->show();
    factory.reset(new BananaFactory());
    std::shared_ptr<Fruit> fruit2 = factory->create();
    fruit2->show();
    return 0;
}

⼯⼚⽅法模式每次增加⼀个产品时，都需要增加⼀个具体产品类和⼯⼚类，这会使得系统中类的个数成倍增加，在⼀定程度上增加了系统的耦合度

3.3 抽象工厂模式

抽象⼯⼚模式: ⼯⼚⽅法模式通过引⼊⼯⼚等级结构，解决了简单⼯⼚模式中⼯⼚类职责太重的问题，但由于⼯⼚⽅法模式中的每个⼯⼚只⽣产⼀类产品，可能会导致系统中存在⼤量的⼯⼚类，势必会增加系统的开销。此时，我们可以考虑将⼀些相关的产品组成⼀个产品族（位于不同产品等级结构中功能相关联的产品组成的家族），由同⼀个⼯⼚来统⼀⽣产，这就是抽象⼯⼚模式的基本思想。

cpp 复制代码

#include <iostream>
#include <string>
#include <memory>
// 抽象⼯⼚：围绕⼀个超级⼯⼚创建其他⼯⼚。每个⽣成的⼯⼚按照⼯⼚模式提供对象。
//  思想：将⼯⼚抽象成两层，抽象⼯⼚ & 具体⼯⼚⼦类， 在⼯⼚⼦类种⽣产不同类型的⼦产品
class Fruit
{
public:
    Fruit() {}
    virtual void show() = 0;
};
class Apple : public Fruit
{
public:
    Apple() {}
    virtual void show()
    {
        std::cout << "我是⼀个苹果" << std::endl;
    }

private:
    std::string _color;
};
class Banana : public Fruit
{
public:
    Banana() {}
    virtual void show()
    {
        std::cout << "我是⼀个⾹蕉" << std::endl;
    }
};

class Animal
{
public:
    virtual void voice() = 0;
};
class Lamp : public Animal
{
public:
    void voice() { std::cout << "咩咩咩\n"; }
};
class Dog : public Animal
{
public:
    void voice() { std::cout << "汪汪汪\n"; }
};

class Factory
{
public:
    virtual std::shared_ptr<Fruit> getFruit(const std::string &name) = 0;
    virtual std::shared_ptr<Animal> getAnimal(const std::string &name) = 0;
};

class FruitFactory : public Factory
{
public:
    virtual std::shared_ptr<Animal> getAnimal(const std::string &name)
    {
        return std::shared_ptr<Animal>();
    }
    virtual std::shared_ptr<Fruit> getFruit(const std::string &name)
    {
        if (name == "苹果")
        {
            return std::make_shared<Apple>();
        }
        else if (name == "⾹蕉")
        {
            return std::make_shared<Banana>();
        }
        return std::shared_ptr<Fruit>();
    }
};

class AnimalFactory : public Factory
{
public:
    virtual std::shared_ptr<Fruit> getFruit(const std::string &name)
    {
        return std::shared_ptr<Fruit>();
    }
    virtual std::shared_ptr<Animal> getAnimal(const std::string &name)
    {
        if (name == "⼩⽺")
        {
            return std::make_shared<Lamp>();
        }
        else if (name == "⼩狗")
        {
            return std::make_shared<Dog>();
        }
        return std::shared_ptr<Animal>();
    }
};
class FactoryProducer
{
public:
    static std::shared_ptr<Factory> getFactory(const std::string &name)
    {
        if (name == "动物")
        {
            return std::make_shared<AnimalFactory>();
        }
        else
        {
            return std::make_shared<FruitFactory>();
        }
    }
};

抽象⼯⼚模式适⽤于⽣产多个⼯⼚系列产品衍⽣的设计模式，增加新的产品等级结构复杂，需要对原有系统进⾏较⼤的修改，甚⾄需要修改抽象层代码，违背了"开闭原则"。

4. 建造者模式

建造者模式：建造者模式是⼀种创建型设计模式，使⽤多个简单的对象⼀步⼀步构建成⼀个复杂的对象，能够将⼀个复杂的对象的构建与它的表⽰分离，提供⼀种创建对象的最佳⽅式。主要⽤于解决对象的构建过于复杂的问题。

建造者模式主要基于五个核⼼类实现：

抽象产品类

具体产品类：⼀个具体的产品对象类

抽象Builder类：创建⼀个产品对象所需的各个部件的抽象接⼝

具体产品的Builder类：实现抽象接⼝，构建各个部件

指挥者Director类：统⼀组建过程，提供给调⽤者使⽤，通过指挥者来构造产品

cpp 复制代码

#include <iostream>
#include <memory>
/*抽象电脑类*/
class Computer
{
public:
    using ptr = std::shared_ptr<Computer>;
    Computer() {}
    void setBoard(const std::string &board) { _board = board; }
    void setDisplay(const std::string &display) { _display = display; }
    virtual void setOs() = 0;
    std::string toString()
    {
        std::string computer = "Computer:{\n";
        computer += "\tboard=" + _board + ",\n";
        computer += "\tdisplay=" + _display + ",\n";
        computer += "\tOs=" + _os + ",\n";
        computer += "}\n";
        return computer;
    }

protected:
    std::string _board;
    std::string _display;
    std::string _os;
};
/*具体产品类*/
class MacBook : public Computer
{
public:
    using ptr = std::shared_ptr<MacBook>;
    MacBook() {}
    virtual void setOs()
    {
        _os = "Max Os X12";
    }
};
/*抽象建造者类：包含创建⼀个产品对象的各个部件的抽象接⼝*/
class Builder
{
public:
    using ptr = std::shared_ptr<Builder>;
    virtual void buildBoard(const std::string &board) = 0;
    virtual void buildDisplay(const std::string &display) = 0;
    virtual void buildOs() = 0;
    virtual Computer::ptr build() = 0;
};

/*具体产品的具体建造者类：实现抽象接⼝，构建和组装各个部件*/
class MacBookBuilder : public Builder
{
public:
    using ptr = std::shared_ptr<MacBookBuilder>;
    MacBookBuilder() : _computer(new MacBook()) {}
    virtual void buildBoard(const std::string &board)
    {
        _computer->setBoard(board);
    }
    virtual void buildDisplay(const std::string &display)
    {
        _computer->setDisplay(display);
    }
    virtual void buildOs()
    {
        _computer->setOs();
    }
    virtual Computer::ptr build()
    {
        return _computer;
    }

private:
    Computer::ptr _computer;
};

/*指挥者类，提供给调⽤者使⽤，通过指挥者来构造复杂产品*/
class Director
{
public:
    Director(Builder *builder) : _builder(builder) {}
    void construct(const std::string &board, const std::string &display)
    {
        _builder->buildBoard(board);
        _builder->buildDisplay(display);
        _builder->buildOs();
    }

private:
    Builder::ptr _builder;
};

5.代理模式

代理模式指代理控制对其他对象的访问，也就是代理对象控制对原对象的引⽤。在某些情况下，⼀个对象不适合或者不能直接被引⽤访问，⽽代理对象可以在客⼾端和⽬标对象之间起到中介的作⽤。

代理模式的结构包括⼀个是真正的你要访问的对象(⽬标类)、⼀个是代理对象。⽬标对象与代理对象实现同⼀个接⼝，先访问代理类再通过代理类访问⽬标对象。代理模式分为静态代理、动态代理：

静态代理指的是，在编译时就已经确定好了代理类和被代理类的关系。也就是说，在编译时就已经

确定了代理类要代理的是哪个被代理类。

动态代理指的是，在运⾏时才动态⽣成代理类，并将其与被代理类绑定。这意味着，在运⾏时才能确定代理类要代理的是哪个被代理类。

以租房为例，房东将房⼦租出去，但是要租房⼦出去，需要发布招租启⽰，带⼈看房，负责维修，这些⼯作中有些操作并⾮房东能完成，因此房东为了图省事，将房⼦委托给中介进⾏租赁。代理模式实现：

cpp 复制代码

/*房东要把⼀个房⼦通过中介租出去理解代理模式*/
#include <iostream>
#include <string>
class RentHouse
{
public:
    virtual void rentHouse() = 0;
};
/*房东类：将房⼦租出去*/
class Landlord : public RentHouse
{
public:
    void rentHouse()
    {
        std::cout << "将房⼦租出去\n";
    }
};
/*中介代理类：对租房⼦进⾏功能加强，实现租房以外的其他功能*/
class Intermediary : public RentHouse
{
public:
    void rentHouse()
    {
        std::cout << "发布招租启⽰\n";
        std::cout << "带⼈看房\n";
        _landlord.rentHouse();
        std::cout << "负责租后维修\n";
    }

private:
    Landlord _landlord;
};
int main()
{
    Intermediary intermediary;
    intermediary.rentHouse();
    return 0;
}