日志系统前置知识

日志：程序运行过程中所记录的程序运行状态信息。通过这些信息，以便于程序员能够随时根据状态信息，对系统的运行状态进行分析。功能：能够让用户非常简便的进行日志的输出以及控制。

同步写日志

同步日志是指当输出日志时，必须等待日志输出语句执行完毕后，才能执行后面的业务逻辑语句，日志输出语句与程序的业务逻辑语句将在同⼀个线程运行。每次调用⼀次打印日志API就对应⼀次系统调用write写日志文件。

在高并发场景下，随着日志数量不断增加，同步日志系统容易产生系统瓶颈：一方面，大量的日志打印陷入等量的write系统调用，有⼀定系统开销。另一方面，使得打印日志的进程附带了大量同步的磁盘IO，影响程序性能。

异步写日志

异步日志是指在进行日志输出时，日志输出语句与业务逻辑语句并不是在同⼀个线程中运行，而是有专门的线程用于进行日志输出操作。业务线程只需要将日志放到⼀个内存缓冲区中不用等待即可继续执行后续业务逻辑（作为日志的生产者），而日志的落地操作交给单独的日志线程去完成（作为日志的消费者）, 这是⼀个典型的生产-消费模型。

这样做的好处是即使日志没有真的地完成输出也不会影响程序的主业务，可以提高程序的性能：主线程调用日志打印接口成为非阻塞操作，同步的磁盘IO从主线程中剥离出来交给单独的线程完成。

不定参宏函数

#include <stdio.h>
#define LOG(fmt,...) printf("[%s:%d]" fmt,__FILE__,__LINE__,##__VA_ARGS__);//fmt是格式化字符串，包含许多格式化字符，要从后面取出各种各样不同的参数来组织字符串， 而...标识是不定参，而宏__VA_ARGS__是使用不定参。##是告诉我们当不定参是空的时候则取消前面的逗号
int main()
{
    printf("[%s:%d]""%s",__FILE__,__LINE__,"hello wjj\n");//__FILE__,__LINE__两个宏说明是所在文件和行号。
    LOG("%s%d\n","wjj",666);
    LOG("hello wjj\n")；//此时不定参是空，所以##起了作用。
    return 0;
}


#include <iostream>
#include <cstdarg>
void printNum(int n, ...) //打印数字，我们首先得确定有多少个数字，n代表传入数字的个数，而传的数字是不确定的。
{
    va_list al;
    va_start(al, n);//获取地址参数的起始地址，这里就是获取参数n之后的第一个不定参数的起始地址
    for (int i = 0; i < n; i++) 
    {
        int num = va_arg(al, int);//从不定参数中获取出⼀个整形参数，这也是va_arg函数第二个参数的意思。
        std::cout << num << std::endl;
    }
    va_end(al);//清空可变参数列表--其实是将al指针置空
}
int main()
{
    printNum(3,1,2,3);
    return 0;
}
//printf前面格式化的字符串里面格式化的字符%d、%s告诉我们编译器接下来应该从后面取几个字节的数据当做整型数据还是字符串来进行处理。

//模拟实现一下printf的实现
#include <iostream>
#include <cstdarg>
void myprintf(const char *fmt, ...) 
{
    char *res;
    va_list al;
    va_start(al, fmt);//fmt有什么格式化的字符，决定我们从后面取出什么类型的数据
    int len = vasprintf(&res, fmt, al);//int vasprintf(char **strp, const char *fmt, va_list ap);借用res会自己申请空间，根据fmt格式化字符，从格式化参数列表al里面取出一个一个的参数进行数据组织，并放入申请的空间里面去。 
    va_end(al);
    std::cout << res << std::endl;
    free(res);//要释放
}
int main()
{
    myprintf("%s-%d", "wjj", 25);
    myprintf("hello wjj");
    return 0;
}

#include <iostream>
#include <cstdarg>
#include <memory>
#include <functional>
void xprintf() //对函数模板进行特化，增加一个无参的形式。
{
    std::cout << std::endl;
}
template<typename T, typename ...Args>//后者定义的是一个不定参参数包类型
void xprintf(const T &value, Args &&...args) 
{
    std::cout << value << " ";//先打印第一个参数
    if ((sizeof ...(args)) > 0) //获得参数包的个数
    {
        xprintf(std::forward<Args>(args)...);//采用一种递归的思想，完美转发，你传递过来的时候是左值，现在就还是左值。 并且还要补充一个无参的形式
    }
    else 
    {
        xprintf();
    }
}
int main()
{
    xprintf("wjj");
    xprintf("wjj", 666);
    xprintf("hello", "wjj", 666);
    return 0;
}

设计模式

单例模式

⼀个类只能创建⼀个对象，即单例模式，该设计模式可以保证系统中该类只有⼀个实例，并提供⼀个访问它的全局访问点，该实例被所有程序模块共享。

//饿汉模式，用空间换时间的思想
class Singleton 
{
private:
    static Singleton _eton;//使用static来修饰。这里属于成员声明，并非定义，类内的静态成员需要在类外进行定义。
private:
    Singleton():_data(99){std::cout<<"单例对象构造\n";}//构造函数私有化，保证类外无法实例化对象，只能在类内实例化，
    ~Singleton(){}
    int _data;
public:
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
    static Singleton& getInstance() //提供一个访问接口
    {
        return _eton;
    }
    int GetData(){return _data;}
};
Singleton Singleton::_eton;//类内的静态成员需要在类外定义。静态对象的资源是在静态区的，它的生命周期随整个程序的，它的初始化构造是在我们程序初始化阶段就完成的。不管你用不用，这个对象的资源都已经分配了。

int main()
{
    std::cout<<Singleton::getInstance().GetData()<<std::endl;//就算没有这行代码，这个单例对象也会构造
    return 0;
}

//懒汉模式，延迟加载的思想，也就是一个对象到用的时候在进行实例化，而不是程序一起来不管用与否都进行实例化
//实现方法：定义对象的时候是定义一个对象的指针，在通过访问接口的时候发现其为空再去new一个对象
class Singleton { 
private:
    Singleton():_data(99){std::cout<<"单例对象构造\n";}//构造函数私有化，保证类外无法实例化对象
    ~Singleton(){}
    int _data;
public: 
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
    static Singleton& getInstance() 
    { 
        static Singleton _eton;//确保C++11起，静态变量将能够在满⾜thread-sa fe的前提下唯⼀地被构造和析构，这里静态局部对象的定义是线程安全的，多个线程试图同时初始化同一个静态局部变量时，初始化只会发生一次。
        return _eton; 
    } 
    int GetData(){return _data;}
}; 

int main()
{
    std::cout<<Singleton::getInstance().GetData()<<std::endl;//没有这行代码，这个单例对象不会构造
    return 0;
}

工厂模式

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

//简单⼯⼚模式：通过参数控制可以⽣产任何产品
// 优点：简单粗暴，直观易懂。使⽤⼀个⼯⼚⽣产同⼀等级结构下的任意产品
// 缺点：
// 1. 所有东西⽣产在⼀起，产品太多会导致代码量庞⼤
// 2. 开闭原则遵循(开放拓展，关闭修改)的不是太好，要新增产品就必须修改⼯⼚⽅法。
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;
}

//工厂方法模式:在简单⼯⼚模式下新增多个⼯⼚，多个产品，每个产品对应⼀个⼯⼚。
#include <iostream>
#include <memory>
#include<string>
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> ff(new AppleFactory()); 
    std::shared_ptr<Fruit> fruit_apple = ff->create();
    fruit_apple->show();
    ff.reset(new BananaFactory());//更改fruit_apple管理的对象
    std::shared_ptr<Fruit> fruit_banana = ff->create();
    fruit_banana->show();
    return 0;
}

//抽象工厂：围绕一个超级工厂创建其他工厂。每个生成的工厂按照工厂模式提供对象。
//思想：将工厂抽象成两层，抽象工厂 & 具体简单工厂子类， 在工厂子类种生产不同类型的子产品
#include<iostream>
#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 {
    protected:
    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>();
            }
        }
};

int main()
{
    std::shared_ptr<Factory> fruit_factory = FactoryProducer::getFactory("水果");//先生产水果工厂
    std::shared_ptr<Fruit> fruit_apple=fruit_factory->getFruit("苹果");
    fruit_apple->show();
    std::shared_ptr<Factory> animal_factory = FactoryProducer::getFactory("动物");//先生动物果工厂
    std::shared_ptr<Animal> animal_dog=animal_factory->getAnimal("小狗");
    animal_dog->voice();
    return 0;
}

建造者模式

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

#include <iostream>
#include <memory>
#include<string>
/*抽象电脑类，里面有许多零部件需要安装*/
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 MackBookBuilder : public Builder {
    public:
        using ptr = std::shared_ptr<MackBookBuilder>;
        MackBookBuilder(): _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){}//指挥者指挥的是一个Builder对象
        void construct(const std::string &board, const std::string &display) //建造对象
        {
            _builder->buildBoard(board);
            _builder->buildDisplay(display);
            _builder->buildOs();
        }
    private:
        Builder::ptr _builder;
};

int main()
{
    Builder *buidler = new MackBookBuilder();//MackBookBuilder建造者建造mac电脑，工人建造没有顺序之分
    std::unique_ptr<Director> pd(new Director(buidler));//pd指挥建造者如何建造，先做什么后做什么。
    pd->construct("英特尔主板", "LG显示器");
    Computer::ptr computer = buidler->build();
    std::cout << computer->toString();
    return 0;
}

代理模式

代理模式指代理控制对其他对象的访问，也就是代理对象控制对原对象的引⽤，完成原对象基础之上的一些额外功能。

/*房东要把⼀个房⼦通过中介租出，而不是从房东手上租房*/
#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;
}

项目框架

日志系统:
作用:将一条消息, 进行格式化称为指定格式的字符串后，写入到指定位置
1.日志要写入指定位置(标准输出，指定文件，滚动文件....)，日志系统需要支持将日志消息落地到不同的位置---多落地方向
2.日志写入指定位置，支持不同的写入方式(同步,异步)：
同步:业务线程自己负责日志的写入(流程简单,但是有可能会因为阻塞导致效率降低)
异步:业务线程将日志放入缓冲区内存,让其他异步线程负责将日志写入指定位置
3.日志输出以日志器为单位，支持多日志器(不同的项目组有不同的输出策略)、日志器的管理
模块划分:
日志等级模块：枚举出日志分为多少个等级---对不同的日志有不同等级标记- -以便于控制输出
日志消息模块：封装-条日志所需的各种要素 (时间,线程ID,文件名,行号，日志等级，消息主体.....)
消息格式化模块：按照指定的格式，对于日志消息关键要素进行组织，最终得到一个指定格式的字符串