1. 六大原则

• 类的职责应该单⼀，⼀个⽅法只做⼀件事。职责划分清晰了，每次改动到最⼩单位的⽅法或 类。
• 使⽤建议：两个完全不⼀样的功能不应该放⼀个类中，⼀个类中应该是⼀组相关性很⾼的函数、数据的封装。
• ⽤例：⽹络聊天：⽹络通信 & 聊天，应该分割成为⽹络通信类 & 聊天类。

• 这⾥介绍的是《Effective C++》⼀书作者 Scott Meyers 提出的⼀种更加优雅简便的单例模式 Meyers' Singleton in C++。
• C++11 Static local variables 特性以确保C++11起，静态变量将能够在满⾜ thread-safe 的前提下唯⼀地被构造和析构。

• 抽象产品类：
• 具体产品类：⼀个具体的产品对象类。
• 抽象Builder类：创建⼀个产品对象所需的各个部件的抽象接⼝。
• 具体产品的Builder类：实现抽象接⼝，构建各个部件。
• 指挥者Director类：统⼀组建过程，提供给调⽤者使⽤，通过指挥者来构造产品。

// 建造者模式
class Computer
{
public:
    Computer() {}
    void setBoard(const std::string &board)
    {
        _board = board;
    }
    void setDisplay(const std::string &display)
    {
        _display = display;
    }
    void showParamaters()
    {
        std::string param = "Computer Paramaters:\n";
        param += "\tBoard: " + _board + "\n";
        param += "\tDisolay: " + _display + "\n";
        param += "\tOS: " + _os + "\n";
        std::cout << param << std::endl;
    }
    virtual void setOS() = 0;
protected:
    std::string _board;
    std::string _display;
    std::string _os;
};

/* 具体产品类 */
class MackBook : public Computer
{
public:
    void setOS() override
    {
        _os = "Mac OS x12";
    }
};

/* 抽象建造者类：包含创建⼀个产品对象的各个部件的抽象接⼝ */
class Builder
{
public:
    virtual void buildBoard(const std::string &board) = 0;
    virtual void buildDisplay(const std::string &display) = 0;
    virtual void buildOS() = 0;
    virtual std::shared_ptr<Computer> build() = 0;
};

/* 具体产品的具体建造者类：实现抽象接⼝，构建和组装各个部件 */
class MacBookBuilder : public Builder
{
public:
    MacBookBuilder() : _computer(new MackBook()) {}
    void buildBoard(const std::string &board)
    {
        _computer->setBoard(board);
    }
    void buildDisplay(const std::string &display)
    {
        _computer->setDisplay(display);
    }
    void buildOS()
    {
        _computer->setOS();
    }
    std::shared_ptr<Computer> build()
    {
        return _computer;
    }
private:
    std::shared_ptr<Computer> _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:
    std::shared_ptr<Builder> _builder;
};

int main()
{
    Builder *builder = new MacBookBuilder();
    std::unique_ptr<Director> director(new Director(builder));
    director->construct("华硕主板", "三星显示器");
    std::shared_ptr<Computer> computer = builder->build();
    computer->showParamaters();

    return 0;
}

• 静态代理指的是，在编译时就已经确定好了代理类和被代理类的关系。也就是说，在编译时就已经确定了代理类要代理的是哪个被代理类。
• 动态代理指的是，在运⾏时才动态⽣成代理类，并将其与被代理类绑定。这意味着，在运⾏时才能确定代理类要代理的是哪个被代理类。

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

// 代理模式

/* 房东要把⼀个房⼦通过中介租出去理解代理模式 */
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";
        _landloard.rentHouse();
        std::cout << "负责租后维修\n";
    }
private:
    Landlord _landloard;
};

int main()
{
    Intermediary intermediary;
    intermediary.rentHouse();

    return 0;
}

五、日志系统框架设计

• OFF：关闭。
• DEBUG：调试，调试时的关键信息输出。
• INFO：提⽰，普通的提⽰型⽇志信息。
• WARN：警告，不影响运⾏，但是需要注意⼀下的⽇志。
• ERROR：错误，程序运⾏出现错误的⽇志。
• FATAL：致命，⼀般是代码异常导致程序⽆法继续推进运⾏的⽇志。

• %d{%H:%M:%S}：表⽰⽇期时间，花括号中的内容表⽰⽇期时间的格式。
• %T：表示制表符缩进。
• %t：表示线程ID
• %p：表示⽇志级别
• %c：表示⽇志器名称，不同的开发组可以创建⾃⼰的⽇志器进⾏⽇志输出，⼩组之间互不影
• 响。
• %f：表示⽇志输出时的源代码⽂件名。
• %l：表示⽇志输出时的源代码⾏号。
• %m：表示给与的⽇志有效载荷数据
• %n：表示换⾏

• 标准输出：表⽰将⽇志进⾏标准输出的打印。
• ⽇志⽂件输出：表⽰将⽇志写⼊指定的⽂件末尾。
• 滚动⽂件输出：当前以⽂件⼤⼩进⾏控制，当⼀个⽇志⽂件⼤⼩达到指定⼤⼩，则切换下⼀个 ⽂件进⾏输出。

后期，也可以扩展远程⽇志输出，创建客⼾端，将⽇志消息发送给远程的⽇志分析服务器。

日志器模块：对上面几个模块进行整合。（建造者模式）

• 同步日志器模块：完成日志的同步输出功能。
• 异步日志器模块：完成日志的异步输出功能。

⽇志器管理模块： 对创建的所有⽇志器进⾏统⼀管理，并提供⼀个默认⽇志器提供标准输出的⽇志输出。

异步线程模块：负责异步日志的实际落地输出。（代理模式）

六、代码设计

（一）实用类设计

• 获取系统时间
• 判断⽂件是否存在
• 获取⽂件的所在⽬录路径
• 创建⽬录

Util.hpp

整体框架：

成员接口设置成静态的，就不需实例化对象而是通过 类名::接口 直接使用即可：

#ifndef __M_UTIL_H__
#define __M_UTIL_H__

/* 实用工具类的设计: 
    1. 获取系统时间
    2. 判断文件是否存在
    3. 获取文件所在路径
    4. 创建目录
*/ 
#include <iostream>
#include <ctime>
#include <unistd.h>
#include <sys/stat.h>

namespace mylog
{
    namespace util
    {
        class Date
        {
        public:
            // 1. 获取系统时间
            static size_t nowTime()
            {
                return (size_t)time(nullptr);
            }
        };

        class File
        {
        public:
            // 2. 判断文件是否存在
            static bool exists(const std::string &pathname);
            // 3. 获取文件所在路径
            static std::string path(const std::string &pathname);
            // 4. 创建目录
            static void createDirectory(const std::string &pathname);
        };
    }
} 
#endif

接口具体实现：

获取当前时间：

 // 1. 获取系统时间
static size_t nowTime()
{
    return (size_t)time(nullptr);
}

判断文件是否存在：

stat 用于获取文件或文件系统的状态信息。可以通过这个系统函数判断文件是否存在；

也可以通过access函数调用，F_OK为文件存在性检查，但这个函数只有在Linux操作系统下才具有：

// 2. 判断文件是否存在
static bool exists(const std::string &pathname)
{
    // 此接口为POSIX(可移植操作系统接口)
    struct stat st;
    if (stat(pathname.c_str(), &st) < 0)
    {
        return false;
    }
    return true;

    // 此接口只有Linux下有，不具有可移植性
    // return (access(pathname.c_str(), F_OK) == 0);
}

获取文件路径：查找到最后一个 / 的位置，然后从起始位置截取到最后一个斜杠位置。

但需注意的是：Windows下文件路径使用 \ 分隔，Linux下为 / ，所以使用此接口查询所给字符串的任意一个字符：

// 3. 获取文件所在路径
static std::string path(const std::string &pathname)
{
    // ./abc/a.txt 
    
    size_t pos = pathname.find_last_of("/\\"); 
    if(pos == std::string::npos) return "."; // 没找到说明在当前目录下
    return pathname.substr(0, pos+1); // +1包含最后一个斜杠
}

创建目录：传入需创建目录的路径，查找第一级目录，没有则创建，有则进行查找下一级目录，直到创建指定目录成功：

// 4. 创建目录
static void createDirectory(const std::string &pathname)
{
    // ./abc/bcd/cde 

    size_t pos = 0, idx = 0;
    while(idx < pathname.size())
    {
        pos = pathname.find_first_of("/\\", idx);
        if(pos == std::string::npos)
        {
            mkdir(pathname.c_str(), 0777); // 赋予全部权限
        }
        std::string parent_dir = pathname.substr(0, pos+1);
        if(exists(parent_dir) == true) 
        {
            idx = pos+1;
            continue;
        }
        mkdir(parent_dir.c_str(), 0777); 
        idx = pos+1;
    }
}

测试：

#include "Util.hpp"

int main()
{
    std::cout << mylog::util::Date::nowTime() << std::endl;
    std::string pathname = "./abc/bcd/cde/a.txt";
    mylog::util::File::createDirectory(mylog::util::File::path(pathname));

    return 0;
}

#ifndef __M_LEVEL_H__
#define __M_LEVEL_H__

/*
   1. 定义枚举类，枚举出日志等级
   2. 提供转换接口: 将枚举转换为对应字符串
*/
namespace mylog
{
    class LogLevel
    {
    public:
        enum class value
        {
            UNKNOW = 0,
            DEBUG,
            INFO,
            WARN,
            ERROR,
            FATAL,
            OFF
        };

        static const char *toString(LogLevel::value level)
        {
            switch (level)
            {
                case LogLevel::value::DEBUG: return "DEBUG";
                case LogLevel::value::INFO: return "INFO";
                case LogLevel::value::WARN: return "WARN";
                case LogLevel::value::ERROR: return "ERROR";
                case LogLevel::value::FATAL: return "FATAL";
                case LogLevel::value::OFF: return "OFF";
            }
            return "UNKNOW";
        } 
    };
} 
#endif

测试：

#include "Util.hpp"
#include "Level.hpp"

int main()
{
    std::cout << mylog::LogLevel::toString(mylog::LogLevel::value::DEBUG) << std::endl;
    std::cout << mylog::LogLevel::toString(mylog::LogLevel::value::INFO) << std::endl;
    std::cout << mylog::LogLevel::toString(mylog::LogLevel::value::WARN) << std::endl;
    std::cout << mylog::LogLevel::toString(mylog::LogLevel::value::ERROR) << std::endl;
    std::cout << mylog::LogLevel::toString(mylog::LogLevel::value::FATAL) << std::endl;
    std::cout << mylog::LogLevel::toString(mylog::LogLevel::value::OFF) << std::endl;

    return 0;
}

成功打印出各个日志等级：

（三）日志消息类设计

中间存储一条日志消息所需的各项要素：

• 日志的输出时间        用于过滤日志输出时间
• 日志等级                   用于进行日志过滤分析
• 源文件名称
• 源代码行号               用于定位出现错误的代码位置
• 线程ID                      用于过滤出错的线程
• 日志主体消息
• 日志器名称（当前支持多日志器同时使用）

Message.hpp

#ifndef __M__MSG_H__
#define __M__MSG_H__

/* 中间存储一条日志消息所需的各项要素: */

#include "Level.hpp"
#include "Util.hpp"
#include <iostream>
#include <string>
#include <thread>

namespace mylog
{
    struct LogMsg
    {
        size_t _ctime;          // 日志产生的时间戳
        LogLevel::value _level; // 日志等级
        size_t _line;           // 行号
        std::thread::id _tid;   // 线程ID
        std::string _file;      // 源码文件名
        std::string _logger;    // 日志器名称
        std::string _payload;   // 有效消息数据

        LogMsg(LogLevel::value level,
            size_t line,
            const std::string file,
            const std::string logger,
            const std::string msg) : 
            _ctime(util::Date::nowTime()),
            _level(level),
            _line(line),
            _tid(std::this_thread::get_id()),
            _file(file),
            _logger(logger),
            _payload(msg)
        {}
    };
}
#endif

这个类没啥测试的~~

（四）日志输出格式化类设计

对日志消息进行格式化，组织为指定格式的字符串。其主要包含以下内容：

• %d ⽇期
• %T 缩进
• %t 线程id
• %p ⽇志级别
• %c ⽇志器名称
• %f ⽂件名
• %l ⾏号
• %m ⽇志消息
• %n 换⾏

格式化字符串控制了日志的输出格式，定义格式化字符，是为了让日志系统进行日志格式化更加的灵活方便。

std::vector<FormatItem::ptr> items成员：用于按序保存格式化字符串对应的⼦格式化对象。

FormatItem类主要负责⽇志消息⼦项的获取及格式化。其包含以下⼦类：

• MsgFormatItem ：表⽰要从LogMsg中取出有效⽇志数据。
• LevelFormatItem ：表⽰要从LogMsg中取出⽇志等级。
• NameFormatItem ：表⽰要从LogMsg中取出⽇志器名称。
• ThreadFormatItem ：表⽰要从LogMsg中取出线程ID。
• TimeFormatItem ：表⽰要从LogMsg中取出时间戳并按照指定格式进⾏格式化。
• CFileFormatItem ：表⽰要从LogMsg中取出源码所在⽂件名。
• CLineFormatItem ：表⽰要从LogMsg中取出源码所在⾏号。
• TabFormatItem ：表⽰⼀个制表符缩进。
• NLineFormatItem ：表⽰⼀个换⾏。
• OtherFormatItem ：表⽰⾮格式化的原始字符串（"["、"]"、":"）。

格式化子项数组对格式化字符串进行解析，保存了日志消息要素的排序，不同的格式化子项，会从日志消息中取出指定的元素，转换为字符串。

 ⽰例："[%d{%H:%M:%S}] %m%n"

pattern = "[%d{%H:%M:%S}] %m%n"
items = {
 {OtherFormatItem(), "["},
 {TimeFormatItem(), "%H:%M:%S"},
 {OtherFormatItem(), "]"},
 {MsgFormatItem (), ""},
 {NLineFormatItem (), ""}
}
LogMsg msg = {
 size_t _line = 22;
 size_t _ctime = 12345678;
 std::thread::id _tid = 0x12345678;
 std::string _name = "logger";
 std::string _file = "main.cpp";
 std::string _payload = "创建套接字失败";
 LogLevel::value _level = ERROR;
};

1. 格式化子项类的设计

对于格式化的日志消息，首先需先实现格式化子项类。

作用：从日志消息中取出指定的元素，追加到一块内存空间中。

设计思想：

1. 抽象一个格式化子项基类。
2. 基于基类，派生出不同的格式化子项子类（主体消息，日志等级，时间子项，文件名，行号，日志器名称，线程ID，制表符，换行，其他等待），这样就可以在父类中定义父类指针的数组，指向不同的格式化子项子类对象。

对于时间子类来说，需将时间戳转换成时间字符串，即分为两个步骤：

1. 时间戳 ——》 实际时间：

用到的函数为 localtime_r 。localtime 是一个在多种编程语言和环境中常见的函数，通常用于将时间戳（Unix 时间戳，即从1970年1月1日00:00:00 UTC到现在的秒数）转换为本地时间（即考虑了时区的时间）。

在C语言中，localtime 函数是一个非线程安全的函数，因为它返回指向静态数据的指针。在多线程环境中，这可能导致数据竞争和不可预测的结果。为了解决这个问题，一些系统提供了localtime_r（或localtime_s在某些平台上）这样的线程安全版本。

localtime_r函数与localtime函数的功能相同，但它接受一个额外的参数，该参数是指向struct tm的指针，用于存储结果，而不是使用静态内存。这使得多个线程可以同时调用localtime_r而不会相互干扰。

struct tm *localtime_r(const time_t *timer, struct tm *result);

• timer：指向时间戳（time_t类型）的指针。
• result：指向struct tm的指针，用于存储转换后的本地时间。

2. 实际时间 ——》时间字符串：

用到的函数为 strftime 是一个在多种编程语言中常见的函数，用于将日期和时间格式化为字符串。

size_t strftime(char *str, size_t maxsize, 
                const char *format, const struct tm *timeptr);

• str：指向用于存储格式化时间的字符数组的指针。
• maxsize：str 数组的大小。
• format：指定日期和时间格式的 C 字符串。
• timeptr：指向 struct tm 结构体的指针，该结构体包含了要格式化的日期和时间信息。

Format.hpp

#ifndef __M__FMT_H__
#define __M__FMT_H__

#include "Level.hpp"
#include "Message.hpp"
#include <vector>

namespace mylog
{
    // 抽象格式化子项基类
    class FormatItem
    {
    public:
        using ptr = std::shared_ptr<FormatItem>;
        virtual void format(std::ostream &out, LogMsg &msg) = 0;
    };

    // 派生格式化子项子类 -- 有效消息、等级、时间、文件名、行号、线程ID、日志器名、制表符、换行、其他

    // 有效消息子类
    class MsgFormatItem : public FormatItem
    {
    public:
        void format(std::ostream &out, LogMsg &msg) override
        {
            out << msg._payload;
        }
    };

    // 等级子类
    class LevelFormatItem : public FormatItem
    {
    public:
        void format(std::ostream &out, LogMsg &msg) override
        {
            out << LogLevel::toString(msg._level);
        }
    };

    // 时间子类
    class TimeFormatItem : public FormatItem
    {
    public:
        TimeFormatItem(const std::string &fmt = "%H:%M:%S") : _time_fmt(fmt) {}
        void format(std::ostream &out, LogMsg &msg) override
        {
            struct tm t;
            localtime_r(&msg._ctime, &t);
            char tmp[32] = {0};
            strftime(tmp, 31, _time_fmt.c_str(), &t);    
            out << tmp;
        }
    private:
        std::string _time_fmt; // %H:%M:%S
    };

    // 文件名子类
    class LevelFormatItem : public FormatItem
    {
    public:
        void format(std::ostream &out, LogMsg &msg) override
        {
            out << msg._file;
        }
    };

    // 行号子类
    class LineFormatItem : public FormatItem
    {
    public:
        void format(std::ostream &out, LogMsg &msg) override
        {
            out << msg._line;
        }
    };

    // 线程ID子类
    class ThreadFormatItem : public FormatItem
    {
    public:
        void format(std::ostream &out, LogMsg &msg) override
        {
            out << msg._tid;
        }
    };

    // 日志器子类
    class LoggerFormatItem : public FormatItem
    {
    public:
        void format(std::ostream &out, LogMsg &msg) override
        {
            out << msg._logger;
        }
    };

    // 制表符子类
    class TabFormatItem : public FormatItem
    {
    public:
        void format(std::ostream &out, LogMsg &msg) override
        {
            out << "\t";
        }
    };

    // 换行子类
    class NLineFormatItem : public FormatItem
    {
    public:
        void format(std::ostream &out, LogMsg &msg) override
        {
            out << "\n";
        }
    };

    // 其他子类 如: abcdefg[%d{%H}]
    class OtherFormatItem : public FormatItem
    {
    public:
        OtherFormatItem(const std::string &str) : _str(str) {}
        void format(std::ostream &out, LogMsg &msg) override
        {
            out << _str;
        }
    private:
        std::string _str;
    };
}

#endif

设计格式化完子项类就可以设计日志格式化类了。

2. 日志格式化类的设计

Format.hpp

整体框架：

#ifndef __M__FMT_H__
#define __M__FMT_H__

#include "Level.hpp"
#include "Message.hpp"
#include <vector>

namespace mylog
{
    /*
        %d 表示日期，包含子格式{%H:%M:%S}
        %t 表示线程ID
        %c 表示日志器名称
        %f 表示源码文件名
        %l 表示源码行号
        %p 表示日志级别
        %T 表示制表符缩进
        %m 表示主体消息
        %n 表示换行
    */
    class Formatter
    {
    public:
        using ptr = std::shared_ptr<Formatter>;
        Formatter(const std::string &pattern = "[%D{%H:%H:%S}][%t][%c][%f:%l][%p]%T%m%n") :
            _pattern(pattern) {}
            
        // 对msg进行格式化
        void format(std::ostream &out, LogMsg &msg);
        std::string format(LogMsg &msg);

        // 对格式话规则字符串进行解析
        bool parsePattern();
    private:
        // 根据不同的格式化字符创建不同的格式化子项对象
        FormatItem::ptr createItem(const std::string &key, const std::string &val);
    private:
        std::string _pattern; // 格式化规则字符串
        std::vector<FormatItem::ptr> _items;
    };
}

#endif

各接口具体实现：

构造函数：

Formatter(const std::string &pattern = "[%D{%H:%H:%S}][%t][%c][%f:%l][%p]%T%m%n") :
    _pattern(pattern) 
{
    assert(parsePattern());
}

格式化消息：使用字符串流来接收格式化的消息：

// 对msg进行格式化
void format(std::ostream &out, LogMsg &msg)
{
    for(auto &item : _items)
    {
        item->format(out, msg);
    }
}
std::string format(LogMsg &msg)
{
    std::stringstream ss;
    format(ss, msg);
    return ss.str();
}

根据不同的格式化字符创建不同的格式化子项对象：

// 根据不同的格式化字符创建不同的格式化子项对象
FormatItem::ptr createItem(const std::string &key, const std::string &val)
{
    if(key == "d") return std::make_shared<TimeFormatItem>(val);
    if(key == "t") return std::make_shared<ThreadFormatItem>();
    if(key == "c") return std::make_shared<LoggerFormatItem>();
    if(key == "f") return std::make_shared<FileFromatItem>();
    if(key == "l") return std::make_shared<LineFormatItem>();
    if(key == "p") return std::make_shared<LevelFormatItem>();
    if(key == "T") return std::make_shared<TabFormatItem>();
    if(key == "m") return std::make_shared<MsgFormatItem>();
    if(key == "n") return std::make_shared<NLineFormatItem>();
    return std::make_shared<OtherFormatItem>(val);
}

对格式化规则字符串进行解析：

举个例子：

规则字符串的处理过程就是一个循环的过程：

while()
{
    1. 处理原始字符串
    2. 原始字符串结束后，遇到%。则处理下一个格式胡字符
}

在处理过程中，需将处理得到的信息保存下来，例如图中的字符串：

1. key = nullptr,  val = abcde[
2. key = d,           val = %H:%M:%S
3. key = nullptr,  val = ][
4. key = p,           val = nullptr
5. key = nullptr,  val = ]
6. key = T,           val = nullptr
7. key = m,          val = nullptr
8. key = n,           val = nullptr

拿到这个数组之后，根据这个数组内容创建对应格式化子项对象，添加到 _items成员数组中：

// 对格式化规则字符串进行解析
bool parsePattern()
{
    // 1. 对格式化规则字符串进行解析
    // ab%c%cde[%d{%H:%M:%S}][%p]%T%m%n
    std::vector<std::pair<std::string, std::string>> fmt_order;
    size_t pos = 0;
    std::string key, val;
    while(pos < _pattern.size())
    {
        // 1. 处理原始字符串 - 判断是否是 % ，不是就为原始字符串
        if(_pattern[pos] != '%')
        {
            val.push_back(_pattern[pos++]);
            continue;
        }
        // 能走下来就代表pos位置就是 % 字符，%% 称为一个原始 % 字符(转义字符)
        if(pos+1 < _pattern.size() && _pattern[pos+1] == '%')
        {
            val.push_back('%'); 
            pos += 2;
            continue;
        }
        // 能走下来就代表 % 后一个字符为格式化字符，代表原始字符串处理完毕，
        // 并将原始字符串添加到格式化数组内
        if(val.empty() == false)
        {
            fmt_order.push_back(std::make_pair("", val));
            val.clear();
        }

        // 这时候为格式化字符的处理
        // pos++指向的是 % 后一个字符位置，即格式化字符位置
        pos++;
        if(pos == _pattern.size())
        {
            std::cout << "%之后没有对应的格式化字符!\n";
            return false;
        }
        key = _pattern[pos];
        pos += 1; // 这时指向的是格式化字符后一个位置
        if(pos < _pattern.size() && _pattern[pos] == '{')
        {
            pos += 1; // 这时候pos指向 { 之后，子项的起始位置
            while(pos < _pattern.size() && _pattern[pos] != '}')
            {
                val.push_back(_pattern[pos++]);
            }
            // 走到了末尾跳出了循环，则代表没有遇到 } ，代表格式是错误的
            if(pos == _pattern.size())
            {
                std::cout << "子规则{}匹配出错!\n";
                return false; // 没有找到 }
            }
            pos += 1; // 这时pos指向的为 } 位置，向后走一步走到了下次处理的新位置
        }
        fmt_order.push_back(std::make_pair(key, val));
        key.clear();
        val.clear();
    }

    // 2. 根据解析得到的数据初始化格式化子项数组成员
    for(auto &it : fmt_order)
    {
        _items.push_back(createItem(it.first, it.second));
    }
    return true;
}

功能测试：

#include "Util.hpp"
#include "Level.hpp"
#include "Message.hpp"
#include "Format.hpp"

int main()
{
    mylog::LogMsg msg(mylog::LogLevel::value::INFO, 100, "test.c", "root", "格式化功能测试...");
    mylog::Formatter fmt;
    std::string str = fmt.format(msg);
    std::cout << str << std::endl;

    return 0;
}

特殊情况测试：

双百分号：

    mylog::Formatter fmt("abc%%acb[%d{%H:%M:%S}] %m%n");

缺少 } 花括号：

    mylog::Formatter fmt("abc%%acb[%d{%H:%M:%S] %m%n");

    mylog::Formatter fmt("abc%%acb[%d{%H:%M:%S}] %m%");

特殊字符处理：%g

    mylog::Formatter fmt("abc%%acb[%d{%H:%M:%S}] %m%n[%g%g%g]");

1. 抽象出落地模块基类。
2. 不同落地方向从基类进行派生。
3. 使用工厂模式进行创建与表示的分离。

#ifndef __M_SINK_H__
#define __M_SINK_H__
/*
    抽象出落地模块基类。
    不同落地方向从基类进行派生。
    使用工厂模式进行创建与表示的分离。
*/

#include "Util.hpp"
#include <memory>
#include <iostream>
#include <fstream>

namespace mylog
{
    class LogSink
    {
    public:
        using ptr = std::shared_ptr<LogSink>;
        LogSink();
        virtual ~LogSink();
        virtual void log(const char *data, size_t len) = 0;
    };

    // 落地方向: 标准输出
    class StdoutSink : public LogSink
    {
    public:
        // 将日志消息写入到标准输出
        void log(const char *data, size_t len);
    };

    // 落地方向: 指定文件
    class FileSink : public LogSink
    {
    public:
        // 构造是传入文件名，并打开文件，将操作句柄管理起来
        FileSink(const std::string &pathname);
        
        // 将日志消息写入到标准输出
        void log(const char *data, size_t len);
    private:
        std::string _pathname;
        std::ofstream _ofs;
    };

    // 落地方向: 滚动文件 (以大小进行滚动)
    class RollBySizeSink : public LogSink
    {
    public:
        // 构造时传入文件名，并打开文件，将操作句柄管理起来
        RollBySizeSink(const std::string &basename, size_t max_size);
        
        // 将日志消息写入到标准输出 - 写入前判断文件大小，超过了最大大小就需切换文件
        void log(const char *data, size_t len);
    private:
        // 进行大小判断，超过指定大小就创建新文件
        void createNewFile(); 
    private:
        // 通过基础文件名 + 扩展文件名(以时间生成)组成一个实际的当前输出文件名
        std::string _basename; // ./log/base-        ——> ./long/base-525623462346.log
        std::ofstream _ofs;
        size_t _max_fsize; // 记录最大大小，当前文件超过了这个大小就要切换文件
        size_t _cur_fsize; // 记录当前文件已经写入的数据大小
    };
}

#endif

落地标准输出方向类成员接口具体实现：

// 落地方向: 标准输出
class StdoutSink : public LogSink
{
public:
    // 将日志消息写入到标准输出
    void log(const char *data, size_t len)
    {
        std::cout.write(data, len); 
    }
};

落地指定文件方向类成员接口具体实现：

// 落地方向: 指定文件
class FileSink : public LogSink
{
public:
    // 构造是传入文件名，并打开文件，将操作句柄管理起来
    FileSink(const std::string &pathname) : _pathname(pathname)
    {
        // 1. 创建日志文件所在目录
        util::File::createDirectory(util::File::path(pathname));
        // 2. 创建并打开日志文件，以二进制格式和追加形式打开
        _ofs.open(_pathname, std::ios::binary | std::ios::app); 
        assert(_ofs.is_open());
    }
    
    // 将日志消息写入到标准输出
    void log(const char *data, size_t len)
    {
        _ofs.write(data, len);
        assert(_ofs.good());
    }
private:
    std::string _pathname;
    std::ofstream _ofs;
};

落地滚动文件方向类成员接口具体实现：

滚动⽇志⽂件输出的必要性：

• 由于机器磁盘空间有限， 我们不可能⼀直⽆限地向⼀个⽂件中增加数据。
• 如果⼀个⽇志⽂件体积太⼤，⼀⽅⾯是不好打开，另⼀⽅⾯是即时打开了由于包含数据巨 ⼤，也不利于查找我们需要的信息。
• 所以实际开发中会对单个⽇志⽂件的⼤⼩也会做⼀些控制，即当⼤⼩超过某个⼤⼩时（如 1GB），我们就重新创建⼀个新的⽇志⽂件来滚动写⽇志。 对于那些过期的⽇志， ⼤部分企业内部都有专⻔的运维⼈员去定时清理过期的⽇志，或者设置系统定时任务，定时清理过 期⽇志。

⽇志⽂件滚动的条件有两个：文件大小 和 时间。我们可以选择：

• ⽇志⽂件在⼤于 1GB 的时候会更换新的⽂件。
• 每天定点滚动⼀个⽇志⽂件。

本项⽬基于文件大小 的判断滚动⽣成新的⽂件。

注意：如果我们设置的最大大小太小（下面程序中设置成了1MB），导致程序可能会在一秒钟之内生成多个同名文件，所以我们可以添加一个计数器区分文件名。

// 落地方向: 滚动文件 (以大小进行滚动)
class RollBySizeSink : public LogSink
{
public:
    // 构造时传入文件名，并打开文件，将操作句柄管理起来
    RollBySizeSink(const std::string &basename, size_t max_size) :
        _basename(basename), _max_fsize(max_size), _cur_fsize(0), _name_coumt(0)
    {
        std::string pathname = createNewFile();
        // 1. 创建日志文件所在目录
        util::File::createDirectory(util::File::path(pathname));
        // 2. 创建并打开日志文件，以二进制格式和追加形式打开
        _ofs.open(pathname, std::ios::binary | std::ios::app); 
        assert(_ofs.is_open());
    }
    
    // 将日志消息写入到文件 - 写入前判断文件大小，超过了最大大小就需切换文件
    void log(const char *data, size_t len)
    {
        if(_cur_fsize >= _max_fsize)
        {
            _ofs.close(); // 关闭原来已经打开的文件
            std::string pathname = createNewFile();
            _ofs.open(pathname, std::ios::binary | std::ios::app); 
            assert(_ofs.is_open());
            _cur_fsize = 0;
        }
        _ofs.write(data, len);
        assert(_ofs.good());
        _cur_fsize += len;
    }
private:
    // 进行大小判断，超过指定大小就创建新文件
    std::string createNewFile()
    {
        // 获取系统时间，以时间来构造文件名扩展名
        time_t t = util::Date::nowTime();
        struct tm lt;
        localtime_r(&t, &lt);
        std::stringstream filename;
        filename << _basename;
        filename << lt.tm_year + 1900; // 时间戳从1900/01/01 00:00:00开始的
        filename << "-";
        filename << lt.tm_mon + 1;     // 系统月份默认为从 0 开始，所以需+1
        filename << "-";
        filename << lt.tm_mday;
        filename << " ";
        filename << lt.tm_hour;
        filename << ":";
        filename << lt.tm_min;
        filename << ":";
        filename << lt.tm_sec;
        filename << "-";
        filename << _name_coumt++;
        filename << ".log";
        return filename.str();
    }
private:
    // 通过基础文件名 + 扩展文件名(以时间生成)组成一个实际的当前输出文件名
    size_t _name_coumt; // 如果我们设置的最大大小太小，导致程序可能会在一秒钟之内生成多个同名文件，所以我们可以添加一个计数器区分文件名
    std::string _basename; // ./log/base-        ——> ./long/base-525623462346.log
    std::ofstream _ofs;
    size_t _max_fsize; // 记录最大大小，当前文件超过了这个大小就要切换文件
    size_t _cur_fsize; // 记录当前文件已经写入的数据大小
};

实现了以上功能类，还差一个工厂类来创建不同的功能类：

使用模版跟不定参来解决创建不同的功能类与其成员接口参数不一致的问题：

#ifndef __M_SINK_H__
#define __M_SINK_H__
/*
    抽象出落地模块基类。
    不同落地方向从基类进行派生。
    使用工厂模式进行创建与表示的分离。
*/

#include "Util.hpp"
#include <memory>
#include <iostream>
#include <fstream>
#include <sstream>
#include <cassert>

namespace mylog
{
    // ...
    
    // 落地方向工厂
    class SinkFactory
    {
    public:
        template <typename SinkType, typename ...Args>
        static LogSink::ptr create(Args &&...args)
        {
            return std::make_shared<SinkType>(std::forward<Args>(args)...);
        }
    };
}

#endif

#include "Util.hpp"
#include "Level.hpp"
#include "Message.hpp"
#include "Format.hpp"
#include "Sink.hpp"

int main()
{
    mylog::LogMsg msg(mylog::LogLevel::value::INFO, 100, "test.c", "root", "格式化功能测试...");
    mylog::Formatter fmt;
    std::string str = fmt.format(msg);

    mylog::LogSink::ptr stdout_lsp = mylog::SinkFactory::create<mylog::StdoutSink>();
    mylog::LogSink::ptr file_lsp = mylog::SinkFactory::create<mylog::FileSink>("./logfile/test.log");
    mylog::LogSink::ptr roll_lsp = mylog::SinkFactory::create<mylog::RollBySizeSink>("./logfile/roll-", 1024*1024);

    stdout_lsp->log(str.c_str(), str.size());
    file_lsp->log(str.c_str(), str.size());
    size_t cursize = 0;
    size_t count = 0;
    while(cursize < 1024 * 1024 * 10)
    {
        std::string tmp = str + std::to_string(count++);
        roll_lsp->log(tmp.c_str(), tmp.size());
        cursize += tmp.size();
    }

    return 0;
}

可以看到：

标准输出打印成功

落地文件创建成功，再查看里面的日志：

滚动文件创建了10个，每个都超过了1MB，再选择一个来查看里面的日志：

#include "Util.hpp"
#include "Level.hpp"
#include "Message.hpp"
#include "Format.hpp"
#include "Sink.hpp"
#include <unistd.h>

/* 
扩展一个以时间作为入职文件滚动切换类型的日志落地模块
    以时间进行文件滚动，实际上是以时间段进行滚动
    实现思想: 以当前系统时间，取模时间段大小，可以得到当前时间是第几个时间段，
    每次以当前系统时间取模，判断与当前文件的时间是否一致，不一致代表不是同一个时间段。 
*/

enum class TimeGap
{
    GAP_SECOND,
    GAP_MINUTE,
    GAP_HOUR,
    GAP_DAY
};

// 落地方向: 滚动文件 (以时间进行滚动)
class RollByTimeSink : public mylog::LogSink
{
public:
    // 构造时传入文件名，并打开文件，将操作句柄管理起来
    RollByTimeSink(const std::string &basename, TimeGap gap_type) :
        _basename(basename)
    {
        switch(gap_type)
        {
            case TimeGap::GAP_SECOND: _gap_size = 1; break;
            case TimeGap::GAP_MINUTE: _gap_size = 60; break;
            case TimeGap::GAP_HOUR: _gap_size = 3600; break;
            case TimeGap::GAP_DAY: _gap_size = 3600*24; break;
        }
        _cur_gap = _gap_size == 1 ? mylog::util::Date::nowTime() : mylog::util::Date::nowTime() % _gap_size; // 获取当前是第几个时间段
        std::string filename = createNewFile();
        // 1. 创建日志文件所在目录
        mylog::util::File::createDirectory(mylog::util::File::path(filename));
        // 2. 创建并打开日志文件，以二进制格式和追加形式打开
        _ofs.open(filename, std::ios::binary | std::ios::app); 
        assert(_ofs.is_open());
    }
    
    // 将日志消息写入到文件 - 写入前判断文件时间段
    void log(const char *data, size_t len)
    {
        time_t cur = mylog::util::Date::nowTime();
        if((cur % _gap_size) != _cur_gap)
        {
            _ofs.close();
            std::string filename = createNewFile();
            _ofs.open(filename, std::ios::binary | std::ios::app);
            assert(_ofs.is_open());
        }
        _ofs.write(data, len);
        assert(_ofs.good());
    }
private:
    // 进行大小判断，超过指定大小就创建新文件
    std::string createNewFile()
    {
        // 获取系统时间，以时间来构造文件名扩展名
        time_t t = mylog::util::Date::nowTime();
        struct tm lt;
        localtime_r(&t, &lt);
        std::stringstream filename;
        filename << _basename;
        filename << lt.tm_year + 1900; // 时间戳从1900/01/01 00:00:00开始的
        filename << "-";
        filename << lt.tm_mon + 1;     // 系统月份默认为从 0 开始，所以需+1
        filename << "-";
        filename << lt.tm_mday;
        filename << " ";
        filename << lt.tm_hour;
        filename << ":";
        filename << lt.tm_min;
        filename << ":";
        filename << lt.tm_sec;
        filename << "-";
        filename << ".log";
        return filename.str();
    }
private:
    std::string _basename; 
    std::ofstream _ofs;
    size_t _cur_gap;  // 当前是第几个时间段
    size_t _gap_size; // 时间段的大小
};

int main()
{
    mylog::Formatter fmt;
    std::string str = fmt.format(msg);
    
    // 以一秒作为时间间隔
    mylog::LogSink::ptr time_lsp = mylog::SinkFactory::create<RollByTimeSink>("./logfile/roll-", TimeGap::GAP_SECOND);
    time_t old = mylog::util::Date::nowTime();
    while(mylog::util::Date::nowTime() < old + 5)
    {
        time_lsp->log(str.c_str(), str.size());
        usleep(1000);
    }

    return 0;
}

这里我们测试以一秒作为时间间隔，预期生成五个日志消息文件，查看运行结果：

这里43秒时的文件大小与其他时间段的文件大小差了很多，因为此时的43秒不是一个完整的时间段，即不是完整的一秒：

namespace mylog
{
    // 日志器管理类
    class LoggerManager
    {
    public:
        static LoggerManager& getInstance()
        {
            // 在C++11之后，针对静态局部变量，编译器在编译的层面实现了线程安全
            // 当静态局部变量在没有构造完成之前，其他的线程进入就会阻塞
            static LoggerManager eton;
            return eton;
        }
        void addLogger(Logger::ptr &logger)
        {
            if(hasLogger(logger->getName())) return;
            std::unique_lock<std::mutex> lock(_mutex);
            _loggers.insert(std::make_pair(logger->getName(), logger));
        }
        bool hasLogger(const std::string &name)
        {
            std::unique_lock<std::mutex> lock(_mutex);
            auto it = _loggers.find(name);
            if(it == _loggers.end())
                return false;
            return true;
        }
        Logger::ptr getLogger(const std::string &name)
        {
            std::unique_lock<std::mutex> lock(_mutex);
            auto it = _loggers.find(name);
            if(it == _loggers.end())
                return Logger::ptr();
            return it->second;
        }
        Logger::ptr rootLogger() { return _root_logger; }
    private:
        LoggerManager() 
        {
            std::unique_ptr<mylog::LoggerBuilder> builder(new mylog::LocalLoggerBuilder());
            builder->buildLoggerName("root");
            _root_logger = builder->build();
            _loggers.insert(std::make_pair("root", _root_logger));
        }
    private:
        std::mutex _mutex;
        Logger::ptr _root_logger; // 默认日志器
        std::unordered_map<std::string, Logger::ptr> _loggers;
    };
}

实现了管理类后，就可以派生出具体的建造者类 -- 全局的日志器建造者(添加了全局单例管理器之后，将日志器添加全局管理)：

namespace mylog
{
    // 2. 派生出具体的建造者类 -- 全局的日志器建造者(添加了全局单例管理器之后，将日志器添加全局管理)
    class GlobalLoggerBuilder : public LoggerBuilder
    {
    public:
        Logger::ptr build() override
        {
            assert(_logger_name.empty() == false); // 必须有日志器名称
            if(_formatter.get() == nullptr)
            {
                _formatter = std::make_shared<Formatter>();
            }
            if(_sinks.empty())
            {
                buildSink<StdoutSink>();
            }
            Logger::ptr logger;
            if(_logger_type == LoggerType::LOGGER_ASYNC) { 
                // 异步
                logger =  std::make_shared<AsyncLogger>(_logger_name, _limit_level, _formatter, _sinks, _looper_type);
            }else{
                // 同步
                logger =  std::make_shared<SyncLogger>(_logger_name, _limit_level, _formatter, _sinks);
            }
            LoggerManager::getInstance().addLogger(logger);
            return logger;
        }
    };
}

编写测试代码，运行并查看结果测试全局管理日志器：

#include "Util.hpp"
#include "Level.hpp"
#include "Message.hpp"
#include "Format.hpp"
#include "Sink.hpp"
#include "Logger.hpp"
#include "Buffer.hpp"
#include "Looper.hpp"
#include <unistd.h>
#include <memory>

// 测试全局管理日志器
void test_log()
{
    mylog::Logger::ptr logger = mylog::LoggerManager::getInstance().getLogger("async_logger");

    logger->debug(__FILE__, __LINE__, "%s", ":测试日志");
    logger->info(__FILE__, __LINE__, "%s", "测试日志");
    logger->warn(__FILE__, __LINE__, "%s", "测试日志");
    logger->error(__FILE__, __LINE__, "%s", "测试日志");
    logger->fatal(__FILE__, __LINE__, "%s", "测试日志");

    size_t count = 0;
    while(count < 500000)
    {
        logger->fatal(__FILE__, __LINE__, "测试日志-%d", count++);
    }
}
int main()
{
    std::unique_ptr<mylog::LoggerBuilder> builder(new mylog::GlobalLoggerBuilder());
    builder->buildLoggerName("async_logger");
    builder->buildLoggerLevel(mylog::LogLevel::value::WARN);
    builder->buildFormatter("[%c]%m%n");
    builder->buildLoggerType(mylog::LoggerType::LOGGER_ASYNC);
    builder->buildEnableUnSafeAsync();
    builder->buildSink<mylog::FileSink>("./asynclogfile/async.log");
    builder->buildSink<mylog::StdoutSink>();
    builder->build();
    
    test_log();

    return 0;
}

运行结果查看日志消息，可以看到标准输出和指定文件都输出了50003条（1条warn、1条error、1条fatal、500000条fatal）数据，都符合预期：

#ifndef __M_MYLOG_H__
#define __M_MYLOG_H__

#include "Logger.hpp"

namespace mylog
{
    // 1. 提供获取指定日志器的全局接口(避免用户自己操作单例对象)
    Logger::ptr getLogger(const std::string &name)
    {
        return mylog::LoggerManager::getInstance().getLogger(name);
    }
    Logger::ptr rootLogger()
    {
        return mylog::LoggerManager::getInstance().rootLogger();
    }

    // 2. 使用宏函数对日志器的接口进行代理（代理模式）。
    #define debug(fmt, ...) debug(__FILE__, __LINE__, fmt, ##__VA_ARGS__)
    #define info(fmt, ...) info(__FILE__, __LINE__, fmt, ##__VA_ARGS__)
    #define warn(fmt, ...) warn(__FILE__, __LINE__, fmt, ##__VA_ARGS__)
    #define error(fmt, ...) error(__FILE__, __LINE__, fmt, ##__VA_ARGS__)
    #define fatal(fmt, ...) fatal(__FILE__, __LINE__, fmt, ##__VA_ARGS__)

    // 3. 提供宏函数，直接通过默认日志器进行日志的标准输出打印（不用获取日志器了）。
    #define DEBUG(fmt, ...) mylog::rootLogger()->debug(fmt, ##__VA_ARGS__)
    #define INFO(fmt, ...) mylog::rootLogger()->info(fmt, ##__VA_ARGS__)
    #define WARN(fmt, ...) mylog::rootLogger()->warn(fmt, ##__VA_ARGS__)
    #define ERROR(fmt, ...) mylog::rootLogger()->error(fmt, ##__VA_ARGS__)
    #define FATAL(fmt, ...) mylog::rootLogger()->fatal(fmt, ##__VA_ARGS__)
}

#endif

编写测试代码，测试通过宏函数能否落地到指定文件：

#include "mylog.h"
#include <unistd.h>

// 测试日志器
void test_log()
{
    mylog::Logger::ptr logger = mylog::LoggerManager::getInstance().getLogger("async_logger");
    logger->debug("%s", "测试日志");
    logger->info("%s", "测试日志");
    logger->warn("%s", "测试日志");
    logger->error("%s", "测试日志");
    logger->fatal("%s", "测试日志");
    size_t count = 0;
    while (count < 500000)
    {
        logger->fatal("测试日志-%d", count++);
    }
}
int main()
{
    std::unique_ptr<mylog::LoggerBuilder> builder(new mylog::GlobalLoggerBuilder());
    builder->buildLoggerName("async_logger");
    builder->buildLoggerLevel(mylog::LogLevel::value::WARN);
    builder->buildFormatter("[%c][%f:%l]%m%n");
    builder->buildLoggerType(mylog::LoggerType::LOGGER_ASYNC);
    builder->buildEnableUnSafeAsync();
    builder->buildSink<mylog::FileSink>("./asynclogfile/async.log");
    builder->buildSink<mylog::StdoutSink>();
    builder->build();
    
    test_log();

    return 0;
}

测试通过默认日志器宏函数，能否进行标准输出打印：

// 测试日志器
void test_log()
{
    DEBUG("%s", "测试日志");
    INFO("%s", "测试日志");
    WARN("%s", "测试日志");
    ERROR("%s", "测试日志");
    FATAL("%s", "测试日志");

    size_t count = 0;
    while(count < 500000)
    {
        FATAL("测试日志-%d", count++);
    }
}

（一）整体测试代码（功能样例代码）测试

各个组件功能打包成一个目录，进行测试：

/example/test.cc

#include "../logsys/mylog.h"
#include <unistd.h>

// 测试日志器
void test_log(const std::string &name)
{
    INFO("%s", "测试开始");

    mylog::Logger::ptr logger = mylog::LoggerManager::getInstance().getLogger(name);
    logger->debug("%s", "测试日志");
    logger->info("%s", "测试日志");
    logger->warn("%s", "测试日志");
    logger->error("%s", "测试日志");
    logger->fatal("%s", "测试日志");

    INFO("%s", "测试结束");
}
int main()
{
    std::unique_ptr<mylog::LoggerBuilder> builder(new mylog::GlobalLoggerBuilder());
    builder->buildLoggerName("async_logger");
    builder->buildLoggerLevel(mylog::LogLevel::value::DEBUG);
    builder->buildFormatter("[%c][%f:%l][%p]%m%n");
    builder->buildLoggerType(mylog::LoggerType::LOGGER_SYNC);
    builder->buildSink<mylog::FileSink>("./logfile/sync.log");
    builder->buildSink<mylog::StdoutSink>();
    builder->buildSink<mylog::RollBySizeSink>("./logfile/roll-sync-by-size.log", 1024*1024);
    builder->build();
    
    test_log("async_logger");

    return 0;
}

运行程序可以看到标准输出、指定文件、滚动文件都落地到位：

#include "../logsys/mylog.h"
#include <unistd.h>

/* 
扩展一个以时间作为入职文件滚动切换类型的日志落地模块
    以时间进行文件滚动，实际上是以时间段进行滚动
    实现思想: 以当前系统时间，取模时间段大小，可以得到当前时间是第几个时间段，
    每次以当前系统时间取模，判断与当前文件的时间是否一致，不一致代表不是同一个时间段。 
*/

enum class TimeGap
{
    GAP_SECOND,
    GAP_MINUTE,
    GAP_HOUR,
    GAP_DAY
};

// 落地方向: 滚动文件 (以时间进行滚动)
class RollByTimeSink : public mylog::LogSink
{
public:
    // 构造时传入文件名，并打开文件，将操作句柄管理起来
    RollByTimeSink(const std::string &basename, TimeGap gap_type) :
        _basename(basename)
    {
        switch(gap_type)
        {
            case TimeGap::GAP_SECOND: _gap_size = 1; break;
            case TimeGap::GAP_MINUTE: _gap_size = 60; break;
            case TimeGap::GAP_HOUR: _gap_size = 3600; break;
            case TimeGap::GAP_DAY: _gap_size = 3600*24; break;
        }
        _cur_gap = _gap_size == 1 ? mylog::util::Date::nowTime() : mylog::util::Date::nowTime() % _gap_size; // 获取当前是第几个时间段
        std::string filename = createNewFile();
        // 1. 创建日志文件所在目录
        mylog::util::File::createDirectory(mylog::util::File::path(filename));
        // 2. 创建并打开日志文件，以二进制格式和追加形式打开
        _ofs.open(filename, std::ios::binary | std::ios::app); 
        assert(_ofs.is_open());
    }
    
    // 将日志消息写入到文件 - 写入前判断文件时间段
    void log(const char *data, size_t len)
    {
        time_t cur = mylog::util::Date::nowTime();
        if((cur % _gap_size) != _cur_gap)
        {
            _ofs.close();
            std::string filename = createNewFile();
            _ofs.open(filename, std::ios::binary | std::ios::app);
            assert(_ofs.is_open());
        }
        _ofs.write(data, len);
        assert(_ofs.good());
    }
private:
    // 进行大小判断，超过指定大小就创建新文件
    std::string createNewFile()
    {
        // 获取系统时间，以时间来构造文件名扩展名
        time_t t = mylog::util::Date::nowTime();
        struct tm lt;
        localtime_r(&t, &lt);
        std::stringstream filename;
        filename << _basename;
        filename << lt.tm_year + 1900; // 时间戳从1900/01/01 00:00:00开始的
        filename << "-";
        filename << lt.tm_mon + 1;     // 系统月份默认为从 0 开始，所以需+1
        filename << "-";
        filename << lt.tm_mday;
        filename << " ";
        filename << lt.tm_hour;
        filename << ":";
        filename << lt.tm_min;
        filename << ":";
        filename << lt.tm_sec;
        filename << "-";
        filename << ".log";
        return filename.str();
    }
private:
    std::string _basename; 
    std::ofstream _ofs;
    size_t _cur_gap;  // 当前是第几个时间段
    size_t _gap_size; // 时间段的大小
};

int main()
{
    std::unique_ptr<mylog::LoggerBuilder> builder(new mylog::GlobalLoggerBuilder());
    builder->buildLoggerName("async_logger");
    builder->buildLoggerLevel(mylog::LogLevel::value::WARN);
    builder->buildFormatter("[%c][%f:%l]%m%n");
    builder->buildLoggerType(mylog::LoggerType::LOGGER_ASYNC);
    builder->buildSink<RollByTimeSink>("./logfile/roll-async-by-size.log", TimeGap::GAP_SECOND);
    mylog::Logger::ptr logger = builder->build();

    size_t cur = mylog::util::Date::nowTime();
    while(mylog::util::Date::nowTime() < cur + 5)
    {
        logger->fatal("这是一条测试日志");
        usleep(1000);
    }
    
    return 0;
}

八、性能测试

测试三要素：

• 测试环境：
• 测试方法：
• 测试结果：

测试环境：

测试工具的编写：

• 可以控制写日志线程数量
• 可以控制写日志的总数量

方法：分别对于同步日志器 & 异步日志器在单多线程下生成指定数量的日志消息总耗时的性能测试：

• 需要测试单写日志线程的性能
• 需要测试多写日志线程的性能

实现：

1. 封装一个接口，传入日志器名称，线程数量，日志数量，单条日志大小。
2. 在接口内，创建指定数量的线程，各自负责一部分日志的输出。
3. 在输出之前计时开始，在输出完毕后即使结束，所耗时间 = 结束时间 - 起始时间。
4. 每秒输出量 = 日志数量 / 总耗时。
5. 每秒输出大小 = 日志数量 * 单条日志大小 / 总耗时。

注意：异步日志输出启动非安全模式，纯内存写入（不去考虑实际落地的时间）。

#include "../logsys/mylog.h"
#include <chrono>

void bench(const std::string &logger_name, size_t thr_count, size_t msg_count, size_t msg_len)
{
    // 1. 获取日志器
    mylog::Logger::ptr logger = mylog::getLogger(logger_name);
    if(logger.get() == nullptr)
    {
        return ;
    }
    std::cout << "测试日志: " << msg_count << "条，总大小: " << (msg_count * msg_len) / 1024 << "KB\n";

    // 2. 组织指定长度的日志消息
    std::string msg(msg_len-1, 'A'); // 少一个字节是为了给末尾到时候添加换行

    // 3. 创建指定数量的线程
    std::vector<std::thread> threads;
    std::vector<double> cost_arry(thr_count);
    size_t msg_per_thr = msg_count / thr_count; // 总日志数量 / 线程数量就是每个线程要输出的日志数量
    for(int i = 0; i < thr_count; i++)
    {
        threads.emplace_back([&, i]()
        {
            // 4. 线程函数内部开始计时
            auto start = std::chrono::high_resolution_clock::now();
            // 5. 开始循环写日志
            for(int j = 0; j < msg_per_thr; j++)
            {
                logger->fatal("%s", msg.c_str());
            }
            // 6. 线程函数内部结束计时
            auto end = std::chrono::high_resolution_clock::now();
            std::chrono::duration<double> cost = end - start;
            cost_arry[i] = cost.count();
            std::cout << "\t线程" << i << ": " << "\t输出数量: " << msg_per_thr << ", 耗时: " << cost.count() << "s" << std::endl;
        });
    }
    for(int i = 0; i < thr_count; i++)
    {
        threads[i].join();
    }

    // 7. 计算总耗时: 在多线程中，每个线程都会耗费时间，但是线程时并发处理的，因此耗时最高的那个就是总时间
    double max_cost = cost_arry[0];
    for(int i = 0; i < thr_count; i++)
    {
        max_cost = max_cost < cost_arry[i] ? cost_arry[i] : max_cost;
    }
    size_t msg_per_sec = msg_count / max_cost;
    size_t size_per_sec = (msg_count * msg_len) / (max_cost * 1024);

    // 8. 进行输出打印
    std::cout << "\t总耗时: " << max_cost << "s\n";
    std::cout << "\t每秒输出日志数量: " << msg_per_sec << "条\n";
    std::cout << "\t每秒输出日志大小: " << size_per_sec << "KB\n";
}

void sync_bench()
{
    std::unique_ptr<mylog::LoggerBuilder> builder(new mylog::GlobalLoggerBuilder());
    builder->buildLoggerName("sync_logger");
    builder->buildFormatter("%m%n");
    builder->buildLoggerType(mylog::LoggerType::LOGGER_SYNC);
    builder->buildSink<mylog::FileSink>("./logfile/sync.log");
    builder->build();
    // bench("sync_logger", 1, 1000000, 100);
    bench("sync_logger", 3, 1000000, 100);
}

void async_bench()
{
    std::unique_ptr<mylog::LoggerBuilder> builder(new mylog::GlobalLoggerBuilder());
    builder->buildLoggerName("async_logger");
    builder->buildFormatter("%m%n");
    builder->buildLoggerType(mylog::LoggerType::LOGGER_ASYNC);
    builder->buildEnableUnSafeAsync(); // 开启非安全模式 - 主要是为了将落地时间排除在外
    builder->buildSink<mylog::FileSink>("./logfile/async.log");
    builder->build();
    // bench("async_logger", 1, 1000000, 100);
    bench("async_logger", 3, 1000000, 100);
}

int main()
{
    // sync_bench();
    async_bench();

}

测试结果：同步下多线程比单线程慢：单线程不涉及到锁冲突，每次都加锁、写日志，加锁、写日志...，是一个串行化的过程；但多线程就涉及到锁冲突，另外磁盘性能也上限了 ，导致多线程性能反而降低了：

测试结果：异步下可以看到安全与非安全模式二者消耗时间差不了多少，在非安全模式下也就少了一丢丢时间，也就是少了实际落地的时间：