C++ 手写日志模块：基于策略模式实现高性能日志系统

刷新策略

利用 C++ 的多态特性，先创建一个日志刷新基类，然后根据日志具体往哪刷新写具体的派生类函数。

1. 将日志内容刷新到文件中时需要在当前工作目录下新建一个文件夹，因为日志需要根据不同的日志等级把日志内容写到不同的文件里。
2. 使用 C++17 提供的文件操作接口 <filesystem>，在派生类 FileLogStrategy 的构造函数里先将指定目录文件创建好。判断在当前工作目录下指定目录文件存不存在，若存在直接返回，若存在则新建该指定目录文件。创建目录时需要 try-catch 捕获异常。
3. 实现 SyncLog 往日志文件中刷新日志内容。拼接目标文件路径，然后使用 C++ 风格的文件操作对指定文件写入日志内容。

// logger.hpp
// 策略模式，策略接口
class LogStrategy {
public:
    virtual ~LogStrategy() = default;
    virtual void SyncLog(const std::string &logmessage) = 0;
};

// 控制台日志策略
class ConsoleLogStrategy : public LogStrategy {
public:
    ~ConsoleLogStrategy() {}
    void SyncLog(const std::string &logmessage) override {
        { LockGuard lockguard(&_lock);
            std::cout << logmessage << std::endl;
        }
    }
private:
    Mutex _lock;
};

// 日志向文件打印
const std::string logdefaultpath = "log";
const static std::string logdefaultfilename = "test.log";

class FileLogStrategy : public LogStrategy {
public:
    FileLogStrategy(const std::string &dir = logdefaultpath, const std::string &filename = logdefaultfilename)
        :_dir_path_name(dir),_filename(filename) {
        { LockGuard lockguard(&_lock);
            if(std::filesystem::exists(_dir_path_name)) return;
            try {
                std::filesystem::create_directories(_dir_path_name);
            } catch(const std::filesystem::filesystem_error &e) {
                std::cerr << e.what()<<'
';
            }
        }
    }
    void SyncLog(const std::string &logmessage) override {
        { LockGuard lockguard(&_lock);
            std::string target = _dir_path_name; target += "/"; target += _filename;
            std::ofstream out(target.c_str(), std::ios::app);
            if(!out.is_open()) return;
            out << logmessage <<"
";
            out.close();
        }
    }
    ~FileLogStrategy() {}
private:
    std::string _dir_path_name;
    std::string _filename;
    Mutex _lock;
};

测试代码：

// main.cc
#include "Logger.hpp"
int main() {
    std::unique_ptr<LogStrategy> logger_ptr = std::make_unique<FileLogStrategy>();
    logger_ptr->SyncLog("test");
    return 0;
}

获取日志时间

1. 利用 time 系统调用获取时间戳。
2. 利用 localtime_r 函数将时间戳转化为 struct tm 结构体。
3. 用 snprintf 将年月日时分秒转化为字符串。注意 struct tm 中年减了 1900，月是 0-11，需手动调整。

std::string GetCurrentTime() {
    time_t curtime = time(nullptr);
    struct tm currtm;
    localtime_r(&curtime,&currtm);
    char timebuffer[64];
    snprintf(timebuffer,sizeof(timebuffer),"%4d-%02d-%02d %02d:%02d:%02d", currtm.tm_year +1900, currtm.tm_mon +1, currtm.tm_mday, currtm.tm_hour, currtm.tm_min, currtm.tm_sec );
    return timebuffer;
}

logger 类实现

激活策略，开启什么策略，就把策略对应的派生类对象创建出来。

class Logger {
public:
    Logger() {}
    void EnableConsoleLogStrategy(){ _strategy = std::make_unique<ConsoleLogStrategy>(); }
    void EnableFileLogStrategy(){ _strategy = std::make_unique<FileLogStrategy>(); }
    ~Logger() {}
private:
    std::unique_ptr<LogStrategy> _strategy;
};

利用内部类 LogMessage 将各种日志信息拼接成一个字符串，在 LogMessage 的析构函数中调用 logger 成员变量_strategy 的刷新函数将字符串刷新出去，这也是 RAII 风格的设计思路。

内部类 LogMessage 实现

LogMessage 的构造函数利用初始化列表初始化，然后用 stringstream 类对象 ss 将各种类型的成员变量格式化为字符串。 LogMessage 的 operator<< 重载输出运算符，参数类型设置成模板，这样任意类型参数都可以输出。 LogMessage 的析构函数中将_loginfo 的日志信息刷新出去。

日志刷新流程图及源码

//logger.hpp
#pragma once
#include<iostream>
#include<filesystem>
#include<fstream>
#include<string>
#include<sstream>
#include<ctime>
#include<memory>
#include<unistd.h>
#include"Mutex.hpp"

enum class LogLevel {
    DEBUG,
    INFO,
    WARNING,
    ERROR,
    FATAL
};

std::string Level_to_string(LogLevel level) {
    switch(level) {
        case LogLevel::DEBUG: return "DEBUG";
        case LogLevel::INFO: return "INFO";
        case LogLevel::WARNING: return "WARNING";
        case LogLevel::ERROR: return "ERROR";
        case LogLevel::FATAL: return "FATAL";
        default: return "Unknown";
    }
}

std::string GetCurrentTime() {
    time_t curtime = time(nullptr);
    struct tm currtm;
    localtime_r(&curtime,&currtm);
    char timebuffer[64];
    snprintf(timebuffer,sizeof(timebuffer),"%4d-%02d-%02d %02d:%02d:%02d", currtm.tm_year +1900, currtm.tm_mon +1, currtm.tm_mday, currtm.tm_hour, currtm.tm_min, currtm.tm_sec);
    return timebuffer;
}

class LogStrategy {
public:
    virtual ~LogStrategy() = default;
    virtual void SyncLog(const std::string &logmessage) = 0;
};

class ConsoleLogStrategy : public LogStrategy {
public:
    ~ConsoleLogStrategy() {}
    void SyncLog(const std::string &logmessage) override {
        { LockGuard lockguard(&_lock);
            std::cout << logmessage << std::endl;
        }
    }
private:
    Mutex _lock;
};

const std::string logdefaultpath = "log";
const static std::string logdefaultfilename = "test.log";

class FileLogStrategy : public LogStrategy {
public:
    FileLogStrategy(const std::string &dir = logdefaultpath, const std::string &filename = logdefaultfilename)
        :_dir_path_name(dir),_filename(filename) {
        { LockGuard lockguard(&_lock);
            if(std::filesystem::exists(_dir_path_name)) return;
            try {
                std::filesystem::create_directories(_dir_path_name);
            } catch(const std::filesystem::filesystem_error &e) {
                std::cerr << e.what()<<'
';
            }
        }
    }
    void SyncLog(const std::string &logmessage) override {
        { LockGuard lockguard(&_lock);
            std::string target = _dir_path_name; target += "/"; target += _filename;
            std::ofstream out(target.c_str(), std::ios::app);
            if(!out.is_open()) return;
            out << logmessage <<"
";
            out.close();
        }
    }
    ~FileLogStrategy() {}
private:
    std::string _dir_path_name;
    std::string _filename;
    Mutex _lock;
};

class Logger {
public:
    Logger() {}
    void EnableConsoleLogStrategy(){ _strategy = std::make_unique<ConsoleLogStrategy>(); }
    void EnableFileLogStrategy(){ _strategy = std::make_unique<FileLogStrategy>(); }
    
    class LogMessage {
    public:
        LogMessage(LogLevel level, std::string filename,int line, Logger &logger)
            :_curr_time(GetCurrentTime()),_level(level),_pid(getpid()),_filename(filename),_line(line),_logger(logger) {
            std::stringstream ss;
            ss <<"["<< _curr_time <<"] "<<"["<<Level_to_string(_level)<<"] "<<"["<< _pid <<"] "<<"["<< _filename <<"] "<<"["<< _line <<"] ";
            _loginfo = ss.str();
        }
        template<typenameT> LogMessage &operator<<(const T &info) {
            std::stringstream ss;
            ss << info;
            _loginfo += ss.str();
            return*this;
        }
        ~LogMessage() {
            if(_logger._strategy){ _logger._strategy->SyncLog(_loginfo); }
        }
    private:
        std::string _curr_time;
        LogLevel _level;
        pid_t _pid;
        std::string _filename;
        int _line;
        std::string _loginfo;
        Logger &_logger;
    };
    
    LogMessage operator()(LogLevel level, std::string filename,int line) {
        return LogMessage(level, filename, line,*this);
    }
    ~Logger() {}
private:
    std::unique_ptr<LogStrategy> _strategy;
};

Logger logger;
#define LOG(level) logger(level,__FILE__,__LINE__)
#define EnableConsoleLogStrategy() logger.EnableConsoleLogStrategy()
#define EnableFileLogStrategy() logger.EnableFileLogStrategy()

//main.cc
#include"Logger.hpp"
#include<unistd.h>
int main() {
    EnableConsoleLogStrategy();
    LOG(LogLevel::ERROR)<<"hello world"<<1234<<", 3.14 "<<'c';
    LOG(LogLevel::WARNING)<<"hello world"<<1234<<", 3.14 "<<'c';
    return 0;
}